blob: 02209d9e36e88ab1a062623a8bd2b3da35bf1137 [file] [log] [blame]
Eric Biederman8ca8d762003-04-22 19:02:15 +00001/*
Stefan Reinauer7e61e452008-01-18 10:35:56 +00002 * This file is part of the coreboot project.
Uwe Hermannb80dbf02007-04-22 19:08:13 +00003 *
4 * It was originally based on the Linux kernel (arch/i386/kernel/pci-pc.c).
5 *
6 * Modifications are:
7 * Copyright (C) 2003 Eric Biederman <ebiederm@xmission.com>
8 * Copyright (C) 2003-2004 Linux Networx
9 * (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx)
10 * Copyright (C) 2003 Ronald G. Minnich <rminnich@gmail.com>
11 * Copyright (C) 2004-2005 Li-Ta Lo <ollie@lanl.gov>
12 * Copyright (C) 2005-2006 Tyan
13 * (Written by Yinghai Lu <yhlu@tyan.com> for Tyan)
14 * Copyright (C) 2005-2006 Stefan Reinauer <stepan@openbios.org>
Myles Watson29cc9ed2009-07-02 18:56:24 +000015 * Copyright (C) 2009 Myles Watson <mylesgw@gmail.com>
Martin Rothbb5953d2016-04-11 20:53:39 -060016 * Copyright (c) 1999--2000 Martin Mares <mj@suse.cz>
17 *
18 * This program is free software; you can redistribute it and/or modify
19 * it under the terms of the GNU General Public License as published by
20 * the Free Software Foundation; version 2 of the License.
21 *
22 * This program is distributed in the hope that it will be useful,
23 * but WITHOUT ANY WARRANTY; without even the implied warranty of
24 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25 * GNU General Public License for more details.
Eric Biederman8ca8d762003-04-22 19:02:15 +000026 */
Uwe Hermanne4870472010-11-04 23:23:47 +000027
28/*
29 * Lots of mods by Ron Minnich <rminnich@lanl.gov>, with
30 * the final architecture guidance from Tom Merritt <tjm@codegen.com>.
31 *
Myles Watson032a9652009-05-11 22:24:53 +000032 * In particular, we changed from the one-pass original version to
33 * Tom's recommended multiple-pass version. I wasn't sure about doing
Eric Biederman8ca8d762003-04-22 19:02:15 +000034 * it with multiple passes, until I actually started doing it and saw
Uwe Hermanne4870472010-11-04 23:23:47 +000035 * the wisdom of Tom's recommendations...
Eric Biederman8ca8d762003-04-22 19:02:15 +000036 *
37 * Lots of cleanups by Eric Biederman to handle bridges, and to
Uwe Hermanne4870472010-11-04 23:23:47 +000038 * handle resource allocation for non-PCI devices.
Eric Biederman8ca8d762003-04-22 19:02:15 +000039 */
40
41#include <console/console.h>
Eric Biederman8ca8d762003-04-22 19:02:15 +000042#include <arch/io.h>
Eric Biederman5899fd82003-04-24 06:25:08 +000043#include <device/device.h>
Kyösti Mälkki318066f2014-02-12 14:18:50 +020044#include <device/pci_def.h>
Li-Ta Lo54f05f62004-05-14 17:20:29 +000045#include <device/pci_ids.h>
Eric Biedermane9a271e32003-09-02 03:36:25 +000046#include <stdlib.h>
47#include <string.h>
Eric Biederman03acab62004-10-14 21:25:53 +000048#include <smp/spinlock.h>
Martin Rothb3b114c2017-06-24 14:00:01 -060049#if IS_ENABLED(CONFIG_ARCH_X86)
Duncan Laurieb4aaaa72012-01-17 09:03:11 -080050#include <arch/ebda.h>
51#endif
Aaron Durbin05294292013-04-30 15:41:13 -050052#include <timer.h>
Eric Biederman8ca8d762003-04-22 19:02:15 +000053
Li-Ta Loe5266692004-03-23 21:28:05 +000054/** Linked list of ALL devices */
Eric Biederman5cd81732004-03-11 15:01:31 +000055struct device *all_devices = &dev_root;
Li-Ta Loe5266692004-03-23 21:28:05 +000056/** Pointer to the last device */
Myles Watson70679a02010-09-01 21:03:03 +000057extern struct device *last_dev;
Myles Watsonc25cc112010-05-21 14:33:48 +000058/** Linked list of free resources */
59struct resource *free_resources = NULL;
Eric Biederman8ca8d762003-04-22 19:02:15 +000060
Nico Huberacd7d952012-07-25 10:33:05 +020061/**
62 * Initialize all chips of statically known devices.
63 *
64 * Will be called before bus enumeration to initialize chips stated in the
65 * device tree.
66 */
67void dev_initialize_chips(void)
68{
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +020069 const struct device *dev;
Nico Huberacd7d952012-07-25 10:33:05 +020070
71 for (dev = all_devices; dev; dev = dev->next) {
72 /* Initialize chip if we haven't yet. */
73 if (dev->chip_ops && dev->chip_ops->init &&
74 !dev->chip_ops->initialized) {
Duncan Laurie8adf7a22013-06-10 10:34:20 -070075 post_log_path(dev);
Nico Huberacd7d952012-07-25 10:33:05 +020076 dev->chip_ops->init(dev->chip_info);
77 dev->chip_ops->initialized = 1;
78 }
79 }
Duncan Laurie8adf7a22013-06-10 10:34:20 -070080 post_log_clear();
Nico Huberacd7d952012-07-25 10:33:05 +020081}
82
Marc Jones2a58ecd2013-10-29 17:32:00 -060083/**
84 * Finalize all chips of statically known devices.
85 *
86 * This is the last call before calling the payload. This is a good place
87 * to lock registers or other final cleanup.
88 */
89void dev_finalize_chips(void)
90{
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +020091 const struct device *dev;
Marc Jones2a58ecd2013-10-29 17:32:00 -060092
93 for (dev = all_devices; dev; dev = dev->next) {
94 /* Initialize chip if we haven't yet. */
95 if (dev->chip_ops && dev->chip_ops->final &&
96 !dev->chip_ops->finalized) {
97 dev->chip_ops->final(dev->chip_info);
98 dev->chip_ops->finalized = 1;
99 }
100 }
101}
102
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000103DECLARE_SPIN_LOCK(dev_lock)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000104
Martin Rothb3b114c2017-06-24 14:00:01 -0600105#if IS_ENABLED(CONFIG_GFXUMA)
Kyösti Mälkkicc55b9b2012-07-11 07:55:21 +0300106/* IGD UMA memory */
107uint64_t uma_memory_base = 0;
108uint64_t uma_memory_size = 0;
Kyösti Mälkkib25374c2012-08-01 08:05:22 +0300109#endif
Kyösti Mälkkicc55b9b2012-07-11 07:55:21 +0300110
Li-Ta Loe5266692004-03-23 21:28:05 +0000111/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000112 * Allocate a new device structure.
Myles Watson032a9652009-05-11 22:24:53 +0000113 *
Martin Roth63373ed2013-07-08 16:24:19 -0600114 * Allocate a new device structure and attach it to the device tree as a
Li-Ta Lo9f0d0f92004-05-10 16:05:16 +0000115 * child of the parent bus.
Li-Ta Loe5266692004-03-23 21:28:05 +0000116 *
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000117 * @param parent Parent bus the newly created device should be attached to.
118 * @param path Path to the device to be created.
119 * @return Pointer to the newly created device structure.
Li-Ta Loe5266692004-03-23 21:28:05 +0000120 *
121 * @see device_path
Eric Biederman8ca8d762003-04-22 19:02:15 +0000122 */
Kyösti Mälkkia5650a42012-07-07 17:15:51 +0300123static device_t __alloc_dev(struct bus *parent, struct device_path *path)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000124{
Eric Biedermane9a271e32003-09-02 03:36:25 +0000125 device_t dev, child;
Li-Ta Loe5266692004-03-23 21:28:05 +0000126
Myles Watson29cc9ed2009-07-02 18:56:24 +0000127 /* Find the last child of our parent. */
Uwe Hermanne4870472010-11-04 23:23:47 +0000128 for (child = parent->children; child && child->sibling; /* */ )
Eric Biedermane9a271e32003-09-02 03:36:25 +0000129 child = child->sibling;
Li-Ta Lo3a812852004-12-03 22:39:34 +0000130
Eric Biedermane9a271e32003-09-02 03:36:25 +0000131 dev = malloc(sizeof(*dev));
Myles Watson29cc9ed2009-07-02 18:56:24 +0000132 if (dev == 0)
Uwe Hermanne4870472010-11-04 23:23:47 +0000133 die("alloc_dev(): out of memory.\n");
Myles Watson29cc9ed2009-07-02 18:56:24 +0000134
Eric Biedermane9a271e32003-09-02 03:36:25 +0000135 memset(dev, 0, sizeof(*dev));
136 memcpy(&dev->path, path, sizeof(*path));
137
Myles Watson29cc9ed2009-07-02 18:56:24 +0000138 /* By default devices are enabled. */
Eric Biederman03acab62004-10-14 21:25:53 +0000139 dev->enabled = 1;
Eric Biedermane9a271e32003-09-02 03:36:25 +0000140
Eric Biedermanb78c1972004-10-14 20:54:17 +0000141 /* Add the new device to the list of children of the bus. */
Eric Biedermane9a271e32003-09-02 03:36:25 +0000142 dev->bus = parent;
Uwe Hermanne4870472010-11-04 23:23:47 +0000143 if (child)
Eric Biedermane9a271e32003-09-02 03:36:25 +0000144 child->sibling = dev;
Uwe Hermanne4870472010-11-04 23:23:47 +0000145 else
Eric Biedermane9a271e32003-09-02 03:36:25 +0000146 parent->children = dev;
Li-Ta Loe5266692004-03-23 21:28:05 +0000147
Eric Biederman03acab62004-10-14 21:25:53 +0000148 /* Append a new device to the global device list.
149 * The list is used to find devices once everything is set up.
150 */
Myles Watson70679a02010-09-01 21:03:03 +0000151 last_dev->next = dev;
152 last_dev = dev;
Eric Biederman03acab62004-10-14 21:25:53 +0000153
Kyösti Mälkkia5650a42012-07-07 17:15:51 +0300154 return dev;
155}
156
157device_t alloc_dev(struct bus *parent, struct device_path *path)
158{
159 device_t dev;
160 spin_lock(&dev_lock);
161 dev = __alloc_dev(parent, path);
Eric Biederman03acab62004-10-14 21:25:53 +0000162 spin_unlock(&dev_lock);
Eric Biedermane9a271e32003-09-02 03:36:25 +0000163 return dev;
164}
Eric Biederman8ca8d762003-04-22 19:02:15 +0000165
Li-Ta Loe5266692004-03-23 21:28:05 +0000166/**
Kyösti Mälkkia5650a42012-07-07 17:15:51 +0300167 * See if a device structure already exists and if not allocate it.
168 *
169 * @param parent The bus to find the device on.
170 * @param path The relative path from the bus to the appropriate device.
171 * @return Pointer to a device structure for the device on bus at path.
172 */
173device_t alloc_find_dev(struct bus *parent, struct device_path *path)
174{
175 device_t child;
176 spin_lock(&dev_lock);
177 child = find_dev_path(parent, path);
178 if (!child)
179 child = __alloc_dev(parent, path);
180 spin_unlock(&dev_lock);
181 return child;
182}
183
184/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000185 * Round a number up to an alignment.
186 *
187 * @param val The starting value.
Martin Roth32bc6b62015-01-04 16:54:35 -0700188 * @param pow Alignment as a power of two.
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000189 * @return Rounded up number.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000190 */
Eric Biederman448bd632004-10-14 22:52:15 +0000191static resource_t round(resource_t val, unsigned long pow)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000192{
Eric Biederman448bd632004-10-14 22:52:15 +0000193 resource_t mask;
194 mask = (1ULL << pow) - 1ULL;
195 val += mask;
196 val &= ~mask;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000197 return val;
198}
199
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200200static const char * resource2str(struct resource *res)
201{
202 if (res->flags & IORESOURCE_IO)
203 return "io";
204 if (res->flags & IORESOURCE_PREFETCH)
205 return "prefmem";
206 if (res->flags & IORESOURCE_MEM)
207 return "mem";
208 return "undefined";
209}
210
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000211/**
212 * Read the resources on all devices of a given bus.
213 *
214 * @param bus Bus to read the resources on.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000215 */
Eric Biedermane9a271e32003-09-02 03:36:25 +0000216static void read_resources(struct bus *bus)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000217{
218 struct device *curdev;
219
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000220 printk(BIOS_SPEW, "%s %s bus %x link: %d\n", dev_path(bus->dev),
221 __func__, bus->secondary, bus->link_num);
Eric Biederman448bd632004-10-14 22:52:15 +0000222
Myles Watson29cc9ed2009-07-02 18:56:24 +0000223 /* Walk through all devices and find which resources they need. */
224 for (curdev = bus->children; curdev; curdev = curdev->sibling) {
Myles Watson894a3472010-06-09 22:41:35 +0000225 struct bus *link;
Uwe Hermanne4870472010-11-04 23:23:47 +0000226
227 if (!curdev->enabled)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000228 continue;
Uwe Hermanne4870472010-11-04 23:23:47 +0000229
Eric Biedermane9a271e32003-09-02 03:36:25 +0000230 if (!curdev->ops || !curdev->ops->read_resources) {
Martin Roth7bc74ab2015-11-18 20:23:02 -0700231 if (curdev->path.type != DEVICE_PATH_APIC)
232 printk(BIOS_ERR, "%s missing read_resources\n",
233 dev_path(curdev));
Eric Biedermane9a271e32003-09-02 03:36:25 +0000234 continue;
235 }
Duncan Laurie7ed39762013-07-09 10:46:52 -0700236 post_log_path(curdev);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000237 curdev->ops->read_resources(curdev);
Myles Watson29cc9ed2009-07-02 18:56:24 +0000238
239 /* Read in the resources behind the current device's links. */
Myles Watson894a3472010-06-09 22:41:35 +0000240 for (link = curdev->link_list; link; link = link->next)
241 read_resources(link);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000242 }
Duncan Laurie7ed39762013-07-09 10:46:52 -0700243 post_log_clear();
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000244 printk(BIOS_SPEW, "%s read_resources bus %d link: %d done\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000245 dev_path(bus->dev), bus->secondary, bus->link_num);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000246}
247
Eric Biedermane9a271e32003-09-02 03:36:25 +0000248struct pick_largest_state {
249 struct resource *last;
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200250 const struct device *result_dev;
Eric Biedermane9a271e32003-09-02 03:36:25 +0000251 struct resource *result;
252 int seen_last;
253};
254
Myles Watson29cc9ed2009-07-02 18:56:24 +0000255static void pick_largest_resource(void *gp, struct device *dev,
256 struct resource *resource)
Eric Biedermane9a271e32003-09-02 03:36:25 +0000257{
Eric Biedermanf8a2ddd2004-10-30 08:05:41 +0000258 struct pick_largest_state *state = gp;
Eric Biedermane9a271e32003-09-02 03:36:25 +0000259 struct resource *last;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000260
Eric Biedermane9a271e32003-09-02 03:36:25 +0000261 last = state->last;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000262
263 /* Be certain to pick the successor to last. */
Eric Biedermane9a271e32003-09-02 03:36:25 +0000264 if (resource == last) {
265 state->seen_last = 1;
266 return;
267 }
Myles Watson032a9652009-05-11 22:24:53 +0000268 if (resource->flags & IORESOURCE_FIXED)
Uwe Hermanne4870472010-11-04 23:23:47 +0000269 return; /* Skip it. */
Myles Watson032a9652009-05-11 22:24:53 +0000270 if (last && ((last->align < resource->align) ||
271 ((last->align == resource->align) &&
272 (last->size < resource->size)) ||
273 ((last->align == resource->align) &&
274 (last->size == resource->size) && (!state->seen_last)))) {
Eric Biedermane9a271e32003-09-02 03:36:25 +0000275 return;
276 }
Myles Watson032a9652009-05-11 22:24:53 +0000277 if (!state->result ||
278 (state->result->align < resource->align) ||
279 ((state->result->align == resource->align) &&
Myles Watson29cc9ed2009-07-02 18:56:24 +0000280 (state->result->size < resource->size))) {
Eric Biedermane9a271e32003-09-02 03:36:25 +0000281 state->result_dev = dev;
282 state->result = resource;
Myles Watson032a9652009-05-11 22:24:53 +0000283 }
Eric Biedermane9a271e32003-09-02 03:36:25 +0000284}
285
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200286static const struct device *largest_resource(struct bus *bus,
Myles Watson29cc9ed2009-07-02 18:56:24 +0000287 struct resource **result_res,
288 unsigned long type_mask,
289 unsigned long type)
Eric Biedermane9a271e32003-09-02 03:36:25 +0000290{
291 struct pick_largest_state state;
292
293 state.last = *result_res;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000294 state.result_dev = NULL;
295 state.result = NULL;
Eric Biedermane9a271e32003-09-02 03:36:25 +0000296 state.seen_last = 0;
297
Myles Watson032a9652009-05-11 22:24:53 +0000298 search_bus_resources(bus, type_mask, type, pick_largest_resource,
299 &state);
Eric Biedermane9a271e32003-09-02 03:36:25 +0000300
301 *result_res = state.result;
302 return state.result_dev;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000303}
304
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000305/**
Uwe Hermanne4870472010-11-04 23:23:47 +0000306 * This function is the guts of the resource allocator.
Myles Watson032a9652009-05-11 22:24:53 +0000307 *
Eric Biederman8ca8d762003-04-22 19:02:15 +0000308 * The problem.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000309 * - Allocate resource locations for every device.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000310 * - Don't overlap, and follow the rules of bridges.
311 * - Don't overlap with resources in fixed locations.
312 * - Be efficient so we don't have ugly strategies.
313 *
314 * The strategy.
315 * - Devices that have fixed addresses are the minority so don't
Myles Watson29cc9ed2009-07-02 18:56:24 +0000316 * worry about them too much. Instead only use part of the address
317 * space for devices with programmable addresses. This easily handles
Eric Biederman8ca8d762003-04-22 19:02:15 +0000318 * everything except bridges.
319 *
Myles Watson29cc9ed2009-07-02 18:56:24 +0000320 * - PCI devices are required to have their sizes and their alignments
321 * equal. In this case an optimal solution to the packing problem
322 * exists. Allocate all devices from highest alignment to least
323 * alignment or vice versa. Use this.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000324 *
Myles Watson29cc9ed2009-07-02 18:56:24 +0000325 * - So we can handle more than PCI run two allocation passes on bridges. The
326 * first to see how large the resources are behind the bridge, and what
327 * their alignment requirements are. The second to assign a safe address to
328 * the devices behind the bridge. This allows us to treat a bridge as just
329 * a device with a couple of resources, and not need to special case it in
330 * the allocator. Also this allows handling of other types of bridges.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000331 *
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000332 * @param bus The bus we are traversing.
333 * @param bridge The bridge resource which must contain the bus' resources.
334 * @param type_mask This value gets ANDed with the resource type.
335 * @param type This value must match the result of the AND.
336 * @return TODO
Eric Biederman8ca8d762003-04-22 19:02:15 +0000337 */
Myles Watson54913b92009-10-13 20:00:09 +0000338static void compute_resources(struct bus *bus, struct resource *bridge,
Uwe Hermanne4870472010-11-04 23:23:47 +0000339 unsigned long type_mask, unsigned long type)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000340{
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200341 const struct device *dev;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000342 struct resource *resource;
Eric Biederman03acab62004-10-14 21:25:53 +0000343 resource_t base;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000344 base = round(bridge->base, bridge->align);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000345
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200346 printk(BIOS_SPEW, "%s %s: base: %llx size: %llx align: %d gran: %d"
347 " limit: %llx\n", dev_path(bus->dev), resource2str(bridge),
348 base, bridge->size, bridge->align,
Uwe Hermanne4870472010-11-04 23:23:47 +0000349 bridge->gran, bridge->limit);
Ronald G. Minnich99dcf232003-09-30 02:16:47 +0000350
Uwe Hermanne4870472010-11-04 23:23:47 +0000351 /* For each child which is a bridge, compute the resource needs. */
Myles Watson29cc9ed2009-07-02 18:56:24 +0000352 for (dev = bus->children; dev; dev = dev->sibling) {
Myles Watson29cc9ed2009-07-02 18:56:24 +0000353 struct resource *child_bridge;
354
Myles Watson894a3472010-06-09 22:41:35 +0000355 if (!dev->link_list)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000356 continue;
357
358 /* Find the resources with matching type flags. */
Myles Watsonc25cc112010-05-21 14:33:48 +0000359 for (child_bridge = dev->resource_list; child_bridge;
360 child_bridge = child_bridge->next) {
Myles Watson894a3472010-06-09 22:41:35 +0000361 struct bus* link;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000362
Uwe Hermanne4870472010-11-04 23:23:47 +0000363 if (!(child_bridge->flags & IORESOURCE_BRIDGE)
364 || (child_bridge->flags & type_mask) != type)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000365 continue;
366
Uwe Hermanne4870472010-11-04 23:23:47 +0000367 /*
368 * Split prefetchable memory if combined. Many domains
Myles Watson29cc9ed2009-07-02 18:56:24 +0000369 * use the same address space for prefetchable memory
Uwe Hermanne4870472010-11-04 23:23:47 +0000370 * and non-prefetchable memory. Bridges below them need
371 * it separated. Add the PREFETCH flag to the type_mask
372 * and type.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000373 */
Myles Watson894a3472010-06-09 22:41:35 +0000374 link = dev->link_list;
375 while (link && link->link_num !=
376 IOINDEX_LINK(child_bridge->index))
377 link = link->next;
Uwe Hermanne4870472010-11-04 23:23:47 +0000378
379 if (link == NULL) {
Myles Watson894a3472010-06-09 22:41:35 +0000380 printk(BIOS_ERR, "link %ld not found on %s\n",
381 IOINDEX_LINK(child_bridge->index),
382 dev_path(dev));
Uwe Hermanne4870472010-11-04 23:23:47 +0000383 }
384
Myles Watson894a3472010-06-09 22:41:35 +0000385 compute_resources(link, child_bridge,
Myles Watson29cc9ed2009-07-02 18:56:24 +0000386 type_mask | IORESOURCE_PREFETCH,
387 type | (child_bridge->flags &
388 IORESOURCE_PREFETCH));
389 }
Eric Biederman8ca8d762003-04-22 19:02:15 +0000390 }
391
Myles Watson29cc9ed2009-07-02 18:56:24 +0000392 /* Remember we haven't found anything yet. */
393 resource = NULL;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000394
Uwe Hermanne4870472010-11-04 23:23:47 +0000395 /*
396 * Walk through all the resources on the current bus and compute the
397 * amount of address space taken by them. Take granularity and
Myles Watson29cc9ed2009-07-02 18:56:24 +0000398 * alignment into account.
Eric Biedermanb78c1972004-10-14 20:54:17 +0000399 */
Myles Watson29cc9ed2009-07-02 18:56:24 +0000400 while ((dev = largest_resource(bus, &resource, type_mask, type))) {
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000401
Myles Watson29cc9ed2009-07-02 18:56:24 +0000402 /* Size 0 resources can be skipped. */
Uwe Hermanne4870472010-11-04 23:23:47 +0000403 if (!resource->size)
Eric Biedermane9a271e32003-09-02 03:36:25 +0000404 continue;
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000405
Myles Watson29cc9ed2009-07-02 18:56:24 +0000406 /* Propagate the resource alignment to the bridge resource. */
Uwe Hermanne4870472010-11-04 23:23:47 +0000407 if (resource->align > bridge->align)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000408 bridge->align = resource->align;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000409
410 /* Propagate the resource limit to the bridge register. */
Uwe Hermanne4870472010-11-04 23:23:47 +0000411 if (bridge->limit > resource->limit)
Eric Biedermandbec2d42004-10-21 10:44:08 +0000412 bridge->limit = resource->limit;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000413
414 /* Warn if it looks like APICs aren't declared. */
415 if ((resource->limit == 0xffffffff) &&
416 (resource->flags & IORESOURCE_ASSIGNED)) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000417 printk(BIOS_ERR,
418 "Resource limit looks wrong! (no APIC?)\n");
Patrick Georgi51615092012-03-11 19:31:03 +0100419 printk(BIOS_ERR, "%s %02lx limit %08llx\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000420 dev_path(dev), resource->index, resource->limit);
Eric Biedermandbec2d42004-10-21 10:44:08 +0000421 }
Stefan Reinauer51754a32008-08-01 12:28:38 +0000422
Eric Biederman8ca8d762003-04-22 19:02:15 +0000423 if (resource->flags & IORESOURCE_IO) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000424 /*
425 * Don't allow potential aliases over the legacy PCI
Myles Watson29cc9ed2009-07-02 18:56:24 +0000426 * expansion card addresses. The legacy PCI decodes
427 * only 10 bits, uses 0x100 - 0x3ff. Therefore, only
428 * 0x00 - 0xff can be used out of each 0x400 block of
429 * I/O space.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000430 */
Eric Biedermanbbb6d102003-08-04 19:54:48 +0000431 if ((base & 0x300) != 0) {
Eric Biederman8ca8d762003-04-22 19:02:15 +0000432 base = (base & ~0x3ff) + 0x400;
433 }
Uwe Hermanne4870472010-11-04 23:23:47 +0000434 /*
435 * Don't allow allocations in the VGA I/O range.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000436 * PCI has special cases for that.
437 */
438 else if ((base >= 0x3b0) && (base <= 0x3df)) {
439 base = 0x3e0;
440 }
441 }
Myles Watson29cc9ed2009-07-02 18:56:24 +0000442 /* Base must be aligned. */
443 base = round(base, resource->align);
444 resource->base = base;
445 base += resource->size;
Myles Watson032a9652009-05-11 22:24:53 +0000446
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000447 printk(BIOS_SPEW, "%s %02lx * [0x%llx - 0x%llx] %s\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000448 dev_path(dev), resource->index, resource->base,
449 resource->base + resource->size - 1,
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200450 resource2str(resource));
Eric Biederman8ca8d762003-04-22 19:02:15 +0000451 }
Uwe Hermanne4870472010-11-04 23:23:47 +0000452
453 /*
454 * A PCI bridge resource does not need to be a power of two size, but
455 * it does have a minimum granularity. Round the size up to that
456 * minimum granularity so we know not to place something else at an
Martin Roth63373ed2013-07-08 16:24:19 -0600457 * address positively decoded by the bridge.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000458 */
Myles Watson29cc9ed2009-07-02 18:56:24 +0000459 bridge->size = round(base, bridge->gran) -
460 round(bridge->base, bridge->align);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000461
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200462 printk(BIOS_SPEW, "%s %s: base: %llx size: %llx align: %d gran: %d"
463 " limit: %llx done\n", dev_path(bus->dev),
464 resource2str(bridge),
Uwe Hermanne4870472010-11-04 23:23:47 +0000465 base, bridge->size, bridge->align, bridge->gran, bridge->limit);
Myles Watson29cc9ed2009-07-02 18:56:24 +0000466}
467
468/**
469 * This function is the second part of the resource allocator.
470 *
Uwe Hermanne4870472010-11-04 23:23:47 +0000471 * See the compute_resources function for a more detailed explanation.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000472 *
Uwe Hermanne4870472010-11-04 23:23:47 +0000473 * This function assigns the resources a value.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000474 *
475 * @param bus The bus we are traversing.
476 * @param bridge The bridge resource which must contain the bus' resources.
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000477 * @param type_mask This value gets ANDed with the resource type.
478 * @param type This value must match the result of the AND.
Uwe Hermanne4870472010-11-04 23:23:47 +0000479 *
480 * @see compute_resources
Myles Watson29cc9ed2009-07-02 18:56:24 +0000481 */
Myles Watson54913b92009-10-13 20:00:09 +0000482static void allocate_resources(struct bus *bus, struct resource *bridge,
Uwe Hermanne4870472010-11-04 23:23:47 +0000483 unsigned long type_mask, unsigned long type)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000484{
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200485 const struct device *dev;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000486 struct resource *resource;
487 resource_t base;
488 base = bridge->base;
489
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200490 printk(BIOS_SPEW, "%s %s: base:%llx size:%llx align:%d gran:%d "
491 "limit:%llx\n", dev_path(bus->dev),
492 resource2str(bridge),
Myles Watson29cc9ed2009-07-02 18:56:24 +0000493 base, bridge->size, bridge->align, bridge->gran, bridge->limit);
494
495 /* Remember we haven't found anything yet. */
496 resource = NULL;
497
Uwe Hermanne4870472010-11-04 23:23:47 +0000498 /*
499 * Walk through all the resources on the current bus and allocate them
Myles Watson29cc9ed2009-07-02 18:56:24 +0000500 * address space.
501 */
502 while ((dev = largest_resource(bus, &resource, type_mask, type))) {
503
504 /* Propagate the bridge limit to the resource register. */
Uwe Hermanne4870472010-11-04 23:23:47 +0000505 if (resource->limit > bridge->limit)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000506 resource->limit = bridge->limit;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000507
508 /* Size 0 resources can be skipped. */
509 if (!resource->size) {
510 /* Set the base to limit so it doesn't confuse tolm. */
511 resource->base = resource->limit;
512 resource->flags |= IORESOURCE_ASSIGNED;
513 continue;
514 }
515
516 if (resource->flags & IORESOURCE_IO) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000517 /*
518 * Don't allow potential aliases over the legacy PCI
Myles Watson29cc9ed2009-07-02 18:56:24 +0000519 * expansion card addresses. The legacy PCI decodes
520 * only 10 bits, uses 0x100 - 0x3ff. Therefore, only
521 * 0x00 - 0xff can be used out of each 0x400 block of
522 * I/O space.
523 */
524 if ((base & 0x300) != 0) {
525 base = (base & ~0x3ff) + 0x400;
526 }
Uwe Hermanne4870472010-11-04 23:23:47 +0000527 /*
528 * Don't allow allocations in the VGA I/O range.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000529 * PCI has special cases for that.
530 */
531 else if ((base >= 0x3b0) && (base <= 0x3df)) {
532 base = 0x3e0;
533 }
534 }
535
536 if ((round(base, resource->align) + resource->size - 1) <=
537 resource->limit) {
538 /* Base must be aligned. */
539 base = round(base, resource->align);
540 resource->base = base;
Kyösti Mälkki134b6162015-03-23 19:58:23 +0200541 resource->limit = resource->base + resource->size - 1;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000542 resource->flags |= IORESOURCE_ASSIGNED;
543 resource->flags &= ~IORESOURCE_STORED;
544 base += resource->size;
545 } else {
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000546 printk(BIOS_ERR, "!! Resource didn't fit !!\n");
Uwe Hermanne4870472010-11-04 23:23:47 +0000547 printk(BIOS_ERR, " aligned base %llx size %llx "
548 "limit %llx\n", round(base, resource->align),
549 resource->size, resource->limit);
550 printk(BIOS_ERR, " %llx needs to be <= %llx "
551 "(limit)\n", (round(base, resource->align) +
Myles Watson29cc9ed2009-07-02 18:56:24 +0000552 resource->size) - 1, resource->limit);
Uwe Hermanne4870472010-11-04 23:23:47 +0000553 printk(BIOS_ERR, " %s%s %02lx * [0x%llx - 0x%llx]"
554 " %s\n", (resource->flags & IORESOURCE_ASSIGNED)
555 ? "Assigned: " : "", dev_path(dev),
556 resource->index, resource->base,
Myles Watson29cc9ed2009-07-02 18:56:24 +0000557 resource->base + resource->size - 1,
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200558 resource2str(resource));
Myles Watson29cc9ed2009-07-02 18:56:24 +0000559 }
560
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200561 printk(BIOS_SPEW, "%s %02lx * [0x%llx - 0x%llx] %s\n",
562 dev_path(dev), resource->index, resource->base,
Myles Watson29cc9ed2009-07-02 18:56:24 +0000563 resource->size ? resource->base + resource->size - 1 :
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200564 resource->base, resource2str(resource));
Myles Watson29cc9ed2009-07-02 18:56:24 +0000565 }
Uwe Hermanne4870472010-11-04 23:23:47 +0000566
567 /*
568 * A PCI bridge resource does not need to be a power of two size, but
Myles Watson29cc9ed2009-07-02 18:56:24 +0000569 * it does have a minimum granularity. Round the size up to that
570 * minimum granularity so we know not to place something else at an
571 * address positively decoded by the bridge.
572 */
573
574 bridge->flags |= IORESOURCE_ASSIGNED;
575
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200576 printk(BIOS_SPEW, "%s %s: next_base: %llx size: %llx align: %d "
577 "gran: %d done\n", dev_path(bus->dev),
578 resource2str(bridge), base, bridge->size, bridge->align,
Uwe Hermanne4870472010-11-04 23:23:47 +0000579 bridge->gran);
Myles Watson29cc9ed2009-07-02 18:56:24 +0000580
581 /* For each child which is a bridge, allocate_resources. */
582 for (dev = bus->children; dev; dev = dev->sibling) {
Myles Watson29cc9ed2009-07-02 18:56:24 +0000583 struct resource *child_bridge;
584
Myles Watson894a3472010-06-09 22:41:35 +0000585 if (!dev->link_list)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000586 continue;
587
588 /* Find the resources with matching type flags. */
Myles Watsonc25cc112010-05-21 14:33:48 +0000589 for (child_bridge = dev->resource_list; child_bridge;
590 child_bridge = child_bridge->next) {
Myles Watson894a3472010-06-09 22:41:35 +0000591 struct bus* link;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000592
593 if (!(child_bridge->flags & IORESOURCE_BRIDGE) ||
594 (child_bridge->flags & type_mask) != type)
595 continue;
596
Uwe Hermanne4870472010-11-04 23:23:47 +0000597 /*
598 * Split prefetchable memory if combined. Many domains
Myles Watson29cc9ed2009-07-02 18:56:24 +0000599 * use the same address space for prefetchable memory
Uwe Hermanne4870472010-11-04 23:23:47 +0000600 * and non-prefetchable memory. Bridges below them need
601 * it separated. Add the PREFETCH flag to the type_mask
602 * and type.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000603 */
Myles Watson894a3472010-06-09 22:41:35 +0000604 link = dev->link_list;
605 while (link && link->link_num !=
606 IOINDEX_LINK(child_bridge->index))
607 link = link->next;
608 if (link == NULL)
609 printk(BIOS_ERR, "link %ld not found on %s\n",
610 IOINDEX_LINK(child_bridge->index),
611 dev_path(dev));
Uwe Hermanne4870472010-11-04 23:23:47 +0000612
Myles Watson894a3472010-06-09 22:41:35 +0000613 allocate_resources(link, child_bridge,
Myles Watson29cc9ed2009-07-02 18:56:24 +0000614 type_mask | IORESOURCE_PREFETCH,
615 type | (child_bridge->flags &
616 IORESOURCE_PREFETCH));
617 }
618 }
619}
620
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200621static int resource_is(struct resource *res, u32 type)
622{
623 return (res->flags & IORESOURCE_TYPE_MASK) == type;
624}
Myles Watson29cc9ed2009-07-02 18:56:24 +0000625
626struct constraints {
Kyösti Mälkkifcbebb62015-03-17 06:42:54 +0200627 struct resource io, mem;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000628};
629
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200630static struct resource * resource_limit(struct constraints *limits, struct resource *res)
631{
632 struct resource *lim = NULL;
633
634 /* MEM, or I/O - skip any others. */
635 if (resource_is(res, IORESOURCE_MEM))
636 lim = &limits->mem;
637 else if (resource_is(res, IORESOURCE_IO))
638 lim = &limits->io;
639
640 return lim;
641}
642
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200643static void constrain_resources(const struct device *dev, struct constraints* limits)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000644{
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200645 const struct device *child;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000646 struct resource *res;
647 struct resource *lim;
Myles Watson894a3472010-06-09 22:41:35 +0000648 struct bus *link;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000649
Myles Watson29cc9ed2009-07-02 18:56:24 +0000650 /* Constrain limits based on the fixed resources of this device. */
Myles Watsonc25cc112010-05-21 14:33:48 +0000651 for (res = dev->resource_list; res; res = res->next) {
Patrick Georgi18c585b2009-08-28 12:48:02 +0000652 if (!(res->flags & IORESOURCE_FIXED))
653 continue;
Myles Watsonce9d8642009-08-19 19:12:39 +0000654 if (!res->size) {
655 /* It makes no sense to have 0-sized, fixed resources.*/
Uwe Hermanne4870472010-11-04 23:23:47 +0000656 printk(BIOS_ERR, "skipping %s@%lx fixed resource, "
657 "size=0!\n", dev_path(dev), res->index);
Patrick Georgi6bd93f42009-08-19 17:29:41 +0000658 continue;
Myles Watsonce9d8642009-08-19 19:12:39 +0000659 }
Myles Watson29cc9ed2009-07-02 18:56:24 +0000660
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200661 lim = resource_limit(limits, res);
662 if (!lim)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000663 continue;
664
Uwe Hermanne4870472010-11-04 23:23:47 +0000665 /*
666 * Is it a fixed resource outside the current known region?
667 * If so, we don't have to consider it - it will be handled
668 * correctly and doesn't affect current region's limits.
669 */
670 if (((res->base + res->size -1) < lim->base)
671 || (res->base > lim->limit))
Myles Watson29cc9ed2009-07-02 18:56:24 +0000672 continue;
673
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200674 printk(BIOS_SPEW, "%s: %s %02lx base %08llx limit %08llx %s (fixed)\n",
675 __func__, dev_path(dev), res->index, res->base,
676 res->base + res->size - 1, resource2str(res));
677
Uwe Hermanne4870472010-11-04 23:23:47 +0000678 /*
679 * Choose to be above or below fixed resources. This check is
680 * signed so that "negative" amounts of space are handled
681 * correctly.
Myles Watson29cc9ed2009-07-02 18:56:24 +0000682 */
Uwe Hermanne4870472010-11-04 23:23:47 +0000683 if ((signed long long)(lim->limit - (res->base + res->size -1))
684 > (signed long long)(res->base - lim->base))
Myles Watson29cc9ed2009-07-02 18:56:24 +0000685 lim->base = res->base + res->size;
686 else
687 lim->limit = res->base -1;
688 }
689
690 /* Descend into every enabled child and look for fixed resources. */
Uwe Hermanne4870472010-11-04 23:23:47 +0000691 for (link = dev->link_list; link; link = link->next) {
692 for (child = link->children; child; child = child->sibling) {
Myles Watson29cc9ed2009-07-02 18:56:24 +0000693 if (child->enabled)
694 constrain_resources(child, limits);
Uwe Hermanne4870472010-11-04 23:23:47 +0000695 }
696 }
Myles Watson29cc9ed2009-07-02 18:56:24 +0000697}
698
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +0200699static void avoid_fixed_resources(const struct device *dev)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000700{
701 struct constraints limits;
702 struct resource *res;
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200703 struct resource *lim;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000704
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000705 printk(BIOS_SPEW, "%s: %s\n", __func__, dev_path(dev));
Myles Watson29cc9ed2009-07-02 18:56:24 +0000706
Uwe Hermanne4870472010-11-04 23:23:47 +0000707 /* Initialize constraints to maximum size. */
Myles Watson29cc9ed2009-07-02 18:56:24 +0000708 limits.io.base = 0;
709 limits.io.limit = 0xffffffffffffffffULL;
710 limits.mem.base = 0;
711 limits.mem.limit = 0xffffffffffffffffULL;
712
713 /* Constrain the limits to dev's initial resources. */
Myles Watsonc25cc112010-05-21 14:33:48 +0000714 for (res = dev->resource_list; res; res = res->next) {
Myles Watson29cc9ed2009-07-02 18:56:24 +0000715 if ((res->flags & IORESOURCE_FIXED))
716 continue;
Patrick Georgi51615092012-03-11 19:31:03 +0100717 printk(BIOS_SPEW, "%s:@%s %02lx limit %08llx\n", __func__,
Uwe Hermanne4870472010-11-04 23:23:47 +0000718 dev_path(dev), res->index, res->limit);
Kyösti Mälkkifcbebb62015-03-17 06:42:54 +0200719
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200720 lim = resource_limit(&limits, res);
721 if (!lim)
722 continue;
723
724 if (res->base > lim->base)
725 lim->base = res->base;
Elyes HAOUAS1943f372018-05-04 16:30:39 +0200726 if (res->limit < lim->limit)
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200727 lim->limit = res->limit;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000728 }
729
730 /* Look through the tree for fixed resources and update the limits. */
731 constrain_resources(dev, &limits);
732
733 /* Update dev's resources with new limits. */
Myles Watsonc25cc112010-05-21 14:33:48 +0000734 for (res = dev->resource_list; res; res = res->next) {
Myles Watson29cc9ed2009-07-02 18:56:24 +0000735 if ((res->flags & IORESOURCE_FIXED))
736 continue;
737
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +0200738 lim = resource_limit(&limits, res);
739 if (!lim)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000740 continue;
741
Myles Watson29cc9ed2009-07-02 18:56:24 +0000742 /* Is the resource outside the limits? */
743 if (lim->base > res->base)
744 res->base = lim->base;
745 if (res->limit > lim->limit)
746 res->limit = lim->limit;
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200747
Kyösti Mälkki634899c2015-03-23 14:22:22 +0200748 /* MEM resources need to start at the highest address manageable. */
749 if (res->flags & IORESOURCE_MEM)
750 res->base = resource_max(res);
751
Kyösti Mälkkie6a9290f2015-03-23 19:37:38 +0200752 printk(BIOS_SPEW, "%s:@%s %02lx base %08llx limit %08llx\n",
753 __func__, dev_path(dev), res->index, res->base, res->limit);
Myles Watson29cc9ed2009-07-02 18:56:24 +0000754 }
Eric Biederman8ca8d762003-04-22 19:02:15 +0000755}
arch import user (historical)dc811182005-07-06 17:16:09 +0000756
Yinghai Lu1f1085b2005-01-17 21:37:12 +0000757device_t vga_pri = 0;
Myles Watsonc7233e02009-07-02 19:02:33 +0000758static void set_vga_bridge_bits(void)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000759{
Uwe Hermann312673c2009-10-27 21:49:33 +0000760 /*
Martin Roth63373ed2013-07-08 16:24:19 -0600761 * FIXME: Modify set_vga_bridge() so it is less PCI-centric!
Uwe Hermann312673c2009-10-27 21:49:33 +0000762 * This function knows too much about PCI stuff, it should be just
763 * an iterator/visitor.
764 */
Li-Ta Loe5266692004-03-23 21:28:05 +0000765
Myles Watson29cc9ed2009-07-02 18:56:24 +0000766 /* FIXME: Handle the VGA palette snooping. */
Patrick Georgi557ecf22012-07-20 12:16:17 +0200767 struct device *dev, *vga, *vga_onboard;
Eric Biedermanb78c1972004-10-14 20:54:17 +0000768 struct bus *bus;
Uwe Hermanne4870472010-11-04 23:23:47 +0000769
Eric Biedermanb78c1972004-10-14 20:54:17 +0000770 bus = 0;
771 vga = 0;
Yinghai Lu1f1085b2005-01-17 21:37:12 +0000772 vga_onboard = 0;
Uwe Hermanne4870472010-11-04 23:23:47 +0000773
Patrick Georgi557ecf22012-07-20 12:16:17 +0200774 dev = NULL;
775 while ((dev = dev_find_class(PCI_CLASS_DISPLAY_VGA << 8, dev))) {
Myles Watson29cc9ed2009-07-02 18:56:24 +0000776 if (!dev->enabled)
777 continue;
Uwe Hermanne4870472010-11-04 23:23:47 +0000778
Patrick Georgi557ecf22012-07-20 12:16:17 +0200779 printk(BIOS_DEBUG, "found VGA at %s\n", dev_path(dev));
Stefan Reinauer7ce8c542005-12-02 21:52:30 +0000780
Patrick Georgi557ecf22012-07-20 12:16:17 +0200781 if (dev->on_mainboard) {
782 vga_onboard = dev;
Kostr1f0d3792012-10-06 13:27:58 +0400783 } else {
Patrick Georgi557ecf22012-07-20 12:16:17 +0200784 vga = dev;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000785 }
Myles Watson032a9652009-05-11 22:24:53 +0000786
Patrick Georgi557ecf22012-07-20 12:16:17 +0200787 /* It isn't safe to enable all VGA cards. */
788 dev->command &= ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
Patrick Georgi594473d2012-07-25 08:55:53 +0200789 }
Stefan Reinauer7ce8c542005-12-02 21:52:30 +0000790
Uwe Hermanne4870472010-11-04 23:23:47 +0000791 if (!vga)
Myles Watson29cc9ed2009-07-02 18:56:24 +0000792 vga = vga_onboard;
Patrick Georgi557ecf22012-07-20 12:16:17 +0200793
794 if (CONFIG_ONBOARD_VGA_IS_PRIMARY && vga_onboard)
795 vga = vga_onboard;
Myles Watson032a9652009-05-11 22:24:53 +0000796
Patrick Georgi5869fa22012-07-20 12:29:33 +0200797 /* If we prefer plugin VGA over chipset VGA, the chipset might
798 want to know. */
799 if (!CONFIG_ONBOARD_VGA_IS_PRIMARY && (vga != vga_onboard) &&
800 vga_onboard && vga_onboard->ops && vga_onboard->ops->disable) {
801 printk(BIOS_DEBUG, "Use plugin graphics over integrated.\n");
802 vga_onboard->ops->disable(vga_onboard);
803 }
804
arch import user (historical)dc811182005-07-06 17:16:09 +0000805 if (vga) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000806 /* VGA is first add-on card or the only onboard VGA. */
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000807 printk(BIOS_DEBUG, "Setting up VGA for %s\n", dev_path(vga));
Myles Watson29cc9ed2009-07-02 18:56:24 +0000808 /* All legacy VGA cards have MEM & I/O space registers. */
Yinghai Lu1f1085b2005-01-17 21:37:12 +0000809 vga->command |= (PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
810 vga_pri = vga;
Eric Biederman8ca8d762003-04-22 19:02:15 +0000811 bus = vga->bus;
812 }
Uwe Hermanne4870472010-11-04 23:23:47 +0000813
Myles Watson29cc9ed2009-07-02 18:56:24 +0000814 /* Now walk up the bridges setting the VGA enable. */
815 while (bus) {
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000816 printk(BIOS_DEBUG, "Setting PCI_BRIDGE_CTL_VGA for bridge %s\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000817 dev_path(bus->dev));
Li-Ta Lodb7f47c2004-01-08 21:15:49 +0000818 bus->bridge_ctrl |= PCI_BRIDGE_CTL_VGA;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000819 bus = (bus == bus->dev->bus) ? 0 : bus->dev->bus;
Myles Watson032a9652009-05-11 22:24:53 +0000820 }
Eric Biederman8ca8d762003-04-22 19:02:15 +0000821}
Stefan Reinauer7ce8c542005-12-02 21:52:30 +0000822
Li-Ta Lo04930692004-11-25 17:37:19 +0000823/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000824 * Assign the computed resources to the devices on the bus.
Li-Ta Lo04930692004-11-25 17:37:19 +0000825 *
Uwe Hermanne4870472010-11-04 23:23:47 +0000826 * Use the device specific set_resources() method to store the computed
Li-Ta Lo04930692004-11-25 17:37:19 +0000827 * resources to hardware. For bridge devices, the set_resources() method
828 * has to recurse into every down stream buses.
829 *
830 * Mutual recursion:
831 * assign_resources() -> device_operation::set_resources()
832 * device_operation::set_resources() -> assign_resources()
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000833 *
834 * @param bus Pointer to the structure for this bus.
Li-Ta Lo04930692004-11-25 17:37:19 +0000835 */
Eric Biedermane9a271e32003-09-02 03:36:25 +0000836void assign_resources(struct bus *bus)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000837{
838 struct device *curdev;
839
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000840 printk(BIOS_SPEW, "%s assign_resources, bus %d link: %d\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000841 dev_path(bus->dev), bus->secondary, bus->link_num);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000842
Myles Watson29cc9ed2009-07-02 18:56:24 +0000843 for (curdev = bus->children; curdev; curdev = curdev->sibling) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000844 if (!curdev->enabled || !curdev->resource_list)
Eric Biederman03acab62004-10-14 21:25:53 +0000845 continue;
Uwe Hermanne4870472010-11-04 23:23:47 +0000846
Eric Biedermane9a271e32003-09-02 03:36:25 +0000847 if (!curdev->ops || !curdev->ops->set_resources) {
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000848 printk(BIOS_ERR, "%s missing set_resources\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000849 dev_path(curdev));
Eric Biedermane9a271e32003-09-02 03:36:25 +0000850 continue;
851 }
Duncan Laurie8adf7a22013-06-10 10:34:20 -0700852 post_log_path(curdev);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000853 curdev->ops->set_resources(curdev);
854 }
Duncan Laurie8adf7a22013-06-10 10:34:20 -0700855 post_log_clear();
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000856 printk(BIOS_SPEW, "%s assign_resources, bus %d link: %d\n",
Uwe Hermanne4870472010-11-04 23:23:47 +0000857 dev_path(bus->dev), bus->secondary, bus->link_num);
Eric Biederman8ca8d762003-04-22 19:02:15 +0000858}
859
Li-Ta Lo5782d272004-04-26 17:51:20 +0000860/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000861 * Enable the resources for devices on a link.
Li-Ta Lo5782d272004-04-26 17:51:20 +0000862 *
863 * Enable resources of the device by calling the device specific
864 * enable_resources() method.
865 *
866 * The parent's resources should be enabled first to avoid having enabling
867 * order problem. This is done by calling the parent's enable_resources()
Martin Roth63373ed2013-07-08 16:24:19 -0600868 * method before its children's enable_resources() methods.
Li-Ta Lo9f0d0f92004-05-10 16:05:16 +0000869 *
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000870 * @param link The link whose devices' resources are to be enabled.
Li-Ta Lo5782d272004-04-26 17:51:20 +0000871 */
Myles Watson7eac4452010-06-17 16:16:56 +0000872static void enable_resources(struct bus *link)
Eric Biederman8ca8d762003-04-22 19:02:15 +0000873{
Myles Watson7eac4452010-06-17 16:16:56 +0000874 struct device *dev;
875 struct bus *c_link;
876
877 for (dev = link->children; dev; dev = dev->sibling) {
Duncan Laurie8adf7a22013-06-10 10:34:20 -0700878 if (dev->enabled && dev->ops && dev->ops->enable_resources) {
879 post_log_path(dev);
Myles Watson7eac4452010-06-17 16:16:56 +0000880 dev->ops->enable_resources(dev);
Duncan Laurie8adf7a22013-06-10 10:34:20 -0700881 }
Eric Biederman8ca8d762003-04-22 19:02:15 +0000882 }
Myles Watson7eac4452010-06-17 16:16:56 +0000883
884 for (dev = link->children; dev; dev = dev->sibling) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000885 for (c_link = dev->link_list; c_link; c_link = c_link->next)
Myles Watson7eac4452010-06-17 16:16:56 +0000886 enable_resources(c_link);
Eric Biederman83b991a2003-10-11 06:20:25 +0000887 }
Duncan Laurie8adf7a22013-06-10 10:34:20 -0700888 post_log_clear();
Eric Biederman8ca8d762003-04-22 19:02:15 +0000889}
890
Myles Watson032a9652009-05-11 22:24:53 +0000891/**
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000892 * Reset all of the devices on a bus and clear the bus's reset_needed flag.
893 *
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000894 * @param bus Pointer to the bus structure.
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000895 * @return 1 if the bus was successfully reset, 0 otherwise.
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000896 */
897int reset_bus(struct bus *bus)
898{
Myles Watson29cc9ed2009-07-02 18:56:24 +0000899 if (bus && bus->dev && bus->dev->ops && bus->dev->ops->reset_bus) {
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000900 bus->dev->ops->reset_bus(bus);
901 bus->reset_needed = 0;
902 return 1;
903 }
904 return 0;
905}
906
Myles Watson032a9652009-05-11 22:24:53 +0000907/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000908 * Scan for devices on a bus.
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000909 *
Myles Watson29cc9ed2009-07-02 18:56:24 +0000910 * If there are bridges on the bus, recursively scan the buses behind the
911 * bridges. If the setting up and tuning of the bus causes a reset to be
912 * required, reset the bus and scan it again.
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000913 *
Myles Watson29cc9ed2009-07-02 18:56:24 +0000914 * @param busdev Pointer to the bus device.
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000915 */
Kyösti Mälkki580e7222015-03-19 21:04:23 +0200916static void scan_bus(struct device *busdev)
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000917{
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000918 int do_scan_bus;
Paul Menzel662380f2015-10-20 10:21:08 +0200919 struct stopwatch sw;
920
921 stopwatch_init(&sw);
Uwe Hermanne4870472010-11-04 23:23:47 +0000922
Kyösti Mälkki2d2367c2015-02-20 21:28:31 +0200923 if (!busdev->enabled)
Kyösti Mälkki580e7222015-03-19 21:04:23 +0200924 return;
Kyösti Mälkki2d2367c2015-02-20 21:28:31 +0200925
926 printk(BIOS_SPEW, "%s scanning...\n", dev_path(busdev));
Myles Watson29cc9ed2009-07-02 18:56:24 +0000927
Duncan Laurie8adf7a22013-06-10 10:34:20 -0700928 post_log_path(busdev);
929
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000930 do_scan_bus = 1;
Myles Watson29cc9ed2009-07-02 18:56:24 +0000931 while (do_scan_bus) {
Myles Watson894a3472010-06-09 22:41:35 +0000932 struct bus *link;
Kyösti Mälkki580e7222015-03-19 21:04:23 +0200933 busdev->ops->scan_bus(busdev);
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000934 do_scan_bus = 0;
Myles Watson894a3472010-06-09 22:41:35 +0000935 for (link = busdev->link_list; link; link = link->next) {
936 if (link->reset_needed) {
Uwe Hermanne4870472010-11-04 23:23:47 +0000937 if (reset_bus(link))
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000938 do_scan_bus = 1;
Uwe Hermanne4870472010-11-04 23:23:47 +0000939 else
Myles Watson29cc9ed2009-07-02 18:56:24 +0000940 busdev->bus->reset_needed = 1;
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000941 }
942 }
943 }
Paul Menzel662380f2015-10-20 10:21:08 +0200944
945 printk(BIOS_DEBUG, "%s: scanning of bus %s took %ld usecs\n",
946 __func__, dev_path(busdev), stopwatch_duration_usecs(&sw));
Yinghai Lu13f1c2a2005-07-08 02:49:49 +0000947}
948
Kyösti Mälkki2d2367c2015-02-20 21:28:31 +0200949void scan_bridges(struct bus *bus)
950{
951 struct device *child;
Kyösti Mälkki2d2367c2015-02-20 21:28:31 +0200952
953 for (child = bus->children; child; child = child->sibling) {
954 if (!child->ops || !child->ops->scan_bus)
955 continue;
Kyösti Mälkki580e7222015-03-19 21:04:23 +0200956 scan_bus(child);
Kyösti Mälkki2d2367c2015-02-20 21:28:31 +0200957 }
Kyösti Mälkki2d2367c2015-02-20 21:28:31 +0200958}
959
Li-Ta Loe5266692004-03-23 21:28:05 +0000960/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +0000961 * Determine the existence of devices and extend the device tree.
Li-Ta Lo04930692004-11-25 17:37:19 +0000962 *
Uwe Hermanne4870472010-11-04 23:23:47 +0000963 * Most of the devices in the system are listed in the mainboard devicetree.cb
Li-Ta Lo04930692004-11-25 17:37:19 +0000964 * file. The device structures for these devices are generated at compile
965 * time by the config tool and are organized into the device tree. This
966 * function determines if the devices created at compile time actually exist
967 * in the physical system.
968 *
Uwe Hermanne4870472010-11-04 23:23:47 +0000969 * For devices in the physical system but not listed in devicetree.cb,
Li-Ta Lo04930692004-11-25 17:37:19 +0000970 * the device structures have to be created at run time and attached to the
Li-Ta Loe5266692004-03-23 21:28:05 +0000971 * device tree.
972 *
Uwe Hermanne4870472010-11-04 23:23:47 +0000973 * This function starts from the root device 'dev_root', scans the buses in
974 * the system recursively, and modifies the device tree according to the
975 * result of the probe.
Li-Ta Loe5266692004-03-23 21:28:05 +0000976 *
Li-Ta Lo5782d272004-04-26 17:51:20 +0000977 * This function has no idea how to scan and probe buses and devices at all.
978 * It depends on the bus/device specific scan_bus() method to do it. The
Li-Ta Lo04930692004-11-25 17:37:19 +0000979 * scan_bus() method also has to create the device structure and attach
Myles Watson032a9652009-05-11 22:24:53 +0000980 * it to the device tree.
Eric Biederman8ca8d762003-04-22 19:02:15 +0000981 */
982void dev_enumerate(void)
983{
984 struct device *root;
Uwe Hermanne4870472010-11-04 23:23:47 +0000985
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000986 printk(BIOS_INFO, "Enumerating buses...\n");
Uwe Hermanne4870472010-11-04 23:23:47 +0000987
Eric Biederman8ca8d762003-04-22 19:02:15 +0000988 root = &dev_root;
Myles Watsoncd5d7562009-05-12 13:43:34 +0000989
Uwe Hermanne4870472010-11-04 23:23:47 +0000990 show_all_devs(BIOS_SPEW, "Before device enumeration.");
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000991 printk(BIOS_SPEW, "Compare with tree...\n");
Kyösti Mälkki3d3c8c32016-08-15 10:04:21 +0300992 show_devs_tree(root, BIOS_SPEW, 0);
Myles Watsoncd5d7562009-05-12 13:43:34 +0000993
Stefan Reinauera675d492012-08-07 14:50:47 -0700994 if (root->chip_ops && root->chip_ops->enable_dev)
995 root->chip_ops->enable_dev(root);
Uwe Hermanne4870472010-11-04 23:23:47 +0000996
Eric Biedermanb78c1972004-10-14 20:54:17 +0000997 if (!root->ops || !root->ops->scan_bus) {
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +0000998 printk(BIOS_ERR, "dev_root missing scan_bus operation");
Eric Biedermanb78c1972004-10-14 20:54:17 +0000999 return;
1000 }
Kyösti Mälkki580e7222015-03-19 21:04:23 +02001001 scan_bus(root);
Duncan Laurie8adf7a22013-06-10 10:34:20 -07001002 post_log_clear();
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001003 printk(BIOS_INFO, "done\n");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001004}
1005
Li-Ta Loe5266692004-03-23 21:28:05 +00001006/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +00001007 * Configure devices on the devices tree.
Myles Watson032a9652009-05-11 22:24:53 +00001008 *
Li-Ta Lo04930692004-11-25 17:37:19 +00001009 * Starting at the root of the device tree, travel it recursively in two
1010 * passes. In the first pass, we compute and allocate resources (ranges)
Martin Roth63373ed2013-07-08 16:24:19 -06001011 * required by each device. In the second pass, the resources ranges are
Li-Ta Lo04930692004-11-25 17:37:19 +00001012 * relocated to their final position and stored to the hardware.
Li-Ta Lo5782d272004-04-26 17:51:20 +00001013 *
Myles Watson29cc9ed2009-07-02 18:56:24 +00001014 * I/O resources grow upward. MEM resources grow downward.
Li-Ta Lo5782d272004-04-26 17:51:20 +00001015 *
1016 * Since the assignment is hierarchical we set the values into the dev_root
Myles Watson032a9652009-05-11 22:24:53 +00001017 * struct.
Eric Biederman8ca8d762003-04-22 19:02:15 +00001018 */
1019void dev_configure(void)
1020{
Myles Watson29cc9ed2009-07-02 18:56:24 +00001021 struct resource *res;
Lubomir Rintel9ba8f7c2018-04-26 00:00:22 +02001022 const struct device *root;
1023 const struct device *child;
Li-Ta Loe5266692004-03-23 21:28:05 +00001024
Marc Jones80bd74c2012-02-21 17:44:35 +01001025 set_vga_bridge_bits();
Marc Jones80bd74c2012-02-21 17:44:35 +01001026
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001027 printk(BIOS_INFO, "Allocating resources...\n");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001028
Eric Biedermanb78c1972004-10-14 20:54:17 +00001029 root = &dev_root;
Myles Watsoncd5d7562009-05-12 13:43:34 +00001030
Uwe Hermanne4870472010-11-04 23:23:47 +00001031 /*
1032 * Each domain should create resources which contain the entire address
Myles Watson29cc9ed2009-07-02 18:56:24 +00001033 * space for IO, MEM, and PREFMEM resources in the domain. The
1034 * allocation of device resources will be done from this address space.
1035 */
Myles Watsoncd5d7562009-05-12 13:43:34 +00001036
Myles Watson29cc9ed2009-07-02 18:56:24 +00001037 /* Read the resources for the entire tree. */
Li-Ta Lo04930692004-11-25 17:37:19 +00001038
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001039 printk(BIOS_INFO, "Reading resources...\n");
Myles Watson894a3472010-06-09 22:41:35 +00001040 read_resources(root->link_list);
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001041 printk(BIOS_INFO, "Done reading resources.\n");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001042
Stefan Reinauer39e72292009-10-26 16:47:05 +00001043 print_resource_tree(root, BIOS_SPEW, "After reading.");
Myles Watsoncd5d7562009-05-12 13:43:34 +00001044
Myles Watson29cc9ed2009-07-02 18:56:24 +00001045 /* Compute resources for all domains. */
Myles Watson894a3472010-06-09 22:41:35 +00001046 for (child = root->link_list->children; child; child = child->sibling) {
Stefan Reinauer4aff4452013-02-12 14:17:15 -08001047 if (!(child->path.type == DEVICE_PATH_DOMAIN))
Myles Watson29cc9ed2009-07-02 18:56:24 +00001048 continue;
Duncan Laurie7ed39762013-07-09 10:46:52 -07001049 post_log_path(child);
Myles Watsonc25cc112010-05-21 14:33:48 +00001050 for (res = child->resource_list; res; res = res->next) {
Myles Watson29cc9ed2009-07-02 18:56:24 +00001051 if (res->flags & IORESOURCE_FIXED)
1052 continue;
Myles Watson29cc9ed2009-07-02 18:56:24 +00001053 if (res->flags & IORESOURCE_MEM) {
Myles Watson894a3472010-06-09 22:41:35 +00001054 compute_resources(child->link_list,
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +02001055 res, IORESOURCE_TYPE_MASK, IORESOURCE_MEM);
Myles Watson29cc9ed2009-07-02 18:56:24 +00001056 continue;
1057 }
1058 if (res->flags & IORESOURCE_IO) {
Myles Watson894a3472010-06-09 22:41:35 +00001059 compute_resources(child->link_list,
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +02001060 res, IORESOURCE_TYPE_MASK, IORESOURCE_IO);
Myles Watson29cc9ed2009-07-02 18:56:24 +00001061 continue;
1062 }
1063 }
1064 }
1065
1066 /* For all domains. */
Myles Watson894a3472010-06-09 22:41:35 +00001067 for (child = root->link_list->children; child; child=child->sibling)
Stefan Reinauer4aff4452013-02-12 14:17:15 -08001068 if (child->path.type == DEVICE_PATH_DOMAIN)
Myles Watson29cc9ed2009-07-02 18:56:24 +00001069 avoid_fixed_resources(child);
1070
Eric Biedermanb78c1972004-10-14 20:54:17 +00001071 /* Store the computed resource allocations into device registers ... */
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001072 printk(BIOS_INFO, "Setting resources...\n");
Myles Watson894a3472010-06-09 22:41:35 +00001073 for (child = root->link_list->children; child; child = child->sibling) {
Stefan Reinauer4aff4452013-02-12 14:17:15 -08001074 if (!(child->path.type == DEVICE_PATH_DOMAIN))
Myles Watson29cc9ed2009-07-02 18:56:24 +00001075 continue;
Duncan Laurie7ed39762013-07-09 10:46:52 -07001076 post_log_path(child);
Myles Watsonc25cc112010-05-21 14:33:48 +00001077 for (res = child->resource_list; res; res = res->next) {
Myles Watson29cc9ed2009-07-02 18:56:24 +00001078 if (res->flags & IORESOURCE_FIXED)
1079 continue;
Myles Watson29cc9ed2009-07-02 18:56:24 +00001080 if (res->flags & IORESOURCE_MEM) {
Myles Watson894a3472010-06-09 22:41:35 +00001081 allocate_resources(child->link_list,
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +02001082 res, IORESOURCE_TYPE_MASK, IORESOURCE_MEM);
Myles Watson29cc9ed2009-07-02 18:56:24 +00001083 continue;
1084 }
1085 if (res->flags & IORESOURCE_IO) {
Myles Watson894a3472010-06-09 22:41:35 +00001086 allocate_resources(child->link_list,
Kyösti Mälkkifdc0a902015-03-26 20:04:38 +02001087 res, IORESOURCE_TYPE_MASK, IORESOURCE_IO);
Myles Watson29cc9ed2009-07-02 18:56:24 +00001088 continue;
1089 }
1090 }
1091 }
Myles Watson894a3472010-06-09 22:41:35 +00001092 assign_resources(root->link_list);
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001093 printk(BIOS_INFO, "Done setting resources.\n");
Stefan Reinauer39e72292009-10-26 16:47:05 +00001094 print_resource_tree(root, BIOS_SPEW, "After assigning values.");
Eric Biederman03acab62004-10-14 21:25:53 +00001095
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001096 printk(BIOS_INFO, "Done allocating resources.\n");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001097}
1098
Li-Ta Loe5266692004-03-23 21:28:05 +00001099/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +00001100 * Enable devices on the device tree.
Li-Ta Loe5266692004-03-23 21:28:05 +00001101 *
1102 * Starting at the root, walk the tree and enable all devices/bridges by
1103 * calling the device's enable_resources() method.
Eric Biederman8ca8d762003-04-22 19:02:15 +00001104 */
1105void dev_enable(void)
1106{
Myles Watson7eac4452010-06-17 16:16:56 +00001107 struct bus *link;
1108
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001109 printk(BIOS_INFO, "Enabling resources...\n");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001110
Uwe Hermanne4870472010-11-04 23:23:47 +00001111 /* Now enable everything. */
Myles Watson7eac4452010-06-17 16:16:56 +00001112 for (link = dev_root.link_list; link; link = link->next)
1113 enable_resources(link);
Li-Ta Loe5266692004-03-23 21:28:05 +00001114
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001115 printk(BIOS_INFO, "done.\n");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001116}
1117
Li-Ta Loe5266692004-03-23 21:28:05 +00001118/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +00001119 * Initialize a specific device.
Myles Watson7eac4452010-06-17 16:16:56 +00001120 *
Uwe Hermanne4870472010-11-04 23:23:47 +00001121 * The parent should be initialized first to avoid having an ordering problem.
Martin Roth63373ed2013-07-08 16:24:19 -06001122 * This is done by calling the parent's init() method before its children's
Uwe Hermanne4870472010-11-04 23:23:47 +00001123 * init() methods.
Myles Watson7eac4452010-06-17 16:16:56 +00001124 *
Uwe Hermannc1ee4292010-10-17 19:01:48 +00001125 * @param dev The device to be initialized.
Myles Watson7eac4452010-06-17 16:16:56 +00001126 */
1127static void init_dev(struct device *dev)
1128{
Uwe Hermanne4870472010-11-04 23:23:47 +00001129 if (!dev->enabled)
Myles Watson7eac4452010-06-17 16:16:56 +00001130 return;
Myles Watson7eac4452010-06-17 16:16:56 +00001131
1132 if (!dev->initialized && dev->ops && dev->ops->init) {
Martin Rothb3b114c2017-06-24 14:00:01 -06001133#if IS_ENABLED(CONFIG_HAVE_MONOTONIC_TIMER)
Aaron Durbin46ba4802014-09-23 16:34:40 -05001134 struct stopwatch sw;
1135 stopwatch_init(&sw);
Aaron Durbin05294292013-04-30 15:41:13 -05001136#endif
Myles Watson7eac4452010-06-17 16:16:56 +00001137 if (dev->path.type == DEVICE_PATH_I2C) {
1138 printk(BIOS_DEBUG, "smbus: %s[%d]->",
1139 dev_path(dev->bus->dev), dev->bus->link_num);
1140 }
1141
Paul Menzeldb232152015-06-07 20:28:17 +02001142 printk(BIOS_DEBUG, "%s init ...\n", dev_path(dev));
Myles Watson7eac4452010-06-17 16:16:56 +00001143 dev->initialized = 1;
1144 dev->ops->init(dev);
Martin Rothb3b114c2017-06-24 14:00:01 -06001145#if IS_ENABLED(CONFIG_HAVE_MONOTONIC_TIMER)
Paul Menzeldb232152015-06-07 20:28:17 +02001146 printk(BIOS_DEBUG, "%s init finished in %ld usecs\n", dev_path(dev),
Aaron Durbin46ba4802014-09-23 16:34:40 -05001147 stopwatch_duration_usecs(&sw));
Aaron Durbin05294292013-04-30 15:41:13 -05001148#endif
Myles Watson7eac4452010-06-17 16:16:56 +00001149 }
1150}
1151
1152static void init_link(struct bus *link)
1153{
1154 struct device *dev;
1155 struct bus *c_link;
1156
Duncan Laurie8adf7a22013-06-10 10:34:20 -07001157 for (dev = link->children; dev; dev = dev->sibling) {
Duncan Lauriecb73a842013-06-10 10:41:04 -07001158 post_code(POST_BS_DEV_INIT);
Duncan Laurie8adf7a22013-06-10 10:34:20 -07001159 post_log_path(dev);
Myles Watson7eac4452010-06-17 16:16:56 +00001160 init_dev(dev);
Duncan Laurie8adf7a22013-06-10 10:34:20 -07001161 }
Myles Watson7eac4452010-06-17 16:16:56 +00001162
1163 for (dev = link->children; dev; dev = dev->sibling) {
Uwe Hermanne4870472010-11-04 23:23:47 +00001164 for (c_link = dev->link_list; c_link; c_link = c_link->next)
Myles Watson7eac4452010-06-17 16:16:56 +00001165 init_link(c_link);
Myles Watson7eac4452010-06-17 16:16:56 +00001166 }
1167}
1168
1169/**
Uwe Hermannc1ee4292010-10-17 19:01:48 +00001170 * Initialize all devices in the global device tree.
Myles Watson7eac4452010-06-17 16:16:56 +00001171 *
Uwe Hermannc1ee4292010-10-17 19:01:48 +00001172 * Starting at the root device, call the device's init() method to do
1173 * device-specific setup, then call each child's init() method.
Eric Biederman8ca8d762003-04-22 19:02:15 +00001174 */
1175void dev_initialize(void)
1176{
Myles Watson7eac4452010-06-17 16:16:56 +00001177 struct bus *link;
Eric Biederman8ca8d762003-04-22 19:02:15 +00001178
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001179 printk(BIOS_INFO, "Initializing devices...\n");
Myles Watson7eac4452010-06-17 16:16:56 +00001180
Martin Rothb3b114c2017-06-24 14:00:01 -06001181#if IS_ENABLED(CONFIG_ARCH_X86)
Subrata Banikc7590cd2017-09-04 18:44:38 +05301182 /*
1183 * Initialize EBDA area in ramstage if early
1184 * initialization is not done.
1185 */
1186 if (!IS_ENABLED(CONFIG_EARLY_EBDA_INIT))
1187 /* Ensure EBDA is prepared before Option ROMs. */
1188 setup_default_ebda();
Duncan Laurieb4aaaa72012-01-17 09:03:11 -08001189#endif
1190
Myles Watson1bd3fb72010-08-16 16:25:23 +00001191 /* First call the mainboard init. */
1192 init_dev(&dev_root);
1193
Uwe Hermanne4870472010-11-04 23:23:47 +00001194 /* Now initialize everything. */
Myles Watson7eac4452010-06-17 16:16:56 +00001195 for (link = dev_root.link_list; link; link = link->next)
1196 init_link(link);
Duncan Laurie8adf7a22013-06-10 10:34:20 -07001197 post_log_clear();
Myles Watson7eac4452010-06-17 16:16:56 +00001198
Stefan Reinauerc02b4fc2010-03-22 11:42:32 +00001199 printk(BIOS_INFO, "Devices initialized\n");
Stefan Reinauer39e72292009-10-26 16:47:05 +00001200 show_all_devs(BIOS_SPEW, "After init.");
Eric Biederman8ca8d762003-04-22 19:02:15 +00001201}
Marc Jones2a58ecd2013-10-29 17:32:00 -06001202
1203/**
1204 * Finalize a specific device.
1205 *
1206 * The parent should be finalized first to avoid having an ordering problem.
1207 * This is done by calling the parent's final() method before its childrens'
1208 * final() methods.
1209 *
1210 * @param dev The device to be initialized.
1211 */
1212static void final_dev(struct device *dev)
1213{
1214 if (!dev->enabled)
1215 return;
1216
1217 if (dev->ops && dev->ops->final) {
1218 printk(BIOS_DEBUG, "%s final\n", dev_path(dev));
1219 dev->ops->final(dev);
1220 }
1221}
1222
1223static void final_link(struct bus *link)
1224{
1225 struct device *dev;
1226 struct bus *c_link;
1227
1228 for (dev = link->children; dev; dev = dev->sibling)
1229 final_dev(dev);
1230
1231 for (dev = link->children; dev; dev = dev->sibling) {
1232 for (c_link = dev->link_list; c_link; c_link = c_link->next)
1233 final_link(c_link);
1234 }
1235}
1236/**
1237 * Finalize all devices in the global device tree.
1238 *
1239 * Starting at the root device, call the device's final() method to do
1240 * device-specific cleanup, then call each child's final() method.
1241 */
1242void dev_finalize(void)
1243{
1244 struct bus *link;
1245
1246 printk(BIOS_INFO, "Finalize devices...\n");
1247
1248 /* First call the mainboard finalize. */
1249 final_dev(&dev_root);
1250
1251 /* Now finalize everything. */
1252 for (link = dev_root.link_list; link; link = link->next)
1253 final_link(link);
1254
1255 printk(BIOS_INFO, "Devices finalized\n");
1256}