kernel/arch/sparc/include/asm/io_32.h

   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 void iounmap(volatile void __iomem *addr);
 133
 134 /* Create a virtual mapping cookie for an IO port range */
 135 void __iomem *ioport_map(unsigned long port, unsigned int nr);
 136 void ioport_unmap(void __iomem *);
 137
 138 /* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
 139 struct pci_dev;
 140 void pci_iounmap(struct pci_dev *dev, void __iomem *);
 141
 142
 143
 144 /*
 145  * At the moment, we do not use CMOS_READ anywhere outside of rtc.c,
 146  * so rtc_port is static in it. This should not change unless a new
 147  * hardware pops up.
 148  */
 149 #define RTC_PORT(x)   (rtc_port + (x))
 150 #define RTC_ALWAYS_BCD  0
 151
 152 static inline int sbus_can_dma_64bit(void)
 153 {
 154         return 0; /* actually, sparc_cpu_model==sun4d */
 155 }
 156 static inline int sbus_can_burst64(void)
 157 {
 158         return 0; /* actually, sparc_cpu_model==sun4d */
 159 }
 160 struct device;
 161 void sbus_set_sbus64(struct device *, int);
 162
 163 #endif
 164
 165 #define __ARCH_HAS_NO_PAGE_ZERO_MAPPED          1
 166
 167
 168 #endif /* !(__SPARC_IO_H) */