include/asm-sparc64/io.h

   1 /* $Id: io.h,v 1.24 1999/09/06 01:17:54 davem Exp $ */
   2 #ifndef __SPARC64_IO_H
   3 #define __SPARC64_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 #include <asm/asi.h>
  11
  12 /* PC crapola... */
  13 #define __SLOW_DOWN_IO  do { } while (0)
  14 #define SLOW_DOWN_IO    do { } while (0)
  15
  16
  17 #define PCI_DVMA_HASHSZ 256
  18
  19 extern unsigned long pci_dvma_v2p_hash[PCI_DVMA_HASHSZ];
  20 extern unsigned long pci_dvma_p2v_hash[PCI_DVMA_HASHSZ];
  21
  22 #define pci_dvma_ahashfn(addr)  (((addr) >> 24) & 0xff)
  23
  24 extern __inline__ unsigned long virt_to_phys(volatile void *addr)
  25 {
  26         unsigned long vaddr = (unsigned long)addr;
  27         unsigned long off;
  28
  29         /* Handle kernel variable pointers... */
  30         if (vaddr < PAGE_OFFSET)
  31                 vaddr += PAGE_OFFSET - (unsigned long)&empty_zero_page;
  32
  33         off = pci_dvma_v2p_hash[pci_dvma_ahashfn(vaddr - PAGE_OFFSET)];
  34         return vaddr + off;
  35 }
  36
  37 extern __inline__ void *phys_to_virt(unsigned long addr)
  38 {
  39         unsigned long paddr = addr & 0xffffffffUL;
  40         unsigned long off;
  41
  42         off = pci_dvma_p2v_hash[pci_dvma_ahashfn(paddr)];
  43         return (void *)(paddr + off);
  44 }
  45
  46 #define virt_to_bus virt_to_phys
  47 #define bus_to_virt phys_to_virt
  48
  49 /* Different PCI controllers we support have their PCI MEM space
  50  * mapped to an either 2GB (Psycho) or 4GB (Sabre) aligned area,
  51  * so need to chop off the top 33 or 32 bits.
  52  */
  53 extern unsigned long pci_memspace_mask;
  54
  55 #define bus_dvma_to_mem(__vaddr) ((__vaddr) & pci_memspace_mask)
  56
  57 extern __inline__ unsigned int inb(unsigned long addr)
  58 {
  59         unsigned int ret;
  60
  61         __asm__ __volatile__("lduba [%1] %2, %0"
  62                              : "=r" (ret)
  63                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
  64
  65         return ret;
  66 }
  67
  68 extern __inline__ unsigned int inw(unsigned long addr)
  69 {
  70         unsigned int ret;
  71
  72         __asm__ __volatile__("lduha [%1] %2, %0"
  73                              : "=r" (ret)
  74                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
  75
  76         return ret;
  77 }
  78
  79 extern __inline__ unsigned int inl(unsigned long addr)
  80 {
  81         unsigned int ret;
  82
  83         __asm__ __volatile__("lduwa [%1] %2, %0"
  84                              : "=r" (ret)
  85                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
  86
  87         return ret;
  88 }
  89
  90 extern __inline__ void outb(unsigned char b, unsigned long addr)
  91 {
  92         __asm__ __volatile__("stba %0, [%1] %2"
  93                              : /* no outputs */
  94                              : "r" (b), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
  95 }
  96
  97 extern __inline__ void outw(unsigned short w, unsigned long addr)
  98 {
  99         __asm__ __volatile__("stha %0, [%1] %2"
 100                              : /* no outputs */
 101                              : "r" (w), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 102 }
 103
 104 extern __inline__ void outl(unsigned int l, unsigned long addr)
 105 {
 106         __asm__ __volatile__("stwa %0, [%1] %2"
 107                              : /* no outputs */
 108                              : "r" (l), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 109 }
 110
 111 #define inb_p inb
 112 #define outb_p outb
 113
 114 extern void outsb(unsigned long addr, const void *src, unsigned long count);
 115 extern void outsw(unsigned long addr, const void *src, unsigned long count);
 116 extern void outsl(unsigned long addr, const void *src, unsigned long count);
 117 extern void insb(unsigned long addr, void *dst, unsigned long count);
 118 extern void insw(unsigned long addr, void *dst, unsigned long count);
 119 extern void insl(unsigned long addr, void *dst, unsigned long count);
 120
 121 /* Memory functions, same as I/O accesses on Ultra. */
 122 extern __inline__ unsigned int _readb(unsigned long addr)
 123 {
 124         unsigned int ret;
 125
 126         __asm__ __volatile__("lduba [%1] %2, %0"
 127                              : "=r" (ret)
 128                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 129
 130         return ret;
 131 }
 132
 133 extern __inline__ unsigned int _readw(unsigned long addr)
 134 {
 135         unsigned int ret;
 136
 137         __asm__ __volatile__("lduha [%1] %2, %0"
 138                              : "=r" (ret)
 139                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 140
 141         return ret;
 142 }
 143
 144 extern __inline__ unsigned int _readl(unsigned long addr)
 145 {
 146         unsigned int ret;
 147
 148         __asm__ __volatile__("lduwa [%1] %2, %0"
 149                              : "=r" (ret)
 150                              : "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 151
 152         return ret;
 153 }
 154
 155 extern __inline__ void _writeb(unsigned char b, unsigned long addr)
 156 {
 157         __asm__ __volatile__("stba %0, [%1] %2"
 158                              : /* no outputs */
 159                              : "r" (b), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 160 }
 161
 162 extern __inline__ void _writew(unsigned short w, unsigned long addr)
 163 {
 164         __asm__ __volatile__("stha %0, [%1] %2"
 165                              : /* no outputs */
 166                              : "r" (w), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 167 }
 168
 169 extern __inline__ void _writel(unsigned int l, unsigned long addr)
 170 {
 171         __asm__ __volatile__("stwa %0, [%1] %2"
 172                              : /* no outputs */
 173                              : "r" (l), "r" (addr), "i" (ASI_PHYS_BYPASS_EC_E_L));
 174 }
 175
 176 #define readb(__addr)           (_readb((unsigned long)(__addr)))
 177 #define readw(__addr)           (_readw((unsigned long)(__addr)))
 178 #define readl(__addr)           (_readl((unsigned long)(__addr)))
 179 #define writeb(__b, __addr)     (_writeb((__b), (unsigned long)(__addr)))
 180 #define writew(__w, __addr)     (_writew((__w), (unsigned long)(__addr)))
 181 #define writel(__l, __addr)     (_writel((__l), (unsigned long)(__addr)))
 182
 183 /*
 184  * Memcpy to/from I/O space is just a regular memory operation on
 185  * Ultra as well.
 186  */
 187
 188 /*
 189  * FIXME: Write faster routines using ASL_*L for this.
 190  */
 191 static inline void *
 192 memset_io(void *dst, int c, __kernel_size_t n)
 193 {
 194         char *d = dst;
 195
 196         while (n--)
 197                 *d++ = c;
 198
 199         return dst;
 200 }
 201
 202 static inline void *
 203 memcpy_fromio(void *dst, const void *src, __kernel_size_t n)
 204 {
 205         const char *s = src;
 206         char *d = dst;
 207
 208         while (n--)
 209                 *d++ = *s++;
 210
 211         return dst;
 212 }
 213
 214 static inline void *
 215 memcpy_toio(void *dst, const void *src, __kernel_size_t n)
 216 {
 217         const char *s = src;
 218         char *d = dst;
 219
 220         while (n--)
 221                 *d++ = *s++;
 222
 223         return dst;
 224 }
 225
 226 #if 0 /* XXX Not exactly, we need to use ASI_*L from/to the I/O end,
 227        * XXX so these are disabled until we code that stuff.
 228        */
 229 #define eth_io_copy_and_sum(a,b,c,d) eth_copy_and_sum((a),((char *)(b)),(c),(d))
 230 #endif
 231
 232 static inline int check_signature(unsigned long io_addr,
 233                                   const unsigned char *signature,
 234                                   int length)
 235 {
 236         int retval = 0;
 237         do {
 238                 if (readb(io_addr++) != *signature++)
 239                         goto out;
 240         } while (--length);
 241         retval = 1;
 242 out:
 243         return retval;
 244 }
 245
 246 /* On sparc64 we have the whole physical IO address space accessible
 247  * using physically addressed loads and stores, so this does nothing.
 248  */
 249 #define ioremap(__offset, __size)       ((void *)(__offset))
 250 #define iounmap(__addr)                 do { } while(0)
 251
 252 extern void sparc_ultra_mapioaddr(unsigned long physaddr,
 253                                   unsigned long virt_addr,
 254                                   int bus, int rdonly);
 255 extern void sparc_ultra_unmapioaddr(unsigned long virt_addr);
 256
 257 extern __inline__ void mapioaddr(unsigned long physaddr,
 258                                  unsigned long virt_addr,
 259                                  int bus, int rdonly)
 260 {
 261         sparc_ultra_mapioaddr(physaddr, virt_addr, bus, rdonly);
 262 }
 263
 264 extern __inline__ void unmapioaddr(unsigned long virt_addr)
 265 {
 266         sparc_ultra_unmapioaddr(virt_addr);
 267 }
 268
 269 extern void *sparc_alloc_io(u32 pa, void *va, int sz, char *name,
 270                             u32 io, int rdonly);
 271 extern void sparc_free_io (void *va, int sz);
 272 extern void *sparc_dvma_malloc (int sz, char *name, __u32 *dvma_addr);
 273
 274 /* Nothing to do */
 275
 276 #define dma_cache_inv(_start,_size)             do { } while (0)
 277 #define dma_cache_wback(_start,_size)           do { } while (0)
 278 #define dma_cache_wback_inv(_start,_size)       do { } while (0)
 279
 280 #endif /* !(__SPARC64_IO_H) */