src/devices/device.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   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>
  15  */
  16
  17 /*
  18  *      (c) 1999--2000 Martin Mares <mj@suse.cz>
  19  */
  20 /* lots of mods by ron minnich (rminnich@lanl.gov), with
  21  * the final architecture guidance from Tom Merritt (tjm@codegen.com)
  22  * In particular, we changed from the one-pass original version to
  23  * Tom's recommended multiple-pass version. I wasn't sure about doing
  24  * it with multiple passes, until I actually started doing it and saw
  25  * the wisdom of Tom's recommendations ...
  26  *
  27  * Lots of cleanups by Eric Biederman to handle bridges, and to
  28  * handle resource allocation for non-pci devices.
  29  */
  30
  31 #include <console/console.h>
  32 #include <bitops.h>
  33 #include <arch/io.h>
  34 #include <device/device.h>
  35 #include <device/pci.h>
  36 #include <device/pci_ids.h>
  37 #include <stdlib.h>
  38 #include <string.h>
  39 #include <smp/spinlock.h>
  40
  41 /** Linked list of ALL devices */
  42 struct device *all_devices = &dev_root;
  43 /** Pointer to the last device */
  44 extern struct device **last_dev_p;
  45
  46 /** The upper limit of MEM resource of the devices.
  47  * Reserve 20M for the system */
  48 #define DEVICE_MEM_HIGH 0xFEBFFFFFUL
  49 /** The lower limit of IO resource of the devices.
  50  * Reserve 4k for ISA/Legacy devices */
  51 #define DEVICE_IO_START 0x1000
  52
  53 /**
  54  * @brief Allocate a new device structure.
  55  *
  56  * Allocte a new device structure and attached it to the device tree as a
  57  * child of the parent bus.
  58  *
  59  * @param parent parent bus the newly created device attached to.
  60  * @param path path to the device to be created.
  61  *
  62  * @return pointer to the newly created device structure.
  63  *
  64  * @see device_path
  65  */
  66 static spinlock_t dev_lock = SPIN_LOCK_UNLOCKED;
  67 device_t alloc_dev(struct bus *parent, struct device_path *path)
  68 {
  69         device_t dev, child;
  70         int link;
  71
  72         spin_lock(&dev_lock);
  73
  74         /* Find the last child of our parent */
  75         for(child = parent->children; child && child->sibling; ) {
  76                 child = child->sibling;
  77         }
  78
  79         dev = malloc(sizeof(*dev));
  80         if (dev == 0) {
  81                 die("DEV: out of memory.\n");
  82         }
  83         memset(dev, 0, sizeof(*dev));
  84         memcpy(&dev->path, path, sizeof(*path));
  85
  86         /* Initialize the back pointers in the link fields */
  87         for(link = 0; link < MAX_LINKS; link++) {
  88                 dev->link[link].dev  = dev;
  89                 dev->link[link].link = link;
  90         }
  91
  92         /* By default devices are enabled */
  93         dev->enabled = 1;
  94
  95         /* Add the new device to the list of children of the bus. */
  96         dev->bus = parent;
  97         if (child) {
  98                 child->sibling = dev;
  99         } else {
 100                 parent->children = dev;
 101         }
 102
 103         /* Append a new device to the global device list.
 104          * The list is used to find devices once everything is set up.
 105          */
 106         *last_dev_p = dev;
 107         last_dev_p = &dev->next;
 108
 109         spin_unlock(&dev_lock);
 110         return dev;
 111 }
 112
 113 /**
 114  * @brief round a number up to an alignment.
 115  * @param val the starting value
 116  * @param roundup Alignment as a power of two
 117  * @returns rounded up number
 118  */
 119 static resource_t round(resource_t val, unsigned long pow)
 120 {
 121         resource_t mask;
 122         mask = (1ULL << pow) - 1ULL;
 123         val += mask;
 124         val &= ~mask;
 125         return val;
 126 }
 127
 128 /** Read the resources on all devices of a given bus.
 129  * @param bus bus to read the resources on.
 130  */
 131 static void read_resources(struct bus *bus)
 132 {
 133         struct device *curdev;
 134
 135         printk_spew("%s read_resources bus %d link: %d\n",
 136                 dev_path(bus->dev), bus->secondary, bus->link);
 137
 138         /* Walk through all of the devices and find which resources they need. */
 139         for(curdev = bus->children; curdev; curdev = curdev->sibling) {
 140                 unsigned links;
 141                 int i;
 142                 if (curdev->have_resources) {
 143                         continue;
 144                 }
 145                 if (!curdev->enabled) {
 146                         continue;
 147                 }
 148                 if (!curdev->ops || !curdev->ops->read_resources) {
 149                         printk_err("%s missing read_resources\n",
 150                                 dev_path(curdev));
 151                         continue;
 152                 }
 153                 curdev->ops->read_resources(curdev);
 154                 curdev->have_resources = 1;
 155                 /* Read in subtractive resources behind the current device */
 156                 links = 0;
 157                 for(i = 0; i < curdev->resources; i++) {
 158                         struct resource *resource;
 159                         unsigned link;
 160                         resource = &curdev->resource[i];
 161                         if (!(resource->flags & IORESOURCE_SUBTRACTIVE))
 162                                 continue;
 163                         link = IOINDEX_SUBTRACTIVE_LINK(resource->index);
 164                         if (link > MAX_LINKS) {
 165                                 printk_err("%s subtractive index on link: %d\n",
 166                                         dev_path(curdev), link);
 167                                 continue;
 168                         }
 169                         if (!(links & (1 << link))) {
 170                                 links |= (1 << link);
 171                                 read_resources(&curdev->link[link]);
 172                         }
 173                 }
 174         }
 175         printk_spew("%s read_resources bus %d link: %d done\n",
 176                 dev_path(bus->dev), bus->secondary, bus->link);
 177 }
 178
 179 struct pick_largest_state {
 180         struct resource *last;
 181         struct device   *result_dev;
 182         struct resource *result;
 183         int seen_last;
 184 };
 185
 186 static void pick_largest_resource(void *gp,
 187         struct device *dev, struct resource *resource)
 188 {
 189         struct pick_largest_state *state = gp;
 190         struct resource *last;
 191         last = state->last;
 192         /* Be certain to pick the successor to last */
 193         if (resource == last) {
 194                 state->seen_last = 1;
 195                 return;
 196         }
 197         if (resource->flags & IORESOURCE_FIXED ) return; //skip it
 198         if (last && (
 199                     (last->align < resource->align) ||
 200                     ((last->align == resource->align) &&
 201                             (last->size < resource->size)) ||
 202                     ((last->align == resource->align) &&
 203                             (last->size == resource->size) &&
 204                             (!state->seen_last)))) {
 205                 return;
 206         }
 207         if (!state->result ||
 208                 (state->result->align < resource->align) ||
 209                 ((state->result->align == resource->align) &&
 210                         (state->result->size < resource->size)))
 211         {
 212                 state->result_dev = dev;
 213                 state->result = resource;
 214         }
 215 }
 216
 217 static struct device *largest_resource(struct bus *bus, struct resource **result_res,
 218         unsigned long type_mask, unsigned long type)
 219 {
 220         struct pick_largest_state state;
 221
 222         state.last = *result_res;
 223         state.result_dev = 0;
 224         state.result = 0;
 225         state.seen_last = 0;
 226
 227         search_bus_resources(bus, type_mask, type, pick_largest_resource, &state);
 228
 229         *result_res = state.result;
 230         return state.result_dev;
 231 }
 232
 233 /* Compute allocate resources is the guts of the resource allocator.
 234  *
 235  * The problem.
 236  *  - Allocate resources locations for every device.
 237  *  - Don't overlap, and follow the rules of bridges.
 238  *  - Don't overlap with resources in fixed locations.
 239  *  - Be efficient so we don't have ugly strategies.
 240  *
 241  * The strategy.
 242  * - Devices that have fixed addresses are the minority so don't
 243  *   worry about them too much.  Instead only use part of the address
 244  *   space for devices with programmable addresses.  This easily handles
 245  *   everything except bridges.
 246  *
 247  * - PCI devices are required to have thier sizes and their alignments
 248  *   equal.  In this case an optimal solution to the packing problem
 249  *   exists.  Allocate all devices from highest alignment to least
 250  *   alignment or vice versa.  Use this.
 251  *
 252  * - So we can handle more than PCI run two allocation passes on
 253  *   bridges.  The first to see how large the resources are behind
 254  *   the bridge, and what their alignment requirements are.  The
 255  *   second to assign a safe address to the devices behind the
 256  *   bridge.  This allows me to treat a bridge as just a device with
 257  *   a couple of resources, and not need to special case it in the
 258  *   allocator.  Also this allows handling of other types of bridges.
 259  *
 260  */
 261
 262 void compute_allocate_resource(
 263         struct bus *bus,
 264         struct resource *bridge,
 265         unsigned long type_mask,
 266         unsigned long type)
 267 {
 268         struct device *dev;
 269         struct resource *resource;
 270         resource_t base;
 271         unsigned long align, min_align;
 272         min_align = 0;
 273         base = bridge->base;
 274
 275         printk_spew("%s compute_allocate_resource %s: base: %08Lx size: %08Lx align: %d gran: %d\n",
 276                 dev_path(bus->dev),
 277                 (bridge->flags & IORESOURCE_IO)? "io":
 278                 (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem",
 279                 base, bridge->size, bridge->align, bridge->gran);
 280
 281         /* We want different minimum alignments for different kinds of
 282          * resources.  These minimums are not device type specific
 283          * but resource type specific.
 284          */
 285         if (bridge->flags & IORESOURCE_IO) {
 286                 min_align = log2(DEVICE_IO_ALIGN);
 287         }
 288         if (bridge->flags & IORESOURCE_MEM) {
 289                 min_align = log2(DEVICE_MEM_ALIGN);
 290         }
 291
 292         /* Make certain I have read in all of the resources */
 293         read_resources(bus);
 294
 295         /* Remember I haven't found anything yet. */
 296         resource = 0;
 297
 298         /* Walk through all the devices on the current bus and
 299          * compute the addresses.
 300          */
 301         while((dev = largest_resource(bus, &resource, type_mask, type))) {
 302                 resource_t size;
 303                 /* Do NOT I repeat do not ignore resources which have zero size.
 304                  * If they need to be ignored dev->read_resources should not even
 305                  * return them.   Some resources must be set even when they have
 306                  * no size.  PCI bridge resources are a good example of this.
 307                  */
 308                 /* Make certain we are dealing with a good minimum size */
 309                 size = resource->size;
 310                 align = resource->align;
 311                 if (align < min_align) {
 312                         align = min_align;
 313                 }
 314
 315                 /* Propagate the resource alignment to the bridge register  */
 316                 if (align > bridge->align) {
 317                         bridge->align = align;
 318                 }
 319
 320                 if (resource->flags & IORESOURCE_FIXED) {
 321                         continue;
 322                 }
 323
 324                 /* Propogate the resource limit to the bridge register */
 325                 if (bridge->limit > resource->limit) {
 326                         bridge->limit = resource->limit;
 327                 }
 328 #warning This heuristic should be replaced by real devices with fixed resources.
 329                 /* Artificially deny limits between DEVICE_MEM_HIGH and 0xffffffff */
 330                 if ((bridge->limit > DEVICE_MEM_HIGH) && (bridge->limit <= 0xffffffff)) {
 331                         bridge->limit = DEVICE_MEM_HIGH;
 332                 }
 333
 334                 if (resource->flags & IORESOURCE_IO) {
 335                         /* Don't allow potential aliases over the
 336                          * legacy pci expansion card addresses.
 337                          * The legacy pci decodes only 10 bits,
 338                          * uses 100h - 3ffh. Therefor, only 0 - ff
 339                          * can be used out of each 400h block of io
 340                          * space.
 341                          */
 342                         if ((base & 0x300) != 0) {
 343                                 base = (base & ~0x3ff) + 0x400;
 344                         }
 345                         /* Don't allow allocations in the VGA IO range.
 346                          * PCI has special cases for that.
 347                          */
 348                         else if ((base >= 0x3b0) && (base <= 0x3df)) {
 349                                 base = 0x3e0;
 350                         }
 351                 }
 352                 if (((round(base, align) + size) -1) <= resource->limit) {
 353                         /* base must be aligned to size */
 354                         base = round(base, align);
 355                         resource->base = base;
 356                         resource->flags |= IORESOURCE_ASSIGNED;
 357                         resource->flags &= ~IORESOURCE_STORED;
 358                         base += size;
 359
 360                         printk_spew("%s %02lx *  [0x%08Lx - 0x%08Lx] %s\n",
 361                                 dev_path(dev),
 362                                 resource->index,
 363                                 resource->base,
 364                                 resource->base + resource->size - 1,
 365                                 (resource->flags & IORESOURCE_IO)? "io":
 366                                 (resource->flags & IORESOURCE_PREFETCH)? "prefmem": "mem");
 367                 }
 368 #if CONFIG_PCIE_CONFIGSPACE_HOLE
 369 #warning Handle PCIe hole differently...
 370                 if (base >= 0xf0000000 && base < 0xf4000000) {
 371                         base = 0xf4000000;
 372                 }
 373 #endif
 374         }
 375         /* A pci bridge resource does not need to be a power
 376          * of two size, but it does have a minimum granularity.
 377          * Round the size up to that minimum granularity so we
 378          * know not to place something else at an address postitively
 379          * decoded by the bridge.
 380          */
 381         bridge->size = round(base, bridge->gran) - bridge->base;
 382
 383         printk_spew("%s compute_allocate_resource %s: base: %08Lx size: %08Lx align: %d gran: %d done\n",
 384                 dev_path(bus->dev),
 385                 (bridge->flags & IORESOURCE_IO)? "io":
 386                 (bridge->flags & IORESOURCE_PREFETCH)? "prefmem" : "mem",
 387                 base, bridge->size, bridge->align, bridge->gran);
 388
 389
 390 }
 391
 392 #if CONFIG_CONSOLE_VGA == 1
 393 device_t vga_pri = 0;
 394 static void allocate_vga_resource(void)
 395 {
 396 #warning "FIXME modify allocate_vga_resource so it is less pci centric!"
 397 #warning "This function knows to much about PCI stuff, it should be just a ietrator/visitor."
 398
 399         /* FIXME handle the VGA pallette snooping */
 400         struct device *dev, *vga, *vga_onboard, *vga_first, *vga_last;
 401         struct bus *bus;
 402         bus = 0;
 403         vga = 0;
 404         vga_onboard = 0;
 405         vga_first = 0;
 406         vga_last = 0;
 407         for(dev = all_devices; dev; dev = dev->next) {
 408                 if (!dev->enabled) continue;
 409                 if (((dev->class >> 16) == PCI_BASE_CLASS_DISPLAY) &&
 410                         ((dev->class >> 8) != PCI_CLASS_DISPLAY_OTHER))
 411                 {
 412                         if (!vga_first) {
 413                                 if (dev->on_mainboard) {
 414                                         vga_onboard = dev;
 415                                 } else {
 416                                         vga_first = dev;
 417                                 }
 418                         } else {
 419                                 if (dev->on_mainboard) {
 420                                         vga_onboard = dev;
 421                                 } else {
 422                                         vga_last = dev;
 423                                 }
 424                         }
 425
 426                         /* It isn't safe to enable other VGA cards */
 427                         dev->command &= ~(PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
 428                 }
 429         }
 430
 431         vga = vga_last;
 432
 433         if(!vga) {
 434                 vga = vga_first;
 435         }
 436
 437 #if CONFIG_CONSOLE_VGA_ONBOARD_AT_FIRST == 1
 438         if (vga_onboard) // will use on board vga as pri
 439 #else
 440         if (!vga) // will use last add on adapter as pri
 441 #endif
 442         {
 443                 vga = vga_onboard;
 444         }
 445
 446
 447         if (vga) {
 448                 /* vga is first add on card or the only onboard vga */
 449                 printk_debug("Allocating VGA resource %s\n", dev_path(vga));
 450                 /* All legacy VGA cards have MEM & I/O space registers */
 451                 vga->command |= (PCI_COMMAND_MEMORY | PCI_COMMAND_IO);
 452                 vga_pri = vga;
 453                 bus = vga->bus;
 454         }
 455         /* Now walk up the bridges setting the VGA enable */
 456         while(bus) {
 457                 printk_debug("Setting PCI_BRIDGE_CTL_VGA for bridge %s\n",
 458                              dev_path(bus->dev));
 459                 bus->bridge_ctrl |= PCI_BRIDGE_CTL_VGA;
 460                 bus = (bus == bus->dev->bus)? 0 : bus->dev->bus;
 461         }
 462 }
 463
 464 #endif
 465
 466
 467 /**
 468  * @brief  Assign the computed resources to the devices on the bus.
 469  *
 470  * @param bus Pointer to the structure for this bus
 471  *
 472  * Use the device specific set_resources method to store the computed
 473  * resources to hardware. For bridge devices, the set_resources() method
 474  * has to recurse into every down stream buses.
 475  *
 476  * Mutual recursion:
 477  *      assign_resources() -> device_operation::set_resources()
 478  *      device_operation::set_resources() -> assign_resources()
 479  */
 480 void assign_resources(struct bus *bus)
 481 {
 482         struct device *curdev;
 483
 484         printk_spew("%s assign_resources, bus %d link: %d\n",
 485                 dev_path(bus->dev), bus->secondary, bus->link);
 486
 487         for(curdev = bus->children; curdev; curdev = curdev->sibling) {
 488                 if (!curdev->enabled || !curdev->resources) {
 489                         continue;
 490                 }
 491                 if (!curdev->ops || !curdev->ops->set_resources) {
 492                         printk_err("%s missing set_resources\n",
 493                                 dev_path(curdev));
 494                         continue;
 495                 }
 496                 curdev->ops->set_resources(curdev);
 497         }
 498         printk_spew("%s assign_resources, bus %d link: %d\n",
 499                 dev_path(bus->dev), bus->secondary, bus->link);
 500 }
 501
 502 /**
 503  * @brief Enable the resources for a specific device
 504  *
 505  * @param dev the device whose resources are to be enabled
 506  *
 507  * Enable resources of the device by calling the device specific
 508  * enable_resources() method.
 509  *
 510  * The parent's resources should be enabled first to avoid having enabling
 511  * order problem. This is done by calling the parent's enable_resources()
 512  * method and let that method to call it's children's enable_resoruces()
 513  * method via the (global) enable_childrens_resources().
 514  *
 515  * Indirect mutual recursion:
 516  *      enable_resources() -> device_operations::enable_resource()
 517  *      device_operations::enable_resource() -> enable_children_resources()
 518  *      enable_children_resources() -> enable_resources()
 519  */
 520 void enable_resources(struct device *dev)
 521 {
 522         if (!dev->enabled) {
 523                 return;
 524         }
 525         if (!dev->ops || !dev->ops->enable_resources) {
 526                 printk_err("%s missing enable_resources\n", dev_path(dev));
 527                 return;
 528         }
 529         dev->ops->enable_resources(dev);
 530 }
 531
 532 /**
 533  * @brief Reset all of the devices a bus
 534  *
 535  * Reset all of the devices on a bus and clear the bus's reset_needed flag.
 536  *
 537  * @param bus pointer to the bus structure
 538  *
 539  * @return 1 if the bus was successfully reset, 0 otherwise.
 540  *
 541  */
 542 int reset_bus(struct bus *bus)
 543 {
 544         if (bus && bus->dev && bus->dev->ops && bus->dev->ops->reset_bus)
 545         {
 546                 bus->dev->ops->reset_bus(bus);
 547                 bus->reset_needed = 0;
 548                 return 1;
 549         }
 550         return 0;
 551 }
 552
 553 /**
 554  * @brief Scan for devices on a bus.
 555  *
 556  * If there are bridges on the bus, recursively scan the buses behind the bridges.
 557  * If the setting up and tuning of the bus causes a reset to be required,
 558  * reset the bus and scan it again.
 559  *
 560  * @param bus pointer to the bus device
 561  * @param max current bus number
 562  *
 563  * @return The maximum bus number found, after scanning all subordinate busses
 564  */
 565 unsigned int scan_bus(device_t bus, unsigned int max)
 566 {
 567         unsigned int new_max;
 568         int do_scan_bus;
 569         if (    !bus ||
 570                 !bus->enabled ||
 571                 !bus->ops ||
 572                 !bus->ops->scan_bus)
 573         {
 574                 return max;
 575         }
 576         do_scan_bus = 1;
 577         while(do_scan_bus) {
 578                 int link;
 579                 new_max = bus->ops->scan_bus(bus, max);
 580                 do_scan_bus = 0;
 581                 for(link = 0; link < bus->links; link++) {
 582                         if (bus->link[link].reset_needed) {
 583                                 if (reset_bus(&bus->link[link])) {
 584                                         do_scan_bus = 1;
 585                                 } else {
 586                                         bus->bus->reset_needed = 1;
 587                                 }
 588                         }
 589                 }
 590         }
 591         return new_max;
 592 }
 593
 594
 595 /**
 596  * @brief Determine the existence of devices and extend the device tree.
 597  *
 598  * Most of the devices in the system are listed in the mainboard Config.lb
 599  * file. The device structures for these devices are generated at compile
 600  * time by the config tool and are organized into the device tree. This
 601  * function determines if the devices created at compile time actually exist
 602  * in the physical system.
 603  *
 604  * For devices in the physical system but not listed in the Config.lb file,
 605  * the device structures have to be created at run time and attached to the
 606  * device tree.
 607  *
 608  * This function starts from the root device 'dev_root', scan the buses in
 609  * the system recursively, modify the device tree according to the result of
 610  * the probe.
 611  *
 612  * This function has no idea how to scan and probe buses and devices at all.
 613  * It depends on the bus/device specific scan_bus() method to do it. The
 614  * scan_bus() method also has to create the device structure and attach
 615  * it to the device tree.
 616  */
 617 void dev_enumerate(void)
 618 {
 619         struct device *root;
 620         unsigned subordinate;
 621         printk_info("Enumerating buses...\n");
 622         root = &dev_root;
 623         if (root->chip_ops && root->chip_ops->enable_dev) {
 624                 root->chip_ops->enable_dev(root);
 625         }
 626         if (!root->ops || !root->ops->scan_bus) {
 627                 printk_err("dev_root missing scan_bus operation");
 628                 return;
 629         }
 630         subordinate = scan_bus(root, 0);
 631         printk_info("done\n");
 632 }
 633
 634 /**
 635  * @brief Configure devices on the devices tree.
 636  *
 637  * Starting at the root of the device tree, travel it recursively in two
 638  * passes. In the first pass, we compute and allocate resources (ranges)
 639  * requried by each device. In the second pass, the resources ranges are
 640  * relocated to their final position and stored to the hardware.
 641  *
 642  * I/O resources start at DEVICE_IO_START and grow upward. MEM resources start
 643  * at DEVICE_MEM_HIGH and grow downward.
 644  *
 645  * Since the assignment is hierarchical we set the values into the dev_root
 646  * struct.
 647  */
 648 void dev_configure(void)
 649 {
 650         struct resource *io, *mem;
 651         struct device *root;
 652
 653         printk_info("Allocating resources...\n");
 654
 655         root = &dev_root;
 656         if (!root->ops || !root->ops->read_resources) {
 657                 printk_err("dev_root missing read_resources\n");
 658                 return;
 659         }
 660         if (!root->ops || !root->ops->set_resources) {
 661                 printk_err("dev_root missing set_resources\n");
 662                 return;
 663         }
 664
 665         printk_info("Reading resources...\n");
 666         root->ops->read_resources(root);
 667         printk_info("Done reading resources.\n");
 668
 669         /* Get the resources */
 670         io  = &root->resource[0];
 671         mem = &root->resource[1];
 672         /* Make certain the io devices are allocated somewhere safe. */
 673         io->base = DEVICE_IO_START;
 674         io->flags |= IORESOURCE_ASSIGNED;
 675         io->flags &= ~IORESOURCE_STORED;
 676         /* Now reallocate the pci resources memory with the
 677          * highest addresses I can manage.
 678          */
 679         mem->base = resource_max(&root->resource[1]);
 680         mem->flags |= IORESOURCE_ASSIGNED;
 681         mem->flags &= ~IORESOURCE_STORED;
 682
 683 #if CONFIG_CONSOLE_VGA == 1
 684         /* Allocate the VGA I/O resource.. */
 685         allocate_vga_resource();
 686 #endif
 687
 688         /* Store the computed resource allocations into device registers ... */
 689         printk_info("Setting resources...\n");
 690         root->ops->set_resources(root);
 691         printk_info("Done setting resources.\n");
 692 #if 0
 693         mem->flags |= IORESOURCE_STORED;
 694         report_resource_stored(root, mem, "");
 695 #endif
 696
 697         printk_info("Done allocating resources.\n");
 698 }
 699
 700 /**
 701  * @brief Enable devices on the device tree.
 702  *
 703  * Starting at the root, walk the tree and enable all devices/bridges by
 704  * calling the device's enable_resources() method.
 705  */
 706 void dev_enable(void)
 707 {
 708         printk_info("Enabling resources...\n");
 709
 710         /* now enable everything. */
 711         enable_resources(&dev_root);
 712
 713         printk_info("done.\n");
 714 }
 715
 716 /**
 717  * @brief Initialize all devices in the global device list.
 718  *
 719  * Starting at the first device on the global device link list,
 720  * walk the list and call the device's init() method to do deivce
 721  * specific setup.
 722  */
 723 void dev_initialize(void)
 724 {
 725         struct device *dev;
 726
 727         printk_info("Initializing devices...\n");
 728         for(dev = all_devices; dev; dev = dev->next) {
 729                 if (dev->enabled && !dev->initialized &&
 730                         dev->ops && dev->ops->init)
 731                 {
 732                         if (dev->path.type == DEVICE_PATH_I2C) {
 733                                 printk_debug("smbus: %s[%d]->",
 734                                         dev_path(dev->bus->dev), dev->bus->link);
 735                         }
 736                         printk_debug("%s init\n", dev_path(dev));
 737                         dev->initialized = 1;
 738                         dev->ops->init(dev);
 739                 }
 740         }
 741         printk_info("Devices initialized\n");
 742 }
 743