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  NEC Electronics Corporation
   5  *  Copyright (C) 2001,02,03  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         while ((dev = pci_find_device(PCI_ANY_ID, PCI_ANY_ID, dev)) != NULL) {
 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 struct pci_fixup pcibios_fixups[] = { { 0 } };
 326
 327 /* Called after each bus is probed, but before its children are examined. */
 328 void pcibios_fixup_bus(struct pci_bus *b)
 329 {
 330 }
 331
 332 void
 333 pcibios_align_resource (void *data, struct resource *res,
 334                         unsigned long size, unsigned long align)
 335 {
 336 }
 337
 338 void pcibios_set_master (struct pci_dev *dev)
 339 {
 340 }
 341
 342 \f
 343 /* Mother-A SRAM memory allocation.  This is a simple first-fit allocator.  */
 344
 345 /* A memory free-list node.  */
 346 struct mb_sram_free_area {
 347         void *mem;
 348         unsigned long size;
 349         struct mb_sram_free_area *next;
 350 };
 351
 352 /* The tail of the free-list, which starts out containing all the SRAM.  */
 353 static struct mb_sram_free_area mb_sram_free_tail = {
 354         (void *)MB_A_SRAM_ADDR, MB_A_SRAM_SIZE, 0
 355 };
 356
 357 /* The free-list.  */
 358 static struct mb_sram_free_area *mb_sram_free_areas = &mb_sram_free_tail;
 359
 360 /* The free-list of free free-list nodes. (:-)  */
 361 static struct mb_sram_free_area *mb_sram_free_free_areas = 0;
 362
 363 /* Spinlock protecting the above globals.  */
 364 static spinlock_t mb_sram_lock = SPIN_LOCK_UNLOCKED;
 365
 366 /* Allocate a memory block at least SIZE bytes long in the Mother-A SRAM
 367    space.  */
 368 static void *alloc_mb_sram (size_t size)
 369 {
 370         struct mb_sram_free_area *prev, *fa;
 371         int flags;
 372         void *mem = 0;
 373
 374         spin_lock_irqsave (mb_sram_lock, flags);
 375
 376         /* Look for a free area that can contain SIZE bytes.  */
 377         for (prev = 0, fa = mb_sram_free_areas; fa; prev = fa, fa = fa->next)
 378                 if (fa->size >= size) {
 379                         /* Found one!  */
 380                         mem = fa->mem;
 381
 382                         if (fa->size == size) {
 383                                 /* In fact, it fits exactly, so remove
 384                                    this node from the free-list.  */
 385                                 if (prev)
 386                                         prev->next = fa->next;
 387                                 else
 388                                         mb_sram_free_areas = fa->next;
 389                                 /* Put it on the free-list-entry-free-list. */
 390                                 fa->next = mb_sram_free_free_areas;
 391                                 mb_sram_free_free_areas = fa;
 392                         } else {
 393                                 /* FA is bigger than SIZE, so just
 394                                    reduce its size to account for this
 395                                    allocation.  */
 396                                 fa->mem += size;
 397                                 fa->size -= size;
 398                         }
 399
 400                         break;
 401                 }
 402
 403         spin_unlock_irqrestore (mb_sram_lock, flags);
 404
 405         return mem;
 406 }
 407
 408 /* Return the memory area MEM of size SIZE to the MB SRAM free pool.  */
 409 static void free_mb_sram (void *mem, size_t size)
 410 {
 411         struct mb_sram_free_area *prev, *fa, *new_fa;
 412         int flags;
 413         void *end = mem + size;
 414
 415         spin_lock_irqsave (mb_sram_lock, flags);
 416
 417  retry:
 418         /* Find an adjacent free-list entry.  */
 419         for (prev = 0, fa = mb_sram_free_areas; fa; prev = fa, fa = fa->next)
 420                 if (fa->mem == end) {
 421                         /* FA is just after MEM, grow down to encompass it. */
 422                         fa->mem = mem;
 423                         fa->size += size;
 424                         goto done;
 425                 } else if (fa->mem + fa->size == mem) {
 426                         struct mb_sram_free_area *next_fa = fa->next;
 427
 428                         /* FA is just before MEM, expand to encompass it. */
 429                         fa->size += size;
 430
 431                         /* See if FA can now be merged with its successor. */
 432                         if (next_fa && fa->mem + fa->size == next_fa->mem) {
 433                                 /* Yup; merge NEXT_FA's info into FA.  */
 434                                 fa->size += next_fa->size;
 435                                 fa->next = next_fa->next;
 436                                 /* Free NEXT_FA.  */
 437                                 next_fa->next = mb_sram_free_free_areas;
 438                                 mb_sram_free_free_areas = next_fa;
 439                         }
 440                         goto done;
 441                 } else if (fa->mem > mem)
 442                         /* We've reached the right spot in the free-list
 443                            without finding an adjacent free-area, so add
 444                            a new free area to hold mem. */
 445                         break;
 446
 447         /* Make a new free-list entry.  */
 448
 449         /* First, get a free-list entry.  */
 450         if (! mb_sram_free_free_areas) {
 451                 /* There are none, so make some.  */
 452                 void *block;
 453                 size_t block_size = sizeof (struct mb_sram_free_area) * 8;
 454
 455                 /* Don't hold the lock while calling kmalloc (I'm not
 456                    sure whether it would be a problem, since we use
 457                    GFP_ATOMIC, but it makes me nervous).  */
 458                 spin_unlock_irqrestore (mb_sram_lock, flags);
 459
 460                 block = kmalloc (block_size, GFP_ATOMIC);
 461                 if (! block)
 462                         panic ("free_mb_sram: can't allocate free-list entry");
 463
 464                 /* Now get the lock back.  */
 465                 spin_lock_irqsave (mb_sram_lock, flags);
 466
 467                 /* Add the new free free-list entries.  */
 468                 while (block_size > 0) {
 469                         struct mb_sram_free_area *nfa = block;
 470                         nfa->next = mb_sram_free_free_areas;
 471                         mb_sram_free_free_areas = nfa;
 472                         block += sizeof *nfa;
 473                         block_size -= sizeof *nfa;
 474                 }
 475
 476                 /* Since we dropped the lock to call kmalloc, the
 477                    free-list could have changed, so retry from the
 478                    beginning.  */
 479                 goto retry;
 480         }
 481
 482         /* Remove NEW_FA from the free-list of free-list entries.  */
 483         new_fa = mb_sram_free_free_areas;
 484         mb_sram_free_free_areas = new_fa->next;
 485
 486         /* NEW_FA initially holds only MEM.  */
 487         new_fa->mem = mem;
 488         new_fa->size = size;
 489
 490         /* Insert NEW_FA in the free-list between PREV and FA. */
 491         new_fa->next = fa;
 492         if (prev)
 493                 prev->next = new_fa;
 494         else
 495                 mb_sram_free_areas = new_fa;
 496
 497  done:
 498         spin_unlock_irqrestore (mb_sram_lock, flags);
 499 }
 500
 501 \f
 502 /* Maintainence of CPU -> Mother-A DMA mappings.  */
 503
 504 struct dma_mapping {
 505         void *cpu_addr;
 506         void *mb_sram_addr;
 507         size_t size;
 508         struct dma_mapping *next;
 509 };
 510
 511 /* A list of mappings from CPU addresses to MB SRAM addresses for active
 512    DMA blocks (that have been `granted' to the PCI device).  */
 513 static struct dma_mapping *active_dma_mappings = 0;
 514
 515 /* A list of free mapping objects.  */
 516 static struct dma_mapping *free_dma_mappings = 0;
 517
 518 /* Spinlock protecting the above globals.  */
 519 static spinlock_t dma_mappings_lock = SPIN_LOCK_UNLOCKED;
 520
 521 static struct dma_mapping *new_dma_mapping (size_t size)
 522 {
 523         int flags;
 524         struct dma_mapping *mapping;
 525         void *mb_sram_block = alloc_mb_sram (size);
 526
 527         if (! mb_sram_block)
 528                 return 0;
 529
 530         spin_lock_irqsave (dma_mappings_lock, flags);
 531
 532         if (! free_dma_mappings) {
 533                 /* We're out of mapping structures, make more.  */
 534                 void *mblock;
 535                 size_t mblock_size = sizeof (struct dma_mapping) * 8;
 536
 537                 /* Don't hold the lock while calling kmalloc (I'm not
 538                    sure whether it would be a problem, since we use
 539                    GFP_ATOMIC, but it makes me nervous).  */
 540                 spin_unlock_irqrestore (dma_mappings_lock, flags);
 541
 542                 mblock = kmalloc (mblock_size, GFP_ATOMIC);
 543                 if (! mblock) {
 544                         free_mb_sram (mb_sram_block, size);
 545                         return 0;
 546                 }
 547
 548                 /* Get the lock back.  */
 549                 spin_lock_irqsave (dma_mappings_lock, flags);
 550
 551                 /* Add the new mapping structures to the free-list.  */
 552                 while (mblock_size > 0) {
 553                         struct dma_mapping *fm = mblock;
 554                         fm->next = free_dma_mappings;
 555                         free_dma_mappings = fm;
 556                         mblock += sizeof *fm;
 557                         mblock_size -= sizeof *fm;
 558                 }
 559         }
 560
 561         /* Get a mapping struct from the freelist.  */
 562         mapping = free_dma_mappings;
 563         free_dma_mappings = mapping->next;
 564
 565         /* Initialize the mapping.  Other fields should be filled in by
 566            caller.  */
 567         mapping->mb_sram_addr = mb_sram_block;
 568         mapping->size = size;
 569
 570         /* Add it to the list of active mappings.  */
 571         mapping->next = active_dma_mappings;
 572         active_dma_mappings = mapping;
 573
 574         spin_unlock_irqrestore (dma_mappings_lock, flags);
 575
 576         return mapping;
 577 }
 578
 579 static struct dma_mapping *find_dma_mapping (void *mb_sram_addr)
 580 {
 581         int flags;
 582         struct dma_mapping *mapping;
 583
 584         spin_lock_irqsave (dma_mappings_lock, flags);
 585
 586         for (mapping = active_dma_mappings; mapping; mapping = mapping->next)
 587                 if (mapping->mb_sram_addr == mb_sram_addr) {
 588                         spin_unlock_irqrestore (dma_mappings_lock, flags);
 589                         return mapping;
 590                 }
 591
 592         panic ("find_dma_mapping: unmapped PCI DMA addr 0x%x",
 593                MB_SRAM_TO_PCI (mb_sram_addr));
 594 }
 595
 596 static struct dma_mapping *deactivate_dma_mapping (void *mb_sram_addr)
 597 {
 598         int flags;
 599         struct dma_mapping *mapping, *prev;
 600
 601         spin_lock_irqsave (dma_mappings_lock, flags);
 602
 603         for (prev = 0, mapping = active_dma_mappings;
 604              mapping;
 605              prev = mapping, mapping = mapping->next)
 606         {
 607                 if (mapping->mb_sram_addr == mb_sram_addr) {
 608                         /* This is the MAPPING; deactivate it.  */
 609                         if (prev)
 610                                 prev->next = mapping->next;
 611                         else
 612                                 active_dma_mappings = mapping->next;
 613
 614                         spin_unlock_irqrestore (dma_mappings_lock, flags);
 615
 616                         return mapping;
 617                 }
 618         }
 619
 620         panic ("deactivate_dma_mapping: unmapped PCI DMA addr 0x%x",
 621                MB_SRAM_TO_PCI (mb_sram_addr));
 622 }
 623
 624 /* Return MAPPING to the freelist.  */
 625 static inline void
 626 free_dma_mapping (struct dma_mapping *mapping)
 627 {
 628         int flags;
 629
 630         free_mb_sram (mapping->mb_sram_addr, mapping->size);
 631
 632         spin_lock_irqsave (dma_mappings_lock, flags);
 633
 634         mapping->next = free_dma_mappings;
 635         free_dma_mappings = mapping;
 636
 637         spin_unlock_irqrestore (dma_mappings_lock, flags);
 638 }
 639
 640 \f
 641 /* Single PCI DMA mappings.  */
 642
 643 /* `Grant' to PDEV the memory block at CPU_ADDR, for doing DMA.  The
 644    32-bit PCI bus mastering address to use is returned.  the device owns
 645    this memory until either pci_unmap_single or pci_dma_sync_single is
 646    performed.  */
 647 dma_addr_t
 648 pci_map_single (struct pci_dev *pdev, void *cpu_addr, size_t size, int dir)
 649 {
 650         struct dma_mapping *mapping = new_dma_mapping (size);
 651
 652         if (! mapping)
 653                 return 0;
 654
 655         mapping->cpu_addr = cpu_addr;
 656
 657         if (dir == PCI_DMA_BIDIRECTIONAL || dir == PCI_DMA_TODEVICE)
 658                 memcpy (mapping->mb_sram_addr, cpu_addr, size);
 659
 660         return MB_SRAM_TO_PCI (mapping->mb_sram_addr);
 661 }
 662
 663 /* Return to the CPU the PCI DMA memory block previously `granted' to
 664    PDEV, at DMA_ADDR.  */
 665 void pci_unmap_single (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
 666                        int dir)
 667 {
 668         void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
 669         struct dma_mapping *mapping = deactivate_dma_mapping (mb_sram_addr);
 670
 671         if (size != mapping->size)
 672                 panic ("pci_unmap_single: size (%d) doesn't match"
 673                        " size of mapping at PCI DMA addr 0x%x (%d)\n",
 674                        size, dma_addr, mapping->size);
 675
 676         /* Copy back the DMA'd contents if necessary.  */
 677         if (dir == PCI_DMA_BIDIRECTIONAL || dir == PCI_DMA_FROMDEVICE)
 678                 memcpy (mapping->cpu_addr, mb_sram_addr, size);
 679
 680         /* Return mapping to the freelist.  */
 681         free_dma_mapping (mapping);
 682 }
 683
 684 /* Make physical memory consistent for a single streaming mode DMA
 685    translation after a transfer.
 686
 687    If you perform a pci_map_single() but wish to interrogate the
 688    buffer using the cpu, yet do not wish to teardown the PCI dma
 689    mapping, you must call this function before doing so.  At the next
 690    point you give the PCI dma address back to the card, the device
 691    again owns the buffer.  */
 692 void
 693 pci_dma_sync_single (struct pci_dev *pdev, dma_addr_t dma_addr, size_t size,
 694                      int dir)
 695 {
 696         void *mb_sram_addr = PCI_TO_MB_SRAM (dma_addr);
 697         struct dma_mapping *mapping = find_dma_mapping (mb_sram_addr);
 698
 699         /* Synchronize the DMA buffer with the CPU buffer if necessary.  */
 700         if (dir == PCI_DMA_FROMDEVICE)
 701                 memcpy (mapping->cpu_addr, mb_sram_addr, size);
 702         else if (dir == PCI_DMA_TODEVICE)
 703                 memcpy (mb_sram_addr, mapping->cpu_addr, size);
 704         else
 705                 panic("pci_dma_sync_single: unsupported sync dir: %d", dir);
 706 }
 707
 708 \f
 709 /* Scatter-gather PCI DMA mappings.  */
 710
 711 /* Do multiple DMA mappings at once.  */
 712 int
 713 pci_map_sg (struct pci_dev *pdev, struct scatterlist *sg, int sg_len, int dir)
 714 {
 715         BUG ();
 716         return 0;
 717 }
 718
 719 /* Unmap multiple DMA mappings at once.  */
 720 void
 721 pci_unmap_sg (struct pci_dev *pdev, struct scatterlist *sg, int sg_len,int dir)
 722 {
 723         BUG ();
 724 }
 725
 726 /* Make physical memory consistent for a set of streaming mode DMA
 727    translations after a transfer.  The same as pci_dma_sync_single but
 728    for a scatter-gather list, same rules and usage.  */
 729
 730 void
 731 pci_dma_sync_sg (struct pci_dev *dev, struct scatterlist *sg, int sg_len,
 732                  int dir)
 733 {
 734         BUG ();
 735 }
 736
 737 \f
 738 /* PCI mem mapping.  */
 739
 740 /* Allocate and map kernel buffer using consistent mode DMA for PCI
 741    device.  Returns non-NULL cpu-view pointer to the buffer if
 742    successful and sets *DMA_ADDR to the pci side dma address as well,
 743    else DMA_ADDR is undefined.  */
 744 void *
 745 pci_alloc_consistent (struct pci_dev *pdev, size_t size, dma_addr_t *dma_addr)
 746 {
 747         void *mb_sram_mem = alloc_mb_sram (size);
 748         if (mb_sram_mem)
 749                 *dma_addr = MB_SRAM_TO_PCI (mb_sram_mem);
 750         return mb_sram_mem;
 751 }
 752
 753 /* Free and unmap a consistent DMA buffer.  CPU_ADDR and DMA_ADDR must
 754    be values that were returned from pci_alloc_consistent.  SIZE must be
 755    the same as what as passed into pci_alloc_consistent.  References to
 756    the memory and mappings assosciated with CPU_ADDR or DMA_ADDR past
 757    this call are illegal.  */
 758 void
 759 pci_free_consistent (struct pci_dev *pdev, size_t size, void *cpu_addr,
 760                      dma_addr_t dma_addr)
 761 {
 762         void *mb_sram_mem = PCI_TO_MB_SRAM (dma_addr);
 763         free_mb_sram (mb_sram_mem, size);
 764 }
 765
 766 \f
 767 /* symbol exports (for modules) */
 768
 769 EXPORT_SYMBOL (pci_map_single);
 770 EXPORT_SYMBOL (pci_unmap_single);
 771 EXPORT_SYMBOL (pci_alloc_consistent);
 772 EXPORT_SYMBOL (pci_free_consistent);
 773 EXPORT_SYMBOL (pci_dma_sync_single);