]>
Commit | Line | Data |
---|---|---|
b2441318 | 1 | // SPDX-License-Identifier: GPL-2.0 |
1da177e4 LT |
2 | /* |
3 | * linux/arch/alpha/kernel/sys_takara.c | |
4 | * | |
5 | * Copyright (C) 1995 David A Rusling | |
6 | * Copyright (C) 1996 Jay A Estabrook | |
7 | * Copyright (C) 1998, 1999 Richard Henderson | |
8 | * | |
9 | * Code supporting the TAKARA. | |
10 | */ | |
11 | ||
12 | #include <linux/kernel.h> | |
13 | #include <linux/types.h> | |
14 | #include <linux/mm.h> | |
15 | #include <linux/sched.h> | |
16 | #include <linux/pci.h> | |
17 | #include <linux/init.h> | |
18 | ||
19 | #include <asm/ptrace.h> | |
1da177e4 LT |
20 | #include <asm/dma.h> |
21 | #include <asm/irq.h> | |
22 | #include <asm/mmu_context.h> | |
23 | #include <asm/io.h> | |
24 | #include <asm/pgtable.h> | |
25 | #include <asm/core_cia.h> | |
26 | #include <asm/tlbflush.h> | |
27 | ||
28 | #include "proto.h" | |
29 | #include "irq_impl.h" | |
30 | #include "pci_impl.h" | |
31 | #include "machvec_impl.h" | |
59b25ed9 | 32 | #include "pc873xx.h" |
1da177e4 LT |
33 | |
34 | /* Note mask bit is true for DISABLED irqs. */ | |
35 | static unsigned long cached_irq_mask[2] = { -1, -1 }; | |
36 | ||
37 | static inline void | |
38 | takara_update_irq_hw(unsigned long irq, unsigned long mask) | |
39 | { | |
40 | int regaddr; | |
41 | ||
42 | mask = (irq >= 64 ? mask << 16 : mask >> ((irq - 16) & 0x30)); | |
43 | regaddr = 0x510 + (((irq - 16) >> 2) & 0x0c); | |
44 | outl(mask & 0xffff0000UL, regaddr); | |
45 | } | |
46 | ||
47 | static inline void | |
b148c614 | 48 | takara_enable_irq(struct irq_data *d) |
1da177e4 | 49 | { |
b148c614 | 50 | unsigned int irq = d->irq; |
1da177e4 LT |
51 | unsigned long mask; |
52 | mask = (cached_irq_mask[irq >= 64] &= ~(1UL << (irq & 63))); | |
53 | takara_update_irq_hw(irq, mask); | |
54 | } | |
55 | ||
56 | static void | |
b148c614 | 57 | takara_disable_irq(struct irq_data *d) |
1da177e4 | 58 | { |
b148c614 | 59 | unsigned int irq = d->irq; |
1da177e4 LT |
60 | unsigned long mask; |
61 | mask = (cached_irq_mask[irq >= 64] |= 1UL << (irq & 63)); | |
62 | takara_update_irq_hw(irq, mask); | |
63 | } | |
64 | ||
44377f62 | 65 | static struct irq_chip takara_irq_type = { |
8ab1221c | 66 | .name = "TAKARA", |
b148c614 TG |
67 | .irq_unmask = takara_enable_irq, |
68 | .irq_mask = takara_disable_irq, | |
69 | .irq_mask_ack = takara_disable_irq, | |
1da177e4 LT |
70 | }; |
71 | ||
72 | static void | |
7ca56053 | 73 | takara_device_interrupt(unsigned long vector) |
1da177e4 LT |
74 | { |
75 | unsigned intstatus; | |
76 | ||
77 | /* | |
78 | * The PALcode will have passed us vectors 0x800 or 0x810, | |
79 | * which are fairly arbitrary values and serve only to tell | |
80 | * us whether an interrupt has come in on IRQ0 or IRQ1. If | |
81 | * it's IRQ1 it's a PCI interrupt; if it's IRQ0, it's | |
82 | * probably ISA, but PCI interrupts can come through IRQ0 | |
83 | * as well if the interrupt controller isn't in accelerated | |
84 | * mode. | |
85 | * | |
86 | * OTOH, the accelerator thing doesn't seem to be working | |
87 | * overly well, so what we'll do instead is try directly | |
88 | * examining the Master Interrupt Register to see if it's a | |
89 | * PCI interrupt, and if _not_ then we'll pass it on to the | |
90 | * ISA handler. | |
91 | */ | |
92 | ||
93 | intstatus = inw(0x500) & 15; | |
94 | if (intstatus) { | |
95 | /* | |
96 | * This is a PCI interrupt. Check each bit and | |
97 | * despatch an interrupt if it's set. | |
98 | */ | |
99 | ||
3dbb8c62 AV |
100 | if (intstatus & 8) handle_irq(16+3); |
101 | if (intstatus & 4) handle_irq(16+2); | |
102 | if (intstatus & 2) handle_irq(16+1); | |
103 | if (intstatus & 1) handle_irq(16+0); | |
1da177e4 | 104 | } else { |
7ca56053 | 105 | isa_device_interrupt (vector); |
1da177e4 LT |
106 | } |
107 | } | |
108 | ||
109 | static void | |
7ca56053 | 110 | takara_srm_device_interrupt(unsigned long vector) |
1da177e4 LT |
111 | { |
112 | int irq = (vector - 0x800) >> 4; | |
3dbb8c62 | 113 | handle_irq(irq); |
1da177e4 LT |
114 | } |
115 | ||
116 | static void __init | |
117 | takara_init_irq(void) | |
118 | { | |
119 | long i; | |
120 | ||
121 | init_i8259a_irqs(); | |
122 | ||
123 | if (alpha_using_srm) { | |
124 | alpha_mv.device_interrupt = takara_srm_device_interrupt; | |
125 | } else { | |
126 | unsigned int ctlreg = inl(0x500); | |
127 | ||
128 | /* Return to non-accelerated mode. */ | |
129 | ctlreg &= ~0x8000; | |
130 | outl(ctlreg, 0x500); | |
131 | ||
132 | /* Enable the PCI interrupt register. */ | |
133 | ctlreg = 0x05107c00; | |
134 | outl(ctlreg, 0x500); | |
135 | } | |
136 | ||
137 | for (i = 16; i < 128; i += 16) | |
138 | takara_update_irq_hw(i, -1); | |
139 | ||
140 | for (i = 16; i < 128; ++i) { | |
a9eb076b TG |
141 | irq_set_chip_and_handler(i, &takara_irq_type, |
142 | handle_level_irq); | |
b148c614 | 143 | irq_set_status_flags(i, IRQ_LEVEL); |
1da177e4 LT |
144 | } |
145 | ||
146 | common_init_isa_dma(); | |
147 | } | |
148 | ||
149 | ||
150 | /* | |
151 | * The Takara has PCI devices 1, 2, and 3 configured to slots 20, | |
152 | * 19, and 18 respectively, in the default configuration. They can | |
153 | * also be jumpered to slots 8, 7, and 6 respectively, which is fun | |
154 | * because the SIO ISA bridge can also be slot 7. However, the SIO | |
155 | * doesn't explicitly generate PCI-type interrupts, so we can | |
156 | * assign it whatever the hell IRQ we like and it doesn't matter. | |
157 | */ | |
158 | ||
159 | static int __init | |
d5341942 | 160 | takara_map_irq_srm(const struct pci_dev *dev, u8 slot, u8 pin) |
1da177e4 LT |
161 | { |
162 | static char irq_tab[15][5] __initdata = { | |
163 | { 16+3, 16+3, 16+3, 16+3, 16+3}, /* slot 6 == device 3 */ | |
164 | { 16+2, 16+2, 16+2, 16+2, 16+2}, /* slot 7 == device 2 */ | |
165 | { 16+1, 16+1, 16+1, 16+1, 16+1}, /* slot 8 == device 1 */ | |
166 | { -1, -1, -1, -1, -1}, /* slot 9 == nothing */ | |
167 | { -1, -1, -1, -1, -1}, /* slot 10 == nothing */ | |
168 | { -1, -1, -1, -1, -1}, /* slot 11 == nothing */ | |
169 | /* These are behind the bridges. */ | |
170 | { 12, 12, 13, 14, 15}, /* slot 12 == nothing */ | |
171 | { 8, 8, 9, 19, 11}, /* slot 13 == nothing */ | |
172 | { 4, 4, 5, 6, 7}, /* slot 14 == nothing */ | |
173 | { 0, 0, 1, 2, 3}, /* slot 15 == nothing */ | |
174 | { -1, -1, -1, -1, -1}, /* slot 16 == nothing */ | |
175 | {64+ 0, 64+0, 64+1, 64+2, 64+3}, /* slot 17= device 4 */ | |
176 | {48+ 0, 48+0, 48+1, 48+2, 48+3}, /* slot 18= device 3 */ | |
177 | {32+ 0, 32+0, 32+1, 32+2, 32+3}, /* slot 19= device 2 */ | |
178 | {16+ 0, 16+0, 16+1, 16+2, 16+3}, /* slot 20= device 1 */ | |
179 | }; | |
180 | const long min_idsel = 6, max_idsel = 20, irqs_per_slot = 5; | |
181 | int irq = COMMON_TABLE_LOOKUP; | |
182 | if (irq >= 0 && irq < 16) { | |
183 | /* Guess that we are behind a bridge. */ | |
184 | unsigned int busslot = PCI_SLOT(dev->bus->self->devfn); | |
185 | irq += irq_tab[busslot-min_idsel][0]; | |
186 | } | |
187 | return irq; | |
188 | } | |
189 | ||
190 | static int __init | |
d5341942 | 191 | takara_map_irq(const struct pci_dev *dev, u8 slot, u8 pin) |
1da177e4 LT |
192 | { |
193 | static char irq_tab[15][5] __initdata = { | |
194 | { 16+3, 16+3, 16+3, 16+3, 16+3}, /* slot 6 == device 3 */ | |
195 | { 16+2, 16+2, 16+2, 16+2, 16+2}, /* slot 7 == device 2 */ | |
196 | { 16+1, 16+1, 16+1, 16+1, 16+1}, /* slot 8 == device 1 */ | |
197 | { -1, -1, -1, -1, -1}, /* slot 9 == nothing */ | |
198 | { -1, -1, -1, -1, -1}, /* slot 10 == nothing */ | |
199 | { -1, -1, -1, -1, -1}, /* slot 11 == nothing */ | |
200 | { -1, -1, -1, -1, -1}, /* slot 12 == nothing */ | |
201 | { -1, -1, -1, -1, -1}, /* slot 13 == nothing */ | |
202 | { -1, -1, -1, -1, -1}, /* slot 14 == nothing */ | |
203 | { -1, -1, -1, -1, -1}, /* slot 15 == nothing */ | |
204 | { -1, -1, -1, -1, -1}, /* slot 16 == nothing */ | |
205 | { -1, -1, -1, -1, -1}, /* slot 17 == nothing */ | |
206 | { 16+3, 16+3, 16+3, 16+3, 16+3}, /* slot 18 == device 3 */ | |
207 | { 16+2, 16+2, 16+2, 16+2, 16+2}, /* slot 19 == device 2 */ | |
208 | { 16+1, 16+1, 16+1, 16+1, 16+1}, /* slot 20 == device 1 */ | |
209 | }; | |
210 | const long min_idsel = 6, max_idsel = 20, irqs_per_slot = 5; | |
211 | return COMMON_TABLE_LOOKUP; | |
212 | } | |
213 | ||
214 | static u8 __init | |
215 | takara_swizzle(struct pci_dev *dev, u8 *pinp) | |
216 | { | |
217 | int slot = PCI_SLOT(dev->devfn); | |
218 | int pin = *pinp; | |
219 | unsigned int ctlreg = inl(0x500); | |
220 | unsigned int busslot; | |
221 | ||
222 | if (!dev->bus->self) | |
223 | return slot; | |
224 | ||
225 | busslot = PCI_SLOT(dev->bus->self->devfn); | |
226 | /* Check for built-in bridges. */ | |
227 | if (dev->bus->number != 0 | |
228 | && busslot > 16 | |
229 | && ((1<<(36-busslot)) & ctlreg)) { | |
230 | if (pin == 1) | |
231 | pin += (20 - busslot); | |
232 | else { | |
233 | printk(KERN_WARNING "takara_swizzle: can only " | |
234 | "handle cards with INTA IRQ pin.\n"); | |
235 | } | |
236 | } else { | |
237 | /* Must be a card-based bridge. */ | |
238 | printk(KERN_WARNING "takara_swizzle: cannot handle " | |
239 | "card-bridge behind builtin bridge yet.\n"); | |
240 | } | |
241 | ||
242 | *pinp = pin; | |
243 | return slot; | |
244 | } | |
245 | ||
246 | static void __init | |
247 | takara_init_pci(void) | |
248 | { | |
249 | if (alpha_using_srm) | |
250 | alpha_mv.pci_map_irq = takara_map_irq_srm; | |
251 | ||
252 | cia_init_pci(); | |
59b25ed9 ML |
253 | |
254 | if (pc873xx_probe() == -1) { | |
255 | printk(KERN_ERR "Probing for PC873xx Super IO chip failed.\n"); | |
256 | } else { | |
257 | printk(KERN_INFO "Found %s Super IO chip at 0x%x\n", | |
258 | pc873xx_get_model(), pc873xx_get_base()); | |
259 | pc873xx_enable_ide(); | |
260 | } | |
1da177e4 LT |
261 | } |
262 | ||
263 | ||
264 | /* | |
265 | * The System Vector | |
266 | */ | |
267 | ||
268 | struct alpha_machine_vector takara_mv __initmv = { | |
269 | .vector_name = "Takara", | |
270 | DO_EV5_MMU, | |
271 | DO_DEFAULT_RTC, | |
272 | DO_CIA_IO, | |
273 | .machine_check = cia_machine_check, | |
274 | .max_isa_dma_address = ALPHA_MAX_ISA_DMA_ADDRESS, | |
275 | .min_io_address = DEFAULT_IO_BASE, | |
276 | .min_mem_address = CIA_DEFAULT_MEM_BASE, | |
277 | ||
278 | .nr_irqs = 128, | |
279 | .device_interrupt = takara_device_interrupt, | |
280 | ||
281 | .init_arch = cia_init_arch, | |
282 | .init_irq = takara_init_irq, | |
283 | .init_rtc = common_init_rtc, | |
284 | .init_pci = takara_init_pci, | |
285 | .kill_arch = cia_kill_arch, | |
286 | .pci_map_irq = takara_map_irq, | |
287 | .pci_swizzle = takara_swizzle, | |
288 | }; | |
289 | ALIAS_MV(takara) |