src/devices/pci_device.c

   1 /*
   2  * This file is part of the coreboot project.
   3  *
   4  * It was originally based on the Linux kernel (drivers/pci/pci.c).
   5  *
   6  * Modifications are:
   7  * Copyright (C) 2003-2004 Linux Networx
   8  * (Written by Eric Biederman <ebiederman@lnxi.com> for Linux Networx)
   9  * Copyright (C) 2003-2006 Ronald G. Minnich <rminnich@gmail.com>
  10  * Copyright (C) 2004-2005 Li-Ta Lo <ollie@lanl.gov>
  11  * Copyright (C) 2005-2006 Tyan
  12  * (Written by Yinghai Lu <yhlu@tyan.com> for Tyan)
  13  * Copyright (C) 2005-2007 Stefan Reinauer <stepan@openbios.org>
  14  */
  15
  16 /*
  17  *      PCI Bus Services, see include/linux/pci.h for further explanation.
  18  *
  19  *      Copyright 1993 -- 1997 Drew Eckhardt, Frederic Potter,
  20  *      David Mosberger-Tang
  21  *
  22  *      Copyright 1997 -- 1999 Martin Mares <mj@atrey.karlin.mff.cuni.cz>
  23  */
  24
  25 #include <console/console.h>
  26 #include <stdlib.h>
  27 #include <stdint.h>
  28 #include <bitops.h>
  29 #include <string.h>
  30 #include <arch/io.h>
  31 #include <device/device.h>
  32 #include <device/pci.h>
  33 #include <device/pci_ids.h>
  34 #include <part/hard_reset.h>
  35 #include <part/fallback_boot.h>
  36 #include <delay.h>
  37 #if CONFIG_HYPERTRANSPORT_PLUGIN_SUPPORT == 1
  38 #include <device/hypertransport.h>
  39 #endif
  40 #if CONFIG_PCIX_PLUGIN_SUPPORT == 1
  41 #include <device/pcix.h>
  42 #endif
  43 #if CONFIG_PCIEXP_PLUGIN_SUPPORT == 1
  44 #include <device/pciexp.h>
  45 #endif
  46 #if CONFGI_AGP_PLUGIN_SUPPORT == 1
  47 #include <device/agp.h>
  48 #endif
  49 #if CONFIG_CARDBUS_PLUGIN_SUPPORT == 1
  50 #include <device/cardbus.h>
  51 #endif
  52
  53 uint8_t pci_moving_config8(struct device *dev, unsigned reg)
  54 {
  55         uint8_t value, ones, zeroes;
  56         value = pci_read_config8(dev, reg);
  57
  58         pci_write_config8(dev, reg, 0xff);
  59         ones = pci_read_config8(dev, reg);
  60
  61         pci_write_config8(dev, reg, 0x00);
  62         zeroes = pci_read_config8(dev, reg);
  63
  64         pci_write_config8(dev, reg, value);
  65
  66         return ones ^ zeroes;
  67 }
  68
  69 uint16_t pci_moving_config16(struct device *dev, unsigned reg)
  70 {
  71         uint16_t value, ones, zeroes;
  72         value = pci_read_config16(dev, reg);
  73
  74         pci_write_config16(dev, reg, 0xffff);
  75         ones = pci_read_config16(dev, reg);
  76
  77         pci_write_config16(dev, reg, 0x0000);
  78         zeroes = pci_read_config16(dev, reg);
  79
  80         pci_write_config16(dev, reg, value);
  81
  82         return ones ^ zeroes;
  83 }
  84
  85 uint32_t pci_moving_config32(struct device *dev, unsigned reg)
  86 {
  87         uint32_t value, ones, zeroes;
  88         value = pci_read_config32(dev, reg);
  89
  90         pci_write_config32(dev, reg, 0xffffffff);
  91         ones = pci_read_config32(dev, reg);
  92
  93         pci_write_config32(dev, reg, 0x00000000);
  94         zeroes = pci_read_config32(dev, reg);
  95
  96         pci_write_config32(dev, reg, value);
  97
  98         return ones ^ zeroes;
  99 }
 100
 101 unsigned pci_find_next_capability(device_t dev, unsigned cap, unsigned last)
 102 {
 103         unsigned pos;
 104         unsigned status;
 105         unsigned reps = 48;
 106         pos = 0;
 107         status = pci_read_config16(dev, PCI_STATUS);
 108         if (!(status & PCI_STATUS_CAP_LIST)) {
 109                 return 0;
 110         }
 111         switch(dev->hdr_type & 0x7f) {
 112         case PCI_HEADER_TYPE_NORMAL:
 113         case PCI_HEADER_TYPE_BRIDGE:
 114                 pos = PCI_CAPABILITY_LIST;
 115                 break;
 116         case PCI_HEADER_TYPE_CARDBUS:
 117                 pos = PCI_CB_CAPABILITY_LIST;
 118                 break;
 119         default:
 120                 return 0;
 121         }
 122         pos = pci_read_config8(dev, pos);
 123         while(reps-- && (pos >= 0x40)) {   /* loop through the linked list */
 124                 int this_cap;
 125                 pos &= ~3;
 126                 this_cap = pci_read_config8(dev, pos + PCI_CAP_LIST_ID);
 127                 printk_spew("Capability: 0x%02x @ 0x%02x\n", cap, pos);
 128                 if (this_cap == 0xff) {
 129                         break;
 130                 }
 131                 if (!last && (this_cap == cap)) {
 132                         return pos;
 133                 }
 134                 if (last == pos) {
 135                         last = 0;
 136                 }
 137                 pos = pci_read_config8(dev, pos + PCI_CAP_LIST_NEXT);
 138         }
 139         return 0;
 140 }
 141
 142 unsigned pci_find_capability(device_t dev, unsigned cap)
 143 {
 144         return pci_find_next_capability(dev, cap, 0);
 145
 146 }
 147
 148 /** Given a device and register, read the size of the BAR for that register.
 149  * @param dev       Pointer to the device structure
 150  * @param resource  Pointer to the resource structure
 151  * @param index     Address of the pci configuration register
 152  */
 153 struct resource *pci_get_resource(struct device *dev, unsigned long index)
 154 {
 155         struct resource *resource;
 156         unsigned long value, attr;
 157         resource_t  moving, limit;
 158
 159         /* Initialize the resources to nothing */
 160         resource = new_resource(dev, index);
 161
 162         /* Get the initial value */
 163         value = pci_read_config32(dev, index);
 164
 165         /* See which bits move */
 166         moving = pci_moving_config32(dev, index);
 167
 168         /* Initialize attr to the bits that do not move */
 169         attr = value & ~moving;
 170
 171         /* If it is a 64bit resource look at the high half as well */
 172         if (((attr & PCI_BASE_ADDRESS_SPACE_IO) == 0) &&
 173                 ((attr & PCI_BASE_ADDRESS_MEM_LIMIT_MASK) == PCI_BASE_ADDRESS_MEM_LIMIT_64))
 174         {
 175                 /* Find the high bits that move */
 176                 moving |= ((resource_t)pci_moving_config32(dev, index + 4)) << 32;
 177         }
 178         /* Find the resource constraints.
 179          *
 180          * Start by finding the bits that move. From there:
 181          * - Size is the least significant bit of the bits that move.
 182          * - Limit is all of the bits that move plus all of the lower bits.
 183          * See PCI Spec 6.2.5.1 ...
 184          */
 185         limit = 0;
 186         if (moving) {
 187                 resource->size = 1;
 188                 resource->align = resource->gran = 0;
 189                 while(!(moving & resource->size)) {
 190                         resource->size <<= 1;
 191                         resource->align += 1;
 192                         resource->gran  += 1;
 193                 }
 194                 resource->limit = limit = moving | (resource->size - 1);
 195         }
 196         /*
 197          * some broken hardware has read-only registers that do not
 198          * really size correctly.
 199          * Example: the acer m7229 has BARs 1-4 normally read-only.
 200          * so BAR1 at offset 0x10 reads 0x1f1. If you size that register
 201          * by writing 0xffffffff to it, it will read back as 0x1f1 -- a
 202          * violation of the spec.
 203          * We catch this case and ignore it by observing which bits move,
 204          * This also catches the common case unimplemented registers
 205          * that always read back as 0.
 206          */
 207         if (moving == 0) {
 208                 if (value != 0) {
 209                         printk_debug(
 210                                 "%s register %02x(%08x), read-only ignoring it\n",
 211                                 dev_path(dev), index, value);
 212                 }
 213                 resource->flags = 0;
 214         }
 215         else if (attr & PCI_BASE_ADDRESS_SPACE_IO) {
 216                 /* An I/O mapped base address */
 217                 attr &= PCI_BASE_ADDRESS_IO_ATTR_MASK;
 218                 resource->flags |= IORESOURCE_IO;
 219                 /* I don't want to deal with 32bit I/O resources */
 220                 resource->limit = 0xffff;
 221         }
 222         else {
 223                 /* A Memory mapped base address */
 224                 attr &= PCI_BASE_ADDRESS_MEM_ATTR_MASK;
 225                 resource->flags |= IORESOURCE_MEM;
 226                 if (attr & PCI_BASE_ADDRESS_MEM_PREFETCH) {
 227                         resource->flags |= IORESOURCE_PREFETCH;
 228                 }
 229                 attr &= PCI_BASE_ADDRESS_MEM_LIMIT_MASK;
 230                 if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_32) {
 231                         /* 32bit limit */
 232                         resource->limit = 0xffffffffUL;
 233                 }
 234                 else if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_1M) {
 235                         /* 1MB limit */
 236                         resource->limit = 0x000fffffUL;
 237                 }
 238                 else if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_64) {
 239                         /* 64bit limit */
 240                         resource->limit = 0xffffffffffffffffULL;
 241                         resource->flags |= IORESOURCE_PCI64;
 242                 }
 243                 else {
 244                         /* Invalid value */
 245                         resource->flags = 0;
 246                 }
 247         }
 248         /* Don't let the limit exceed which bits can move */
 249         if (resource->limit > limit) {
 250                 resource->limit = limit;
 251         }
 252 #if 0
 253         if (resource->flags) {
 254                 printk_debug("%s %02x ->",
 255                         dev_path(dev), resource->index);
 256                 printk_debug(" value: 0x%08Lx zeroes: 0x%08Lx ones: 0x%08Lx attr: %08lx\n",
 257                         value, zeroes, ones, attr);
 258                 printk_debug(
 259                         "%s %02x -> size: 0x%08Lx max: 0x%08Lx %s\n ",
 260                         dev_path(dev),
 261                         resource->index,
 262                         resource->size, resource->limit,
 263                         resource_type(resource));
 264         }
 265 #endif
 266
 267         return resource;
 268 }
 269
 270 static void pci_get_rom_resource(struct device *dev, unsigned long index)
 271 {
 272         struct resource *resource;
 273         unsigned long value;
 274         resource_t  moving, limit;
 275
 276         if ((dev->on_mainboard) && (dev->rom_address == 0)) {
 277                 //skip it if rom_address is not set in MB Config.lb
 278                 return;
 279         }
 280
 281         /* Initialize the resources to nothing */
 282         resource = new_resource(dev, index);
 283
 284         /* Get the initial value */
 285         value = pci_read_config32(dev, index);
 286
 287         /* See which bits move */
 288         moving = pci_moving_config32(dev, index);
 289         /* clear the Enable bit */
 290         moving = moving & ~PCI_ROM_ADDRESS_ENABLE;
 291
 292         /* Find the resource constraints.
 293          *
 294          * Start by finding the bits that move. From there:
 295          * - Size is the least significant bit of the bits that move.
 296          * - Limit is all of the bits that move plus all of the lower bits.
 297          * See PCI Spec 6.2.5.1 ...
 298          */
 299         limit = 0;
 300
 301         if (moving) {
 302                 resource->size = 1;
 303                 resource->align = resource->gran = 0;
 304                 while (!(moving & resource->size)) {
 305                         resource->size <<= 1;
 306                         resource->align += 1;
 307                         resource->gran  += 1;
 308                 }
 309                 resource->limit = limit = moving | (resource->size - 1);
 310         }
 311
 312         if (moving == 0) {
 313                 if (value != 0) {
 314                         printk_debug("%s register %02x(%08x), read-only ignoring it\n",
 315                                      dev_path(dev), index, value);
 316                 }
 317                 resource->flags = 0;
 318         } else {
 319                 resource->flags |= IORESOURCE_MEM | IORESOURCE_READONLY;
 320         }
 321
 322         /* for on board device with embedded ROM image, the ROM image is at
 323          * fixed address specified in the Config.lb, the dev->rom_address is
 324          * inited by driver_pci_onboard_ops::enable_dev() */
 325         if ((dev->on_mainboard) && (dev->rom_address != 0)) {
 326                 resource->base   = dev->rom_address;
 327                 resource->flags |= IORESOURCE_MEM | IORESOURCE_READONLY |
 328                         IORESOURCE_ASSIGNED | IORESOURCE_FIXED;
 329         }
 330
 331         compact_resources(dev);
 332 }
 333
 334 /** Read the base address registers for a given device.
 335  * @param dev Pointer to the dev structure
 336  * @param howmany How many registers to read (6 for device, 2 for bridge)
 337  */
 338 static void pci_read_bases(struct device *dev, unsigned int howmany)
 339 {
 340         unsigned long index;
 341
 342         for(index = PCI_BASE_ADDRESS_0; (index < PCI_BASE_ADDRESS_0 + (howmany << 2)); ) {
 343                 struct resource *resource;
 344                 resource = pci_get_resource(dev, index);
 345                 index += (resource->flags & IORESOURCE_PCI64)?8:4;
 346         }
 347
 348         compact_resources(dev);
 349 }
 350
 351 static void pci_set_resource(struct device *dev, struct resource *resource);
 352
 353 static void pci_record_bridge_resource(
 354         struct device *dev, resource_t moving,
 355         unsigned index, unsigned long mask, unsigned long type)
 356 {
 357         /* Initiliaze the constraints on the current bus */
 358         struct resource *resource;
 359         resource = 0;
 360         if (moving) {
 361                 unsigned long gran;
 362                 resource_t step;
 363                 resource = new_resource(dev, index);
 364                 resource->size = 0;
 365                 gran = 0;
 366                 step = 1;
 367                 while((moving & step) == 0) {
 368                         gran += 1;
 369                         step <<= 1;
 370                 }
 371                 resource->gran = gran;
 372                 resource->align = gran;
 373                 resource->limit = moving | (step - 1);
 374                 resource->flags = type | IORESOURCE_PCI_BRIDGE;
 375                 compute_allocate_resource(&dev->link[0], resource, mask, type);
 376                 /* If there is nothing behind the resource,
 377                  * clear it and forget it.
 378                  */
 379                 if (resource->size == 0) {
 380                         resource->base = moving;
 381                         resource->flags |= IORESOURCE_ASSIGNED;
 382                         resource->flags &= ~IORESOURCE_STORED;
 383                         pci_set_resource(dev, resource);
 384                         resource->flags = 0;
 385                 }
 386         }
 387         return;
 388 }
 389
 390 static void pci_bridge_read_bases(struct device *dev)
 391 {
 392         resource_t moving_base, moving_limit, moving;
 393
 394         /* See if the bridge I/O resources are implemented */
 395         moving_base = ((uint32_t)pci_moving_config8(dev, PCI_IO_BASE)) << 8;
 396         moving_base |= ((uint32_t)pci_moving_config16(dev, PCI_IO_BASE_UPPER16)) << 16;
 397
 398         moving_limit = ((uint32_t)pci_moving_config8(dev, PCI_IO_LIMIT)) << 8;
 399         moving_limit |= ((uint32_t)pci_moving_config16(dev, PCI_IO_LIMIT_UPPER16)) << 16;
 400
 401         moving = moving_base & moving_limit;
 402
 403         /* Initialize the io space constraints on the current bus */
 404         pci_record_bridge_resource(
 405                 dev, moving, PCI_IO_BASE,
 406                 IORESOURCE_IO, IORESOURCE_IO);
 407
 408
 409         /* See if the bridge prefmem resources are implemented */
 410         moving_base =  ((resource_t)pci_moving_config16(dev, PCI_PREF_MEMORY_BASE)) << 16;
 411         moving_base |= ((resource_t)pci_moving_config32(dev, PCI_PREF_BASE_UPPER32)) << 32;
 412
 413         moving_limit =  ((resource_t)pci_moving_config16(dev, PCI_PREF_MEMORY_LIMIT)) << 16;
 414         moving_limit |= ((resource_t)pci_moving_config32(dev, PCI_PREF_LIMIT_UPPER32)) << 32;
 415
 416         moving = moving_base & moving_limit;
 417         /* Initiliaze the prefetchable memory constraints on the current bus */
 418         pci_record_bridge_resource(
 419                 dev, moving, PCI_PREF_MEMORY_BASE,
 420                 IORESOURCE_MEM | IORESOURCE_PREFETCH,
 421                 IORESOURCE_MEM | IORESOURCE_PREFETCH);
 422
 423
 424         /* See if the bridge mem resources are implemented */
 425         moving_base = ((uint32_t)pci_moving_config16(dev, PCI_MEMORY_BASE)) << 16;
 426         moving_limit = ((uint32_t)pci_moving_config16(dev, PCI_MEMORY_LIMIT)) << 16;
 427
 428         moving = moving_base & moving_limit;
 429
 430         /* Initialize the memory resources on the current bus */
 431         pci_record_bridge_resource(
 432                 dev, moving, PCI_MEMORY_BASE,
 433                 IORESOURCE_MEM | IORESOURCE_PREFETCH,
 434                 IORESOURCE_MEM);
 435
 436         compact_resources(dev);
 437 }
 438
 439 void pci_dev_read_resources(struct device *dev)
 440 {
 441         pci_read_bases(dev, 6);
 442         pci_get_rom_resource(dev, PCI_ROM_ADDRESS);
 443 }
 444
 445 void pci_bus_read_resources(struct device *dev)
 446 {
 447         pci_bridge_read_bases(dev);
 448         pci_read_bases(dev, 2);
 449         pci_get_rom_resource(dev, PCI_ROM_ADDRESS1);
 450 }
 451
 452 static void pci_set_resource(struct device *dev, struct resource *resource)
 453 {
 454         resource_t base, end;
 455
 456         /* Make certain the resource has actually been set */
 457         if (!(resource->flags & IORESOURCE_ASSIGNED)) {
 458                 printk_err("ERROR: %s %02x %s size: 0x%010Lx not assigned\n",
 459                         dev_path(dev), resource->index,
 460                         resource_type(resource),
 461                         resource->size);
 462                 return;
 463         }
 464
 465         /* If I have already stored this resource don't worry about it */
 466         if (resource->flags & IORESOURCE_STORED) {
 467                 return;
 468         }
 469
 470         /* If the resources is substractive don't worry about it */
 471         if (resource->flags & IORESOURCE_SUBTRACTIVE) {
 472                 return;
 473         }
 474
 475         /* Only handle PCI memory and IO resources for now */
 476         if (!(resource->flags & (IORESOURCE_MEM |IORESOURCE_IO)))
 477                 return;
 478
 479         /* Enable the resources in the command register */
 480         if (resource->size) {
 481                 if (resource->flags & IORESOURCE_MEM) {
 482                         dev->command |= PCI_COMMAND_MEMORY;
 483                 }
 484                 if (resource->flags & IORESOURCE_IO) {
 485                         dev->command |= PCI_COMMAND_IO;
 486                 }
 487                 if (resource->flags & IORESOURCE_PCI_BRIDGE) {
 488                         dev->command |= PCI_COMMAND_MASTER;
 489                 }
 490         }
 491         /* Get the base address */
 492         base = resource->base;
 493
 494         /* Get the end */
 495         end = resource_end(resource);
 496
 497         /* Now store the resource */
 498         resource->flags |= IORESOURCE_STORED;
 499         if (!(resource->flags & IORESOURCE_PCI_BRIDGE)) {
 500                 unsigned long base_lo, base_hi;
 501                 /*
 502                  * some chipsets allow us to set/clear the IO bit.
 503                  * (e.g. VIA 82c686a.) So set it to be safe)
 504                  */
 505                 base_lo = base & 0xffffffff;
 506                 base_hi = (base >> 32) & 0xffffffff;
 507                 if (resource->flags & IORESOURCE_IO) {
 508                         base_lo |= PCI_BASE_ADDRESS_SPACE_IO;
 509                 }
 510                 pci_write_config32(dev, resource->index, base_lo);
 511                 if (resource->flags & IORESOURCE_PCI64) {
 512                         pci_write_config32(dev, resource->index + 4, base_hi);
 513                 }
 514         }
 515         else if (resource->index == PCI_IO_BASE) {
 516                 /* set the IO ranges */
 517                 compute_allocate_resource(&dev->link[0], resource,
 518                         IORESOURCE_IO, IORESOURCE_IO);
 519                 pci_write_config8(dev,  PCI_IO_BASE, base >> 8);
 520                 pci_write_config16(dev, PCI_IO_BASE_UPPER16, base >> 16);
 521                 pci_write_config8(dev,  PCI_IO_LIMIT, end >> 8);
 522                 pci_write_config16(dev, PCI_IO_LIMIT_UPPER16, end >> 16);
 523         }
 524         else if (resource->index == PCI_MEMORY_BASE) {
 525                 /* set the memory range  */
 526                 compute_allocate_resource(&dev->link[0], resource,
 527                         IORESOURCE_MEM | IORESOURCE_PREFETCH,
 528                         IORESOURCE_MEM);
 529                 pci_write_config16(dev, PCI_MEMORY_BASE, base >> 16);
 530                 pci_write_config16(dev, PCI_MEMORY_LIMIT, end >> 16);
 531         }
 532         else if (resource->index == PCI_PREF_MEMORY_BASE) {
 533                 /* set the prefetchable memory range */
 534                 compute_allocate_resource(&dev->link[0], resource,
 535                         IORESOURCE_MEM | IORESOURCE_PREFETCH,
 536                         IORESOURCE_MEM | IORESOURCE_PREFETCH);
 537                 pci_write_config16(dev, PCI_PREF_MEMORY_BASE, base >> 16);
 538                 pci_write_config32(dev, PCI_PREF_BASE_UPPER32, base >> 32);
 539                 pci_write_config16(dev, PCI_PREF_MEMORY_LIMIT, end >> 16);
 540                 pci_write_config32(dev, PCI_PREF_LIMIT_UPPER32, end >> 32);
 541         }
 542         else {
 543                 /* Don't let me think I stored the resource */
 544                 resource->flags &= ~IORESOURCE_STORED;
 545                 printk_err("ERROR: invalid resource->index %x\n",
 546                         resource->index);
 547         }
 548         report_resource_stored(dev, resource, "");
 549         return;
 550 }
 551
 552 void pci_dev_set_resources(struct device *dev)
 553 {
 554         struct resource *resource, *last;
 555         unsigned link;
 556         uint8_t line;
 557
 558         last = &dev->resource[dev->resources];
 559
 560         for(resource = &dev->resource[0]; resource < last; resource++) {
 561                 pci_set_resource(dev, resource);
 562         }
 563         for(link = 0; link < dev->links; link++) {
 564                 struct bus *bus;
 565                 bus = &dev->link[link];
 566                 if (bus->children) {
 567                         assign_resources(bus);
 568                 }
 569         }
 570
 571         /* set a default latency timer */
 572         pci_write_config8(dev, PCI_LATENCY_TIMER, 0x40);
 573
 574         /* set a default secondary latency timer */
 575         if ((dev->hdr_type & 0x7f) == PCI_HEADER_TYPE_BRIDGE) {
 576                 pci_write_config8(dev, PCI_SEC_LATENCY_TIMER, 0x40);
 577         }
 578
 579         /* zero the irq settings */
 580         line = pci_read_config8(dev, PCI_INTERRUPT_PIN);
 581         if (line) {
 582                 pci_write_config8(dev, PCI_INTERRUPT_LINE, 0);
 583         }
 584         /* set the cache line size, so far 64 bytes is good for everyone */
 585         pci_write_config8(dev, PCI_CACHE_LINE_SIZE, 64 >> 2);
 586 }
 587
 588 void pci_dev_enable_resources(struct device *dev)
 589 {
 590         const struct pci_operations *ops;
 591         uint16_t command;
 592
 593         /* Set the subsystem vendor and device id for mainboard devices */
 594         ops = ops_pci(dev);
 595         if (dev->on_mainboard && ops && ops->set_subsystem) {
 596                 printk_debug("%s subsystem <- %02x/%02x\n",
 597                         dev_path(dev),
 598                         MAINBOARD_PCI_SUBSYSTEM_VENDOR_ID,
 599                         MAINBOARD_PCI_SUBSYSTEM_DEVICE_ID);
 600                 ops->set_subsystem(dev,
 601                         MAINBOARD_PCI_SUBSYSTEM_VENDOR_ID,
 602                         MAINBOARD_PCI_SUBSYSTEM_DEVICE_ID);
 603         }
 604         command = pci_read_config16(dev, PCI_COMMAND);
 605         command |= dev->command;
 606         printk_debug("%s cmd <- %02x\n", dev_path(dev), command);
 607         pci_write_config16(dev, PCI_COMMAND, command);
 608 }
 609
 610 void pci_bus_enable_resources(struct device *dev)
 611 {
 612         uint16_t ctrl;
 613         /* enable IO in command register if there is VGA card
 614          * connected with (even it does not claim IO resource) */
 615         if (dev->link[0].bridge_ctrl & PCI_BRIDGE_CTL_VGA)
 616                 dev->command |= PCI_COMMAND_IO;
 617         ctrl = pci_read_config16(dev, PCI_BRIDGE_CONTROL);
 618         ctrl |= dev->link[0].bridge_ctrl;
 619         ctrl |= (PCI_BRIDGE_CTL_PARITY + PCI_BRIDGE_CTL_SERR); /* error check */
 620         printk_debug("%s bridge ctrl <- %04x\n", dev_path(dev), ctrl);
 621         pci_write_config16(dev, PCI_BRIDGE_CONTROL, ctrl);
 622
 623         pci_dev_enable_resources(dev);
 624
 625         enable_childrens_resources(dev);
 626 }
 627
 628 void pci_bus_reset(struct bus *bus)
 629 {
 630         unsigned ctl;
 631         ctl = pci_read_config16(bus->dev, PCI_BRIDGE_CONTROL);
 632         ctl |= PCI_BRIDGE_CTL_BUS_RESET;
 633         pci_write_config16(bus->dev, PCI_BRIDGE_CONTROL, ctl);
 634         mdelay(10);
 635         ctl &= ~PCI_BRIDGE_CTL_BUS_RESET;
 636         pci_write_config16(bus->dev, PCI_BRIDGE_CONTROL, ctl);
 637         delay(1);
 638 }
 639
 640 void pci_dev_set_subsystem(device_t dev, unsigned vendor, unsigned device)
 641 {
 642         pci_write_config32(dev, PCI_SUBSYSTEM_VENDOR_ID,
 643                 ((device & 0xffff) << 16) | (vendor & 0xffff));
 644 }
 645
 646 /** default handler: only runs the relevant pci bios. */
 647 void pci_dev_init(struct device *dev)
 648 {
 649 #if CONFIG_PCI_ROM_RUN == 1 || CONFIG_VGA_ROM_RUN == 1
 650         void run_bios(struct device * dev, unsigned long addr);
 651         struct rom_header *rom, *ram;
 652
 653 #if CONFIG_PCI_ROM_RUN != 1
 654         /* We want to execute VGA option ROMs when CONFIG_VGA_ROM_RUN
 655          * is set but CONFIG_PCI_ROM_RUN is not. In this case we skip
 656          * all other option ROM types.
 657          */
 658         if ((dev->class>>8)!=PCI_CLASS_DISPLAY_VGA)
 659                 return;
 660 #endif
 661
 662         rom = pci_rom_probe(dev);
 663         if (rom == NULL)
 664                 return;
 665
 666         ram = pci_rom_load(dev, rom);
 667         if (ram == NULL)
 668                 return;
 669
 670         run_bios(dev, (unsigned long)ram);
 671
 672 #if CONFIG_CONSOLE_VGA == 1
 673         /* vga_inited is a trigger of the VGA console code. */
 674         if ((dev->class>>8) == PCI_CLASS_DISPLAY_VGA) {
 675             extern int vga_inited;
 676             vga_inited = 1;
 677         }
 678 #endif /* CONFIG_CONSOLE_VGA */
 679 #endif /* CONFIG_PCI_ROM_RUN || CONFIG_VGA_ROM_RUN */
 680 }
 681
 682 /** Default device operation for PCI devices */
 683 static struct pci_operations pci_dev_ops_pci = {
 684         .set_subsystem = pci_dev_set_subsystem,
 685 };
 686
 687 struct device_operations default_pci_ops_dev = {
 688         .read_resources   = pci_dev_read_resources,
 689         .set_resources    = pci_dev_set_resources,
 690         .enable_resources = pci_dev_enable_resources,
 691         .init             = pci_dev_init,
 692         .scan_bus         = 0,
 693         .enable           = 0,
 694         .ops_pci          = &pci_dev_ops_pci,
 695 };
 696
 697 /** Default device operations for PCI bridges */
 698 static struct pci_operations pci_bus_ops_pci = {
 699         .set_subsystem = 0,
 700 };
 701
 702 struct device_operations default_pci_ops_bus = {
 703         .read_resources   = pci_bus_read_resources,
 704         .set_resources    = pci_dev_set_resources,
 705         .enable_resources = pci_bus_enable_resources,
 706         .init             = 0,
 707         .scan_bus         = pci_scan_bridge,
 708         .enable           = 0,
 709         .reset_bus        = pci_bus_reset,
 710         .ops_pci          = &pci_bus_ops_pci,
 711 };
 712
 713 /**
 714  * @brief Detect the type of downstream bridge
 715  *
 716  * This function is a heuristic to detect which type
 717  * of bus is downstream of a pci to pci bridge.  This
 718  * functions by looking for various capability blocks
 719  * to figure out the type of downstream bridge.  PCI-X
 720  * PCI-E, and Hypertransport all seem to have appropriate
 721  * capabilities.
 722  *
 723  * When only a PCI-Express capability is found the type
 724  * is examined to see which type of bridge we have.
 725  *
 726  * @param dev
 727  *
 728  * @return appropriate bridge operations
 729  */
 730 static struct device_operations *get_pci_bridge_ops(device_t dev)
 731 {
 732         unsigned pos;
 733
 734 #if CONFIG_PCIX_PLUGIN_SUPPORT == 1
 735         pos = pci_find_capability(dev, PCI_CAP_ID_PCIX);
 736         if (pos) {
 737                 printk_debug("%s subbordinate bus PCI-X\n", dev_path(dev));
 738                 return &default_pcix_ops_bus;
 739         }
 740 #endif
 741 #if CONFIG_AGP_PLUGIN_SUPPORT == 1
 742         /* How do I detect an PCI to AGP bridge? */
 743 #endif
 744 #if CONFIG_HYPERTRANSPORT_PLUGIN_SUPPORT == 1
 745         pos = 0;
 746         while((pos = pci_find_next_capability(dev, PCI_CAP_ID_HT, pos))) {
 747                 unsigned flags;
 748                 flags = pci_read_config16(dev, pos + PCI_CAP_FLAGS);
 749                 if ((flags >> 13) == 1) {
 750                         /* Host or Secondary Interface */
 751                         printk_debug("%s subbordinate bus Hypertransport\n",
 752                                 dev_path(dev));
 753                         return &default_ht_ops_bus;
 754                 }
 755         }
 756 #endif
 757 #if CONFIG_PCIEXP_PLUGIN_SUPPORT == 1
 758         pos = pci_find_capability(dev, PCI_CAP_ID_PCIE);
 759         if (pos) {
 760                 unsigned flags;
 761                 flags = pci_read_config16(dev, pos + PCI_EXP_FLAGS);
 762                 switch((flags & PCI_EXP_FLAGS_TYPE) >> 4) {
 763                 case PCI_EXP_TYPE_ROOT_PORT:
 764                 case PCI_EXP_TYPE_UPSTREAM:
 765                 case PCI_EXP_TYPE_DOWNSTREAM:
 766                         printk_debug("%s subbordinate bus PCI Express\n",
 767                                 dev_path(dev));
 768                         return &default_pciexp_ops_bus;
 769                 case PCI_EXP_TYPE_PCI_BRIDGE:
 770                         printk_debug("%s subbordinate PCI\n",
 771                                 dev_path(dev));
 772                         return &default_pci_ops_bus;
 773                 default:
 774                         break;
 775                 }
 776         }
 777 #endif
 778         return &default_pci_ops_bus;
 779 }
 780
 781 /**
 782  * @brief Set up PCI device operation
 783  *
 784  *
 785  * @param dev
 786  *
 787  * @see pci_drivers
 788  */
 789 static void set_pci_ops(struct device *dev)
 790 {
 791         struct pci_driver *driver;
 792         if (dev->ops) {
 793                 return;
 794         }
 795
 796         /* Look through the list of setup drivers and find one for
 797          * this pci device
 798          */
 799         for(driver = &pci_drivers[0]; driver != &epci_drivers[0]; driver++) {
 800                 if ((driver->vendor == dev->vendor) &&
 801                         (driver->device == dev->device))
 802                 {
 803                         dev->ops = driver->ops;
 804                         printk_spew("%s [%04x/%04x] %sops\n",
 805                                 dev_path(dev),
 806                                 driver->vendor, driver->device,
 807                                 (driver->ops->scan_bus?"bus ":""));
 808                         return;
 809                 }
 810         }
 811
 812         /* If I don't have a specific driver use the default operations */
 813         switch(dev->hdr_type & 0x7f) {  /* header type */
 814         case PCI_HEADER_TYPE_NORMAL:    /* standard header */
 815                 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)
 816                         goto bad;
 817                 dev->ops = &default_pci_ops_dev;
 818                 break;
 819         case PCI_HEADER_TYPE_BRIDGE:
 820                 if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI)
 821                         goto bad;
 822                 dev->ops = get_pci_bridge_ops(dev);
 823                 break;
 824 #if CONFIG_CARDBUS_PLUGIN_SUPPORT == 1
 825         case PCI_HEADER_TYPE_CARDBUS:
 826                 dev->ops = &default_cardbus_ops_bus;
 827                 break;
 828 #endif
 829         default:
 830         bad:
 831                 if (dev->enabled) {
 832                         printk_err("%s [%04x/%04x/%06x] has unknown header "
 833                                 "type %02x, ignoring.\n",
 834                                 dev_path(dev),
 835                                 dev->vendor, dev->device,
 836                                 dev->class >> 8, dev->hdr_type);
 837                 }
 838         }
 839         return;
 840 }
 841
 842
 843
 844 /**
 845  * @brief See if we have already allocated a device structure for a given devfn.
 846  *
 847  * Given a linked list of PCI device structures and a devfn number, find the
 848  * device structure correspond to the devfn, if present. This function also
 849  * removes the device structure from the linked list.
 850  *
 851  * @param list the device structure list
 852  * @param devfn a device/function number
 853  *
 854  * @return pointer to the device structure found or null of we have not
 855  *         allocated a device for this devfn yet.
 856  */
 857 static struct device *pci_scan_get_dev(struct device **list, unsigned int devfn)
 858 {
 859         struct device *dev;
 860         dev = 0;
 861         for(; *list; list = &(*list)->sibling) {
 862                 if ((*list)->path.type != DEVICE_PATH_PCI) {
 863                         printk_err("child %s not a pci device\n",
 864                                 dev_path(*list));
 865                         continue;
 866                 }
 867                 if ((*list)->path.u.pci.devfn == devfn) {
 868                         /* Unlink from the list */
 869                         dev = *list;
 870                         *list = (*list)->sibling;
 871                         dev->sibling = 0;
 872                         break;
 873                 }
 874         }
 875         /* Just like alloc_dev add the device to the  list of device on the bus.
 876          * When the list of devices was formed we removed all of the parents
 877          * children, and now we are interleaving static and dynamic devices in
 878          * order on the bus.
 879          */
 880         if (dev) {
 881                 device_t child;
 882                 /* Find the last child of our parent */
 883                 for(child = dev->bus->children; child && child->sibling; ) {
 884                         child = child->sibling;
 885                 }
 886                 /* Place the device on the list of children of it's parent. */
 887                 if (child) {
 888                         child->sibling = dev;
 889                 } else {
 890                         dev->bus->children = dev;
 891                 }
 892         }
 893
 894         return dev;
 895 }
 896
 897 /**
 898  * @brief Scan a PCI bus.
 899  *
 900  * Determine the existence of a given PCI device.
 901  *
 902  * @param bus pointer to the bus structure
 903  * @param devfn to look at
 904  *
 905  * @return The device structure for hte device (if found)
 906  *         or the NULL if no device is found.
 907  */
 908 device_t pci_probe_dev(device_t dev, struct bus *bus, unsigned devfn)
 909 {
 910         uint32_t id, class;
 911         uint8_t hdr_type;
 912
 913         /* Detect if a device is present */
 914         if (!dev) {
 915                 struct device dummy;
 916                 dummy.bus              = bus;
 917                 dummy.path.type        = DEVICE_PATH_PCI;
 918                 dummy.path.u.pci.devfn = devfn;
 919                 id = pci_read_config32(&dummy, PCI_VENDOR_ID);
 920                 /* Have we found somthing?
 921                  * Some broken boards return 0 if a slot is empty.
 922                  */
 923                 if (    (id == 0xffffffff) || (id == 0x00000000) ||
 924                         (id == 0x0000ffff) || (id == 0xffff0000))
 925                 {
 926                         printk_spew("%s, bad id 0x%x\n", dev_path(&dummy), id);
 927                         return NULL;
 928                 }
 929                 dev = alloc_dev(bus, &dummy.path);
 930         }
 931         else {
 932                 /* Enable/disable the device.  Once we have
 933                  * found the device specific operations this
 934                  * operations we will disable the device with
 935                  * those as well.
 936                  *
 937                  * This is geared toward devices that have subfunctions
 938                  * that do not show up by default.
 939                  *
 940                  * If a device is a stuff option on the motherboard
 941                  * it may be absent and enable_dev must cope.
 942                  *
 943                  */
 944                 /* Run the magice enable sequence for the device */
 945                 if (dev->chip_ops && dev->chip_ops->enable_dev) {
 946                         dev->chip_ops->enable_dev(dev);
 947                 }
 948                 /* Now read the vendor and device id */
 949                 id = pci_read_config32(dev, PCI_VENDOR_ID);
 950
 951
 952                 /* If the device does not have a pci id disable it.
 953                  * Possibly this is because we have already disabled
 954                  * the device.  But this also handles optional devices
 955                  * that may not always show up.
 956                  */
 957                 /* If the chain is fully enumerated quit */
 958                 if (    (id == 0xffffffff) || (id == 0x00000000) ||
 959                         (id == 0x0000ffff) || (id == 0xffff0000))
 960                 {
 961                         if (dev->enabled) {
 962                                 printk_info("Disabling static device: %s\n",
 963                                         dev_path(dev));
 964                                 dev->enabled = 0;
 965                         }
 966                         return dev;
 967                 }
 968         }
 969         /* Read the rest of the pci configuration information */
 970         hdr_type = pci_read_config8(dev, PCI_HEADER_TYPE);
 971         class = pci_read_config32(dev, PCI_CLASS_REVISION);
 972
 973         /* Store the interesting information in the device structure */
 974         dev->vendor = id & 0xffff;
 975         dev->device = (id >> 16) & 0xffff;
 976         dev->hdr_type = hdr_type;
 977         /* class code, the upper 3 bytes of PCI_CLASS_REVISION */
 978         dev->class = class >> 8;
 979
 980
 981         /* Architectural/System devices always need to
 982          * be bus masters.
 983          */
 984         if ((dev->class >> 16) == PCI_BASE_CLASS_SYSTEM) {
 985                 dev->command |= PCI_COMMAND_MASTER;
 986         }
 987         /* Look at the vendor and device id, or at least the
 988          * header type and class and figure out which set of
 989          * configuration methods to use.  Unless we already
 990          * have some pci ops.
 991          */
 992         set_pci_ops(dev);
 993
 994         /* Now run the magic enable/disable sequence for the device */
 995         if (dev->ops && dev->ops->enable) {
 996                 dev->ops->enable(dev);
 997         }
 998
 999
1000         /* Display the device and error if we don't have some pci operations
1001          * for it.
1002          */
1003         printk_debug("%s [%04x/%04x] %s%s\n",
1004                 dev_path(dev),
1005                 dev->vendor, dev->device,
1006                 dev->enabled?"enabled": "disabled",
1007                 dev->ops?"" : " No operations"
1008                 );
1009
1010         return dev;
1011 }
1012
1013 /**
1014  * @brief Scan a PCI bus.
1015  *
1016  * Determine the existence of devices and bridges on a PCI bus. If there are
1017  * bridges on the bus, recursively scan the buses behind the bridges.
1018  *
1019  * This function is the default scan_bus() method for the root device
1020  * 'dev_root'.
1021  *
1022  * @param bus pointer to the bus structure
1023  * @param min_devfn minimum devfn to look at in the scan usually 0x00
1024  * @param max_devfn maximum devfn to look at in the scan usually 0xff
1025  * @param max current bus number
1026  *
1027  * @return The maximum bus number found, after scanning all subordinate busses
1028  */
1029 unsigned int pci_scan_bus(struct bus *bus,
1030         unsigned min_devfn, unsigned max_devfn,
1031         unsigned int max)
1032 {
1033         unsigned int devfn;
1034         device_t old_devices;
1035         device_t child;
1036
1037 #if PCI_BUS_SEGN_BITS
1038         printk_debug("PCI: pci_scan_bus for bus %04x:%02x\n", bus->secondary >> 8, bus->secondary & 0xff);
1039 #else
1040         printk_debug("PCI: pci_scan_bus for bus %02x\n", bus->secondary);
1041 #endif
1042
1043         old_devices = bus->children;
1044         bus->children = 0;
1045
1046         post_code(0x24);
1047         /* probe all devices/functions on this bus with some optimization for
1048          * non-existence and single funcion devices
1049          */
1050         for (devfn = min_devfn; devfn <= max_devfn; devfn++) {
1051                 device_t dev;
1052
1053                 /* First thing setup the device structure */
1054                 dev = pci_scan_get_dev(&old_devices, devfn);
1055
1056                 /* See if a device is present and setup the device
1057                  * structure.
1058                  */
1059                 dev = pci_probe_dev(dev, bus, devfn);
1060
1061                 /* if this is not a multi function device,
1062                  * or the device is not present don't waste
1063                  * time probing another function.
1064                  * Skip to next device.
1065                  */
1066                 if ((PCI_FUNC(devfn) == 0x00) &&
1067                         (!dev || (dev->enabled && ((dev->hdr_type & 0x80) != 0x80))))
1068                 {
1069                         devfn += 0x07;
1070                 }
1071         }
1072         post_code(0x25);
1073
1074         /* Die if any left over static devices are are found.
1075          * There's probably a problem in the Config.lb.
1076         */
1077         if(old_devices) {
1078                 device_t left;
1079                 for(left = old_devices; left; left = left->sibling) {
1080                         printk_err("%s\n", dev_path(left));
1081                 }
1082                 printk_warning("PCI: Left over static devices.  Check your mainboard Config.lb\n");
1083         }
1084
1085         /* For all children that implement scan_bus (i.e. bridges)
1086          * scan the bus behind that child.
1087          */
1088         for(child = bus->children; child; child = child->sibling) {
1089                 max = scan_bus(child, max);
1090         }
1091
1092         /*
1093          * We've scanned the bus and so we know all about what's on
1094          * the other side of any bridges that may be on this bus plus
1095          * any devices.
1096          *
1097          * Return how far we've got finding sub-buses.
1098          */
1099         printk_debug("PCI: pci_scan_bus returning with max=%03x\n", max);
1100         post_code(0x55);
1101         return max;
1102 }
1103
1104
1105 /**
1106  * @brief Scan a PCI bridge and the buses behind the bridge.
1107  *
1108  * Determine the existence of buses behind the bridge. Set up the bridge
1109  * according to the result of the scan.
1110  *
1111  * This function is the default scan_bus() method for PCI bridge devices.
1112  *
1113  * @param dev pointer to the bridge device
1114  * @param max the highest bus number assgined up to now
1115  *
1116  * @return The maximum bus number found, after scanning all subordinate busses
1117  */
1118 unsigned int do_pci_scan_bridge(struct device *dev, unsigned int max,
1119         unsigned int (*do_scan_bus)(struct bus *bus,
1120                 unsigned min_devfn, unsigned max_devfn, unsigned int max))
1121 {
1122         struct bus *bus;
1123         uint32_t buses;
1124         uint16_t cr;
1125
1126         printk_spew("%s for %s\n", __func__, dev_path(dev));
1127
1128         bus = &dev->link[0];
1129         bus->dev = dev;
1130         dev->links = 1;
1131
1132         /* Set up the primary, secondary and subordinate bus numbers. We have
1133          * no idea how many buses are behind this bridge yet, so we set the
1134          * subordinate bus number to 0xff for the moment.
1135          */
1136         bus->secondary = ++max;
1137         bus->subordinate = 0xff;
1138
1139         /* Clear all status bits and turn off memory, I/O and master enables. */
1140         cr = pci_read_config16(dev, PCI_COMMAND);
1141         pci_write_config16(dev, PCI_COMMAND, 0x0000);
1142         pci_write_config16(dev, PCI_STATUS, 0xffff);
1143
1144         /*
1145          * Read the existing primary/secondary/subordinate bus
1146          * number configuration.
1147          */
1148         buses = pci_read_config32(dev, PCI_PRIMARY_BUS);
1149
1150         /* Configure the bus numbers for this bridge: the configuration
1151          * transactions will not be propagated by the bridge if it is not
1152          * correctly configured.
1153          */
1154         buses &= 0xff000000;
1155         buses |= (((unsigned int) (dev->bus->secondary) << 0) |
1156                 ((unsigned int) (bus->secondary) << 8) |
1157                 ((unsigned int) (bus->subordinate) << 16));
1158         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
1159
1160         /* Now we can scan all subordinate buses
1161          * i.e. the bus behind the bridge.
1162          */
1163         max = do_scan_bus(bus, 0x00, 0xff, max);
1164
1165         /* We know the number of buses behind this bridge. Set the subordinate
1166          * bus number to its real value.
1167          */
1168         bus->subordinate = max;
1169         buses = (buses & 0xff00ffff) |
1170                 ((unsigned int) (bus->subordinate) << 16);
1171         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
1172         pci_write_config16(dev, PCI_COMMAND, cr);
1173
1174         printk_spew("%s returns max %d\n", __func__, max);
1175         return max;
1176 }
1177
1178 /**
1179  * @brief Scan a PCI bridge and the buses behind the bridge.
1180  *
1181  * Determine the existence of buses behind the bridge. Set up the bridge
1182  * according to the result of the scan.
1183  *
1184  * This function is the default scan_bus() method for PCI bridge devices.
1185  *
1186  * @param dev pointer to the bridge device
1187  * @param max the highest bus number assgined up to now
1188  *
1189  * @return The maximum bus number found, after scanning all subordinate busses
1190  */
1191 unsigned int pci_scan_bridge(struct device *dev, unsigned int max)
1192 {
1193         return do_pci_scan_bridge(dev, max, pci_scan_bus);
1194 }
1195
1196 /*
1197     Tell the EISA int controller this int must be level triggered
1198     THIS IS A KLUDGE -- sorry, this needs to get cleaned up.
1199 */
1200 void pci_level_irq(unsigned char intNum)
1201 {
1202         unsigned short intBits = inb(0x4d0) | (((unsigned) inb(0x4d1)) << 8);
1203
1204         printk_spew("%s: current ints are 0x%x\n", __func__, intBits);
1205         intBits |= (1 << intNum);
1206
1207         printk_spew("%s: try to set ints 0x%x\n", __func__, intBits);
1208
1209         // Write new values
1210         outb((unsigned char) intBits, 0x4d0);
1211         outb((unsigned char) (intBits >> 8), 0x4d1);
1212
1213         /* this seems like an error but is not ... */
1214 #if 1
1215         if (inb(0x4d0) != (intBits & 0xff)) {
1216           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
1217                      __func__, intBits &0xff, inb(0x4d0));
1218         }
1219         if (inb(0x4d1) != ((intBits >> 8) & 0xff)) {
1220           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
1221                      __func__, (intBits>>8) &0xff, inb(0x4d1));
1222         }
1223 #endif
1224 }
1225
1226 /*
1227     This function assigns IRQs for all functions contained within
1228     the indicated device address.  If the device does not exist or does
1229     not require interrupts then this function has no effect.
1230
1231     This function should be called for each PCI slot in your system.
1232
1233     pIntAtoD is an array of IRQ #s that are assigned to PINTA through PINTD of
1234     this slot.
1235     The particular irq #s that are passed in depend on the routing inside
1236     your southbridge and on your motherboard.
1237
1238     -kevinh@ispiri.com
1239 */
1240 void pci_assign_irqs(unsigned bus, unsigned slot,
1241         const unsigned char pIntAtoD[4])
1242 {
1243         unsigned functNum;
1244         device_t pdev;
1245         unsigned char line;
1246         unsigned char irq;
1247         unsigned char readback;
1248
1249         /* Each slot may contain up to eight functions */
1250         for (functNum = 0; functNum < 8; functNum++) {
1251                 pdev = dev_find_slot(bus, (slot << 3) + functNum);
1252
1253                 if (pdev) {
1254                   line = pci_read_config8(pdev, PCI_INTERRUPT_PIN);
1255
1256                         // PCI spec says all other values are reserved
1257                         if ((line >= 1) && (line <= 4)) {
1258                                 irq = pIntAtoD[line - 1];
1259
1260                                 printk_debug("Assigning IRQ %d to %d:%x.%d\n", \
1261                                         irq, bus, slot, functNum);
1262
1263                                 pci_write_config8(pdev, PCI_INTERRUPT_LINE,\
1264                                         pIntAtoD[line - 1]);
1265
1266                                 readback = pci_read_config8(pdev, PCI_INTERRUPT_LINE);
1267                                 printk_debug("  Readback = %d\n", readback);
1268
1269                                 // Change to level triggered
1270                                 pci_level_irq(pIntAtoD[line - 1]);
1271                         }
1272                 }
1273         }
1274 }