arch/parisc/lib/iomap.c

   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)(void __iomem *);
  47         unsigned int (*read16)(void __iomem *);
  48         unsigned int (*read16be)(void __iomem *);
  49         unsigned int (*read32)(void __iomem *);
  50         unsigned int (*read32be)(void __iomem *);
  51         u64 (*read64)(void __iomem *);
  52         u64 (*read64be)(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)(void __iomem *, void *, unsigned long);
  61         void (*read16r)(void __iomem *, void *, unsigned long);
  62         void (*read32r)(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
  72 static unsigned int ioport_read8(void __iomem *addr)
  73 {
  74         return inb(ADDR2PORT(addr));
  75 }
  76
  77 static unsigned int ioport_read16(void __iomem *addr)
  78 {
  79         return inw(ADDR2PORT(addr));
  80 }
  81
  82 static unsigned int ioport_read32(void __iomem *addr)
  83 {
  84         return inl(ADDR2PORT(addr));
  85 }
  86
  87 static void ioport_write8(u8 datum, void __iomem *addr)
  88 {
  89         outb(datum, ADDR2PORT(addr));
  90 }
  91
  92 static void ioport_write16(u16 datum, void __iomem *addr)
  93 {
  94         outw(datum, ADDR2PORT(addr));
  95 }
  96
  97 static void ioport_write32(u32 datum, void __iomem *addr)
  98 {
  99         outl(datum, ADDR2PORT(addr));
 100 }
 101
 102 static void ioport_read8r(void __iomem *addr, void *dst, unsigned long count)
 103 {
 104         insb(ADDR2PORT(addr), dst, count);
 105 }
 106
 107 static void ioport_read16r(void __iomem *addr, void *dst, unsigned long count)
 108 {
 109         insw(ADDR2PORT(addr), dst, count);
 110 }
 111
 112 static void ioport_read32r(void __iomem *addr, void *dst, unsigned long count)
 113 {
 114         insl(ADDR2PORT(addr), dst, count);
 115 }
 116
 117 static void ioport_write8r(void __iomem *addr, const void *s, unsigned long n)
 118 {
 119         outsb(ADDR2PORT(addr), s, n);
 120 }
 121
 122 static void ioport_write16r(void __iomem *addr, const void *s, unsigned long n)
 123 {
 124         outsw(ADDR2PORT(addr), s, n);
 125 }
 126
 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
 153 static unsigned int iomem_read8(void __iomem *addr)
 154 {
 155         return readb(addr);
 156 }
 157
 158 static unsigned int iomem_read16(void __iomem *addr)
 159 {
 160         return readw(addr);
 161 }
 162
 163 static unsigned int iomem_read16be(void __iomem *addr)
 164 {
 165         return __raw_readw(addr);
 166 }
 167
 168 static unsigned int iomem_read32(void __iomem *addr)
 169 {
 170         return readl(addr);
 171 }
 172
 173 static unsigned int iomem_read32be(void __iomem *addr)
 174 {
 175         return __raw_readl(addr);
 176 }
 177
 178 static u64 iomem_read64(void __iomem *addr)
 179 {
 180         return readq(addr);
 181 }
 182
 183 static u64 iomem_read64be(void __iomem *addr)
 184 {
 185         return __raw_readq(addr);
 186 }
 187
 188 static void iomem_write8(u8 datum, void __iomem *addr)
 189 {
 190         writeb(datum, addr);
 191 }
 192
 193 static void iomem_write16(u16 datum, void __iomem *addr)
 194 {
 195         writew(datum, addr);
 196 }
 197
 198 static void iomem_write16be(u16 datum, void __iomem *addr)
 199 {
 200         __raw_writew(datum, addr);
 201 }
 202
 203 static void iomem_write32(u32 datum, void __iomem *addr)
 204 {
 205         writel(datum, addr);
 206 }
 207
 208 static void iomem_write32be(u32 datum, void __iomem *addr)
 209 {
 210         __raw_writel(datum, addr);
 211 }
 212
 213 static void iomem_write64(u64 datum, void __iomem *addr)
 214 {
 215         writel(datum, addr);
 216 }
 217
 218 static void iomem_write64be(u64 datum, void __iomem *addr)
 219 {
 220         __raw_writel(datum, addr);
 221 }
 222
 223 static void iomem_read8r(void __iomem *addr, void *dst, unsigned long count)
 224 {
 225         while (count--) {
 226                 *(u8 *)dst = __raw_readb(addr);
 227                 dst++;
 228         }
 229 }
 230
 231 static void iomem_read16r(void __iomem *addr, void *dst, unsigned long count)
 232 {
 233         while (count--) {
 234                 *(u16 *)dst = __raw_readw(addr);
 235                 dst += 2;
 236         }
 237 }
 238
 239 static void iomem_read32r(void __iomem *addr, void *dst, unsigned long count)
 240 {
 241         while (count--) {
 242                 *(u32 *)dst = __raw_readl(addr);
 243                 dst += 4;
 244         }
 245 }
 246
 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
 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
 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
 300 unsigned int ioread8(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
 307 unsigned int ioread16(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
 314 unsigned int ioread16be(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
 321 unsigned int ioread32(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
 328 unsigned int ioread32be(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
 335 u64 ioread64(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
 342 u64 ioread64be(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
 349 void iowrite8(u8 datum, void __iomem *addr)
 350 {
 351         if (unlikely(INDIRECT_ADDR(addr))) {
 352                 iomap_ops[ADDR_TO_REGION(addr)]->write8(datum, addr);
 353         } else {
 354                 *((u8 *)addr) = datum;
 355         }
 356 }
 357
 358 void iowrite16(u16 datum, void __iomem *addr)
 359 {
 360         if (unlikely(INDIRECT_ADDR(addr))) {
 361                 iomap_ops[ADDR_TO_REGION(addr)]->write16(datum, addr);
 362         } else {
 363                 *((u16 *)addr) = cpu_to_le16(datum);
 364         }
 365 }
 366
 367 void iowrite16be(u16 datum, void __iomem *addr)
 368 {
 369         if (unlikely(INDIRECT_ADDR(addr))) {
 370                 iomap_ops[ADDR_TO_REGION(addr)]->write16be(datum, addr);
 371         } else {
 372                 *((u16 *)addr) = datum;
 373         }
 374 }
 375
 376 void iowrite32(u32 datum, void __iomem *addr)
 377 {
 378         if (unlikely(INDIRECT_ADDR(addr))) {
 379                 iomap_ops[ADDR_TO_REGION(addr)]->write32(datum, addr);
 380         } else {
 381                 *((u32 *)addr) = cpu_to_le32(datum);
 382         }
 383 }
 384
 385 void iowrite32be(u32 datum, void __iomem *addr)
 386 {
 387         if (unlikely(INDIRECT_ADDR(addr))) {
 388                 iomap_ops[ADDR_TO_REGION(addr)]->write32be(datum, addr);
 389         } else {
 390                 *((u32 *)addr) = datum;
 391         }
 392 }
 393
 394 void iowrite64(u64 datum, void __iomem *addr)
 395 {
 396         if (unlikely(INDIRECT_ADDR(addr))) {
 397                 iomap_ops[ADDR_TO_REGION(addr)]->write64(datum, addr);
 398         } else {
 399                 *((u64 *)addr) = cpu_to_le64(datum);
 400         }
 401 }
 402
 403 void iowrite64be(u64 datum, void __iomem *addr)
 404 {
 405         if (unlikely(INDIRECT_ADDR(addr))) {
 406                 iomap_ops[ADDR_TO_REGION(addr)]->write64be(datum, addr);
 407         } else {
 408                 *((u64 *)addr) = datum;
 409         }
 410 }
 411
 412 /* Repeating interfaces */
 413
 414 void ioread8_rep(void __iomem *addr, void *dst, unsigned long count)
 415 {
 416         if (unlikely(INDIRECT_ADDR(addr))) {
 417                 iomap_ops[ADDR_TO_REGION(addr)]->read8r(addr, dst, count);
 418         } else {
 419                 while (count--) {
 420                         *(u8 *)dst = *(u8 *)addr;
 421                         dst++;
 422                 }
 423         }
 424 }
 425
 426 void ioread16_rep(void __iomem *addr, void *dst, unsigned long count)
 427 {
 428         if (unlikely(INDIRECT_ADDR(addr))) {
 429                 iomap_ops[ADDR_TO_REGION(addr)]->read16r(addr, dst, count);
 430         } else {
 431                 while (count--) {
 432                         *(u16 *)dst = *(u16 *)addr;
 433                         dst += 2;
 434                 }
 435         }
 436 }
 437
 438 void ioread32_rep(void __iomem *addr, void *dst, unsigned long count)
 439 {
 440         if (unlikely(INDIRECT_ADDR(addr))) {
 441                 iomap_ops[ADDR_TO_REGION(addr)]->read32r(addr, dst, count);
 442         } else {
 443                 while (count--) {
 444                         *(u32 *)dst = *(u32 *)addr;
 445                         dst += 4;
 446                 }
 447         }
 448 }
 449
 450 void iowrite8_rep(void __iomem *addr, const void *src, unsigned long count)
 451 {
 452         if (unlikely(INDIRECT_ADDR(addr))) {
 453                 iomap_ops[ADDR_TO_REGION(addr)]->write8r(addr, src, count);
 454         } else {
 455                 while (count--) {
 456                         *(u8 *)addr = *(u8 *)src;
 457                         src++;
 458                 }
 459         }
 460 }
 461
 462 void iowrite16_rep(void __iomem *addr, const void *src, unsigned long count)
 463 {
 464         if (unlikely(INDIRECT_ADDR(addr))) {
 465                 iomap_ops[ADDR_TO_REGION(addr)]->write16r(addr, src, count);
 466         } else {
 467                 while (count--) {
 468                         *(u16 *)addr = *(u16 *)src;
 469                         src += 2;
 470                 }
 471         }
 472 }
 473
 474 void iowrite32_rep(void __iomem *addr, const void *src, unsigned long count)
 475 {
 476         if (unlikely(INDIRECT_ADDR(addr))) {
 477                 iomap_ops[ADDR_TO_REGION(addr)]->write32r(addr, src, count);
 478         } else {
 479                 while (count--) {
 480                         *(u32 *)addr = *(u32 *)src;
 481                         src += 4;
 482                 }
 483         }
 484 }
 485
 486 /* Mapping interfaces */
 487
 488 void __iomem *ioport_map(unsigned long port, unsigned int nr)
 489 {
 490         return (void __iomem *)(IOPORT_MAP_BASE | port);
 491 }
 492
 493 void ioport_unmap(void __iomem *addr)
 494 {
 495         if (!INDIRECT_ADDR(addr)) {
 496                 iounmap(addr);
 497         }
 498 }
 499
 500 void pci_iounmap(struct pci_dev *dev, void __iomem * addr)
 501 {
 502         if (!INDIRECT_ADDR(addr)) {
 503                 iounmap(addr);
 504         }
 505 }
 506
 507 EXPORT_SYMBOL(ioread8);
 508 EXPORT_SYMBOL(ioread16);
 509 EXPORT_SYMBOL(ioread16be);
 510 EXPORT_SYMBOL(ioread32);
 511 EXPORT_SYMBOL(ioread32be);
 512 EXPORT_SYMBOL(ioread64);
 513 EXPORT_SYMBOL(ioread64be);
 514 EXPORT_SYMBOL(iowrite8);
 515 EXPORT_SYMBOL(iowrite16);
 516 EXPORT_SYMBOL(iowrite16be);
 517 EXPORT_SYMBOL(iowrite32);
 518 EXPORT_SYMBOL(iowrite32be);
 519 EXPORT_SYMBOL(iowrite64);
 520 EXPORT_SYMBOL(iowrite64be);
 521 EXPORT_SYMBOL(ioread8_rep);
 522 EXPORT_SYMBOL(ioread16_rep);
 523 EXPORT_SYMBOL(ioread32_rep);
 524 EXPORT_SYMBOL(iowrite8_rep);
 525 EXPORT_SYMBOL(iowrite16_rep);
 526 EXPORT_SYMBOL(iowrite32_rep);
 527 EXPORT_SYMBOL(ioport_map);
 528 EXPORT_SYMBOL(ioport_unmap);
 529 EXPORT_SYMBOL(pci_iounmap);