arch/sh/kernel/io_generic.c

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