arch/alpha/include/asm/jensen.h

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