src/devices/pci_device.c

   1 /*
   2  *      PCI Bus Services, see include/linux/pci.h for further explanation.
   3  *
   4  *      Copyright 1993 -- 1997 Drew Eckhardt, Frederic Potter,
   5  *      David Mosberger-Tang
   6  *
   7  *      Copyright 1997 -- 1999 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
   8  *
   9  *      Copyright 2003 -- Eric Biederman <ebiederman@lnxi.com>
  10  */
  11
  12 #include <console/console.h>
  13 #include <stdlib.h>
  14 #include <stdint.h>
  15 #include <bitops.h>
  16 #include <string.h>
  17 #include <arch/io.h>
  18 #include <device/device.h>
  19 #include <device/pci.h>
  20 #include <device/pci_ids.h>
  21 #include <device/chip.h>
  22 #include <part/hard_reset.h>
  23 #include <part/fallback_boot.h>
  24
  25 /** Given a device and register, read the size of the BAR for that register.
  26  * @param dev       Pointer to the device structure
  27  * @param resource  Pointer to the resource structure
  28  * @param index     Address of the pci configuration register
  29  */
  30 static struct resource *pci_get_resource(struct device *dev, unsigned long index)
  31 {
  32         struct resource *resource;
  33         uint32_t addr, size, base;
  34         unsigned long type;
  35
  36         /* Initialize the resources to nothing */
  37         resource = get_resource(dev, index);
  38
  39         addr = pci_read_config32(dev, index);
  40
  41         /* FIXME: more consideration for 64-bit PCI devices,
  42          * we currently detect their size but otherwise
  43          * treat them as 32-bit resources
  44          */
  45         /* get the size */
  46         pci_write_config32(dev, index, ~0);
  47         size = pci_read_config32(dev,  index);
  48
  49         /* get the minimum value the bar can be set to */
  50         pci_write_config32(dev, index, 0);
  51         base = pci_read_config32(dev, index);
  52
  53         /* restore addr */
  54         pci_write_config32(dev, index, addr);
  55
  56         /*
  57          * some broken hardware has read-only registers that do not
  58          * really size correctly. You can tell this if addr == size
  59          * Example: the acer m7229 has BARs 1-4 normally read-only.
  60          * so BAR1 at offset 0x10 reads 0x1f1. If you size that register
  61          * by writing 0xffffffff to it, it will read back as 0x1f1 -- a
  62          * violation of the spec.
  63          * We catch this case and ignore it by settting size and type to 0.
  64          * This incidentally catches the common case where registers
  65          * read back as 0 for both address and size.
  66          */
  67         if ((addr == size) && (addr == base)) {
  68                 if (size != 0) {
  69                         printk_debug(
  70                                 "%s register %02x(%08x), read-only ignoring it\n",
  71                                 dev_path(dev),
  72                                 index, addr);
  73                 }
  74                 resource->flags = 0;
  75         }
  76         /* Now compute the actual size, See PCI Spec 6.2.5.1 ...  */
  77         else if (size & PCI_BASE_ADDRESS_SPACE_IO) {
  78                 type = size & (~PCI_BASE_ADDRESS_IO_MASK);
  79                 /* BUG! Top 16 bits can be zero (or not)
  80                  * So set them to 0xffff so they go away ...
  81                  */
  82                 resource->size = (~((size | 0xffff0000) & PCI_BASE_ADDRESS_IO_MASK)) +1;
  83                 resource->align = log2(resource->size);
  84                 resource->gran = resource->align;
  85                 resource->flags |= IORESOURCE_IO;
  86                 resource->limit = 0xffff;
  87         }
  88         else {
  89                 /* A Memory mapped base address */
  90                 type = size & (~PCI_BASE_ADDRESS_MEM_MASK);
  91                 resource->size = (~(size &PCI_BASE_ADDRESS_MEM_MASK)) +1;
  92                 resource->align = log2(resource->size);
  93                 resource->gran = resource->align;
  94                 resource->flags |= IORESOURCE_MEM;
  95                 if (type & PCI_BASE_ADDRESS_MEM_PREFETCH) {
  96                         resource->flags |= IORESOURCE_PREFETCH;
  97                 }
  98                 type &= PCI_BASE_ADDRESS_MEM_TYPE_MASK;
  99                 if (type == PCI_BASE_ADDRESS_MEM_TYPE_32) {
 100                         /* 32bit limit */
 101                         resource->limit = 0xffffffffUL;
 102                 }
 103                 else if (type == PCI_BASE_ADDRESS_MEM_TYPE_1M) {
 104                         /* 1MB limit */
 105                         resource->limit = 0x000fffffUL;
 106                 }
 107                 else if (type == PCI_BASE_ADDRESS_MEM_TYPE_64) {
 108                         unsigned long index_hi;
 109                         /* 64bit limit
 110                          * For now just treat this as a 32bit limit
 111                          */
 112                         index_hi = index + 4;
 113                         resource->limit = 0xffffffffUL;
 114                         resource->flags |= IORESOURCE_PCI64;
 115                         addr = pci_read_config32( dev, index_hi);
 116                         /* get the extended size */
 117                         pci_write_config32(dev, index_hi, 0xffffffffUL);
 118                         size = pci_read_config32( dev, index_hi);
 119
 120                         /* get the minimum value the bar can be set to */
 121                         pci_write_config32(dev, index_hi, 0);
 122                         base = pci_read_config32(dev,  index_hi);
 123
 124                         /* restore addr */
 125                         pci_write_config32(dev, index_hi, addr);
 126
 127                         if ((size == 0xffffffff) && (base == 0)) {
 128                                 /* Clear the top half of the bar */
 129                                 pci_write_config32(dev, index_hi, 0);
 130                         }
 131                         else {
 132                                 printk_err("%s Unable to handle 64-bit address\n",
 133                                         dev_path(dev));
 134                                 resource->flags = IORESOURCE_PCI64;
 135                         }
 136                 }
 137                 else {
 138                         /* Invalid value */
 139                         resource->flags = 0;
 140                 }
 141         }
 142         /* dev->size holds the flags... */
 143         return resource;
 144 }
 145
 146 /** Read the base address registers for a given device.
 147  * @param dev Pointer to the dev structure
 148  * @param howmany How many registers to read (6 for device, 2 for bridge)
 149  */
 150 static void pci_read_bases(struct device *dev, unsigned int howmany)
 151 {
 152         unsigned long index;
 153
 154         for (index = PCI_BASE_ADDRESS_0; (index < PCI_BASE_ADDRESS_0 + (howmany << 2)); ) {
 155                 struct resource *resource;
 156                 resource = pci_get_resource(dev, index);
 157                 index += (resource->flags & IORESOURCE_PCI64)?8:4;
 158         }
 159         compact_resources(dev);
 160 }
 161
 162 static void pci_bridge_read_bases(struct device *dev)
 163 {
 164         struct resource *resource;
 165
 166         /* FIXME handle bridges without some of the optional resources */
 167
 168         /* Initialize the io space constraints on the current bus */
 169         resource = get_resource(dev, PCI_IO_BASE);
 170         resource->size  = 0;
 171         resource->align = log2(PCI_IO_BRIDGE_ALIGN);
 172         resource->gran  = log2(PCI_IO_BRIDGE_ALIGN);
 173         resource->limit = 0xffffUL;
 174         resource->flags |= IORESOURCE_IO | IORESOURCE_PCI_BRIDGE;
 175         compute_allocate_resource(&dev->link[0], resource,
 176                                   IORESOURCE_IO, IORESOURCE_IO);
 177
 178         /* Initiliaze the prefetchable memory constraints on the current bus */
 179         resource = get_resource(dev, PCI_PREF_MEMORY_BASE);
 180         resource->size = 0;
 181         resource->align = log2(PCI_MEM_BRIDGE_ALIGN);
 182         resource->gran  = log2(PCI_MEM_BRIDGE_ALIGN);
 183         resource->limit = 0xffffffffUL;
 184         resource->flags = IORESOURCE_MEM | IORESOURCE_PREFETCH | IORESOURCE_PCI_BRIDGE;
 185         resource->index = PCI_PREF_MEMORY_BASE;
 186         compute_allocate_resource(&dev->link[0], resource,
 187                                   IORESOURCE_MEM | IORESOURCE_PREFETCH,
 188                                   IORESOURCE_MEM | IORESOURCE_PREFETCH);
 189
 190         /* Initialize the memory resources on the current bus */
 191         resource = get_resource(dev, PCI_MEMORY_BASE);
 192         resource->size = 0;
 193         resource->align = log2(PCI_MEM_BRIDGE_ALIGN);
 194         resource->gran  = log2(PCI_MEM_BRIDGE_ALIGN);
 195         resource->limit = 0xffffffffUL;
 196         resource->flags = IORESOURCE_MEM | IORESOURCE_PCI_BRIDGE;
 197         compute_allocate_resource(&dev->link[0], resource,
 198                                   IORESOURCE_MEM | IORESOURCE_PREFETCH,
 199                                   IORESOURCE_MEM);
 200
 201         compact_resources(dev);
 202 }
 203
 204 void pci_dev_read_resources(struct device *dev)
 205 {
 206         uint32_t addr;
 207
 208         pci_read_bases(dev, 6);
 209
 210         addr = pci_read_config32(dev, PCI_ROM_ADDRESS);
 211         dev->rom_address = (addr == 0xffffffff)? 0 : addr;
 212 }
 213
 214 void pci_bus_read_resources(struct device *dev)
 215 {
 216         uint32_t addr;
 217
 218         pci_bridge_read_bases(dev);
 219         pci_read_bases(dev, 2);
 220
 221         addr = pci_read_config32(dev, PCI_ROM_ADDRESS1);
 222         dev->rom_address = (addr == 0xffffffff)? 0 : addr;
 223 }
 224
 225 /**
 226  * @brief round a number up to an alignment.
 227  * @param val the starting value
 228  * @param roundup Alignment as a power of two
 229  * @returns rounded up number
 230  */
 231 static unsigned long round(unsigned long val, unsigned long roundup)
 232 {
 233         /* ROUNDUP MUST BE A POWER OF TWO. */
 234         unsigned long inverse;
 235         inverse = ~(roundup - 1);
 236         val += (roundup - 1);
 237         val &= inverse;
 238         return val;
 239 }
 240
 241 static void pci_set_resource(struct device *dev, struct resource *resource)
 242 {
 243         unsigned long base, limit;
 244         unsigned char buf[10];
 245         unsigned long gran;
 246
 247         /* Make certain the resource has actually been set */
 248
 249         if (!(resource->flags & IORESOURCE_ASSIGNED)) {
 250                 printk_err("ERROR: %s %02x not allocated\n",
 251                            dev_path(dev), resource->index);
 252                 return;
 253         }
 254
 255         /* If I have already stored this resource don't worry about it */
 256         if (resource->flags & IORESOURCE_STORED) {
 257                 return;
 258         }
 259
 260         /* Only handle PCI memory and IO resources for now */
 261         if (!(resource->flags & (IORESOURCE_MEM |IORESOURCE_IO)))
 262                 return;
 263
 264         if (resource->flags & IORESOURCE_MEM) {
 265                 dev->command |= PCI_COMMAND_MEMORY;
 266         }
 267         if (resource->flags & IORESOURCE_IO) {
 268                 dev->command |= PCI_COMMAND_IO;
 269         }
 270         if (resource->flags & IORESOURCE_PCI_BRIDGE) {
 271                 dev->command |= PCI_COMMAND_MASTER;
 272         }
 273
 274         /* Get the base address */
 275         base = resource->base;
 276
 277         /* Get the resource granularity */
 278         gran = 1UL << resource->gran;
 279
 280         /* For a non bridge resource granularity and alignment are the same.
 281          * For a bridge resource align is the largest needed alignment below
 282          * the bridge.  While the granularity is simply how many low bits of the
 283          * address cannot be set.
 284          */
 285
 286         /* Get the limit (rounded up) */
 287         limit = base + round(resource->size, gran) - 1UL;
 288
 289         /* Now store the resource */
 290         resource->flags |= IORESOURCE_STORED;
 291         if (!(resource->flags & IORESOURCE_PCI_BRIDGE)) {
 292                 /* some chipsets allow us to set/clear the IO bit.
 293                  * (e.g. VIA 82c686a.) So set it to be safe) */
 294                 limit = base + resource->size -1;
 295                 if (resource->flags & IORESOURCE_IO) {
 296                         base |= PCI_BASE_ADDRESS_SPACE_IO;
 297                 }
 298                 pci_write_config32(dev, resource->index, base & 0xffffffff);
 299                 if (resource->flags & IORESOURCE_PCI64) {
 300                         /* FIXME handle real 64bit base addresses */
 301                         pci_write_config32(dev, resource->index + 4, 0);
 302                 }
 303         } else if (resource->index == PCI_IO_BASE) {
 304                 /* set the IO ranges
 305                  * WARNING: we don't really do 32-bit addressing for IO yet!
 306                  */
 307                 compute_allocate_resource(&dev->link[0], resource,
 308                                           IORESOURCE_IO, IORESOURCE_IO);
 309                 pci_write_config8(dev, PCI_IO_BASE,  base >> 8);
 310                 pci_write_config8(dev, PCI_IO_LIMIT, limit >> 8);
 311                 pci_write_config16(dev, PCI_IO_BASE_UPPER16, 0);
 312                 pci_write_config16(dev, PCI_IO_LIMIT_UPPER16, 0);
 313         } else if (resource->index == PCI_MEMORY_BASE) {
 314                 /* set the memory range */
 315                 compute_allocate_resource(&dev->link[0], resource,
 316                                           IORESOURCE_MEM | IORESOURCE_PREFETCH,
 317                                           IORESOURCE_MEM);
 318                 pci_write_config16(dev, PCI_MEMORY_BASE, base >> 16);
 319                 pci_write_config16(dev, PCI_MEMORY_LIMIT, limit >> 16);
 320         } else if (resource->index == PCI_PREF_MEMORY_BASE) {
 321                 /* set the prefetchable memory range
 322                  * WARNING: we don't really do 64-bit addressing for
 323                  * prefetchable memory yet! */
 324                 compute_allocate_resource(&dev->link[0], resource,
 325                                           IORESOURCE_MEM | IORESOURCE_PREFETCH,
 326                                           IORESOURCE_MEM | IORESOURCE_PREFETCH);
 327                 pci_write_config16(dev, PCI_PREF_MEMORY_BASE,  base >> 16);
 328                 pci_write_config16(dev, PCI_PREF_MEMORY_LIMIT, limit >> 16);
 329                 pci_write_config32(dev, PCI_PREF_BASE_UPPER32, 0);
 330                 pci_write_config32(dev, PCI_PREF_LIMIT_UPPER32, 0);
 331         } else {
 332                 /* Don't let me think I stored the resource */
 333                 resource->flags &= ~IORESOURCE_STORED;
 334                 printk_err("ERROR: invalid resource->index %x\n",
 335                            resource->index);
 336         }
 337
 338         buf[0] = '\0';
 339         if (resource->flags & IORESOURCE_PCI_BRIDGE) {
 340                 sprintf(buf, "bus %d ", dev->link[0].secondary);
 341         }
 342         printk_debug("%s %02x <- [0x%08lx - 0x%08lx] %s%s\n",
 343                      dev_path(dev), resource->index, resource->base,
 344                      limit, buf,
 345                      (resource->flags & IORESOURCE_IO)? "io":
 346                      (resource->flags & IORESOURCE_PREFETCH)? "prefmem": "mem");
 347         return;
 348 }
 349
 350 void pci_dev_set_resources(struct device *dev)
 351 {
 352         struct resource *resource, *last;
 353         unsigned link;
 354         uint8_t line;
 355
 356         last = &dev->resource[dev->resources];
 357         for (resource = &dev->resource[0]; resource < last; resource++) {
 358                 pci_set_resource(dev, resource);
 359         }
 360
 361         for (link = 0; link < dev->links; link++) {
 362                 struct bus *bus;
 363                 bus = &dev->link[link];
 364                 if (bus->children) {
 365                         assign_resources(bus);
 366                 }
 367         }
 368
 369         /* set a default latency timer */
 370         pci_write_config8(dev, PCI_LATENCY_TIMER, 0x40);
 371
 372         /* set a default secondary latency timer */
 373         if ((dev->hdr_type & 0x7f) == PCI_HEADER_TYPE_BRIDGE) {
 374                 pci_write_config8(dev, PCI_SEC_LATENCY_TIMER, 0x40);
 375         }
 376
 377         /* zero the irq settings */
 378         line = pci_read_config8(dev, PCI_INTERRUPT_PIN);
 379         if (line) {
 380                 pci_write_config8(dev, PCI_INTERRUPT_LINE, 0);
 381         }
 382         /* set the cache line size, so far 64 bytes is good for everyone */
 383         pci_write_config8(dev, PCI_CACHE_LINE_SIZE, 64 >> 2);
 384 }
 385
 386 void pci_dev_enable_resources(struct device *dev)
 387 {
 388         uint16_t command;
 389         command = pci_read_config16(dev, PCI_COMMAND);
 390         command |= dev->command;
 391         command |= (PCI_COMMAND_PARITY + PCI_COMMAND_SERR); /* error check */
 392         printk_debug("%s cmd <- %02x\n", dev_path(dev), command);
 393         pci_write_config16(dev, PCI_COMMAND, command);
 394
 395         enable_childrens_resources(dev);
 396 }
 397
 398 void pci_bus_enable_resources(struct device *dev)
 399 {
 400         uint16_t ctrl;
 401         ctrl = pci_read_config16(dev, PCI_BRIDGE_CONTROL);
 402         ctrl |= dev->link[0].bridge_ctrl;
 403         ctrl |= (PCI_BRIDGE_CTL_PARITY + PCI_BRIDGE_CTL_SERR); /* error check */
 404         printk_debug("%s bridge ctrl <- %04x\n", dev_path(dev), ctrl);
 405         pci_write_config16(dev, PCI_BRIDGE_CONTROL, ctrl);
 406
 407         pci_dev_enable_resources(dev);
 408 }
 409
 410 /** Default device operation for PCI devices */
 411 struct device_operations default_pci_ops_dev = {
 412         .read_resources   = pci_dev_read_resources,
 413         .set_resources    = pci_dev_set_resources,
 414         .enable_resources = pci_dev_enable_resources,
 415         .init             = 0,
 416         .scan_bus         = 0,
 417 };
 418
 419 /** Default device operations for PCI bridges */
 420 struct device_operations default_pci_ops_bus = {
 421         .read_resources   = pci_bus_read_resources,
 422         .set_resources    = pci_dev_set_resources,
 423         .enable_resources = pci_bus_enable_resources,
 424         .init             = 0,
 425         .scan_bus         = pci_scan_bridge,
 426 };
 427
 428 /**
 429  * @brief Set up PCI device operation
 430  *
 431  *
 432  * @param dev
 433  *
 434  * @see pci_drivers
 435  */
 436 static void set_pci_ops(struct device *dev)
 437 {
 438         struct pci_driver *driver;
 439
 440         if (dev->ops) {
 441                 return;
 442         }
 443
 444         /* Look through the list of setup drivers and find one for
 445          * this pci device */
 446         for (driver = &pci_drivers[0]; driver != &epci_drivers[0]; driver++) {
 447                 if ((driver->vendor == dev->vendor) &&
 448                     (driver->device == dev->device)) {
 449                         dev->ops = driver->ops;
 450
 451                         printk_debug("%s [%04x/%04x] %sops\n", dev_path(dev),
 452                                      driver->vendor, driver->device,
 453                                      (driver->ops->scan_bus?"bus ":""));
 454
 455                         return;
 456                 }
 457         }
 458
 459 #if 0
 460         extern struct pci_driver generic_vga_driver;
 461         /* TODO: Install generic VGA driver for VGA devices, base on the
 462          * class ID */
 463         if ((dev->class >> 8)  == PCI_CLASS_DISPLAY_VGA) {
 464                 printk_debug("setting up generic VGA driver\n");
 465                 dev->ops = generic_vga_driver.ops;
 466                 return;
 467         }
 468 #endif
 469
 470         /* If I don't have a specific driver use the default operations */
 471         switch(dev->hdr_type & 0x7f) {  /* header type */
 472         case PCI_HEADER_TYPE_NORMAL:    /* standard header */
 473                 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)
 474                         goto bad;
 475                 dev->ops = &default_pci_ops_dev;
 476                 break;
 477         case PCI_HEADER_TYPE_BRIDGE:
 478                 if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI)
 479                         goto bad;
 480                 dev->ops = &default_pci_ops_bus;
 481                 break;
 482         default:
 483         bad:
 484                 if (dev->enabled) {
 485                         printk_err("%s [%04x/%04x/%06x] has unknown header "
 486                                    "type %02x, ignoring.\n",
 487                                    dev_path(dev),
 488                                    dev->vendor, dev->device,
 489                                    dev->class >> 8, dev->hdr_type);
 490                 }
 491         }
 492         return;
 493 }
 494
 495 /**
 496  * @brief Find a specific device structure on a list of device structures
 497  *
 498  * Given a linked list of PCI device structures and a devfn number, find the
 499  * device structure correspond to the devfn.
 500  *
 501  * @param list the device structure list
 502  * @param devfn a device/function number
 503  *
 504  * @return pointer to the device structure found
 505  */
 506 static struct device *pci_scan_get_dev(struct device **list,
 507                                        unsigned int devfn)
 508 {
 509         struct device *dev = 0;
 510
 511         printk_debug("%s, looking for devfn: %02x.%01x\n", __FUNCTION__,
 512                      devfn >> 3, devfn & 7);
 513         for (; *list; list = &(*list)->sibling) {
 514                 if ((*list)->path.type != DEVICE_PATH_PCI) {
 515                         printk_err("child %s not a pci device\n",
 516                                    dev_path(*list));
 517                         continue;
 518                 }
 519                 if ((*list)->path.u.pci.devfn == devfn) {
 520                         /* Unlink from the list */
 521                         dev = *list;
 522                         *list = (*list)->sibling;
 523                         dev->sibling = 0;
 524                         break;
 525                 }
 526         }
 527
 528         printk_debug("%s, found dev %08x\n", __FUNCTION__, dev);
 529
 530         /* FIXME: why are we doing this ? Isn't there some order between the
 531          * structures before ? */
 532         if (dev) {
 533                 device_t child;
 534                 /* Find the last child of our parent */
 535                 for (child = dev->bus->children; child && child->sibling; ) {
 536                         child = child->sibling;
 537                 }
 538                 /* Place the device on the list of children of it's parent. */
 539                 if (child) {
 540                         child->sibling = dev;
 541                 } else {
 542                         dev->bus->children = dev;
 543                 }
 544         }
 545
 546         return dev;
 547 }
 548
 549 /**
 550  * @brief Scan a PCI bus
 551  *
 552  * Determine the existence of devices and bridges on a PCI bus. If there are
 553  * bridges on the bus, recursively scan the buses behind the bridges.
 554  *
 555  * This function is the default scan_bus() method for the root device
 556  * 'dev_root'.
 557  *
 558  * @param bus pointer to the bus structure
 559  * @param min_devfn minimum devfn to look at in the scan usually 0x00
 560  * @param max_devfn maximum devfn to look at in the scan usually 0xff
 561  * @param max current bus number
 562  *
 563  * @return The maximum bus number found, after scanning all subordinate busses
 564  */
 565 unsigned int pci_scan_bus(struct bus *bus, unsigned min_devfn,
 566                           unsigned max_devfn, unsigned int max)
 567 {
 568         unsigned int devfn;
 569         device_t dev;
 570         device_t old_devices;
 571         device_t child;
 572
 573         printk_debug("PCI: pci_scan_bus for bus %d\n", bus->secondary);
 574
 575         old_devices = bus->children;
 576         bus->children = 0;
 577
 578         post_code(0x24);
 579
 580         /* probe all devices/functions on this bus with some optimization for
 581          * non-existence and single funcion devices */
 582         for (devfn = min_devfn; devfn <= max_devfn; devfn++) {
 583                 uint32_t id, class;
 584                 uint8_t hdr_type;
 585
 586                 /* device structures for PCI devices associated with static
 587                  * devices are already created during the static device
 588                  * enumeration, find out if it is the case for this devfn */
 589                 dev = pci_scan_get_dev(&old_devices, devfn);
 590
 591                 if (!dev) {
 592                         /* it's not associated with a static device, detect if
 593                          * this device is present */
 594                         struct device dummy;
 595                         dummy.bus              = bus;
 596                         dummy.path.type        = DEVICE_PATH_PCI;
 597                         dummy.path.u.pci.devfn = devfn;
 598                         id = pci_read_config32(&dummy, PCI_VENDOR_ID);
 599                         /* some broken boards return 0 if a slot is empty: */
 600                         if ((id == 0xffffffff) || (id == 0x00000000) ||
 601                             (id == 0x0000ffff) || (id == 0xffff0000)) {
 602                                 printk_spew("PCI: devfn 0x%x, bad id 0x%x\n",
 603                                             devfn, id);
 604                                 if (PCI_FUNC(devfn) == 0x00) {
 605                                         /* if this is a function 0 device and
 606                                          * it is not present, skip to next
 607                                          * device */
 608                                         devfn += 0x07;
 609                                 }
 610                                 /* this function in a multi function device is
 611                                  * not present, skip to next function */
 612                                 continue;
 613                         }
 614                         dev = alloc_dev(bus, &dummy.path);
 615                 } else {
 616                         /* Run the magic enable/disable sequence for the
 617                          * device */
 618                         /* FIXME: What happen if this PCI device listed as
 619                          * static device but does not exist ? This calls
 620                          * some arbitray code without any justification
 621                          * Also, it calls the enable function regardlessly
 622                          * the value of dev->enabled  */
 623                         if (dev->chip && dev->chip->control &&
 624                             dev->chip->control->enable_dev) {
 625                                 int enabled  = dev->enabled;
 626                                 dev->enabled = 1;
 627                                 dev->chip->control->enable_dev(dev);
 628                                 dev->enabled = enabled;
 629                         }
 630                         /* Now read the vendor and device id */
 631                         id = pci_read_config32(dev, PCI_VENDOR_ID);
 632                 }
 633                 /* Read the rest of the pci configuration information */
 634                 hdr_type = pci_read_config8(dev, PCI_HEADER_TYPE);
 635                 class = pci_read_config32(dev, PCI_CLASS_REVISION);
 636
 637                 /* Store the interesting information in the device structure */
 638                 dev->vendor = id & 0xffff;
 639                 dev->device = (id >> 16) & 0xffff;
 640                 dev->hdr_type = hdr_type;
 641                 /* class code, the upper 3 bytes of PCI_CLASS_REVISION */
 642                 dev->class = class >> 8;
 643
 644                 /* Look at the vendor and device id, or at least the
 645                  * header type and class and figure out which set of
 646                  * configuration methods to use.  Unless we already
 647                  * have some pci ops.
 648                  */
 649                 set_pci_ops(dev);
 650                 /* Error if we don't have some pci operations for it */
 651                 if (!dev->ops) {
 652                         printk_err("%s No device operations\n",
 653                                    dev_path(dev));
 654                         continue;
 655                 }
 656
 657                 /* Now run the magic enable/disable sequence for the device */
 658                 if (dev->ops && dev->ops->enable) {
 659                         dev->ops->enable(dev);
 660                 } else if (dev->chip && dev->chip->control &&
 661                            dev->chip->control->enable_dev) {
 662                         dev->chip->control->enable_dev(dev);
 663                 }
 664
 665                 printk_debug("%s [%04x/%04x] %s\n",
 666                              dev_path(dev),
 667                              dev->vendor, dev->device,
 668                              dev->enabled?"enabled": "disabled");
 669
 670                 if (PCI_FUNC(devfn) == 0x00 && (hdr_type & 0x80) != 0x80) {
 671                         /* if this is not a multi function device, don't
 672                          * waste time probe another function.
 673                          * Skip to next device. */
 674                         devfn += 0x07;
 675                 }
 676         }
 677         post_code(0x25);
 678
 679         /* if a child provides scan_bus(), for example a bridge, scan
 680          * buses behind that child */
 681         for (child = bus->children; child; child = child->sibling) {
 682                 // make sure that we have an ops structure
 683                 if (!child->ops) {
 684                         continue;
 685                 }
 686                 if (!child->ops->scan_bus) {
 687                         continue;
 688                 }
 689                 max = child->ops->scan_bus(child, max);
 690         }
 691
 692         /*
 693          * We've scanned the bus and so we know all about what's on
 694          * the other side of any bridges that may be on this bus plus
 695          * any devices.
 696          *
 697          * Return how far we've got finding sub-buses.
 698          */
 699         printk_debug("PCI: pci_scan_bus returning with max=%02x\n", max);
 700         post_code(0x55);
 701         return max;
 702 }
 703
 704 /**
 705  * @brief Scan a PCI bridge and the buses behind the bridge.
 706  *
 707  * Determine the existence of buses behind the bridge. Set up the bridge
 708  * according to the result of the scan.
 709  *
 710  * This function is the default scan_bus() method for PCI bridge devices.
 711  *
 712  * @param dev pointer to the bridge device
 713  * @param max the highest bus number assgined up to now
 714  *
 715  * @return The maximum bus number found, after scanning all subordinate busses
 716  */
 717 unsigned int pci_scan_bridge(struct device *dev, unsigned int max)
 718 {
 719         struct bus *bus;
 720         uint32_t buses;
 721         uint16_t cr;
 722
 723         bus = &dev->link[0];
 724         dev->links = 1;
 725
 726         /* Set up the primary, secondary and subordinate bus numbers. We have
 727          * no idea how many buses are behind this bridge yet, so we set the
 728          * subordinate bus number to 0xff for the moment. */
 729         bus->secondary = ++max;
 730         bus->subordinate = 0xff;
 731
 732         /* Clear all status bits and turn off memory, I/O and master enables. */
 733         cr = pci_read_config16(dev, PCI_COMMAND);
 734         pci_write_config16(dev, PCI_COMMAND, 0x0000);
 735         pci_write_config16(dev, PCI_STATUS, 0xffff);
 736
 737         /* Read the existing primary/secondary/subordinate bus
 738          * number configuration. */
 739         buses = pci_read_config32(dev, PCI_PRIMARY_BUS);
 740
 741         /* Configure the bus numbers for this bridge: the configuration
 742          * transactions will not be propagated by the bridge if it is not
 743          * correctly configured */
 744         buses &= 0xff000000;
 745         buses |= (((unsigned int) (dev->bus->secondary) << 0) |
 746                   ((unsigned int) (bus->secondary) << 8) |
 747                   ((unsigned int) (bus->subordinate) << 16));
 748         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 749
 750         /* Now we can scan all subordinate buses i.e. the buses behind the
 751          * bridge */
 752         max = pci_scan_bus(bus, 0x00, 0xff, max);
 753
 754         /* We know the number of buses behind this bridge. Set the subordinate
 755          * bus number to its real value */
 756         bus->subordinate = max;
 757         buses = (buses & 0xff00ffff) |
 758                 ((unsigned int) (bus->subordinate) << 16);
 759         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 760         pci_write_config16(dev, PCI_COMMAND, cr);
 761
 762         printk_spew("%s returns max %d\n", __FUNCTION__, max);
 763         return max;
 764 }
 765
 766 /*
 767     Tell the EISA int controller this int must be level triggered
 768     THIS IS A KLUDGE -- sorry, this needs to get cleaned up.
 769 */
 770 static void pci_level_irq(unsigned char intNum)
 771 {
 772         unsigned short intBits = inb(0x4d0) | (((unsigned) inb(0x4d1)) << 8);
 773
 774         printk_debug("%s: current ints are 0x%x\n", __FUNCTION__, intBits);
 775         intBits |= (1 << intNum);
 776
 777         printk_debug("%s: try to set ints 0x%x\n", __FUNCTION__, intBits);
 778
 779         // Write new values
 780         outb((unsigned char) intBits, 0x4d0);
 781         outb((unsigned char) (intBits >> 8), 0x4d1);
 782
 783         /* this seems like an error but is not ... */
 784 #if 1
 785         if (inb(0x4d0) != (intBits & 0xf)) {
 786           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 787                      __FUNCTION__, intBits &0xf, inb(0x4d0));
 788         }
 789         if (inb(0x4d1) != ((intBits >> 8) & 0xf)) {
 790           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 791                      __FUNCTION__, (intBits>>8) &0xf, inb(0x4d1));
 792         }
 793 #endif
 794 }
 795
 796 /*
 797     This function assigns IRQs for all functions contained within
 798     the indicated device address.  If the device does not exist or does
 799     not require interrupts then this function has no effect.
 800
 801     This function should be called for each PCI slot in your system.
 802
 803     pIntAtoD is an array of IRQ #s that are assigned to PINTA through PINTD of
 804     this slot.
 805     The particular irq #s that are passed in depend on the routing inside
 806     your southbridge and on your motherboard.
 807
 808     -kevinh@ispiri.com
 809 */
 810 void pci_assign_irqs(unsigned bus, unsigned slot,
 811         const unsigned char pIntAtoD[4])
 812 {
 813         unsigned functNum;
 814         device_t pdev;
 815         unsigned char line;
 816         unsigned char irq;
 817         unsigned char readback;
 818
 819         /* Each slot may contain up to eight functions */
 820         for (functNum = 0; functNum < 8; functNum++) {
 821                 pdev = dev_find_slot(bus, (slot << 3) + functNum);
 822
 823                 if (pdev) {
 824                   line = pci_read_config8(pdev, PCI_INTERRUPT_PIN);
 825
 826                         // PCI spec says all other values are reserved
 827                         if ((line >= 1) && (line <= 4)) {
 828                                 irq = pIntAtoD[line - 1];
 829
 830                                 printk_debug("Assigning IRQ %d to %d:%x.%d\n", \
 831                                         irq, bus, slot, functNum);
 832
 833                                 pci_write_config8(pdev, PCI_INTERRUPT_LINE,\
 834                                         pIntAtoD[line - 1]);
 835
 836                                 readback = pci_read_config8(pdev, PCI_INTERRUPT_LINE);
 837                                 printk_debug("  Readback = %d\n", readback);
 838
 839                                 // Change to level triggered
 840                                 pci_level_irq(pIntAtoD[line - 1]);
 841                         }
 842                 }
 843         }
 844 }