1 #ifndef __ALPHA_JENSEN_H
2 #define __ALPHA_JENSEN_H
4 #include <asm/compiler.h>
7 * Defines for the AlphaPC EISA IO and memory address space.
11 * NOTE! The memory operations do not set any memory barriers, as it's
12 * not needed for cases like a frame buffer that is essentially memory-like.
13 * You need to do them by hand if the operations depend on ordering.
15 * Similarly, the port IO operations do a "mb" only after a write operation:
16 * if an mb is needed before (as in the case of doing memory mapped IO
17 * first, and then a port IO operation to the same device), it needs to be
20 * After the above has bitten me 100 times, I'll give up and just do the
21 * mb all the time, but right now I'm hoping this will work out. Avoiding
22 * mb's may potentially be a noticeable speed improvement, but I can't
23 * honestly say I've tested it.
25 * Handling interrupts that need to do mb's to synchronize to non-interrupts
26 * is another fun race area. Don't do it (because if you do, I'll have to
27 * do *everything* with interrupts disabled, ugh).
31 * EISA Interrupt Acknowledge address
33 #define EISA_INTA (IDENT_ADDR + 0x100000000UL)
38 #define EISA_FEPROM0 (IDENT_ADDR + 0x180000000UL)
39 #define EISA_FEPROM1 (IDENT_ADDR + 0x1A0000000UL)
42 * VL82C106 base address
44 #define EISA_VL82C106 (IDENT_ADDR + 0x1C0000000UL)
47 * EISA "Host Address Extension" address (bits 25-31 of the EISA address)
49 #define EISA_HAE (IDENT_ADDR + 0x1D0000000UL)
52 * "SYSCTL" register address
54 #define EISA_SYSCTL (IDENT_ADDR + 0x1E0000000UL)
57 * "spare" register address
59 #define EISA_SPARE (IDENT_ADDR + 0x1F0000000UL)
62 * EISA memory address offset
64 #define EISA_MEM (IDENT_ADDR + 0x200000000UL)
67 * EISA IO address offset
69 #define EISA_IO (IDENT_ADDR + 0x300000000UL)
74 #ifndef __EXTERN_INLINE
75 #define __EXTERN_INLINE extern inline
76 #define __IO_EXTERN_INLINE
80 * Handle the "host address register". This needs to be set
81 * to the high 7 bits of the EISA address. This is also needed
82 * for EISA IO addresses, which are only 16 bits wide (the
83 * hae needs to be set to 0).
85 * HAE isn't needed for the local IO operations, though.
88 #define JENSEN_HAE_ADDRESS EISA_HAE
89 #define JENSEN_HAE_MASK 0x1ffffff
91 __EXTERN_INLINE void jensen_set_hae(unsigned long addr)
93 /* hae on the Jensen is bits 31:25 shifted right */
95 if (addr != alpha_mv.hae_cache)
99 #define vuip volatile unsigned int *
104 * The "local" functions are those that don't go out to the EISA bus,
105 * but instead act on the VL82C106 chip directly.. This is mainly the
106 * keyboard, RTC, printer and first two serial lines..
108 * The local stuff makes for some complications, but it seems to be
109 * gone in the PCI version. I hope I can get DEC suckered^H^H^H^H^H^H^H^H
110 * convinced that I need one of the newer machines.
113 static inline unsigned int jensen_local_inb(unsigned long addr)
115 return 0xff & *(vuip)((addr << 9) + EISA_VL82C106);
118 static inline void jensen_local_outb(u8 b, unsigned long addr)
120 *(vuip)((addr << 9) + EISA_VL82C106) = b;
124 static inline unsigned int jensen_bus_inb(unsigned long addr)
129 result = *(volatile int *)((addr << 7) + EISA_IO + 0x00);
130 return __kernel_extbl(result, addr & 3);
133 static inline void jensen_bus_outb(u8 b, unsigned long addr)
136 *(vuip)((addr << 7) + EISA_IO + 0x00) = b * 0x01010101;
141 * It seems gcc is not very good at optimizing away logical
142 * operations that result in operations across inline functions.
143 * Which is why this is a macro.
146 #define jensen_is_local(addr) ( \
147 /* keyboard */ (addr == 0x60 || addr == 0x64) || \
148 /* RTC */ (addr == 0x170 || addr == 0x171) || \
149 /* mb COM2 */ (addr >= 0x2f8 && addr <= 0x2ff) || \
150 /* mb LPT1 */ (addr >= 0x3bc && addr <= 0x3be) || \
151 /* mb COM2 */ (addr >= 0x3f8 && addr <= 0x3ff))
153 __EXTERN_INLINE u8 jensen_inb(unsigned long addr)
155 if (jensen_is_local(addr))
156 return jensen_local_inb(addr);
158 return jensen_bus_inb(addr);
161 __EXTERN_INLINE void jensen_outb(u8 b, unsigned long addr)
163 if (jensen_is_local(addr))
164 jensen_local_outb(b, addr);
166 jensen_bus_outb(b, addr);
169 __EXTERN_INLINE u16 jensen_inw(unsigned long addr)
174 result = *(volatile int *) ((addr << 7) + EISA_IO + 0x20);
175 result >>= (addr & 3) * 8;
176 return 0xffffUL & result;
179 __EXTERN_INLINE u32 jensen_inl(unsigned long addr)
182 return *(vuip) ((addr << 7) + EISA_IO + 0x60);
185 __EXTERN_INLINE void jensen_outw(u16 b, unsigned long addr)
188 *(vuip) ((addr << 7) + EISA_IO + 0x20) = b * 0x00010001;
192 __EXTERN_INLINE void jensen_outl(u32 b, unsigned long addr)
195 *(vuip) ((addr << 7) + EISA_IO + 0x60) = b;
203 __EXTERN_INLINE u8 jensen_readb(unsigned long addr)
207 jensen_set_hae(addr);
208 addr &= JENSEN_HAE_MASK;
209 result = *(volatile int *) ((addr << 7) + EISA_MEM + 0x00);
210 result >>= (addr & 3) * 8;
211 return 0xffUL & result;
214 __EXTERN_INLINE u16 jensen_readw(unsigned long addr)
218 jensen_set_hae(addr);
219 addr &= JENSEN_HAE_MASK;
220 result = *(volatile int *) ((addr << 7) + EISA_MEM + 0x20);
221 result >>= (addr & 3) * 8;
222 return 0xffffUL & result;
225 __EXTERN_INLINE u32 jensen_readl(unsigned long addr)
227 jensen_set_hae(addr);
228 addr &= JENSEN_HAE_MASK;
229 return *(vuip) ((addr << 7) + EISA_MEM + 0x60);
232 __EXTERN_INLINE u64 jensen_readq(unsigned long addr)
234 unsigned long r0, r1;
236 jensen_set_hae(addr);
237 addr &= JENSEN_HAE_MASK;
238 addr = (addr << 7) + EISA_MEM + 0x60;
240 r1 = *(vuip) (addr + (4 << 7));
241 return r1 << 32 | r0;
244 __EXTERN_INLINE void jensen_writeb(u8 b, unsigned long addr)
246 jensen_set_hae(addr);
247 addr &= JENSEN_HAE_MASK;
248 *(vuip) ((addr << 7) + EISA_MEM + 0x00) = b * 0x01010101;
251 __EXTERN_INLINE void jensen_writew(u16 b, unsigned long addr)
253 jensen_set_hae(addr);
254 addr &= JENSEN_HAE_MASK;
255 *(vuip) ((addr << 7) + EISA_MEM + 0x20) = b * 0x00010001;
258 __EXTERN_INLINE void jensen_writel(u32 b, unsigned long addr)
260 jensen_set_hae(addr);
261 addr &= JENSEN_HAE_MASK;
262 *(vuip) ((addr << 7) + EISA_MEM + 0x60) = b;
265 __EXTERN_INLINE void jensen_writeq(u64 b, unsigned long addr)
267 jensen_set_hae(addr);
268 addr &= JENSEN_HAE_MASK;
269 addr = (addr << 7) + EISA_MEM + 0x60;
271 *(vuip) (addr + (4 << 7)) = b >> 32;
274 __EXTERN_INLINE unsigned long jensen_ioremap(unsigned long addr,
280 __EXTERN_INLINE void jensen_iounmap(unsigned long addr)
285 __EXTERN_INLINE int jensen_is_ioaddr(unsigned long addr)
287 return (long)addr >= 0;
294 #define __inb jensen_inb
295 #define __inw jensen_inw
296 #define __inl jensen_inl
297 #define __outb jensen_outb
298 #define __outw jensen_outw
299 #define __outl jensen_outl
300 #define __readb jensen_readb
301 #define __readw jensen_readw
302 #define __writeb jensen_writeb
303 #define __writew jensen_writew
304 #define __readl jensen_readl
305 #define __readq jensen_readq
306 #define __writel jensen_writel
307 #define __writeq jensen_writeq
308 #define __ioremap jensen_ioremap
309 #define __iounmap(a) jensen_iounmap((unsigned long)a)
310 #define __is_ioaddr jensen_is_ioaddr
313 * The above have so much overhead that it probably doesn't make
314 * sense to have them inlined (better icache behaviour).
317 (__builtin_constant_p((port))?__inb(port):_inb(port))
319 #define outb(x, port) \
320 (__builtin_constant_p((port))?__outb((x),(port)):_outb((x),(port)))
322 #endif /* __WANT_IO_DEF */
324 #ifdef __IO_EXTERN_INLINE
325 #undef __EXTERN_INLINE
326 #undef __IO_EXTERN_INLINE
329 #endif /* __KERNEL__ */
331 #endif /* __ALPHA_JENSEN_H */