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
337IOPORT(b, 8)
338IOPORT(w, 16)
339IOPORT(l, 32)
340IOPORT(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 */
364