blob: fb8e10a4fb39d5184b127a934308df1a7aac7900 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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>
Paul Gortmakera87df542011-08-01 13:12:26 -04008#include <linux/export.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -07009#include <asm/io.h>
10
11/*
12 * The iomap space on 32-bit PA-RISC is intended to look like this:
13 * 00000000-7fffffff virtual mapped IO
14 * 80000000-8fffffff ISA/EISA port space that can't be virtually mapped
15 * 90000000-9fffffff Dino port space
16 * a0000000-afffffff Astro port space
17 * b0000000-bfffffff PAT port space
18 * c0000000-cfffffff non-swapped memory IO
19 * f0000000-ffffffff legacy IO memory pointers
20 *
21 * For the moment, here's what it looks like:
22 * 80000000-8fffffff All ISA/EISA port space
23 * f0000000-ffffffff legacy IO memory pointers
24 *
25 * On 64-bit, everything is extended, so:
26 * 8000000000000000-8fffffffffffffff All ISA/EISA port space
27 * f000000000000000-ffffffffffffffff legacy IO memory pointers
28 */
29
30/*
31 * Technically, this should be 'if (VMALLOC_START < addr < VMALLOC_END),
32 * but that's slow and we know it'll be within the first 2GB.
33 */
34#ifdef CONFIG_64BIT
35#define INDIRECT_ADDR(addr) (((unsigned long)(addr) & 1UL<<63) != 0)
36#define ADDR_TO_REGION(addr) (((unsigned long)addr >> 60) & 7)
37#define IOPORT_MAP_BASE (8UL << 60)
38#else
39#define INDIRECT_ADDR(addr) (((unsigned long)(addr) & 1UL<<31) != 0)
40#define ADDR_TO_REGION(addr) (((unsigned long)addr >> 28) & 7)
41#define IOPORT_MAP_BASE (8UL << 28)
42#endif
43
44struct iomap_ops {
45 unsigned int (*read8)(void __iomem *);
46 unsigned int (*read16)(void __iomem *);
James Bottomleydae409a2005-04-16 15:25:54 -070047 unsigned int (*read16be)(void __iomem *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070048 unsigned int (*read32)(void __iomem *);
James Bottomleydae409a2005-04-16 15:25:54 -070049 unsigned int (*read32be)(void __iomem *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070050 void (*write8)(u8, void __iomem *);
51 void (*write16)(u16, void __iomem *);
James Bottomleydae409a2005-04-16 15:25:54 -070052 void (*write16be)(u16, void __iomem *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070053 void (*write32)(u32, void __iomem *);
James Bottomleydae409a2005-04-16 15:25:54 -070054 void (*write32be)(u32, void __iomem *);
Linus Torvalds1da177e2005-04-16 15:20:36 -070055 void (*read8r)(void __iomem *, void *, unsigned long);
56 void (*read16r)(void __iomem *, void *, unsigned long);
57 void (*read32r)(void __iomem *, void *, unsigned long);
58 void (*write8r)(void __iomem *, const void *, unsigned long);
59 void (*write16r)(void __iomem *, const void *, unsigned long);
60 void (*write32r)(void __iomem *, const void *, unsigned long);
61};
62
63/* Generic ioport ops. To be replaced later by specific dino/elroy/wax code */
64
65#define ADDR2PORT(addr) ((unsigned long __force)(addr) & 0xffffff)
66
67static unsigned int ioport_read8(void __iomem *addr)
68{
69 return inb(ADDR2PORT(addr));
70}
71
72static unsigned int ioport_read16(void __iomem *addr)
73{
74 return inw(ADDR2PORT(addr));
75}
76
77static unsigned int ioport_read32(void __iomem *addr)
78{
79 return inl(ADDR2PORT(addr));
80}
81
82static void ioport_write8(u8 datum, void __iomem *addr)
83{
84 outb(datum, ADDR2PORT(addr));
85}
86
87static void ioport_write16(u16 datum, void __iomem *addr)
88{
89 outw(datum, ADDR2PORT(addr));
90}
91
92static void ioport_write32(u32 datum, void __iomem *addr)
93{
94 outl(datum, ADDR2PORT(addr));
95}
96
97static void ioport_read8r(void __iomem *addr, void *dst, unsigned long count)
98{
99 insb(ADDR2PORT(addr), dst, count);
100}
101
102static void ioport_read16r(void __iomem *addr, void *dst, unsigned long count)
103{
104 insw(ADDR2PORT(addr), dst, count);
105}
106
107static void ioport_read32r(void __iomem *addr, void *dst, unsigned long count)
108{
109 insl(ADDR2PORT(addr), dst, count);
110}
111
112static void ioport_write8r(void __iomem *addr, const void *s, unsigned long n)
113{
114 outsb(ADDR2PORT(addr), s, n);
115}
116
117static void ioport_write16r(void __iomem *addr, const void *s, unsigned long n)
118{
119 outsw(ADDR2PORT(addr), s, n);
120}
121
122static void ioport_write32r(void __iomem *addr, const void *s, unsigned long n)
123{
124 outsl(ADDR2PORT(addr), s, n);
125}
126
127static const struct iomap_ops ioport_ops = {
128 ioport_read8,
129 ioport_read16,
James Bottomleydae409a2005-04-16 15:25:54 -0700130 ioport_read16,
131 ioport_read32,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700132 ioport_read32,
133 ioport_write8,
134 ioport_write16,
James Bottomleydae409a2005-04-16 15:25:54 -0700135 ioport_write16,
136 ioport_write32,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 ioport_write32,
138 ioport_read8r,
139 ioport_read16r,
140 ioport_read32r,
141 ioport_write8r,
142 ioport_write16r,
143 ioport_write32r,
144};
145
146/* Legacy I/O memory ops */
147
148static unsigned int iomem_read8(void __iomem *addr)
149{
150 return readb(addr);
151}
152
153static unsigned int iomem_read16(void __iomem *addr)
154{
155 return readw(addr);
156}
157
James Bottomleydae409a2005-04-16 15:25:54 -0700158static unsigned int iomem_read16be(void __iomem *addr)
159{
160 return __raw_readw(addr);
161}
162
Linus Torvalds1da177e2005-04-16 15:20:36 -0700163static unsigned int iomem_read32(void __iomem *addr)
164{
165 return readl(addr);
166}
167
James Bottomleydae409a2005-04-16 15:25:54 -0700168static unsigned int iomem_read32be(void __iomem *addr)
169{
170 return __raw_readl(addr);
171}
172
Linus Torvalds1da177e2005-04-16 15:20:36 -0700173static void iomem_write8(u8 datum, void __iomem *addr)
174{
175 writeb(datum, addr);
176}
177
178static void iomem_write16(u16 datum, void __iomem *addr)
179{
180 writew(datum, addr);
181}
182
James Bottomleydae409a2005-04-16 15:25:54 -0700183static void iomem_write16be(u16 datum, void __iomem *addr)
184{
185 __raw_writew(datum, addr);
186}
187
Linus Torvalds1da177e2005-04-16 15:20:36 -0700188static void iomem_write32(u32 datum, void __iomem *addr)
189{
190 writel(datum, addr);
191}
192
James Bottomleydae409a2005-04-16 15:25:54 -0700193static void iomem_write32be(u32 datum, void __iomem *addr)
194{
195 __raw_writel(datum, addr);
196}
197
Linus Torvalds1da177e2005-04-16 15:20:36 -0700198static void iomem_read8r(void __iomem *addr, void *dst, unsigned long count)
199{
200 while (count--) {
201 *(u8 *)dst = __raw_readb(addr);
202 dst++;
203 }
204}
205
206static void iomem_read16r(void __iomem *addr, void *dst, unsigned long count)
207{
208 while (count--) {
209 *(u16 *)dst = __raw_readw(addr);
210 dst += 2;
211 }
212}
213
214static void iomem_read32r(void __iomem *addr, void *dst, unsigned long count)
215{
216 while (count--) {
217 *(u32 *)dst = __raw_readl(addr);
218 dst += 4;
219 }
220}
221
222static void iomem_write8r(void __iomem *addr, const void *s, unsigned long n)
223{
224 while (n--) {
225 __raw_writeb(*(u8 *)s, addr);
226 s++;
227 }
228}
229
230static void iomem_write16r(void __iomem *addr, const void *s, unsigned long n)
231{
232 while (n--) {
233 __raw_writew(*(u16 *)s, addr);
234 s += 2;
235 }
236}
237
238static void iomem_write32r(void __iomem *addr, const void *s, unsigned long n)
239{
240 while (n--) {
241 __raw_writel(*(u32 *)s, addr);
242 s += 4;
243 }
244}
245
246static const struct iomap_ops iomem_ops = {
247 iomem_read8,
248 iomem_read16,
James Bottomleydae409a2005-04-16 15:25:54 -0700249 iomem_read16be,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700250 iomem_read32,
James Bottomleydae409a2005-04-16 15:25:54 -0700251 iomem_read32be,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700252 iomem_write8,
253 iomem_write16,
James Bottomleydae409a2005-04-16 15:25:54 -0700254 iomem_write16be,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700255 iomem_write32,
James Bottomleydae409a2005-04-16 15:25:54 -0700256 iomem_write32be,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 iomem_read8r,
258 iomem_read16r,
259 iomem_read32r,
260 iomem_write8r,
261 iomem_write16r,
262 iomem_write32r,
263};
264
Adrian Bunk8f47cb872008-12-02 03:28:15 +0000265static const struct iomap_ops *iomap_ops[8] = {
Linus Torvalds1da177e2005-04-16 15:20:36 -0700266 [0] = &ioport_ops,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700267 [7] = &iomem_ops
Linus Torvalds1da177e2005-04-16 15:20:36 -0700268};
269
270
271unsigned int ioread8(void __iomem *addr)
272{
273 if (unlikely(INDIRECT_ADDR(addr)))
274 return iomap_ops[ADDR_TO_REGION(addr)]->read8(addr);
275 return *((u8 *)addr);
276}
277
278unsigned int ioread16(void __iomem *addr)
279{
280 if (unlikely(INDIRECT_ADDR(addr)))
281 return iomap_ops[ADDR_TO_REGION(addr)]->read16(addr);
282 return le16_to_cpup((u16 *)addr);
283}
284
James Bottomleydae409a2005-04-16 15:25:54 -0700285unsigned int ioread16be(void __iomem *addr)
286{
287 if (unlikely(INDIRECT_ADDR(addr)))
288 return iomap_ops[ADDR_TO_REGION(addr)]->read16be(addr);
289 return *((u16 *)addr);
290}
291
Linus Torvalds1da177e2005-04-16 15:20:36 -0700292unsigned int ioread32(void __iomem *addr)
293{
294 if (unlikely(INDIRECT_ADDR(addr)))
295 return iomap_ops[ADDR_TO_REGION(addr)]->read32(addr);
296 return le32_to_cpup((u32 *)addr);
297}
298
James Bottomleydae409a2005-04-16 15:25:54 -0700299unsigned int ioread32be(void __iomem *addr)
300{
301 if (unlikely(INDIRECT_ADDR(addr)))
302 return iomap_ops[ADDR_TO_REGION(addr)]->read32be(addr);
303 return *((u32 *)addr);
304}
305
Linus Torvalds1da177e2005-04-16 15:20:36 -0700306void iowrite8(u8 datum, void __iomem *addr)
307{
308 if (unlikely(INDIRECT_ADDR(addr))) {
309 iomap_ops[ADDR_TO_REGION(addr)]->write8(datum, addr);
310 } else {
311 *((u8 *)addr) = datum;
312 }
313}
314
315void iowrite16(u16 datum, void __iomem *addr)
316{
317 if (unlikely(INDIRECT_ADDR(addr))) {
318 iomap_ops[ADDR_TO_REGION(addr)]->write16(datum, addr);
319 } else {
320 *((u16 *)addr) = cpu_to_le16(datum);
321 }
322}
323
James Bottomleydae409a2005-04-16 15:25:54 -0700324void iowrite16be(u16 datum, void __iomem *addr)
325{
326 if (unlikely(INDIRECT_ADDR(addr))) {
327 iomap_ops[ADDR_TO_REGION(addr)]->write16be(datum, addr);
328 } else {
329 *((u16 *)addr) = datum;
330 }
331}
332
Linus Torvalds1da177e2005-04-16 15:20:36 -0700333void iowrite32(u32 datum, void __iomem *addr)
334{
335 if (unlikely(INDIRECT_ADDR(addr))) {
336 iomap_ops[ADDR_TO_REGION(addr)]->write32(datum, addr);
337 } else {
338 *((u32 *)addr) = cpu_to_le32(datum);
339 }
340}
341
James Bottomleydae409a2005-04-16 15:25:54 -0700342void iowrite32be(u32 datum, void __iomem *addr)
343{
344 if (unlikely(INDIRECT_ADDR(addr))) {
345 iomap_ops[ADDR_TO_REGION(addr)]->write32be(datum, addr);
346 } else {
347 *((u32 *)addr) = datum;
348 }
349}
350
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351/* Repeating interfaces */
352
353void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
354{
355 if (unlikely(INDIRECT_ADDR(addr))) {
356 iomap_ops[ADDR_TO_REGION(addr)]->read8r(addr, dst, count);
357 } else {
358 while (count--) {
359 *(u8 *)dst = *(u8 *)addr;
360 dst++;
361 }
362 }
363}
364
365void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
366{
367 if (unlikely(INDIRECT_ADDR(addr))) {
368 iomap_ops[ADDR_TO_REGION(addr)]->read16r(addr, dst, count);
369 } else {
370 while (count--) {
371 *(u16 *)dst = *(u16 *)addr;
372 dst += 2;
373 }
374 }
375}
376
377void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
378{
379 if (unlikely(INDIRECT_ADDR(addr))) {
380 iomap_ops[ADDR_TO_REGION(addr)]->read32r(addr, dst, count);
381 } else {
382 while (count--) {
383 *(u32 *)dst = *(u32 *)addr;
384 dst += 4;
385 }
386 }
387}
388
389void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
390{
391 if (unlikely(INDIRECT_ADDR(addr))) {
392 iomap_ops[ADDR_TO_REGION(addr)]->write8r(addr, src, count);
393 } else {
394 while (count--) {
395 *(u8 *)addr = *(u8 *)src;
396 src++;
397 }
398 }
399}
400
401void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
402{
403 if (unlikely(INDIRECT_ADDR(addr))) {
404 iomap_ops[ADDR_TO_REGION(addr)]->write16r(addr, src, count);
405 } else {
406 while (count--) {
407 *(u16 *)addr = *(u16 *)src;
408 src += 2;
409 }
410 }
411}
412
413void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
414{
415 if (unlikely(INDIRECT_ADDR(addr))) {
416 iomap_ops[ADDR_TO_REGION(addr)]->write32r(addr, src, count);
417 } else {
418 while (count--) {
419 *(u32 *)addr = *(u32 *)src;
420 src += 4;
421 }
422 }
423}
424
425/* Mapping interfaces */
426
427void __iomem *ioport_map(unsigned long port, unsigned int nr)
428{
429 return (void __iomem *)(IOPORT_MAP_BASE | port);
430}
431
432void ioport_unmap(void __iomem *addr)
433{
434 if (!INDIRECT_ADDR(addr)) {
435 iounmap(addr);
436 }
437}
438
Linus Torvalds1da177e2005-04-16 15:20:36 -0700439void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
440{
441 if (!INDIRECT_ADDR(addr)) {
442 iounmap(addr);
443 }
444}
445
446EXPORT_SYMBOL(ioread8);
447EXPORT_SYMBOL(ioread16);
James Bottomleydae409a2005-04-16 15:25:54 -0700448EXPORT_SYMBOL(ioread16be);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700449EXPORT_SYMBOL(ioread32);
James Bottomleydae409a2005-04-16 15:25:54 -0700450EXPORT_SYMBOL(ioread32be);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700451EXPORT_SYMBOL(iowrite8);
452EXPORT_SYMBOL(iowrite16);
James Bottomleydae409a2005-04-16 15:25:54 -0700453EXPORT_SYMBOL(iowrite16be);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700454EXPORT_SYMBOL(iowrite32);
James Bottomleydae409a2005-04-16 15:25:54 -0700455EXPORT_SYMBOL(iowrite32be);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700456EXPORT_SYMBOL(ioread8_rep);
457EXPORT_SYMBOL(ioread16_rep);
458EXPORT_SYMBOL(ioread32_rep);
459EXPORT_SYMBOL(iowrite8_rep);
460EXPORT_SYMBOL(iowrite16_rep);
461EXPORT_SYMBOL(iowrite32_rep);
462EXPORT_SYMBOL(ioport_map);
463EXPORT_SYMBOL(ioport_unmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700464EXPORT_SYMBOL(pci_iounmap);