LXR linux/arch/sparc/include/asm/io

   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
  15static 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
  26static 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
  38static 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 */
  57static inline u8 sbus_readb(const volatile void __iomem *addr)
  58{
  59        return *(__force volatile u8 *)addr;
  60}
  61
  62static inline u16 sbus_readw(const volatile void __iomem *addr)
  63{
  64        return *(__force volatile u16 *)addr;
  65}
  66
  67static inline u32 sbus_readl(const volatile void __iomem *addr)
  68{
  69        return *(__force volatile u32 *)addr;
  70}
  71
  72static inline void sbus_writeb(u8 b, volatile void __iomem *addr)
  73{
  74        *(__force volatile u8 *)addr = b;
  75}
  76
  77static inline void sbus_writew(u16 w, volatile void __iomem *addr)
  78{
  79        *(__force volatile u16 *)addr = w;
  80}
  81
  82static inline void sbus_writel(u32 l, volatile void __iomem *addr)
  83{
  84        *(__force volatile u32 *)addr = l;
  85}
  86
  87static 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
  96static 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
 109static 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 */
 129void __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))
 133void iounmap(volatile void __iomem *addr);
 134
 135/* Create a virtual mapping cookie for an IO port range */
 136void __iomem *ioport_map(unsigned long port, unsigned int nr);
 137void ioport_unmap(void __iomem *);
 138
 139/* Create a virtual mapping cookie for a PCI BAR (memory or IO) */
 140struct pci_dev;
 141void 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
 153static inline int sbus_can_dma_64bit(void)
 154{
 155        return 0; /* actually, sparc_cpu_model==sun4d */
 156}
 157static inline int sbus_can_burst64(void)
 158{
 159        return 0; /* actually, sparc_cpu_model==sun4d */
 160}
 161struct device;
 162void 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