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 #include <linux/irq.h> 45 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 #include <asm/io.h> 54 55 56 /* 57 * Atari interrupt handling scheme: 58 * -------------------------------- 59 * 60 * All interrupt source have an internal number (defined in 61 * <asm/atariints.h>): Autovector interrupts are 1..7, then follow ST-MFP, 62 * TT-MFP, SCC, and finally VME interrupts. Vector numbers for the latter can 63 * be allocated by atari_register_vme_int(). 64 */ 65 66 /* 67 * Bitmap for free interrupt vector numbers 68 * (new vectors starting from 0x70 can be allocated by 69 * atari_register_vme_int()) 70 */ 71 static int free_vme_vec_bitmap; 72 73 /* GK: 74 * HBL IRQ handler for Falcon. Nobody needs it :-) 75 * ++andreas: raise ipl to disable further HBLANK interrupts. 76 */ 77 asmlinkage void falcon_hblhandler(void); 78 asm(".text\n" 79 __ALIGN_STR "\n\t" 80 "falcon_hblhandler:\n\t" 81 "orw #0x200,%sp@\n\t" /* set saved ipl to 2 */ 82 "rte"); 83 84 extern void atari_microwire_cmd(int cmd); 85 86 static unsigned int atari_irq_startup(struct irq_data *data) 87 { 88 unsigned int irq = data->irq; 89 90 m68k_irq_startup(data); 91 atari_turnon_irq(irq); 92 atari_enable_irq(irq); 93 return 0; 94 } 95 96 static void atari_irq_shutdown(struct irq_data *data) 97 { 98 unsigned int irq = data->irq; 99 100 atari_disable_irq(irq); 101 atari_turnoff_irq(irq); 102 m68k_irq_shutdown(data); 103 104 if (irq == IRQ_AUTO_4) 105 vectors[VEC_INT4] = falcon_hblhandler; 106 } 107 108 static void atari_irq_enable(struct irq_data *data) 109 { 110 atari_enable_irq(data->irq); 111 } 112 113 static void atari_irq_disable(struct irq_data *data) 114 { 115 atari_disable_irq(data->irq); 116 } 117 118 static struct irq_chip atari_irq_chip = { 119 .name = "atari", 120 .irq_startup = atari_irq_startup, 121 .irq_shutdown = atari_irq_shutdown, 122 .irq_enable = atari_irq_enable, 123 .irq_disable = atari_irq_disable, 124 }; 125 126 /* 127 * ST-MFP timer D chained interrupts - each driver gets its own timer 128 * interrupt instance. 129 */ 130 131 struct mfptimerbase { 132 volatile struct MFP *mfp; 133 unsigned char mfp_mask, mfp_data; 134 unsigned short int_mask; 135 int handler_irq, mfptimer_irq, server_irq; 136 char *name; 137 } stmfp_base = { 138 .mfp = &st_mfp, 139 .int_mask = 0x0, 140 .handler_irq = IRQ_MFP_TIMD, 141 .mfptimer_irq = IRQ_MFP_TIMER1, 142 .name = "MFP Timer D" 143 }; 144 145 static irqreturn_t mfp_timer_d_handler(int irq, void *dev_id) 146 { 147 struct mfptimerbase *base = dev_id; 148 int mach_irq; 149 unsigned char ints; 150 151 mach_irq = base->mfptimer_irq; 152 ints = base->int_mask; 153 for (; ints; mach_irq++, ints >>= 1) { 154 if (ints & 1) 155 generic_handle_irq(mach_irq); 156 } 157 return IRQ_HANDLED; 158 } 159 160 161 static void atari_mfptimer_enable(struct irq_data *data) 162 { 163 int mfp_num = data->irq - IRQ_MFP_TIMER1; 164 stmfp_base.int_mask |= 1 << mfp_num; 165 atari_enable_irq(IRQ_MFP_TIMD); 166 } 167 168 static void atari_mfptimer_disable(struct irq_data *data) 169 { 170 int mfp_num = data->irq - IRQ_MFP_TIMER1; 171 stmfp_base.int_mask &= ~(1 << mfp_num); 172 if (!stmfp_base.int_mask) 173 atari_disable_irq(IRQ_MFP_TIMD); 174 } 175 176 static struct irq_chip atari_mfptimer_chip = { 177 .name = "timer_d", 178 .irq_enable = atari_mfptimer_enable, 179 .irq_disable = atari_mfptimer_disable, 180 }; 181 182 183 /* 184 * EtherNAT CPLD interrupt handling 185 * CPLD interrupt register is at phys. 0x80000023 186 * Need this mapped in at interrupt startup time 187 * Possibly need this mapped on demand anyway - 188 * EtherNAT USB driver needs to disable IRQ before 189 * startup! 190 */ 191 192 static unsigned char *enat_cpld; 193 194 static unsigned int atari_ethernat_startup(struct irq_data *data) 195 { 196 int enat_num = 140 - data->irq + 1; 197 198 m68k_irq_startup(data); 199 /* 200 * map CPLD interrupt register 201 */ 202 if (!enat_cpld) 203 enat_cpld = (unsigned char *)ioremap((ATARI_ETHERNAT_PHYS_ADDR+0x23), 0x2); 204 /* 205 * do _not_ enable the USB chip interrupt here - causes interrupt storm 206 * and triggers dead interrupt watchdog 207 * Need to reset the USB chip to a sane state in early startup before 208 * removing this hack 209 */ 210 if (enat_num == 1) 211 *enat_cpld |= 1 << enat_num; 212 213 return 0; 214 } 215 216 static void atari_ethernat_enable(struct irq_data *data) 217 { 218 int enat_num = 140 - data->irq + 1; 219 /* 220 * map CPLD interrupt register 221 */ 222 if (!enat_cpld) 223 enat_cpld = (unsigned char *)ioremap((ATARI_ETHERNAT_PHYS_ADDR+0x23), 0x2); 224 *enat_cpld |= 1 << enat_num; 225 } 226 227 static void atari_ethernat_disable(struct irq_data *data) 228 { 229 int enat_num = 140 - data->irq + 1; 230 /* 231 * map CPLD interrupt register 232 */ 233 if (!enat_cpld) 234 enat_cpld = (unsigned char *)ioremap((ATARI_ETHERNAT_PHYS_ADDR+0x23), 0x2); 235 *enat_cpld &= ~(1 << enat_num); 236 } 237 238 static void atari_ethernat_shutdown(struct irq_data *data) 239 { 240 int enat_num = 140 - data->irq + 1; 241 if (enat_cpld) { 242 *enat_cpld &= ~(1 << enat_num); 243 iounmap(enat_cpld); 244 enat_cpld = NULL; 245 } 246 } 247 248 static struct irq_chip atari_ethernat_chip = { 249 .name = "ethernat", 250 .irq_startup = atari_ethernat_startup, 251 .irq_shutdown = atari_ethernat_shutdown, 252 .irq_enable = atari_ethernat_enable, 253 .irq_disable = atari_ethernat_disable, 254 }; 255 256 /* 257 * void atari_init_IRQ (void) 258 * 259 * Parameters: None 260 * 261 * Returns: Nothing 262 * 263 * This function should be called during kernel startup to initialize 264 * the atari IRQ handling routines. 265 */ 266 267 void __init atari_init_IRQ(void) 268 { 269 m68k_setup_user_interrupt(VEC_USER, NUM_ATARI_SOURCES - IRQ_USER); 270 m68k_setup_irq_controller(&atari_irq_chip, handle_simple_irq, 1, 271 NUM_ATARI_SOURCES - 1); 272 273 /* Initialize the MFP(s) */ 274 275 #ifdef ATARI_USE_SOFTWARE_EOI 276 st_mfp.vec_adr = 0x48; /* Software EOI-Mode */ 277 #else 278 st_mfp.vec_adr = 0x40; /* Automatic EOI-Mode */ 279 #endif 280 st_mfp.int_en_a = 0x00; /* turn off MFP-Ints */ 281 st_mfp.int_en_b = 0x00; 282 st_mfp.int_mk_a = 0xff; /* no Masking */ 283 st_mfp.int_mk_b = 0xff; 284 285 if (ATARIHW_PRESENT(TT_MFP)) { 286 #ifdef ATARI_USE_SOFTWARE_EOI 287 tt_mfp.vec_adr = 0x58; /* Software EOI-Mode */ 288 #else 289 tt_mfp.vec_adr = 0x50; /* Automatic EOI-Mode */ 290 #endif 291 tt_mfp.int_en_a = 0x00; /* turn off MFP-Ints */ 292 tt_mfp.int_en_b = 0x00; 293 tt_mfp.int_mk_a = 0xff; /* no Masking */ 294 tt_mfp.int_mk_b = 0xff; 295 } 296 297 if (ATARIHW_PRESENT(SCC) && !atari_SCC_reset_done) { 298 atari_scc.cha_a_ctrl = 9; 299 MFPDELAY(); 300 atari_scc.cha_a_ctrl = (char) 0xc0; /* hardware reset */ 301 } 302 303 if (ATARIHW_PRESENT(SCU)) { 304 /* init the SCU if present */ 305 tt_scu.sys_mask = 0x0; /* disable all interrupts */ 306 tt_scu.vme_mask = 0x60; /* enable MFP and SCC ints */ 307 } else { 308 /* If no SCU and no Hades, the HSYNC interrupt needs to be 309 * disabled this way. (Else _inthandler in kernel/sys_call.S 310 * gets overruns) 311 */ 312 313 vectors[VEC_INT2] = falcon_hblhandler; 314 vectors[VEC_INT4] = falcon_hblhandler; 315 } 316 317 if (ATARIHW_PRESENT(PCM_8BIT) && ATARIHW_PRESENT(MICROWIRE)) { 318 /* Initialize the LM1992 Sound Controller to enable 319 the PSG sound. This is misplaced here, it should 320 be in an atasound_init(), that doesn't exist yet. */ 321 atari_microwire_cmd(MW_LM1992_PSG_HIGH); 322 } 323 324 stdma_init(); 325 326 /* Initialize the PSG: all sounds off, both ports output */ 327 sound_ym.rd_data_reg_sel = 7; 328 sound_ym.wd_data = 0xff; 329 330 m68k_setup_irq_controller(&atari_mfptimer_chip, handle_simple_irq, 331 IRQ_MFP_TIMER1, 8); 332 333 irq_set_status_flags(IRQ_MFP_TIMER1, IRQ_IS_POLLED); 334 irq_set_status_flags(IRQ_MFP_TIMER2, IRQ_IS_POLLED); 335 336 /* prepare timer D data for use as poll interrupt */ 337 /* set Timer D data Register - needs to be > 0 */ 338 st_mfp.tim_dt_d = 254; /* < 100 Hz */ 339 /* start timer D, div = 1:100 */ 340 st_mfp.tim_ct_cd = (st_mfp.tim_ct_cd & 0xf0) | 0x6; 341 342 /* request timer D dispatch handler */ 343 if (request_irq(IRQ_MFP_TIMD, mfp_timer_d_handler, IRQF_SHARED, 344 stmfp_base.name, &stmfp_base)) 345 pr_err("Couldn't register %s interrupt\n", stmfp_base.name); 346 347 /* 348 * EtherNAT ethernet / USB interrupt handlers 349 */ 350 351 m68k_setup_irq_controller(&atari_ethernat_chip, handle_simple_irq, 352 139, 2); 353 } 354 355 356 /* 357 * atari_register_vme_int() returns the number of a free interrupt vector for 358 * hardware with a programmable int vector (probably a VME board). 359 */ 360 361 unsigned int atari_register_vme_int(void) 362 { 363 int i; 364 365 for (i = 0; i < 32; i++) 366 if ((free_vme_vec_bitmap & (1 << i)) == 0) 367 break; 368 369 if (i == 16) 370 return 0; 371 372 free_vme_vec_bitmap |= 1 << i; 373 return VME_SOURCE_BASE + i; 374 } 375 EXPORT_SYMBOL(atari_register_vme_int); 376 377 378 void atari_unregister_vme_int(unsigned int irq) 379 { 380 if (irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) { 381 irq -= VME_SOURCE_BASE; 382 free_vme_vec_bitmap &= ~(1 << irq); 383 } 384 } 385 EXPORT_SYMBOL(atari_unregister_vme_int); 386 387 388