arch/alpha/include/asm/io.h

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 #ifndef __ALPHA_IO_H
   3 #define __ALPHA_IO_H
   4
   5 #ifdef __KERNEL__
   6
   7 #include <linux/kernel.h>
   8 #include <linux/mm.h>
   9 #include <asm/compiler.h>
  10 #include <asm/machvec.h>
  11 #include <asm/hwrpb.h>
  12
  13 /* The generic header contains only prototypes.  Including it ensures that
  14    the implementation we have here matches that interface.  */
  15 #include <asm-generic/iomap.h>
  16
  17 /*
  18  * Virtual -> physical identity mapping starts at this offset
  19  */
  20 #ifdef USE_48_BIT_KSEG
  21 #define IDENT_ADDR     0xffff800000000000UL
  22 #else
  23 #define IDENT_ADDR     0xfffffc0000000000UL
  24 #endif
  25
  26 /*
  27  * We try to avoid hae updates (thus the cache), but when we
  28  * do need to update the hae, we need to do it atomically, so
  29  * that any interrupts wouldn't get confused with the hae
  30  * register not being up-to-date with respect to the hardware
  31  * value.
  32  */
  33 extern inline void __set_hae(unsigned long new_hae)
  34 {
  35         unsigned long flags = swpipl(IPL_MAX);
  36
  37         barrier();
  38
  39         alpha_mv.hae_cache = new_hae;
  40         *alpha_mv.hae_register = new_hae;
  41         mb();
  42         /* Re-read to make sure it was written.  */
  43         new_hae = *alpha_mv.hae_register;
  44
  45         setipl(flags);
  46         barrier();
  47 }
  48
  49 extern inline void set_hae(unsigned long new_hae)
  50 {
  51         if (new_hae != alpha_mv.hae_cache)
  52                 __set_hae(new_hae);
  53 }
  54
  55 /*
  56  * Change virtual addresses to physical addresses and vv.
  57  */
  58 #ifdef USE_48_BIT_KSEG
  59 static inline unsigned long virt_to_phys(volatile void *address)
  60 {
  61         return (unsigned long)address - IDENT_ADDR;
  62 }
  63
  64 static inline void * phys_to_virt(unsigned long address)
  65 {
  66         return (void *) (address + IDENT_ADDR);
  67 }
  68 #else
  69 static inline unsigned long virt_to_phys(volatile void *address)
  70 {
  71         unsigned long phys = (unsigned long)address;
  72
  73         /* Sign-extend from bit 41.  */
  74         phys <<= (64 - 41);
  75         phys = (long)phys >> (64 - 41);
  76
  77         /* Crop to the physical address width of the processor.  */
  78         phys &= (1ul << hwrpb->pa_bits) - 1;
  79
  80         return phys;
  81 }
  82
  83 static inline void * phys_to_virt(unsigned long address)
  84 {
  85         return (void *)(IDENT_ADDR + (address & ((1ul << 41) - 1)));
  86 }
  87 #endif
  88
  89 #define virt_to_phys            virt_to_phys
  90 #define phys_to_virt            phys_to_virt
  91
  92 /* Maximum PIO space address supported?  */
  93 #define IO_SPACE_LIMIT 0xffff
  94
  95 /*
  96  * Change addresses as seen by the kernel (virtual) to addresses as
  97  * seen by a device (bus), and vice versa.
  98  *
  99  * Note that this only works for a limited range of kernel addresses,
 100  * and very well may not span all memory.  Consider this interface
 101  * deprecated in favour of the DMA-mapping API.
 102  */
 103 extern unsigned long __direct_map_base;
 104 extern unsigned long __direct_map_size;
 105
 106 static inline unsigned long __deprecated isa_virt_to_bus(volatile void *address)
 107 {
 108         unsigned long phys = virt_to_phys(address);
 109         unsigned long bus = phys + __direct_map_base;
 110         return phys <= __direct_map_size ? bus : 0;
 111 }
 112 #define isa_virt_to_bus isa_virt_to_bus
 113
 114 static inline void * __deprecated isa_bus_to_virt(unsigned long address)
 115 {
 116         void *virt;
 117
 118         /* This check is a sanity check but also ensures that bus address 0
 119            maps to virtual address 0 which is useful to detect null pointers
 120            (the NCR driver is much simpler if NULL pointers are preserved).  */
 121         address -= __direct_map_base;
 122         virt = phys_to_virt(address);
 123         return (long)address <= 0 ? NULL : virt;
 124 }
 125 #define isa_bus_to_virt isa_bus_to_virt
 126
 127 /*
 128  * There are different chipsets to interface the Alpha CPUs to the world.
 129  */
 130
 131 #define IO_CONCAT(a,b)  _IO_CONCAT(a,b)
 132 #define _IO_CONCAT(a,b) a ## _ ## b
 133
 134 #ifdef CONFIG_ALPHA_GENERIC
 135
 136 /* In a generic kernel, we always go through the machine vector.  */
 137
 138 #define REMAP1(TYPE, NAME, QUAL)                                        \
 139 static inline TYPE generic_##NAME(QUAL void __iomem *addr)              \
 140 {                                                                       \
 141         return alpha_mv.mv_##NAME(addr);                                \
 142 }
 143
 144 #define REMAP2(TYPE, NAME, QUAL)                                        \
 145 static inline void generic_##NAME(TYPE b, QUAL void __iomem *addr)      \
 146 {                                                                       \
 147         alpha_mv.mv_##NAME(b, addr);                                    \
 148 }
 149
 150 REMAP1(unsigned int, ioread8, const)
 151 REMAP1(unsigned int, ioread16, const)
 152 REMAP1(unsigned int, ioread32, const)
 153 REMAP1(u64, ioread64, const)
 154 REMAP1(u8, readb, const volatile)
 155 REMAP1(u16, readw, const volatile)
 156 REMAP1(u32, readl, const volatile)
 157 REMAP1(u64, readq, const volatile)
 158
 159 REMAP2(u8, iowrite8, /**/)
 160 REMAP2(u16, iowrite16, /**/)
 161 REMAP2(u32, iowrite32, /**/)
 162 REMAP2(u64, iowrite64, /**/)
 163 REMAP2(u8, writeb, volatile)
 164 REMAP2(u16, writew, volatile)
 165 REMAP2(u32, writel, volatile)
 166 REMAP2(u64, writeq, volatile)
 167
 168 #undef REMAP1
 169 #undef REMAP2
 170
 171 extern inline void __iomem *generic_ioportmap(unsigned long a)
 172 {
 173         return alpha_mv.mv_ioportmap(a);
 174 }
 175
 176 static inline void __iomem *generic_ioremap(unsigned long a, unsigned long s)
 177 {
 178         return alpha_mv.mv_ioremap(a, s);
 179 }
 180
 181 static inline void generic_iounmap(volatile void __iomem *a)
 182 {
 183         return alpha_mv.mv_iounmap(a);
 184 }
 185
 186 static inline int generic_is_ioaddr(unsigned long a)
 187 {
 188         return alpha_mv.mv_is_ioaddr(a);
 189 }
 190
 191 static inline int generic_is_mmio(const volatile void __iomem *a)
 192 {
 193         return alpha_mv.mv_is_mmio(a);
 194 }
 195
 196 #define __IO_PREFIX             generic
 197 #define generic_trivial_rw_bw   0
 198 #define generic_trivial_rw_lq   0
 199 #define generic_trivial_io_bw   0
 200 #define generic_trivial_io_lq   0
 201 #define generic_trivial_iounmap 0
 202
 203 #else
 204
 205 #if defined(CONFIG_ALPHA_CIA)
 206 # include <asm/core_cia.h>
 207 #elif defined(CONFIG_ALPHA_IRONGATE)
 208 # include <asm/core_irongate.h>
 209 #elif defined(CONFIG_ALPHA_MARVEL)
 210 # include <asm/core_marvel.h>
 211 #elif defined(CONFIG_ALPHA_MCPCIA)
 212 # include <asm/core_mcpcia.h>
 213 #elif defined(CONFIG_ALPHA_POLARIS)
 214 # include <asm/core_polaris.h>
 215 #elif defined(CONFIG_ALPHA_T2)
 216 # include <asm/core_t2.h>
 217 #elif defined(CONFIG_ALPHA_TSUNAMI)
 218 # include <asm/core_tsunami.h>
 219 #elif defined(CONFIG_ALPHA_TITAN)
 220 # include <asm/core_titan.h>
 221 #elif defined(CONFIG_ALPHA_WILDFIRE)
 222 # include <asm/core_wildfire.h>
 223 #else
 224 #error "What system is this?"
 225 #endif
 226
 227 #endif /* GENERIC */
 228
 229 /*
 230  * We always have external versions of these routines.
 231  */
 232 extern u8               inb(unsigned long port);
 233 extern u16              inw(unsigned long port);
 234 extern u32              inl(unsigned long port);
 235 extern void             outb(u8 b, unsigned long port);
 236 extern void             outw(u16 b, unsigned long port);
 237 extern void             outl(u32 b, unsigned long port);
 238 #define inb inb
 239 #define inw inw
 240 #define inl inl
 241 #define outb outb
 242 #define outw outw
 243 #define outl outl
 244
 245 extern u8               readb(const volatile void __iomem *addr);
 246 extern u16              readw(const volatile void __iomem *addr);
 247 extern u32              readl(const volatile void __iomem *addr);
 248 extern u64              readq(const volatile void __iomem *addr);
 249 extern void             writeb(u8 b, volatile void __iomem *addr);
 250 extern void             writew(u16 b, volatile void __iomem *addr);
 251 extern void             writel(u32 b, volatile void __iomem *addr);
 252 extern void             writeq(u64 b, volatile void __iomem *addr);
 253 #define readb readb
 254 #define readw readw
 255 #define readl readl
 256 #define readq readq
 257 #define writeb writeb
 258 #define writew writew
 259 #define writel writel
 260 #define writeq writeq
 261
 262 extern u8               __raw_readb(const volatile void __iomem *addr);
 263 extern u16              __raw_readw(const volatile void __iomem *addr);
 264 extern u32              __raw_readl(const volatile void __iomem *addr);
 265 extern u64              __raw_readq(const volatile void __iomem *addr);
 266 extern void             __raw_writeb(u8 b, volatile void __iomem *addr);
 267 extern void             __raw_writew(u16 b, volatile void __iomem *addr);
 268 extern void             __raw_writel(u32 b, volatile void __iomem *addr);
 269 extern void             __raw_writeq(u64 b, volatile void __iomem *addr);
 270 #define __raw_readb __raw_readb
 271 #define __raw_readw __raw_readw
 272 #define __raw_readl __raw_readl
 273 #define __raw_readq __raw_readq
 274 #define __raw_writeb __raw_writeb
 275 #define __raw_writew __raw_writew
 276 #define __raw_writel __raw_writel
 277 #define __raw_writeq __raw_writeq
 278
 279 /*
 280  * Mapping from port numbers to __iomem space is pretty easy.
 281  */
 282
 283 /* These two have to be extern inline because of the extern prototype from
 284    <asm-generic/iomap.h>.  It is not legal to mix "extern" and "static" for
 285    the same declaration.  */
 286 extern inline void __iomem *ioport_map(unsigned long port, unsigned int size)
 287 {
 288         return IO_CONCAT(__IO_PREFIX,ioportmap) (port);
 289 }
 290
 291 extern inline void ioport_unmap(void __iomem *addr)
 292 {
 293 }
 294
 295 #define ioport_map ioport_map
 296 #define ioport_unmap ioport_unmap
 297
 298 static inline void __iomem *ioremap(unsigned long port, unsigned long size)
 299 {
 300         return IO_CONCAT(__IO_PREFIX,ioremap) (port, size);
 301 }
 302
 303 #define ioremap_wc ioremap
 304
 305 static inline void iounmap(volatile void __iomem *addr)
 306 {
 307         IO_CONCAT(__IO_PREFIX,iounmap)(addr);
 308 }
 309
 310 static inline int __is_ioaddr(unsigned long addr)
 311 {
 312         return IO_CONCAT(__IO_PREFIX,is_ioaddr)(addr);
 313 }
 314 #define __is_ioaddr(a)          __is_ioaddr((unsigned long)(a))
 315
 316 static inline int __is_mmio(const volatile void __iomem *addr)
 317 {
 318         return IO_CONCAT(__IO_PREFIX,is_mmio)(addr);
 319 }
 320
 321
 322 /*
 323  * If the actual I/O bits are sufficiently trivial, then expand inline.
 324  */
 325
 326 #if IO_CONCAT(__IO_PREFIX,trivial_io_bw)
 327 extern inline unsigned int ioread8(const void __iomem *addr)
 328 {
 329         unsigned int ret;
 330         mb();
 331         ret = IO_CONCAT(__IO_PREFIX,ioread8)(addr);
 332         mb();
 333         return ret;
 334 }
 335
 336 extern inline unsigned int ioread16(const void __iomem *addr)
 337 {
 338         unsigned int ret;
 339         mb();
 340         ret = IO_CONCAT(__IO_PREFIX,ioread16)(addr);
 341         mb();
 342         return ret;
 343 }
 344
 345 extern inline void iowrite8(u8 b, void __iomem *addr)
 346 {
 347         mb();
 348         IO_CONCAT(__IO_PREFIX, iowrite8)(b, addr);
 349 }
 350
 351 extern inline void iowrite16(u16 b, void __iomem *addr)
 352 {
 353         mb();
 354         IO_CONCAT(__IO_PREFIX, iowrite16)(b, addr);
 355 }
 356
 357 extern inline u8 inb(unsigned long port)
 358 {
 359         return ioread8(ioport_map(port, 1));
 360 }
 361
 362 extern inline u16 inw(unsigned long port)
 363 {
 364         return ioread16(ioport_map(port, 2));
 365 }
 366
 367 extern inline void outb(u8 b, unsigned long port)
 368 {
 369         iowrite8(b, ioport_map(port, 1));
 370 }
 371
 372 extern inline void outw(u16 b, unsigned long port)
 373 {
 374         iowrite16(b, ioport_map(port, 2));
 375 }
 376 #endif
 377
 378 #define ioread8 ioread8
 379 #define ioread16 ioread16
 380 #define iowrite8 iowrite8
 381 #define iowrite16 iowrite16
 382
 383 #if IO_CONCAT(__IO_PREFIX,trivial_io_lq)
 384 extern inline unsigned int ioread32(const void __iomem *addr)
 385 {
 386         unsigned int ret;
 387         mb();
 388         ret = IO_CONCAT(__IO_PREFIX,ioread32)(addr);
 389         mb();
 390         return ret;
 391 }
 392
 393 extern inline u64 ioread64(const void __iomem *addr)
 394 {
 395         unsigned int ret;
 396         mb();
 397         ret = IO_CONCAT(__IO_PREFIX,ioread64)(addr);
 398         mb();
 399         return ret;
 400 }
 401
 402 extern inline void iowrite32(u32 b, void __iomem *addr)
 403 {
 404         mb();
 405         IO_CONCAT(__IO_PREFIX, iowrite32)(b, addr);
 406 }
 407
 408 extern inline void iowrite64(u64 b, void __iomem *addr)
 409 {
 410         mb();
 411         IO_CONCAT(__IO_PREFIX, iowrite64)(b, addr);
 412 }
 413
 414 extern inline u32 inl(unsigned long port)
 415 {
 416         return ioread32(ioport_map(port, 4));
 417 }
 418
 419 extern inline void outl(u32 b, unsigned long port)
 420 {
 421         iowrite32(b, ioport_map(port, 4));
 422 }
 423 #endif
 424
 425 #define ioread32 ioread32
 426 #define ioread64 ioread64
 427 #define iowrite32 iowrite32
 428 #define iowrite64 iowrite64
 429
 430 #if IO_CONCAT(__IO_PREFIX,trivial_rw_bw) == 1
 431 extern inline u8 __raw_readb(const volatile void __iomem *addr)
 432 {
 433         return IO_CONCAT(__IO_PREFIX,readb)(addr);
 434 }
 435
 436 extern inline u16 __raw_readw(const volatile void __iomem *addr)
 437 {
 438         return IO_CONCAT(__IO_PREFIX,readw)(addr);
 439 }
 440
 441 extern inline void __raw_writeb(u8 b, volatile void __iomem *addr)
 442 {
 443         IO_CONCAT(__IO_PREFIX,writeb)(b, addr);
 444 }
 445
 446 extern inline void __raw_writew(u16 b, volatile void __iomem *addr)
 447 {
 448         IO_CONCAT(__IO_PREFIX,writew)(b, addr);
 449 }
 450
 451 extern inline u8 readb(const volatile void __iomem *addr)
 452 {
 453         u8 ret;
 454         mb();
 455         ret = __raw_readb(addr);
 456         mb();
 457         return ret;
 458 }
 459
 460 extern inline u16 readw(const volatile void __iomem *addr)
 461 {
 462         u16 ret;
 463         mb();
 464         ret = __raw_readw(addr);
 465         mb();
 466         return ret;
 467 }
 468
 469 extern inline void writeb(u8 b, volatile void __iomem *addr)
 470 {
 471         mb();
 472         __raw_writeb(b, addr);
 473 }
 474
 475 extern inline void writew(u16 b, volatile void __iomem *addr)
 476 {
 477         mb();
 478         __raw_writew(b, addr);
 479 }
 480 #endif
 481
 482 #if IO_CONCAT(__IO_PREFIX,trivial_rw_lq) == 1
 483 extern inline u32 __raw_readl(const volatile void __iomem *addr)
 484 {
 485         return IO_CONCAT(__IO_PREFIX,readl)(addr);
 486 }
 487
 488 extern inline u64 __raw_readq(const volatile void __iomem *addr)
 489 {
 490         return IO_CONCAT(__IO_PREFIX,readq)(addr);
 491 }
 492
 493 extern inline void __raw_writel(u32 b, volatile void __iomem *addr)
 494 {
 495         IO_CONCAT(__IO_PREFIX,writel)(b, addr);
 496 }
 497
 498 extern inline void __raw_writeq(u64 b, volatile void __iomem *addr)
 499 {
 500         IO_CONCAT(__IO_PREFIX,writeq)(b, addr);
 501 }
 502
 503 extern inline u32 readl(const volatile void __iomem *addr)
 504 {
 505         u32 ret;
 506         mb();
 507         ret = __raw_readl(addr);
 508         mb();
 509         return ret;
 510 }
 511
 512 extern inline u64 readq(const volatile void __iomem *addr)
 513 {
 514         u64 ret;
 515         mb();
 516         ret = __raw_readq(addr);
 517         mb();
 518         return ret;
 519 }
 520
 521 extern inline void writel(u32 b, volatile void __iomem *addr)
 522 {
 523         mb();
 524         __raw_writel(b, addr);
 525 }
 526
 527 extern inline void writeq(u64 b, volatile void __iomem *addr)
 528 {
 529         mb();
 530         __raw_writeq(b, addr);
 531 }
 532 #endif
 533
 534 #define ioread16be(p) swab16(ioread16(p))
 535 #define ioread32be(p) swab32(ioread32(p))
 536 #define ioread64be(p) swab64(ioread64(p))
 537 #define iowrite16be(v,p) iowrite16(swab16(v), (p))
 538 #define iowrite32be(v,p) iowrite32(swab32(v), (p))
 539 #define iowrite64be(v,p) iowrite64(swab64(v), (p))
 540
 541 #define inb_p           inb
 542 #define inw_p           inw
 543 #define inl_p           inl
 544 #define outb_p          outb
 545 #define outw_p          outw
 546 #define outl_p          outl
 547
 548 extern u8 readb_relaxed(const volatile void __iomem *addr);
 549 extern u16 readw_relaxed(const volatile void __iomem *addr);
 550 extern u32 readl_relaxed(const volatile void __iomem *addr);
 551 extern u64 readq_relaxed(const volatile void __iomem *addr);
 552 #define readb_relaxed readb_relaxed
 553 #define readw_relaxed readw_relaxed
 554 #define readl_relaxed readl_relaxed
 555 #define readq_relaxed readq_relaxed
 556
 557 #if IO_CONCAT(__IO_PREFIX,trivial_io_bw)
 558 extern inline u8 readb_relaxed(const volatile void __iomem *addr)
 559 {
 560         mb();
 561         return __raw_readb(addr);
 562 }
 563
 564 extern inline u16 readw_relaxed(const volatile void __iomem *addr)
 565 {
 566         mb();
 567         return __raw_readw(addr);
 568 }
 569 #endif
 570
 571 #if IO_CONCAT(__IO_PREFIX,trivial_io_lq)
 572 extern inline u32 readl_relaxed(const volatile void __iomem *addr)
 573 {
 574         mb();
 575         return __raw_readl(addr);
 576 }
 577
 578 extern inline u64 readq_relaxed(const volatile void __iomem *addr)
 579 {
 580         mb();
 581         return __raw_readq(addr);
 582 }
 583 #endif
 584
 585 #define writeb_relaxed  writeb
 586 #define writew_relaxed  writew
 587 #define writel_relaxed  writel
 588 #define writeq_relaxed  writeq
 589
 590 /*
 591  * String version of IO memory access ops:
 592  */
 593 extern void memcpy_fromio(void *, const volatile void __iomem *, long);
 594 extern void memcpy_toio(volatile void __iomem *, const void *, long);
 595 extern void _memset_c_io(volatile void __iomem *, unsigned long, long);
 596
 597 static inline void memset_io(volatile void __iomem *addr, u8 c, long len)
 598 {
 599         _memset_c_io(addr, 0x0101010101010101UL * c, len);
 600 }
 601
 602 #define __HAVE_ARCH_MEMSETW_IO
 603 static inline void memsetw_io(volatile void __iomem *addr, u16 c, long len)
 604 {
 605         _memset_c_io(addr, 0x0001000100010001UL * c, len);
 606 }
 607
 608 #define memset_io memset_io
 609 #define memcpy_fromio memcpy_fromio
 610 #define memcpy_toio memcpy_toio
 611
 612 /*
 613  * String versions of in/out ops:
 614  */
 615 extern void insb (unsigned long port, void *dst, unsigned long count);
 616 extern void insw (unsigned long port, void *dst, unsigned long count);
 617 extern void insl (unsigned long port, void *dst, unsigned long count);
 618 extern void outsb (unsigned long port, const void *src, unsigned long count);
 619 extern void outsw (unsigned long port, const void *src, unsigned long count);
 620 extern void outsl (unsigned long port, const void *src, unsigned long count);
 621
 622 #define insb insb
 623 #define insw insw
 624 #define insl insl
 625 #define outsb outsb
 626 #define outsw outsw
 627 #define outsl outsl
 628
 629 #define RTC_PORT(x)     (0x70 + (x))
 630 #define RTC_ALWAYS_BCD  0
 631
 632 /*
 633  * These get provided from <asm-generic/iomap.h> since alpha does not
 634  * select GENERIC_IOMAP.
 635  */
 636 #define ioread64 ioread64
 637 #define iowrite64 iowrite64
 638 #define ioread8_rep ioread8_rep
 639 #define ioread16_rep ioread16_rep
 640 #define ioread32_rep ioread32_rep
 641 #define iowrite8_rep iowrite8_rep
 642 #define iowrite16_rep iowrite16_rep
 643 #define iowrite32_rep iowrite32_rep
 644 #define pci_iounmap pci_iounmap
 645
 646 #include <asm-generic/io.h>
 647
 648 #endif /* __KERNEL__ */
 649
 650 #endif /* __ALPHA_IO_H */