arch/sparc/kernel/pci.c

   1 /* pci.c: UltraSparc PCI controller support.
   2  *
   3  * Copyright (C) 1997, 1998, 1999 David S. Miller ([email protected])
   4  * Copyright (C) 1998, 1999 Eddie C. Dost   ([email protected])
   5  * Copyright (C) 1999 Jakub Jelinek   ([email protected])
   6  *
   7  * OF tree based PCI bus probing taken from the PowerPC port
   8  * with minor modifications, see there for credits.
   9  */
  10
  11 #include <linux/export.h>
  12 #include <linux/kernel.h>
  13 #include <linux/string.h>
  14 #include <linux/sched.h>
  15 #include <linux/capability.h>
  16 #include <linux/errno.h>
  17 #include <linux/pci.h>
  18 #include <linux/msi.h>
  19 #include <linux/irq.h>
  20 #include <linux/init.h>
  21 #include <linux/of.h>
  22 #include <linux/of_device.h>
  23
  24 #include <asm/uaccess.h>
  25 #include <asm/pgtable.h>
  26 #include <asm/irq.h>
  27 #include <asm/prom.h>
  28 #include <asm/apb.h>
  29
  30 #include "pci_impl.h"
  31 #include "kernel.h"
  32
  33 /* List of all PCI controllers found in the system. */
  34 struct pci_pbm_info *pci_pbm_root = NULL;
  35
  36 /* Each PBM found gets a unique index. */
  37 int pci_num_pbms = 0;
  38
  39 volatile int pci_poke_in_progress;
  40 volatile int pci_poke_cpu = -1;
  41 volatile int pci_poke_faulted;
  42
  43 static DEFINE_SPINLOCK(pci_poke_lock);
  44
  45 void pci_config_read8(u8 *addr, u8 *ret)
  46 {
  47         unsigned long flags;
  48         u8 byte;
  49
  50         spin_lock_irqsave(&pci_poke_lock, flags);
  51         pci_poke_cpu = smp_processor_id();
  52         pci_poke_in_progress = 1;
  53         pci_poke_faulted = 0;
  54         __asm__ __volatile__("membar #Sync\n\t"
  55                              "lduba [%1] %2, %0\n\t"
  56                              "membar #Sync"
  57                              : "=r" (byte)
  58                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
  59                              : "memory");
  60         pci_poke_in_progress = 0;
  61         pci_poke_cpu = -1;
  62         if (!pci_poke_faulted)
  63                 *ret = byte;
  64         spin_unlock_irqrestore(&pci_poke_lock, flags);
  65 }
  66
  67 void pci_config_read16(u16 *addr, u16 *ret)
  68 {
  69         unsigned long flags;
  70         u16 word;
  71
  72         spin_lock_irqsave(&pci_poke_lock, flags);
  73         pci_poke_cpu = smp_processor_id();
  74         pci_poke_in_progress = 1;
  75         pci_poke_faulted = 0;
  76         __asm__ __volatile__("membar #Sync\n\t"
  77                              "lduha [%1] %2, %0\n\t"
  78                              "membar #Sync"
  79                              : "=r" (word)
  80                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
  81                              : "memory");
  82         pci_poke_in_progress = 0;
  83         pci_poke_cpu = -1;
  84         if (!pci_poke_faulted)
  85                 *ret = word;
  86         spin_unlock_irqrestore(&pci_poke_lock, flags);
  87 }
  88
  89 void pci_config_read32(u32 *addr, u32 *ret)
  90 {
  91         unsigned long flags;
  92         u32 dword;
  93
  94         spin_lock_irqsave(&pci_poke_lock, flags);
  95         pci_poke_cpu = smp_processor_id();
  96         pci_poke_in_progress = 1;
  97         pci_poke_faulted = 0;
  98         __asm__ __volatile__("membar #Sync\n\t"
  99                              "lduwa [%1] %2, %0\n\t"
 100                              "membar #Sync"
 101                              : "=r" (dword)
 102                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 103                              : "memory");
 104         pci_poke_in_progress = 0;
 105         pci_poke_cpu = -1;
 106         if (!pci_poke_faulted)
 107                 *ret = dword;
 108         spin_unlock_irqrestore(&pci_poke_lock, flags);
 109 }
 110
 111 void pci_config_write8(u8 *addr, u8 val)
 112 {
 113         unsigned long flags;
 114
 115         spin_lock_irqsave(&pci_poke_lock, flags);
 116         pci_poke_cpu = smp_processor_id();
 117         pci_poke_in_progress = 1;
 118         pci_poke_faulted = 0;
 119         __asm__ __volatile__("membar #Sync\n\t"
 120                              "stba %0, [%1] %2\n\t"
 121                              "membar #Sync"
 122                              : /* no outputs */
 123                              : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 124                              : "memory");
 125         pci_poke_in_progress = 0;
 126         pci_poke_cpu = -1;
 127         spin_unlock_irqrestore(&pci_poke_lock, flags);
 128 }
 129
 130 void pci_config_write16(u16 *addr, u16 val)
 131 {
 132         unsigned long flags;
 133
 134         spin_lock_irqsave(&pci_poke_lock, flags);
 135         pci_poke_cpu = smp_processor_id();
 136         pci_poke_in_progress = 1;
 137         pci_poke_faulted = 0;
 138         __asm__ __volatile__("membar #Sync\n\t"
 139                              "stha %0, [%1] %2\n\t"
 140                              "membar #Sync"
 141                              : /* no outputs */
 142                              : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 143                              : "memory");
 144         pci_poke_in_progress = 0;
 145         pci_poke_cpu = -1;
 146         spin_unlock_irqrestore(&pci_poke_lock, flags);
 147 }
 148
 149 void pci_config_write32(u32 *addr, u32 val)
 150 {
 151         unsigned long flags;
 152
 153         spin_lock_irqsave(&pci_poke_lock, flags);
 154         pci_poke_cpu = smp_processor_id();
 155         pci_poke_in_progress = 1;
 156         pci_poke_faulted = 0;
 157         __asm__ __volatile__("membar #Sync\n\t"
 158                              "stwa %0, [%1] %2\n\t"
 159                              "membar #Sync"
 160                              : /* no outputs */
 161                              : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 162                              : "memory");
 163         pci_poke_in_progress = 0;
 164         pci_poke_cpu = -1;
 165         spin_unlock_irqrestore(&pci_poke_lock, flags);
 166 }
 167
 168 static int ofpci_verbose;
 169
 170 static int __init ofpci_debug(char *str)
 171 {
 172         int val = 0;
 173
 174         get_option(&str, &val);
 175         if (val)
 176                 ofpci_verbose = 1;
 177         return 1;
 178 }
 179
 180 __setup("ofpci_debug=", ofpci_debug);
 181
 182 static unsigned long pci_parse_of_flags(u32 addr0)
 183 {
 184         unsigned long flags = 0;
 185
 186         if (addr0 & 0x02000000) {
 187                 flags = IORESOURCE_MEM | PCI_BASE_ADDRESS_SPACE_MEMORY;
 188                 flags |= (addr0 >> 22) & PCI_BASE_ADDRESS_MEM_TYPE_64;
 189                 flags |= (addr0 >> 28) & PCI_BASE_ADDRESS_MEM_TYPE_1M;
 190                 if (addr0 & 0x40000000)
 191                         flags |= IORESOURCE_PREFETCH
 192                                  | PCI_BASE_ADDRESS_MEM_PREFETCH;
 193         } else if (addr0 & 0x01000000)
 194                 flags = IORESOURCE_IO | PCI_BASE_ADDRESS_SPACE_IO;
 195         return flags;
 196 }
 197
 198 /* The of_device layer has translated all of the assigned-address properties
 199  * into physical address resources, we only have to figure out the register
 200  * mapping.
 201  */
 202 static void pci_parse_of_addrs(struct platform_device *op,
 203                                struct device_node *node,
 204                                struct pci_dev *dev)
 205 {
 206         struct resource *op_res;
 207         const u32 *addrs;
 208         int proplen;
 209
 210         addrs = of_get_property(node, "assigned-addresses", &proplen);
 211         if (!addrs)
 212                 return;
 213         if (ofpci_verbose)
 214                 printk("    parse addresses (%d bytes) @ %p\n",
 215                        proplen, addrs);
 216         op_res = &op->resource[0];
 217         for (; proplen >= 20; proplen -= 20, addrs += 5, op_res++) {
 218                 struct resource *res;
 219                 unsigned long flags;
 220                 int i;
 221
 222                 flags = pci_parse_of_flags(addrs[0]);
 223                 if (!flags)
 224                         continue;
 225                 i = addrs[0] & 0xff;
 226                 if (ofpci_verbose)
 227                         printk("  start: %llx, end: %llx, i: %x\n",
 228                                op_res->start, op_res->end, i);
 229
 230                 if (PCI_BASE_ADDRESS_0 <= i && i <= PCI_BASE_ADDRESS_5) {
 231                         res = &dev->resource[(i - PCI_BASE_ADDRESS_0) >> 2];
 232                 } else if (i == dev->rom_base_reg) {
 233                         res = &dev->resource[PCI_ROM_RESOURCE];
 234                         flags |= IORESOURCE_READONLY | IORESOURCE_CACHEABLE
 235                               | IORESOURCE_SIZEALIGN;
 236                 } else {
 237                         printk(KERN_ERR "PCI: bad cfg reg num 0x%x\n", i);
 238                         continue;
 239                 }
 240                 res->start = op_res->start;
 241                 res->end = op_res->end;
 242                 res->flags = flags;
 243                 res->name = pci_name(dev);
 244         }
 245 }
 246
 247 static struct pci_dev *of_create_pci_dev(struct pci_pbm_info *pbm,
 248                                          struct device_node *node,
 249                                          struct pci_bus *bus, int devfn)
 250 {
 251         struct dev_archdata *sd;
 252         struct platform_device *op;
 253         struct pci_dev *dev;
 254         const char *type;
 255         u32 class;
 256
 257         dev = pci_alloc_dev(bus);
 258         if (!dev)
 259                 return NULL;
 260
 261         sd = &dev->dev.archdata;
 262         sd->iommu = pbm->iommu;
 263         sd->stc = &pbm->stc;
 264         sd->host_controller = pbm;
 265         sd->op = op = of_find_device_by_node(node);
 266         sd->numa_node = pbm->numa_node;
 267
 268         sd = &op->dev.archdata;
 269         sd->iommu = pbm->iommu;
 270         sd->stc = &pbm->stc;
 271         sd->numa_node = pbm->numa_node;
 272
 273         if (!strcmp(node->name, "ebus"))
 274                 of_propagate_archdata(op);
 275
 276         type = of_get_property(node, "device_type", NULL);
 277         if (type == NULL)
 278                 type = "";
 279
 280         if (ofpci_verbose)
 281                 printk("    create device, devfn: %x, type: %s\n",
 282                        devfn, type);
 283
 284         dev->sysdata = node;
 285         dev->dev.parent = bus->bridge;
 286         dev->dev.bus = &pci_bus_type;
 287         dev->dev.of_node = of_node_get(node);
 288         dev->devfn = devfn;
 289         dev->multifunction = 0;         /* maybe a lie? */
 290         set_pcie_port_type(dev);
 291
 292         pci_dev_assign_slot(dev);
 293         dev->vendor = of_getintprop_default(node, "vendor-id", 0xffff);
 294         dev->device = of_getintprop_default(node, "device-id", 0xffff);
 295         dev->subsystem_vendor =
 296                 of_getintprop_default(node, "subsystem-vendor-id", 0);
 297         dev->subsystem_device =
 298                 of_getintprop_default(node, "subsystem-id", 0);
 299
 300         dev->cfg_size = pci_cfg_space_size(dev);
 301
 302         /* We can't actually use the firmware value, we have
 303          * to read what is in the register right now.  One
 304          * reason is that in the case of IDE interfaces the
 305          * firmware can sample the value before the the IDE
 306          * interface is programmed into native mode.
 307          */
 308         pci_read_config_dword(dev, PCI_CLASS_REVISION, &class);
 309         dev->class = class >> 8;
 310         dev->revision = class & 0xff;
 311
 312         dev_set_name(&dev->dev, "%04x:%02x:%02x.%d", pci_domain_nr(bus),
 313                 dev->bus->number, PCI_SLOT(devfn), PCI_FUNC(devfn));
 314
 315         if (ofpci_verbose)
 316                 printk("    class: 0x%x device name: %s\n",
 317                        dev->class, pci_name(dev));
 318
 319         /* I have seen IDE devices which will not respond to
 320          * the bmdma simplex check reads if bus mastering is
 321          * disabled.
 322          */
 323         if ((dev->class >> 8) == PCI_CLASS_STORAGE_IDE)
 324                 pci_set_master(dev);
 325
 326         dev->current_state = PCI_UNKNOWN;       /* unknown power state */
 327         dev->error_state = pci_channel_io_normal;
 328         dev->dma_mask = 0xffffffff;
 329
 330         if (!strcmp(node->name, "pci")) {
 331                 /* a PCI-PCI bridge */
 332                 dev->hdr_type = PCI_HEADER_TYPE_BRIDGE;
 333                 dev->rom_base_reg = PCI_ROM_ADDRESS1;
 334         } else if (!strcmp(type, "cardbus")) {
 335                 dev->hdr_type = PCI_HEADER_TYPE_CARDBUS;
 336         } else {
 337                 dev->hdr_type = PCI_HEADER_TYPE_NORMAL;
 338                 dev->rom_base_reg = PCI_ROM_ADDRESS;
 339
 340                 dev->irq = sd->op->archdata.irqs[0];
 341                 if (dev->irq == 0xffffffff)
 342                         dev->irq = PCI_IRQ_NONE;
 343         }
 344
 345         pci_parse_of_addrs(sd->op, node, dev);
 346
 347         if (ofpci_verbose)
 348                 printk("    adding to system ...\n");
 349
 350         pci_device_add(dev, bus);
 351
 352         return dev;
 353 }
 354
 355 static void apb_calc_first_last(u8 map, u32 *first_p, u32 *last_p)
 356 {
 357         u32 idx, first, last;
 358
 359         first = 8;
 360         last = 0;
 361         for (idx = 0; idx < 8; idx++) {
 362                 if ((map & (1 << idx)) != 0) {
 363                         if (first > idx)
 364                                 first = idx;
 365                         if (last < idx)
 366                                 last = idx;
 367                 }
 368         }
 369
 370         *first_p = first;
 371         *last_p = last;
 372 }
 373
 374 /* Cook up fake bus resources for SUNW,simba PCI bridges which lack
 375  * a proper 'ranges' property.
 376  */
 377 static void apb_fake_ranges(struct pci_dev *dev,
 378                             struct pci_bus *bus,
 379                             struct pci_pbm_info *pbm)
 380 {
 381         struct pci_bus_region region;
 382         struct resource *res;
 383         u32 first, last;
 384         u8 map;
 385
 386         pci_read_config_byte(dev, APB_IO_ADDRESS_MAP, &map);
 387         apb_calc_first_last(map, &first, &last);
 388         res = bus->resource[0];
 389         res->flags = IORESOURCE_IO;
 390         region.start = (first << 21);
 391         region.end = (last << 21) + ((1 << 21) - 1);
 392         pcibios_bus_to_resource(dev->bus, res, &region);
 393
 394         pci_read_config_byte(dev, APB_MEM_ADDRESS_MAP, &map);
 395         apb_calc_first_last(map, &first, &last);
 396         res = bus->resource[1];
 397         res->flags = IORESOURCE_MEM;
 398         region.start = (first << 29);
 399         region.end = (last << 29) + ((1 << 29) - 1);
 400         pcibios_bus_to_resource(dev->bus, res, &region);
 401 }
 402
 403 static void pci_of_scan_bus(struct pci_pbm_info *pbm,
 404                             struct device_node *node,
 405                             struct pci_bus *bus);
 406
 407 #define GET_64BIT(prop, i)      ((((u64) (prop)[(i)]) << 32) | (prop)[(i)+1])
 408
 409 static void of_scan_pci_bridge(struct pci_pbm_info *pbm,
 410                                struct device_node *node,
 411                                struct pci_dev *dev)
 412 {
 413         struct pci_bus *bus;
 414         const u32 *busrange, *ranges;
 415         int len, i, simba;
 416         struct pci_bus_region region;
 417         struct resource *res;
 418         unsigned int flags;
 419         u64 size;
 420
 421         if (ofpci_verbose)
 422                 printk("of_scan_pci_bridge(%s)\n", node->full_name);
 423
 424         /* parse bus-range property */
 425         busrange = of_get_property(node, "bus-range", &len);
 426         if (busrange == NULL || len != 8) {
 427                 printk(KERN_DEBUG "Can't get bus-range for PCI-PCI bridge %s\n",
 428                        node->full_name);
 429                 return;
 430         }
 431
 432         if (ofpci_verbose)
 433                 printk("    Bridge bus range [%u --> %u]\n",
 434                        busrange[0], busrange[1]);
 435
 436         ranges = of_get_property(node, "ranges", &len);
 437         simba = 0;
 438         if (ranges == NULL) {
 439                 const char *model = of_get_property(node, "model", NULL);
 440                 if (model && !strcmp(model, "SUNW,simba"))
 441                         simba = 1;
 442         }
 443
 444         bus = pci_add_new_bus(dev->bus, dev, busrange[0]);
 445         if (!bus) {
 446                 printk(KERN_ERR "Failed to create pci bus for %s\n",
 447                        node->full_name);
 448                 return;
 449         }
 450
 451         bus->primary = dev->bus->number;
 452         pci_bus_insert_busn_res(bus, busrange[0], busrange[1]);
 453         bus->bridge_ctl = 0;
 454
 455         if (ofpci_verbose)
 456                 printk("    Bridge ranges[%p] simba[%d]\n",
 457                        ranges, simba);
 458
 459         /* parse ranges property, or cook one up by hand for Simba */
 460         /* PCI #address-cells == 3 and #size-cells == 2 always */
 461         res = &dev->resource[PCI_BRIDGE_RESOURCES];
 462         for (i = 0; i < PCI_NUM_RESOURCES - PCI_BRIDGE_RESOURCES; ++i) {
 463                 res->flags = 0;
 464                 bus->resource[i] = res;
 465                 ++res;
 466         }
 467         if (simba) {
 468                 apb_fake_ranges(dev, bus, pbm);
 469                 goto after_ranges;
 470         } else if (ranges == NULL) {
 471                 pci_read_bridge_bases(bus);
 472                 goto after_ranges;
 473         }
 474         i = 1;
 475         for (; len >= 32; len -= 32, ranges += 8) {
 476                 u64 start;
 477
 478                 if (ofpci_verbose)
 479                         printk("    RAW Range[%08x:%08x:%08x:%08x:%08x:%08x:"
 480                                "%08x:%08x]\n",
 481                                ranges[0], ranges[1], ranges[2], ranges[3],
 482                                ranges[4], ranges[5], ranges[6], ranges[7]);
 483
 484                 flags = pci_parse_of_flags(ranges[0]);
 485                 size = GET_64BIT(ranges, 6);
 486                 if (flags == 0 || size == 0)
 487                         continue;
 488
 489                 /* On PCI-Express systems, PCI bridges that have no devices downstream
 490                  * have a bogus size value where the first 32-bit cell is 0xffffffff.
 491                  * This results in a bogus range where start + size overflows.
 492                  *
 493                  * Just skip these otherwise the kernel will complain when the resource
 494                  * tries to be claimed.
 495                  */
 496                 if (size >> 32 == 0xffffffff)
 497                         continue;
 498
 499                 if (flags & IORESOURCE_IO) {
 500                         res = bus->resource[0];
 501                         if (res->flags) {
 502                                 printk(KERN_ERR "PCI: ignoring extra I/O range"
 503                                        " for bridge %s\n", node->full_name);
 504                                 continue;
 505                         }
 506                 } else {
 507                         if (i >= PCI_NUM_RESOURCES - PCI_BRIDGE_RESOURCES) {
 508                                 printk(KERN_ERR "PCI: too many memory ranges"
 509                                        " for bridge %s\n", node->full_name);
 510                                 continue;
 511                         }
 512                         res = bus->resource[i];
 513                         ++i;
 514                 }
 515
 516                 res->flags = flags;
 517                 region.start = start = GET_64BIT(ranges, 1);
 518                 region.end = region.start + size - 1;
 519
 520                 if (ofpci_verbose)
 521                         printk("      Using flags[%08x] start[%016llx] size[%016llx]\n",
 522                                flags, start, size);
 523
 524                 pcibios_bus_to_resource(dev->bus, res, &region);
 525         }
 526 after_ranges:
 527         sprintf(bus->name, "PCI Bus %04x:%02x", pci_domain_nr(bus),
 528                 bus->number);
 529         if (ofpci_verbose)
 530                 printk("    bus name: %s\n", bus->name);
 531
 532         pci_of_scan_bus(pbm, node, bus);
 533 }
 534
 535 static void pci_of_scan_bus(struct pci_pbm_info *pbm,
 536                             struct device_node *node,
 537                             struct pci_bus *bus)
 538 {
 539         struct device_node *child;
 540         const u32 *reg;
 541         int reglen, devfn, prev_devfn;
 542         struct pci_dev *dev;
 543
 544         if (ofpci_verbose)
 545                 printk("PCI: scan_bus[%s] bus no %d\n",
 546                        node->full_name, bus->number);
 547
 548         child = NULL;
 549         prev_devfn = -1;
 550         while ((child = of_get_next_child(node, child)) != NULL) {
 551                 if (ofpci_verbose)
 552                         printk("  * %s\n", child->full_name);
 553                 reg = of_get_property(child, "reg", &reglen);
 554                 if (reg == NULL || reglen < 20)
 555                         continue;
 556
 557                 devfn = (reg[0] >> 8) & 0xff;
 558
 559                 /* This is a workaround for some device trees
 560                  * which list PCI devices twice.  On the V100
 561                  * for example, device number 3 is listed twice.
 562                  * Once as "pm" and once again as "lomp".
 563                  */
 564                 if (devfn == prev_devfn)
 565                         continue;
 566                 prev_devfn = devfn;
 567
 568                 /* create a new pci_dev for this device */
 569                 dev = of_create_pci_dev(pbm, child, bus, devfn);
 570                 if (!dev)
 571                         continue;
 572                 if (ofpci_verbose)
 573                         printk("PCI: dev header type: %x\n",
 574                                dev->hdr_type);
 575
 576                 if (pci_is_bridge(dev))
 577                         of_scan_pci_bridge(pbm, child, dev);
 578         }
 579 }
 580
 581 static ssize_t
 582 show_pciobppath_attr(struct device * dev, struct device_attribute * attr, char * buf)
 583 {
 584         struct pci_dev *pdev;
 585         struct device_node *dp;
 586
 587         pdev = to_pci_dev(dev);
 588         dp = pdev->dev.of_node;
 589
 590         return snprintf (buf, PAGE_SIZE, "%s\n", dp->full_name);
 591 }
 592
 593 static DEVICE_ATTR(obppath, S_IRUSR | S_IRGRP | S_IROTH, show_pciobppath_attr, NULL);
 594
 595 static void pci_bus_register_of_sysfs(struct pci_bus *bus)
 596 {
 597         struct pci_dev *dev;
 598         struct pci_bus *child_bus;
 599         int err;
 600
 601         list_for_each_entry(dev, &bus->devices, bus_list) {
 602                 /* we don't really care if we can create this file or
 603                  * not, but we need to assign the result of the call
 604                  * or the world will fall under alien invasion and
 605                  * everybody will be frozen on a spaceship ready to be
 606                  * eaten on alpha centauri by some green and jelly
 607                  * humanoid.
 608                  */
 609                 err = sysfs_create_file(&dev->dev.kobj, &dev_attr_obppath.attr);
 610                 (void) err;
 611         }
 612         list_for_each_entry(child_bus, &bus->children, node)
 613                 pci_bus_register_of_sysfs(child_bus);
 614 }
 615
 616 static void pci_claim_bus_resources(struct pci_bus *bus)
 617 {
 618         struct pci_bus *child_bus;
 619         struct pci_dev *dev;
 620
 621         list_for_each_entry(dev, &bus->devices, bus_list) {
 622                 int i;
 623
 624                 for (i = 0; i < PCI_NUM_RESOURCES; i++) {
 625                         struct resource *r = &dev->resource[i];
 626
 627                         if (r->parent || !r->start || !r->flags)
 628                                 continue;
 629
 630                         if (ofpci_verbose)
 631                                 printk("PCI: Claiming %s: "
 632                                        "Resource %d: %016llx..%016llx [%x]\n",
 633                                        pci_name(dev), i,
 634                                        (unsigned long long)r->start,
 635                                        (unsigned long long)r->end,
 636                                        (unsigned int)r->flags);
 637
 638                         pci_claim_resource(dev, i);
 639                 }
 640         }
 641
 642         list_for_each_entry(child_bus, &bus->children, node)
 643                 pci_claim_bus_resources(child_bus);
 644 }
 645
 646 struct pci_bus *pci_scan_one_pbm(struct pci_pbm_info *pbm,
 647                                  struct device *parent)
 648 {
 649         LIST_HEAD(resources);
 650         struct device_node *node = pbm->op->dev.of_node;
 651         struct pci_bus *bus;
 652
 653         printk("PCI: Scanning PBM %s\n", node->full_name);
 654
 655         pci_add_resource_offset(&resources, &pbm->io_space,
 656                                 pbm->io_space.start);
 657         pci_add_resource_offset(&resources, &pbm->mem_space,
 658                                 pbm->mem_space.start);
 659         pbm->busn.start = pbm->pci_first_busno;
 660         pbm->busn.end   = pbm->pci_last_busno;
 661         pbm->busn.flags = IORESOURCE_BUS;
 662         pci_add_resource(&resources, &pbm->busn);
 663         bus = pci_create_root_bus(parent, pbm->pci_first_busno, pbm->pci_ops,
 664                                   pbm, &resources);
 665         if (!bus) {
 666                 printk(KERN_ERR "Failed to create bus for %s\n",
 667                        node->full_name);
 668                 pci_free_resource_list(&resources);
 669                 return NULL;
 670         }
 671
 672         pci_of_scan_bus(pbm, node, bus);
 673         pci_bus_register_of_sysfs(bus);
 674
 675         pci_claim_bus_resources(bus);
 676         pci_bus_add_devices(bus);
 677         return bus;
 678 }
 679
 680 void pcibios_fixup_bus(struct pci_bus *pbus)
 681 {
 682 }
 683
 684 resource_size_t pcibios_align_resource(void *data, const struct resource *res,
 685                                 resource_size_t size, resource_size_t align)
 686 {
 687         return res->start;
 688 }
 689
 690 int pcibios_enable_device(struct pci_dev *dev, int mask)
 691 {
 692         u16 cmd, oldcmd;
 693         int i;
 694
 695         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 696         oldcmd = cmd;
 697
 698         for (i = 0; i < PCI_NUM_RESOURCES; i++) {
 699                 struct resource *res = &dev->resource[i];
 700
 701                 /* Only set up the requested stuff */
 702                 if (!(mask & (1<<i)))
 703                         continue;
 704
 705                 if (res->flags & IORESOURCE_IO)
 706                         cmd |= PCI_COMMAND_IO;
 707                 if (res->flags & IORESOURCE_MEM)
 708                         cmd |= PCI_COMMAND_MEMORY;
 709         }
 710
 711         if (cmd != oldcmd) {
 712                 printk(KERN_DEBUG "PCI: Enabling device: (%s), cmd %x\n",
 713                        pci_name(dev), cmd);
 714                 /* Enable the appropriate bits in the PCI command register.  */
 715                 pci_write_config_word(dev, PCI_COMMAND, cmd);
 716         }
 717         return 0;
 718 }
 719
 720 /* Platform support for /proc/bus/pci/X/Y mmap()s. */
 721
 722 /* If the user uses a host-bridge as the PCI device, he may use
 723  * this to perform a raw mmap() of the I/O or MEM space behind
 724  * that controller.
 725  *
 726  * This can be useful for execution of x86 PCI bios initialization code
 727  * on a PCI card, like the xfree86 int10 stuff does.
 728  */
 729 static int __pci_mmap_make_offset_bus(struct pci_dev *pdev, struct vm_area_struct *vma,
 730                                       enum pci_mmap_state mmap_state)
 731 {
 732         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
 733         unsigned long space_size, user_offset, user_size;
 734
 735         if (mmap_state == pci_mmap_io) {
 736                 space_size = resource_size(&pbm->io_space);
 737         } else {
 738                 space_size = resource_size(&pbm->mem_space);
 739         }
 740
 741         /* Make sure the request is in range. */
 742         user_offset = vma->vm_pgoff << PAGE_SHIFT;
 743         user_size = vma->vm_end - vma->vm_start;
 744
 745         if (user_offset >= space_size ||
 746             (user_offset + user_size) > space_size)
 747                 return -EINVAL;
 748
 749         if (mmap_state == pci_mmap_io) {
 750                 vma->vm_pgoff = (pbm->io_space.start +
 751                                  user_offset) >> PAGE_SHIFT;
 752         } else {
 753                 vma->vm_pgoff = (pbm->mem_space.start +
 754                                  user_offset) >> PAGE_SHIFT;
 755         }
 756
 757         return 0;
 758 }
 759
 760 /* Adjust vm_pgoff of VMA such that it is the physical page offset
 761  * corresponding to the 32-bit pci bus offset for DEV requested by the user.
 762  *
 763  * Basically, the user finds the base address for his device which he wishes
 764  * to mmap.  They read the 32-bit value from the config space base register,
 765  * add whatever PAGE_SIZE multiple offset they wish, and feed this into the
 766  * offset parameter of mmap on /proc/bus/pci/XXX for that device.
 767  *
 768  * Returns negative error code on failure, zero on success.
 769  */
 770 static int __pci_mmap_make_offset(struct pci_dev *pdev,
 771                                   struct vm_area_struct *vma,
 772                                   enum pci_mmap_state mmap_state)
 773 {
 774         unsigned long user_paddr, user_size;
 775         int i, err;
 776
 777         /* First compute the physical address in vma->vm_pgoff,
 778          * making sure the user offset is within range in the
 779          * appropriate PCI space.
 780          */
 781         err = __pci_mmap_make_offset_bus(pdev, vma, mmap_state);
 782         if (err)
 783                 return err;
 784
 785         /* If this is a mapping on a host bridge, any address
 786          * is OK.
 787          */
 788         if ((pdev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
 789                 return err;
 790
 791         /* Otherwise make sure it's in the range for one of the
 792          * device's resources.
 793          */
 794         user_paddr = vma->vm_pgoff << PAGE_SHIFT;
 795         user_size = vma->vm_end - vma->vm_start;
 796
 797         for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
 798                 struct resource *rp = &pdev->resource[i];
 799                 resource_size_t aligned_end;
 800
 801                 /* Active? */
 802                 if (!rp->flags)
 803                         continue;
 804
 805                 /* Same type? */
 806                 if (i == PCI_ROM_RESOURCE) {
 807                         if (mmap_state != pci_mmap_mem)
 808                                 continue;
 809                 } else {
 810                         if ((mmap_state == pci_mmap_io &&
 811                              (rp->flags & IORESOURCE_IO) == 0) ||
 812                             (mmap_state == pci_mmap_mem &&
 813                              (rp->flags & IORESOURCE_MEM) == 0))
 814                                 continue;
 815                 }
 816
 817                 /* Align the resource end to the next page address.
 818                  * PAGE_SIZE intentionally added instead of (PAGE_SIZE - 1),
 819                  * because actually we need the address of the next byte
 820                  * after rp->end.
 821                  */
 822                 aligned_end = (rp->end + PAGE_SIZE) & PAGE_MASK;
 823
 824                 if ((rp->start <= user_paddr) &&
 825                     (user_paddr + user_size) <= aligned_end)
 826                         break;
 827         }
 828
 829         if (i > PCI_ROM_RESOURCE)
 830                 return -EINVAL;
 831
 832         return 0;
 833 }
 834
 835 /* Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
 836  * device mapping.
 837  */
 838 static void __pci_mmap_set_pgprot(struct pci_dev *dev, struct vm_area_struct *vma,
 839                                              enum pci_mmap_state mmap_state)
 840 {
 841         /* Our io_remap_pfn_range takes care of this, do nothing.  */
 842 }
 843
 844 /* Perform the actual remap of the pages for a PCI device mapping, as appropriate
 845  * for this architecture.  The region in the process to map is described by vm_start
 846  * and vm_end members of VMA, the base physical address is found in vm_pgoff.
 847  * The pci device structure is provided so that architectures may make mapping
 848  * decisions on a per-device or per-bus basis.
 849  *
 850  * Returns a negative error code on failure, zero on success.
 851  */
 852 int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
 853                         enum pci_mmap_state mmap_state,
 854                         int write_combine)
 855 {
 856         int ret;
 857
 858         ret = __pci_mmap_make_offset(dev, vma, mmap_state);
 859         if (ret < 0)
 860                 return ret;
 861
 862         __pci_mmap_set_pgprot(dev, vma, mmap_state);
 863
 864         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 865         ret = io_remap_pfn_range(vma, vma->vm_start,
 866                                  vma->vm_pgoff,
 867                                  vma->vm_end - vma->vm_start,
 868                                  vma->vm_page_prot);
 869         if (ret)
 870                 return ret;
 871
 872         return 0;
 873 }
 874
 875 #ifdef CONFIG_NUMA
 876 int pcibus_to_node(struct pci_bus *pbus)
 877 {
 878         struct pci_pbm_info *pbm = pbus->sysdata;
 879
 880         return pbm->numa_node;
 881 }
 882 EXPORT_SYMBOL(pcibus_to_node);
 883 #endif
 884
 885 /* Return the domain number for this pci bus */
 886
 887 int pci_domain_nr(struct pci_bus *pbus)
 888 {
 889         struct pci_pbm_info *pbm = pbus->sysdata;
 890         int ret;
 891
 892         if (!pbm) {
 893                 ret = -ENXIO;
 894         } else {
 895                 ret = pbm->index;
 896         }
 897
 898         return ret;
 899 }
 900 EXPORT_SYMBOL(pci_domain_nr);
 901
 902 #ifdef CONFIG_PCI_MSI
 903 int arch_setup_msi_irq(struct pci_dev *pdev, struct msi_desc *desc)
 904 {
 905         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
 906         unsigned int irq;
 907
 908         if (!pbm->setup_msi_irq)
 909                 return -EINVAL;
 910
 911         return pbm->setup_msi_irq(&irq, pdev, desc);
 912 }
 913
 914 void arch_teardown_msi_irq(unsigned int irq)
 915 {
 916         struct msi_desc *entry = irq_get_msi_desc(irq);
 917         struct pci_dev *pdev = msi_desc_to_pci_dev(entry);
 918         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
 919
 920         if (pbm->teardown_msi_irq)
 921                 pbm->teardown_msi_irq(irq, pdev);
 922 }
 923 #endif /* !(CONFIG_PCI_MSI) */
 924
 925 static void ali_sound_dma_hack(struct pci_dev *pdev, int set_bit)
 926 {
 927         struct pci_dev *ali_isa_bridge;
 928         u8 val;
 929
 930         /* ALI sound chips generate 31-bits of DMA, a special register
 931          * determines what bit 31 is emitted as.
 932          */
 933         ali_isa_bridge = pci_get_device(PCI_VENDOR_ID_AL,
 934                                          PCI_DEVICE_ID_AL_M1533,
 935                                          NULL);
 936
 937         pci_read_config_byte(ali_isa_bridge, 0x7e, &val);
 938         if (set_bit)
 939                 val |= 0x01;
 940         else
 941                 val &= ~0x01;
 942         pci_write_config_byte(ali_isa_bridge, 0x7e, val);
 943         pci_dev_put(ali_isa_bridge);
 944 }
 945
 946 int pci64_dma_supported(struct pci_dev *pdev, u64 device_mask)
 947 {
 948         u64 dma_addr_mask;
 949
 950         if (pdev == NULL) {
 951                 dma_addr_mask = 0xffffffff;
 952         } else {
 953                 struct iommu *iommu = pdev->dev.archdata.iommu;
 954
 955                 dma_addr_mask = iommu->dma_addr_mask;
 956
 957                 if (pdev->vendor == PCI_VENDOR_ID_AL &&
 958                     pdev->device == PCI_DEVICE_ID_AL_M5451 &&
 959                     device_mask == 0x7fffffff) {
 960                         ali_sound_dma_hack(pdev,
 961                                            (dma_addr_mask & 0x80000000) != 0);
 962                         return 1;
 963                 }
 964         }
 965
 966         if (device_mask >= (1UL << 32UL))
 967                 return 0;
 968
 969         return (device_mask & dma_addr_mask) == dma_addr_mask;
 970 }
 971
 972 void pci_resource_to_user(const struct pci_dev *pdev, int bar,
 973                           const struct resource *rp, resource_size_t *start,
 974                           resource_size_t *end)
 975 {
 976         struct pci_pbm_info *pbm = pdev->dev.archdata.host_controller;
 977         unsigned long offset;
 978
 979         if (rp->flags & IORESOURCE_IO)
 980                 offset = pbm->io_space.start;
 981         else
 982                 offset = pbm->mem_space.start;
 983
 984         *start = rp->start - offset;
 985         *end = rp->end - offset;
 986 }
 987
 988 void pcibios_set_master(struct pci_dev *dev)
 989 {
 990         /* No special bus mastering setup handling */
 991 }
 992
 993 static int __init pcibios_init(void)
 994 {
 995         pci_dfl_cache_line_size = 64 >> 2;
 996         return 0;
 997 }
 998 subsys_initcall(pcibios_init);
 999
1000 #ifdef CONFIG_SYSFS
1001
1002 #define SLOT_NAME_SIZE  11  /* Max decimal digits + null in u32 */
1003
1004 static void pcie_bus_slot_names(struct pci_bus *pbus)
1005 {
1006         struct pci_dev *pdev;
1007         struct pci_bus *bus;
1008
1009         list_for_each_entry(pdev, &pbus->devices, bus_list) {
1010                 char name[SLOT_NAME_SIZE];
1011                 struct pci_slot *pci_slot;
1012                 const u32 *slot_num;
1013                 int len;
1014
1015                 slot_num = of_get_property(pdev->dev.of_node,
1016                                            "physical-slot#", &len);
1017
1018                 if (slot_num == NULL || len != 4)
1019                         continue;
1020
1021                 snprintf(name, sizeof(name), "%u", slot_num[0]);
1022                 pci_slot = pci_create_slot(pbus, slot_num[0], name, NULL);
1023
1024                 if (IS_ERR(pci_slot))
1025                         pr_err("PCI: pci_create_slot returned %ld.\n",
1026                                PTR_ERR(pci_slot));
1027         }
1028
1029         list_for_each_entry(bus, &pbus->children, node)
1030                 pcie_bus_slot_names(bus);
1031 }
1032
1033 static void pci_bus_slot_names(struct device_node *node, struct pci_bus *bus)
1034 {
1035         const struct pci_slot_names {
1036                 u32     slot_mask;
1037                 char    names[0];
1038         } *prop;
1039         const char *sp;
1040         int len, i;
1041         u32 mask;
1042
1043         prop = of_get_property(node, "slot-names", &len);
1044         if (!prop)
1045                 return;
1046
1047         mask = prop->slot_mask;
1048         sp = prop->names;
1049
1050         if (ofpci_verbose)
1051                 printk("PCI: Making slots for [%s] mask[0x%02x]\n",
1052                        node->full_name, mask);
1053
1054         i = 0;
1055         while (mask) {
1056                 struct pci_slot *pci_slot;
1057                 u32 this_bit = 1 << i;
1058
1059                 if (!(mask & this_bit)) {
1060                         i++;
1061                         continue;
1062                 }
1063
1064                 if (ofpci_verbose)
1065                         printk("PCI: Making slot [%s]\n", sp);
1066
1067                 pci_slot = pci_create_slot(bus, i, sp, NULL);
1068                 if (IS_ERR(pci_slot))
1069                         printk(KERN_ERR "PCI: pci_create_slot returned %ld\n",
1070                                PTR_ERR(pci_slot));
1071
1072                 sp += strlen(sp) + 1;
1073                 mask &= ~this_bit;
1074                 i++;
1075         }
1076 }
1077
1078 static int __init of_pci_slot_init(void)
1079 {
1080         struct pci_bus *pbus = NULL;
1081
1082         while ((pbus = pci_find_next_bus(pbus)) != NULL) {
1083                 struct device_node *node;
1084                 struct pci_dev *pdev;
1085
1086                 pdev = list_first_entry(&pbus->devices, struct pci_dev,
1087                                         bus_list);
1088
1089                 if (pdev && pci_is_pcie(pdev)) {
1090                         pcie_bus_slot_names(pbus);
1091                 } else {
1092
1093                         if (pbus->self) {
1094
1095                                 /* PCI->PCI bridge */
1096                                 node = pbus->self->dev.of_node;
1097
1098                         } else {
1099                                 struct pci_pbm_info *pbm = pbus->sysdata;
1100
1101                                 /* Host PCI controller */
1102                                 node = pbm->op->dev.of_node;
1103                         }
1104
1105                         pci_bus_slot_names(node, pbus);
1106                 }
1107         }
1108
1109         return 0;
1110 }
1111 device_initcall(of_pci_slot_init);
1112 #endif