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 #ifdef CONFIG_64BIT 52 u64 (*read64)(const void __iomem *); 53 u64 (*read64be)(const void __iomem *); 54 #endif 55 void (*write8)(u8, void __iomem *); 56 void (*write16)(u16, void __iomem *); 57 void (*write16be)(u16, void __iomem *); 58 void (*write32)(u32, void __iomem *); 59 void (*write32be)(u32, void __iomem *); 60 #ifdef CONFIG_64BIT 61 void (*write64)(u64, void __iomem *); 62 void (*write64be)(u64, void __iomem *); 63 #endif 64 void (*read8r)(const void __iomem *, void *, unsigned long); 65 void (*read16r)(const void __iomem *, void *, unsigned long); 66 void (*read32r)(const void __iomem *, void *, unsigned long); 67 void (*write8r)(void __iomem *, const void *, unsigned long); 68 void (*write16r)(void __iomem *, const void *, unsigned long); 69 void (*write32r)(void __iomem *, const void *, unsigned long); 70 }; 71 72 /* Generic ioport ops. To be replaced later by specific dino/elroy/wax code */ 73 74 #define ADDR2PORT(addr) ((unsigned long __force)(addr) & 0xffffff) 75 76 static unsigned int ioport_read8(const void __iomem *addr) 77 { 78 return inb(ADDR2PORT(addr)); 79 } 80 81 static unsigned int ioport_read16(const void __iomem *addr) 82 { 83 return inw(ADDR2PORT(addr)); 84 } 85 86 static unsigned int ioport_read32(const void __iomem *addr) 87 { 88 return inl(ADDR2PORT(addr)); 89 } 90 91 static void ioport_write8(u8 datum, void __iomem *addr) 92 { 93 outb(datum, ADDR2PORT(addr)); 94 } 95 96 static void ioport_write16(u16 datum, void __iomem *addr) 97 { 98 outw(datum, ADDR2PORT(addr)); 99 } 100 101 static void ioport_write32(u32 datum, void __iomem *addr) 102 { 103 outl(datum, ADDR2PORT(addr)); 104 } 105 106 static void ioport_read8r(const void __iomem *addr, void *dst, unsigned long count) 107 { 108 insb(ADDR2PORT(addr), dst, count); 109 } 110 111 static void ioport_read16r(const void __iomem *addr, void *dst, unsigned long count) 112 { 113 insw(ADDR2PORT(addr), dst, count); 114 } 115 116 static void ioport_read32r(const void __iomem *addr, void *dst, unsigned long count) 117 { 118 insl(ADDR2PORT(addr), dst, count); 119 } 120 121 static void ioport_write8r(void __iomem *addr, const void *s, unsigned long n) 122 { 123 outsb(ADDR2PORT(addr), s, n); 124 } 125 126 static void ioport_write16r(void __iomem *addr, const void *s, unsigned long n) 127 { 128 outsw(ADDR2PORT(addr), s, n); 129 } 130 131 static void ioport_write32r(void __iomem *addr, const void *s, unsigned long n) 132 { 133 outsl(ADDR2PORT(addr), s, n); 134 } 135 136 static const struct iomap_ops ioport_ops = { 137 .read8 = ioport_read8, 138 .read16 = ioport_read16, 139 .read16be = ioport_read16, 140 .read32 = ioport_read32, 141 .read32be = ioport_read32, 142 .write8 = ioport_write8, 143 .write16 = ioport_write16, 144 .write16be = ioport_write16, 145 .write32 = ioport_write32, 146 .write32be = ioport_write32, 147 .read8r = ioport_read8r, 148 .read16r = ioport_read16r, 149 .read32r = ioport_read32r, 150 .write8r = ioport_write8r, 151 .write16r = ioport_write16r, 152 .write32r = ioport_write32r, 153 }; 154 155 /* Legacy I/O memory ops */ 156 157 static unsigned int iomem_read8(const void __iomem *addr) 158 { 159 return readb(addr); 160 } 161 162 static unsigned int iomem_read16(const void __iomem *addr) 163 { 164 return readw(addr); 165 } 166 167 static unsigned int iomem_read16be(const void __iomem *addr) 168 { 169 return __raw_readw(addr); 170 } 171 172 static unsigned int iomem_read32(const void __iomem *addr) 173 { 174 return readl(addr); 175 } 176 177 static unsigned int iomem_read32be(const void __iomem *addr) 178 { 179 return __raw_readl(addr); 180 } 181 182 #ifdef CONFIG_64BIT 183 static u64 iomem_read64(const void __iomem *addr) 184 { 185 return readq(addr); 186 } 187 188 static u64 iomem_read64be(const void __iomem *addr) 189 { 190 return __raw_readq(addr); 191 } 192 #endif 193 194 static void iomem_write8(u8 datum, void __iomem *addr) 195 { 196 writeb(datum, addr); 197 } 198 199 static void iomem_write16(u16 datum, void __iomem *addr) 200 { 201 writew(datum, addr); 202 } 203 204 static void iomem_write16be(u16 datum, void __iomem *addr) 205 { 206 __raw_writew(datum, addr); 207 } 208 209 static void iomem_write32(u32 datum, void __iomem *addr) 210 { 211 writel(datum, addr); 212 } 213 214 static void iomem_write32be(u32 datum, void __iomem *addr) 215 { 216 __raw_writel(datum, addr); 217 } 218 219 #ifdef CONFIG_64BIT 220 static void iomem_write64(u64 datum, void __iomem *addr) 221 { 222 writeq(datum, addr); 223 } 224 225 static void iomem_write64be(u64 datum, void __iomem *addr) 226 { 227 __raw_writeq(datum, addr); 228 } 229 #endif 230 231 static void iomem_read8r(const void __iomem *addr, void *dst, unsigned long count) 232 { 233 while (count--) { 234 *(u8 *)dst = __raw_readb(addr); 235 dst++; 236 } 237 } 238 239 static void iomem_read16r(const void __iomem *addr, void *dst, unsigned long count) 240 { 241 while (count--) { 242 *(u16 *)dst = __raw_readw(addr); 243 dst += 2; 244 } 245 } 246 247 static void iomem_read32r(const void __iomem *addr, void *dst, unsigned long count) 248 { 249 while (count--) { 250 *(u32 *)dst = __raw_readl(addr); 251 dst += 4; 252 } 253 } 254 255 static void iomem_write8r(void __iomem *addr, const void *s, unsigned long n) 256 { 257 while (n--) { 258 __raw_writeb(*(u8 *)s, addr); 259 s++; 260 } 261 } 262 263 static void iomem_write16r(void __iomem *addr, const void *s, unsigned long n) 264 { 265 while (n--) { 266 __raw_writew(*(u16 *)s, addr); 267 s += 2; 268 } 269 } 270 271 static void iomem_write32r(void __iomem *addr, const void *s, unsigned long n) 272 { 273 while (n--) { 274 __raw_writel(*(u32 *)s, addr); 275 s += 4; 276 } 277 } 278 279 static const struct iomap_ops iomem_ops = { 280 .read8 = iomem_read8, 281 .read16 = iomem_read16, 282 .read16be = iomem_read16be, 283 .read32 = iomem_read32, 284 .read32be = iomem_read32be, 285 #ifdef CONFIG_64BIT 286 .read64 = iomem_read64, 287 .read64be = iomem_read64be, 288 #endif 289 .write8 = iomem_write8, 290 .write16 = iomem_write16, 291 .write16be = iomem_write16be, 292 .write32 = iomem_write32, 293 .write32be = iomem_write32be, 294 #ifdef CONFIG_64BIT 295 .write64 = iomem_write64, 296 .write64be = iomem_write64be, 297 #endif 298 .read8r = iomem_read8r, 299 .read16r = iomem_read16r, 300 .read32r = iomem_read32r, 301 .write8r = iomem_write8r, 302 .write16r = iomem_write16r, 303 .write32r = iomem_write32r, 304 }; 305 306 static const struct iomap_ops *iomap_ops[8] = { 307 [0] = &ioport_ops, 308 [7] = &iomem_ops 309 }; 310 311 312 unsigned int ioread8(const void __iomem *addr) 313 { 314 if (unlikely(INDIRECT_ADDR(addr))) 315 return iomap_ops[ADDR_TO_REGION(addr)]->read8(addr); 316 return *((u8 *)addr); 317 } 318 319 unsigned int ioread16(const void __iomem *addr) 320 { 321 if (unlikely(INDIRECT_ADDR(addr))) 322 return iomap_ops[ADDR_TO_REGION(addr)]->read16(addr); 323 return le16_to_cpup((u16 *)addr); 324 } 325 326 unsigned int ioread16be(const void __iomem *addr) 327 { 328 if (unlikely(INDIRECT_ADDR(addr))) 329 return iomap_ops[ADDR_TO_REGION(addr)]->read16be(addr); 330 return *((u16 *)addr); 331 } 332 333 unsigned int ioread32(const void __iomem *addr) 334 { 335 if (unlikely(INDIRECT_ADDR(addr))) 336 return iomap_ops[ADDR_TO_REGION(addr)]->read32(addr); 337 return le32_to_cpup((u32 *)addr); 338 } 339 340 unsigned int ioread32be(const void __iomem *addr) 341 { 342 if (unlikely(INDIRECT_ADDR(addr))) 343 return iomap_ops[ADDR_TO_REGION(addr)]->read32be(addr); 344 return *((u32 *)addr); 345 } 346 347 #ifdef CONFIG_64BIT 348 u64 ioread64(const void __iomem *addr) 349 { 350 if (unlikely(INDIRECT_ADDR(addr))) 351 return iomap_ops[ADDR_TO_REGION(addr)]->read64(addr); 352 return le64_to_cpup((u64 *)addr); 353 } 354 355 u64 ioread64be(const void __iomem *addr) 356 { 357 if (unlikely(INDIRECT_ADDR(addr))) 358 return iomap_ops[ADDR_TO_REGION(addr)]->read64be(addr); 359 return *((u64 *)addr); 360 } 361 #endif 362 363 void iowrite8(u8 datum, void __iomem *addr) 364 { 365 if (unlikely(INDIRECT_ADDR(addr))) { 366 iomap_ops[ADDR_TO_REGION(addr)]->write8(datum, addr); 367 } else { 368 *((u8 *)addr) = datum; 369 } 370 } 371 372 void iowrite16(u16 datum, void __iomem *addr) 373 { 374 if (unlikely(INDIRECT_ADDR(addr))) { 375 iomap_ops[ADDR_TO_REGION(addr)]->write16(datum, addr); 376 } else { 377 *((u16 *)addr) = cpu_to_le16(datum); 378 } 379 } 380 381 void iowrite16be(u16 datum, void __iomem *addr) 382 { 383 if (unlikely(INDIRECT_ADDR(addr))) { 384 iomap_ops[ADDR_TO_REGION(addr)]->write16be(datum, addr); 385 } else { 386 *((u16 *)addr) = datum; 387 } 388 } 389 390 void iowrite32(u32 datum, void __iomem *addr) 391 { 392 if (unlikely(INDIRECT_ADDR(addr))) { 393 iomap_ops[ADDR_TO_REGION(addr)]->write32(datum, addr); 394 } else { 395 *((u32 *)addr) = cpu_to_le32(datum); 396 } 397 } 398 399 void iowrite32be(u32 datum, void __iomem *addr) 400 { 401 if (unlikely(INDIRECT_ADDR(addr))) { 402 iomap_ops[ADDR_TO_REGION(addr)]->write32be(datum, addr); 403 } else { 404 *((u32 *)addr) = datum; 405 } 406 } 407 408 #ifdef CONFIG_64BIT 409 void iowrite64(u64 datum, void __iomem *addr) 410 { 411 if (unlikely(INDIRECT_ADDR(addr))) { 412 iomap_ops[ADDR_TO_REGION(addr)]->write64(datum, addr); 413 } else { 414 *((u64 *)addr) = cpu_to_le64(datum); 415 } 416 } 417 418 void iowrite64be(u64 datum, void __iomem *addr) 419 { 420 if (unlikely(INDIRECT_ADDR(addr))) { 421 iomap_ops[ADDR_TO_REGION(addr)]->write64be(datum, addr); 422 } else { 423 *((u64 *)addr) = datum; 424 } 425 } 426 #endif 427 428 /* Repeating interfaces */ 429 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 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 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 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 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 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 504 void __iomem *ioport_map(unsigned long port, unsigned int nr) 505 { 506 return (void __iomem *)(IOPORT_MAP_BASE | port); 507 } 508 509 void ioport_unmap(void __iomem *addr) 510 { 511 if (!INDIRECT_ADDR(addr)) { 512 iounmap(addr); 513 } 514 } 515 516 #ifdef CONFIG_PCI 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 #ifdef CONFIG_64BIT 532 EXPORT_SYMBOL(ioread64); 533 EXPORT_SYMBOL(ioread64be); 534 #endif 535 EXPORT_SYMBOL(iowrite8); 536 EXPORT_SYMBOL(iowrite16); 537 EXPORT_SYMBOL(iowrite16be); 538 EXPORT_SYMBOL(iowrite32); 539 EXPORT_SYMBOL(iowrite32be); 540 #ifdef CONFIG_64BIT 541 EXPORT_SYMBOL(iowrite64); 542 EXPORT_SYMBOL(iowrite64be); 543 #endif 544 EXPORT_SYMBOL(ioread8_rep); 545 EXPORT_SYMBOL(ioread16_rep); 546 EXPORT_SYMBOL(ioread32_rep); 547 EXPORT_SYMBOL(iowrite8_rep); 548 EXPORT_SYMBOL(iowrite16_rep); 549 EXPORT_SYMBOL(iowrite32_rep); 550 EXPORT_SYMBOL(ioport_map); 551 EXPORT_SYMBOL(ioport_unmap); 552