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                 if (!child->ops->scan_bus) {
 683                         continue;
 684                 }
 685                 max = child->ops->scan_bus(child, max);
 686         }
 687
 688         /*
 689          * We've scanned the bus and so we know all about what's on
 690          * the other side of any bridges that may be on this bus plus
 691          * any devices.
 692          *
 693          * Return how far we've got finding sub-buses.
 694          */
 695         printk_debug("PCI: pci_scan_bus returning with max=%02x\n", max);
 696         post_code(0x55);
 697         return max;
 698 }
 699
 700 /**
 701  * @brief Scan a PCI bridge and the buses behind the bridge.
 702  *
 703  * Determine the existence of buses behind the bridge. Set up the bridge
 704  * according to the result of the scan.
 705  *
 706  * This function is the default scan_bus() method for PCI bridge devices.
 707  *
 708  * @param dev pointer to the bridge device
 709  * @param max the highest bus number assgined up to now
 710  *
 711  * @return The maximum bus number found, after scanning all subordinate busses
 712  */
 713 unsigned int pci_scan_bridge(struct device *dev, unsigned int max)
 714 {
 715         struct bus *bus;
 716         uint32_t buses;
 717         uint16_t cr;
 718
 719         bus = &dev->link[0];
 720         dev->links = 1;
 721
 722         /* Set up the primary, secondary and subordinate bus numbers. We have
 723          * no idea how many buses are behind this bridge yet, so we set the
 724          * subordinate bus number to 0xff for the moment. */
 725         bus->secondary = ++max;
 726         bus->subordinate = 0xff;
 727
 728         /* Clear all status bits and turn off memory, I/O and master enables. */
 729         cr = pci_read_config16(dev, PCI_COMMAND);
 730         pci_write_config16(dev, PCI_COMMAND, 0x0000);
 731         pci_write_config16(dev, PCI_STATUS, 0xffff);
 732
 733         /* Read the existing primary/secondary/subordinate bus
 734          * number configuration. */
 735         buses = pci_read_config32(dev, PCI_PRIMARY_BUS);
 736
 737         /* Configure the bus numbers for this bridge: the configuration
 738          * transactions will not be propagated by the bridge if it is not
 739          * correctly configured */
 740         buses &= 0xff000000;
 741         buses |= (((unsigned int) (dev->bus->secondary) << 0) |
 742                   ((unsigned int) (bus->secondary) << 8) |
 743                   ((unsigned int) (bus->subordinate) << 16));
 744         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 745
 746         /* Now we can scan all subordinate buses i.e. the buses behind the
 747          * bridge */
 748         max = pci_scan_bus(bus, 0x00, 0xff, max);
 749
 750         /* We know the number of buses behind this bridge. Set the subordinate
 751          * bus number to its real value */
 752         bus->subordinate = max;
 753         buses = (buses & 0xff00ffff) |
 754                 ((unsigned int) (bus->subordinate) << 16);
 755         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 756         pci_write_config16(dev, PCI_COMMAND, cr);
 757
 758         printk_spew("%s returns max %d\n", __FUNCTION__, max);
 759         return max;
 760 }
 761
 762 /*
 763     Tell the EISA int controller this int must be level triggered
 764     THIS IS A KLUDGE -- sorry, this needs to get cleaned up.
 765 */
 766 static void pci_level_irq(unsigned char intNum)
 767 {
 768         unsigned short intBits = inb(0x4d0) | (((unsigned) inb(0x4d1)) << 8);
 769
 770         printk_spew("%s: current ints are 0x%x\n", __FUNCTION__, intBits);
 771         intBits |= (1 << intNum);
 772
 773         printk_spew("%s: try to set ints 0x%x\n", __FUNCTION__, intBits);
 774
 775         // Write new values
 776         outb((unsigned char) intBits, 0x4d0);
 777         outb((unsigned char) (intBits >> 8), 0x4d1);
 778
 779         /* this seems like an error but is not ... */
 780 #if 0
 781         if (inb(0x4d0) != (intBits & 0xf)) {
 782           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 783                      __FUNCTION__, intBits &0xf, inb(0x4d0));
 784         }
 785         if (inb(0x4d1) != ((intBits >> 8) & 0xf)) {
 786           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 787                      __FUNCTION__, (intBits>>8) &0xf, inb(0x4d1));
 788         }
 789 #endif
 790 }
 791
 792 /*
 793     This function assigns IRQs for all functions contained within
 794     the indicated device address.  If the device does not exist or does
 795     not require interrupts then this function has no effect.
 796
 797     This function should be called for each PCI slot in your system.
 798
 799     pIntAtoD is an array of IRQ #s that are assigned to PINTA through PINTD of
 800     this slot.
 801     The particular irq #s that are passed in depend on the routing inside
 802     your southbridge and on your motherboard.
 803
 804     -kevinh@ispiri.com
 805 */
 806 void pci_assign_irqs(unsigned bus, unsigned slot,
 807         const unsigned char pIntAtoD[4])
 808 {
 809         unsigned functNum;
 810         device_t pdev;
 811         unsigned char line;
 812         unsigned char irq;
 813         unsigned char readback;
 814
 815         /* Each slot may contain up to eight functions */
 816         for (functNum = 0; functNum < 8; functNum++) {
 817                 pdev = dev_find_slot(bus, (slot << 3) + functNum);
 818
 819                 if (pdev) {
 820                   line = pci_read_config8(pdev, PCI_INTERRUPT_PIN);
 821
 822                         // PCI spec says all other values are reserved
 823                         if ((line >= 1) && (line <= 4)) {
 824                                 irq = pIntAtoD[line - 1];
 825
 826                                 printk_debug("Assigning IRQ %d to %d:%x.%d\n", \
 827                                         irq, bus, slot, functNum);
 828
 829                                 pci_write_config8(pdev, PCI_INTERRUPT_LINE,\
 830                                         pIntAtoD[line - 1]);
 831
 832                                 readback = pci_read_config8(pdev, PCI_INTERRUPT_LINE);
 833                                 printk_debug("  Readback = %d\n", readback);
 834
 835                                 // Change to level triggered
 836                                 pci_level_irq(pIntAtoD[line - 1]);
 837                         }
 838                 }
 839         }
 840 }