atomic: use <linux/atomic.h>
[linux-2.6.git] / arch / parisc / lib / iomap.c
1 /*
2  * iomap.c - Implement iomap interface for PA-RISC
3  * Copyright (c) 2004 Matthew Wilcox
4  */
5
6 #include <linux/ioport.h>
7 #include <linux/pci.h>
8 #include <asm/io.h>
9
10 /*
11  * The iomap space on 32-bit PA-RISC is intended to look like this:
12  * 00000000-7fffffff virtual mapped IO
13  * 80000000-8fffffff ISA/EISA port space that can't be virtually mapped
14  * 90000000-9fffffff Dino port space
15  * a0000000-afffffff Astro port space
16  * b0000000-bfffffff PAT port space
17  * c0000000-cfffffff non-swapped memory IO
18  * f0000000-ffffffff legacy IO memory pointers
19  *
20  * For the moment, here's what it looks like:
21  * 80000000-8fffffff All ISA/EISA port space
22  * f0000000-ffffffff legacy IO memory pointers
23  *
24  * On 64-bit, everything is extended, so:
25  * 8000000000000000-8fffffffffffffff All ISA/EISA port space
26  * f000000000000000-ffffffffffffffff legacy IO memory pointers
27  */
28
29 /*
30  * Technically, this should be 'if (VMALLOC_START < addr < VMALLOC_END),
31  * but that's slow and we know it'll be within the first 2GB.
32  */
33 #ifdef CONFIG_64BIT
34 #define INDIRECT_ADDR(addr)     (((unsigned long)(addr) & 1UL<<63) != 0)
35 #define ADDR_TO_REGION(addr)    (((unsigned long)addr >> 60) & 7)
36 #define IOPORT_MAP_BASE         (8UL << 60)
37 #else
38 #define INDIRECT_ADDR(addr)     (((unsigned long)(addr) & 1UL<<31) != 0)
39 #define ADDR_TO_REGION(addr)    (((unsigned long)addr >> 28) & 7)
40 #define IOPORT_MAP_BASE         (8UL << 28)
41 #endif
42
43 struct iomap_ops {
44         unsigned int (*read8)(void __iomem *);
45         unsigned int (*read16)(void __iomem *);
46         unsigned int (*read16be)(void __iomem *);
47         unsigned int (*read32)(void __iomem *);
48         unsigned int (*read32be)(void __iomem *);
49         void (*write8)(u8, void __iomem *);
50         void (*write16)(u16, void __iomem *);
51         void (*write16be)(u16, void __iomem *);
52         void (*write32)(u32, void __iomem *);
53         void (*write32be)(u32, void __iomem *);
54         void (*read8r)(void __iomem *, void *, unsigned long);
55         void (*read16r)(void __iomem *, void *, unsigned long);
56         void (*read32r)(void __iomem *, void *, unsigned long);
57         void (*write8r)(void __iomem *, const void *, unsigned long);
58         void (*write16r)(void __iomem *, const void *, unsigned long);
59         void (*write32r)(void __iomem *, const void *, unsigned long);
60 };
61
62 /* Generic ioport ops.  To be replaced later by specific dino/elroy/wax code */
63
64 #define ADDR2PORT(addr) ((unsigned long __force)(addr) & 0xffffff)
65
66 static unsigned int ioport_read8(void __iomem *addr)
67 {
68         return inb(ADDR2PORT(addr));
69 }
70
71 static unsigned int ioport_read16(void __iomem *addr)
72 {
73         return inw(ADDR2PORT(addr));
74 }
75
76 static unsigned int ioport_read32(void __iomem *addr)
77 {
78         return inl(ADDR2PORT(addr));
79 }
80
81 static void ioport_write8(u8 datum, void __iomem *addr)
82 {
83         outb(datum, ADDR2PORT(addr));
84 }
85
86 static void ioport_write16(u16 datum, void __iomem *addr)
87 {
88         outw(datum, ADDR2PORT(addr));
89 }
90
91 static void ioport_write32(u32 datum, void __iomem *addr)
92 {
93         outl(datum, ADDR2PORT(addr));
94 }
95
96 static void ioport_read8r(void __iomem *addr, void *dst, unsigned long count)
97 {
98         insb(ADDR2PORT(addr), dst, count);
99 }
100
101 static void ioport_read16r(void __iomem *addr, void *dst, unsigned long count)
102 {
103         insw(ADDR2PORT(addr), dst, count);
104 }
105
106 static void ioport_read32r(void __iomem *addr, void *dst, unsigned long count)
107 {
108         insl(ADDR2PORT(addr), dst, count);
109 }
110
111 static void ioport_write8r(void __iomem *addr, const void *s, unsigned long n)
112 {
113         outsb(ADDR2PORT(addr), s, n);
114 }
115
116 static void ioport_write16r(void __iomem *addr, const void *s, unsigned long n)
117 {
118         outsw(ADDR2PORT(addr), s, n);
119 }
120
121 static void ioport_write32r(void __iomem *addr, const void *s, unsigned long n)
122 {
123         outsl(ADDR2PORT(addr), s, n);
124 }
125
126 static const struct iomap_ops ioport_ops = {
127         ioport_read8,
128         ioport_read16,
129         ioport_read16,
130         ioport_read32,
131         ioport_read32,
132         ioport_write8,
133         ioport_write16,
134         ioport_write16,
135         ioport_write32,
136         ioport_write32,
137         ioport_read8r,
138         ioport_read16r,
139         ioport_read32r,
140         ioport_write8r,
141         ioport_write16r,
142         ioport_write32r,
143 };
144
145 /* Legacy I/O memory ops */
146
147 static unsigned int iomem_read8(void __iomem *addr)
148 {
149         return readb(addr);
150 }
151
152 static unsigned int iomem_read16(void __iomem *addr)
153 {
154         return readw(addr);
155 }
156
157 static unsigned int iomem_read16be(void __iomem *addr)
158 {
159         return __raw_readw(addr);
160 }
161
162 static unsigned int iomem_read32(void __iomem *addr)
163 {
164         return readl(addr);
165 }
166
167 static unsigned int iomem_read32be(void __iomem *addr)
168 {
169         return __raw_readl(addr);
170 }
171
172 static void iomem_write8(u8 datum, void __iomem *addr)
173 {
174         writeb(datum, addr);
175 }
176
177 static void iomem_write16(u16 datum, void __iomem *addr)
178 {
179         writew(datum, addr);
180 }
181
182 static void iomem_write16be(u16 datum, void __iomem *addr)
183 {
184         __raw_writew(datum, addr);
185 }
186
187 static void iomem_write32(u32 datum, void __iomem *addr)
188 {
189         writel(datum, addr);
190 }
191
192 static void iomem_write32be(u32 datum, void __iomem *addr)
193 {
194         __raw_writel(datum, addr);
195 }
196
197 static void iomem_read8r(void __iomem *addr, void *dst, unsigned long count)
198 {
199         while (count--) {
200                 *(u8 *)dst = __raw_readb(addr);
201                 dst++;
202         }
203 }
204
205 static void iomem_read16r(void __iomem *addr, void *dst, unsigned long count)
206 {
207         while (count--) {
208                 *(u16 *)dst = __raw_readw(addr);
209                 dst += 2;
210         }
211 }
212
213 static void iomem_read32r(void __iomem *addr, void *dst, unsigned long count)
214 {
215         while (count--) {
216                 *(u32 *)dst = __raw_readl(addr);
217                 dst += 4;
218         }
219 }
220
221 static void iomem_write8r(void __iomem *addr, const void *s, unsigned long n)
222 {
223         while (n--) {
224                 __raw_writeb(*(u8 *)s, addr);
225                 s++;
226         }
227 }
228
229 static void iomem_write16r(void __iomem *addr, const void *s, unsigned long n)
230 {
231         while (n--) {
232                 __raw_writew(*(u16 *)s, addr);
233                 s += 2;
234         }
235 }
236
237 static void iomem_write32r(void __iomem *addr, const void *s, unsigned long n)
238 {
239         while (n--) {
240                 __raw_writel(*(u32 *)s, addr);
241                 s += 4;
242         }
243 }
244
245 static const struct iomap_ops iomem_ops = {
246         iomem_read8,
247         iomem_read16,
248         iomem_read16be,
249         iomem_read32,
250         iomem_read32be,
251         iomem_write8,
252         iomem_write16,
253         iomem_write16be,
254         iomem_write32,
255         iomem_write32be,
256         iomem_read8r,
257         iomem_read16r,
258         iomem_read32r,
259         iomem_write8r,
260         iomem_write16r,
261         iomem_write32r,
262 };
263
264 static const struct iomap_ops *iomap_ops[8] = {
265         [0] = &ioport_ops,
266         [7] = &iomem_ops
267 };
268
269
270 unsigned int ioread8(void __iomem *addr)
271 {
272         if (unlikely(INDIRECT_ADDR(addr)))
273                 return iomap_ops[ADDR_TO_REGION(addr)]->read8(addr);
274         return *((u8 *)addr);
275 }
276
277 unsigned int ioread16(void __iomem *addr)
278 {
279         if (unlikely(INDIRECT_ADDR(addr)))
280                 return iomap_ops[ADDR_TO_REGION(addr)]->read16(addr);
281         return le16_to_cpup((u16 *)addr);
282 }
283
284 unsigned int ioread16be(void __iomem *addr)
285 {
286         if (unlikely(INDIRECT_ADDR(addr)))
287                 return iomap_ops[ADDR_TO_REGION(addr)]->read16be(addr);
288         return *((u16 *)addr);
289 }
290
291 unsigned int ioread32(void __iomem *addr)
292 {
293         if (unlikely(INDIRECT_ADDR(addr)))
294                 return iomap_ops[ADDR_TO_REGION(addr)]->read32(addr);
295         return le32_to_cpup((u32 *)addr);
296 }
297
298 unsigned int ioread32be(void __iomem *addr)
299 {
300         if (unlikely(INDIRECT_ADDR(addr)))
301                 return iomap_ops[ADDR_TO_REGION(addr)]->read32be(addr);
302         return *((u32 *)addr);
303 }
304
305 void iowrite8(u8 datum, void __iomem *addr)
306 {
307         if (unlikely(INDIRECT_ADDR(addr))) {
308                 iomap_ops[ADDR_TO_REGION(addr)]->write8(datum, addr);
309         } else {
310                 *((u8 *)addr) = datum;
311         }
312 }
313
314 void iowrite16(u16 datum, void __iomem *addr)
315 {
316         if (unlikely(INDIRECT_ADDR(addr))) {
317                 iomap_ops[ADDR_TO_REGION(addr)]->write16(datum, addr);
318         } else {
319                 *((u16 *)addr) = cpu_to_le16(datum);
320         }
321 }
322
323 void iowrite16be(u16 datum, void __iomem *addr)
324 {
325         if (unlikely(INDIRECT_ADDR(addr))) {
326                 iomap_ops[ADDR_TO_REGION(addr)]->write16be(datum, addr);
327         } else {
328                 *((u16 *)addr) = datum;
329         }
330 }
331
332 void iowrite32(u32 datum, void __iomem *addr)
333 {
334         if (unlikely(INDIRECT_ADDR(addr))) {
335                 iomap_ops[ADDR_TO_REGION(addr)]->write32(datum, addr);
336         } else {
337                 *((u32 *)addr) = cpu_to_le32(datum);
338         }
339 }
340
341 void iowrite32be(u32 datum, void __iomem *addr)
342 {
343         if (unlikely(INDIRECT_ADDR(addr))) {
344                 iomap_ops[ADDR_TO_REGION(addr)]->write32be(datum, addr);
345         } else {
346                 *((u32 *)addr) = datum;
347         }
348 }
349
350 /* Repeating interfaces */
351
352 void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
353 {
354         if (unlikely(INDIRECT_ADDR(addr))) {
355                 iomap_ops[ADDR_TO_REGION(addr)]->read8r(addr, dst, count);
356         } else {
357                 while (count--) {
358                         *(u8 *)dst = *(u8 *)addr;
359                         dst++;
360                 }
361         }
362 }
363
364 void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
365 {
366         if (unlikely(INDIRECT_ADDR(addr))) {
367                 iomap_ops[ADDR_TO_REGION(addr)]->read16r(addr, dst, count);
368         } else {
369                 while (count--) {
370                         *(u16 *)dst = *(u16 *)addr;
371                         dst += 2;
372                 }
373         }
374 }
375
376 void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
377 {
378         if (unlikely(INDIRECT_ADDR(addr))) {
379                 iomap_ops[ADDR_TO_REGION(addr)]->read32r(addr, dst, count);
380         } else {
381                 while (count--) {
382                         *(u32 *)dst = *(u32 *)addr;
383                         dst += 4;
384                 }
385         }
386 }
387
388 void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
389 {
390         if (unlikely(INDIRECT_ADDR(addr))) {
391                 iomap_ops[ADDR_TO_REGION(addr)]->write8r(addr, src, count);
392         } else {
393                 while (count--) {
394                         *(u8 *)addr = *(u8 *)src;
395                         src++;
396                 }
397         }
398 }
399
400 void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
401 {
402         if (unlikely(INDIRECT_ADDR(addr))) {
403                 iomap_ops[ADDR_TO_REGION(addr)]->write16r(addr, src, count);
404         } else {
405                 while (count--) {
406                         *(u16 *)addr = *(u16 *)src;
407                         src += 2;
408                 }
409         }
410 }
411
412 void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
413 {
414         if (unlikely(INDIRECT_ADDR(addr))) {
415                 iomap_ops[ADDR_TO_REGION(addr)]->write32r(addr, src, count);
416         } else {
417                 while (count--) {
418                         *(u32 *)addr = *(u32 *)src;
419                         src += 4;
420                 }
421         }
422 }
423
424 /* Mapping interfaces */
425
426 void __iomem *ioport_map(unsigned long port, unsigned int nr)
427 {
428         return (void __iomem *)(IOPORT_MAP_BASE | port);
429 }
430
431 void ioport_unmap(void __iomem *addr)
432 {
433         if (!INDIRECT_ADDR(addr)) {
434                 iounmap(addr);
435         }
436 }
437
438 /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
439 void __iomem *pci_iomap(struct pci_dev *dev, int bar, unsigned long maxlen)
440 {
441         resource_size_t start = pci_resource_start(dev, bar);
442         resource_size_t len = pci_resource_len(dev, bar);
443         unsigned long flags = pci_resource_flags(dev, bar);
444
445         if (!len || !start)
446                 return NULL;
447         if (maxlen && len > maxlen)
448                 len = maxlen;
449         if (flags & IORESOURCE_IO)
450                 return ioport_map(start, len);
451         if (flags & IORESOURCE_MEM) {
452                 if (flags & IORESOURCE_CACHEABLE)
453                         return ioremap(start, len);
454                 return ioremap_nocache(start, len);
455         }
456         /* What? */
457         return NULL;
458 }
459
460 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
461 {
462         if (!INDIRECT_ADDR(addr)) {
463                 iounmap(addr);
464         }
465 }
466
467 EXPORT_SYMBOL(ioread8);
468 EXPORT_SYMBOL(ioread16);
469 EXPORT_SYMBOL(ioread16be);
470 EXPORT_SYMBOL(ioread32);
471 EXPORT_SYMBOL(ioread32be);
472 EXPORT_SYMBOL(iowrite8);
473 EXPORT_SYMBOL(iowrite16);
474 EXPORT_SYMBOL(iowrite16be);
475 EXPORT_SYMBOL(iowrite32);
476 EXPORT_SYMBOL(iowrite32be);
477 EXPORT_SYMBOL(ioread8_rep);
478 EXPORT_SYMBOL(ioread16_rep);
479 EXPORT_SYMBOL(ioread32_rep);
480 EXPORT_SYMBOL(iowrite8_rep);
481 EXPORT_SYMBOL(iowrite16_rep);
482 EXPORT_SYMBOL(iowrite32_rep);
483 EXPORT_SYMBOL(ioport_map);
484 EXPORT_SYMBOL(ioport_unmap);
485 EXPORT_SYMBOL(pci_iomap);
486 EXPORT_SYMBOL(pci_iounmap);