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  * @param bus pointer to the bus structure
 669  * @param min_devfn minimum devfn to look at in the scan usually 0x00
 670  * @param max_devfn maximum devfn to look at in the scan usually 0xff
 671  * @param max current bus number
 672  *
 673  * @return The maximum bus number found, after scanning all subordinate busses
 674  */
 675 unsigned int pci_scan_bus(struct bus *bus,
 676         unsigned min_devfn, unsigned max_devfn,
 677         unsigned int max)
 678 {
 679         unsigned int devfn;
 680         device_t dev;
 681         device_t old_devices;
 682         device_t child;
 683
 684         printk_debug("PCI: pci_scan_bus for bus %d\n", bus->secondary);
 685
 686         old_devices = bus->children;
 687         bus->children = 0;
 688
 689         post_code(0x24);
 690
 691         /* probe all devices/functions on this bus with some optimization for
 692          * non-existence and single funcion devices
 693          */
 694         for (devfn = min_devfn; devfn <= max_devfn; devfn++) {
 695                 uint32_t id, class;
 696                 uint8_t hdr_type;
 697
 698                 /* First thing setup the device structure */
 699                 dev = pci_scan_get_dev(&old_devices, devfn);
 700
 701                 /* Detect if a device is present */
 702                 if (!dev) {
 703                         struct device dummy;
 704                         dummy.bus              = bus;
 705                         dummy.path.type        = DEVICE_PATH_PCI;
 706                         dummy.path.u.pci.devfn = devfn;
 707                         id = pci_read_config32(&dummy, PCI_VENDOR_ID);
 708                         /* some broken boards return 0 if a slot is empty: */
 709                         if ((id == 0xffffffff) || (id == 0x00000000) ||
 710                             (id == 0x0000ffff) || (id == 0xffff0000))
 711                         {
 712                                 printk_spew("PCI: devfn 0x%x, bad id 0x%x\n", devfn, id);
 713                                 if (PCI_FUNC(devfn) == 0x00) {
 714                                         /* if this is a function 0 device and
 715                                          * it is not present,
 716                                          * skip to next device
 717                                          */
 718                                         devfn += 0x07;
 719                                 }
 720                                 /* This function in a multi function device is
 721                                  * not present, skip to the next function.
 722                                  */
 723                                 continue;
 724                         }
 725                         dev = alloc_dev(bus, &dummy.path);
 726                 }
 727                 else {
 728                         /* Enable/disable the device.  Once we have
 729                          * found the device specific operations this
 730                          * operations we will disable the device with
 731                          * those as well.
 732                          *
 733                          * This is geared toward devices that have subfunctions
 734                          * that do not show up by default.
 735                          *
 736                          * If a device is a stuff option on the motherboard
 737                          * it may be absent and enable_dev must cope.
 738                          *
 739                          */
 740                         if (dev->chip_ops && dev->chip_ops->enable_dev)
 741                         {
 742                                 dev->chip_ops->enable_dev(dev);
 743                         }
 744                         /* Now read the vendor and device id */
 745                         id = pci_read_config32(dev, PCI_VENDOR_ID);
 746
 747                         /* If the device does not have a pci id disable it.
 748                          * Possibly this is because we have already disabled
 749                          * the device.  But this also handles optional devices
 750                          * that may not always show up.
 751                          */
 752                         if (id == 0xffffffff || id == 0x00000000 ||
 753                             id == 0x0000ffff || id == 0xffff0000)
 754                         {
 755                                 if (dev->enabled) {
 756                                         printk_info("Disabling static device: %s\n",
 757                                                 dev_path(dev));
 758                                         dev->enabled = 0;
 759                                 }
 760                         }
 761                 }
 762                 /* Read the rest of the pci configuration information */
 763                 hdr_type = pci_read_config8(dev, PCI_HEADER_TYPE);
 764                 class = pci_read_config32(dev, PCI_CLASS_REVISION);
 765
 766                 /* Store the interesting information in the device structure */
 767                 dev->vendor = id & 0xffff;
 768                 dev->device = (id >> 16) & 0xffff;
 769                 dev->hdr_type = hdr_type;
 770                 /* class code, the upper 3 bytes of PCI_CLASS_REVISION */
 771                 dev->class = class >> 8;
 772
 773                 /* Architectural/System devices always need to
 774                  * be bus masters.
 775                  */
 776                 if ((dev->class >> 16) == PCI_BASE_CLASS_SYSTEM) {
 777                         dev->command |= PCI_COMMAND_MASTER;
 778                 }
 779
 780                 /* Look at the vendor and device id, or at least the
 781                  * header type and class and figure out which set of
 782                  * configuration methods to use.  Unless we already
 783                  * have some pci ops.
 784                  */
 785                 set_pci_ops(dev);
 786                 /* Error if we don't have some pci operations for it */
 787                 if (!dev->ops) {
 788                         printk_err("%s No device operations\n",
 789                                 dev_path(dev));
 790                         continue;
 791                 }
 792
 793                 /* Now run the magic enable/disable sequence for the device */
 794                 if (dev->ops && dev->ops->enable) {
 795                         dev->ops->enable(dev);
 796                 }
 797
 798                 printk_debug("%s [%04x/%04x] %s\n",
 799                         dev_path(dev),
 800                         dev->vendor, dev->device,
 801                         dev->enabled?"enabled": "disabled");
 802
 803                 if (PCI_FUNC(devfn) == 0x00 && (hdr_type & 0x80) != 0x80) {
 804                         /* if this is not a multi function device,
 805                          * don't waste time probing another function.
 806                          * Skip to next device.
 807                          */
 808                         devfn += 0x07;
 809                 }
 810         }
 811         post_code(0x25);
 812
 813         /* For all children that implement scan_bus (i.e. bridges)
 814          * scan the bus behind that child.
 815          */
 816         for (child = bus->children; child; child = child->sibling) {
 817                 if (!child->enabled ||
 818                     !child->ops ||
 819                     !child->ops->scan_bus)
 820                 {
 821                         continue;
 822                 }
 823                 max = child->ops->scan_bus(child, max);
 824         }
 825
 826         /*
 827          * We've scanned the bus and so we know all about what's on
 828          * the other side of any bridges that may be on this bus plus
 829          * any devices.
 830          *
 831          * Return how far we've got finding sub-buses.
 832          */
 833         printk_debug("PCI: pci_scan_bus returning with max=%02x\n", max);
 834         post_code(0x55);
 835         return max;
 836 }
 837
 838 /**
 839  * @brief Scan a PCI bridge and the buses behind the bridge.
 840  *
 841  * Determine the existence of buses behind the bridge. Set up the bridge
 842  * according to the result of the scan.
 843  *
 844  * This function is the default scan_bus() method for PCI bridge devices.
 845  *
 846  * @param dev pointer to the bridge device
 847  * @param max the highest bus number assgined up to now
 848  *
 849  * @return The maximum bus number found, after scanning all subordinate busses
 850  */
 851 unsigned int pci_scan_bridge(struct device *dev, unsigned int max)
 852 {
 853         struct bus *bus;
 854         uint32_t buses;
 855         uint16_t cr;
 856
 857         bus = &dev->link[0];
 858         bus->dev = dev;
 859         dev->links = 1;
 860
 861         /* Set up the primary, secondary and subordinate bus numbers. We have
 862          * no idea how many buses are behind this bridge yet, so we set the
 863          * subordinate bus number to 0xff for the moment.
 864          */
 865         bus->secondary = ++max;
 866         bus->subordinate = 0xff;
 867
 868         /* Clear all status bits and turn off memory, I/O and master enables. */
 869         cr = pci_read_config16(dev, PCI_COMMAND);
 870         pci_write_config16(dev, PCI_COMMAND, 0x0000);
 871         pci_write_config16(dev, PCI_STATUS, 0xffff);
 872
 873         /*
 874          * Read the existing primary/secondary/subordinate bus
 875          * number configuration.
 876          */
 877         buses = pci_read_config32(dev, PCI_PRIMARY_BUS);
 878
 879         /* Configure the bus numbers for this bridge: the configuration
 880          * transactions will not be propagated by the bridge if it is not
 881          * correctly configured.
 882          */
 883         buses &= 0xff000000;
 884         buses |= (((unsigned int) (dev->bus->secondary) << 0) |
 885                 ((unsigned int) (bus->secondary) << 8) |
 886                 ((unsigned int) (bus->subordinate) << 16));
 887         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 888
 889         /* Now we can scan all subordinate buses
 890          * i.e. the bus behind the bridge.
 891          */
 892         max = pci_scan_bus(bus, 0x00, 0xff, max);
 893
 894         /* We know the number of buses behind this bridge. Set the subordinate
 895          * bus number to its real value.
 896          */
 897         bus->subordinate = max;
 898         buses = (buses & 0xff00ffff) |
 899                 ((unsigned int) (bus->subordinate) << 16);
 900         pci_write_config32(dev, PCI_PRIMARY_BUS, buses);
 901         pci_write_config16(dev, PCI_COMMAND, cr);
 902
 903         printk_spew("%s returns max %d\n", __func__, max);
 904         return max;
 905 }
 906
 907 /*
 908     Tell the EISA int controller this int must be level triggered
 909     THIS IS A KLUDGE -- sorry, this needs to get cleaned up.
 910 */
 911 static void pci_level_irq(unsigned char intNum)
 912 {
 913         unsigned short intBits = inb(0x4d0) | (((unsigned) inb(0x4d1)) << 8);
 914
 915         printk_spew("%s: current ints are 0x%x\n", __func__, intBits);
 916         intBits |= (1 << intNum);
 917
 918         printk_spew("%s: try to set ints 0x%x\n", __func__, intBits);
 919
 920         // Write new values
 921         outb((unsigned char) intBits, 0x4d0);
 922         outb((unsigned char) (intBits >> 8), 0x4d1);
 923
 924         /* this seems like an error but is not ... */
 925 #if 1
 926         if (inb(0x4d0) != (intBits & 0xf)) {
 927           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 928                      __func__, intBits &0xf, inb(0x4d0));
 929         }
 930         if (inb(0x4d1) != ((intBits >> 8) & 0xf)) {
 931           printk_err("%s: lower order bits are wrong: want 0x%x, got 0x%x\n",
 932                      __func__, (intBits>>8) &0xf, inb(0x4d1));
 933         }
 934 #endif
 935 }
 936
 937 /*
 938     This function assigns IRQs for all functions contained within
 939     the indicated device address.  If the device does not exist or does
 940     not require interrupts then this function has no effect.
 941
 942     This function should be called for each PCI slot in your system.
 943
 944     pIntAtoD is an array of IRQ #s that are assigned to PINTA through PINTD of
 945     this slot.
 946     The particular irq #s that are passed in depend on the routing inside
 947     your southbridge and on your motherboard.
 948
 949     -kevinh@ispiri.com
 950 */
 951 void pci_assign_irqs(unsigned bus, unsigned slot,
 952         const unsigned char pIntAtoD[4])
 953 {
 954         unsigned functNum;
 955         device_t pdev;
 956         unsigned char line;
 957         unsigned char irq;
 958         unsigned char readback;
 959
 960         /* Each slot may contain up to eight functions */
 961         for (functNum = 0; functNum < 8; functNum++) {
 962                 pdev = dev_find_slot(bus, (slot << 3) + functNum);
 963
 964                 if (pdev) {
 965                   line = pci_read_config8(pdev, PCI_INTERRUPT_PIN);
 966
 967                         // PCI spec says all other values are reserved
 968                         if ((line >= 1) && (line <= 4)) {
 969                                 irq = pIntAtoD[line - 1];
 970
 971                                 printk_debug("Assigning IRQ %d to %d:%x.%d\n", \
 972                                         irq, bus, slot, functNum);
 973
 974                                 pci_write_config8(pdev, PCI_INTERRUPT_LINE,\
 975                                         pIntAtoD[line - 1]);
 976
 977                                 readback = pci_read_config8(pdev, PCI_INTERRUPT_LINE);
 978                                 printk_debug("  Readback = %d\n", readback);
 979
 980                                 // Change to level triggered
 981                                 pci_level_irq(pIntAtoD[line - 1]);
 982                         }
 983                 }
 984         }
 985 }