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 107 108/* 109 * Bitmap for free interrupt vector numbers 110 * (new vectors starting from 0x70 can be allocated by 111 * atari_register_vme_int()) 112 */ 113static int free_vme_vec_bitmap; 114 115/* GK: 116 * HBL IRQ handler for Falcon. Nobody needs it :-) 117 * ++andreas: raise ipl to disable further HBLANK interrupts. 118 */ 119asmlinkage void falcon_hblhandler(void); 120asm(".text\n" 121__ALIGN_STR "\n\t" 122"falcon_hblhandler:\n\t" 123 "orw #0x200,%sp@\n\t" /* set saved ipl to 2 */ 124 "rte"); 125 126extern void atari_microwire_cmd(int cmd); 127 128extern int atari_SCC_reset_done; 129 130static int atari_startup_irq(unsigned int irq) 131{ 132 m68k_irq_startup(irq); 133 atari_turnon_irq(irq); 134 atari_enable_irq(irq); 135 return 0; 136} 137 138static void atari_shutdown_irq(unsigned int irq) 139{ 140 atari_disable_irq(irq); 141 atari_turnoff_irq(irq); 142 m68k_irq_shutdown(irq); 143 144 if (irq == IRQ_AUTO_4) 145 vectors[VEC_INT4] = falcon_hblhandler; 146} 147 148static struct irq_controller atari_irq_controller = { 149 .name = "atari", 150 .lock = __SPIN_LOCK_UNLOCKED(atari_irq_controller.lock), 151 .startup = atari_startup_irq, 152 .shutdown = atari_shutdown_irq, 153 .enable = atari_enable_irq, 154 .disable = atari_disable_irq, 155}; 156 157/* 158 * void atari_init_IRQ (void) 159 * 160 * Parameters: None 161 * 162 * Returns: Nothing 163 * 164 * This function should be called during kernel startup to initialize 165 * the atari IRQ handling routines. 166 */ 167 168void __init atari_init_IRQ(void) 169{ 170 m68k_setup_user_interrupt(VEC_USER, NUM_ATARI_SOURCES - IRQ_USER, NULL); 171 m68k_setup_irq_controller(&atari_irq_controller, 1, NUM_ATARI_SOURCES - 1); 172 173 /* Initialize the MFP(s) */ 174 175#ifdef ATARI_USE_SOFTWARE_EOI 176 mfp.vec_adr = 0x48; /* Software EOI-Mode */ 177#else 178 mfp.vec_adr = 0x40; /* Automatic EOI-Mode */ 179#endif 180 mfp.int_en_a = 0x00; /* turn off MFP-Ints */ 181 mfp.int_en_b = 0x00; 182 mfp.int_mk_a = 0xff; /* no Masking */ 183 mfp.int_mk_b = 0xff; 184 185 if (ATARIHW_PRESENT(TT_MFP)) { 186#ifdef ATARI_USE_SOFTWARE_EOI 187 tt_mfp.vec_adr = 0x58; /* Software EOI-Mode */ 188#else 189 tt_mfp.vec_adr = 0x50; /* Automatic EOI-Mode */ 190#endif 191 tt_mfp.int_en_a = 0x00; /* turn off MFP-Ints */ 192 tt_mfp.int_en_b = 0x00; 193 tt_mfp.int_mk_a = 0xff; /* no Masking */ 194 tt_mfp.int_mk_b = 0xff; 195 } 196 197 if (ATARIHW_PRESENT(SCC) && !atari_SCC_reset_done) { 198 scc.cha_a_ctrl = 9; 199 MFPDELAY(); 200 scc.cha_a_ctrl = (char) 0xc0; /* hardware reset */ 201 } 202 203 if (ATARIHW_PRESENT(SCU)) { 204 /* init the SCU if present */ 205 tt_scu.sys_mask = 0x10; /* enable VBL (for the cursor) and 206 * disable HSYNC interrupts (who 207 * needs them?) MFP and SCC are 208 * enabled in VME mask 209 */ 210 tt_scu.vme_mask = 0x60; /* enable MFP and SCC ints */ 211 } else { 212 /* If no SCU and no Hades, the HSYNC interrupt needs to be 213 * disabled this way. (Else _inthandler in kernel/sys_call.S 214 * gets overruns) 215 */ 216 217 if (!MACH_IS_HADES) { 218 vectors[VEC_INT2] = falcon_hblhandler; 219 vectors[VEC_INT4] = falcon_hblhandler; 220 } 221 } 222 223 if (ATARIHW_PRESENT(PCM_8BIT) && ATARIHW_PRESENT(MICROWIRE)) { 224 /* Initialize the LM1992 Sound Controller to enable 225 the PSG sound. This is misplaced here, it should 226 be in an atasound_init(), that doesn't exist yet. */ 227 atari_microwire_cmd(MW_LM1992_PSG_HIGH); 228 } 229 230 stdma_init(); 231 232 /* Initialize the PSG: all sounds off, both ports output */ 233 sound_ym.rd_data_reg_sel = 7; 234 sound_ym.wd_data = 0xff; 235} 236 237 238/* 239 * atari_register_vme_int() returns the number of a free interrupt vector for 240 * hardware with a programmable int vector (probably a VME board). 241 */ 242 243unsigned long atari_register_vme_int(void) 244{ 245 int i; 246 247 for (i = 0; i < 32; i++) 248 if ((free_vme_vec_bitmap & (1 << i)) == 0) 249 break; 250 251 if (i == 16) 252 return 0; 253 254 free_vme_vec_bitmap |= 1 << i; 255 return VME_SOURCE_BASE + i; 256} 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} 266