arch/parisc/lib/io.c

   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 <[email protected]>
   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);