arch/sh/kernel/io_generic.c

   1 /* $Id: io_generic.c,v 1.2 2003/05/04 19:29:53 lethal Exp $
   2  *
   3  * linux/arch/sh/kernel/io_generic.c
   4  *
   5  * Copyright (C) 2000  Niibe Yutaka
   6  * Copyright (C) 2005  Paul Mundt
   7  *
   8  * Generic I/O routine. These can be used where a machine specific version
   9  * is not required.
  10  *
  11  * This file is subject to the terms and conditions of the GNU General Public
  12  * License.  See the file "COPYING" in the main directory of this archive
  13  * for more details.
  14  */
  15 #include <linux/module.h>
  16 #include <asm/io.h>
  17 #include <asm/machvec.h>
  18
  19 #ifdef CONFIG_CPU_SH3
  20 /* SH3 has a PCMCIA bug that needs a dummy read from area 6 for a
  21  * workaround. */
  22 /* I'm not sure SH7709 has this kind of bug */
  23 #define dummy_read()    ctrl_inb(0xba000000)
  24 #else
  25 #define dummy_read()
  26 #endif
  27
  28 unsigned long generic_io_base;
  29
  30 static inline void delay(void)
  31 {
  32         ctrl_inw(0xa0000000);
  33 }
  34
  35 u8 generic_inb(unsigned long port)
  36 {
  37         return ctrl_inb((unsigned long __force)ioport_map(port, 1));
  38 }
  39
  40 u16 generic_inw(unsigned long port)
  41 {
  42         return ctrl_inw((unsigned long __force)ioport_map(port, 2));
  43 }
  44
  45 u32 generic_inl(unsigned long port)
  46 {
  47         return ctrl_inl((unsigned long __force)ioport_map(port, 4));
  48 }
  49
  50 u8 generic_inb_p(unsigned long port)
  51 {
  52         unsigned long v = generic_inb(port);
  53
  54         delay();
  55         return v;
  56 }
  57
  58 u16 generic_inw_p(unsigned long port)
  59 {
  60         unsigned long v = generic_inw(port);
  61
  62         delay();
  63         return v;
  64 }
  65
  66 u32 generic_inl_p(unsigned long port)
  67 {
  68         unsigned long v = generic_inl(port);
  69
  70         delay();
  71         return v;
  72 }
  73
  74 /*
  75  * insb/w/l all read a series of bytes/words/longs from a fixed port
  76  * address. However as the port address doesn't change we only need to
  77  * convert the port address to real address once.
  78  */
  79
  80 void generic_insb(unsigned long port, void *dst, unsigned long count)
  81 {
  82         volatile u8 *port_addr;
  83         u8 *buf = dst;
  84
  85         port_addr = (volatile u8 *)ioport_map(port, 1);
  86         while (count--)
  87                 *buf++ = *port_addr;
  88 }
  89
  90 void generic_insw(unsigned long port, void *dst, unsigned long count)
  91 {
  92         volatile u16 *port_addr;
  93         u16 *buf = dst;
  94
  95         port_addr = (volatile u16 *)ioport_map(port, 2);
  96         while (count--)
  97                 *buf++ = *port_addr;
  98
  99         dummy_read();
 100 }
 101
 102 void generic_insl(unsigned long port, void *dst, unsigned long count)
 103 {
 104         volatile u32 *port_addr;
 105         u32 *buf = dst;
 106
 107         port_addr = (volatile u32 *)ioport_map(port, 4);
 108         while (count--)
 109                 *buf++ = *port_addr;
 110
 111         dummy_read();
 112 }
 113
 114 void generic_outb(u8 b, unsigned long port)
 115 {
 116         ctrl_outb(b, (unsigned long __force)ioport_map(port, 1));
 117 }
 118
 119 void generic_outw(u16 b, unsigned long port)
 120 {
 121         ctrl_outw(b, (unsigned long __force)ioport_map(port, 2));
 122 }
 123
 124 void generic_outl(u32 b, unsigned long port)
 125 {
 126         ctrl_outl(b, (unsigned long __force)ioport_map(port, 4));
 127 }
 128
 129 void generic_outb_p(u8 b, unsigned long port)
 130 {
 131         generic_outb(b, port);
 132         delay();
 133 }
 134
 135 void generic_outw_p(u16 b, unsigned long port)
 136 {
 137         generic_outw(b, port);
 138         delay();
 139 }
 140
 141 void generic_outl_p(u32 b, unsigned long port)
 142 {
 143         generic_outl(b, port);
 144         delay();
 145 }
 146
 147 /*
 148  * outsb/w/l all write a series of bytes/words/longs to a fixed port
 149  * address. However as the port address doesn't change we only need to
 150  * convert the port address to real address once.
 151  */
 152 void generic_outsb(unsigned long port, const void *src, unsigned long count)
 153 {
 154         volatile u8 *port_addr;
 155         const u8 *buf = src;
 156
 157         port_addr = (volatile u8 __force *)ioport_map(port, 1);
 158
 159         while (count--)
 160                 *port_addr = *buf++;
 161 }
 162
 163 void generic_outsw(unsigned long port, const void *src, unsigned long count)
 164 {
 165         volatile u16 *port_addr;
 166         const u16 *buf = src;
 167
 168         port_addr = (volatile u16 __force *)ioport_map(port, 2);
 169
 170         while (count--)
 171                 *port_addr = *buf++;
 172
 173         dummy_read();
 174 }
 175
 176 void generic_outsl(unsigned long port, const void *src, unsigned long count)
 177 {
 178         volatile u32 *port_addr;
 179         const u32 *buf = src;
 180
 181         port_addr = (volatile u32 __force *)ioport_map(port, 4);
 182         while (count--)
 183                 *port_addr = *buf++;
 184
 185         dummy_read();
 186 }
 187
 188 u8 generic_readb(void __iomem *addr)
 189 {
 190         return ctrl_inb((unsigned long __force)addr);
 191 }
 192
 193 u16 generic_readw(void __iomem *addr)
 194 {
 195         return ctrl_inw((unsigned long __force)addr);
 196 }
 197
 198 u32 generic_readl(void __iomem *addr)
 199 {
 200         return ctrl_inl((unsigned long __force)addr);
 201 }
 202
 203 void generic_writeb(u8 b, void __iomem *addr)
 204 {
 205         ctrl_outb(b, (unsigned long __force)addr);
 206 }
 207
 208 void generic_writew(u16 b, void __iomem *addr)
 209 {
 210         ctrl_outw(b, (unsigned long __force)addr);
 211 }
 212
 213 void generic_writel(u32 b, void __iomem *addr)
 214 {
 215         ctrl_outl(b, (unsigned long __force)addr);
 216 }
 217
 218 void __iomem *generic_ioport_map(unsigned long addr, unsigned int size)
 219 {
 220         return (void __iomem *)(addr + generic_io_base);
 221 }
 222
 223 void generic_ioport_unmap(void __iomem *addr)
 224 {
 225 }