arch/powerpc/kernel/io.c

   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/export.h>
  23
  24 #include <asm/io.h>
  25 #include <asm/firmware.h>
  26 #include <asm/bug.h>
  27
  28 /* See definition in io.h */
  29 bool isa_io_special;
  30
  31 void _insb(const volatile u8 __iomem *port, void *buf, long count)
  32 {
  33         u8 *tbuf = buf;
  34         u8 tmp;
  35
  36         if (unlikely(count <= 0))
  37                 return;
  38         asm volatile("sync");
  39         do {
  40                 tmp = *port;
  41                 eieio();
  42                 *tbuf++ = tmp;
  43         } while (--count != 0);
  44         asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
  45 }
  46 EXPORT_SYMBOL(_insb);
  47
  48 void _outsb(volatile u8 __iomem *port, const void *buf, long count)
  49 {
  50         const u8 *tbuf = buf;
  51
  52         if (unlikely(count <= 0))
  53                 return;
  54         asm volatile("sync");
  55         do {
  56                 *port = *tbuf++;
  57         } while (--count != 0);
  58         asm volatile("sync");
  59 }
  60 EXPORT_SYMBOL(_outsb);
  61
  62 void _insw_ns(const volatile u16 __iomem *port, void *buf, long count)
  63 {
  64         u16 *tbuf = buf;
  65         u16 tmp;
  66
  67         if (unlikely(count <= 0))
  68                 return;
  69         asm volatile("sync");
  70         do {
  71                 tmp = *port;
  72                 eieio();
  73                 *tbuf++ = tmp;
  74         } while (--count != 0);
  75         asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
  76 }
  77 EXPORT_SYMBOL(_insw_ns);
  78
  79 void _outsw_ns(volatile u16 __iomem *port, const void *buf, long count)
  80 {
  81         const u16 *tbuf = buf;
  82
  83         if (unlikely(count <= 0))
  84                 return;
  85         asm volatile("sync");
  86         do {
  87                 *port = *tbuf++;
  88         } while (--count != 0);
  89         asm volatile("sync");
  90 }
  91 EXPORT_SYMBOL(_outsw_ns);
  92
  93 void _insl_ns(const volatile u32 __iomem *port, void *buf, long count)
  94 {
  95         u32 *tbuf = buf;
  96         u32 tmp;
  97
  98         if (unlikely(count <= 0))
  99                 return;
 100         asm volatile("sync");
 101         do {
 102                 tmp = *port;
 103                 eieio();
 104                 *tbuf++ = tmp;
 105         } while (--count != 0);
 106         asm volatile("twi 0,%0,0; isync" : : "r" (tmp));
 107 }
 108 EXPORT_SYMBOL(_insl_ns);
 109
 110 void _outsl_ns(volatile u32 __iomem *port, const void *buf, long count)
 111 {
 112         const u32 *tbuf = buf;
 113
 114         if (unlikely(count <= 0))
 115                 return;
 116         asm volatile("sync");
 117         do {
 118                 *port = *tbuf++;
 119         } while (--count != 0);
 120         asm volatile("sync");
 121 }
 122 EXPORT_SYMBOL(_outsl_ns);
 123
 124 #define IO_CHECK_ALIGN(v,a) ((((unsigned long)(v)) & ((a) - 1)) == 0)
 125
 126 notrace void
 127 _memset_io(volatile void __iomem *addr, int c, unsigned long n)
 128 {
 129         void *p = (void __force *)addr;
 130         u32 lc = c;
 131         lc |= lc << 8;
 132         lc |= lc << 16;
 133
 134         __asm__ __volatile__ ("sync" : : : "memory");
 135         while(n && !IO_CHECK_ALIGN(p, 4)) {
 136                 *((volatile u8 *)p) = c;
 137                 p++;
 138                 n--;
 139         }
 140         while(n >= 4) {
 141                 *((volatile u32 *)p) = lc;
 142                 p += 4;
 143                 n -= 4;
 144         }
 145         while(n) {
 146                 *((volatile u8 *)p) = c;
 147                 p++;
 148                 n--;
 149         }
 150         __asm__ __volatile__ ("sync" : : : "memory");
 151 }
 152 EXPORT_SYMBOL(_memset_io);
 153
 154 void _memcpy_fromio(void *dest, const volatile void __iomem *src,
 155                     unsigned long n)
 156 {
 157         void *vsrc = (void __force *) src;
 158
 159         __asm__ __volatile__ ("sync" : : : "memory");
 160         while(n && (!IO_CHECK_ALIGN(vsrc, 4) || !IO_CHECK_ALIGN(dest, 4))) {
 161                 *((u8 *)dest) = *((volatile u8 *)vsrc);
 162                 eieio();
 163                 vsrc++;
 164                 dest++;
 165                 n--;
 166         }
 167         while(n >= 4) {
 168                 *((u32 *)dest) = *((volatile u32 *)vsrc);
 169                 eieio();
 170                 vsrc += 4;
 171                 dest += 4;
 172                 n -= 4;
 173         }
 174         while(n) {
 175                 *((u8 *)dest) = *((volatile u8 *)vsrc);
 176                 eieio();
 177                 vsrc++;
 178                 dest++;
 179                 n--;
 180         }
 181         __asm__ __volatile__ ("sync" : : : "memory");
 182 }
 183 EXPORT_SYMBOL(_memcpy_fromio);
 184
 185 void _memcpy_toio(volatile void __iomem *dest, const void *src, unsigned long n)
 186 {
 187         void *vdest = (void __force *) dest;
 188
 189         __asm__ __volatile__ ("sync" : : : "memory");
 190         while(n && (!IO_CHECK_ALIGN(vdest, 4) || !IO_CHECK_ALIGN(src, 4))) {
 191                 *((volatile u8 *)vdest) = *((u8 *)src);
 192                 src++;
 193                 vdest++;
 194                 n--;
 195         }
 196         while(n >= 4) {
 197                 *((volatile u32 *)vdest) = *((volatile u32 *)src);
 198                 src += 4;
 199                 vdest += 4;
 200                 n-=4;
 201         }
 202         while(n) {
 203                 *((volatile u8 *)vdest) = *((u8 *)src);
 204                 src++;
 205                 vdest++;
 206                 n--;
 207         }
 208         __asm__ __volatile__ ("sync" : : : "memory");
 209 }
 210 EXPORT_SYMBOL(_memcpy_toio);