447d78f666f90ef2f34430185a1d10ae8ef9ddb4
[~shefty/rdma-dev.git] / 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()    __raw_readb(0xba000000)
23 #else
24 #define dummy_read()
25 #endif
26
27 unsigned long generic_io_base = 0;
28
29 u8 generic_inb(unsigned long port)
30 {
31         return __raw_readb(__ioport_map(port, 1));
32 }
33
34 u16 generic_inw(unsigned long port)
35 {
36         return __raw_readw(__ioport_map(port, 2));
37 }
38
39 u32 generic_inl(unsigned long port)
40 {
41         return __raw_readl(__ioport_map(port, 4));
42 }
43
44 u8 generic_inb_p(unsigned long port)
45 {
46         unsigned long v = generic_inb(port);
47
48         ctrl_delay();
49         return v;
50 }
51
52 u16 generic_inw_p(unsigned long port)
53 {
54         unsigned long v = generic_inw(port);
55
56         ctrl_delay();
57         return v;
58 }
59
60 u32 generic_inl_p(unsigned long port)
61 {
62         unsigned long v = generic_inl(port);
63
64         ctrl_delay();
65         return v;
66 }
67
68 /*
69  * insb/w/l all read a series of bytes/words/longs from a fixed port
70  * address. However as the port address doesn't change we only need to
71  * convert the port address to real address once.
72  */
73
74 void generic_insb(unsigned long port, void *dst, unsigned long count)
75 {
76         __raw_readsb(__ioport_map(port, 1), dst, count);
77         dummy_read();
78 }
79
80 void generic_insw(unsigned long port, void *dst, unsigned long count)
81 {
82         __raw_readsw(__ioport_map(port, 2), dst, count);
83         dummy_read();
84 }
85
86 void generic_insl(unsigned long port, void *dst, unsigned long count)
87 {
88         __raw_readsl(__ioport_map(port, 4), dst, count);
89         dummy_read();
90 }
91
92 void generic_outb(u8 b, unsigned long port)
93 {
94         __raw_writeb(b, __ioport_map(port, 1));
95 }
96
97 void generic_outw(u16 b, unsigned long port)
98 {
99         __raw_writew(b, __ioport_map(port, 2));
100 }
101
102 void generic_outl(u32 b, unsigned long port)
103 {
104         __raw_writel(b, __ioport_map(port, 4));
105 }
106
107 void generic_outb_p(u8 b, unsigned long port)
108 {
109         generic_outb(b, port);
110         ctrl_delay();
111 }
112
113 void generic_outw_p(u16 b, unsigned long port)
114 {
115         generic_outw(b, port);
116         ctrl_delay();
117 }
118
119 void generic_outl_p(u32 b, unsigned long port)
120 {
121         generic_outl(b, port);
122         ctrl_delay();
123 }
124
125 /*
126  * outsb/w/l all write a series of bytes/words/longs to a fixed port
127  * address. However as the port address doesn't change we only need to
128  * convert the port address to real address once.
129  */
130 void generic_outsb(unsigned long port, const void *src, unsigned long count)
131 {
132         __raw_writesb(__ioport_map(port, 1), src, count);
133         dummy_read();
134 }
135
136 void generic_outsw(unsigned long port, const void *src, unsigned long count)
137 {
138         __raw_writesw(__ioport_map(port, 2), src, count);
139         dummy_read();
140 }
141
142 void generic_outsl(unsigned long port, const void *src, unsigned long count)
143 {
144         __raw_writesl(__ioport_map(port, 4), src, count);
145         dummy_read();
146 }
147
148 void __iomem *generic_ioport_map(unsigned long addr, unsigned int size)
149 {
150 #ifdef P1SEG
151         if (PXSEG(addr) >= P1SEG)
152                 return (void __iomem *)addr;
153 #endif
154
155         return (void __iomem *)(addr + generic_io_base);
156 }
157
158 void generic_ioport_unmap(void __iomem *addr)
159 {
160 }
161
162 #ifndef CONFIG_GENERIC_IOMAP
163 void __iomem *ioport_map(unsigned long port, unsigned int nr)
164 {
165         void __iomem *ret;
166
167         ret = __ioport_map_trapped(port, nr);
168         if (ret)
169                 return ret;
170
171         return __ioport_map(port, nr);
172 }
173 EXPORT_SYMBOL(ioport_map);
174
175 void ioport_unmap(void __iomem *addr)
176 {
177         sh_mv.mv_ioport_unmap(addr);
178 }
179 EXPORT_SYMBOL(ioport_unmap);
180 #endif /* CONFIG_GENERIC_IOMAP */