Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 107 | #if 0 |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | } |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 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; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 318 | extern void atari_microwire_cmd(int cmd); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 319 | |
| 320 | extern int atari_SCC_reset_done; |
| 321 | |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 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); |
Geert Uytterhoeven | 69961c3 | 2006-10-09 22:23:31 +0200 | [diff] [blame] | 335 | |
| 336 | if (irq == IRQ_AUTO_4) |
| 337 | vectors[VEC_INT4] = falcon_hblhandler; |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 338 | } |
| 339 | |
| 340 | static struct irq_controller atari_irq_controller = { |
| 341 | .name = "atari", |
Milind Arun Choudhary | 241258d | 2007-05-06 14:50:54 -0700 | [diff] [blame] | 342 | .lock = __SPIN_LOCK_UNLOCKED(atari_irq_controller.lock), |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 343 | .startup = atari_startup_irq, |
| 344 | .shutdown = atari_shutdown_irq, |
| 345 | .enable = atari_enable_irq, |
| 346 | .disable = atari_disable_irq, |
| 347 | }; |
| 348 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | { |
Geert Uytterhoeven | 69961c3 | 2006-10-09 22:23:31 +0200 | [diff] [blame] | 362 | m68k_setup_user_interrupt(VEC_USER, NUM_ATARI_SOURCES - IRQ_USER, NULL); |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 363 | m68k_setup_irq_controller(&atari_irq_controller, 1, NUM_ATARI_SOURCES - 1); |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 */ |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 403 | } else { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Geert Uytterhoeven | 69961c3 | 2006-10-09 22:23:31 +0200 | [diff] [blame] | 409 | if (!MACH_IS_HADES) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 410 | vectors[VEC_INT2] = falcon_hblhandler; |
Geert Uytterhoeven | 69961c3 | 2006-10-09 22:23:31 +0200 | [diff] [blame] | 411 | vectors[VEC_INT4] = falcon_hblhandler; |
| 412 | } |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 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 | |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 439 | for (i = 0; i < 32; i++) |
| 440 | if ((free_vme_vec_bitmap & (1 << i)) == 0) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 441 | break; |
| 442 | |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 443 | if (i == 16) |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 444 | return 0; |
| 445 | |
| 446 | free_vme_vec_bitmap |= 1 << i; |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 447 | return VME_SOURCE_BASE + i; |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 448 | } |
| 449 | |
| 450 | |
| 451 | void atari_unregister_vme_int(unsigned long irq) |
| 452 | { |
Roman Zippel | 7340856 | 2006-06-25 05:47:03 -0700 | [diff] [blame] | 453 | if (irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) { |
Linus Torvalds | 1da177e | 2005-04-16 15:20:36 -0700 | [diff] [blame] | 454 | irq -= VME_SOURCE_BASE; |
| 455 | free_vme_vec_bitmap &= ~(1 << irq); |
| 456 | } |
| 457 | } |
| 458 | |
| 459 | |