1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * arch/parisc/lib/io.c 4 * 5 * Copyright (c) Matthew Wilcox 2001 for Hewlett-Packard 6 * Copyright (c) Randolph Chung 2001 <tausq@debian.org> 7 * 8 * IO accessing functions which shouldn't be inlined because they're too big 9 */ 10 11 #include <linux/kernel.h> 12 #include <linux/module.h> 13 #include <asm/io.h> 14 15 /* Copies a block of memory to a device in an efficient manner. 16 * Assumes the device can cope with 32-bit transfers. If it can't, 17 * don't use this function. 18 */ 19 void memcpy_toio(volatile void __iomem *dst, const void *src, int count) 20 { 21 if (((unsigned long)dst & 3) != ((unsigned long)src & 3)) 22 goto bytecopy; 23 while ((unsigned long)dst & 3) { 24 writeb(*(char *)src, dst++); 25 src++; 26 count--; 27 } 28 while (count > 3) { 29 __raw_writel(*(u32 *)src, dst); 30 src += 4; 31 dst += 4; 32 count -= 4; 33 } 34 bytecopy: 35 while (count--) { 36 writeb(*(char *)src, dst++); 37 src++; 38 } 39 } 40 41 /* 42 ** Copies a block of memory from a device in an efficient manner. 43 ** Assumes the device can cope with 32-bit transfers. If it can't, 44 ** don't use this function. 45 ** 46 ** CR16 counts on C3000 reading 256 bytes from Symbios 896 RAM: 47 ** 27341/64 = 427 cyc per int 48 ** 61311/128 = 478 cyc per short 49 ** 122637/256 = 479 cyc per byte 50 ** Ergo bus latencies dominant (not transfer size). 51 ** Minimize total number of transfers at cost of CPU cycles. 52 ** TODO: only look at src alignment and adjust the stores to dest. 53 */ 54 void memcpy_fromio(void *dst, const volatile void __iomem *src, int count) 55 { 56 /* first compare alignment of src/dst */ 57 if ( (((unsigned long)dst ^ (unsigned long)src) & 1) || (count < 2) ) 58 goto bytecopy; 59 60 if ( (((unsigned long)dst ^ (unsigned long)src) & 2) || (count < 4) ) 61 goto shortcopy; 62 63 /* Then check for misaligned start address */ 64 if ((unsigned long)src & 1) { 65 *(u8 *)dst = readb(src); 66 src++; 67 dst++; 68 count--; 69 if (count < 2) goto bytecopy; 70 } 71 72 if ((unsigned long)src & 2) { 73 *(u16 *)dst = __raw_readw(src); 74 src += 2; 75 dst += 2; 76 count -= 2; 77 } 78 79 while (count > 3) { 80 *(u32 *)dst = __raw_readl(src); 81 dst += 4; 82 src += 4; 83 count -= 4; 84 } 85 86 shortcopy: 87 while (count > 1) { 88 *(u16 *)dst = __raw_readw(src); 89 src += 2; 90 dst += 2; 91 count -= 2; 92 } 93 94 bytecopy: 95 while (count--) { 96 *(char *)dst = readb(src); 97 src++; 98 dst++; 99 } 100 } 101 102 /* Sets a block of memory on a device to a given value. 103 * Assumes the device can cope with 32-bit transfers. If it can't, 104 * don't use this function. 105 */ 106 void memset_io(volatile void __iomem *addr, unsigned char val, int count) 107 { 108 u32 val32 = (val << 24) | (val << 16) | (val << 8) | val; 109 while ((unsigned long)addr & 3) { 110 writeb(val, addr++); 111 count--; 112 } 113 while (count > 3) { 114 __raw_writel(val32, addr); 115 addr += 4; 116 count -= 4; 117 } 118 while (count--) { 119 writeb(val, addr++); 120 } 121 } 122 123 /* 124 * Read COUNT 8-bit bytes from port PORT into memory starting at 125 * SRC. 126 */ 127 void insb (unsigned long port, void *dst, unsigned long count) 128 { 129 unsigned char *p; 130 131 p = (unsigned char *)dst; 132 133 while (((unsigned long)p) & 0x3) { 134 if (!count) 135 return; 136 count--; 137 *p = inb(port); 138 p++; 139 } 140 141 while (count >= 4) { 142 unsigned int w; 143 count -= 4; 144 w = inb(port) << 24; 145 w |= inb(port) << 16; 146 w |= inb(port) << 8; 147 w |= inb(port); 148 *(unsigned int *) p = w; 149 p += 4; 150 } 151 152 while (count) { 153 --count; 154 *p = inb(port); 155 p++; 156 } 157 } 158 159 160 /* 161 * Read COUNT 16-bit words from port PORT into memory starting at 162 * SRC. SRC must be at least short aligned. This is used by the 163 * IDE driver to read disk sectors. Performance is important, but 164 * the interfaces seems to be slow: just using the inlined version 165 * of the inw() breaks things. 166 */ 167 void insw (unsigned long port, void *dst, unsigned long count) 168 { 169 unsigned int l = 0, l2; 170 unsigned char *p; 171 172 p = (unsigned char *)dst; 173 174 if (!count) 175 return; 176 177 switch (((unsigned long)p) & 0x3) 178 { 179 case 0x00: /* Buffer 32-bit aligned */ 180 while (count>=2) { 181 182 count -= 2; 183 l = cpu_to_le16(inw(port)) << 16; 184 l |= cpu_to_le16(inw(port)); 185 *(unsigned int *)p = l; 186 p += 4; 187 } 188 if (count) { 189 *(unsigned short *)p = cpu_to_le16(inw(port)); 190 } 191 break; 192 193 case 0x02: /* Buffer 16-bit aligned */ 194 *(unsigned short *)p = cpu_to_le16(inw(port)); 195 p += 2; 196 count--; 197 while (count>=2) { 198 199 count -= 2; 200 l = cpu_to_le16(inw(port)) << 16; 201 l |= cpu_to_le16(inw(port)); 202 *(unsigned int *)p = l; 203 p += 4; 204 } 205 if (count) { 206 *(unsigned short *)p = cpu_to_le16(inw(port)); 207 } 208 break; 209 210 case 0x01: /* Buffer 8-bit aligned */ 211 case 0x03: 212 /* I don't bother with 32bit transfers 213 * in this case, 16bit will have to do -- DE */ 214 --count; 215 216 l = cpu_to_le16(inw(port)); 217 *p = l >> 8; 218 p++; 219 while (count--) 220 { 221 l2 = cpu_to_le16(inw(port)); 222 *(unsigned short *)p = (l & 0xff) << 8 | (l2 >> 8); 223 p += 2; 224 l = l2; 225 } 226 *p = l & 0xff; 227 break; 228 } 229 } 230 231 232 233 /* 234 * Read COUNT 32-bit words from port PORT into memory starting at 235 * SRC. Now works with any alignment in SRC. Performance is important, 236 * but the interfaces seems to be slow: just using the inlined version 237 * of the inl() breaks things. 238 */ 239 void insl (unsigned long port, void *dst, unsigned long count) 240 { 241 unsigned int l = 0, l2; 242 unsigned char *p; 243 244 p = (unsigned char *)dst; 245 246 if (!count) 247 return; 248 249 switch (((unsigned long) dst) & 0x3) 250 { 251 case 0x00: /* Buffer 32-bit aligned */ 252 while (count--) 253 { 254 *(unsigned int *)p = cpu_to_le32(inl(port)); 255 p += 4; 256 } 257 break; 258 259 case 0x02: /* Buffer 16-bit aligned */ 260 --count; 261 262 l = cpu_to_le32(inl(port)); 263 *(unsigned short *)p = l >> 16; 264 p += 2; 265 266 while (count--) 267 { 268 l2 = cpu_to_le32(inl(port)); 269 *(unsigned int *)p = (l & 0xffff) << 16 | (l2 >> 16); 270 p += 4; 271 l = l2; 272 } 273 *(unsigned short *)p = l & 0xffff; 274 break; 275 case 0x01: /* Buffer 8-bit aligned */ 276 --count; 277 278 l = cpu_to_le32(inl(port)); 279 *(unsigned char *)p = l >> 24; 280 p++; 281 *(unsigned short *)p = (l >> 8) & 0xffff; 282 p += 2; 283 while (count--) 284 { 285 l2 = cpu_to_le32(inl(port)); 286 *(unsigned int *)p = (l & 0xff) << 24 | (l2 >> 8); 287 p += 4; 288 l = l2; 289 } 290 *p = l & 0xff; 291 break; 292 case 0x03: /* Buffer 8-bit aligned */ 293 --count; 294 295 l = cpu_to_le32(inl(port)); 296 *p = l >> 24; 297 p++; 298 while (count--) 299 { 300 l2 = cpu_to_le32(inl(port)); 301 *(unsigned int *)p = (l & 0xffffff) << 8 | l2 >> 24; 302 p += 4; 303 l = l2; 304 } 305 *(unsigned short *)p = (l >> 8) & 0xffff; 306 p += 2; 307 *p = l & 0xff; 308 break; 309 } 310 } 311 312 313 /* 314 * Like insb but in the opposite direction. 315 * Don't worry as much about doing aligned memory transfers: 316 * doing byte reads the "slow" way isn't nearly as slow as 317 * doing byte writes the slow way (no r-m-w cycle). 318 */ 319 void outsb(unsigned long port, const void * src, unsigned long count) 320 { 321 const unsigned char *p; 322 323 p = (const unsigned char *)src; 324 while (count) { 325 count--; 326 outb(*p, port); 327 p++; 328 } 329 } 330 331 /* 332 * Like insw but in the opposite direction. This is used by the IDE 333 * driver to write disk sectors. Performance is important, but the 334 * interfaces seems to be slow: just using the inlined version of the 335 * outw() breaks things. 336 */ 337 void outsw (unsigned long port, const void *src, unsigned long count) 338 { 339 unsigned int l = 0, l2; 340 const unsigned char *p; 341 342 p = (const unsigned char *)src; 343 344 if (!count) 345 return; 346 347 switch (((unsigned long)p) & 0x3) 348 { 349 case 0x00: /* Buffer 32-bit aligned */ 350 while (count>=2) { 351 count -= 2; 352 l = *(unsigned int *)p; 353 p += 4; 354 outw(le16_to_cpu(l >> 16), port); 355 outw(le16_to_cpu(l & 0xffff), port); 356 } 357 if (count) { 358 outw(le16_to_cpu(*(unsigned short*)p), port); 359 } 360 break; 361 362 case 0x02: /* Buffer 16-bit aligned */ 363 364 outw(le16_to_cpu(*(unsigned short*)p), port); 365 p += 2; 366 count--; 367 368 while (count>=2) { 369 count -= 2; 370 l = *(unsigned int *)p; 371 p += 4; 372 outw(le16_to_cpu(l >> 16), port); 373 outw(le16_to_cpu(l & 0xffff), port); 374 } 375 if (count) { 376 outw(le16_to_cpu(*(unsigned short *)p), port); 377 } 378 break; 379 380 case 0x01: /* Buffer 8-bit aligned */ 381 /* I don't bother with 32bit transfers 382 * in this case, 16bit will have to do -- DE */ 383 384 l = *p << 8; 385 p++; 386 count--; 387 while (count) 388 { 389 count--; 390 l2 = *(unsigned short *)p; 391 p += 2; 392 outw(le16_to_cpu(l | l2 >> 8), port); 393 l = l2 << 8; 394 } 395 l2 = *(unsigned char *)p; 396 outw (le16_to_cpu(l | l2>>8), port); 397 break; 398 399 } 400 } 401 402 403 /* 404 * Like insl but in the opposite direction. This is used by the IDE 405 * driver to write disk sectors. Works with any alignment in SRC. 406 * Performance is important, but the interfaces seems to be slow: 407 * just using the inlined version of the outl() breaks things. 408 */ 409 void outsl (unsigned long port, const void *src, unsigned long count) 410 { 411 unsigned int l = 0, l2; 412 const unsigned char *p; 413 414 p = (const unsigned char *)src; 415 416 if (!count) 417 return; 418 419 switch (((unsigned long)p) & 0x3) 420 { 421 case 0x00: /* Buffer 32-bit aligned */ 422 while (count--) 423 { 424 outl(le32_to_cpu(*(unsigned int *)p), port); 425 p += 4; 426 } 427 break; 428 429 case 0x02: /* Buffer 16-bit aligned */ 430 --count; 431 432 l = *(unsigned short *)p; 433 p += 2; 434 435 while (count--) 436 { 437 l2 = *(unsigned int *)p; 438 p += 4; 439 outl (le32_to_cpu(l << 16 | l2 >> 16), port); 440 l = l2; 441 } 442 l2 = *(unsigned short *)p; 443 outl (le32_to_cpu(l << 16 | l2), port); 444 break; 445 case 0x01: /* Buffer 8-bit aligned */ 446 --count; 447 448 l = *p << 24; 449 p++; 450 l |= *(unsigned short *)p << 8; 451 p += 2; 452 453 while (count--) 454 { 455 l2 = *(unsigned int *)p; 456 p += 4; 457 outl (le32_to_cpu(l | l2 >> 24), port); 458 l = l2 << 8; 459 } 460 l2 = *p; 461 outl (le32_to_cpu(l | l2), port); 462 break; 463 case 0x03: /* Buffer 8-bit aligned */ 464 --count; 465 466 l = *p << 24; 467 p++; 468 469 while (count--) 470 { 471 l2 = *(unsigned int *)p; 472 p += 4; 473 outl (le32_to_cpu(l | l2 >> 8), port); 474 l = l2 << 24; 475 } 476 l2 = *(unsigned short *)p << 16; 477 p += 2; 478 l2 |= *p; 479 outl (le32_to_cpu(l | l2), port); 480 break; 481 } 482 } 483 484 EXPORT_SYMBOL(insb); 485 EXPORT_SYMBOL(insw); 486 EXPORT_SYMBOL(insl); 487 EXPORT_SYMBOL(outsb); 488 EXPORT_SYMBOL(outsw); 489 EXPORT_SYMBOL(outsl); 490