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