]> err.no Git - linux-2.6/blob - include/asm-arm/arch-ixp4xx/io.h
Merge /spare/repo/linux-2.6/
[linux-2.6] / include / asm-arm / arch-ixp4xx / io.h
1 /*
2  * linux/include/asm-arm/arch-ixp4xx/io.h
3  *
4  * Author: Deepak Saxena <dsaxena@plexity.net>
5  *
6  * Copyright (C) 2002-2005  MontaVista Software, Inc.
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License version 2 as
10  * published by the Free Software Foundation.
11  */
12
13 #ifndef __ASM_ARM_ARCH_IO_H
14 #define __ASM_ARM_ARCH_IO_H
15
16 #include <asm/hardware.h>
17
18 #define IO_SPACE_LIMIT 0xffff0000
19
20 #define BIT(x)  ((1)<<(x))
21
22
23 extern int (*ixp4xx_pci_read)(u32 addr, u32 cmd, u32* data);
24 extern int ixp4xx_pci_write(u32 addr, u32 cmd, u32 data);
25
26
27 /*
28  * IXP4xx provides two methods of accessing PCI memory space:
29  *
30  * 1) A direct mapped window from 0x48000000 to 0x4bffffff (64MB).
31  *    To access PCI via this space, we simply ioremap() the BAR
32  *    into the kernel and we can use the standard read[bwl]/write[bwl]
33  *    macros. This is the preffered method due to speed but it
34  *    limits the system to just 64MB of PCI memory. This can be 
35  *    problamatic if using video cards and other memory-heavy
36  *    targets.
37  *
38  * 2) If > 64MB of memory space is required, the IXP4xx can be configured
39  *    to use indirect registers to access PCI (as we do below for I/O
40  *    transactions). This allows for up to 128MB (0x48000000 to 0x4fffffff)
41  *    of memory on the bus. The disadvantadge of this is that every 
42  *    PCI access requires three local register accesses plus a spinlock,
43  *    but in some cases the performance hit is acceptable. In addition,
44  *    you cannot mmap() PCI devices in this case.
45  *
46  */
47 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
48
49 #define __mem_pci(a)            (a)
50
51 #else
52
53 #include <linux/mm.h>
54
55 /*
56  * In the case of using indirect PCI, we simply return the actual PCI
57  * address and our read/write implementation use that to drive the 
58  * access registers. If something outside of PCI is ioremap'd, we
59  * fallback to the default.
60  */
61 static inline void __iomem *
62 __ixp4xx_ioremap(unsigned long addr, size_t size, unsigned long flags, unsigned long align)
63 {
64         extern void __iomem * __ioremap(unsigned long, size_t, unsigned long, unsigned long);
65         if((addr < 0x48000000) || (addr > 0x4fffffff))
66                 return __ioremap(addr, size, flags, align);
67
68         return (void *)addr;
69 }
70
71 static inline void
72 __ixp4xx_iounmap(void __iomem *addr)
73 {
74         extern void __iounmap(void __iomem *addr);
75
76         if ((u32)addr >= VMALLOC_START)
77                 __iounmap(addr);
78 }
79
80 #define __arch_ioremap(a, s, f, x)      __ixp4xx_ioremap(a, s, f, x)
81 #define __arch_iounmap(a)               __ixp4xx_iounmap(a)
82
83 #define writeb(p, v)                    __ixp4xx_writeb(p, v)
84 #define writew(p, v)                    __ixp4xx_writew(p, v)
85 #define writel(p, v)                    __ixp4xx_writel(p, v)
86
87 #define writesb(p, v, l)                __ixp4xx_writesb(p, v, l)
88 #define writesw(p, v, l)                __ixp4xx_writesw(p, v, l)
89 #define writesl(p, v, l)                __ixp4xx_writesl(p, v, l)
90         
91 #define readb(p)                        __ixp4xx_readb(p)
92 #define readw(p)                        __ixp4xx_readw(p)
93 #define readl(p)                        __ixp4xx_readl(p)
94         
95 #define readsb(p, v, l)                 __ixp4xx_readsb(p, v, l)
96 #define readsw(p, v, l)                 __ixp4xx_readsw(p, v, l)
97 #define readsl(p, v, l)                 __ixp4xx_readsl(p, v, l)
98
99 static inline void 
100 __ixp4xx_writeb(u8 value, u32 addr)
101 {
102         u32 n, byte_enables, data;
103
104         if (addr >= VMALLOC_START) {
105                 __raw_writeb(value, addr);
106                 return;
107         }
108
109         n = addr % 4;
110         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
111         data = value << (8*n);
112         ixp4xx_pci_write(addr, byte_enables | NP_CMD_MEMWRITE, data);
113 }
114
115 static inline void
116 __ixp4xx_writesb(u32 bus_addr, u8 *vaddr, int count)
117 {
118         while (count--)
119                 writeb(*vaddr++, bus_addr);
120 }
121
122 static inline void 
123 __ixp4xx_writew(u16 value, u32 addr)
124 {
125         u32 n, byte_enables, data;
126
127         if (addr >= VMALLOC_START) {
128                 __raw_writew(value, addr);
129                 return;
130         }
131
132         n = addr % 4;
133         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
134         data = value << (8*n);
135         ixp4xx_pci_write(addr, byte_enables | NP_CMD_MEMWRITE, data);
136 }
137
138 static inline void
139 __ixp4xx_writesw(u32 bus_addr, u16 *vaddr, int count)
140 {
141         while (count--)
142                 writew(*vaddr++, bus_addr);
143 }
144
145 static inline void 
146 __ixp4xx_writel(u32 value, u32 addr)
147 {
148         if (addr >= VMALLOC_START) {
149                 __raw_writel(value, addr);
150                 return;
151         }
152
153         ixp4xx_pci_write(addr, NP_CMD_MEMWRITE, value);
154 }
155
156 static inline void
157 __ixp4xx_writesl(u32 bus_addr, u32 *vaddr, int count)
158 {
159         while (count--)
160                 writel(*vaddr++, bus_addr);
161 }
162
163 static inline unsigned char 
164 __ixp4xx_readb(u32 addr)
165 {
166         u32 n, byte_enables, data;
167
168         if (addr >= VMALLOC_START)
169                 return __raw_readb(addr);
170
171         n = addr % 4;
172         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
173         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_MEMREAD, &data))
174                 return 0xff;
175
176         return data >> (8*n);
177 }
178
179 static inline void
180 __ixp4xx_readsb(u32 bus_addr, u8 *vaddr, u32 count)
181 {
182         while (count--)
183                 *vaddr++ = readb(bus_addr);
184 }
185
186 static inline unsigned short 
187 __ixp4xx_readw(u32 addr)
188 {
189         u32 n, byte_enables, data;
190
191         if (addr >= VMALLOC_START)
192                 return __raw_readw(addr);
193
194         n = addr % 4;
195         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
196         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_MEMREAD, &data))
197                 return 0xffff;
198
199         return data>>(8*n);
200 }
201
202 static inline void 
203 __ixp4xx_readsw(u32 bus_addr, u16 *vaddr, u32 count)
204 {
205         while (count--)
206                 *vaddr++ = readw(bus_addr);
207 }
208
209 static inline unsigned long 
210 __ixp4xx_readl(u32 addr)
211 {
212         u32 data;
213
214         if (addr >= VMALLOC_START)
215                 return __raw_readl(addr);
216
217         if (ixp4xx_pci_read(addr, NP_CMD_MEMREAD, &data))
218                 return 0xffffffff;
219
220         return data;
221 }
222
223 static inline void 
224 __ixp4xx_readsl(u32 bus_addr, u32 *vaddr, u32 count)
225 {
226         while (count--)
227                 *vaddr++ = readl(bus_addr);
228 }
229
230
231 /*
232  * We can use the built-in functions b/c they end up calling writeb/readb
233  */
234 #define memset_io(c,v,l)                _memset_io((c),(v),(l))
235 #define memcpy_fromio(a,c,l)            _memcpy_fromio((a),(c),(l))
236 #define memcpy_toio(c,a,l)              _memcpy_toio((c),(a),(l))
237
238 #define eth_io_copy_and_sum(s,c,l,b) \
239                                 eth_copy_and_sum((s),__mem_pci(c),(l),(b))
240
241 static inline int
242 check_signature(unsigned long bus_addr, const unsigned char *signature,
243                 int length)
244 {
245         int retval = 0;
246         do {
247                 if (readb(bus_addr) != *signature)
248                         goto out;
249                 bus_addr++;
250                 signature++;
251                 length--;
252         } while (length);
253         retval = 1;
254 out:
255         return retval;
256 }
257
258 #endif
259
260 /*
261  * IXP4xx does not have a transparent cpu -> PCI I/O translation
262  * window.  Instead, it has a set of registers that must be tweaked
263  * with the proper byte lanes, command types, and address for the
264  * transaction.  This means that we need to override the default
265  * I/O functions.
266  */
267 #define outb(p, v)                      __ixp4xx_outb(p, v)
268 #define outw(p, v)                      __ixp4xx_outw(p, v)
269 #define outl(p, v)                      __ixp4xx_outl(p, v)
270         
271 #define outsb(p, v, l)                  __ixp4xx_outsb(p, v, l)
272 #define outsw(p, v, l)                  __ixp4xx_outsw(p, v, l)
273 #define outsl(p, v, l)                  __ixp4xx_outsl(p, v, l)
274
275 #define inb(p)                          __ixp4xx_inb(p)
276 #define inw(p)                          __ixp4xx_inw(p)
277 #define inl(p)                          __ixp4xx_inl(p)
278
279 #define insb(p, v, l)                   __ixp4xx_insb(p, v, l)
280 #define insw(p, v, l)                   __ixp4xx_insw(p, v, l)
281 #define insl(p, v, l)                   __ixp4xx_insl(p, v, l)
282
283
284 static inline void 
285 __ixp4xx_outb(u8 value, u32 addr)
286 {
287         u32 n, byte_enables, data;
288         n = addr % 4;
289         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
290         data = value << (8*n);
291         ixp4xx_pci_write(addr, byte_enables | NP_CMD_IOWRITE, data);
292 }
293
294 static inline void 
295 __ixp4xx_outsb(u32 io_addr, const u8 *vaddr, u32 count)
296 {
297         while (count--)
298                 outb(*vaddr++, io_addr);
299 }
300
301 static inline void 
302 __ixp4xx_outw(u16 value, u32 addr)
303 {
304         u32 n, byte_enables, data;
305         n = addr % 4;
306         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
307         data = value << (8*n);
308         ixp4xx_pci_write(addr, byte_enables | NP_CMD_IOWRITE, data);
309 }
310
311 static inline void 
312 __ixp4xx_outsw(u32 io_addr, const u16 *vaddr, u32 count)
313 {
314         while (count--)
315                 outw(cpu_to_le16(*vaddr++), io_addr);
316 }
317
318 static inline void 
319 __ixp4xx_outl(u32 value, u32 addr)
320 {
321         ixp4xx_pci_write(addr, NP_CMD_IOWRITE, value);
322 }
323
324 static inline void 
325 __ixp4xx_outsl(u32 io_addr, const u32 *vaddr, u32 count)
326 {
327         while (count--)
328                 outl(*vaddr++, io_addr);
329 }
330
331 static inline u8 
332 __ixp4xx_inb(u32 addr)
333 {
334         u32 n, byte_enables, data;
335         n = addr % 4;
336         byte_enables = (0xf & ~BIT(n)) << IXP4XX_PCI_NP_CBE_BESL;
337         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_IOREAD, &data))
338                 return 0xff;
339
340         return data >> (8*n);
341 }
342
343 static inline void 
344 __ixp4xx_insb(u32 io_addr, u8 *vaddr, u32 count)
345 {
346         while (count--)
347                 *vaddr++ = inb(io_addr);
348 }
349
350 static inline u16 
351 __ixp4xx_inw(u32 addr)
352 {
353         u32 n, byte_enables, data;
354         n = addr % 4;
355         byte_enables = (0xf & ~(BIT(n) | BIT(n+1))) << IXP4XX_PCI_NP_CBE_BESL;
356         if (ixp4xx_pci_read(addr, byte_enables | NP_CMD_IOREAD, &data))
357                 return 0xffff;
358
359         return data>>(8*n);
360 }
361
362 static inline void 
363 __ixp4xx_insw(u32 io_addr, u16 *vaddr, u32 count)
364 {
365         while (count--)
366                 *vaddr++ = le16_to_cpu(inw(io_addr));
367 }
368
369 static inline u32 
370 __ixp4xx_inl(u32 addr)
371 {
372         u32 data;
373         if (ixp4xx_pci_read(addr, NP_CMD_IOREAD, &data))
374                 return 0xffffffff;
375
376         return data;
377 }
378
379 static inline void 
380 __ixp4xx_insl(u32 io_addr, u32 *vaddr, u32 count)
381 {
382         while (count--)
383                 *vaddr++ = inl(io_addr);
384 }
385
386 #define PIO_OFFSET      0x10000UL
387 #define PIO_MASK        0x0ffffUL
388
389 #define __is_io_address(p)      (((unsigned long)p >= PIO_OFFSET) && \
390                                         ((unsigned long)p <= (PIO_MASK + PIO_OFFSET)))
391 static inline unsigned int
392 __ixp4xx_ioread8(void __iomem *addr)
393 {
394         unsigned long port = (unsigned long __force)addr;
395         if (__is_io_address(port))
396                 return  (unsigned int)__ixp4xx_inb(port & PIO_MASK);
397         else
398 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
399                 return (unsigned int)__raw_readb(port);
400 #else
401                 return (unsigned int)__ixp4xx_readb(port);
402 #endif
403 }
404
405 static inline void
406 __ixp4xx_ioread8_rep(void __iomem *addr, void *vaddr, u32 count)
407 {
408         unsigned long port = (unsigned long __force)addr;
409         if (__is_io_address(port))
410                 __ixp4xx_insb(port & PIO_MASK, vaddr, count);
411         else
412 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
413                 __raw_readsb(addr, vaddr, count);
414 #else
415                 __ixp4xx_readsb(port, vaddr, count);
416 #endif
417 }
418
419 static inline unsigned int
420 __ixp4xx_ioread16(void __iomem *addr)
421 {
422         unsigned long port = (unsigned long __force)addr;
423         if (__is_io_address(port))
424                 return  (unsigned int)__ixp4xx_inw(port & PIO_MASK);
425         else
426 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
427                 return le16_to_cpu(__raw_readw((u32)port));
428 #else
429                 return (unsigned int)__ixp4xx_readw((u32)port);
430 #endif
431 }
432
433 static inline void
434 __ixp4xx_ioread16_rep(void __iomem *addr, void *vaddr, u32 count)
435 {
436         unsigned long port = (unsigned long __force)addr;
437         if (__is_io_address(port))
438                 __ixp4xx_insw(port & PIO_MASK, vaddr, count);
439         else
440 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
441                 __raw_readsw(addr, vaddr, count);
442 #else
443                 __ixp4xx_readsw(port, vaddr, count);
444 #endif
445 }
446
447 static inline unsigned int
448 __ixp4xx_ioread32(void __iomem *addr)
449 {
450         unsigned long port = (unsigned long __force)addr;
451         if (__is_io_address(port))
452                 return  (unsigned int)__ixp4xx_inl(port & PIO_MASK);
453         else {
454 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
455                 return le32_to_cpu(__raw_readl((u32)port));
456 #else
457                 return (unsigned int)__ixp4xx_readl((u32)port);
458 #endif
459         }
460 }
461
462 static inline void
463 __ixp4xx_ioread32_rep(void __iomem *addr, void *vaddr, u32 count)
464 {
465         unsigned long port = (unsigned long __force)addr;
466         if (__is_io_address(port))
467                 __ixp4xx_insl(port & PIO_MASK, vaddr, count);
468         else
469 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
470                 __raw_readsl(addr, vaddr, count);
471 #else
472                 __ixp4xx_readsl(port, vaddr, count);
473 #endif
474 }
475
476 static inline void
477 __ixp4xx_iowrite8(u8 value, void __iomem *addr)
478 {
479         unsigned long port = (unsigned long __force)addr;
480         if (__is_io_address(port))
481                 __ixp4xx_outb(value, port & PIO_MASK);
482         else
483 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
484                 __raw_writeb(value, port);
485 #else
486                 __ixp4xx_writeb(value, port);
487 #endif
488 }
489
490 static inline void
491 __ixp4xx_iowrite8_rep(void __iomem *addr, const void *vaddr, u32 count)
492 {
493         unsigned long port = (unsigned long __force)addr;
494         if (__is_io_address(port))
495                 __ixp4xx_outsb(port & PIO_MASK, vaddr, count);
496         else
497 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
498                 __raw_writesb(addr, vaddr, count);
499 #else
500                 __ixp4xx_writesb(port, vaddr, count);
501 #endif
502 }
503
504 static inline void
505 __ixp4xx_iowrite16(u16 value, void __iomem *addr)
506 {
507         unsigned long port = (unsigned long __force)addr;
508         if (__is_io_address(port))
509                 __ixp4xx_outw(value, port & PIO_MASK);
510         else
511 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
512                 __raw_writew(cpu_to_le16(value), addr);
513 #else
514                 __ixp4xx_writew(value, port);
515 #endif
516 }
517
518 static inline void
519 __ixp4xx_iowrite16_rep(void __iomem *addr, const void *vaddr, u32 count)
520 {
521         unsigned long port = (unsigned long __force)addr;
522         if (__is_io_address(port))
523                 __ixp4xx_outsw(port & PIO_MASK, vaddr, count);
524         else
525 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
526                 __raw_writesw(addr, vaddr, count);
527 #else
528                 __ixp4xx_writesw(port, vaddr, count);
529 #endif
530 }
531
532 static inline void
533 __ixp4xx_iowrite32(u32 value, void __iomem *addr)
534 {
535         unsigned long port = (unsigned long __force)addr;
536         if (__is_io_address(port))
537                 __ixp4xx_outl(value, port & PIO_MASK);
538         else
539 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
540                 __raw_writel(cpu_to_le32(value), port);
541 #else
542                 __ixp4xx_writel(value, port);
543 #endif
544 }
545
546 static inline void
547 __ixp4xx_iowrite32_rep(void __iomem *addr, const void *vaddr, u32 count)
548 {
549         unsigned long port = (unsigned long __force)addr;
550         if (__is_io_address(port))
551                 __ixp4xx_outsl(port & PIO_MASK, vaddr, count);
552         else
553 #ifndef CONFIG_IXP4XX_INDIRECT_PCI
554                 __raw_writesl(addr, vaddr, count);
555 #else
556                 __ixp4xx_writesl(port, vaddr, count);
557 #endif
558 }
559
560 #define ioread8(p)                      __ixp4xx_ioread8(p)
561 #define ioread16(p)                     __ixp4xx_ioread16(p)
562 #define ioread32(p)                     __ixp4xx_ioread32(p)
563
564 #define ioread8_rep(p, v, c)            __ixp4xx_ioread8_rep(p, v, c)
565 #define ioread16_rep(p, v, c)           __ixp4xx_ioread16_rep(p, v, c)
566 #define ioread32_rep(p, v, c)           __ixp4xx_ioread32_rep(p, v, c)
567
568 #define iowrite8(v,p)                   __ixp4xx_iowrite8(v,p)
569 #define iowrite16(v,p)                  __ixp4xx_iowrite16(v,p)
570 #define iowrite32(v,p)                  __ixp4xx_iowrite32(v,p)
571
572 #define iowrite8_rep(p, v, c)           __ixp4xx_iowrite8_rep(p, v, c)
573 #define iowrite16_rep(p, v, c)          __ixp4xx_iowrite16_rep(p, v, c)
574 #define iowrite32_rep(p, v, c)          __ixp4xx_iowrite32_rep(p, v, c)
575
576 #define ioport_map(port, nr)            ((void __iomem*)(port + PIO_OFFSET))
577 #define ioport_unmap(addr)
578
579 #endif  //  __ASM_ARM_ARCH_IO_H
580