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#include <linux/module.h> 44 45#include <asm/system.h> 46#include <asm/traps.h> 47 48#include <asm/atarihw.h> 49#include <asm/atariints.h> 50#include <asm/atari_stdma.h> 51#include <asm/irq.h> 52#include <asm/entry.h> 53 54 55/* 56 * Atari interrupt handling scheme: 57 * -------------------------------- 58 * 59 * All interrupt source have an internal number (defined in 60 * <asm/atariints.h>): Autovector interrupts are 1..7, then follow ST-MFP, 61 * TT-MFP, SCC, and finally VME interrupts. Vector numbers for the latter can 62 * be allocated by atari_register_vme_int(). 63 * 64 * Each interrupt can be of three types: 65 * 66 * - SLOW: The handler runs with all interrupts enabled, except the one it 67 * was called by (to avoid reentering). This should be the usual method. 68 * But it is currently possible only for MFP ints, since only the MFP 69 * offers an easy way to mask interrupts. 70 * 71 * - FAST: The handler runs with all interrupts disabled. This should be used 72 * only for really fast handlers, that just do actions immediately 73 * necessary, and let the rest do a bottom half or task queue. 74 * 75 * - PRIORITIZED: The handler can be interrupted by higher-level ints 76 * (greater IPL, no MFP priorities!). This is the method of choice for ints 77 * which should be slow, but are not from a MFP. 78 * 79 * The feature of more than one handler for one int source is still there, but 80 * only applicable if all handers are of the same type. To not slow down 81 * processing of ints with only one handler by the chaining feature, the list 82 * calling function atari_call_irq_list() is only plugged in at the time the 83 * second handler is registered. 84 * 85 * Implementation notes: For fast-as-possible int handling, there are separate 86 * entry points for each type (slow/fast/prio). The assembler handler calls 87 * the irq directly in the usual case, no C wrapper is involved. In case of 88 * multiple handlers, atari_call_irq_list() is registered as handler and calls 89 * in turn the real irq's. To ease access from assembler level to the irq 90 * function pointer and accompanying data, these two are stored in a separate 91 * array, irq_handler[]. The rest of data (type, name) are put into a second 92 * array, irq_param, that is accessed from C only. For each slow interrupt (32 93 * in all) there are separate handler functions, which makes it possible to 94 * hard-code the MFP register address and value, are necessary to mask the 95 * int. If there'd be only one generic function, lots of calculations would be 96 * needed to determine MFP register and int mask from the vector number :-( 97 * 98 * Furthermore, slow ints may not lower the IPL below its previous value 99 * (before the int happened). This is needed so that an int of class PRIO, on 100 * that this int may be stacked, cannot be reentered. This feature is 101 * implemented as follows: If the stack frame format is 1 (throwaway), the int 102 * is not stacked, and the IPL is anded with 0xfbff, resulting in a new level 103 * 2, which still blocks the HSYNC, but no interrupts of interest. If the 104 * frame format is 0, the int is nested, and the old IPL value can be found in 105 * the sr copy in the frame. 106 */ 107 108 109/* 110 * Bitmap for free interrupt vector numbers 111 * (new vectors starting from 0x70 can be allocated by 112 * atari_register_vme_int()) 113 */ 114static int free_vme_vec_bitmap; 115 116/* GK: 117 * HBL IRQ handler for Falcon. Nobody needs it :-) 118 * ++andreas: raise ipl to disable further HBLANK interrupts. 119 */ 120asmlinkage void falcon_hblhandler(void); 121asm(".text\n" 122__ALIGN_STR "\n\t" 123"falcon_hblhandler:\n\t" 124 "orw #0x200,%sp@\n\t" /* set saved ipl to 2 */ 125 "rte"); 126 127extern void atari_microwire_cmd(int cmd); 128 129extern int atari_SCC_reset_done; 130 131static int atari_startup_irq(unsigned int irq) 132{ 133 m68k_irq_startup(irq); 134 atari_turnon_irq(irq); 135 atari_enable_irq(irq); 136 return 0; 137} 138 139static void atari_shutdown_irq(unsigned int irq) 140{ 141 atari_disable_irq(irq); 142 atari_turnoff_irq(irq); 143 m68k_irq_shutdown(irq); 144 145 if (irq == IRQ_AUTO_4) 146 vectors[VEC_INT4] = falcon_hblhandler; 147} 148 149static struct irq_controller atari_irq_controller = { 150 .name = "atari", 151 .lock = __SPIN_LOCK_UNLOCKED(atari_irq_controller.lock), 152 .startup = atari_startup_irq, 153 .shutdown = atari_shutdown_irq, 154 .enable = atari_enable_irq, 155 .disable = atari_disable_irq, 156}; 157 158/* 159 * void atari_init_IRQ (void) 160 * 161 * Parameters: None 162 * 163 * Returns: Nothing 164 * 165 * This function should be called during kernel startup to initialize 166 * the atari IRQ handling routines. 167 */ 168 169void __init atari_init_IRQ(void) 170{ 171 m68k_setup_user_interrupt(VEC_USER, NUM_ATARI_SOURCES - IRQ_USER, NULL); 172 m68k_setup_irq_controller(&atari_irq_controller, 1, NUM_ATARI_SOURCES - 1); 173 174 /* Initialize the MFP(s) */ 175 176#ifdef ATARI_USE_SOFTWARE_EOI 177 st_mfp.vec_adr = 0x48; /* Software EOI-Mode */ 178#else 179 st_mfp.vec_adr = 0x40; /* Automatic EOI-Mode */ 180#endif 181 st_mfp.int_en_a = 0x00; /* turn off MFP-Ints */ 182 st_mfp.int_en_b = 0x00; 183 st_mfp.int_mk_a = 0xff; /* no Masking */ 184 st_mfp.int_mk_b = 0xff; 185 186 if (ATARIHW_PRESENT(TT_MFP)) { 187#ifdef ATARI_USE_SOFTWARE_EOI 188 tt_mfp.vec_adr = 0x58; /* Software EOI-Mode */ 189#else 190 tt_mfp.vec_adr = 0x50; /* Automatic EOI-Mode */ 191#endif 192 tt_mfp.int_en_a = 0x00; /* turn off MFP-Ints */ 193 tt_mfp.int_en_b = 0x00; 194 tt_mfp.int_mk_a = 0xff; /* no Masking */ 195 tt_mfp.int_mk_b = 0xff; 196 } 197 198 if (ATARIHW_PRESENT(SCC) && !atari_SCC_reset_done) { 199 scc.cha_a_ctrl = 9; 200 MFPDELAY(); 201 scc.cha_a_ctrl = (char) 0xc0; /* hardware reset */ 202 } 203 204 if (ATARIHW_PRESENT(SCU)) { 205 /* init the SCU if present */ 206 tt_scu.sys_mask = 0x10; /* enable VBL (for the cursor) and 207 * disable HSYNC interrupts (who 208 * needs them?) MFP and SCC are 209 * enabled in VME mask 210 */ 211 tt_scu.vme_mask = 0x60; /* enable MFP and SCC ints */ 212 } else { 213 /* If no SCU and no Hades, the HSYNC interrupt needs to be 214 * disabled this way. (Else _inthandler in kernel/sys_call.S 215 * gets overruns) 216 */ 217 218 vectors[VEC_INT2] = falcon_hblhandler; 219 vectors[VEC_INT4] = falcon_hblhandler; 220 } 221 222 if (ATARIHW_PRESENT(PCM_8BIT) && ATARIHW_PRESENT(MICROWIRE)) { 223 /* Initialize the LM1992 Sound Controller to enable 224 the PSG sound. This is misplaced here, it should 225 be in an atasound_init(), that doesn't exist yet. */ 226 atari_microwire_cmd(MW_LM1992_PSG_HIGH); 227 } 228 229 stdma_init(); 230 231 /* Initialize the PSG: all sounds off, both ports output */ 232 sound_ym.rd_data_reg_sel = 7; 233 sound_ym.wd_data = 0xff; 234} 235 236 237/* 238 * atari_register_vme_int() returns the number of a free interrupt vector for 239 * hardware with a programmable int vector (probably a VME board). 240 */ 241 242unsigned long atari_register_vme_int(void) 243{ 244 int i; 245 246 for (i = 0; i < 32; i++) 247 if ((free_vme_vec_bitmap & (1 << i)) == 0) 248 break; 249 250 if (i == 16) 251 return 0; 252 253 free_vme_vec_bitmap |= 1 << i; 254 return VME_SOURCE_BASE + i; 255} 256EXPORT_SYMBOL(atari_register_vme_int); 257 258 259void atari_unregister_vme_int(unsigned long irq) 260{ 261 if (irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) { 262 irq -= VME_SOURCE_BASE; 263 free_vme_vec_bitmap &= ~(1 << irq); 264 } 265} 266EXPORT_SYMBOL(atari_unregister_vme_int); 267