arch/sparc64/kernel/pci.c

   1 /* $Id: pci.c,v 1.39 2002/01/05 01:13:43 davem Exp $
   2  * pci.c: UltraSparc PCI controller support.
   3  *
   4  * Copyright (C) 1997, 1998, 1999 David S. Miller (davem@redhat.com)
   5  * Copyright (C) 1998, 1999 Eddie C. Dost   (ecd@skynet.be)
   6  * Copyright (C) 1999 Jakub Jelinek   (jj@ultra.linux.cz)
   7  */
   8
   9 #include <linux/config.h>
  10 #include <linux/module.h>
  11 #include <linux/kernel.h>
  12 #include <linux/string.h>
  13 #include <linux/sched.h>
  14 #include <linux/capability.h>
  15 #include <linux/errno.h>
  16 #include <linux/smp_lock.h>
  17 #include <linux/init.h>
  18
  19 #include <asm/uaccess.h>
  20 #include <asm/pbm.h>
  21 #include <asm/pgtable.h>
  22 #include <asm/irq.h>
  23 #include <asm/ebus.h>
  24 #include <asm/isa.h>
  25
  26 unsigned long pci_memspace_mask = 0xffffffffUL;
  27
  28 #ifndef CONFIG_PCI
  29 /* A "nop" PCI implementation. */
  30 asmlinkage int sys_pciconfig_read(unsigned long bus, unsigned long dfn,
  31                                   unsigned long off, unsigned long len,
  32                                   unsigned char *buf)
  33 {
  34         return 0;
  35 }
  36 asmlinkage int sys_pciconfig_write(unsigned long bus, unsigned long dfn,
  37                                    unsigned long off, unsigned long len,
  38                                    unsigned char *buf)
  39 {
  40         return 0;
  41 }
  42 #else
  43
  44 /* List of all PCI controllers found in the system. */
  45 struct pci_controller_info *pci_controller_root = NULL;
  46
  47 /* Each PCI controller found gets a unique index. */
  48 int pci_num_controllers = 0;
  49
  50 /* At boot time the user can give the kernel a command
  51  * line option which controls if and how PCI devices
  52  * are reordered at PCI bus probing time.
  53  */
  54 int pci_device_reorder = 0;
  55
  56 volatile int pci_poke_in_progress;
  57 volatile int pci_poke_cpu = -1;
  58 volatile int pci_poke_faulted;
  59
  60 static DEFINE_SPINLOCK(pci_poke_lock);
  61
  62 void pci_config_read8(u8 *addr, u8 *ret)
  63 {
  64         unsigned long flags;
  65         u8 byte;
  66
  67         spin_lock_irqsave(&pci_poke_lock, flags);
  68         pci_poke_cpu = smp_processor_id();
  69         pci_poke_in_progress = 1;
  70         pci_poke_faulted = 0;
  71         __asm__ __volatile__("membar #Sync\n\t"
  72                              "lduba [%1] %2, %0\n\t"
  73                              "membar #Sync"
  74                              : "=r" (byte)
  75                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
  76                              : "memory");
  77         pci_poke_in_progress = 0;
  78         pci_poke_cpu = -1;
  79         if (!pci_poke_faulted)
  80                 *ret = byte;
  81         spin_unlock_irqrestore(&pci_poke_lock, flags);
  82 }
  83
  84 void pci_config_read16(u16 *addr, u16 *ret)
  85 {
  86         unsigned long flags;
  87         u16 word;
  88
  89         spin_lock_irqsave(&pci_poke_lock, flags);
  90         pci_poke_cpu = smp_processor_id();
  91         pci_poke_in_progress = 1;
  92         pci_poke_faulted = 0;
  93         __asm__ __volatile__("membar #Sync\n\t"
  94                              "lduha [%1] %2, %0\n\t"
  95                              "membar #Sync"
  96                              : "=r" (word)
  97                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
  98                              : "memory");
  99         pci_poke_in_progress = 0;
 100         pci_poke_cpu = -1;
 101         if (!pci_poke_faulted)
 102                 *ret = word;
 103         spin_unlock_irqrestore(&pci_poke_lock, flags);
 104 }
 105
 106 void pci_config_read32(u32 *addr, u32 *ret)
 107 {
 108         unsigned long flags;
 109         u32 dword;
 110
 111         spin_lock_irqsave(&pci_poke_lock, flags);
 112         pci_poke_cpu = smp_processor_id();
 113         pci_poke_in_progress = 1;
 114         pci_poke_faulted = 0;
 115         __asm__ __volatile__("membar #Sync\n\t"
 116                              "lduwa [%1] %2, %0\n\t"
 117                              "membar #Sync"
 118                              : "=r" (dword)
 119                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 120                              : "memory");
 121         pci_poke_in_progress = 0;
 122         pci_poke_cpu = -1;
 123         if (!pci_poke_faulted)
 124                 *ret = dword;
 125         spin_unlock_irqrestore(&pci_poke_lock, flags);
 126 }
 127
 128 void pci_config_write8(u8 *addr, u8 val)
 129 {
 130         unsigned long flags;
 131
 132         spin_lock_irqsave(&pci_poke_lock, flags);
 133         pci_poke_cpu = smp_processor_id();
 134         pci_poke_in_progress = 1;
 135         pci_poke_faulted = 0;
 136         __asm__ __volatile__("membar #Sync\n\t"
 137                              "stba %0, [%1] %2\n\t"
 138                              "membar #Sync"
 139                              : /* no outputs */
 140                              : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 141                              : "memory");
 142         pci_poke_in_progress = 0;
 143         pci_poke_cpu = -1;
 144         spin_unlock_irqrestore(&pci_poke_lock, flags);
 145 }
 146
 147 void pci_config_write16(u16 *addr, u16 val)
 148 {
 149         unsigned long flags;
 150
 151         spin_lock_irqsave(&pci_poke_lock, flags);
 152         pci_poke_cpu = smp_processor_id();
 153         pci_poke_in_progress = 1;
 154         pci_poke_faulted = 0;
 155         __asm__ __volatile__("membar #Sync\n\t"
 156                              "stha %0, [%1] %2\n\t"
 157                              "membar #Sync"
 158                              : /* no outputs */
 159                              : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 160                              : "memory");
 161         pci_poke_in_progress = 0;
 162         pci_poke_cpu = -1;
 163         spin_unlock_irqrestore(&pci_poke_lock, flags);
 164 }
 165
 166 void pci_config_write32(u32 *addr, u32 val)
 167 {
 168         unsigned long flags;
 169
 170         spin_lock_irqsave(&pci_poke_lock, flags);
 171         pci_poke_cpu = smp_processor_id();
 172         pci_poke_in_progress = 1;
 173         pci_poke_faulted = 0;
 174         __asm__ __volatile__("membar #Sync\n\t"
 175                              "stwa %0, [%1] %2\n\t"
 176                              "membar #Sync"
 177                              : /* no outputs */
 178                              : "r" (val), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L)
 179                              : "memory");
 180         pci_poke_in_progress = 0;
 181         pci_poke_cpu = -1;
 182         spin_unlock_irqrestore(&pci_poke_lock, flags);
 183 }
 184
 185 /* Probe for all PCI controllers in the system. */
 186 extern void sabre_init(int, char *);
 187 extern void psycho_init(int, char *);
 188 extern void schizo_init(int, char *);
 189 extern void schizo_plus_init(int, char *);
 190 extern void tomatillo_init(int, char *);
 191 extern void sun4v_pci_init(int, char *);
 192
 193 static struct {
 194         char *model_name;
 195         void (*init)(int, char *);
 196 } pci_controller_table[] __initdata = {
 197         { "SUNW,sabre", sabre_init },
 198         { "pci108e,a000", sabre_init },
 199         { "pci108e,a001", sabre_init },
 200         { "SUNW,psycho", psycho_init },
 201         { "pci108e,8000", psycho_init },
 202         { "SUNW,schizo", schizo_init },
 203         { "pci108e,8001", schizo_init },
 204         { "SUNW,schizo+", schizo_plus_init },
 205         { "pci108e,8002", schizo_plus_init },
 206         { "SUNW,tomatillo", tomatillo_init },
 207         { "pci108e,a801", tomatillo_init },
 208         { "SUNW,sun4v-pci", sun4v_pci_init },
 209 };
 210 #define PCI_NUM_CONTROLLER_TYPES (sizeof(pci_controller_table) / \
 211                                   sizeof(pci_controller_table[0]))
 212
 213 static int __init pci_controller_init(char *model_name, int namelen, int node)
 214 {
 215         int i;
 216
 217         for (i = 0; i < PCI_NUM_CONTROLLER_TYPES; i++) {
 218                 if (!strncmp(model_name,
 219                              pci_controller_table[i].model_name,
 220                              namelen)) {
 221                         pci_controller_table[i].init(node, model_name);
 222                         return 1;
 223                 }
 224         }
 225         printk("PCI: Warning unknown controller, model name [%s]\n",
 226                model_name);
 227         printk("PCI: Ignoring controller...\n");
 228
 229         return 0;
 230 }
 231
 232 static int __init pci_is_controller(char *model_name, int namelen, int node)
 233 {
 234         int i;
 235
 236         for (i = 0; i < PCI_NUM_CONTROLLER_TYPES; i++) {
 237                 if (!strncmp(model_name,
 238                              pci_controller_table[i].model_name,
 239                              namelen)) {
 240                         return 1;
 241                 }
 242         }
 243         return 0;
 244 }
 245
 246 static int __init pci_controller_scan(int (*handler)(char *, int, int))
 247 {
 248         char namebuf[64];
 249         int node;
 250         int count = 0;
 251
 252         node = prom_getchild(prom_root_node);
 253         while ((node = prom_searchsiblings(node, "pci")) != 0) {
 254                 int len;
 255
 256                 if ((len = prom_getproperty(node, "model", namebuf, sizeof(namebuf))) > 0 ||
 257                     (len = prom_getproperty(node, "compatible", namebuf, sizeof(namebuf))) > 0) {
 258                         int item_len = 0;
 259
 260                         /* Our value may be a multi-valued string in the
 261                          * case of some compatible properties. For sanity,
 262                          * only try the first one. */
 263
 264                         while (namebuf[item_len] && len) {
 265                                 len--;
 266                                 item_len++;
 267                         }
 268
 269                         if (handler(namebuf, item_len, node))
 270                                 count++;
 271                 }
 272
 273                 node = prom_getsibling(node);
 274                 if (!node)
 275                         break;
 276         }
 277
 278         return count;
 279 }
 280
 281
 282 /* Is there some PCI controller in the system?  */
 283 int __init pcic_present(void)
 284 {
 285         return pci_controller_scan(pci_is_controller);
 286 }
 287
 288 struct pci_iommu_ops *pci_iommu_ops;
 289 EXPORT_SYMBOL(pci_iommu_ops);
 290
 291 extern struct pci_iommu_ops pci_sun4u_iommu_ops,
 292         pci_sun4v_iommu_ops;
 293
 294 /* Find each controller in the system, attach and initialize
 295  * software state structure for each and link into the
 296  * pci_controller_root.  Setup the controller enough such
 297  * that bus scanning can be done.
 298  */
 299 static void __init pci_controller_probe(void)
 300 {
 301         if (tlb_type == hypervisor)
 302                 pci_iommu_ops = &pci_sun4v_iommu_ops;
 303         else
 304                 pci_iommu_ops = &pci_sun4u_iommu_ops;
 305
 306         printk("PCI: Probing for controllers.\n");
 307
 308         pci_controller_scan(pci_controller_init);
 309 }
 310
 311 static void __init pci_scan_each_controller_bus(void)
 312 {
 313         struct pci_controller_info *p;
 314
 315         for (p = pci_controller_root; p; p = p->next)
 316                 p->scan_bus(p);
 317 }
 318
 319 /* Reorder the pci_dev chain, so that onboard devices come first
 320  * and then come the pluggable cards.
 321  */
 322 static void __init pci_reorder_devs(void)
 323 {
 324         struct list_head *pci_onboard = &pci_devices;
 325         struct list_head *walk = pci_onboard->next;
 326
 327         while (walk != pci_onboard) {
 328                 struct pci_dev *pdev = pci_dev_g(walk);
 329                 struct list_head *walk_next = walk->next;
 330
 331                 if (pdev->irq && (__irq_ino(pdev->irq) & 0x20)) {
 332                         list_del(walk);
 333                         list_add(walk, pci_onboard);
 334                 }
 335
 336                 walk = walk_next;
 337         }
 338 }
 339
 340 extern void clock_probe(void);
 341 extern void power_init(void);
 342
 343 static int __init pcibios_init(void)
 344 {
 345         pci_controller_probe();
 346         if (pci_controller_root == NULL)
 347                 return 0;
 348
 349         pci_scan_each_controller_bus();
 350
 351         if (pci_device_reorder)
 352                 pci_reorder_devs();
 353
 354         isa_init();
 355         ebus_init();
 356         clock_probe();
 357         power_init();
 358
 359         return 0;
 360 }
 361
 362 subsys_initcall(pcibios_init);
 363
 364 void pcibios_fixup_bus(struct pci_bus *pbus)
 365 {
 366         struct pci_pbm_info *pbm = pbus->sysdata;
 367
 368         /* Generic PCI bus probing sets these to point at
 369          * &io{port,mem}_resouce which is wrong for us.
 370          */
 371         pbus->resource[0] = &pbm->io_space;
 372         pbus->resource[1] = &pbm->mem_space;
 373 }
 374
 375 struct resource *pcibios_select_root(struct pci_dev *pdev, struct resource *r)
 376 {
 377         struct pci_pbm_info *pbm = pdev->bus->sysdata;
 378         struct resource *root = NULL;
 379
 380         if (r->flags & IORESOURCE_IO)
 381                 root = &pbm->io_space;
 382         if (r->flags & IORESOURCE_MEM)
 383                 root = &pbm->mem_space;
 384
 385         return root;
 386 }
 387
 388 void pcibios_update_irq(struct pci_dev *pdev, int irq)
 389 {
 390 }
 391
 392 void pcibios_align_resource(void *data, struct resource *res,
 393                             unsigned long size, unsigned long align)
 394 {
 395 }
 396
 397 int pcibios_enable_device(struct pci_dev *pdev, int mask)
 398 {
 399         return 0;
 400 }
 401
 402 void pcibios_resource_to_bus(struct pci_dev *pdev, struct pci_bus_region *region,
 403                              struct resource *res)
 404 {
 405         struct pci_pbm_info *pbm = pdev->bus->sysdata;
 406         struct resource zero_res, *root;
 407
 408         zero_res.start = 0;
 409         zero_res.end = 0;
 410         zero_res.flags = res->flags;
 411
 412         if (res->flags & IORESOURCE_IO)
 413                 root = &pbm->io_space;
 414         else
 415                 root = &pbm->mem_space;
 416
 417         pbm->parent->resource_adjust(pdev, &zero_res, root);
 418
 419         region->start = res->start - zero_res.start;
 420         region->end = res->end - zero_res.start;
 421 }
 422 EXPORT_SYMBOL(pcibios_resource_to_bus);
 423
 424 void pcibios_bus_to_resource(struct pci_dev *pdev, struct resource *res,
 425                              struct pci_bus_region *region)
 426 {
 427         struct pci_pbm_info *pbm = pdev->bus->sysdata;
 428         struct resource *root;
 429
 430         res->start = region->start;
 431         res->end = region->end;
 432
 433         if (res->flags & IORESOURCE_IO)
 434                 root = &pbm->io_space;
 435         else
 436                 root = &pbm->mem_space;
 437
 438         pbm->parent->resource_adjust(pdev, res, root);
 439 }
 440 EXPORT_SYMBOL(pcibios_bus_to_resource);
 441
 442 char * __init pcibios_setup(char *str)
 443 {
 444         if (!strcmp(str, "onboardfirst")) {
 445                 pci_device_reorder = 1;
 446                 return NULL;
 447         }
 448         if (!strcmp(str, "noreorder")) {
 449                 pci_device_reorder = 0;
 450                 return NULL;
 451         }
 452         return str;
 453 }
 454
 455 /* Platform support for /proc/bus/pci/X/Y mmap()s. */
 456
 457 /* If the user uses a host-bridge as the PCI device, he may use
 458  * this to perform a raw mmap() of the I/O or MEM space behind
 459  * that controller.
 460  *
 461  * This can be useful for execution of x86 PCI bios initialization code
 462  * on a PCI card, like the xfree86 int10 stuff does.
 463  */
 464 static int __pci_mmap_make_offset_bus(struct pci_dev *pdev, struct vm_area_struct *vma,
 465                                       enum pci_mmap_state mmap_state)
 466 {
 467         struct pcidev_cookie *pcp = pdev->sysdata;
 468         struct pci_pbm_info *pbm;
 469         struct pci_controller_info *p;
 470         unsigned long space_size, user_offset, user_size;
 471
 472         if (!pcp)
 473                 return -ENXIO;
 474         pbm = pcp->pbm;
 475         if (!pbm)
 476                 return -ENXIO;
 477
 478         p = pbm->parent;
 479         if (p->pbms_same_domain) {
 480                 unsigned long lowest, highest;
 481
 482                 lowest = ~0UL; highest = 0UL;
 483                 if (mmap_state == pci_mmap_io) {
 484                         if (p->pbm_A.io_space.flags) {
 485                                 lowest = p->pbm_A.io_space.start;
 486                                 highest = p->pbm_A.io_space.end + 1;
 487                         }
 488                         if (p->pbm_B.io_space.flags) {
 489                                 if (lowest > p->pbm_B.io_space.start)
 490                                         lowest = p->pbm_B.io_space.start;
 491                                 if (highest < p->pbm_B.io_space.end + 1)
 492                                         highest = p->pbm_B.io_space.end + 1;
 493                         }
 494                         space_size = highest - lowest;
 495                 } else {
 496                         if (p->pbm_A.mem_space.flags) {
 497                                 lowest = p->pbm_A.mem_space.start;
 498                                 highest = p->pbm_A.mem_space.end + 1;
 499                         }
 500                         if (p->pbm_B.mem_space.flags) {
 501                                 if (lowest > p->pbm_B.mem_space.start)
 502                                         lowest = p->pbm_B.mem_space.start;
 503                                 if (highest < p->pbm_B.mem_space.end + 1)
 504                                         highest = p->pbm_B.mem_space.end + 1;
 505                         }
 506                         space_size = highest - lowest;
 507                 }
 508         } else {
 509                 if (mmap_state == pci_mmap_io) {
 510                         space_size = (pbm->io_space.end -
 511                                       pbm->io_space.start) + 1;
 512                 } else {
 513                         space_size = (pbm->mem_space.end -
 514                                       pbm->mem_space.start) + 1;
 515                 }
 516         }
 517
 518         /* Make sure the request is in range. */
 519         user_offset = vma->vm_pgoff << PAGE_SHIFT;
 520         user_size = vma->vm_end - vma->vm_start;
 521
 522         if (user_offset >= space_size ||
 523             (user_offset + user_size) > space_size)
 524                 return -EINVAL;
 525
 526         if (p->pbms_same_domain) {
 527                 unsigned long lowest = ~0UL;
 528
 529                 if (mmap_state == pci_mmap_io) {
 530                         if (p->pbm_A.io_space.flags)
 531                                 lowest = p->pbm_A.io_space.start;
 532                         if (p->pbm_B.io_space.flags &&
 533                             lowest > p->pbm_B.io_space.start)
 534                                 lowest = p->pbm_B.io_space.start;
 535                 } else {
 536                         if (p->pbm_A.mem_space.flags)
 537                                 lowest = p->pbm_A.mem_space.start;
 538                         if (p->pbm_B.mem_space.flags &&
 539                             lowest > p->pbm_B.mem_space.start)
 540                                 lowest = p->pbm_B.mem_space.start;
 541                 }
 542                 vma->vm_pgoff = (lowest + user_offset) >> PAGE_SHIFT;
 543         } else {
 544                 if (mmap_state == pci_mmap_io) {
 545                         vma->vm_pgoff = (pbm->io_space.start +
 546                                          user_offset) >> PAGE_SHIFT;
 547                 } else {
 548                         vma->vm_pgoff = (pbm->mem_space.start +
 549                                          user_offset) >> PAGE_SHIFT;
 550                 }
 551         }
 552
 553         return 0;
 554 }
 555
 556 /* Adjust vm_pgoff of VMA such that it is the physical page offset corresponding
 557  * to the 32-bit pci bus offset for DEV requested by the user.
 558  *
 559  * Basically, the user finds the base address for his device which he wishes
 560  * to mmap.  They read the 32-bit value from the config space base register,
 561  * add whatever PAGE_SIZE multiple offset they wish, and feed this into the
 562  * offset parameter of mmap on /proc/bus/pci/XXX for that device.
 563  *
 564  * Returns negative error code on failure, zero on success.
 565  */
 566 static int __pci_mmap_make_offset(struct pci_dev *dev, struct vm_area_struct *vma,
 567                                   enum pci_mmap_state mmap_state)
 568 {
 569         unsigned long user_offset = vma->vm_pgoff << PAGE_SHIFT;
 570         unsigned long user32 = user_offset & pci_memspace_mask;
 571         unsigned long largest_base, this_base, addr32;
 572         int i;
 573
 574         if ((dev->class >> 8) == PCI_CLASS_BRIDGE_HOST)
 575                 return __pci_mmap_make_offset_bus(dev, vma, mmap_state);
 576
 577         /* Figure out which base address this is for. */
 578         largest_base = 0UL;
 579         for (i = 0; i <= PCI_ROM_RESOURCE; i++) {
 580                 struct resource *rp = &dev->resource[i];
 581
 582                 /* Active? */
 583                 if (!rp->flags)
 584                         continue;
 585
 586                 /* Same type? */
 587                 if (i == PCI_ROM_RESOURCE) {
 588                         if (mmap_state != pci_mmap_mem)
 589                                 continue;
 590                 } else {
 591                         if ((mmap_state == pci_mmap_io &&
 592                              (rp->flags & IORESOURCE_IO) == 0) ||
 593                             (mmap_state == pci_mmap_mem &&
 594                              (rp->flags & IORESOURCE_MEM) == 0))
 595                                 continue;
 596                 }
 597
 598                 this_base = rp->start;
 599
 600                 addr32 = (this_base & PAGE_MASK) & pci_memspace_mask;
 601
 602                 if (mmap_state == pci_mmap_io)
 603                         addr32 &= 0xffffff;
 604
 605                 if (addr32 <= user32 && this_base > largest_base)
 606                         largest_base = this_base;
 607         }
 608
 609         if (largest_base == 0UL)
 610                 return -EINVAL;
 611
 612         /* Now construct the final physical address. */
 613         if (mmap_state == pci_mmap_io)
 614                 vma->vm_pgoff = (((largest_base & ~0xffffffUL) | user32) >> PAGE_SHIFT);
 615         else
 616                 vma->vm_pgoff = (((largest_base & ~(pci_memspace_mask)) | user32) >> PAGE_SHIFT);
 617
 618         return 0;
 619 }
 620
 621 /* Set vm_flags of VMA, as appropriate for this architecture, for a pci device
 622  * mapping.
 623  */
 624 static void __pci_mmap_set_flags(struct pci_dev *dev, struct vm_area_struct *vma,
 625                                             enum pci_mmap_state mmap_state)
 626 {
 627         vma->vm_flags |= (VM_IO | VM_RESERVED);
 628 }
 629
 630 /* Set vm_page_prot of VMA, as appropriate for this architecture, for a pci
 631  * device mapping.
 632  */
 633 static void __pci_mmap_set_pgprot(struct pci_dev *dev, struct vm_area_struct *vma,
 634                                              enum pci_mmap_state mmap_state)
 635 {
 636         /* Our io_remap_pfn_range takes care of this, do nothing.  */
 637 }
 638
 639 /* Perform the actual remap of the pages for a PCI device mapping, as appropriate
 640  * for this architecture.  The region in the process to map is described by vm_start
 641  * and vm_end members of VMA, the base physical address is found in vm_pgoff.
 642  * The pci device structure is provided so that architectures may make mapping
 643  * decisions on a per-device or per-bus basis.
 644  *
 645  * Returns a negative error code on failure, zero on success.
 646  */
 647 int pci_mmap_page_range(struct pci_dev *dev, struct vm_area_struct *vma,
 648                         enum pci_mmap_state mmap_state,
 649                         int write_combine)
 650 {
 651         int ret;
 652
 653         ret = __pci_mmap_make_offset(dev, vma, mmap_state);
 654         if (ret < 0)
 655                 return ret;
 656
 657         __pci_mmap_set_flags(dev, vma, mmap_state);
 658         __pci_mmap_set_pgprot(dev, vma, mmap_state);
 659
 660         vma->vm_page_prot = pgprot_noncached(vma->vm_page_prot);
 661         ret = io_remap_pfn_range(vma, vma->vm_start,
 662                                  vma->vm_pgoff,
 663                                  vma->vm_end - vma->vm_start,
 664                                  vma->vm_page_prot);
 665         if (ret)
 666                 return ret;
 667
 668         return 0;
 669 }
 670
 671 /* Return the domain nuber for this pci bus */
 672
 673 int pci_domain_nr(struct pci_bus *pbus)
 674 {
 675         struct pci_pbm_info *pbm = pbus->sysdata;
 676         int ret;
 677
 678         if (pbm == NULL || pbm->parent == NULL) {
 679                 ret = -ENXIO;
 680         } else {
 681                 struct pci_controller_info *p = pbm->parent;
 682
 683                 ret = p->index;
 684                 if (p->pbms_same_domain == 0)
 685                         ret = ((ret << 1) +
 686                                ((pbm == &pbm->parent->pbm_B) ? 1 : 0));
 687         }
 688
 689         return ret;
 690 }
 691 EXPORT_SYMBOL(pci_domain_nr);
 692
 693 int pcibios_prep_mwi(struct pci_dev *dev)
 694 {
 695         /* We set correct PCI_CACHE_LINE_SIZE register values for every
 696          * device probed on this platform.  So there is nothing to check
 697          * and this always succeeds.
 698          */
 699         return 0;
 700 }
 701
 702 #endif /* !(CONFIG_PCI) */