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