1 /* 2 * I/O string operations 3 * Copyright (C) 1995-1996 Gary Thomas (gdt@linuxppc.org) 4 * Copyright (C) 2006 IBM Corporation 5 * 6 * Largely rewritten by Cort Dougan (cort@cs.nmt.edu) 7 * and Paul Mackerras. 8 * 9 * Adapted for iSeries by Mike Corrigan (mikejc@us.ibm.com) 10 * PPC64 updates by Dave Engebretsen (engebret@us.ibm.com) 11 * 12 * Rewritten in C by Stephen Rothwell. 13 * 14 * This program is free software; you can redistribute it and/or 15 * modify it under the terms of the GNU General Public License 16 * as published by the Free Software Foundation; either version 17 * 2 of the License, or (at your option) any later version. 18 */ 19 #include <linux/kernel.h> 20 #include <linux/types.h> 21 #include <linux/compiler.h> 22 #include <linux/module.h> 23 24 #include <asm/io.h> 25 #include <asm/firmware.h> 26 #include <asm/bug.h> 27 28 void _insb(const volatile u8 __iomem *port, void *buf, long count) 29 { 30 u8 *tbuf = buf; 31 u8 tmp; 32 33 if (unlikely(count <= 0)) 34 return; 35 asm volatile("sync"); 36 do { 37 tmp = *port; 38 eieio(); 39 *tbuf++ = tmp; 40 } while (--count != 0); 41 asm volatile("twi 0,%0,0; isync" : : "r" (tmp)); 42 } 43 EXPORT_SYMBOL(_insb); 44 45 void _outsb(volatile u8 __iomem *port, const void *buf, long count) 46 { 47 const u8 *tbuf = buf; 48 49 if (unlikely(count <= 0)) 50 return; 51 asm volatile("sync"); 52 do { 53 *port = *tbuf++; 54 } while (--count != 0); 55 asm volatile("sync"); 56 } 57 EXPORT_SYMBOL(_outsb); 58 59 void _insw_ns(const volatile u16 __iomem *port, void *buf, long count) 60 { 61 u16 *tbuf = buf; 62 u16 tmp; 63 64 if (unlikely(count <= 0)) 65 return; 66 asm volatile("sync"); 67 do { 68 tmp = *port; 69 eieio(); 70 *tbuf++ = tmp; 71 } while (--count != 0); 72 asm volatile("twi 0,%0,0; isync" : : "r" (tmp)); 73 } 74 EXPORT_SYMBOL(_insw_ns); 75 76 void _outsw_ns(volatile u16 __iomem *port, const void *buf, long count) 77 { 78 const u16 *tbuf = buf; 79 80 if (unlikely(count <= 0)) 81 return; 82 asm volatile("sync"); 83 do { 84 *port = *tbuf++; 85 } while (--count != 0); 86 asm volatile("sync"); 87 } 88 EXPORT_SYMBOL(_outsw_ns); 89 90 void _insl_ns(const volatile u32 __iomem *port, void *buf, long count) 91 { 92 u32 *tbuf = buf; 93 u32 tmp; 94 95 if (unlikely(count <= 0)) 96 return; 97 asm volatile("sync"); 98 do { 99 tmp = *port; 100 eieio(); 101 *tbuf++ = tmp; 102 } while (--count != 0); 103 asm volatile("twi 0,%0,0; isync" : : "r" (tmp)); 104 } 105 EXPORT_SYMBOL(_insl_ns); 106 107 void _outsl_ns(volatile u32 __iomem *port, const void *buf, long count) 108 { 109 const u32 *tbuf = buf; 110 111 if (unlikely(count <= 0)) 112 return; 113 asm volatile("sync"); 114 do { 115 *port = *tbuf++; 116 } while (--count != 0); 117 asm volatile("sync"); 118 } 119 EXPORT_SYMBOL(_outsl_ns); 120 121 #define IO_CHECK_ALIGN(v,a) ((((unsigned long)(v)) & ((a) - 1)) == 0) 122 123 notrace void 124 _memset_io(volatile void __iomem *addr, int c, unsigned long n) 125 { 126 void *p = (void __force *)addr; 127 u32 lc = c; 128 lc |= lc << 8; 129 lc |= lc << 16; 130 131 __asm__ __volatile__ ("sync" : : : "memory"); 132 while(n && !IO_CHECK_ALIGN(p, 4)) { 133 *((volatile u8 *)p) = c; 134 p++; 135 n--; 136 } 137 while(n >= 4) { 138 *((volatile u32 *)p) = lc; 139 p += 4; 140 n -= 4; 141 } 142 while(n) { 143 *((volatile u8 *)p) = c; 144 p++; 145 n--; 146 } 147 __asm__ __volatile__ ("sync" : : : "memory"); 148 } 149 EXPORT_SYMBOL(_memset_io); 150 151 void _memcpy_fromio(void *dest, const volatile void __iomem *src, 152 unsigned long n) 153 { 154 void *vsrc = (void __force *) src; 155 156 __asm__ __volatile__ ("sync" : : : "memory"); 157 while(n && (!IO_CHECK_ALIGN(vsrc, 4) || !IO_CHECK_ALIGN(dest, 4))) { 158 *((u8 *)dest) = *((volatile u8 *)vsrc); 159 eieio(); 160 vsrc++; 161 dest++; 162 n--; 163 } 164 while(n >= 4) { 165 *((u32 *)dest) = *((volatile u32 *)vsrc); 166 eieio(); 167 vsrc += 4; 168 dest += 4; 169 n -= 4; 170 } 171 while(n) { 172 *((u8 *)dest) = *((volatile u8 *)vsrc); 173 eieio(); 174 vsrc++; 175 dest++; 176 n--; 177 } 178 __asm__ __volatile__ ("sync" : : : "memory"); 179 } 180 EXPORT_SYMBOL(_memcpy_fromio); 181 182 void _memcpy_toio(volatile void __iomem *dest, const void *src, unsigned long n) 183 { 184 void *vdest = (void __force *) dest; 185 186 __asm__ __volatile__ ("sync" : : : "memory"); 187 while(n && (!IO_CHECK_ALIGN(vdest, 4) || !IO_CHECK_ALIGN(src, 4))) { 188 *((volatile u8 *)vdest) = *((u8 *)src); 189 src++; 190 vdest++; 191 n--; 192 } 193 while(n >= 4) { 194 *((volatile u32 *)vdest) = *((volatile u32 *)src); 195 src += 4; 196 vdest += 4; 197 n-=4; 198 } 199 while(n) { 200 *((volatile u8 *)vdest) = *((u8 *)src); 201 src++; 202 vdest++; 203 n--; 204 } 205 __asm__ __volatile__ ("sync" : : : "memory"); 206 } 207 EXPORT_SYMBOL(_memcpy_toio); 208