1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Alpha IO and memory functions. 4 */ 5 6 #include <linux/kernel.h> 7 #include <linux/types.h> 8 #include <linux/string.h> 9 #include <linux/module.h> 10 #include <asm/io.h> 11 12 /* Out-of-line versions of the i/o routines that redirect into the 13 platform-specific version. Note that "platform-specific" may mean 14 "generic", which bumps through the machine vector. */ 15 16 unsigned int 17 ioread8(const void __iomem *addr) 18 { 19 unsigned int ret; 20 mb(); 21 ret = IO_CONCAT(__IO_PREFIX,ioread8)(addr); 22 mb(); 23 return ret; 24 } 25 26 unsigned int ioread16(const void __iomem *addr) 27 { 28 unsigned int ret; 29 mb(); 30 ret = IO_CONCAT(__IO_PREFIX,ioread16)(addr); 31 mb(); 32 return ret; 33 } 34 35 unsigned int ioread32(const void __iomem *addr) 36 { 37 unsigned int ret; 38 mb(); 39 ret = IO_CONCAT(__IO_PREFIX,ioread32)(addr); 40 mb(); 41 return ret; 42 } 43 44 u64 ioread64(const void __iomem *addr) 45 { 46 unsigned int ret; 47 mb(); 48 ret = IO_CONCAT(__IO_PREFIX,ioread64)(addr); 49 mb(); 50 return ret; 51 } 52 53 void iowrite8(u8 b, void __iomem *addr) 54 { 55 mb(); 56 IO_CONCAT(__IO_PREFIX,iowrite8)(b, addr); 57 } 58 59 void iowrite16(u16 b, void __iomem *addr) 60 { 61 mb(); 62 IO_CONCAT(__IO_PREFIX,iowrite16)(b, addr); 63 } 64 65 void iowrite32(u32 b, void __iomem *addr) 66 { 67 mb(); 68 IO_CONCAT(__IO_PREFIX,iowrite32)(b, addr); 69 } 70 71 void iowrite64(u64 b, void __iomem *addr) 72 { 73 mb(); 74 IO_CONCAT(__IO_PREFIX,iowrite64)(b, addr); 75 } 76 77 EXPORT_SYMBOL(ioread8); 78 EXPORT_SYMBOL(ioread16); 79 EXPORT_SYMBOL(ioread32); 80 EXPORT_SYMBOL(ioread64); 81 EXPORT_SYMBOL(iowrite8); 82 EXPORT_SYMBOL(iowrite16); 83 EXPORT_SYMBOL(iowrite32); 84 EXPORT_SYMBOL(iowrite64); 85 86 u8 inb(unsigned long port) 87 { 88 return ioread8(ioport_map(port, 1)); 89 } 90 91 u16 inw(unsigned long port) 92 { 93 return ioread16(ioport_map(port, 2)); 94 } 95 96 u32 inl(unsigned long port) 97 { 98 return ioread32(ioport_map(port, 4)); 99 } 100 101 void outb(u8 b, unsigned long port) 102 { 103 iowrite8(b, ioport_map(port, 1)); 104 } 105 106 void outw(u16 b, unsigned long port) 107 { 108 iowrite16(b, ioport_map(port, 2)); 109 } 110 111 void outl(u32 b, unsigned long port) 112 { 113 iowrite32(b, ioport_map(port, 4)); 114 } 115 116 EXPORT_SYMBOL(inb); 117 EXPORT_SYMBOL(inw); 118 EXPORT_SYMBOL(inl); 119 EXPORT_SYMBOL(outb); 120 EXPORT_SYMBOL(outw); 121 EXPORT_SYMBOL(outl); 122 123 u8 __raw_readb(const volatile void __iomem *addr) 124 { 125 return IO_CONCAT(__IO_PREFIX,readb)(addr); 126 } 127 128 u16 __raw_readw(const volatile void __iomem *addr) 129 { 130 return IO_CONCAT(__IO_PREFIX,readw)(addr); 131 } 132 133 u32 __raw_readl(const volatile void __iomem *addr) 134 { 135 return IO_CONCAT(__IO_PREFIX,readl)(addr); 136 } 137 138 u64 __raw_readq(const volatile void __iomem *addr) 139 { 140 return IO_CONCAT(__IO_PREFIX,readq)(addr); 141 } 142 143 void __raw_writeb(u8 b, volatile void __iomem *addr) 144 { 145 IO_CONCAT(__IO_PREFIX,writeb)(b, addr); 146 } 147 148 void __raw_writew(u16 b, volatile void __iomem *addr) 149 { 150 IO_CONCAT(__IO_PREFIX,writew)(b, addr); 151 } 152 153 void __raw_writel(u32 b, volatile void __iomem *addr) 154 { 155 IO_CONCAT(__IO_PREFIX,writel)(b, addr); 156 } 157 158 void __raw_writeq(u64 b, volatile void __iomem *addr) 159 { 160 IO_CONCAT(__IO_PREFIX,writeq)(b, addr); 161 } 162 163 EXPORT_SYMBOL(__raw_readb); 164 EXPORT_SYMBOL(__raw_readw); 165 EXPORT_SYMBOL(__raw_readl); 166 EXPORT_SYMBOL(__raw_readq); 167 EXPORT_SYMBOL(__raw_writeb); 168 EXPORT_SYMBOL(__raw_writew); 169 EXPORT_SYMBOL(__raw_writel); 170 EXPORT_SYMBOL(__raw_writeq); 171 172 u8 readb(const volatile void __iomem *addr) 173 { 174 u8 ret; 175 mb(); 176 ret = __raw_readb(addr); 177 mb(); 178 return ret; 179 } 180 181 u16 readw(const volatile void __iomem *addr) 182 { 183 u16 ret; 184 mb(); 185 ret = __raw_readw(addr); 186 mb(); 187 return ret; 188 } 189 190 u32 readl(const volatile void __iomem *addr) 191 { 192 u32 ret; 193 mb(); 194 ret = __raw_readl(addr); 195 mb(); 196 return ret; 197 } 198 199 u64 readq(const volatile void __iomem *addr) 200 { 201 u64 ret; 202 mb(); 203 ret = __raw_readq(addr); 204 mb(); 205 return ret; 206 } 207 208 void writeb(u8 b, volatile void __iomem *addr) 209 { 210 mb(); 211 __raw_writeb(b, addr); 212 } 213 214 void writew(u16 b, volatile void __iomem *addr) 215 { 216 mb(); 217 __raw_writew(b, addr); 218 } 219 220 void writel(u32 b, volatile void __iomem *addr) 221 { 222 mb(); 223 __raw_writel(b, addr); 224 } 225 226 void writeq(u64 b, volatile void __iomem *addr) 227 { 228 mb(); 229 __raw_writeq(b, addr); 230 } 231 232 EXPORT_SYMBOL(readb); 233 EXPORT_SYMBOL(readw); 234 EXPORT_SYMBOL(readl); 235 EXPORT_SYMBOL(readq); 236 EXPORT_SYMBOL(writeb); 237 EXPORT_SYMBOL(writew); 238 EXPORT_SYMBOL(writel); 239 EXPORT_SYMBOL(writeq); 240 241 /* 242 * The _relaxed functions must be ordered w.r.t. each other, but they don't 243 * have to be ordered w.r.t. other memory accesses. 244 */ 245 u8 readb_relaxed(const volatile void __iomem *addr) 246 { 247 mb(); 248 return __raw_readb(addr); 249 } 250 251 u16 readw_relaxed(const volatile void __iomem *addr) 252 { 253 mb(); 254 return __raw_readw(addr); 255 } 256 257 u32 readl_relaxed(const volatile void __iomem *addr) 258 { 259 mb(); 260 return __raw_readl(addr); 261 } 262 263 u64 readq_relaxed(const volatile void __iomem *addr) 264 { 265 mb(); 266 return __raw_readq(addr); 267 } 268 269 EXPORT_SYMBOL(readb_relaxed); 270 EXPORT_SYMBOL(readw_relaxed); 271 EXPORT_SYMBOL(readl_relaxed); 272 EXPORT_SYMBOL(readq_relaxed); 273 274 /* 275 * Read COUNT 8-bit bytes from port PORT into memory starting at SRC. 276 */ 277 void ioread8_rep(const void __iomem *port, void *dst, unsigned long count) 278 { 279 while ((unsigned long)dst & 0x3) { 280 if (!count) 281 return; 282 count--; 283 *(unsigned char *)dst = ioread8(port); 284 dst += 1; 285 } 286 287 while (count >= 4) { 288 unsigned int w; 289 count -= 4; 290 w = ioread8(port); 291 w |= ioread8(port) << 8; 292 w |= ioread8(port) << 16; 293 w |= ioread8(port) << 24; 294 *(unsigned int *)dst = w; 295 dst += 4; 296 } 297 298 while (count) { 299 --count; 300 *(unsigned char *)dst = ioread8(port); 301 dst += 1; 302 } 303 } 304 305 void insb(unsigned long port, void *dst, unsigned long count) 306 { 307 ioread8_rep(ioport_map(port, 1), dst, count); 308 } 309 310 EXPORT_SYMBOL(ioread8_rep); 311 EXPORT_SYMBOL(insb); 312 313 /* 314 * Read COUNT 16-bit words from port PORT into memory starting at 315 * SRC. SRC must be at least short aligned. This is used by the 316 * IDE driver to read disk sectors. Performance is important, but 317 * the interfaces seems to be slow: just using the inlined version 318 * of the inw() breaks things. 319 */ 320 void ioread16_rep(const void __iomem *port, void *dst, unsigned long count) 321 { 322 if (unlikely((unsigned long)dst & 0x3)) { 323 if (!count) 324 return; 325 BUG_ON((unsigned long)dst & 0x1); 326 count--; 327 *(unsigned short *)dst = ioread16(port); 328 dst += 2; 329 } 330 331 while (count >= 2) { 332 unsigned int w; 333 count -= 2; 334 w = ioread16(port); 335 w |= ioread16(port) << 16; 336 *(unsigned int *)dst = w; 337 dst += 4; 338 } 339 340 if (count) { 341 *(unsigned short*)dst = ioread16(port); 342 } 343 } 344 345 void insw(unsigned long port, void *dst, unsigned long count) 346 { 347 ioread16_rep(ioport_map(port, 2), dst, count); 348 } 349 350 EXPORT_SYMBOL(ioread16_rep); 351 EXPORT_SYMBOL(insw); 352 353 354 /* 355 * Read COUNT 32-bit words from port PORT into memory starting at 356 * SRC. Now works with any alignment in SRC. Performance is important, 357 * but the interfaces seems to be slow: just using the inlined version 358 * of the inl() breaks things. 359 */ 360 void ioread32_rep(const void __iomem *port, void *dst, unsigned long count) 361 { 362 if (unlikely((unsigned long)dst & 0x3)) { 363 while (count--) { 364 struct S { int x __attribute__((packed)); }; 365 ((struct S *)dst)->x = ioread32(port); 366 dst += 4; 367 } 368 } else { 369 /* Buffer 32-bit aligned. */ 370 while (count--) { 371 *(unsigned int *)dst = ioread32(port); 372 dst += 4; 373 } 374 } 375 } 376 377 void insl(unsigned long port, void *dst, unsigned long count) 378 { 379 ioread32_rep(ioport_map(port, 4), dst, count); 380 } 381 382 EXPORT_SYMBOL(ioread32_rep); 383 EXPORT_SYMBOL(insl); 384 385 386 /* 387 * Like insb but in the opposite direction. 388 * Don't worry as much about doing aligned memory transfers: 389 * doing byte reads the "slow" way isn't nearly as slow as 390 * doing byte writes the slow way (no r-m-w cycle). 391 */ 392 void iowrite8_rep(void __iomem *port, const void *xsrc, unsigned long count) 393 { 394 const unsigned char *src = xsrc; 395 while (count--) 396 iowrite8(*src++, port); 397 } 398 399 void outsb(unsigned long port, const void *src, unsigned long count) 400 { 401 iowrite8_rep(ioport_map(port, 1), src, count); 402 } 403 404 EXPORT_SYMBOL(iowrite8_rep); 405 EXPORT_SYMBOL(outsb); 406 407 408 /* 409 * Like insw but in the opposite direction. This is used by the IDE 410 * driver to write disk sectors. Performance is important, but the 411 * interfaces seems to be slow: just using the inlined version of the 412 * outw() breaks things. 413 */ 414 void iowrite16_rep(void __iomem *port, const void *src, unsigned long count) 415 { 416 if (unlikely((unsigned long)src & 0x3)) { 417 if (!count) 418 return; 419 BUG_ON((unsigned long)src & 0x1); 420 iowrite16(*(unsigned short *)src, port); 421 src += 2; 422 --count; 423 } 424 425 while (count >= 2) { 426 unsigned int w; 427 count -= 2; 428 w = *(unsigned int *)src; 429 src += 4; 430 iowrite16(w >> 0, port); 431 iowrite16(w >> 16, port); 432 } 433 434 if (count) { 435 iowrite16(*(unsigned short *)src, port); 436 } 437 } 438 439 void outsw(unsigned long port, const void *src, unsigned long count) 440 { 441 iowrite16_rep(ioport_map(port, 2), src, count); 442 } 443 444 EXPORT_SYMBOL(iowrite16_rep); 445 EXPORT_SYMBOL(outsw); 446 447 448 /* 449 * Like insl but in the opposite direction. This is used by the IDE 450 * driver to write disk sectors. Works with any alignment in SRC. 451 * Performance is important, but the interfaces seems to be slow: 452 * just using the inlined version of the outl() breaks things. 453 */ 454 void iowrite32_rep(void __iomem *port, const void *src, unsigned long count) 455 { 456 if (unlikely((unsigned long)src & 0x3)) { 457 while (count--) { 458 struct S { int x __attribute__((packed)); }; 459 iowrite32(((struct S *)src)->x, port); 460 src += 4; 461 } 462 } else { 463 /* Buffer 32-bit aligned. */ 464 while (count--) { 465 iowrite32(*(unsigned int *)src, port); 466 src += 4; 467 } 468 } 469 } 470 471 void outsl(unsigned long port, const void *src, unsigned long count) 472 { 473 iowrite32_rep(ioport_map(port, 4), src, count); 474 } 475 476 EXPORT_SYMBOL(iowrite32_rep); 477 EXPORT_SYMBOL(outsl); 478 479 480 /* 481 * Copy data from IO memory space to "real" memory space. 482 * This needs to be optimized. 483 */ 484 void memcpy_fromio(void *to, const volatile void __iomem *from, long count) 485 { 486 /* Optimize co-aligned transfers. Everything else gets handled 487 a byte at a time. */ 488 489 if (count >= 8 && ((u64)to & 7) == ((u64)from & 7)) { 490 count -= 8; 491 do { 492 *(u64 *)to = __raw_readq(from); 493 count -= 8; 494 to += 8; 495 from += 8; 496 } while (count >= 0); 497 count += 8; 498 } 499 500 if (count >= 4 && ((u64)to & 3) == ((u64)from & 3)) { 501 count -= 4; 502 do { 503 *(u32 *)to = __raw_readl(from); 504 count -= 4; 505 to += 4; 506 from += 4; 507 } while (count >= 0); 508 count += 4; 509 } 510 511 if (count >= 2 && ((u64)to & 1) == ((u64)from & 1)) { 512 count -= 2; 513 do { 514 *(u16 *)to = __raw_readw(from); 515 count -= 2; 516 to += 2; 517 from += 2; 518 } while (count >= 0); 519 count += 2; 520 } 521 522 while (count > 0) { 523 *(u8 *) to = __raw_readb(from); 524 count--; 525 to++; 526 from++; 527 } 528 mb(); 529 } 530 531 EXPORT_SYMBOL(memcpy_fromio); 532 533 534 /* 535 * Copy data from "real" memory space to IO memory space. 536 * This needs to be optimized. 537 */ 538 void memcpy_toio(volatile void __iomem *to, const void *from, long count) 539 { 540 /* Optimize co-aligned transfers. Everything else gets handled 541 a byte at a time. */ 542 /* FIXME -- align FROM. */ 543 544 if (count >= 8 && ((u64)to & 7) == ((u64)from & 7)) { 545 count -= 8; 546 do { 547 __raw_writeq(*(const u64 *)from, to); 548 count -= 8; 549 to += 8; 550 from += 8; 551 } while (count >= 0); 552 count += 8; 553 } 554 555 if (count >= 4 && ((u64)to & 3) == ((u64)from & 3)) { 556 count -= 4; 557 do { 558 __raw_writel(*(const u32 *)from, to); 559 count -= 4; 560 to += 4; 561 from += 4; 562 } while (count >= 0); 563 count += 4; 564 } 565 566 if (count >= 2 && ((u64)to & 1) == ((u64)from & 1)) { 567 count -= 2; 568 do { 569 __raw_writew(*(const u16 *)from, to); 570 count -= 2; 571 to += 2; 572 from += 2; 573 } while (count >= 0); 574 count += 2; 575 } 576 577 while (count > 0) { 578 __raw_writeb(*(const u8 *) from, to); 579 count--; 580 to++; 581 from++; 582 } 583 mb(); 584 } 585 586 EXPORT_SYMBOL(memcpy_toio); 587 588 589 /* 590 * "memset" on IO memory space. 591 */ 592 void _memset_c_io(volatile void __iomem *to, unsigned long c, long count) 593 { 594 /* Handle any initial odd byte */ 595 if (count > 0 && ((u64)to & 1)) { 596 __raw_writeb(c, to); 597 to++; 598 count--; 599 } 600 601 /* Handle any initial odd halfword */ 602 if (count >= 2 && ((u64)to & 2)) { 603 __raw_writew(c, to); 604 to += 2; 605 count -= 2; 606 } 607 608 /* Handle any initial odd word */ 609 if (count >= 4 && ((u64)to & 4)) { 610 __raw_writel(c, to); 611 to += 4; 612 count -= 4; 613 } 614 615 /* Handle all full-sized quadwords: we're aligned 616 (or have a small count) */ 617 count -= 8; 618 if (count >= 0) { 619 do { 620 __raw_writeq(c, to); 621 to += 8; 622 count -= 8; 623 } while (count >= 0); 624 } 625 count += 8; 626 627 /* The tail is word-aligned if we still have count >= 4 */ 628 if (count >= 4) { 629 __raw_writel(c, to); 630 to += 4; 631 count -= 4; 632 } 633 634 /* The tail is half-word aligned if we have count >= 2 */ 635 if (count >= 2) { 636 __raw_writew(c, to); 637 to += 2; 638 count -= 2; 639 } 640 641 /* And finally, one last byte.. */ 642 if (count) { 643 __raw_writeb(c, to); 644 } 645 mb(); 646 } 647 648 EXPORT_SYMBOL(_memset_c_io); 649 650 /* A version of memcpy used by the vga console routines to move data around 651 arbitrarily between screen and main memory. */ 652 653 void 654 scr_memcpyw(u16 *d, const u16 *s, unsigned int count) 655 { 656 const u16 __iomem *ios = (const u16 __iomem *) s; 657 u16 __iomem *iod = (u16 __iomem *) d; 658 int s_isio = __is_ioaddr(s); 659 int d_isio = __is_ioaddr(d); 660 661 if (s_isio) { 662 if (d_isio) { 663 /* FIXME: Should handle unaligned ops and 664 operation widening. */ 665 666 count /= 2; 667 while (count--) { 668 u16 tmp = __raw_readw(ios++); 669 __raw_writew(tmp, iod++); 670 } 671 } 672 else 673 memcpy_fromio(d, ios, count); 674 } else { 675 if (d_isio) 676 memcpy_toio(iod, s, count); 677 else 678 memcpy(d, s, count); 679 } 680 } 681 682 EXPORT_SYMBOL(scr_memcpyw); 683 684 void __iomem *ioport_map(unsigned long port, unsigned int size) 685 { 686 return IO_CONCAT(__IO_PREFIX,ioportmap) (port); 687 } 688 689 void ioport_unmap(void __iomem *addr) 690 { 691 } 692 693 EXPORT_SYMBOL(ioport_map); 694 EXPORT_SYMBOL(ioport_unmap); 695