include/asm-sparc/io.h

   1 /* $Id: io.h,v 1.19 1999/05/14 07:26:09 davem Exp $ */
   2 #ifndef __SPARC_IO_H
   3 #define __SPARC_IO_H
   4
   5 #include <linux/kernel.h>
   6 #include <linux/types.h>
   7
   8 #include <asm/page.h>      /* IO address mapping routines need this */
   9 #include <asm/system.h>
  10
  11 /*
  12  * Defines for io operations on the Sparc. Whether a memory access is going
  13  * to i/o sparc is encoded in the pte. The type bits determine whether this
  14  * is i/o sparc, on board memory, or VME space for VME cards. I think VME
  15  * space only works on sun4's
  16  */
  17
  18 #define virt_to_bus virt_to_phys
  19
  20 extern __inline__ unsigned  flip_dword (unsigned d) {
  21         return ((d&0xff)<<24) | (((d>>8)&0xff)<<16) | (((d>>16)&0xff)<<8)| ((d>>24)&0xff);
  22 }
  23
  24 extern __inline__ unsigned short flip_word (unsigned short d) {
  25         return ((d&0xff) << 8) | ((d>>8)&0xff);
  26 }
  27
  28 extern __inline__ unsigned long readb(unsigned long addr)
  29 {
  30        return *(volatile unsigned char*)addr;
  31 }
  32
  33 extern __inline__ unsigned long readw(unsigned long addr)
  34 {
  35        return flip_word(*(volatile unsigned short*)addr);
  36 }
  37
  38 extern __inline__ unsigned long readl(unsigned long addr)
  39 {
  40        return flip_dword(*(volatile unsigned long*)addr);
  41 }
  42
  43 extern __inline__ void writeb(unsigned short b, unsigned long addr)
  44 {
  45        *(volatile unsigned char*)addr = b;
  46 }
  47
  48 extern __inline__ void writew(unsigned short b, unsigned long addr)
  49 {
  50        *(volatile unsigned short*)addr = flip_word(b);
  51 }
  52
  53 extern __inline__ void writel(unsigned int b, unsigned long addr)
  54 {
  55         *(volatile unsigned long*)addr = flip_dword(b);
  56 }
  57
  58 extern __inline__ unsigned long inb_local(unsigned long addr)
  59 {
  60        return readb(addr);
  61 }
  62
  63 extern __inline__ void outb_local(unsigned char b, unsigned long addr)
  64 {
  65        return writeb(b,addr);
  66 }
  67
  68 extern __inline__ unsigned long inb(unsigned long addr)
  69 {
  70        return readb(addr);
  71 }
  72
  73 extern __inline__ unsigned long inw(unsigned long addr)
  74 {
  75        return readw(addr);
  76 }
  77
  78 extern __inline__ unsigned long inl(unsigned long addr)
  79 {
  80        return readl(addr);
  81 }
  82
  83 extern __inline__ void outb(unsigned char b, unsigned long addr)
  84 {
  85        return writeb(b,addr);
  86 }
  87
  88 extern __inline__ void outw(unsigned short b, unsigned long addr)
  89 {
  90        return writew(b,addr);
  91 }
  92
  93 extern __inline__ void outl(unsigned int b, unsigned long addr)
  94 {
  95        return writel(b,addr);
  96 }
  97
  98 #define inb_p inb
  99 #define outb_p outb
 100
 101 extern void sun4c_mapioaddr(unsigned long, unsigned long, int bus_type, int rdonly);
 102 extern void srmmu_mapioaddr(unsigned long, unsigned long, int bus_type, int rdonly);
 103
 104 extern __inline__ void mapioaddr(unsigned long physaddr, unsigned long virt_addr,
 105                                  int bus, int rdonly)
 106 {
 107         switch(sparc_cpu_model) {
 108         case sun4c:
 109         case sun4:
 110                 sun4c_mapioaddr(physaddr, virt_addr, bus, rdonly);
 111                 break;
 112         case sun4m:
 113         case sun4d:
 114         case sun4e:
 115                 srmmu_mapioaddr(physaddr, virt_addr, bus, rdonly);
 116                 break;
 117         default:
 118                 printk("mapioaddr: Trying to map IO space for unsupported machine.\n");
 119                 printk("mapioaddr: sparc_cpu_model = %d\n", sparc_cpu_model);
 120                 printk("mapioaddr: Halting...\n");
 121                 halt();
 122         };
 123         return;
 124 }
 125
 126 extern void srmmu_unmapioaddr(unsigned long virt);
 127 extern void sun4c_unmapioaddr(unsigned long virt);
 128
 129 extern __inline__ void unmapioaddr(unsigned long virt_addr)
 130 {
 131         switch(sparc_cpu_model) {
 132         case sun4c:
 133         case sun4:
 134                 sun4c_unmapioaddr(virt_addr);
 135                 break;
 136         case sun4m:
 137         case sun4d:
 138         case sun4e:
 139                 srmmu_unmapioaddr(virt_addr);
 140                 break;
 141         default:
 142                 printk("unmapioaddr: sparc_cpu_model = %d, halt...\n", sparc_cpu_model);
 143                 halt();
 144         };
 145         return;
 146 }
 147
 148 extern void *sparc_alloc_io (u32 pa, void *va, int sz, char *name, u32 io, int rdonly);
 149 extern void sparc_free_io (void *vaddr, int sz);
 150 extern void *_sparc_dvma_malloc (int sz, char *name);
 151
 152 /* Returns CPU visible address, dvmaaddr_p is a pointer to where
 153  * the DVMA visible (ie. SBUS/PSYCO+PCI) address should be stored.
 154  */
 155 static __inline__ void *sparc_dvma_malloc(int size, char *name, __u32 *dvmaaddr_p)
 156 {
 157         void *cpuaddr = _sparc_dvma_malloc(size, name);
 158         *dvmaaddr_p = (__u32) cpuaddr;
 159         return cpuaddr;
 160 }
 161
 162 #define virt_to_phys(x) __pa((unsigned long)(x))
 163 #define phys_to_virt(x) __va((unsigned long)(x))
 164
 165 /* Nothing to do */
 166
 167 #define dma_cache_inv(_start,_size)             do { } while (0)
 168 #define dma_cache_wback(_start,_size)           do { } while (0)
 169 #define dma_cache_wback_inv(_start,_size)       do { } while (0)
 170
 171 #endif /* !(__SPARC_IO_H) */