1 #ifndef __SPARC_IO_H 2 #define __SPARC_IO_H 3 4 #include <linux/kernel.h> 5 #include <linux/ioport.h> /* struct resource */ 6 7 #define IO_SPACE_LIMIT 0xffffffff 8 9 #define memset_io(d,c,sz) _memset_io(d,c,sz) 10 #define memcpy_fromio(d,s,sz) _memcpy_fromio(d,s,sz) 11 #define memcpy_toio(d,s,sz) _memcpy_toio(d,s,sz) 12 13 #include <asm-generic/io.h> 14 15 static inline void _memset_io(volatile void __iomem *dst, 16 int c, __kernel_size_t n) 17 { 18 volatile void __iomem *d = dst; 19 20 while (n--) { 21 writeb(c, d); 22 d++; 23 } 24 } 25 26 static inline void _memcpy_fromio(void *dst, const volatile void __iomem *src, 27 __kernel_size_t n) 28 { 29 char *d = dst; 30 31 while (n--) { 32 char tmp = readb(src); 33 *d++ = tmp; 34 src++; 35 } 36 } 37 38 static inline void _memcpy_toio(volatile void __iomem *dst, const void *src, 39 __kernel_size_t n) 40 { 41 const char *s = src; 42 volatile void __iomem *d = dst; 43 44 while (n--) { 45 char tmp = *s++; 46 writeb(tmp, d); 47 d++; 48 } 49 } 50 51 /* 52 * SBus accessors. 53 * 54 * SBus has only one, memory mapped, I/O space. 55 * We do not need to flip bytes for SBus of course. 56 */ 57 static inline u8 sbus_readb(const volatile void __iomem *addr) 58 { 59 return *(__force volatile u8 *)addr; 60 } 61 62 static inline u16 sbus_readw(const volatile void __iomem *addr) 63 { 64 return *(__force volatile u16 *)addr; 65 } 66 67 static inline u32 sbus_readl(const volatile void __iomem *addr) 68 { 69 return *(__force volatile u32 *)addr; 70 } 71 72 static inline void sbus_writeb(u8 b, volatile void __iomem *addr) 73 { 74 *(__force volatile u8 *)addr = b; 75 } 76 77 static inline void sbus_writew(u16 w, volatile void __iomem *addr) 78 { 79 *(__force volatile u16 *)addr = w; 80 } 81 82 static inline void sbus_writel(u32 l, volatile void __iomem *addr) 83 { 84 *(__force volatile u32 *)addr = l; 85 } 86 87 static inline void sbus_memset_io(volatile void __iomem *__dst, int c, 88 __kernel_size_t n) 89 { 90 while(n--) { 91 sbus_writeb(c, __dst); 92 __dst++; 93 } 94 } 95 96 static inline void sbus_memcpy_fromio(void *dst, 97 const volatile void __iomem *src, 98 __kernel_size_t n) 99 { 100 char *d = dst; 101 102 while (n--) { 103 char tmp = sbus_readb(src); 104 *d++ = tmp; 105 src++; 106 } 107 } 108 109 static inline void sbus_memcpy_toio(volatile void __iomem *dst, 110 const void *src, 111 __kernel_size_t n) 112 { 113 const char *s = src; 114 volatile void __iomem *d = dst; 115 116 while (n--) { 117 char tmp = *s++; 118 sbus_writeb(tmp, d); 119 d++; 120 } 121 } 122 123 #ifdef __KERNEL__ 124 125 /* 126 * Bus number may be embedded in the higher bits of the physical address. 127 * This is why we have no bus number argument to ioremap(). 128 */ 129 void __iomem *ioremap(unsigned long offset, unsigned long size); 130 #define ioremap_nocache(X,Y) ioremap((X),(Y)) 131 #define ioremap_wc(X,Y) ioremap((X),(Y)) 132 #define ioremap_wt(X,Y) ioremap((X),(Y)) 133 void iounmap(volatile void __iomem *addr); 134 135 /* Create a virtual mapping cookie for an IO port range */ 136 void __iomem *ioport_map(unsigned long port, unsigned int nr); 137 void ioport_unmap(void __iomem *); 138 139 /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */ 140 struct pci_dev; 141 void pci_iounmap(struct pci_dev *dev, void __iomem *); 142 143 144 145 /* 146 * At the moment, we do not use CMOS_READ anywhere outside of rtc.c, 147 * so rtc_port is static in it. This should not change unless a new 148 * hardware pops up. 149 */ 150 #define RTC_PORT(x) (rtc_port + (x)) 151 #define RTC_ALWAYS_BCD 0 152 153 static inline int sbus_can_dma_64bit(void) 154 { 155 return 0; /* actually, sparc_cpu_model==sun4d */ 156 } 157 static inline int sbus_can_burst64(void) 158 { 159 return 0; /* actually, sparc_cpu_model==sun4d */ 160 } 161 struct device; 162 void sbus_set_sbus64(struct device *, int); 163 164 #endif 165 166 #define __ARCH_HAS_NO_PAGE_ZERO_MAPPED 1 167 168 169 #endif /* !(__SPARC_IO_H) */ 170