include/asm-alpha/jensen.h

   1 #ifndef __ALPHA_JENSEN_H
   2 #define __ALPHA_JENSEN_H
   3
   4 #include <asm/compiler.h>
   5
   6 /*
   7  * Defines for the AlphaPC EISA IO and memory address space.
   8  */
   9
  10 /* The Jensen is strange */
  11 #define AUX_IRQ (9)
  12
  13 /*
  14  * NOTE! The memory operations do not set any memory barriers, as it's
  15  * not needed for cases like a frame buffer that is essentially memory-like.
  16  * You need to do them by hand if the operations depend on ordering.
  17  *
  18  * Similarly, the port IO operations do a "mb" only after a write operation:
  19  * if an mb is needed before (as in the case of doing memory mapped IO
  20  * first, and then a port IO operation to the same device), it needs to be
  21  * done by hand.
  22  *
  23  * After the above has bitten me 100 times, I'll give up and just do the
  24  * mb all the time, but right now I'm hoping this will work out.  Avoiding
  25  * mb's may potentially be a noticeable speed improvement, but I can't
  26  * honestly say I've tested it.
  27  *
  28  * Handling interrupts that need to do mb's to synchronize to non-interrupts
  29  * is another fun race area.  Don't do it (because if you do, I'll have to
  30  * do *everything* with interrupts disabled, ugh).
  31  */
  32
  33 /*
  34  * EISA Interrupt Acknowledge address
  35  */
  36 #define EISA_INTA               (IDENT_ADDR + 0x100000000UL)
  37
  38 /*
  39  * FEPROM addresses
  40  */
  41 #define EISA_FEPROM0            (IDENT_ADDR + 0x180000000UL)
  42 #define EISA_FEPROM1            (IDENT_ADDR + 0x1A0000000UL)
  43
  44 /*
  45  * VL82C106 base address
  46  */
  47 #define EISA_VL82C106           (IDENT_ADDR + 0x1C0000000UL)
  48
  49 /*
  50  * EISA "Host Address Extension" address (bits 25-31 of the EISA address)
  51  */
  52 #define EISA_HAE                (IDENT_ADDR + 0x1D0000000UL)
  53
  54 /*
  55  * "SYSCTL" register address
  56  */
  57 #define EISA_SYSCTL             (IDENT_ADDR + 0x1E0000000UL)
  58
  59 /*
  60  * "spare" register address
  61  */
  62 #define EISA_SPARE              (IDENT_ADDR + 0x1F0000000UL)
  63
  64 /*
  65  * EISA memory address offset
  66  */
  67 #define EISA_MEM                (IDENT_ADDR + 0x200000000UL)
  68
  69 /*
  70  * EISA IO address offset
  71  */
  72 #define EISA_IO                 (IDENT_ADDR + 0x300000000UL)
  73
  74
  75 #ifdef __KERNEL__
  76
  77 #ifndef __EXTERN_INLINE
  78 #define __EXTERN_INLINE extern inline
  79 #define __IO_EXTERN_INLINE
  80 #endif
  81
  82 /*
  83  * Change virtual addresses to bus addresses and vv.
  84  *
  85  * NOTE! On the Jensen, the physical address is the same
  86  * as the bus address, but this is not necessarily true on
  87  * other alpha hardware.
  88  */
  89 __EXTERN_INLINE unsigned long jensen_virt_to_bus(void * address)
  90 {
  91         return virt_to_phys(address);
  92 }
  93
  94 __EXTERN_INLINE void * jensen_bus_to_virt(unsigned long address)
  95 {
  96         return phys_to_virt(address);
  97 }
  98
  99
 100 /*
 101  * Handle the "host address register". This needs to be set
 102  * to the high 7 bits of the EISA address.  This is also needed
 103  * for EISA IO addresses, which are only 16 bits wide (the
 104  * hae needs to be set to 0).
 105  *
 106  * HAE isn't needed for the local IO operations, though.
 107  */
 108
 109 #define JENSEN_HAE_ADDRESS      EISA_HAE
 110 #define JENSEN_HAE_MASK         0x1ffffff
 111
 112 __EXTERN_INLINE void jensen_set_hae(unsigned long addr)
 113 {
 114         /* hae on the Jensen is bits 31:25 shifted right */
 115         addr >>= 25;
 116         if (addr != alpha_mv.hae_cache)
 117                 set_hae(addr);
 118 }
 119
 120 #define vuip    volatile unsigned int *
 121
 122 /*
 123  * IO functions
 124  *
 125  * The "local" functions are those that don't go out to the EISA bus,
 126  * but instead act on the VL82C106 chip directly.. This is mainly the
 127  * keyboard, RTC,  printer and first two serial lines..
 128  *
 129  * The local stuff makes for some complications, but it seems to be
 130  * gone in the PCI version. I hope I can get DEC suckered^H^H^H^H^H^H^H^H
 131  * convinced that I need one of the newer machines.
 132  */
 133
 134 static inline unsigned int jensen_local_inb(unsigned long addr)
 135 {
 136         return 0xff & *(vuip)((addr << 9) + EISA_VL82C106);
 137 }
 138
 139 static inline void jensen_local_outb(unsigned char b, unsigned long addr)
 140 {
 141         *(vuip)((addr << 9) + EISA_VL82C106) = b;
 142         mb();
 143 }
 144
 145 static inline unsigned int jensen_bus_inb(unsigned long addr)
 146 {
 147         long result;
 148
 149         jensen_set_hae(0);
 150         result = *(volatile int *)((addr << 7) + EISA_IO + 0x00);
 151         return __kernel_extbl(result, addr & 3);
 152 }
 153
 154 static inline void jensen_bus_outb(unsigned char b, unsigned long addr)
 155 {
 156         jensen_set_hae(0);
 157         *(vuip)((addr << 7) + EISA_IO + 0x00) = b * 0x01010101;
 158         mb();
 159 }
 160
 161 /*
 162  * It seems gcc is not very good at optimizing away logical
 163  * operations that result in operations across inline functions.
 164  * Which is why this is a macro.
 165  */
 166
 167 #define jensen_is_local(addr) ( \
 168 /* keyboard */  (addr == 0x60 || addr == 0x64) || \
 169 /* RTC */       (addr == 0x170 || addr == 0x171) || \
 170 /* mb COM2 */   (addr >= 0x2f8 && addr <= 0x2ff) || \
 171 /* mb LPT1 */   (addr >= 0x3bc && addr <= 0x3be) || \
 172 /* mb COM2 */   (addr >= 0x3f8 && addr <= 0x3ff))
 173
 174 __EXTERN_INLINE unsigned int jensen_inb(unsigned long addr)
 175 {
 176         if (jensen_is_local(addr))
 177                 return jensen_local_inb(addr);
 178         else
 179                 return jensen_bus_inb(addr);
 180 }
 181
 182 __EXTERN_INLINE void jensen_outb(unsigned char b, unsigned long addr)
 183 {
 184         if (jensen_is_local(addr))
 185                 jensen_local_outb(b, addr);
 186         else
 187                 jensen_bus_outb(b, addr);
 188 }
 189
 190 __EXTERN_INLINE unsigned int jensen_inw(unsigned long addr)
 191 {
 192         long result;
 193
 194         jensen_set_hae(0);
 195         result = *(volatile int *) ((addr << 7) + EISA_IO + 0x20);
 196         result >>= (addr & 3) * 8;
 197         return 0xffffUL & result;
 198 }
 199
 200 __EXTERN_INLINE unsigned int jensen_inl(unsigned long addr)
 201 {
 202         jensen_set_hae(0);
 203         return *(vuip) ((addr << 7) + EISA_IO + 0x60);
 204 }
 205
 206 __EXTERN_INLINE void jensen_outw(unsigned short b, unsigned long addr)
 207 {
 208         jensen_set_hae(0);
 209         *(vuip) ((addr << 7) + EISA_IO + 0x20) = b * 0x00010001;
 210         mb();
 211 }
 212
 213 __EXTERN_INLINE void jensen_outl(unsigned int b, unsigned long addr)
 214 {
 215         jensen_set_hae(0);
 216         *(vuip) ((addr << 7) + EISA_IO + 0x60) = b;
 217         mb();
 218 }
 219
 220 /*
 221  * Memory functions.
 222  */
 223
 224 __EXTERN_INLINE unsigned long jensen_readb(unsigned long addr)
 225 {
 226         long result;
 227
 228         jensen_set_hae(addr);
 229         addr &= JENSEN_HAE_MASK;
 230         result = *(volatile int *) ((addr << 7) + EISA_MEM + 0x00);
 231         result >>= (addr & 3) * 8;
 232         return 0xffUL & result;
 233 }
 234
 235 __EXTERN_INLINE unsigned long jensen_readw(unsigned long addr)
 236 {
 237         long result;
 238
 239         jensen_set_hae(addr);
 240         addr &= JENSEN_HAE_MASK;
 241         result = *(volatile int *) ((addr << 7) + EISA_MEM + 0x20);
 242         result >>= (addr & 3) * 8;
 243         return 0xffffUL & result;
 244 }
 245
 246 __EXTERN_INLINE unsigned long jensen_readl(unsigned long addr)
 247 {
 248         jensen_set_hae(addr);
 249         addr &= JENSEN_HAE_MASK;
 250         return *(vuip) ((addr << 7) + EISA_MEM + 0x60);
 251 }
 252
 253 __EXTERN_INLINE unsigned long jensen_readq(unsigned long addr)
 254 {
 255         unsigned long r0, r1;
 256
 257         jensen_set_hae(addr);
 258         addr &= JENSEN_HAE_MASK;
 259         addr = (addr << 7) + EISA_MEM + 0x60;
 260         r0 = *(vuip) (addr);
 261         r1 = *(vuip) (addr + (4 << 7));
 262         return r1 << 32 | r0;
 263 }
 264
 265 __EXTERN_INLINE void jensen_writeb(unsigned char b, unsigned long addr)
 266 {
 267         jensen_set_hae(addr);
 268         addr &= JENSEN_HAE_MASK;
 269         *(vuip) ((addr << 7) + EISA_MEM + 0x00) = b * 0x01010101;
 270 }
 271
 272 __EXTERN_INLINE void jensen_writew(unsigned short b, unsigned long addr)
 273 {
 274         jensen_set_hae(addr);
 275         addr &= JENSEN_HAE_MASK;
 276         *(vuip) ((addr << 7) + EISA_MEM + 0x20) = b * 0x00010001;
 277 }
 278
 279 __EXTERN_INLINE void jensen_writel(unsigned int b, unsigned long addr)
 280 {
 281         jensen_set_hae(addr);
 282         addr &= JENSEN_HAE_MASK;
 283         *(vuip) ((addr << 7) + EISA_MEM + 0x60) = b;
 284 }
 285
 286 __EXTERN_INLINE void jensen_writeq(unsigned long b, unsigned long addr)
 287 {
 288         jensen_set_hae(addr);
 289         addr &= JENSEN_HAE_MASK;
 290         addr = (addr << 7) + EISA_MEM + 0x60;
 291         *(vuip) (addr) = b;
 292         *(vuip) (addr + (4 << 7)) = b >> 32;
 293 }
 294
 295 /* Find the DENSE memory area for a given bus address.
 296    Whee, there is none.  */
 297
 298 __EXTERN_INLINE unsigned long jensen_dense_mem(unsigned long addr)
 299 {
 300         return 0;
 301 }
 302
 303 #undef vuip
 304
 305 #ifdef __WANT_IO_DEF
 306
 307 #define virt_to_bus     jensen_virt_to_bus
 308 #define bus_to_virt     jensen_bus_to_virt
 309 #define __inb           jensen_inb
 310 #define __inw           jensen_inw
 311 #define __inl           jensen_inl
 312 #define __outb          jensen_outb
 313 #define __outw          jensen_outw
 314 #define __outl          jensen_outl
 315 #define __readb         jensen_readb
 316 #define __readw         jensen_readw
 317 #define __writeb        jensen_writeb
 318 #define __writew        jensen_writew
 319 #define __readl         jensen_readl
 320 #define __readq         jensen_readq
 321 #define __writel        jensen_writel
 322 #define __writeq        jensen_writeq
 323 #define dense_mem       jensen_dense_mem
 324
 325 /*
 326  * The above have so much overhead that it probably doesn't make
 327  * sense to have them inlined (better icache behaviour).
 328  */
 329 #define inb(port) \
 330 (__builtin_constant_p((port))?__inb(port):_inb(port))
 331
 332 #define outb(x, port) \
 333 (__builtin_constant_p((port))?__outb((x),(port)):_outb((x),(port)))
 334
 335 #endif /* __WANT_IO_DEF */
 336
 337 #ifdef __IO_EXTERN_INLINE
 338 #undef __EXTERN_INLINE
 339 #undef __IO_EXTERN_INLINE
 340 #endif
 341
 342 #endif /* __KERNEL__ */
 343
 344 #endif /* __ALPHA_JENSEN_H */