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 <part/hard_reset.h>
  22 #include <part/fallback_boot.h>
  23 #include <delay.h>
  24
  25 static uint8_t pci_moving_config8(struct device *dev, unsigned reg)
  26 {
  27         uint8_t value, ones, zeroes;
  28         value = pci_read_config8(dev, reg);
  29
  30         pci_write_config8(dev, reg, 0xff);
  31         ones = pci_read_config8(dev, reg);
  32
  33         pci_write_config8(dev, reg, 0x00);
  34         zeroes = pci_read_config8(dev, reg);
  35
  36         pci_write_config8(dev, reg, value);
  37
  38         return ones ^ zeroes;
  39 }
  40 static uint16_t pci_moving_config16(struct device *dev, unsigned reg)
  41 {
  42         uint16_t value, ones, zeroes;
  43         value = pci_read_config16(dev, reg);
  44
  45         pci_write_config16(dev, reg, 0xffff);
  46         ones = pci_read_config16(dev, reg);
  47
  48         pci_write_config16(dev, reg, 0x0000);
  49         zeroes = pci_read_config16(dev, reg);
  50
  51         pci_write_config16(dev, reg, value);
  52
  53         return ones ^ zeroes;
  54 }
  55 static uint32_t pci_moving_config32(struct device *dev, unsigned reg)
  56 {
  57         uint32_t value, ones, zeroes;
  58         value = pci_read_config32(dev, reg);
  59
  60         pci_write_config32(dev, reg, 0xffffffff);
  61         ones = pci_read_config32(dev, reg);
  62
  63         pci_write_config32(dev, reg, 0x00000000);
  64         zeroes = pci_read_config32(dev, reg);
  65
  66         pci_write_config32(dev, reg, value);
  67
  68         return ones ^ zeroes;
  69 }
  70
  71 unsigned pci_find_capability(device_t dev, unsigned cap)
  72 {
  73         unsigned pos;
  74         pos = 0;
  75         switch(dev->hdr_type & 0x7f) {
  76         case PCI_HEADER_TYPE_NORMAL:
  77         case PCI_HEADER_TYPE_BRIDGE:
  78                 pos = PCI_CAPABILITY_LIST;
  79                 break;
  80         }
  81         if (pos > PCI_CAP_LIST_NEXT) {
  82                 pos = pci_read_config8(dev, pos);
  83         }
  84         while(pos != 0) {   /* loop through the linked list */
  85                 int this_cap;
  86                 this_cap = pci_read_config8(dev, pos + PCI_CAP_LIST_ID);
  87                 if (this_cap == cap) {
  88                         return pos;
  89                 }
  90         }
  91         return 0;
  92 }
  93
  94
  95 /** Given a device and register, read the size of the BAR for that register.
  96  * @param dev       Pointer to the device structure
  97  * @param resource  Pointer to the resource structure
  98  * @param index     Address of the pci configuration register
  99  */
 100 struct resource *pci_get_resource(struct device *dev, unsigned long index)
 101 {
 102         struct resource *resource;
 103         unsigned long value, attr;
 104         resource_t  moving, limit;
 105
 106         /* Initialize the resources to nothing */
 107         resource = new_resource(dev, index);
 108
 109         /* Get the initial value */
 110         value = pci_read_config32(dev, index);
 111
 112         /* See which bits move */
 113         moving = pci_moving_config32(dev, index);
 114
 115         /* Initialize attr to the bits that do not move */
 116         attr = value & ~moving;
 117
 118         /* If it is a 64bit resource look at the high half as well */
 119         if (((attr & PCI_BASE_ADDRESS_SPACE_IO) == 0) &&
 120                 ((attr & PCI_BASE_ADDRESS_MEM_LIMIT_MASK) == PCI_BASE_ADDRESS_MEM_LIMIT_64))
 121         {
 122                 /* Find the high bits that move */
 123                 moving |= ((resource_t)pci_moving_config32(dev, index + 4)) << 32;
 124         }
 125         /* Find the resource constraints.
 126          *
 127          * Start by finding the bits that move. From there:
 128          * - Size is the least significant bit of the bits that move.
 129          * - Limit is all of the bits that move plus all of the lower bits.
 130          * See PCI Spec 6.2.5.1 ...
 131          */
 132         limit = 0;
 133         if (moving) {
 134                 resource->size = 1;
 135                 resource->align = resource->gran = 0;
 136                 while(!(moving & resource->size)) {
 137                         resource->size <<= 1;
 138                         resource->align += 1;
 139                         resource->gran  += 1;
 140                 }
 141                 resource->limit = limit = moving | (resource->size - 1);
 142         }
 143         /*
 144          * some broken hardware has read-only registers that do not
 145          * really size correctly.
 146          * Example: the acer m7229 has BARs 1-4 normally read-only.
 147          * so BAR1 at offset 0x10 reads 0x1f1. If you size that register
 148          * by writing 0xffffffff to it, it will read back as 0x1f1 -- a
 149          * violation of the spec.
 150          * We catch this case and ignore it by observing which bits move,
 151          * This also catches the common case unimplemented registers
 152          * that always read back as 0.
 153          */
 154         if (moving == 0) {
 155                 if (value != 0) {
 156                         printk_debug(
 157                                 "%s register %02x(%08x), read-only ignoring it\n",
 158                                 dev_path(dev), index, value);
 159                 }
 160                 resource->flags = 0;
 161         }
 162         else if (attr & PCI_BASE_ADDRESS_SPACE_IO) {
 163                 /* An I/O mapped base address */
 164                 attr &= PCI_BASE_ADDRESS_IO_ATTR_MASK;
 165                 resource->flags |= IORESOURCE_IO;
 166                 /* I don't want to deal with 32bit I/O resources */
 167                 resource->limit = 0xffff;
 168         }
 169         else {
 170                 /* A Memory mapped base address */
 171                 attr &= PCI_BASE_ADDRESS_MEM_ATTR_MASK;
 172                 resource->flags |= IORESOURCE_MEM;
 173                 if (attr & PCI_BASE_ADDRESS_MEM_PREFETCH) {
 174                         resource->flags |= IORESOURCE_PREFETCH;
 175                 }
 176                 attr &= PCI_BASE_ADDRESS_MEM_LIMIT_MASK;
 177                 if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_32) {
 178                         /* 32bit limit */
 179                         resource->limit = 0xffffffffUL;
 180                 }
 181                 else if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_1M) {
 182                         /* 1MB limit */
 183                         resource->limit = 0x000fffffUL;
 184                 }
 185                 else if (attr == PCI_BASE_ADDRESS_MEM_LIMIT_64) {
 186                         /* 64bit limit */
 187                         resource->limit = 0xffffffffffffffffULL;
 188                         resource->flags |= IORESOURCE_PCI64;
 189                 }
 190                 else {
 191                         /* Invalid value */
 192                         resource->flags = 0;
 193                 }
 194         }
 195         /* Don't let the limit exceed which bits can move */
 196         if (resource->limit > limit) {
 197                 resource->limit = limit;
 198         }
 199 #if 0
 200         if (resource->flags) {
 201                 printk_debug("%s %02x ->",
 202                         dev_path(dev), resource->index);
 203                 printk_debug(" value: 0x%08Lx zeroes: 0x%08Lx ones: 0x%08Lx attr: %08lx\n",
 204                         value, zeroes, ones, attr);
 205                 printk_debug(
 206                         "%s %02x -> size: 0x%08Lx max: 0x%08Lx %s%s\n ",
 207                         dev_path(dev),
 208                         resource->index,
 209                         resource->size, resource->limit,
 210                         (resource->flags == 0) ? "unused":
 211                         (resource->flags & IORESOURCE_IO)? "io":
 212                         (resource->flags & IORESOURCE_PREFETCH)? "prefmem": "mem",
 213                         (resource->flags & IORESOURCE_PCI64)?"64":"");
 214         }
 215 #endif
 216
 217         return resource;
 218 }
 219
 220 /** Read the base address registers for a given device.
 221  * @param dev Pointer to the dev structure
 222  * @param howmany How many registers to read (6 for device, 2 for bridge)
 223  */
 224 static void pci_read_bases(struct device *dev, unsigned int howmany)
 225 {
 226         unsigned long index;
 227
 228         for(index = PCI_BASE_ADDRESS_0; (index < PCI_BASE_ADDRESS_0 + (howmany << 2)); ) {
 229                 struct resource *resource;
 230                 resource = pci_get_resource(dev, index);
 231                 index += (resource->flags & IORESOURCE_PCI64)?8:4;
 232         }
 233         compact_resources(dev);
 234 }
 235
 236 static void pci_set_resource(struct device *dev, struct resource *resource);
 237
 238 static void pci_record_bridge_resource(
 239         struct device *dev, resource_t moving,
 240         unsigned index, unsigned long mask, unsigned long type)
 241 {
 242         /* Initiliaze the constraints on the current bus */
 243         struct resource *resource;
 244         resource = 0;
 245         if (moving) {
 246                 unsigned long gran;
 247                 resource_t step;
 248                 resource = new_resource(dev, index);
 249                 resource->size = 0;
 250                 gran = 0;
 251                 step = 1;
 252                 while((moving & step) == 0) {
 253                         gran += 1;
 254                         step <<= 1;
 255                 }
 256                 resource->gran = gran;
 257                 resource->align = gran;
 258                 resource->limit = moving | (step - 1);
 259                 resource->flags = type | IORESOURCE_PCI_BRIDGE;
 260                 compute_allocate_resource(&dev->link[0], resource, mask, type);
 261                 /* If there is nothing behind the resource,
 262                  * clear it and forget it.
 263                  */
 264                 if (resource->size == 0) {
 265                         resource->base = moving;
 266                         resource->flags |= IORESOURCE_ASSIGNED;
 267                         resource->flags &= ~IORESOURCE_STORED;
 268                         pci_set_resource(dev, resource);
 269                         resource->flags = 0;
 270                 }
 271         }
 272         return;
 273 }
 274
 275
 276 static void pci_bridge_read_bases(struct device *dev)
 277 {
 278         resource_t moving_base, moving_limit, moving;
 279
 280
 281         /* See if the bridge I/O resources are implemented */
 282         moving_base = ((uint32_t)pci_moving_config8(dev, PCI_IO_BASE)) << 8;
 283         moving_base |= ((uint32_t)pci_moving_config16(dev, PCI_IO_BASE_UPPER16)) << 16;
 284
 285         moving_limit = ((uint32_t)pci_moving_config8(dev, PCI_IO_LIMIT)) << 8;
 286         moving_limit |= ((uint32_t)pci_moving_config16(dev, PCI_IO_LIMIT_UPPER16)) << 16;
 287
 288         moving = moving_base & moving_limit;
 289
 290         /* Initialize the io space constraints on the current bus */
 291         pci_record_bridge_resource(
 292                 dev, moving, PCI_IO_BASE,
 293                 IORESOURCE_IO, IORESOURCE_IO);
 294
 295
 296         /* See if the bridge prefmem resources are implemented */
 297         moving_base =  ((resource_t)pci_moving_config16(dev, PCI_PREF_MEMORY_BASE)) << 16;
 298         moving_base |= ((resource_t)pci_moving_config32(dev, PCI_PREF_BASE_UPPER32)) << 32;
 299
 300         moving_limit =  ((resource_t)pci_moving_config16(dev, PCI_PREF_MEMORY_LIMIT)) << 16;
 301         moving_limit |= ((resource_t)pci_moving_config32(dev, PCI_PREF_LIMIT_UPPER32)) << 32;
 302
 303         moving = moving_base & moving_limit;
 304         /* Initiliaze the prefetchable memory constraints on the current bus */
 305         pci_record_bridge_resource(
 306                 dev, moving, PCI_PREF_MEMORY_BASE,
 307                 IORESOURCE_MEM | IORESOURCE_PREFETCH,
 308                 IORESOURCE_MEM | IORESOURCE_PREFETCH);
 309
 310
 311         /* See if the bridge mem resources are implemented */
 312         moving_base = ((uint32_t)pci_moving_config16(dev, PCI_MEMORY_BASE)) << 16;
 313         moving_limit = ((uint32_t)pci_moving_config16(dev, PCI_MEMORY_LIMIT)) << 16;
 314
 315         moving = moving_base & moving_limit;
 316
 317         /* Initialize the memory resources on the current bus */
 318         pci_record_bridge_resource(
 319                 dev, moving, PCI_MEMORY_BASE,
 320                 IORESOURCE_MEM | IORESOURCE_PREFETCH,
 321                 IORESOURCE_MEM);
 322
 323         compact_resources(dev);
 324 }
 325
 326 void pci_dev_read_resources(struct device *dev)
 327 {
 328         uint32_t addr;
 329
 330         pci_read_bases(dev, 6);
 331
 332         addr = pci_read_config32(dev, PCI_ROM_ADDRESS);
 333         dev->rom_address = (addr == 0xffffffff)? 0 : addr;
 334 }
 335
 336 void pci_bus_read_resources(struct device *dev)
 337 {
 338         uint32_t addr;
 339
 340         pci_bridge_read_bases(dev);
 341         pci_read_bases(dev, 2);
 342
 343         addr = pci_read_config32(dev, PCI_ROM_ADDRESS1);
 344         dev->rom_address = (addr == 0xffffffff)? 0 : addr;
 345 }
 346
 347 static void pci_set_resource(struct device *dev, struct resource *resource)
 348 {
 349         resource_t base, end;
 350
 351         /* Make certain the resource has actually been set */
 352         if (!(resource->flags & IORESOURCE_ASSIGNED)) {
 353                 printk_err("ERROR: %s %02x not allocated\n",
 354                         dev_path(dev), resource->index);
 355                 return;
 356         }
 357
 358         /* If I have already stored this resource don't worry about it */
 359         if (resource->flags & IORESOURCE_STORED) {
 360                 return;
 361         }
 362
 363         /* If the resources is substractive don't worry about it */
 364         if (resource->flags & IORESOURCE_SUBTRACTIVE) {
 365                 return;
 366         }
 367
 368         /* Only handle PCI memory and IO resources for now */
 369         if (!(resource->flags & (IORESOURCE_MEM |IORESOURCE_IO)))
 370                 return;
 371
 372         /* Enable the resources in the command register */
 373         if (resource->size) {
 374                 if (resource->flags & IORESOURCE_MEM) {
 375                         dev->command |= PCI_COMMAND_MEMORY;
 376                 }
 377                 if (resource->flags & IORESOURCE_IO) {
 378                         dev->command |= PCI_COMMAND_IO;
 379                 }
 380                 if (resource->flags & IORESOURCE_PCI_BRIDGE) {
 381                         dev->command |= PCI_COMMAND_MASTER;
 382                 }
 383         }
 384         /* Get the base address */
 385         base = resource->base;
 386
 387         /* Get the end */
 388         end = resource_end(resource);
 389
 390         /* Now store the resource */
 391         resource->flags |= IORESOURCE_STORED;
 392         if (!(resource->flags & IORESOURCE_PCI_BRIDGE)) {
 393                 unsigned long base_lo, base_hi;
 394                 /*
 395                  * some chipsets allow us to set/clear the IO bit.
 396                  * (e.g. VIA 82c686a.) So set it to be safe)
 397                  */
 398                 base_lo = base & 0xffffffff;
 399                 base_hi = (base >> 32) & 0xffffffff;
 400                 if (resource->flags & IORESOURCE_IO) {
 401                         base_lo |= PCI_BASE_ADDRESS_SPACE_IO;
 402                 }
 403                 pci_write_config32(dev, resource->index, base_lo);
 404                 if (resource->flags & IORESOURCE_PCI64) {
 405                         pci_write_config32(dev, resource->index + 4, base_hi);
 406                 }
 407         }
 408         else if (resource->index == PCI_IO_BASE) {
 409                 /* set the IO ranges */
 410                 compute_allocate_resource(&dev->link[0], resource,
 411                         IORESOURCE_IO, IORESOURCE_IO);
 412                 pci_write_config8(dev,  PCI_IO_BASE, base >> 8);
 413                 pci_write_config16(dev, PCI_IO_BASE_UPPER16, base >> 16);
 414                 pci_write_config8(dev,  PCI_IO_LIMIT, end >> 8);
 415                 pci_write_config16(dev, PCI_IO_LIMIT_UPPER16, end >> 16);
 416         }
 417         else if (resource->index == PCI_MEMORY_BASE) {
 418                 /* set the memory range  */
 419                 compute_allocate_resource(&dev->link[0], resource,
 420                         IORESOURCE_MEM | IORESOURCE_PREFETCH,
 421                         IORESOURCE_MEM);
 422                 pci_write_config16(dev, PCI_MEMORY_BASE, base >> 16);
 423                 pci_write_config16(dev, PCI_MEMORY_LIMIT, end >> 16);
 424         }
 425         else if (resource->index == PCI_PREF_MEMORY_BASE) {
 426                 /* set the prefetchable memory range */
 427                 compute_allocate_resource(&dev->link[0], resource,
 428                         IORESOURCE_MEM | IORESOURCE_PREFETCH,
 429                         IORESOURCE_MEM | IORESOURCE_PREFETCH);
 430                 pci_write_config16(dev, PCI_PREF_MEMORY_BASE, base >> 16);
 431                 pci_write_config32(dev, PCI_PREF_BASE_UPPER32, base >> 32);
 432                 pci_write_config16(dev, PCI_PREF_MEMORY_LIMIT, end >> 16);
 433                 pci_write_config32(dev, PCI_PREF_LIMIT_UPPER32, end >> 32);
 434         }
 435         else {
 436                 /* Don't let me think I stored the resource */
 437                 resource->flags &= ~IORESOURCE_STORED;
 438                 printk_err("ERROR: invalid resource->index %x\n",
 439                         resource->index);
 440         }
 441         report_resource_stored(dev, resource, "");
 442         return;
 443 }
 444
 445 void pci_dev_set_resources(struct device *dev)
 446 {
 447         struct resource *resource, *last;
 448         unsigned link;
 449         uint8_t line;
 450
 451         last = &dev->resource[dev->resources];
 452
 453         for(resource = &dev->resource[0]; resource < last; resource++) {
 454                 pci_set_resource(dev, resource);
 455         }
 456         for(link = 0; link < dev->links; link++) {
 457                 struct bus *bus;
 458                 bus = &dev->link[link];
 459                 if (bus->children) {
 460                         assign_resources(bus);
 461                 }
 462         }
 463
 464         /* set a default latency timer */
 465         pci_write_config8(dev, PCI_LATENCY_TIMER, 0x40);
 466
 467         /* set a default secondary latency timer */
 468         if ((dev->hdr_type & 0x7f) == PCI_HEADER_TYPE_BRIDGE) {
 469                 pci_write_config8(dev, PCI_SEC_LATENCY_TIMER, 0x40);
 470         }
 471
 472         /* zero the irq settings */
 473         line = pci_read_config8(dev, PCI_INTERRUPT_PIN);
 474         if (line) {
 475                 pci_write_config8(dev, PCI_INTERRUPT_LINE, 0);
 476         }
 477         /* set the cache line size, so far 64 bytes is good for everyone */
 478         pci_write_config8(dev, PCI_CACHE_LINE_SIZE, 64 >> 2);
 479 }
 480
 481 void pci_dev_enable_resources(struct device *dev)
 482 {
 483         const struct pci_operations *ops;
 484         uint16_t command;
 485
 486         /* Set the subsystem vendor and device id for mainboard devices */
 487         ops = ops_pci(dev);
 488         if (dev->on_mainboard && ops && ops->set_subsystem) {
 489                 printk_debug("%s subsystem <- %02x/%02x\n",
 490                         dev_path(dev),
 491                         MAINBOARD_PCI_SUBSYSTEM_VENDOR_ID,
 492                         MAINBOARD_PCI_SUBSYSTEM_DEVICE_ID);
 493                 ops->set_subsystem(dev,
 494                         MAINBOARD_PCI_SUBSYSTEM_VENDOR_ID,
 495                         MAINBOARD_PCI_SUBSYSTEM_DEVICE_ID);
 496         }
 497         command = pci_read_config16(dev, PCI_COMMAND);
 498         command |= dev->command;
 499         command |= (PCI_COMMAND_PARITY + PCI_COMMAND_SERR); /* error check */
 500         printk_debug("%s cmd <- %02x\n", dev_path(dev), command);
 501         pci_write_config16(dev, PCI_COMMAND, command);
 502 }
 503
 504 void pci_bus_enable_resources(struct device *dev)
 505 {
 506         uint16_t ctrl;
 507         ctrl = pci_read_config16(dev, PCI_BRIDGE_CONTROL);
 508         ctrl |= dev->link[0].bridge_ctrl;
 509         ctrl |= (PCI_BRIDGE_CTL_PARITY + PCI_BRIDGE_CTL_SERR); /* error check */
 510         printk_debug("%s bridge ctrl <- %04x\n", dev_path(dev), ctrl);
 511         pci_write_config16(dev, PCI_BRIDGE_CONTROL, ctrl);
 512
 513         pci_dev_enable_resources(dev);
 514
 515         enable_childrens_resources(dev);
 516 }
 517
 518
 519 void pci_dev_set_subsystem(device_t dev, unsigned vendor, unsigned device)
 520 {
 521         pci_write_config32(dev, PCI_SUBSYSTEM_VENDOR_ID,
 522                 ((device & 0xffff) << 16) | (vendor & 0xffff));
 523 }
 524
 525 /** Default device operation for PCI devices */
 526 static struct pci_operations pci_dev_ops_pci = {
 527         .set_subsystem = pci_dev_set_subsystem,
 528 };
 529
 530 struct device_operations default_pci_ops_dev = {
 531         .read_resources   = pci_dev_read_resources,
 532         .set_resources    = pci_dev_set_resources,
 533         .enable_resources = pci_dev_enable_resources,
 534         .init             = 0,
 535         .scan_bus         = 0,
 536         .enable           = 0,
 537         .ops_pci          = &pci_dev_ops_pci,
 538 };
 539
 540 /** Default device operations for PCI bridges */
 541 static struct pci_operations pci_bus_ops_pci = {
 542         .set_subsystem = 0,
 543 };
 544 struct device_operations default_pci_ops_bus = {
 545         .read_resources   = pci_bus_read_resources,
 546         .set_resources    = pci_dev_set_resources,
 547         .enable_resources = pci_bus_enable_resources,
 548         .init             = 0,
 549         .scan_bus         = pci_scan_bridge,
 550         .enable           = 0,
 551         .ops_pci          = &pci_bus_ops_pci,
 552 };
 553
 554 /**
 555  * @brief Set up PCI device operation
 556  *
 557  *
 558  * @param dev
 559  *
 560  * @see pci_drivers
 561  */
 562 static void set_pci_ops(struct device *dev)
 563 {
 564         struct pci_driver *driver;
 565         if (dev->ops) {
 566                 return;
 567         }
 568
 569         /* Look through the list of setup drivers and find one for
 570          * this pci device
 571          */
 572         for(driver = &pci_drivers[0]; driver != &epci_drivers[0]; driver++) {
 573                 if ((driver->vendor == dev->vendor) &&
 574                         (driver->device == dev->device))
 575                 {
 576                         dev->ops = driver->ops;
 577                         printk_debug("%s [%04x/%04x] %sops\n",
 578                                 dev_path(dev),
 579                                 driver->vendor, driver->device,
 580                                 (driver->ops->scan_bus?"bus ":""));
 581                         return;
 582                 }
 583         }
 584
 585         /* If I don't have a specific driver use the default operations */
 586         switch(dev->hdr_type & 0x7f) {  /* header type */
 587         case PCI_HEADER_TYPE_NORMAL:    /* standard header */
 588                 if ((dev->class >> 8) == PCI_CLASS_BRIDGE_PCI)
 589                         goto bad;
 590                 dev->ops = &default_pci_ops_dev;
 591                 break;
 592         case PCI_HEADER_TYPE_BRIDGE:
 593                 if ((dev->class >> 8) != PCI_CLASS_BRIDGE_PCI)
 594                         goto bad;
 595                 dev->ops = &default_pci_ops_bus;
 596                 break;
 597         default:
 598         bad:
 599                 if (dev->enabled) {
 600                         printk_err("%s [%04x/%04x/%06x] has unknown header "
 601                                 "type %02x, ignoring.\n",
 602                                 dev_path(dev),
 603                                 dev->vendor, dev->device,
 604                                 dev->class >> 8, dev->hdr_type);
 605                 }
 606         }
 607         return;
 608 }
 609
 610 /**
 611  * @brief See if we have already allocated a device structure for a given devfn.
 612  *
 613  * Given a linked list of PCI device structures and a devfn number, find the
 614  * device structure correspond to the devfn, if present.
 615  *
 616  * @param list the device structure list
 617  * @param devfn a device/function number
 618  *
 619  * @return pointer to the device structure found or null of we have not allocated
 620  *         a device for this devfn yet.
 621  */
 622 static struct device *pci_scan_get_dev(struct device **list, unsigned int devfn)
 623 {
 624         struct device *dev;
 625         dev = 0;
 626         for(; *list; list = &(*list)->sibling) {
 627                 if ((*list)->path.type != DEVICE_PATH_PCI) {
 628                         printk_err("child %s not a pci device\n",
 629                                 dev_path(*list));
 630                         continue;
 631                 }
 632                 if ((*list)->path.u.pci.devfn == devfn) {
 633                         /* Unlink from the list */
 634                         dev = *list;
 635                         *list = (*list)->sibling;
 636                         dev->sibling = 0;
 637                         break;
 638                 }
 639         }
 640         /* Just like alloc_dev add the device to the
 641          * list of device on the bus.  When the list of devices was formed
 642          * we removed all of the parents children, and now we are interleaving
 643          * static and dynamic devices in order on the bus.
 644          */
 645         if (dev) {
 646                 device_t child;
 647                 /* Find the last child of our parent */
 648                 for(child = dev->bus->children; child && child->sibling; ) {
 649                         child = child->sibling;
 650                 }
 651                 /* Place the device on the list of children of it's parent. */
 652                 if (child) {
 653                         child->sibling = dev;
 654                 } else {
 655                         dev->bus->children = dev;
 656                 }
 657         }
 658
 659         return dev;
 660 }
 661
 662 /**
 663  * @brief Scan a PCI bus.
 664  *
 665  * Determine the existence of devices and bridges on a PCI bus. If there are
 666  * bridges on the bus, recursively scan the buses behind the bridges.
 667  *
 668  * This function is the default scan_bus() method for the root device
 669  * 'dev_root'.
 670  *
 671  * @param bus pointer to the bus structure
 672  * @param min_devfn minimum devfn to look at in the scan usually 0x00
 673  * @param max_devfn maximum devfn to look at in the scan usually 0xff
 674  * @param max current bus number
 675  *
 676  * @return The maximum bus number found, after scanning all subordinate busses
 677  */
 678 unsigned int pci_scan_bus(struct bus *bus,
 679         unsigned min_devfn, unsigned max_devfn,
 680         unsigned int max)
 681 {
 682         unsigned int devfn;
 683         device_t dev;
 684         device_t old_devices;
 685         device_t child;
 686
 687         printk_debug("PCI: pci_scan_bus for bus %d\n", bus->secondary);
 688
 689         old_devices = bus->children;
 690         bus->children = 0;
 691
 692         post_code(0x24);
 693
 694         /* probe all devices/functions on this bus with some optimization for
 695          * non-existence and single funcion devices
 696          */
 697         for (devfn = min_devfn; devfn <= max_devfn; devfn++) {
 698                 uint32_t id, class;
 699                 uint8_t hdr_type;
 700
 701                 /* First thing setup the device structure */
 702                 dev = pci_scan_get_dev(&old_devices, devfn);
 703
 704                 /* Detect if a device is present */
 705                 if (!dev) {
 706                         struct device dummy;
 707                         dummy.bus              = bus;
 708                         dummy.path.type        = DEVICE_PATH_PCI;
 709                         dummy.path.u.pci.devfn = devfn;
 710                         id = pci_read_config32(&dummy, PCI_VENDOR_ID);
 711                         /* some broken boards return 0 if a slot is empty: */
 712                         if (    (id == 0xffffffff) || (id == 0x00000000) ||
 713                                 (id == 0x0000ffff) || (id == 0xffff0000))
 714                         {
 715                                 printk_spew("PCI: devfn 0x%x, bad id 0x%x\n", devfn, id);
 716                                 if (PCI_FUNC(devfn) == 0x00) {
 717                                         /* if this is a function 0 device and
 718                                          * it is not present,
 719                                          * skip to next device
 720                                          */
 721                                         devfn += 0x07;
 722                                 }
 723                                 /* This function in a multi function device is
 724                                  * not present, skip to the next function.
 725                                  */
 726                                 continue;
 727                         }
 728                         dev = alloc_dev(bus, &dummy.path);
 729                 }
 730                 else {
 731                         /* Enable/disable the device.  Once we have
 732                          * found the device specific operations this
 733                          * operations we will disable the device with
 734                          * those as well.
 735                          *
 736                          * This is geared toward devices that have subfunctions
 737                          * that do not show up by default.
 738                          *
 739                          * If a device is a stuff option on the motherboard
 740                          * it may be absent and enable_dev must cope.
 741                          *
 742                          */
 743                         if (dev->chip_ops && dev->chip_ops->enable_dev)
 744                         {
 745                                 dev->chip_ops->enable_dev(dev);
 746                         }
 747                         /* Now read the vendor and device id */
 748                         id = pci_read_config32(dev, PCI_VENDOR_ID);
 749
 750                         /* If the device does not have a pci id disable it.
 751                          * Possibly this is because we have already disabled
 752                          * the device.  But this also handles optional devices
 753                          * that may not always show up.
 754                          */
 755                         if (id == 0xffffffff || id == 0x00000000 ||
 756                                 id == 0x0000ffff || id == 0xffff0000)
 757                         {
 758                                 if (dev->enabled) {
 759                                         printk_info("Disabling static device: %s\n",
 760                                                 dev_path(dev));
 761                                         dev->enabled = 0;
 762                                 }
 763                         }
 764                 }
 765                 /* Read the rest of the pci configuration information */
 766                 hdr_type = pci_read_config8(dev, PCI_HEADER_TYPE);
 767                 class = pci_read_config32(dev, PCI_CLASS_REVISION);
 768
 769                 /* Store the interesting information in the device structure */
 770                 dev->vendor = id & 0xffff;
 771                 dev->device = (id >> 16) & 0xffff;
 772                 dev->hdr_type = hdr_type;
 773                 /* class code, the upper 3 bytes of PCI_CLASS_REVISION */
 774                 dev->class = class >> 8;
 775
 776                 /* Architectural/System devices always need to
 777                  * be bus masters.
 778                  */
 779                 if ((dev->class >> 16) == PCI_BASE_CLASS_SYSTEM) {
 780                         dev->command |= PCI_COMMAND_MASTER;
 781                 }
 782
 783                 /* Look at the vendor and device id, or at least the
 784                  * header type and class and figure out which set of
 785                  * configuration methods to use.  Unless we already
 786                  * have some pci ops.
 787                  */
 788                 set_pci_ops(dev);
 789                 /* Error if we don't have some pci operations for it */
 790                 if (!dev->ops) {
 791                         printk_err("%s No device operations\n",
 792                                 dev_path(dev));
 793                         continue;
 794                 }
 795
 796                 /* Now run the magic enable/disable sequence for the device */
 797                 if (dev->ops && dev->ops->enable) {
 798                         dev->ops->enable(dev);
 799                 }
 800
 801                 printk_debug("%s [%04x/%04x] %s\n",
 802                         dev_path(dev),
 803                         dev->vendor, dev->device,
 804                         dev->enabled?"enabled": "disabled");
 805
 806                 if (PCI_FUNC(devfn) == 0x00 && (hdr_type & 0x80) != 0x80) {
 807                         /* if this is not a multi function device,
 808                          * don't waste time probing another function.
 809                          * Skip to next device.
 810                          */
 811                         devfn += 0x07;
 812                 }
 813         }
 814         post_code(0x25);
 815
 816         /* For all children that implement scan_bus (i.e. bridges)
 817          * scan the bus behind that child.
 818          */
 819         for(child = bus->children; child; child = child->sibling) {
 820                 if (!child->enabled ||
 821                         !child->ops ||
 822                         !child->ops->scan_bus)
 823                 {
 824                         continue;
 825                 }
 826                 max = child->ops->scan_bus(child, max);
 827         }
 828
 829         /*
 830          * We've scanned the bus and so we know all about what's on
 831          * the other side of any bridges that may be on this bus plus
 832          * any devices.
 833          *
 834          * Return how far we've got finding sub-buses.
 835          */
 836         printk_debug("PCI: pci_scan_bus returning with max=%02x\n", max);
 837         post_code(0x55);
 838         return max;
 839 }
 840
 841 /**
 842  * @brief Scan a PCI bridge and the buses behind the bridge.
 843  *
 844  * Determine the existence of buses behind the bridge. Set up the bridge
 845  * according to the result of the scan.
 846  *
 847  * This function is the default scan_bus() method for PCI bridge devices.
 848  *
 849  * @param dev pointer to the bridge device
 850  * @param max the highest bus number assgined up to now
 851  *
 852  * @return The maximum bus number found, after scanning all subordinate busses
 853  */
 854 unsigned int pci_scan_bridge(struct device *dev, unsigned int max)
 855 {
 856         struct bus *bus;
 857         uint32_t buses;
 858         uint16_t cr;
 859
 860         bus = &dev->link[0];
 861         bus->dev = dev;
 862         dev->links = 1;
 863
 864         /* Set up the primary, secondary and subordinate bus numbers. We have
 865          * no idea how many buses are behind this bridge yet, so we set the
 866          * subordinate bus number to 0xff for the moment.
 867          */
 868         bus->secondary = ++max;
 869         bus->subordinate = 0xff;
 870
 871         /* Clear all status bits and turn off memory, I/O and master enables. */
 872         cr = pci_read_config16(dev, PCI_COMMAND);
 873         pci_write_config16(dev, PCI_COMMAND, 0x0000);
 874         pci_write_config16(dev, PCI_STATUS, 0xffff);
 875
 876         /*
 877          * Read the existing primary/secondary/subordinate bus
 878          * number configuration.
 879          */
 880         buses = pci_read_config32(dev, PCI_PRIMARY_BUS);
 881
 882         /* Configure the bus numbers for this bridge: the configuration
 883          * transactions will not be propagated by the bridge if it is not
 884          * correctly configured.
 885          */
 886         buses &= 0xff000000;
 887         buses |= (((unsigned int) (dev->bus->secondary) << 0) |
 888                 ((unsigned int) (bus->secondary) << 8) |
 889                 ((unsigned int) (bus->subordinate) << 16));
 890         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 891
 892         /* Now we can scan all subordinate buses
 893          * i.e. the bus behind the bridge.
 894          */
 895         max = pci_scan_bus(bus, 0x00, 0xff, max);
 896
 897         /* We know the number of buses behind this bridge. Set the subordinate
 898          * bus number to its real value.
 899          */
 900         bus->subordinate = max;
 901         buses = (buses & 0xff00ffff) |
 902                 ((unsigned int) (bus->subordinate) << 16);
 903         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 904         pci_write_config16(dev, PCI_COMMAND, cr);
 905
 906         printk_spew("%s returns max %d\n", __func__, max);
 907         return max;
 908 }
 909
 910 /*
 911     Tell the EISA int controller this int must be level triggered
 912     THIS IS A KLUDGE -- sorry, this needs to get cleaned up.
 913 */
 914 static void pci_level_irq(unsigned char intNum)
 915 {
 916         unsigned short intBits = inb(0x4d0) | (((unsigned) inb(0x4d1)) << 8);
 917
 918         printk_spew("%s: current ints are 0x%x\n", __func__, intBits);
 919         intBits |= (1 << intNum);
 920
 921         printk_spew("%s: try to set ints 0x%x\n", __func__, intBits);
 922
 923         // Write new values
 924         outb((unsigned char) intBits, 0x4d0);
 925         outb((unsigned char) (intBits >> 8), 0x4d1);
 926
 927         /* this seems like an error but is not ... */
 928 #if 1
 929         if (inb(0x4d0) != (intBits & 0xf)) {
 930           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 931                      __func__, intBits &0xf, inb(0x4d0));
 932         }
 933         if (inb(0x4d1) != ((intBits >> 8) & 0xf)) {
 934           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 935                      __func__, (intBits>>8) &0xf, inb(0x4d1));
 936         }
 937 #endif
 938 }
 939
 940 /*
 941     This function assigns IRQs for all functions contained within
 942     the indicated device address.  If the device does not exist or does
 943     not require interrupts then this function has no effect.
 944
 945     This function should be called for each PCI slot in your system.
 946
 947     pIntAtoD is an array of IRQ #s that are assigned to PINTA through PINTD of
 948     this slot.
 949     The particular irq #s that are passed in depend on the routing inside
 950     your southbridge and on your motherboard.
 951
 952     -kevinh@ispiri.com
 953 */
 954 void pci_assign_irqs(unsigned bus, unsigned slot,
 955         const unsigned char pIntAtoD[4])
 956 {
 957         unsigned functNum;
 958         device_t pdev;
 959         unsigned char line;
 960         unsigned char irq;
 961         unsigned char readback;
 962
 963         /* Each slot may contain up to eight functions */
 964         for (functNum = 0; functNum < 8; functNum++) {
 965                 pdev = dev_find_slot(bus, (slot << 3) + functNum);
 966
 967                 if (pdev) {
 968                   line = pci_read_config8(pdev, PCI_INTERRUPT_PIN);
 969
 970                         // PCI spec says all other values are reserved
 971                         if ((line >= 1) && (line <= 4)) {
 972                                 irq = pIntAtoD[line - 1];
 973
 974                                 printk_debug("Assigning IRQ %d to %d:%x.%d\n", \
 975                                         irq, bus, slot, functNum);
 976
 977                                 pci_write_config8(pdev, PCI_INTERRUPT_LINE,\
 978                                         pIntAtoD[line - 1]);
 979
 980                                 readback = pci_read_config8(pdev, PCI_INTERRUPT_LINE);
 981                                 printk_debug("  Readback = %d\n", readback);
 982
 983                                 // Change to level triggered
 984                                 pci_level_irq(pIntAtoD[line - 1]);
 985                         }
 986                 }
 987         }
 988 }