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