arch/v850/kernel/rte_mb_a_pci.c

   1 /*
   2  * arch/v850/kernel/mb_a_pci.c -- PCI support for Midas lab RTE-MOTHER-A board
   3  *
   4  *  Copyright (C) 2001,02,03,05  NEC Electronics Corporation
   5  *  Copyright (C) 2001,02,03,05  Miles Bader <miles@gnu.org>
   6  *
   7  * This file is subject to the terms and conditions of the GNU General
   8  * Public License.  See the file COPYING in the main directory of this
   9  * archive for more details.
  10  *
  11  * Written by Miles Bader <miles@gnu.org>
  12  */
  13
  14 #include <linux/config.h>
  15 #include <linux/kernel.h>
  16 #include <linux/module.h>
  17 #include <linux/init.h>
  18 #include <linux/slab.h>
  19 #include <linux/spinlock.h>
  20 #include <linux/pci.h>
  21
  22 #include <asm/machdep.h>
  23
  24 /* __nomods_init is like __devinit, but is a no-op when modules are enabled.
  25    This is used by some routines that can be called either during boot
  26    or by a module.  */
  27 #ifdef CONFIG_MODULES
  28 #define __nomods_init /*nothing*/
  29 #else
  30 #define __nomods_init __devinit
  31 #endif
  32
  33 /* PCI devices on the Mother-A board can only do DMA to/from the MB SRAM
  34    (the RTE-V850E/MA1-CB cpu board doesn't support PCI access to
  35    CPU-board memory), and since linux DMA buffers are allocated in
  36    normal kernel memory, we basically have to copy DMA blocks around
  37    (this is like a `bounce buffer').  When a DMA block is `mapped', we
  38    allocate an identically sized block in MB SRAM, and if we're doing
  39    output to the device, copy the CPU-memory block to the MB-SRAM block.
  40    When an active block is `unmapped', we will copy the block back to
  41    CPU memory if necessary, and then deallocate the MB SRAM block.
  42    Ack.  */
  43
  44 /* Where the motherboard SRAM is in the PCI-bus address space (the
  45    first 512K of it is also mapped at PCI address 0).  */
  46 #define PCI_MB_SRAM_ADDR 0x800000
  47
  48 /* Convert CPU-view MB SRAM address to/from PCI-view addresses of the
  49    same memory.  */
  50 #define MB_SRAM_TO_PCI(mb_sram_addr) \
  51    ((dma_addr_t)mb_sram_addr - MB_A_SRAM_ADDR + PCI_MB_SRAM_ADDR)
  52 #define PCI_TO_MB_SRAM(pci_addr)     \
  53    (void *)(pci_addr - PCI_MB_SRAM_ADDR + MB_A_SRAM_ADDR)
  54
  55 static void pcibios_assign_resources (void);
  56
  57 struct mb_pci_dev_irq {
  58         unsigned dev;           /* PCI device number */
  59         unsigned irq_base;      /* First IRQ  */
  60         unsigned query_pin;     /* True if we should read the device's
  61                                    Interrupt Pin info, and allocate
  62                                    interrupt IRQ_BASE + PIN.  */
  63 };
  64
  65 /* PCI interrupts are mapped statically to GBUS interrupts.  */
  66 static struct mb_pci_dev_irq mb_pci_dev_irqs[] = {
  67         /* Motherboard SB82558 ethernet controller */
  68         { 10,   IRQ_MB_A_LAN,           0 },
  69         /* PCI slot 1 */
  70         { 8,    IRQ_MB_A_PCI1(0),       1 },
  71         /* PCI slot 2 */
  72         { 9,    IRQ_MB_A_PCI2(0),       1 }
  73 };
  74 #define NUM_MB_PCI_DEV_IRQS \
  75   (sizeof mb_pci_dev_irqs / sizeof mb_pci_dev_irqs[0])
  76
  77 \f
  78 /* PCI configuration primitives.  */
  79
  80 #define CONFIG_DMCFGA(bus, devfn, offs)                                 \
  81    (0x80000000                                                          \
  82     | ((offs) & ~0x3)                                                   \
  83     | ((devfn) << 8)                                                    \
  84     | ((bus)->number << 16))
  85
  86 static int
  87 mb_pci_read (struct pci_bus *bus, unsigned devfn, int offs, int size, u32 *rval)
  88 {
  89         u32 addr;
  90         int flags;
  91
  92         local_irq_save (flags);
  93
  94         MB_A_PCI_PCICR = 0x7;
  95         MB_A_PCI_DMCFGA = CONFIG_DMCFGA (bus, devfn, offs);
  96
  97         addr = MB_A_PCI_IO_ADDR + (offs & 0x3);
  98
  99         switch (size) {
 100         case 1: *rval = *(volatile  u8 *)addr; break;
 101         case 2: *rval = *(volatile u16 *)addr; break;
 102         case 4: *rval = *(volatile u32 *)addr; break;
 103         }
 104
 105         if (MB_A_PCI_PCISR & 0x2000) {
 106                 MB_A_PCI_PCISR = 0x2000;
 107                 *rval = ~0;
 108         }
 109
 110         MB_A_PCI_DMCFGA = 0;
 111
 112         local_irq_restore (flags);
 113
 114         return PCIBIOS_SUCCESSFUL;
 115 }
 116
 117 static int
 118 mb_pci_write (struct pci_bus *bus, unsigned devfn, int offs, int size, u32 val)
 119 {
 120         u32 addr;
 121         int flags;
 122
 123         local_irq_save (flags);
 124
 125         MB_A_PCI_PCICR = 0x7;
 126         MB_A_PCI_DMCFGA = CONFIG_DMCFGA (bus, devfn, offs);
 127
 128         addr = MB_A_PCI_IO_ADDR + (offs & 0x3);
 129
 130         switch (size) {
 131         case 1: *(volatile  u8 *)addr = val; break;
 132         case 2: *(volatile u16 *)addr = val; break;
 133         case 4: *(volatile u32 *)addr = val; break;
 134         }
 135
 136         if (MB_A_PCI_PCISR & 0x2000)
 137                 MB_A_PCI_PCISR = 0x2000;
 138
 139         MB_A_PCI_DMCFGA = 0;
 140
 141         local_irq_restore (flags);
 142
 143         return PCIBIOS_SUCCESSFUL;
 144 }
 145
 146 static struct pci_ops mb_pci_config_ops = {
 147         .read   = mb_pci_read,
 148         .write  = mb_pci_write,
 149 };
 150
 151 \f
 152 /* PCI Initialization.  */
 153
 154 static struct pci_bus *mb_pci_bus = 0;
 155
 156 /* Do initial PCI setup.  */
 157 static int __devinit pcibios_init (void)
 158 {
 159         u32 id = MB_A_PCI_PCIHIDR;
 160         u16 vendor = id & 0xFFFF;
 161         u16 device = (id >> 16) & 0xFFFF;
 162
 163         if (vendor == PCI_VENDOR_ID_PLX && device == PCI_DEVICE_ID_PLX_9080) {
 164                 printk (KERN_INFO
 165                         "PCI: PLX Technology PCI9080 HOST/PCI bridge\n");
 166
 167                 MB_A_PCI_PCICR = 0x147;
 168
 169                 MB_A_PCI_PCIBAR0 = 0x007FFF00;
 170                 MB_A_PCI_PCIBAR1 = 0x0000FF00;
 171                 MB_A_PCI_PCIBAR2 = 0x00800000;
 172
 173                 MB_A_PCI_PCILTR = 0x20;
 174
 175                 MB_A_PCI_PCIPBAM |= 0x3;
 176
 177                 MB_A_PCI_PCISR =  ~0; /* Clear errors.  */
 178
 179                 /* Reprogram the motherboard's IO/config address space,
 180                    as we don't support the GCS7 address space that the
 181                    default uses.  */
 182
 183                 /* Significant address bits used for decoding PCI GCS5 space
 184                    accessess.  */
 185                 MB_A_PCI_DMRR = ~(MB_A_PCI_MEM_SIZE - 1);
 186
 187                 /* I don't understand this, but the SolutionGear example code
 188                    uses such an offset, and it doesn't work without it.  XXX */
 189 #if GCS5_SIZE == 0x00800000
 190 #define GCS5_CFG_OFFS 0x00800000
 191 #else
 192 #define GCS5_CFG_OFFS 0
 193 #endif
 194
 195                 /* Address bit values for matching.  Note that we have to give
 196                    the address from the motherboard's point of view, which is
 197                    different than the CPU's.  */
 198                 /* PCI memory space.  */
 199                 MB_A_PCI_DMLBAM = GCS5_CFG_OFFS + 0x0;
 200                 /* PCI I/O space.  */
 201                 MB_A_PCI_DMLBAI =
 202                         GCS5_CFG_OFFS + (MB_A_PCI_IO_ADDR - GCS5_ADDR);
 203
 204                 mb_pci_bus = pci_scan_bus (0, &mb_pci_config_ops, 0);
 205
 206                 pcibios_assign_resources ();
 207         } else
 208                 printk (KERN_ERR "PCI: HOST/PCI bridge not found\n");
 209
 210         return 0;
 211 }
 212
 213 subsys_initcall (pcibios_init);
 214
 215 char __devinit *pcibios_setup (char *option)
 216 {
 217         /* Don't handle any options. */
 218         return option;
 219 }
 220
 221 \f
 222 int __nomods_init pcibios_enable_device (struct pci_dev *dev, int mask)
 223 {
 224         u16 cmd, old_cmd;
 225         int idx;
 226         struct resource *r;
 227
 228         pci_read_config_word(dev, PCI_COMMAND, &cmd);
 229         old_cmd = cmd;
 230         for (idx = 0; idx < 6; idx++) {
 231                 r = &dev->resource[idx];
 232                 if (!r->start && r->end) {
 233                         printk(KERN_ERR "PCI: Device %s not available because "
 234                                "of resource collisions\n", pci_name(dev));
 235                         return -EINVAL;
 236                 }
 237                 if (r->flags & IORESOURCE_IO)
 238                         cmd |= PCI_COMMAND_IO;
 239                 if (r->flags & IORESOURCE_MEM)
 240                         cmd |= PCI_COMMAND_MEMORY;
 241         }
 242         if (cmd != old_cmd) {
 243                 printk("PCI: Enabling device %s (%04x -> %04x)\n",
 244                        pci_name(dev), old_cmd, cmd);
 245                 pci_write_config_word(dev, PCI_COMMAND, cmd);
 246         }
 247         return 0;
 248 }
 249
 250 \f
 251 /* Resource allocation.  */
 252 static void __devinit pcibios_assign_resources (void)
 253 {
 254         struct pci_dev *dev = NULL;
 255         struct resource *r;
 256
 257         for_each_pci_dev(dev) {
 258                 unsigned di_num;
 259                 unsigned class = dev->class >> 8;
 260
 261                 if (class && class != PCI_CLASS_BRIDGE_HOST) {
 262                         unsigned r_num;
 263                         for(r_num = 0; r_num < 6; r_num++) {
 264                                 r = &dev->resource[r_num];
 265                                 if (!r->start && r->end)
 266                                         pci_assign_resource (dev, r_num);
 267                         }
 268                 }
 269
 270                 /* Assign interrupts.  */
 271                 for (di_num = 0; di_num < NUM_MB_PCI_DEV_IRQS; di_num++) {
 272                         struct mb_pci_dev_irq *di = &mb_pci_dev_irqs[di_num];
 273
 274                         if (di->dev == PCI_SLOT (dev->devfn)) {
 275                                 unsigned irq = di->irq_base;
 276
 277                                 if (di->query_pin) {
 278                                         /* Find out which interrupt pin
 279                                            this device uses (each PCI
 280                                            slot has 4).  */
 281                                         u8 irq_pin;
 282
 283                                         pci_read_config_byte (dev,
 284                                                              PCI_INTERRUPT_PIN,
 285                                                               &irq_pin);
 286
 287                                         if (irq_pin == 0)
 288                                                 /* Doesn't use interrupts.  */
 289                                                 continue;
 290                                         else
 291                                                 irq += irq_pin - 1;
 292                                 }
 293
 294                                 pcibios_update_irq (dev, irq);
 295                         }
 296                 }
 297         }
 298 }
 299
 300 void __devinit pcibios_update_irq (struct pci_dev *dev, int irq)
 301 {
 302         dev->irq = irq;
 303         pci_write_config_byte (dev, PCI_INTERRUPT_LINE, irq);
 304 }
 305
 306 void __devinit
 307 pcibios_resource_to_bus(struct pci_dev *dev, struct pci_bus_region *region,
 308                         struct resource *res)
 309 {
 310         unsigned long offset = 0;
 311
 312         if (res->flags & IORESOURCE_IO) {
 313                 offset = MB_A_PCI_IO_ADDR;
 314         } else if (res->flags & IORESOURCE_MEM) {
 315                 offset = MB_A_PCI_MEM_ADDR;
 316         }
 317
 318         region->start = res->start - offset;
 319         region->end = res->end - offset;
 320 }
 321
 322 \f
 323 /* Stubs for things we don't use.  */
 324
 325 /* Called after each bus is probed, but before its children are examined. */
 326 void pcibios_fixup_bus(struct pci_bus *b)
 327 {
 328 }
 329
 330 void
 331 pcibios_align_resource (void *data, struct resource *res,
 332                         resource_size_t size, resource_size_t align)
 333 {
 334 }
 335
 336 void pcibios_set_master (struct pci_dev *dev)
 337 {
 338 }
 339
 340 \f
 341 /* Mother-A SRAM memory allocation.  This is a simple first-fit allocator.  */
 342
 343 /* A memory free-list node.  */
 344 struct mb_sram_free_area {
 345         void *mem;
 346         unsigned long size;
 347         struct mb_sram_free_area *next;
 348 };
 349
 350 /* The tail of the free-list, which starts out containing all the SRAM.  */
 351 static struct mb_sram_free_area mb_sram_free_tail = {
 352         (void *)MB_A_SRAM_ADDR, MB_A_SRAM_SIZE, 0
 353 };
 354
 355 /* The free-list.  */
 356 static struct mb_sram_free_area *mb_sram_free_areas = &mb_sram_free_tail;
 357
 358 /* The free-list of free free-list nodes. (:-)  */
 359 static struct mb_sram_free_area *mb_sram_free_free_areas = 0;
 360
 361 /* Spinlock protecting the above globals.  */
 362 static DEFINE_SPINLOCK(mb_sram_lock);
 363
 364 /* Allocate a memory block at least SIZE bytes long in the Mother-A SRAM
 365    space.  */
 366 static void *alloc_mb_sram (size_t size)
 367 {
 368         struct mb_sram_free_area *prev, *fa;
 369         int flags;
 370         void *mem = 0;
 371
 372         spin_lock_irqsave (mb_sram_lock, flags);
 373
 374         /* Look for a free area that can contain SIZE bytes.  */
 375         for (prev = 0, fa = mb_sram_free_areas; fa; prev = fa, fa = fa->next)
 376                 if (fa->size >= size) {
 377                         /* Found one!  */
 378                         mem = fa->mem;
 379
 380                         if (fa->size == size) {
 381                                 /* In fact, it fits exactly, so remove
 382                                    this node from the free-list.  */
 383                                 if (prev)
 384                                         prev->next = fa->next;
 385                                 else
 386                                         mb_sram_free_areas = fa->next;
 387                                 /* Put it on the free-list-entry-free-list. */
 388                                 fa->next = mb_sram_free_free_areas;
 389                                 mb_sram_free_free_areas = fa;
 390                         } else {
 391                                 /* FA is bigger than SIZE, so just
 392                                    reduce its size to account for this
 393                                    allocation.  */
 394                                 fa->mem += size;
 395                                 fa->size -= size;
 396                         }
 397
 398                         break;
 399                 }
 400
 401         spin_unlock_irqrestore (mb_sram_lock, flags);
 402
 403         return mem;
 404 }
 405
 406 /* Return the memory area MEM of size SIZE to the MB SRAM free pool.  */
 407 static void free_mb_sram (void *mem, size_t size)
 408 {
 409         struct mb_sram_free_area *prev, *fa, *new_fa;
 410         int flags;
 411         void *end = mem + size;
 412
 413         spin_lock_irqsave (mb_sram_lock, flags);
 414
 415  retry:
 416         /* Find an adjacent free-list entry.  */
 417         for (prev = 0, fa = mb_sram_free_areas; fa; prev = fa, fa = fa->next)
 418                 if (fa->mem == end) {
 419                         /* FA is just after MEM, grow down to encompass it. */
 420                         fa->mem = mem;
 421                         fa->size += size;
 422                         goto done;
 423                 } else if (fa->mem + fa->size == mem) {
 424                         struct mb_sram_free_area *next_fa = fa->next;
 425
 426                         /* FA is just before MEM, expand to encompass it. */
 427                         fa->size += size;
 428
 429                         /* See if FA can now be merged with its successor. */
 430                         if (next_fa && fa->mem + fa->size == next_fa->mem) {
 431                                 /* Yup; merge NEXT_FA's info into FA.  */
 432                                 fa->size += next_fa->size;
 433                                 fa->next = next_fa->next;
 434                                 /* Free NEXT_FA.  */
 435                                 next_fa->next = mb_sram_free_free_areas;
 436                                 mb_sram_free_free_areas = next_fa;
 437                         }
 438                         goto done;
 439                 } else if (fa->mem > mem)
 440                         /* We've reached the right spot in the free-list
 441                            without finding an adjacent free-area, so add
 442                            a new free area to hold mem. */
 443                         break;
 444
 445         /* Make a new free-list entry.  */
 446
 447         /* First, get a free-list entry.  */
 448         if (! mb_sram_free_free_areas) {
 449                 /* There are none, so make some.  */
 450                 void *block;
 451                 size_t block_size = sizeof (struct mb_sram_free_area) * 8;
 452
 453                 /* Don't hold the lock while calling kmalloc (I'm not
 454                    sure whether it would be a problem, since we use
 455                    GFP_ATOMIC, but it makes me nervous).  */
 456                 spin_unlock_irqrestore (mb_sram_lock, flags);
 457
 458                 block = kmalloc (block_size, GFP_ATOMIC);
 459                 if (! block)
 460                         panic ("free_mb_sram: can't allocate free-list entry");
 461
 462                 /* Now get the lock back.  */
 463                 spin_lock_irqsave (mb_sram_lock, flags);
 464
 465                 /* Add the new free free-list entries.  */
 466                 while (block_size > 0) {
 467                         struct mb_sram_free_area *nfa = block;
 468                         nfa->next = mb_sram_free_free_areas;
 469                         mb_sram_free_free_areas = nfa;
 470                         block += sizeof *nfa;
 471                         block_size -= sizeof *nfa;
 472                 }
 473
 474                 /* Since we dropped the lock to call kmalloc, the
 475                    free-list could have changed, so retry from the
 476                    beginning.  */
 477                 goto retry;
 478         }
 479
 480         /* Remove NEW_FA from the free-list of free-list entries.  */
 481         new_fa = mb_sram_free_free_areas;
 482         mb_sram_free_free_areas = new_fa->next;
 483
 484         /* NEW_FA initially holds only MEM.  */
 485         new_fa->mem = mem;
 486         new_fa->size = size;
 487
 488         /* Insert NEW_FA in the free-list between PREV and FA. */
 489         new_fa->next = fa;
 490         if (prev)
 491                 prev->next = new_fa;
 492         else
 493                 mb_sram_free_areas = new_fa;
 494
 495  done:
 496         spin_unlock_irqrestore (mb_sram_lock, flags);
 497 }
 498
 499 \f
 500 /* Maintainence of CPU -> Mother-A DMA mappings.  */
 501
 502 struct dma_mapping {
 503         void *cpu_addr;
 504         void *mb_sram_addr;
 505         size_t size;
 506         struct dma_mapping *next;
 507 };
 508
 509 /* A list of mappings from CPU addresses to MB SRAM addresses for active
 510    DMA blocks (that have been `granted' to the PCI device).  */
 511 static struct dma_mapping *active_dma_mappings = 0;
 512
 513 /* A list of free mapping objects.  */
 514 static struct dma_mapping *free_dma_mappings = 0;
 515
 516 /* Spinlock protecting the above globals.  */
 517 static DEFINE_SPINLOCK(dma_mappings_lock);
 518
 519 static struct dma_mapping *new_dma_mapping (size_t size)
 520 {
 521         int flags;
 522         struct dma_mapping *mapping;
 523         void *mb_sram_block = alloc_mb_sram (size);
 524
 525         if (! mb_sram_block)
 526                 return 0;
 527
 528         spin_lock_irqsave (dma_mappings_lock, flags);
 529
 530         if (! free_dma_mappings) {
 531                 /* We're out of mapping structures, make more.  */
 532                 void *mblock;
 533                 size_t mblock_size = sizeof (struct dma_mapping) * 8;
 534
 535                 /* Don't hold the lock while calling kmalloc (I'm not
 536                    sure whether it would be a problem, since we use
 537                    GFP_ATOMIC, but it makes me nervous).  */
 538                 spin_unlock_irqrestore (dma_mappings_lock, flags);
 539
 540                 mblock = kmalloc (mblock_size, GFP_ATOMIC);
 541                 if (! mblock) {
 542                         free_mb_sram (mb_sram_block, size);
 543                         return 0;
 544                 }
 545
 546                 /* Get the lock back.  */
 547                 spin_lock_irqsave (dma_mappings_lock, flags);
 548
 549                 /* Add the new mapping structures to the free-list.  */
 550                 while (mblock_size > 0) {
 551                         struct dma_mapping *fm = mblock;
 552                         fm->next = free_dma_mappings;
 553                         free_dma_mappings = fm;
 554                         mblock += sizeof *fm;
 555                         mblock_size -= sizeof *fm;
 556                 }
 557         }
 558
 559         /* Get a mapping struct from the freelist.  */
 560         mapping = free_dma_mappings;
 561         free_dma_mappings = mapping->next;
 562
 563         /* Initialize the mapping.  Other fields should be filled in by
 564            caller.  */
 565         mapping->mb_sram_addr = mb_sram_block;
 566         mapping->size = size;
 567
 568         /* Add it to the list of active mappings.  */
 569         mapping->next = active_dma_mappings;
 570         active_dma_mappings = mapping;
 571
 572         spin_unlock_irqrestore (dma_mappings_lock, flags);
 573
 574         return mapping;
 575 }
 576
 577 static struct dma_mapping *find_dma_mapping (void *mb_sram_addr)
 578 {
 579         int flags;
 580         struct dma_mapping *mapping;
 581
 582         spin_lock_irqsave (dma_mappings_lock, flags);
 583
 584         for (mapping = active_dma_mappings; mapping; mapping = mapping->next)
 585                 if (mapping->mb_sram_addr == mb_sram_addr) {
 586                         spin_unlock_irqrestore (dma_mappings_lock, flags);
 587                         return mapping;
 588                 }
 589
 590         panic ("find_dma_mapping: unmapped PCI DMA addr 0x%x",
 591                MB_SRAM_TO_PCI (mb_sram_addr));
 592 }
 593
 594 static struct dma_mapping *deactivate_dma_mapping (void *mb_sram_addr)
 595 {
 596         int flags;
 597         struct dma_mapping *mapping, *prev;
 598
 599         spin_lock_irqsave (dma_mappings_lock, flags);
 600
 601         for (prev = 0, mapping = active_dma_mappings;
 602              mapping;
 603              prev = mapping, mapping = mapping->next)
 604         {
 605                 if (mapping->mb_sram_addr == mb_sram_addr) {
 606                         /* This is the MAPPING; deactivate it.  */
 607                         if (prev)
 608                                 prev->next = mapping->next;
 609                         else
 610                                 active_dma_mappings = mapping->next;
 611
 612                         spin_unlock_irqrestore (dma_mappings_lock, flags);
 613
 614                         return mapping;
 615                 }
 616         }
 617
 618         panic ("deactivate_dma_mapping: unmapped PCI DMA addr 0x%x",
 619                MB_SRAM_TO_PCI (mb_sram_addr));
 620 }
 621
 622 /* Return MAPPING to the freelist.  */
 623 static inline void
 624 free_dma_mapping (struct dma_mapping *mapping)
 625 {
 626         int flags;
 627
 628         free_mb_sram (mapping->mb_sram_addr, mapping->size);
 629
 630         spin_lock_irqsave (dma_mappings_lock, flags);
 631
 632         mapping->next = free_dma_mappings;
 633         free_dma_mappings = mapping;
 634
 635         spin_unlock_irqrestore (dma_mappings_lock, flags);
 636 }
 637
 638 \f
 639 /* Single PCI DMA mappings.  */
 640
 641 /* `Grant' to PDEV the memory block at CPU_ADDR, for doing DMA.  The
 642    32-bit PCI bus mastering address to use is returned.  the device owns
 643    this memory until either pci_unmap_single or pci_dma_sync_single is
 644    performed.  */
 645 dma_addr_t
 646 pci_map_single (struct pci_dev *pdev, void *cpu_addr, size_t size, int dir)
 647 {
 648         struct dma_mapping *mapping = new_dma_mapping (size);
 649
 650         if (! mapping)
 651                 return 0;
 652
 653         mapping->cpu_addr = cpu_addr;
 654
 655         if (dir == PCI_DMA_BIDIRECTIONAL || dir == PCI_DMA_TODEVICE)
 656                 memcpy (mapping->mb_sram_addr, cpu_addr, size);
 657
 658         return MB_SRAM_TO_PCI (mapping->mb_sram_addr);
 659 }
 660
 661 /* Return to the CPU the PCI DMA memory block previously `granted' to
 662    PDEV, at DMA_ADDR.  */
 663 void pci_unmap_single (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
 664                        int dir)
 665 {
 666         void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
 667         struct dma_mapping *mapping = deactivate_dma_mapping (mb_sram_addr);
 668
 669         if (size != mapping->size)
 670                 panic ("pci_unmap_single: size (%d) doesn't match"
 671                        " size of mapping at PCI DMA addr 0x%x (%d)\n",
 672                        size, dma_addr, mapping->size);
 673
 674         /* Copy back the DMA'd contents if necessary.  */
 675         if (dir == PCI_DMA_BIDIRECTIONAL || dir == PCI_DMA_FROMDEVICE)
 676                 memcpy (mapping->cpu_addr, mb_sram_addr, size);
 677
 678         /* Return mapping to the freelist.  */
 679         free_dma_mapping (mapping);
 680 }
 681
 682 /* Make physical memory consistent for a single streaming mode DMA
 683    translation after a transfer.
 684
 685    If you perform a pci_map_single() but wish to interrogate the
 686    buffer using the cpu, yet do not wish to teardown the PCI dma
 687    mapping, you must call this function before doing so.  At the next
 688    point you give the PCI dma address back to the card, you must first
 689    perform a pci_dma_sync_for_device, and then the device again owns
 690    the buffer.  */
 691 void
 692 pci_dma_sync_single_for_cpu (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
 693                      int dir)
 694 {
 695         void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
 696         struct dma_mapping *mapping = find_dma_mapping (mb_sram_addr);
 697
 698         /* Synchronize the DMA buffer with the CPU buffer if necessary.  */
 699         if (dir == PCI_DMA_FROMDEVICE)
 700                 memcpy (mapping->cpu_addr, mb_sram_addr, size);
 701         else if (dir == PCI_DMA_TODEVICE)
 702                 ; /* nothing to do */
 703         else
 704                 panic("pci_dma_sync_single: unsupported sync dir: %d", dir);
 705 }
 706
 707 void
 708 pci_dma_sync_single_for_device (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
 709                                 int dir)
 710 {
 711         void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
 712         struct dma_mapping *mapping = find_dma_mapping (mb_sram_addr);
 713
 714         /* Synchronize the DMA buffer with the CPU buffer if necessary.  */
 715         if (dir == PCI_DMA_FROMDEVICE)
 716                 ; /* nothing to do */
 717         else if (dir == PCI_DMA_TODEVICE)
 718                 memcpy (mb_sram_addr, mapping->cpu_addr, size);
 719         else
 720                 panic("pci_dma_sync_single: unsupported sync dir: %d", dir);
 721 }
 722
 723 \f
 724 /* Scatter-gather PCI DMA mappings.  */
 725
 726 /* Do multiple DMA mappings at once.  */
 727 int
 728 pci_map_sg (struct pci_dev *pdev, struct scatterlist *sg, int sg_len, int dir)
 729 {
 730         BUG ();
 731         return 0;
 732 }
 733
 734 /* Unmap multiple DMA mappings at once.  */
 735 void
 736 pci_unmap_sg (struct pci_dev *pdev, struct scatterlist *sg, int sg_len,int dir)
 737 {
 738         BUG ();
 739 }
 740
 741 /* Make physical memory consistent for a set of streaming mode DMA
 742    translations after a transfer.  The same as pci_dma_sync_single_* but
 743    for a scatter-gather list, same rules and usage.  */
 744
 745 void
 746 pci_dma_sync_sg_for_cpu (struct pci_dev *dev,
 747                          struct scatterlist *sg, int sg_len,
 748                          int dir)
 749 {
 750         BUG ();
 751 }
 752
 753 void
 754 pci_dma_sync_sg_for_device (struct pci_dev *dev,
 755                             struct scatterlist *sg, int sg_len,
 756                             int dir)
 757 {
 758         BUG ();
 759 }
 760
 761 \f
 762 /* PCI mem mapping.  */
 763
 764 /* Allocate and map kernel buffer using consistent mode DMA for PCI
 765    device.  Returns non-NULL cpu-view pointer to the buffer if
 766    successful and sets *DMA_ADDR to the pci side dma address as well,
 767    else DMA_ADDR is undefined.  */
 768 void *
 769 pci_alloc_consistent (struct pci_dev *pdev, size_t size, dma_addr_t *dma_addr)
 770 {
 771         void *mb_sram_mem = alloc_mb_sram (size);
 772         if (mb_sram_mem)
 773                 *dma_addr = MB_SRAM_TO_PCI (mb_sram_mem);
 774         return mb_sram_mem;
 775 }
 776
 777 /* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must
 778    be values that were returned from pci_alloc_consistent.  SIZE must be
 779    the same as what as passed into pci_alloc_consistent.  References to
 780    the memory and mappings assosciated with CPU_ADDR or DMA_ADDR past
 781    this call are illegal.  */
 782 void
 783 pci_free_consistent (struct pci_dev *pdev, size_t size, void *cpu_addr,
 784                      dma_addr_t dma_addr)
 785 {
 786         void *mb_sram_mem = PCI_TO_MB_SRAM (dma_addr);
 787         free_mb_sram (mb_sram_mem, size);
 788 }
 789
 790 \f
 791 /* iomap/iomap */
 792
 793 void __iomem *pci_iomap (struct pci_dev *dev, int bar, unsigned long max)
 794 {
 795         unsigned long start = pci_resource_start (dev, bar);
 796         unsigned long len = pci_resource_len (dev, bar);
 797
 798         if (!start || len == 0)
 799                 return 0;
 800
 801         /* None of the ioremap functions actually do anything, other than
 802            re-casting their argument, so don't bother differentiating them.  */
 803         return ioremap (start, len);
 804 }
 805
 806 void pci_iounmap (struct pci_dev *dev, void __iomem *addr)
 807 {
 808         /* nothing */
 809 }
 810
 811 \f
 812 /* symbol exports (for modules) */
 813
 814 EXPORT_SYMBOL (pci_map_single);
 815 EXPORT_SYMBOL (pci_unmap_single);
 816 EXPORT_SYMBOL (pci_alloc_consistent);
 817 EXPORT_SYMBOL (pci_free_consistent);
 818 EXPORT_SYMBOL (pci_dma_sync_single_for_cpu);
 819 EXPORT_SYMBOL (pci_dma_sync_single_for_device);
 820 EXPORT_SYMBOL (pci_iomap);
 821 EXPORT_SYMBOL (pci_iounmap);