Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 1 | #ifndef _BFIN_IO_H |
| 2 | #define _BFIN_IO_H |
| 3 | |
| 4 | #ifdef __KERNEL__ |
| 5 | |
| 6 | #ifndef __ASSEMBLY__ |
| 7 | #include <linux/types.h> |
| 8 | #endif |
| 9 | #include <linux/compiler.h> |
| 10 | |
| 11 | /* |
| 12 | * These are for ISA/PCI shared memory _only_ and should never be used |
| 13 | * on any other type of memory, including Zorro memory. They are meant to |
| 14 | * access the bus in the bus byte order which is little-endian!. |
| 15 | * |
| 16 | * readX/writeX() are used to access memory mapped devices. On some |
| 17 | * architectures the memory mapped IO stuff needs to be accessed |
| 18 | * differently. On the bfin architecture, we just read/write the |
| 19 | * memory location directly. |
| 20 | */ |
| 21 | #ifndef __ASSEMBLY__ |
| 22 | |
Mike Frysinger | 216e39d | 2007-06-21 11:34:16 +0800 | [diff] [blame] | 23 | static inline unsigned char readb(const volatile void __iomem *addr) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 24 | { |
| 25 | unsigned int val; |
| 26 | int tmp; |
| 27 | |
| 28 | __asm__ __volatile__ ("cli %1;\n\t" |
| 29 | "NOP; NOP; SSYNC;\n\t" |
| 30 | "%0 = b [%2] (z);\n\t" |
| 31 | "sti %1;\n\t" |
| 32 | : "=d"(val), "=d"(tmp): "a"(addr) |
| 33 | ); |
| 34 | |
| 35 | return (unsigned char) val; |
| 36 | } |
| 37 | |
Mike Frysinger | 216e39d | 2007-06-21 11:34:16 +0800 | [diff] [blame] | 38 | static inline unsigned short readw(const volatile void __iomem *addr) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 39 | { |
| 40 | unsigned int val; |
| 41 | int tmp; |
| 42 | |
| 43 | __asm__ __volatile__ ("cli %1;\n\t" |
| 44 | "NOP; NOP; SSYNC;\n\t" |
| 45 | "%0 = w [%2] (z);\n\t" |
| 46 | "sti %1;\n\t" |
| 47 | : "=d"(val), "=d"(tmp): "a"(addr) |
| 48 | ); |
| 49 | |
| 50 | return (unsigned short) val; |
| 51 | } |
| 52 | |
Mike Frysinger | 216e39d | 2007-06-21 11:34:16 +0800 | [diff] [blame] | 53 | static inline unsigned int readl(const volatile void __iomem *addr) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 54 | { |
| 55 | unsigned int val; |
| 56 | int tmp; |
| 57 | |
| 58 | __asm__ __volatile__ ("cli %1;\n\t" |
| 59 | "NOP; NOP; SSYNC;\n\t" |
| 60 | "%0 = [%2];\n\t" |
| 61 | "sti %1;\n\t" |
| 62 | : "=d"(val), "=d"(tmp): "a"(addr) |
| 63 | ); |
| 64 | return val; |
| 65 | } |
| 66 | |
| 67 | #endif /* __ASSEMBLY__ */ |
| 68 | |
| 69 | #define writeb(b,addr) (void)((*(volatile unsigned char *) (addr)) = (b)) |
| 70 | #define writew(b,addr) (void)((*(volatile unsigned short *) (addr)) = (b)) |
| 71 | #define writel(b,addr) (void)((*(volatile unsigned int *) (addr)) = (b)) |
| 72 | |
| 73 | #define __raw_readb readb |
| 74 | #define __raw_readw readw |
| 75 | #define __raw_readl readl |
| 76 | #define __raw_writeb writeb |
| 77 | #define __raw_writew writew |
| 78 | #define __raw_writel writel |
| 79 | #define memset_io(a,b,c) memset((void *)(a),(b),(c)) |
| 80 | #define memcpy_fromio(a,b,c) memcpy((a),(void *)(b),(c)) |
| 81 | #define memcpy_toio(a,b,c) memcpy((void *)(a),(b),(c)) |
| 82 | |
| 83 | #define inb(addr) readb(addr) |
| 84 | #define inw(addr) readw(addr) |
| 85 | #define inl(addr) readl(addr) |
| 86 | #define outb(x,addr) ((void) writeb(x,addr)) |
| 87 | #define outw(x,addr) ((void) writew(x,addr)) |
| 88 | #define outl(x,addr) ((void) writel(x,addr)) |
| 89 | |
| 90 | #define inb_p(addr) inb(addr) |
| 91 | #define inw_p(addr) inw(addr) |
| 92 | #define inl_p(addr) inl(addr) |
| 93 | #define outb_p(x,addr) outb(x,addr) |
| 94 | #define outw_p(x,addr) outw(x,addr) |
| 95 | #define outl_p(x,addr) outl(x,addr) |
| 96 | |
Sonic Zhang | 55e247e | 2009-01-07 23:14:39 +0800 | [diff] [blame] | 97 | #define ioread8_rep(a,d,c) readsb(a,d,c) |
| 98 | #define ioread16_rep(a,d,c) readsw(a,d,c) |
| 99 | #define ioread32_rep(a,d,c) readsl(a,d,c) |
| 100 | #define iowrite8_rep(a,s,c) writesb(a,s,c) |
| 101 | #define iowrite16_rep(a,s,c) writesw(a,s,c) |
| 102 | #define iowrite32_rep(a,s,c) writesl(a,s,c) |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 103 | |
| 104 | #define ioread8(X) readb(X) |
| 105 | #define ioread16(X) readw(X) |
| 106 | #define ioread32(X) readl(X) |
| 107 | #define iowrite8(val,X) writeb(val,X) |
| 108 | #define iowrite16(val,X) writew(val,X) |
| 109 | #define iowrite32(val,X) writel(val,X) |
| 110 | |
Mike Frysinger | ecdbfc1 | 2008-11-18 17:48:21 +0800 | [diff] [blame] | 111 | #define mmiowb() wmb() |
| 112 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 113 | #define IO_SPACE_LIMIT 0xffffffff |
| 114 | |
| 115 | /* Values for nocacheflag and cmode */ |
| 116 | #define IOMAP_NOCACHE_SER 1 |
| 117 | |
| 118 | #ifndef __ASSEMBLY__ |
| 119 | |
Bryan Wu | b7b2d344 | 2007-10-09 15:09:49 +0800 | [diff] [blame] | 120 | extern void outsb(unsigned long port, const void *addr, unsigned long count); |
| 121 | extern void outsw(unsigned long port, const void *addr, unsigned long count); |
Michael Hennerich | 5906967 | 2008-05-17 16:38:52 +0800 | [diff] [blame] | 122 | extern void outsw_8(unsigned long port, const void *addr, unsigned long count); |
Bryan Wu | b7b2d344 | 2007-10-09 15:09:49 +0800 | [diff] [blame] | 123 | extern void outsl(unsigned long port, const void *addr, unsigned long count); |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 124 | |
Bryan Wu | b7b2d344 | 2007-10-09 15:09:49 +0800 | [diff] [blame] | 125 | extern void insb(unsigned long port, void *addr, unsigned long count); |
| 126 | extern void insw(unsigned long port, void *addr, unsigned long count); |
Michael Hennerich | 5906967 | 2008-05-17 16:38:52 +0800 | [diff] [blame] | 127 | extern void insw_8(unsigned long port, void *addr, unsigned long count); |
Bryan Wu | b7b2d344 | 2007-10-09 15:09:49 +0800 | [diff] [blame] | 128 | extern void insl(unsigned long port, void *addr, unsigned long count); |
Michael Hennerich | 5c91fb9 | 2007-11-17 23:46:58 +0800 | [diff] [blame] | 129 | extern void insl_16(unsigned long port, void *addr, unsigned long count); |
Michael Hennerich | 23ee968 | 2007-05-21 18:09:17 +0800 | [diff] [blame] | 130 | |
Bryan Wu | b7b2d344 | 2007-10-09 15:09:49 +0800 | [diff] [blame] | 131 | extern void dma_outsb(unsigned long port, const void *addr, unsigned short count); |
| 132 | extern void dma_outsw(unsigned long port, const void *addr, unsigned short count); |
| 133 | extern void dma_outsl(unsigned long port, const void *addr, unsigned short count); |
Michael Hennerich | 23ee968 | 2007-05-21 18:09:17 +0800 | [diff] [blame] | 134 | |
Bryan Wu | b7b2d344 | 2007-10-09 15:09:49 +0800 | [diff] [blame] | 135 | extern void dma_insb(unsigned long port, void *addr, unsigned short count); |
| 136 | extern void dma_insw(unsigned long port, void *addr, unsigned short count); |
| 137 | extern void dma_insl(unsigned long port, void *addr, unsigned short count); |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 138 | |
Bryan Wu | 121e598 | 2008-10-16 22:31:56 +0800 | [diff] [blame] | 139 | static inline void readsl(const void __iomem *addr, void *buf, int len) |
| 140 | { |
| 141 | insl((unsigned long)addr, buf, len); |
| 142 | } |
| 143 | |
| 144 | static inline void readsw(const void __iomem *addr, void *buf, int len) |
| 145 | { |
| 146 | insw((unsigned long)addr, buf, len); |
| 147 | } |
| 148 | |
| 149 | static inline void readsb(const void __iomem *addr, void *buf, int len) |
| 150 | { |
| 151 | insb((unsigned long)addr, buf, len); |
| 152 | } |
| 153 | |
| 154 | static inline void writesl(const void __iomem *addr, const void *buf, int len) |
| 155 | { |
| 156 | outsl((unsigned long)addr, buf, len); |
| 157 | } |
| 158 | |
| 159 | static inline void writesw(const void __iomem *addr, const void *buf, int len) |
| 160 | { |
| 161 | outsw((unsigned long)addr, buf, len); |
| 162 | } |
| 163 | |
| 164 | static inline void writesb(const void __iomem *addr, const void *buf, int len) |
| 165 | { |
| 166 | outsb((unsigned long)addr, buf, len); |
| 167 | } |
| 168 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 169 | /* |
| 170 | * Map some physical address range into the kernel address space. |
| 171 | */ |
| 172 | static inline void __iomem *__ioremap(unsigned long physaddr, unsigned long size, |
| 173 | int cacheflag) |
| 174 | { |
| 175 | return (void __iomem *)physaddr; |
| 176 | } |
| 177 | |
| 178 | /* |
| 179 | * Unmap a ioremap()ed region again |
| 180 | */ |
| 181 | static inline void iounmap(void *addr) |
| 182 | { |
| 183 | } |
| 184 | |
| 185 | /* |
| 186 | * __iounmap unmaps nearly everything, so be careful |
| 187 | * it doesn't free currently pointer/page tables anymore but it |
| 188 | * wans't used anyway and might be added later. |
| 189 | */ |
| 190 | static inline void __iounmap(void *addr, unsigned long size) |
| 191 | { |
| 192 | } |
| 193 | |
| 194 | /* |
| 195 | * Set new cache mode for some kernel address space. |
| 196 | * The caller must push data for that range itself, if such data may already |
| 197 | * be in the cache. |
| 198 | */ |
| 199 | static inline void kernel_set_cachemode(void *addr, unsigned long size, |
| 200 | int cmode) |
| 201 | { |
| 202 | } |
| 203 | |
| 204 | static inline void __iomem *ioremap(unsigned long physaddr, unsigned long size) |
| 205 | { |
| 206 | return __ioremap(physaddr, size, IOMAP_NOCACHE_SER); |
| 207 | } |
| 208 | static inline void __iomem *ioremap_nocache(unsigned long physaddr, |
| 209 | unsigned long size) |
| 210 | { |
| 211 | return __ioremap(physaddr, size, IOMAP_NOCACHE_SER); |
| 212 | } |
| 213 | |
| 214 | extern void blkfin_inv_cache_all(void); |
| 215 | |
| 216 | #endif |
| 217 | |
| 218 | #define ioport_map(port, nr) ((void __iomem*)(port)) |
| 219 | #define ioport_unmap(addr) |
| 220 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 221 | /* Pages to physical address... */ |
| 222 | #define page_to_phys(page) ((page - mem_map) << PAGE_SHIFT) |
| 223 | #define page_to_bus(page) ((page - mem_map) << PAGE_SHIFT) |
| 224 | |
Bryan Wu | 1394f03 | 2007-05-06 14:50:22 -0700 | [diff] [blame] | 225 | #define phys_to_virt(vaddr) ((void *) (vaddr)) |
| 226 | #define virt_to_phys(vaddr) ((unsigned long) (vaddr)) |
| 227 | |
| 228 | #define virt_to_bus virt_to_phys |
| 229 | #define bus_to_virt phys_to_virt |
| 230 | |
| 231 | /* |
| 232 | * Convert a physical pointer to a virtual kernel pointer for /dev/mem |
| 233 | * access |
| 234 | */ |
| 235 | #define xlate_dev_mem_ptr(p) __va(p) |
| 236 | |
| 237 | /* |
| 238 | * Convert a virtual cached pointer to an uncached pointer |
| 239 | */ |
| 240 | #define xlate_dev_kmem_ptr(p) p |
| 241 | |
| 242 | #endif /* __KERNEL__ */ |
| 243 | |
| 244 | #endif /* _BFIN_IO_H */ |