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