Commit | Line | Data |
---|---|---|
1da177e4 LT |
1 | /* |
2 | * arch/m68k/atari/ataints.c -- Atari Linux interrupt handling code | |
3 | * | |
4 | * 5/2/94 Roman Hodek: | |
5 | * Added support for TT interrupts; setup for TT SCU (may someone has | |
6 | * twiddled there and we won't get the right interrupts :-() | |
7 | * | |
8 | * Major change: The device-independent code in m68k/ints.c didn't know | |
9 | * about non-autovec ints yet. It hardcoded the number of possible ints to | |
10 | * 7 (IRQ1...IRQ7). But the Atari has lots of non-autovec ints! I made the | |
11 | * number of possible ints a constant defined in interrupt.h, which is | |
12 | * 47 for the Atari. So we can call request_irq() for all Atari interrupts | |
13 | * just the normal way. Additionally, all vectors >= 48 are initialized to | |
14 | * call trap() instead of inthandler(). This must be changed here, too. | |
15 | * | |
16 | * 1995-07-16 Lars Brinkhoff <f93labr@dd.chalmers.se>: | |
17 | * Corrected a bug in atari_add_isr() which rejected all SCC | |
18 | * interrupt sources if there were no TT MFP! | |
19 | * | |
20 | * 12/13/95: New interface functions atari_level_triggered_int() and | |
21 | * atari_register_vme_int() as support for level triggered VME interrupts. | |
22 | * | |
23 | * 02/12/96: (Roman) | |
24 | * Total rewrite of Atari interrupt handling, for new scheme see comments | |
25 | * below. | |
26 | * | |
27 | * 1996-09-03 lars brinkhoff <f93labr@dd.chalmers.se>: | |
28 | * Added new function atari_unregister_vme_int(), and | |
29 | * modified atari_register_vme_int() as well as IS_VALID_INTNO() | |
30 | * to work with it. | |
31 | * | |
32 | * This file is subject to the terms and conditions of the GNU General Public | |
33 | * License. See the file COPYING in the main directory of this archive | |
34 | * for more details. | |
35 | * | |
36 | */ | |
37 | ||
38 | #include <linux/types.h> | |
39 | #include <linux/kernel.h> | |
40 | #include <linux/kernel_stat.h> | |
41 | #include <linux/init.h> | |
42 | #include <linux/seq_file.h> | |
43 | ||
44 | #include <asm/system.h> | |
45 | #include <asm/traps.h> | |
46 | ||
47 | #include <asm/atarihw.h> | |
48 | #include <asm/atariints.h> | |
49 | #include <asm/atari_stdma.h> | |
50 | #include <asm/irq.h> | |
51 | #include <asm/entry.h> | |
52 | ||
53 | ||
54 | /* | |
55 | * Atari interrupt handling scheme: | |
56 | * -------------------------------- | |
57 | * | |
58 | * All interrupt source have an internal number (defined in | |
59 | * <asm/atariints.h>): Autovector interrupts are 1..7, then follow ST-MFP, | |
60 | * TT-MFP, SCC, and finally VME interrupts. Vector numbers for the latter can | |
61 | * be allocated by atari_register_vme_int(). | |
62 | * | |
63 | * Each interrupt can be of three types: | |
64 | * | |
65 | * - SLOW: The handler runs with all interrupts enabled, except the one it | |
66 | * was called by (to avoid reentering). This should be the usual method. | |
67 | * But it is currently possible only for MFP ints, since only the MFP | |
68 | * offers an easy way to mask interrupts. | |
69 | * | |
70 | * - FAST: The handler runs with all interrupts disabled. This should be used | |
71 | * only for really fast handlers, that just do actions immediately | |
72 | * necessary, and let the rest do a bottom half or task queue. | |
73 | * | |
74 | * - PRIORITIZED: The handler can be interrupted by higher-level ints | |
75 | * (greater IPL, no MFP priorities!). This is the method of choice for ints | |
76 | * which should be slow, but are not from a MFP. | |
77 | * | |
78 | * The feature of more than one handler for one int source is still there, but | |
79 | * only applicable if all handers are of the same type. To not slow down | |
80 | * processing of ints with only one handler by the chaining feature, the list | |
81 | * calling function atari_call_irq_list() is only plugged in at the time the | |
82 | * second handler is registered. | |
83 | * | |
84 | * Implementation notes: For fast-as-possible int handling, there are separate | |
85 | * entry points for each type (slow/fast/prio). The assembler handler calls | |
86 | * the irq directly in the usual case, no C wrapper is involved. In case of | |
87 | * multiple handlers, atari_call_irq_list() is registered as handler and calls | |
88 | * in turn the real irq's. To ease access from assembler level to the irq | |
89 | * function pointer and accompanying data, these two are stored in a separate | |
90 | * array, irq_handler[]. The rest of data (type, name) are put into a second | |
91 | * array, irq_param, that is accessed from C only. For each slow interrupt (32 | |
92 | * in all) there are separate handler functions, which makes it possible to | |
93 | * hard-code the MFP register address and value, are necessary to mask the | |
94 | * int. If there'd be only one generic function, lots of calculations would be | |
95 | * needed to determine MFP register and int mask from the vector number :-( | |
96 | * | |
97 | * Furthermore, slow ints may not lower the IPL below its previous value | |
98 | * (before the int happened). This is needed so that an int of class PRIO, on | |
99 | * that this int may be stacked, cannot be reentered. This feature is | |
100 | * implemented as follows: If the stack frame format is 1 (throwaway), the int | |
101 | * is not stacked, and the IPL is anded with 0xfbff, resulting in a new level | |
102 | * 2, which still blocks the HSYNC, but no interrupts of interest. If the | |
103 | * frame format is 0, the int is nested, and the old IPL value can be found in | |
104 | * the sr copy in the frame. | |
105 | */ | |
106 | ||
73408565 | 107 | #if 0 |
1da177e4 LT |
108 | |
109 | #define NUM_INT_SOURCES (8 + NUM_ATARI_SOURCES) | |
110 | ||
111 | typedef void (*asm_irq_handler)(void); | |
112 | ||
113 | struct irqhandler { | |
114 | irqreturn_t (*handler)(int, void *, struct pt_regs *); | |
115 | void *dev_id; | |
116 | }; | |
117 | ||
118 | struct irqparam { | |
119 | unsigned long flags; | |
120 | const char *devname; | |
121 | }; | |
122 | ||
123 | /* | |
124 | * Array with irq's and their parameter data. This array is accessed from low | |
125 | * level assembler code, so an element size of 8 allows usage of index scaling | |
126 | * addressing mode. | |
127 | */ | |
128 | static struct irqhandler irq_handler[NUM_INT_SOURCES]; | |
129 | ||
130 | /* | |
131 | * This array hold the rest of parameters of int handlers: type | |
132 | * (slow,fast,prio) and the name of the handler. These values are only | |
133 | * accessed from C | |
134 | */ | |
135 | static struct irqparam irq_param[NUM_INT_SOURCES]; | |
136 | ||
1da177e4 LT |
137 | /* check for valid int number (complex, sigh...) */ |
138 | #define IS_VALID_INTNO(n) \ | |
139 | ((n) > 0 && \ | |
140 | /* autovec and ST-MFP ok anyway */ \ | |
141 | (((n) < TTMFP_SOURCE_BASE) || \ | |
142 | /* TT-MFP ok if present */ \ | |
143 | ((n) >= TTMFP_SOURCE_BASE && (n) < SCC_SOURCE_BASE && \ | |
144 | ATARIHW_PRESENT(TT_MFP)) || \ | |
145 | /* SCC ok if present and number even */ \ | |
146 | ((n) >= SCC_SOURCE_BASE && (n) < VME_SOURCE_BASE && \ | |
147 | !((n) & 1) && ATARIHW_PRESENT(SCC)) || \ | |
148 | /* greater numbers ok if they are registered VME vectors */ \ | |
149 | ((n) >= VME_SOURCE_BASE && (n) < VME_SOURCE_BASE + VME_MAX_SOURCES && \ | |
150 | free_vme_vec_bitmap & (1 << ((n) - VME_SOURCE_BASE))))) | |
151 | ||
152 | ||
153 | /* | |
154 | * Here start the assembler entry points for interrupts | |
155 | */ | |
156 | ||
157 | #define IRQ_NAME(nr) atari_slow_irq_##nr##_handler(void) | |
158 | ||
159 | #define BUILD_SLOW_IRQ(n) \ | |
160 | asmlinkage void IRQ_NAME(n); \ | |
161 | /* Dummy function to allow asm with operands. */ \ | |
162 | void atari_slow_irq_##n##_dummy (void) { \ | |
163 | __asm__ (__ALIGN_STR "\n" \ | |
164 | "atari_slow_irq_" #n "_handler:\t" \ | |
165 | " addl %6,%5\n" /* preempt_count() += HARDIRQ_OFFSET */ \ | |
166 | SAVE_ALL_INT "\n" \ | |
167 | GET_CURRENT(%%d0) "\n" \ | |
168 | " andb #~(1<<(%c3&7)),%a4:w\n" /* mask this interrupt */ \ | |
169 | /* get old IPL from stack frame */ \ | |
170 | " bfextu %%sp@(%c2){#5,#3},%%d0\n" \ | |
171 | " movew %%sr,%%d1\n" \ | |
172 | " bfins %%d0,%%d1{#21,#3}\n" \ | |
173 | " movew %%d1,%%sr\n" /* set IPL = previous value */ \ | |
174 | " addql #1,%a0\n" \ | |
175 | " lea %a1,%%a0\n" \ | |
176 | " pea %%sp@\n" /* push addr of frame */ \ | |
177 | " movel %%a0@(4),%%sp@-\n" /* push handler data */ \ | |
178 | " pea (%c3+8)\n" /* push int number */ \ | |
179 | " movel %%a0@,%%a0\n" \ | |
180 | " jbsr %%a0@\n" /* call the handler */ \ | |
181 | " addql #8,%%sp\n" \ | |
182 | " addql #4,%%sp\n" \ | |
183 | " orw #0x0600,%%sr\n" \ | |
184 | " andw #0xfeff,%%sr\n" /* set IPL = 6 again */ \ | |
185 | " orb #(1<<(%c3&7)),%a4:w\n" /* now unmask the int again */ \ | |
186 | " jbra ret_from_interrupt\n" \ | |
187 | : : "i" (&kstat_cpu(0).irqs[n+8]), "i" (&irq_handler[n+8]), \ | |
188 | "n" (PT_OFF_SR), "n" (n), \ | |
189 | "i" (n & 8 ? (n & 16 ? &tt_mfp.int_mk_a : &mfp.int_mk_a) \ | |
190 | : (n & 16 ? &tt_mfp.int_mk_b : &mfp.int_mk_b)), \ | |
191 | "m" (preempt_count()), "di" (HARDIRQ_OFFSET) \ | |
192 | ); \ | |
193 | for (;;); /* fake noreturn */ \ | |
194 | } | |
195 | ||
196 | BUILD_SLOW_IRQ(0); | |
197 | BUILD_SLOW_IRQ(1); | |
198 | BUILD_SLOW_IRQ(2); | |
199 | BUILD_SLOW_IRQ(3); | |
200 | BUILD_SLOW_IRQ(4); | |
201 | BUILD_SLOW_IRQ(5); | |
202 | BUILD_SLOW_IRQ(6); | |
203 | BUILD_SLOW_IRQ(7); | |
204 | BUILD_SLOW_IRQ(8); | |
205 | BUILD_SLOW_IRQ(9); | |
206 | BUILD_SLOW_IRQ(10); | |
207 | BUILD_SLOW_IRQ(11); | |
208 | BUILD_SLOW_IRQ(12); | |
209 | BUILD_SLOW_IRQ(13); | |
210 | BUILD_SLOW_IRQ(14); | |
211 | BUILD_SLOW_IRQ(15); | |
212 | BUILD_SLOW_IRQ(16); | |
213 | BUILD_SLOW_IRQ(17); | |
214 | BUILD_SLOW_IRQ(18); | |
215 | BUILD_SLOW_IRQ(19); | |
216 | BUILD_SLOW_IRQ(20); | |
217 | BUILD_SLOW_IRQ(21); | |
218 | BUILD_SLOW_IRQ(22); | |
219 | BUILD_SLOW_IRQ(23); | |
220 | BUILD_SLOW_IRQ(24); | |
221 | BUILD_SLOW_IRQ(25); | |
222 | BUILD_SLOW_IRQ(26); | |
223 | BUILD_SLOW_IRQ(27); | |
224 | BUILD_SLOW_IRQ(28); | |
225 | BUILD_SLOW_IRQ(29); | |
226 | BUILD_SLOW_IRQ(30); | |
227 | BUILD_SLOW_IRQ(31); | |
228 | ||
229 | asm_irq_handler slow_handlers[32] = { | |
230 | [0] = atari_slow_irq_0_handler, | |
231 | [1] = atari_slow_irq_1_handler, | |
232 | [2] = atari_slow_irq_2_handler, | |
233 | [3] = atari_slow_irq_3_handler, | |
234 | [4] = atari_slow_irq_4_handler, | |
235 | [5] = atari_slow_irq_5_handler, | |
236 | [6] = atari_slow_irq_6_handler, | |
237 | [7] = atari_slow_irq_7_handler, | |
238 | [8] = atari_slow_irq_8_handler, | |
239 | [9] = atari_slow_irq_9_handler, | |
240 | [10] = atari_slow_irq_10_handler, | |
241 | [11] = atari_slow_irq_11_handler, | |
242 | [12] = atari_slow_irq_12_handler, | |
243 | [13] = atari_slow_irq_13_handler, | |
244 | [14] = atari_slow_irq_14_handler, | |
245 | [15] = atari_slow_irq_15_handler, | |
246 | [16] = atari_slow_irq_16_handler, | |
247 | [17] = atari_slow_irq_17_handler, | |
248 | [18] = atari_slow_irq_18_handler, | |
249 | [19] = atari_slow_irq_19_handler, | |
250 | [20] = atari_slow_irq_20_handler, | |
251 | [21] = atari_slow_irq_21_handler, | |
252 | [22] = atari_slow_irq_22_handler, | |
253 | [23] = atari_slow_irq_23_handler, | |
254 | [24] = atari_slow_irq_24_handler, | |
255 | [25] = atari_slow_irq_25_handler, | |
256 | [26] = atari_slow_irq_26_handler, | |
257 | [27] = atari_slow_irq_27_handler, | |
258 | [28] = atari_slow_irq_28_handler, | |
259 | [29] = atari_slow_irq_29_handler, | |
260 | [30] = atari_slow_irq_30_handler, | |
261 | [31] = atari_slow_irq_31_handler | |
262 | }; | |
263 | ||
264 | asmlinkage void atari_fast_irq_handler( void ); | |
265 | asmlinkage void atari_prio_irq_handler( void ); | |
266 | ||
267 | /* Dummy function to allow asm with operands. */ | |
268 | void atari_fast_prio_irq_dummy (void) { | |
269 | __asm__ (__ALIGN_STR "\n" | |
270 | "atari_fast_irq_handler:\n\t" | |
271 | "orw #0x700,%%sr\n" /* disable all interrupts */ | |
272 | "atari_prio_irq_handler:\n\t" | |
273 | "addl %3,%2\n\t" /* preempt_count() += HARDIRQ_OFFSET */ | |
274 | SAVE_ALL_INT "\n\t" | |
275 | GET_CURRENT(%%d0) "\n\t" | |
276 | /* get vector number from stack frame and convert to source */ | |
277 | "bfextu %%sp@(%c1){#4,#10},%%d0\n\t" | |
278 | "subw #(0x40-8),%%d0\n\t" | |
279 | "jpl 1f\n\t" | |
280 | "addw #(0x40-8-0x18),%%d0\n" | |
281 | "1:\tlea %a0,%%a0\n\t" | |
282 | "addql #1,%%a0@(%%d0:l:4)\n\t" | |
283 | "lea irq_handler,%%a0\n\t" | |
284 | "lea %%a0@(%%d0:l:8),%%a0\n\t" | |
285 | "pea %%sp@\n\t" /* push frame address */ | |
286 | "movel %%a0@(4),%%sp@-\n\t" /* push handler data */ | |
287 | "movel %%d0,%%sp@-\n\t" /* push int number */ | |
288 | "movel %%a0@,%%a0\n\t" | |
289 | "jsr %%a0@\n\t" /* and call the handler */ | |
290 | "addql #8,%%sp\n\t" | |
291 | "addql #4,%%sp\n\t" | |
292 | "jbra ret_from_interrupt" | |
293 | : : "i" (&kstat_cpu(0).irqs), "n" (PT_OFF_FORMATVEC), | |
294 | "m" (preempt_count()), "di" (HARDIRQ_OFFSET) | |
295 | ); | |
296 | for (;;); | |
297 | } | |
73408565 RZ |
298 | #endif |
299 | ||
300 | /* | |
301 | * Bitmap for free interrupt vector numbers | |
302 | * (new vectors starting from 0x70 can be allocated by | |
303 | * atari_register_vme_int()) | |
304 | */ | |
305 | static int free_vme_vec_bitmap; | |
1da177e4 LT |
306 | |
307 | /* GK: | |
308 | * HBL IRQ handler for Falcon. Nobody needs it :-) | |
309 | * ++andreas: raise ipl to disable further HBLANK interrupts. | |
310 | */ | |
311 | asmlinkage void falcon_hblhandler(void); | |
312 | asm(".text\n" | |
313 | __ALIGN_STR "\n\t" | |
314 | "falcon_hblhandler:\n\t" | |
315 | "orw #0x200,%sp@\n\t" /* set saved ipl to 2 */ | |
316 | "rte"); | |
317 | ||
73408565 | 318 | extern void atari_microwire_cmd(int cmd); |
1da177e4 LT |
319 | |
320 | extern int atari_SCC_reset_done; | |
321 | ||
73408565 RZ |
322 | static int atari_startup_irq(unsigned int irq) |
323 | { | |
324 | m68k_irq_startup(irq); | |
325 | atari_turnon_irq(irq); | |
326 | atari_enable_irq(irq); | |
327 | return 0; | |
328 | } | |
329 | ||
330 | static void atari_shutdown_irq(unsigned int irq) | |
331 | { | |
332 | atari_disable_irq(irq); | |
333 | atari_turnoff_irq(irq); | |
334 | m68k_irq_shutdown(irq); | |
69961c37 GU |
335 | |
336 | if (irq == IRQ_AUTO_4) | |
337 | vectors[VEC_INT4] = falcon_hblhandler; | |
73408565 RZ |
338 | } |
339 | ||
340 | static struct irq_controller atari_irq_controller = { | |
341 | .name = "atari", | |
342 | .lock = SPIN_LOCK_UNLOCKED, | |
343 | .startup = atari_startup_irq, | |
344 | .shutdown = atari_shutdown_irq, | |
345 | .enable = atari_enable_irq, | |
346 | .disable = atari_disable_irq, | |
347 | }; | |
348 | ||
1da177e4 LT |
349 | /* |
350 | * void atari_init_IRQ (void) | |
351 | * | |
352 | * Parameters: None | |
353 | * | |
354 | * Returns: Nothing | |
355 | * | |
356 | * This function should be called during kernel startup to initialize | |
357 | * the atari IRQ handling routines. | |
358 | */ | |
359 | ||
360 | void __init atari_init_IRQ(void) | |
361 | { | |
69961c37 | 362 | m68k_setup_user_interrupt(VEC_USER, NUM_ATARI_SOURCES - IRQ_USER, NULL); |
73408565 | 363 | m68k_setup_irq_controller(&atari_irq_controller, 1, NUM_ATARI_SOURCES - 1); |
1da177e4 LT |
364 | |
365 | /* Initialize the MFP(s) */ | |
366 | ||
367 | #ifdef ATARI_USE_SOFTWARE_EOI | |
368 | mfp.vec_adr = 0x48; /* Software EOI-Mode */ | |
369 | #else | |
370 | mfp.vec_adr = 0x40; /* Automatic EOI-Mode */ | |
371 | #endif | |
372 | mfp.int_en_a = 0x00; /* turn off MFP-Ints */ | |
373 | mfp.int_en_b = 0x00; | |
374 | mfp.int_mk_a = 0xff; /* no Masking */ | |
375 | mfp.int_mk_b = 0xff; | |
376 | ||
377 | if (ATARIHW_PRESENT(TT_MFP)) { | |
378 | #ifdef ATARI_USE_SOFTWARE_EOI | |
379 | tt_mfp.vec_adr = 0x58; /* Software EOI-Mode */ | |
380 | #else | |
381 | tt_mfp.vec_adr = 0x50; /* Automatic EOI-Mode */ | |
382 | #endif | |
383 | tt_mfp.int_en_a = 0x00; /* turn off MFP-Ints */ | |
384 | tt_mfp.int_en_b = 0x00; | |
385 | tt_mfp.int_mk_a = 0xff; /* no Masking */ | |
386 | tt_mfp.int_mk_b = 0xff; | |
387 | } | |
388 | ||
389 | if (ATARIHW_PRESENT(SCC) && !atari_SCC_reset_done) { | |
390 | scc.cha_a_ctrl = 9; | |
391 | MFPDELAY(); | |
392 | scc.cha_a_ctrl = (char) 0xc0; /* hardware reset */ | |
393 | } | |
394 | ||
395 | if (ATARIHW_PRESENT(SCU)) { | |
396 | /* init the SCU if present */ | |
397 | tt_scu.sys_mask = 0x10; /* enable VBL (for the cursor) and | |
398 | * disable HSYNC interrupts (who | |
399 | * needs them?) MFP and SCC are | |
400 | * enabled in VME mask | |
401 | */ | |
402 | tt_scu.vme_mask = 0x60; /* enable MFP and SCC ints */ | |
73408565 | 403 | } else { |
1da177e4 LT |
404 | /* If no SCU and no Hades, the HSYNC interrupt needs to be |
405 | * disabled this way. (Else _inthandler in kernel/sys_call.S | |
406 | * gets overruns) | |
407 | */ | |
408 | ||
69961c37 | 409 | if (!MACH_IS_HADES) { |
1da177e4 | 410 | vectors[VEC_INT2] = falcon_hblhandler; |
69961c37 GU |
411 | vectors[VEC_INT4] = falcon_hblhandler; |
412 | } | |
1da177e4 LT |
413 | } |
414 | ||
415 | if (ATARIHW_PRESENT(PCM_8BIT) && ATARIHW_PRESENT(MICROWIRE)) { | |
416 | /* Initialize the LM1992 Sound Controller to enable | |
417 | the PSG sound. This is misplaced here, it should | |
418 | be in an atasound_init(), that doesn't exist yet. */ | |
419 | atari_microwire_cmd(MW_LM1992_PSG_HIGH); | |
420 | } | |
421 | ||
422 | stdma_init(); | |
423 | ||
424 | /* Initialize the PSG: all sounds off, both ports output */ | |
425 | sound_ym.rd_data_reg_sel = 7; | |
426 | sound_ym.wd_data = 0xff; | |
427 | } | |
428 | ||
429 | ||
1da177e4 LT |
430 | /* |
431 | * atari_register_vme_int() returns the number of a free interrupt vector for | |
432 | * hardware with a programmable int vector (probably a VME board). | |
433 | */ | |
434 | ||
435 | unsigned long atari_register_vme_int(void) | |
436 | { | |
437 | int i; | |
438 | ||
73408565 RZ |
439 | for (i = 0; i < 32; i++) |
440 | if ((free_vme_vec_bitmap & (1 << i)) == 0) | |
1da177e4 LT |
441 | break; |
442 | ||
73408565 | 443 | if (i == 16) |
1da177e4 LT |
444 | return 0; |
445 | ||
446 | free_vme_vec_bitmap |= 1 << i; | |
73408565 | 447 | return VME_SOURCE_BASE + i; |
1da177e4 LT |
448 | } |
449 | ||
450 | ||
451 | void atari_unregister_vme_int(unsigned long irq) | |
452 | { | |
73408565 | 453 | if (irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) { |
1da177e4 LT |
454 | irq -= VME_SOURCE_BASE; |
455 | free_vme_vec_bitmap &= ~(1 << irq); | |
456 | } | |
457 | } | |
458 | ||
459 |