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

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

Version: ~ [ linux-5.2-rc4 ] ~ [ linux-5.1.9 ] ~ [ linux-5.0.21 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.50 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.125 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.181 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.181 ] ~ [ 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.68 ] ~ [ 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.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ 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 /* MN10300 I/O port emulation and memory-mapped I/O
  2  *
  3  * Copyright (C) 2007 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 Licence
  8  * as published by the Free Software Foundation; either version
  9  * 2 of the Licence, or (at your option) any later version.
 10  */
 11 #ifndef _ASM_IO_H
 12 #define _ASM_IO_H
 13 
 14 #include <asm/page.h> /* I/O is all done through memory accesses */
 15 #include <asm/cpu-regs.h>
 16 #include <asm/cacheflush.h>
 17 #include <asm-generic/pci_iomap.h>
 18 
 19 #define mmiowb() do {} while (0)
 20 
 21 /*****************************************************************************/
 22 /*
 23  * readX/writeX() are used to access memory mapped devices. On some
 24  * architectures the memory mapped IO stuff needs to be accessed
 25  * differently. On the x86 architecture, we just read/write the
 26  * memory location directly.
 27  */
 28 static inline u8 readb(const volatile void __iomem *addr)
 29 {
 30         return *(const volatile u8 *) addr;
 31 }
 32 
 33 static inline u16 readw(const volatile void __iomem *addr)
 34 {
 35         return *(const volatile u16 *) addr;
 36 }
 37 
 38 static inline u32 readl(const volatile void __iomem *addr)
 39 {
 40         return *(const volatile u32 *) addr;
 41 }
 42 
 43 #define __raw_readb readb
 44 #define __raw_readw readw
 45 #define __raw_readl readl
 46 
 47 #define readb_relaxed readb
 48 #define readw_relaxed readw
 49 #define readl_relaxed readl
 50 
 51 static inline void writeb(u8 b, volatile void __iomem *addr)
 52 {
 53         *(volatile u8 *) addr = b;
 54 }
 55 
 56 static inline void writew(u16 b, volatile void __iomem *addr)
 57 {
 58         *(volatile u16 *) addr = b;
 59 }
 60 
 61 static inline void writel(u32 b, volatile void __iomem *addr)
 62 {
 63         *(volatile u32 *) addr = b;
 64 }
 65 
 66 #define __raw_writeb writeb
 67 #define __raw_writew writew
 68 #define __raw_writel writel
 69 
 70 #define writeb_relaxed writeb
 71 #define writew_relaxed writew
 72 #define writel_relaxed writel
 73 
 74 /*****************************************************************************/
 75 /*
 76  * traditional input/output functions
 77  */
 78 static inline u8 inb_local(unsigned long addr)
 79 {
 80         return readb((volatile void __iomem *) addr);
 81 }
 82 
 83 static inline void outb_local(u8 b, unsigned long addr)
 84 {
 85         return writeb(b, (volatile void __iomem *) addr);
 86 }
 87 
 88 static inline u8 inb(unsigned long addr)
 89 {
 90         return readb((volatile void __iomem *) addr);
 91 }
 92 
 93 static inline u16 inw(unsigned long addr)
 94 {
 95         return readw((volatile void __iomem *) addr);
 96 }
 97 
 98 static inline u32 inl(unsigned long addr)
 99 {
100         return readl((volatile void __iomem *) addr);
101 }
102 
103 static inline void outb(u8 b, unsigned long addr)
104 {
105         return writeb(b, (volatile void __iomem *) addr);
106 }
107 
108 static inline void outw(u16 b, unsigned long addr)
109 {
110         return writew(b, (volatile void __iomem *) addr);
111 }
112 
113 static inline void outl(u32 b, unsigned long addr)
114 {
115         return writel(b, (volatile void __iomem *) addr);
116 }
117 
118 #define inb_p(addr)     inb(addr)
119 #define inw_p(addr)     inw(addr)
120 #define inl_p(addr)     inl(addr)
121 #define outb_p(x, addr) outb((x), (addr))
122 #define outw_p(x, addr) outw((x), (addr))
123 #define outl_p(x, addr) outl((x), (addr))
124 
125 static inline void insb(unsigned long addr, void *buffer, int count)
126 {
127         if (count) {
128                 u8 *buf = buffer;
129                 do {
130                         u8 x = inb(addr);
131                         *buf++ = x;
132                 } while (--count);
133         }
134 }
135 
136 static inline void insw(unsigned long addr, void *buffer, int count)
137 {
138         if (count) {
139                 u16 *buf = buffer;
140                 do {
141                         u16 x = inw(addr);
142                         *buf++ = x;
143                 } while (--count);
144         }
145 }
146 
147 static inline void insl(unsigned long addr, void *buffer, int count)
148 {
149         if (count) {
150                 u32 *buf = buffer;
151                 do {
152                         u32 x = inl(addr);
153                         *buf++ = x;
154                 } while (--count);
155         }
156 }
157 
158 static inline void outsb(unsigned long addr, const void *buffer, int count)
159 {
160         if (count) {
161                 const u8 *buf = buffer;
162                 do {
163                         outb(*buf++, addr);
164                 } while (--count);
165         }
166 }
167 
168 static inline void outsw(unsigned long addr, const void *buffer, int count)
169 {
170         if (count) {
171                 const u16 *buf = buffer;
172                 do {
173                         outw(*buf++, addr);
174                 } while (--count);
175         }
176 }
177 
178 extern void __outsl(unsigned long addr, const void *buffer, int count);
179 static inline void outsl(unsigned long addr, const void *buffer, int count)
180 {
181         if ((unsigned long) buffer & 0x3)
182                 return __outsl(addr, buffer, count);
183 
184         if (count) {
185                 const u32 *buf = buffer;
186                 do {
187                         outl(*buf++, addr);
188                 } while (--count);
189         }
190 }
191 
192 #define ioread8(addr)           readb(addr)
193 #define ioread16(addr)          readw(addr)
194 #define ioread32(addr)          readl(addr)
195 
196 #define iowrite8(v, addr)       writeb((v), (addr))
197 #define iowrite16(v, addr)      writew((v), (addr))
198 #define iowrite32(v, addr)      writel((v), (addr))
199 
200 #define ioread16be(addr)        be16_to_cpu(readw(addr))
201 #define ioread32be(addr)        be32_to_cpu(readl(addr))
202 #define iowrite16be(v, addr)    writew(cpu_to_be16(v), (addr))
203 #define iowrite32be(v, addr)    writel(cpu_to_be32(v), (addr))
204 
205 #define ioread8_rep(p, dst, count) \
206         insb((unsigned long) (p), (dst), (count))
207 #define ioread16_rep(p, dst, count) \
208         insw((unsigned long) (p), (dst), (count))
209 #define ioread32_rep(p, dst, count) \
210         insl((unsigned long) (p), (dst), (count))
211 
212 #define iowrite8_rep(p, src, count) \
213         outsb((unsigned long) (p), (src), (count))
214 #define iowrite16_rep(p, src, count) \
215         outsw((unsigned long) (p), (src), (count))
216 #define iowrite32_rep(p, src, count) \
217         outsl((unsigned long) (p), (src), (count))
218 
219 #define readsb(p, dst, count) \
220         insb((unsigned long) (p), (dst), (count))
221 #define readsw(p, dst, count) \
222         insw((unsigned long) (p), (dst), (count))
223 #define readsl(p, dst, count) \
224         insl((unsigned long) (p), (dst), (count))
225 
226 #define writesb(p, src, count) \
227         outsb((unsigned long) (p), (src), (count))
228 #define writesw(p, src, count) \
229         outsw((unsigned long) (p), (src), (count))
230 #define writesl(p, src, count) \
231         outsl((unsigned long) (p), (src), (count))
232 
233 #define IO_SPACE_LIMIT 0xffffffff
234 
235 #ifdef __KERNEL__
236 
237 #include <linux/vmalloc.h>
238 #define __io_virt(x) ((void *) (x))
239 
240 /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
241 struct pci_dev;
242 static inline void pci_iounmap(struct pci_dev *dev, void __iomem *p)
243 {
244 }
245 
246 /*
247  * Change virtual addresses to physical addresses and vv.
248  * These are pretty trivial
249  */
250 static inline unsigned long virt_to_phys(volatile void *address)
251 {
252         return __pa(address);
253 }
254 
255 static inline void *phys_to_virt(unsigned long address)
256 {
257         return __va(address);
258 }
259 
260 /*
261  * Change "struct page" to physical address.
262  */
263 static inline void __iomem *__ioremap(unsigned long offset, unsigned long size,
264                                       unsigned long flags)
265 {
266         return (void __iomem *) offset;
267 }
268 
269 static inline void __iomem *ioremap(unsigned long offset, unsigned long size)
270 {
271         return (void __iomem *)(offset & ~0x20000000);
272 }
273 
274 /*
275  * This one maps high address device memory and turns off caching for that
276  * area.  it's useful if some control registers are in such an area and write
277  * combining or read caching is not desirable:
278  */
279 static inline void __iomem *ioremap_nocache(unsigned long offset, unsigned long size)
280 {
281         return (void __iomem *) (offset | 0x20000000);
282 }
283 
284 #define ioremap_wc ioremap_nocache
285 #define ioremap_wt ioremap_nocache
286 #define ioremap_uc ioremap_nocache
287 
288 static inline void iounmap(void __iomem *addr)
289 {
290 }
291 
292 static inline void __iomem *ioport_map(unsigned long port, unsigned int nr)
293 {
294         return (void __iomem *) port;
295 }
296 
297 static inline void ioport_unmap(void __iomem *p)
298 {
299 }
300 
301 #define xlate_dev_kmem_ptr(p)   ((void *) (p))
302 #define xlate_dev_mem_ptr(p)    ((void *) (p))
303 
304 /*
305  * PCI bus iomem addresses must be in the region 0x80000000-0x9fffffff
306  */
307 static inline unsigned long virt_to_bus(volatile void *address)
308 {
309         return ((unsigned long) address) & ~0x20000000;
310 }
311 
312 static inline void *bus_to_virt(unsigned long address)
313 {
314         return (void *) address;
315 }
316 
317 #define page_to_bus page_to_phys
318 
319 #define memset_io(a, b, c)      memset(__io_virt(a), (b), (c))
320 #define memcpy_fromio(a, b, c)  memcpy((a), __io_virt(b), (c))
321 #define memcpy_toio(a, b, c)    memcpy(__io_virt(a), (b), (c))
322 
323 #endif /* __KERNEL__ */
324 
325 #endif /* _ASM_IO_H */
326 

~ [ 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