Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | #ifndef __ASM_SH_IO_H |
2 | #define __ASM_SH_IO_H | |
1da177e4 LT |
3 | /* |
4 | * Convention: | |
14866543 | 5 | * read{b,w,l,q}/write{b,w,l,q} are for PCI, |
1da177e4 | 6 | * while in{b,w,l}/out{b,w,l} are for ISA |
14866543 | 7 | * |
1da177e4 LT |
8 | * In addition we have 'pausing' versions: in{b,w,l}_p/out{b,w,l}_p |
9 | * and 'string' versions: ins{b,w,l}/outs{b,w,l} | |
1da177e4 | 10 | * |
14866543 PM |
11 | * While read{b,w,l,q} and write{b,w,l,q} contain memory barriers |
12 | * automatically, there are also __raw versions, which do not. | |
13 | * | |
14 | * Historically, we have also had ctrl_in{b,w,l,q}/ctrl_out{b,w,l,q} for | |
15 | * SuperH specific I/O (raw I/O to on-chip CPU peripherals). In practice | |
16 | * these have the same semantics as the __raw variants, and as such, all | |
17 | * new code should be using the __raw versions. | |
18 | * | |
19 | * All ISA I/O routines are wrapped through the machine vector. If a | |
20 | * board does not provide overrides, a generic set that are copied in | |
21 | * from the default machine vector are used instead. These are largely | |
22 | * for old compat code for I/O offseting to SuperIOs, all of which are | |
23 | * better handled through the machvec ioport mapping routines these days. | |
1da177e4 | 24 | */ |
1da177e4 LT |
25 | #include <asm/cache.h> |
26 | #include <asm/system.h> | |
27 | #include <asm/addrspace.h> | |
28 | #include <asm/machvec.h> | |
b66c1a39 PM |
29 | #include <asm/pgtable.h> |
30 | #include <asm-generic/iomap.h> | |
31 | ||
32 | #ifdef __KERNEL__ | |
1da177e4 LT |
33 | /* |
34 | * Depending on which platform we are running on, we need different | |
35 | * I/O functions. | |
36 | */ | |
b66c1a39 PM |
37 | #define __IO_PREFIX generic |
38 | #include <asm/io_generic.h> | |
e7cc9a73 | 39 | #include <asm/io_trapped.h> |
b66c1a39 | 40 | |
14866543 PM |
41 | #define inb(p) sh_mv.mv_inb((p)) |
42 | #define inw(p) sh_mv.mv_inw((p)) | |
43 | #define inl(p) sh_mv.mv_inl((p)) | |
44 | #define outb(x,p) sh_mv.mv_outb((x),(p)) | |
45 | #define outw(x,p) sh_mv.mv_outw((x),(p)) | |
46 | #define outl(x,p) sh_mv.mv_outl((x),(p)) | |
47 | ||
48 | #define inb_p(p) sh_mv.mv_inb_p((p)) | |
49 | #define inw_p(p) sh_mv.mv_inw_p((p)) | |
50 | #define inl_p(p) sh_mv.mv_inl_p((p)) | |
51 | #define outb_p(x,p) sh_mv.mv_outb_p((x),(p)) | |
52 | #define outw_p(x,p) sh_mv.mv_outw_p((x),(p)) | |
53 | #define outl_p(x,p) sh_mv.mv_outl_p((x),(p)) | |
54 | ||
55 | #define insb(p,b,c) sh_mv.mv_insb((p), (b), (c)) | |
56 | #define insw(p,b,c) sh_mv.mv_insw((p), (b), (c)) | |
57 | #define insl(p,b,c) sh_mv.mv_insl((p), (b), (c)) | |
58 | #define outsb(p,b,c) sh_mv.mv_outsb((p), (b), (c)) | |
59 | #define outsw(p,b,c) sh_mv.mv_outsw((p), (b), (c)) | |
60 | #define outsl(p,b,c) sh_mv.mv_outsl((p), (b), (c)) | |
61 | ||
62 | #define __raw_writeb(v,a) (__chk_io_ptr(a), *(volatile u8 __force *)(a) = (v)) | |
63 | #define __raw_writew(v,a) (__chk_io_ptr(a), *(volatile u16 __force *)(a) = (v)) | |
64 | #define __raw_writel(v,a) (__chk_io_ptr(a), *(volatile u32 __force *)(a) = (v)) | |
65 | #define __raw_writeq(v,a) (__chk_io_ptr(a), *(volatile u64 __force *)(a) = (v)) | |
66 | ||
67 | #define __raw_readb(a) (__chk_io_ptr(a), *(volatile u8 __force *)(a)) | |
68 | #define __raw_readw(a) (__chk_io_ptr(a), *(volatile u16 __force *)(a)) | |
69 | #define __raw_readl(a) (__chk_io_ptr(a), *(volatile u32 __force *)(a)) | |
70 | #define __raw_readq(a) (__chk_io_ptr(a), *(volatile u64 __force *)(a)) | |
71 | ||
72 | #define readb(a) ({ u8 r_ = __raw_readb(a); mb(); r_; }) | |
73 | #define readw(a) ({ u16 r_ = __raw_readw(a); mb(); r_; }) | |
74 | #define readl(a) ({ u32 r_ = __raw_readl(a); mb(); r_; }) | |
75 | #define readq(a) ({ u64 r_ = __raw_readq(a); mb(); r_; }) | |
76 | ||
77 | #define writeb(v,a) ({ __raw_writeb((v),(a)); mb(); }) | |
78 | #define writew(v,a) ({ __raw_writew((v),(a)); mb(); }) | |
79 | #define writel(v,a) ({ __raw_writel((v),(a)); mb(); }) | |
80 | #define writeq(v,a) ({ __raw_writeq((v),(a)); mb(); }) | |
1da177e4 | 81 | |
14866543 PM |
82 | /* SuperH on-chip I/O functions */ |
83 | #define ctrl_inb __raw_readb | |
84 | #define ctrl_inw __raw_readw | |
85 | #define ctrl_inl __raw_readl | |
86 | #define ctrl_inq __raw_readq | |
05ae9158 | 87 | |
14866543 PM |
88 | #define ctrl_outb __raw_writeb |
89 | #define ctrl_outw __raw_writew | |
90 | #define ctrl_outl __raw_writel | |
91 | #define ctrl_outq __raw_writeq | |
64c9627c | 92 | |
14866543 PM |
93 | static inline void ctrl_delay(void) |
94 | { | |
95 | #ifdef P2SEG | |
96 | __raw_readw(P2SEG); | |
97 | #endif | |
98 | } | |
1da177e4 | 99 | |
da6b003a MD |
100 | #define __BUILD_MEMORY_STRING(bwlq, type) \ |
101 | \ | |
64c9627c | 102 | static inline void __raw_writes##bwlq(volatile void __iomem *mem, \ |
da6b003a MD |
103 | const void *addr, unsigned int count) \ |
104 | { \ | |
105 | const volatile type *__addr = addr; \ | |
106 | \ | |
107 | while (count--) { \ | |
108 | __raw_write##bwlq(*__addr, mem); \ | |
109 | __addr++; \ | |
110 | } \ | |
111 | } \ | |
112 | \ | |
64c9627c PM |
113 | static inline void __raw_reads##bwlq(volatile void __iomem *mem, \ |
114 | void *addr, unsigned int count) \ | |
da6b003a MD |
115 | { \ |
116 | volatile type *__addr = addr; \ | |
117 | \ | |
118 | while (count--) { \ | |
119 | *__addr = __raw_read##bwlq(mem); \ | |
120 | __addr++; \ | |
121 | } \ | |
122 | } | |
123 | ||
124 | __BUILD_MEMORY_STRING(b, u8) | |
125 | __BUILD_MEMORY_STRING(w, u16) | |
14866543 | 126 | |
6dbe47a1 | 127 | #ifdef CONFIG_SUPERH32 |
14866543 PM |
128 | void __raw_writesl(void __iomem *addr, const void *data, int longlen); |
129 | void __raw_readsl(const void __iomem *addr, void *data, int longlen); | |
6dbe47a1 PM |
130 | #else |
131 | __BUILD_MEMORY_STRING(l, u32) | |
132 | #endif | |
133 | ||
134 | __BUILD_MEMORY_STRING(q, u64) | |
64c9627c | 135 | |
14866543 PM |
136 | #define writesb __raw_writesb |
137 | #define writesw __raw_writesw | |
138 | #define writesl __raw_writesl | |
64c9627c | 139 | |
14866543 PM |
140 | #define readsb __raw_readsb |
141 | #define readsw __raw_readsw | |
142 | #define readsl __raw_readsl | |
05ae9158 | 143 | |
14866543 PM |
144 | #define readb_relaxed(a) readb(a) |
145 | #define readw_relaxed(a) readw(a) | |
146 | #define readl_relaxed(a) readl(a) | |
147 | #define readq_relaxed(a) readq(a) | |
1da177e4 | 148 | |
b66c1a39 | 149 | /* Simple MMIO */ |
64c9627c PM |
150 | #define ioread8(a) __raw_readb(a) |
151 | #define ioread16(a) __raw_readw(a) | |
b66c1a39 | 152 | #define ioread16be(a) be16_to_cpu(__raw_readw((a))) |
64c9627c | 153 | #define ioread32(a) __raw_readl(a) |
b66c1a39 | 154 | #define ioread32be(a) be32_to_cpu(__raw_readl((a))) |
1da177e4 | 155 | |
64c9627c PM |
156 | #define iowrite8(v,a) __raw_writeb((v),(a)) |
157 | #define iowrite16(v,a) __raw_writew((v),(a)) | |
b66c1a39 | 158 | #define iowrite16be(v,a) __raw_writew(cpu_to_be16((v)),(a)) |
64c9627c | 159 | #define iowrite32(v,a) __raw_writel((v),(a)) |
b66c1a39 PM |
160 | #define iowrite32be(v,a) __raw_writel(cpu_to_be32((v)),(a)) |
161 | ||
64c9627c PM |
162 | #define ioread8_rep(a, d, c) __raw_readsb((a), (d), (c)) |
163 | #define ioread16_rep(a, d, c) __raw_readsw((a), (d), (c)) | |
164 | #define ioread32_rep(a, d, c) __raw_readsl((a), (d), (c)) | |
b66c1a39 | 165 | |
64c9627c PM |
166 | #define iowrite8_rep(a, s, c) __raw_writesb((a), (s), (c)) |
167 | #define iowrite16_rep(a, s, c) __raw_writesw((a), (s), (c)) | |
168 | #define iowrite32_rep(a, s, c) __raw_writesl((a), (s), (c)) | |
b66c1a39 | 169 | |
14866543 PM |
170 | /* synco on SH-4A, otherwise a nop */ |
171 | #define mmiowb() wmb() | |
1da177e4 | 172 | |
0f2c15ce PM |
173 | #define IO_SPACE_LIMIT 0xffffffff |
174 | ||
fa43972f PM |
175 | extern unsigned long generic_io_base; |
176 | ||
1da177e4 | 177 | /* |
14866543 PM |
178 | * This function provides a method for the generic case where a |
179 | * board-specific ioport_map simply needs to return the port + some | |
180 | * arbitrary port base. | |
1da177e4 LT |
181 | * |
182 | * We use this at board setup time to implicitly set the port base, and | |
b66c1a39 | 183 | * as a result, we can use the generic ioport_map. |
1da177e4 LT |
184 | */ |
185 | static inline void __set_io_port_base(unsigned long pbase) | |
186 | { | |
1da177e4 LT |
187 | generic_io_base = pbase; |
188 | } | |
189 | ||
e7cc9a73 MD |
190 | #define __ioport_map(p, n) sh_mv.mv_ioport_map((p), (n)) |
191 | ||
1da177e4 | 192 | /* We really want to try and get these to memcpy etc */ |
14866543 PM |
193 | void memcpy_fromio(void *, const volatile void __iomem *, unsigned long); |
194 | void memcpy_toio(volatile void __iomem *, const void *, unsigned long); | |
195 | void memset_io(volatile void __iomem *, int, unsigned long); | |
959f85f8 | 196 | |
ac490a48 PM |
197 | /* Quad-word real-mode I/O, don't ask.. */ |
198 | unsigned long long peek_real_address_q(unsigned long long addr); | |
199 | unsigned long long poke_real_address_q(unsigned long long addr, | |
200 | unsigned long long val); | |
201 | ||
da06b8d0 PM |
202 | #if !defined(CONFIG_MMU) |
203 | #define virt_to_phys(address) ((unsigned long)(address)) | |
204 | #define phys_to_virt(address) ((void *)(address)) | |
d02b08f6 | 205 | #else |
da06b8d0 PM |
206 | #define virt_to_phys(address) (__pa(address)) |
207 | #define phys_to_virt(address) (__va(address)) | |
a2d1a5fa | 208 | #endif |
1da177e4 | 209 | |
1da177e4 | 210 | /* |
da06b8d0 PM |
211 | * On 32-bit SH, we traditionally have the whole physical address space |
212 | * mapped at all times (as MIPS does), so "ioremap()" and "iounmap()" do | |
213 | * not need to do anything but place the address in the proper segment. | |
214 | * This is true for P1 and P2 addresses, as well as some P3 ones. | |
215 | * However, most of the P3 addresses and newer cores using extended | |
216 | * addressing need to map through page tables, so the ioremap() | |
217 | * implementation becomes a bit more complicated. | |
1da177e4 | 218 | * |
da06b8d0 | 219 | * See arch/sh/mm/ioremap.c for additional notes on this. |
1da177e4 LT |
220 | * |
221 | * We cheat a bit and always return uncachable areas until we've fixed | |
b66c1a39 | 222 | * the drivers to handle caching properly. |
da06b8d0 PM |
223 | * |
224 | * On the SH-5 the concept of segmentation in the 1:1 PXSEG sense simply | |
225 | * doesn't exist, so everything must go through page tables. | |
1da177e4 | 226 | */ |
b66c1a39 PM |
227 | #ifdef CONFIG_MMU |
228 | void __iomem *__ioremap(unsigned long offset, unsigned long size, | |
229 | unsigned long flags); | |
230 | void __iounmap(void __iomem *addr); | |
ccd80587 | 231 | |
b66c1a39 PM |
232 | static inline void __iomem * |
233 | __ioremap_mode(unsigned long offset, unsigned long size, unsigned long flags) | |
1da177e4 | 234 | { |
2f47f447 | 235 | #if defined(CONFIG_SUPERH32) && !defined(CONFIG_PMB_FIXED) |
b66c1a39 | 236 | unsigned long last_addr = offset + size - 1; |
e7cc9a73 MD |
237 | #endif |
238 | void __iomem *ret; | |
b66c1a39 | 239 | |
e7cc9a73 MD |
240 | ret = __ioremap_trapped(offset, size); |
241 | if (ret) | |
242 | return ret; | |
243 | ||
2f47f447 | 244 | #if defined(CONFIG_SUPERH32) && !defined(CONFIG_PMB_FIXED) |
b66c1a39 PM |
245 | /* |
246 | * For P1 and P2 space this is trivial, as everything is already | |
247 | * mapped. Uncached access for P1 addresses are done through P2. | |
248 | * In the P3 case or for addresses outside of the 29-bit space, | |
249 | * mapping must be done by the PMB or by using page tables. | |
250 | */ | |
251 | if (likely(PXSEG(offset) < P3SEG && PXSEG(last_addr) < P3SEG)) { | |
252 | if (unlikely(flags & _PAGE_CACHABLE)) | |
253 | return (void __iomem *)P1SEGADDR(offset); | |
254 | ||
255 | return (void __iomem *)P2SEGADDR(offset); | |
256 | } | |
716777db MD |
257 | |
258 | /* P4 above the store queues are always mapped. */ | |
259 | if (unlikely(offset >= P3_ADDR_MAX)) | |
260 | return (void __iomem *)P4SEGADDR(offset); | |
da06b8d0 | 261 | #endif |
b66c1a39 PM |
262 | |
263 | return __ioremap(offset, size, flags); | |
1da177e4 | 264 | } |
e6be3a25 | 265 | #else |
e6be3a25 MD |
266 | #define __ioremap_mode(offset, size, flags) ((void __iomem *)(offset)) |
267 | #define __iounmap(addr) do { } while (0) | |
268 | #endif /* CONFIG_MMU */ | |
1da177e4 | 269 | |
b66c1a39 PM |
270 | #define ioremap(offset, size) \ |
271 | __ioremap_mode((offset), (size), 0) | |
272 | #define ioremap_nocache(offset, size) \ | |
273 | __ioremap_mode((offset), (size), 0) | |
274 | #define ioremap_cache(offset, size) \ | |
275 | __ioremap_mode((offset), (size), _PAGE_CACHABLE) | |
276 | #define p3_ioremap(offset, size, flags) \ | |
277 | __ioremap((offset), (size), (flags)) | |
cb700aa4 PM |
278 | #define ioremap_prot(offset, size, flags) \ |
279 | __ioremap_mode((offset), (size), (flags)) | |
b66c1a39 PM |
280 | #define iounmap(addr) \ |
281 | __iounmap((addr)) | |
282 | ||
14866543 PM |
283 | #define maybebadio(port) \ |
284 | printk(KERN_ERR "bad PC-like io %s:%u for port 0x%lx at 0x%08x\n", \ | |
285 | __func__, __LINE__, (port), (u32)__builtin_return_address(0)) | |
286 | ||
1da177e4 LT |
287 | /* |
288 | * Convert a physical pointer to a virtual kernel pointer for /dev/mem | |
289 | * access | |
290 | */ | |
291 | #define xlate_dev_mem_ptr(p) __va(p) | |
292 | ||
293 | /* | |
294 | * Convert a virtual cached pointer to an uncached pointer | |
295 | */ | |
296 | #define xlate_dev_kmem_ptr(p) p | |
297 | ||
185aed75 PM |
298 | #define ARCH_HAS_VALID_PHYS_ADDR_RANGE |
299 | int valid_phys_addr_range(unsigned long addr, size_t size); | |
300 | int valid_mmap_phys_addr_range(unsigned long pfn, size_t size); | |
301 | ||
1da177e4 LT |
302 | #endif /* __KERNEL__ */ |
303 | ||
304 | #endif /* __ASM_SH_IO_H */ |