io.c 4.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * I/O string operations
  4. * Copyright (C) 1995-1996 Gary Thomas ([email protected])
  5. * Copyright (C) 2006 IBM Corporation
  6. *
  7. * Largely rewritten by Cort Dougan ([email protected])
  8. * and Paul Mackerras.
  9. *
  10. * Adapted for iSeries by Mike Corrigan ([email protected])
  11. * PPC64 updates by Dave Engebretsen ([email protected])
  12. *
  13. * Rewritten in C by Stephen Rothwell.
  14. */
  15. #include <linux/kernel.h>
  16. #include <linux/types.h>
  17. #include <linux/compiler.h>
  18. #include <linux/export.h>
  19. #include <asm/io.h>
  20. #include <asm/firmware.h>
  21. #include <asm/bug.h>
  22. /* See definition in io.h */
  23. bool isa_io_special;
  24. void _insb(const volatile u8 __iomem *port, void *buf, long count)
  25. {
  26. u8 *tbuf = buf;
  27. u8 tmp;
  28. if (unlikely(count <= 0))
  29. return;
  30. asm volatile("sync");
  31. do {
  32. tmp = *port;
  33. eieio();
  34. *tbuf++ = tmp;
  35. } while (--count != 0);
  36. asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
  37. }
  38. EXPORT_SYMBOL(_insb);
  39. void _outsb(volatile u8 __iomem *port, const void *buf, long count)
  40. {
  41. const u8 *tbuf = buf;
  42. if (unlikely(count <= 0))
  43. return;
  44. asm volatile("sync");
  45. do {
  46. *port = *tbuf++;
  47. } while (--count != 0);
  48. asm volatile("sync");
  49. }
  50. EXPORT_SYMBOL(_outsb);
  51. void _insw_ns(const volatile u16 __iomem *port, void *buf, long count)
  52. {
  53. u16 *tbuf = buf;
  54. u16 tmp;
  55. if (unlikely(count <= 0))
  56. return;
  57. asm volatile("sync");
  58. do {
  59. tmp = *port;
  60. eieio();
  61. *tbuf++ = tmp;
  62. } while (--count != 0);
  63. asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
  64. }
  65. EXPORT_SYMBOL(_insw_ns);
  66. void _outsw_ns(volatile u16 __iomem *port, const void *buf, long count)
  67. {
  68. const u16 *tbuf = buf;
  69. if (unlikely(count <= 0))
  70. return;
  71. asm volatile("sync");
  72. do {
  73. *port = *tbuf++;
  74. } while (--count != 0);
  75. asm volatile("sync");
  76. }
  77. EXPORT_SYMBOL(_outsw_ns);
  78. void _insl_ns(const volatile u32 __iomem *port, void *buf, long count)
  79. {
  80. u32 *tbuf = buf;
  81. u32 tmp;
  82. if (unlikely(count <= 0))
  83. return;
  84. asm volatile("sync");
  85. do {
  86. tmp = *port;
  87. eieio();
  88. *tbuf++ = tmp;
  89. } while (--count != 0);
  90. asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
  91. }
  92. EXPORT_SYMBOL(_insl_ns);
  93. void _outsl_ns(volatile u32 __iomem *port, const void *buf, long count)
  94. {
  95. const u32 *tbuf = buf;
  96. if (unlikely(count <= 0))
  97. return;
  98. asm volatile("sync");
  99. do {
  100. *port = *tbuf++;
  101. } while (--count != 0);
  102. asm volatile("sync");
  103. }
  104. EXPORT_SYMBOL(_outsl_ns);
  105. #define IO_CHECK_ALIGN(v,a) ((((unsigned long)(v)) & ((a) - 1)) == 0)
  106. notrace void
  107. _memset_io(volatile void __iomem *addr, int c, unsigned long n)
  108. {
  109. void *p = (void __force *)addr;
  110. u32 lc = c;
  111. lc |= lc << 8;
  112. lc |= lc << 16;
  113. __asm__ __volatile__ ("sync" : : : "memory");
  114. while(n && !IO_CHECK_ALIGN(p, 4)) {
  115. *((volatile u8 *)p) = c;
  116. p++;
  117. n--;
  118. }
  119. while(n >= 4) {
  120. *((volatile u32 *)p) = lc;
  121. p += 4;
  122. n -= 4;
  123. }
  124. while(n) {
  125. *((volatile u8 *)p) = c;
  126. p++;
  127. n--;
  128. }
  129. __asm__ __volatile__ ("sync" : : : "memory");
  130. }
  131. EXPORT_SYMBOL(_memset_io);
  132. void _memcpy_fromio(void *dest, const volatile void __iomem *src,
  133. unsigned long n)
  134. {
  135. void *vsrc = (void __force *) src;
  136. __asm__ __volatile__ ("sync" : : : "memory");
  137. while(n && (!IO_CHECK_ALIGN(vsrc, 4) || !IO_CHECK_ALIGN(dest, 4))) {
  138. *((u8 *)dest) = *((volatile u8 *)vsrc);
  139. eieio();
  140. vsrc++;
  141. dest++;
  142. n--;
  143. }
  144. while(n >= 4) {
  145. *((u32 *)dest) = *((volatile u32 *)vsrc);
  146. eieio();
  147. vsrc += 4;
  148. dest += 4;
  149. n -= 4;
  150. }
  151. while(n) {
  152. *((u8 *)dest) = *((volatile u8 *)vsrc);
  153. eieio();
  154. vsrc++;
  155. dest++;
  156. n--;
  157. }
  158. __asm__ __volatile__ ("sync" : : : "memory");
  159. }
  160. EXPORT_SYMBOL(_memcpy_fromio);
  161. void _memcpy_toio(volatile void __iomem *dest, const void *src, unsigned long n)
  162. {
  163. void *vdest = (void __force *) dest;
  164. __asm__ __volatile__ ("sync" : : : "memory");
  165. while(n && (!IO_CHECK_ALIGN(vdest, 4) || !IO_CHECK_ALIGN(src, 4))) {
  166. *((volatile u8 *)vdest) = *((u8 *)src);
  167. src++;
  168. vdest++;
  169. n--;
  170. }
  171. while(n >= 4) {
  172. *((volatile u32 *)vdest) = *((volatile u32 *)src);
  173. src += 4;
  174. vdest += 4;
  175. n-=4;
  176. }
  177. while(n) {
  178. *((volatile u8 *)vdest) = *((u8 *)src);
  179. src++;
  180. vdest++;
  181. n--;
  182. }
  183. __asm__ __volatile__ ("sync" : : : "memory");
  184. }
  185. EXPORT_SYMBOL(_memcpy_toio);