include/asm-ia64/sn/io.h

   1 /*
   2  * This file is subject to the terms and conditions of the GNU General Public
   3  * License.  See the file "COPYING" in the main directory of this archive
   4  * for more details.
   5  *
   6  * Copyright (C) 2000-2004 Silicon Graphics, Inc. All rights reserved.
   7  */
   8
   9 #ifndef _ASM_SN_IO_H
  10 #define _ASM_SN_IO_H
  11 #include <linux/compiler.h>
  12 #include <asm/intrinsics.h>
  13
  14 extern void * sn_io_addr(unsigned long port) __attribute_const__; /* Forward definition */
  15 extern void __sn_mmiowb(void); /* Forward definition */
  16
  17 extern int numionodes;
  18
  19 #define __sn_mf_a()   ia64_mfa()
  20
  21 extern void sn_dma_flush(unsigned long);
  22
  23 #define __sn_inb ___sn_inb
  24 #define __sn_inw ___sn_inw
  25 #define __sn_inl ___sn_inl
  26 #define __sn_outb ___sn_outb
  27 #define __sn_outw ___sn_outw
  28 #define __sn_outl ___sn_outl
  29 #define __sn_readb ___sn_readb
  30 #define __sn_readw ___sn_readw
  31 #define __sn_readl ___sn_readl
  32 #define __sn_readq ___sn_readq
  33 #define __sn_readb_relaxed ___sn_readb_relaxed
  34 #define __sn_readw_relaxed ___sn_readw_relaxed
  35 #define __sn_readl_relaxed ___sn_readl_relaxed
  36 #define __sn_readq_relaxed ___sn_readq_relaxed
  37
  38 /*
  39  * The following routines are SN Platform specific, called when
  40  * a reference is made to inX/outX set macros.  SN Platform
  41  * inX set of macros ensures that Posted DMA writes on the
  42  * Bridge is flushed.
  43  *
  44  * The routines should be self explainatory.
  45  */
  46
  47 static inline unsigned int
  48 ___sn_inb (unsigned long port)
  49 {
  50         volatile unsigned char *addr;
  51         unsigned char ret = -1;
  52
  53         if ((addr = sn_io_addr(port))) {
  54                 ret = *addr;
  55                 __sn_mf_a();
  56                 sn_dma_flush((unsigned long)addr);
  57         }
  58         return ret;
  59 }
  60
  61 static inline unsigned int
  62 ___sn_inw (unsigned long port)
  63 {
  64         volatile unsigned short *addr;
  65         unsigned short ret = -1;
  66
  67         if ((addr = sn_io_addr(port))) {
  68                 ret = *addr;
  69                 __sn_mf_a();
  70                 sn_dma_flush((unsigned long)addr);
  71         }
  72         return ret;
  73 }
  74
  75 static inline unsigned int
  76 ___sn_inl (unsigned long port)
  77 {
  78         volatile unsigned int *addr;
  79         unsigned int ret = -1;
  80
  81         if ((addr = sn_io_addr(port))) {
  82                 ret = *addr;
  83                 __sn_mf_a();
  84                 sn_dma_flush((unsigned long)addr);
  85         }
  86         return ret;
  87 }
  88
  89 static inline void
  90 ___sn_outb (unsigned char val, unsigned long port)
  91 {
  92         volatile unsigned char *addr;
  93
  94         if ((addr = sn_io_addr(port))) {
  95                 *addr = val;
  96                 __sn_mmiowb();
  97         }
  98 }
  99
 100 static inline void
 101 ___sn_outw (unsigned short val, unsigned long port)
 102 {
 103         volatile unsigned short *addr;
 104
 105         if ((addr = sn_io_addr(port))) {
 106                 *addr = val;
 107                 __sn_mmiowb();
 108         }
 109 }
 110
 111 static inline void
 112 ___sn_outl (unsigned int val, unsigned long port)
 113 {
 114         volatile unsigned int *addr;
 115
 116         if ((addr = sn_io_addr(port))) {
 117                 *addr = val;
 118                 __sn_mmiowb();
 119         }
 120 }
 121
 122 /*
 123  * The following routines are SN Platform specific, called when
 124  * a reference is made to readX/writeX set macros.  SN Platform
 125  * readX set of macros ensures that Posted DMA writes on the
 126  * Bridge is flushed.
 127  *
 128  * The routines should be self explainatory.
 129  */
 130
 131 static inline unsigned char
 132 ___sn_readb (const volatile void __iomem *addr)
 133 {
 134         unsigned char val;
 135
 136         val = *(volatile unsigned char __force *)addr;
 137         __sn_mf_a();
 138         sn_dma_flush((unsigned long)addr);
 139         return val;
 140 }
 141
 142 static inline unsigned short
 143 ___sn_readw (const volatile void __iomem *addr)
 144 {
 145         unsigned short val;
 146
 147         val = *(volatile unsigned short __force *)addr;
 148         __sn_mf_a();
 149         sn_dma_flush((unsigned long)addr);
 150         return val;
 151 }
 152
 153 static inline unsigned int
 154 ___sn_readl (const volatile void __iomem *addr)
 155 {
 156         unsigned int val;
 157
 158         val = *(volatile unsigned int __force *)addr;
 159         __sn_mf_a();
 160         sn_dma_flush((unsigned long)addr);
 161         return val;
 162 }
 163
 164 static inline unsigned long
 165 ___sn_readq (const volatile void __iomem *addr)
 166 {
 167         unsigned long val;
 168
 169         val = *(volatile unsigned long __force *)addr;
 170         __sn_mf_a();
 171         sn_dma_flush((unsigned long)addr);
 172         return val;
 173 }
 174
 175 /*
 176  * For generic and SN2 kernels, we have a set of fast access
 177  * PIO macros.  These macros are provided on SN Platform
 178  * because the normal inX and readX macros perform an
 179  * additional task of flushing Post DMA request on the Bridge.
 180  *
 181  * These routines should be self explainatory.
 182  */
 183
 184 static inline unsigned int
 185 sn_inb_fast (unsigned long port)
 186 {
 187         volatile unsigned char *addr = (unsigned char *)port;
 188         unsigned char ret;
 189
 190         ret = *addr;
 191         __sn_mf_a();
 192         return ret;
 193 }
 194
 195 static inline unsigned int
 196 sn_inw_fast (unsigned long port)
 197 {
 198         volatile unsigned short *addr = (unsigned short *)port;
 199         unsigned short ret;
 200
 201         ret = *addr;
 202         __sn_mf_a();
 203         return ret;
 204 }
 205
 206 static inline unsigned int
 207 sn_inl_fast (unsigned long port)
 208 {
 209         volatile unsigned int *addr = (unsigned int *)port;
 210         unsigned int ret;
 211
 212         ret = *addr;
 213         __sn_mf_a();
 214         return ret;
 215 }
 216
 217 static inline unsigned char
 218 ___sn_readb_relaxed (const volatile void __iomem *addr)
 219 {
 220         return *(volatile unsigned char __force *)addr;
 221 }
 222
 223 static inline unsigned short
 224 ___sn_readw_relaxed (const volatile void __iomem *addr)
 225 {
 226         return *(volatile unsigned short __force *)addr;
 227 }
 228
 229 static inline unsigned int
 230 ___sn_readl_relaxed (const volatile void __iomem *addr)
 231 {
 232         return *(volatile unsigned int __force *) addr;
 233 }
 234
 235 static inline unsigned long
 236 ___sn_readq_relaxed (const volatile void __iomem *addr)
 237 {
 238         return *(volatile unsigned long __force *) addr;
 239 }
 240
 241 struct pci_dev;
 242
 243 static inline int
 244 sn_pci_set_vchan(struct pci_dev *pci_dev, unsigned long *addr, int vchan)
 245 {
 246
 247         if (vchan > 1) {
 248                 return -1;
 249         }
 250
 251         if (!(*addr >> 32))     /* Using a mask here would be cleaner */
 252                 return 0;       /* but this generates better code */
 253
 254         if (vchan == 1) {
 255                 /* Set Bit 57 */
 256                 *addr |= (1UL << 57);
 257         } else {
 258                 /* Clear Bit 57 */
 259                 *addr &= ~(1UL << 57);
 260         }
 261
 262         return 0;
 263 }
 264
 265 #endif  /* _ASM_SN_IO_H */