arch/mips/sni/io.c

   1 /* $Id: io.c,v 1.4 1999/08/18 23:37:46 ralf Exp $
   2  *
   3  * This file is subject to the terms and conditions of the GNU General Public
   4  * License.  See the file "COPYING" in the main directory of this archive
   5  * for more details.
   6  *
   7  * Low level I/O functions for SNI.
   8  */
   9 #include <linux/string.h>
  10 #include <linux/spinlock.h>
  11 #include <asm/addrspace.h>
  12 #include <asm/system.h>
  13 #include <asm/sni.h>
  14
  15 /*
  16  * Urgs...  We only can see a 16mb window of the 4gb EISA address space
  17  * at PCIMT_EISA_BASE.  Maladia segmentitis ...
  18  *
  19  * To avoid locking and all the related headacke we implement this such
  20  * that accessing the bus address space nests, so we're treating this
  21  * correctly even for interrupts.  This is going to suck seriously for
  22  * the SMP members of the RM family.
  23  *
  24  * Making things worse the PCIMT_CSMAPISA register resides on the X bus with
  25  * it's unbeatable 1.4 mb/s transfer rate.
  26  */
  27
  28 static inline void eisa_map(unsigned long address)
  29 {
  30         unsigned char upper;
  31
  32         upper = address >> 24;
  33         *(volatile unsigned char *)PCIMT_CSMAPISA = ~upper;
  34 }
  35
  36 #define save_eisa_map()                                                 \
  37         (*(volatile unsigned char *)PCIMT_CSMAPISA)
  38 #define restore_eisa_map(val)                                           \
  39         do { (*(volatile unsigned char *)PCIMT_CSMAPISA) = val; } while(0)
  40
  41 static unsigned char sni_readb(unsigned long addr)
  42 {
  43         unsigned char res;
  44         unsigned int save_map;
  45
  46         save_map = save_eisa_map();
  47         eisa_map(addr);
  48         addr &= 0xffffff;
  49         res = *(volatile unsigned char *) (PCIMT_EISA_BASE + addr);
  50         restore_eisa_map(save_map);
  51
  52         return res;
  53 }
  54
  55 static unsigned short sni_readw(unsigned long addr)
  56 {
  57         unsigned short res;
  58         unsigned int save_map;
  59
  60         save_map = save_eisa_map();
  61         eisa_map(addr);
  62         addr &= 0xffffff;
  63         res = *(volatile unsigned char *) (PCIMT_EISA_BASE + addr);
  64         restore_eisa_map(save_map);
  65
  66         return res;
  67 }
  68
  69 static unsigned int sni_readl(unsigned long addr)
  70 {
  71         unsigned int res;
  72         unsigned int save_map;
  73
  74         save_map = save_eisa_map();
  75         eisa_map(addr);
  76         addr &= 0xffffff;
  77         res = *(volatile unsigned char *) (PCIMT_EISA_BASE + addr);
  78         restore_eisa_map(save_map);
  79
  80         return res;
  81 }
  82
  83 static void sni_writeb(unsigned char val, unsigned long addr)
  84 {
  85         unsigned int save_map;
  86
  87         save_map = save_eisa_map();
  88         eisa_map(addr);
  89         addr &= 0xffffff;
  90         *(volatile unsigned char *) (PCIMT_EISA_BASE + addr) = val;
  91         restore_eisa_map(save_map);
  92 }
  93
  94 static void sni_writew(unsigned short val, unsigned long addr)
  95 {
  96         unsigned int save_map;
  97
  98         save_map = save_eisa_map();
  99         eisa_map(addr);
 100         addr &= 0xffffff;
 101         *(volatile unsigned char *) (PCIMT_EISA_BASE + addr) = val;
 102         restore_eisa_map(save_map);
 103 }
 104
 105 static void sni_writel(unsigned int val, unsigned long addr)
 106 {
 107         unsigned int save_map;
 108
 109         save_map = save_eisa_map();
 110         eisa_map(addr);
 111         addr &= 0xffffff;
 112         *(volatile unsigned char *) (PCIMT_EISA_BASE + addr) = val;
 113         restore_eisa_map(save_map);
 114 }
 115
 116 static void sni_memset_io(unsigned long addr, int val, unsigned long len)
 117 {
 118         unsigned long waddr;
 119         unsigned int save_map;
 120
 121         save_map = save_eisa_map();
 122         waddr = PCIMT_EISA_BASE | (addr & 0xffffff);
 123         while(len) {
 124                 unsigned long fraglen;
 125
 126                 fraglen = (~addr + 1) & 0xffffff;
 127                 fraglen = (fraglen < len) ? fraglen : len;
 128                 eisa_map(addr);
 129                 memset((char *)waddr, val, fraglen);
 130                 addr += fraglen;
 131                 waddr = waddr + fraglen - 0x1000000;
 132                 len -= fraglen;
 133         }
 134         restore_eisa_map(save_map);
 135 }
 136
 137 static void sni_memcpy_fromio(unsigned long to, unsigned long from, unsigned long len)
 138 {
 139         unsigned long waddr;
 140         unsigned int save_map;
 141
 142         save_map = save_eisa_map();
 143         waddr = PCIMT_EISA_BASE | (from & 0xffffff);
 144         while(len) {
 145                 unsigned long fraglen;
 146
 147                 fraglen = (~from + 1) & 0xffffff;
 148                 fraglen = (fraglen < len) ? fraglen : len;
 149                 eisa_map(from);
 150                 memcpy((void *)to, (void *)waddr, fraglen);
 151                 to += fraglen;
 152                 from += fraglen;
 153                 waddr = waddr + fraglen - 0x1000000;
 154                 len -= fraglen;
 155         }
 156         restore_eisa_map(save_map);
 157 }
 158
 159 static void sni_memcpy_toio(unsigned long to, unsigned long from, unsigned long len)
 160 {
 161         unsigned long waddr;
 162         unsigned int save_map;
 163
 164         save_map = save_eisa_map();
 165         waddr = PCIMT_EISA_BASE | (to & 0xffffff);
 166         while(len) {
 167                 unsigned long fraglen;
 168
 169                 fraglen = (~to + 1) & 0xffffff;
 170                 fraglen = (fraglen < len) ? fraglen : len;
 171                 eisa_map(to);
 172                 memcpy((char *)to + PCIMT_EISA_BASE, (void *)from, fraglen);
 173                 to += fraglen;
 174                 from += fraglen;
 175                 waddr = waddr + fraglen - 0x1000000;
 176                 len -= fraglen;
 177         }
 178         restore_eisa_map(save_map);
 179 }