~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/arch/frv/include/asm/io.h

Version: ~ [ linux-5.5 ] ~ [ linux-5.4.15 ] ~ [ linux-5.3.18 ] ~ [ linux-5.2.21 ] ~ [ linux-5.1.21 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.98 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.167 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.211 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.211 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.140 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.81 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /* io.h: FRV I/O operations
  2  *
  3  * Copyright (C) 2004 Red Hat, Inc. All Rights Reserved.
  4  * Written by David Howells (dhowells@redhat.com)
  5  *
  6  * This program is free software; you can redistribute it and/or
  7  * modify it under the terms of the GNU General Public License
  8  * as published by the Free Software Foundation; either version
  9  * 2 of the License, or (at your option) any later version.
 10  *
 11  * This gets interesting when talking to the PCI bus - the CPU is in big endian
 12  * mode, the PCI bus is little endian and the hardware in the middle can do
 13  * byte swapping
 14  */
 15 #ifndef _ASM_IO_H
 16 #define _ASM_IO_H
 17 
 18 #ifdef __KERNEL__
 19 
 20 #include <linux/types.h>
 21 #include <asm/virtconvert.h>
 22 #include <asm/string.h>
 23 #include <asm/mb-regs.h>
 24 #include <asm-generic/pci_iomap.h>
 25 #include <linux/delay.h>
 26 
 27 /*
 28  * swap functions are sometimes needed to interface little-endian hardware
 29  */
 30 
 31 static inline unsigned short _swapw(unsigned short v)
 32 {
 33     return ((v << 8) | (v >> 8));
 34 }
 35 
 36 static inline unsigned long _swapl(unsigned long v)
 37 {
 38     return ((v << 24) | ((v & 0xff00) << 8) | ((v & 0xff0000) >> 8) | (v >> 24));
 39 }
 40 
 41 //#define __iormb() asm volatile("membar")
 42 //#define __iowmb() asm volatile("membar")
 43 
 44 #define __raw_readb __builtin_read8
 45 #define __raw_readw __builtin_read16
 46 #define __raw_readl __builtin_read32
 47 
 48 #define __raw_writeb(datum, addr) __builtin_write8(addr, datum)
 49 #define __raw_writew(datum, addr) __builtin_write16(addr, datum)
 50 #define __raw_writel(datum, addr) __builtin_write32(addr, datum)
 51 
 52 static inline void io_outsb(unsigned int addr, const void *buf, int len)
 53 {
 54         unsigned long __ioaddr = (unsigned long) addr;
 55         const uint8_t *bp = buf;
 56 
 57         while (len--)
 58                 __builtin_write8((volatile void __iomem *) __ioaddr, *bp++);
 59 }
 60 
 61 static inline void io_outsw(unsigned int addr, const void *buf, int len)
 62 {
 63         unsigned long __ioaddr = (unsigned long) addr;
 64         const uint16_t *bp = buf;
 65 
 66         while (len--)
 67                 __builtin_write16((volatile void __iomem *) __ioaddr, (*bp++));
 68 }
 69 
 70 extern void __outsl_ns(unsigned int addr, const void *buf, int len);
 71 extern void __outsl_sw(unsigned int addr, const void *buf, int len);
 72 static inline void __outsl(unsigned int addr, const void *buf, int len, int swap)
 73 {
 74         unsigned long __ioaddr = (unsigned long) addr;
 75 
 76         if (!swap)
 77                 __outsl_ns(__ioaddr, buf, len);
 78         else
 79                 __outsl_sw(__ioaddr, buf, len);
 80 }
 81 
 82 static inline void io_insb(unsigned long addr, void *buf, int len)
 83 {
 84         uint8_t *bp = buf;
 85 
 86         while (len--)
 87                 *bp++ = __builtin_read8((volatile void __iomem *) addr);
 88 }
 89 
 90 static inline void io_insw(unsigned long addr, void *buf, int len)
 91 {
 92         uint16_t *bp = buf;
 93 
 94         while (len--)
 95                 *bp++ = __builtin_read16((volatile void __iomem *) addr);
 96 }
 97 
 98 extern void __insl_ns(unsigned long addr, void *buf, int len);
 99 extern void __insl_sw(unsigned long addr, void *buf, int len);
100 static inline void __insl(unsigned long addr, void *buf, int len, int swap)
101 {
102         if (!swap)
103                 __insl_ns(addr, buf, len);
104         else
105                 __insl_sw(addr, buf, len);
106 }
107 
108 #define mmiowb() mb()
109 
110 /*
111  *      make the short names macros so specific devices
112  *      can override them as required
113  */
114 
115 static inline void memset_io(volatile void __iomem *addr, unsigned char val, int count)
116 {
117         memset((void __force *) addr, val, count);
118 }
119 
120 static inline void memcpy_fromio(void *dst, const volatile void __iomem *src, int count)
121 {
122         memcpy(dst, (void __force *) src, count);
123 }
124 
125 static inline void memcpy_toio(volatile void __iomem *dst, const void *src, int count)
126 {
127         memcpy((void __force *) dst, src, count);
128 }
129 
130 static inline uint8_t inb(unsigned long addr)
131 {
132         return __builtin_read8((void __iomem *)addr);
133 }
134 
135 static inline uint16_t inw(unsigned long addr)
136 {
137         uint16_t ret = __builtin_read16((void __iomem *)addr);
138 
139         if (__is_PCI_IO(addr))
140                 ret = _swapw(ret);
141 
142         return ret;
143 }
144 
145 static inline uint32_t inl(unsigned long addr)
146 {
147         uint32_t ret = __builtin_read32((void __iomem *)addr);
148 
149         if (__is_PCI_IO(addr))
150                 ret = _swapl(ret);
151 
152         return ret;
153 }
154 
155 static inline void outb(uint8_t datum, unsigned long addr)
156 {
157         __builtin_write8((void __iomem *)addr, datum);
158 }
159 
160 static inline void outw(uint16_t datum, unsigned long addr)
161 {
162         if (__is_PCI_IO(addr))
163                 datum = _swapw(datum);
164         __builtin_write16((void __iomem *)addr, datum);
165 }
166 
167 static inline void outl(uint32_t datum, unsigned long addr)
168 {
169         if (__is_PCI_IO(addr))
170                 datum = _swapl(datum);
171         __builtin_write32((void __iomem *)addr, datum);
172 }
173 
174 #define inb_p(addr)     inb(addr)
175 #define inw_p(addr)     inw(addr)
176 #define inl_p(addr)     inl(addr)
177 #define outb_p(x,addr)  outb(x,addr)
178 #define outw_p(x,addr)  outw(x,addr)
179 #define outl_p(x,addr)  outl(x,addr)
180 
181 #define outsb(a,b,l)    io_outsb(a,b,l)
182 #define outsw(a,b,l)    io_outsw(a,b,l)
183 #define outsl(a,b,l)    __outsl(a,b,l,0)
184 
185 #define insb(a,b,l)     io_insb(a,b,l)
186 #define insw(a,b,l)     io_insw(a,b,l)
187 #define insl(a,b,l)     __insl(a,b,l,0)
188 
189 #define IO_SPACE_LIMIT  0xffffffff
190 
191 static inline uint8_t readb(const volatile void __iomem *addr)
192 {
193         return __builtin_read8((__force void volatile __iomem *) addr);
194 }
195 
196 static inline uint16_t readw(const volatile void __iomem *addr)
197 {
198         uint16_t ret =  __builtin_read16((__force void volatile __iomem *)addr);
199 
200         if (__is_PCI_MEM(addr))
201                 ret = _swapw(ret);
202         return ret;
203 }
204 
205 static inline uint32_t readl(const volatile void __iomem *addr)
206 {
207         uint32_t ret =  __builtin_read32((__force void volatile __iomem *)addr);
208 
209         if (__is_PCI_MEM(addr))
210                 ret = _swapl(ret);
211 
212         return ret;
213 }
214 
215 #define readb_relaxed readb
216 #define readw_relaxed readw
217 #define readl_relaxed readl
218 
219 static inline void writeb(uint8_t datum, volatile void __iomem *addr)
220 {
221         __builtin_write8(addr, datum);
222         if (__is_PCI_MEM(addr))
223                 __flush_PCI_writes();
224 }
225 
226 static inline void writew(uint16_t datum, volatile void __iomem *addr)
227 {
228         if (__is_PCI_MEM(addr))
229                 datum = _swapw(datum);
230 
231         __builtin_write16(addr, datum);
232         if (__is_PCI_MEM(addr))
233                 __flush_PCI_writes();
234 }
235 
236 static inline void writel(uint32_t datum, volatile void __iomem *addr)
237 {
238         if (__is_PCI_MEM(addr))
239                 datum = _swapl(datum);
240 
241         __builtin_write32(addr, datum);
242         if (__is_PCI_MEM(addr))
243                 __flush_PCI_writes();
244 }
245 
246 
247 /* Values for nocacheflag and cmode */
248 #define IOMAP_FULL_CACHING              0
249 #define IOMAP_NOCACHE_SER               1
250 #define IOMAP_NOCACHE_NONSER            2
251 #define IOMAP_WRITETHROUGH              3
252 
253 extern void __iomem *__ioremap(unsigned long physaddr, unsigned long size, int cacheflag);
254 
255 static inline void __iomem *ioremap(unsigned long physaddr, unsigned long size)
256 {
257         return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
258 }
259 
260 static inline void __iomem *ioremap_nocache(unsigned long physaddr, unsigned long size)
261 {
262         return __ioremap(physaddr, size, IOMAP_NOCACHE_SER);
263 }
264 
265 static inline void __iomem *ioremap_writethrough(unsigned long physaddr, unsigned long size)
266 {
267         return __ioremap(physaddr, size, IOMAP_WRITETHROUGH);
268 }
269 
270 static inline void __iomem *ioremap_fullcache(unsigned long physaddr, unsigned long size)
271 {
272         return __ioremap(physaddr, size, IOMAP_FULL_CACHING);
273 }
274 
275 #define ioremap_wc ioremap_nocache
276 
277 extern void iounmap(void volatile __iomem *addr);
278 
279 static inline void __iomem *ioport_map(unsigned long port, unsigned int nr)
280 {
281         return (void __iomem *) port;
282 }
283 
284 static inline void ioport_unmap(void __iomem *p)
285 {
286 }
287 
288 static inline void flush_write_buffers(void)
289 {
290         __asm__ __volatile__ ("membar" : : :"memory");
291 }
292 
293 /*
294  * do appropriate I/O accesses for token type
295  */
296 static inline unsigned int ioread8(void __iomem *p)
297 {
298         return __builtin_read8(p);
299 }
300 
301 static inline unsigned int ioread16(void __iomem *p)
302 {
303         uint16_t ret = __builtin_read16(p);
304         if (__is_PCI_addr(p))
305                 ret = _swapw(ret);
306         return ret;
307 }
308 
309 static inline unsigned int ioread32(void __iomem *p)
310 {
311         uint32_t ret = __builtin_read32(p);
312         if (__is_PCI_addr(p))
313                 ret = _swapl(ret);
314         return ret;
315 }
316 
317 static inline void iowrite8(u8 val, void __iomem *p)
318 {
319         __builtin_write8(p, val);
320         if (__is_PCI_MEM(p))
321                 __flush_PCI_writes();
322 }
323 
324 static inline void iowrite16(u16 val, void __iomem *p)
325 {
326         if (__is_PCI_addr(p))
327                 val = _swapw(val);
328         __builtin_write16(p, val);
329         if (__is_PCI_MEM(p))
330                 __flush_PCI_writes();
331 }
332 
333 static inline void iowrite32(u32 val, void __iomem *p)
334 {
335         if (__is_PCI_addr(p))
336                 val = _swapl(val);
337         __builtin_write32(p, val);
338         if (__is_PCI_MEM(p))
339                 __flush_PCI_writes();
340 }
341 
342 static inline void ioread8_rep(void __iomem *p, void *dst, unsigned long count)
343 {
344         io_insb((unsigned long) p, dst, count);
345 }
346 
347 static inline void ioread16_rep(void __iomem *p, void *dst, unsigned long count)
348 {
349         io_insw((unsigned long) p, dst, count);
350 }
351 
352 static inline void ioread32_rep(void __iomem *p, void *dst, unsigned long count)
353 {
354         __insl_ns((unsigned long) p, dst, count);
355 }
356 
357 static inline void iowrite8_rep(void __iomem *p, const void *src, unsigned long count)
358 {
359         io_outsb((unsigned long) p, src, count);
360 }
361 
362 static inline void iowrite16_rep(void __iomem *p, const void *src, unsigned long count)
363 {
364         io_outsw((unsigned long) p, src, count);
365 }
366 
367 static inline void iowrite32_rep(void __iomem *p, const void *src, unsigned long count)
368 {
369         __outsl_ns((unsigned long) p, src, count);
370 }
371 
372 /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
373 struct pci_dev;
374 static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p)
375 {
376 }
377 
378 
379 /*
380  * Convert a physical pointer to a virtual kernel pointer for /dev/mem
381  * access
382  */
383 #define xlate_dev_mem_ptr(p)    __va(p)
384 
385 /*
386  * Convert a virtual cached pointer to an uncached pointer
387  */
388 #define xlate_dev_kmem_ptr(p)   p
389 
390 #endif /* __KERNEL__ */
391 
392 #endif /* _ASM_IO_H */
393 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp