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