arch/m68k/atari/ataints.c

   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 #define NUM_INT_SOURCES (8 + NUM_ATARI_SOURCES)
 109
 110 typedef void (*asm_irq_handler)(void);
 111
 112 struct irqhandler {
 113         irqreturn_t (*handler)(int, void *, struct pt_regs *);
 114         void    *dev_id;
 115 };
 116
 117 struct irqparam {
 118         unsigned long   flags;
 119         const char      *devname;
 120 };
 121
 122 /*
 123  * Array with irq's and their parameter data. This array is accessed from low
 124  * level assembler code, so an element size of 8 allows usage of index scaling
 125  * addressing mode.
 126  */
 127 static struct irqhandler irq_handler[NUM_INT_SOURCES];
 128
 129 /*
 130  * This array hold the rest of parameters of int handlers: type
 131  * (slow,fast,prio) and the name of the handler. These values are only
 132  * accessed from C
 133  */
 134 static struct irqparam irq_param[NUM_INT_SOURCES];
 135
 136 /*
 137  * Bitmap for free interrupt vector numbers
 138  * (new vectors starting from 0x70 can be allocated by
 139  * atari_register_vme_int())
 140  */
 141 static int free_vme_vec_bitmap;
 142
 143 /* check for valid int number (complex, sigh...) */
 144 #define IS_VALID_INTNO(n)                                                                                       \
 145         ((n) > 0 &&                                                                                                             \
 146          /* autovec and ST-MFP ok anyway */                                                             \
 147          (((n) < TTMFP_SOURCE_BASE) ||                                                                  \
 148           /* TT-MFP ok if present */                                                                    \
 149           ((n) >= TTMFP_SOURCE_BASE && (n) < SCC_SOURCE_BASE &&                 \
 150            ATARIHW_PRESENT(TT_MFP)) ||                                                                  \
 151           /* SCC ok if present and number even */                                               \
 152           ((n) >= SCC_SOURCE_BASE && (n) < VME_SOURCE_BASE &&                   \
 153            !((n) & 1) && ATARIHW_PRESENT(SCC)) ||                                               \
 154           /* greater numbers ok if they are registered VME vectors */           \
 155           ((n) >= VME_SOURCE_BASE && (n) < VME_SOURCE_BASE + VME_MAX_SOURCES && \
 156                   free_vme_vec_bitmap & (1 << ((n) - VME_SOURCE_BASE)))))
 157
 158
 159 /*
 160  * Here start the assembler entry points for interrupts
 161  */
 162
 163 #define IRQ_NAME(nr) atari_slow_irq_##nr##_handler(void)
 164
 165 #define BUILD_SLOW_IRQ(n)                                                  \
 166 asmlinkage void IRQ_NAME(n);                                               \
 167 /* Dummy function to allow asm with operands.  */                          \
 168 void atari_slow_irq_##n##_dummy (void) {                                   \
 169 __asm__ (__ALIGN_STR "\n"                                                  \
 170 "atari_slow_irq_" #n "_handler:\t"                                         \
 171 "       addl    %6,%5\n"        /* preempt_count() += HARDIRQ_OFFSET */    \
 172         SAVE_ALL_INT "\n"                                                  \
 173         GET_CURRENT(%%d0) "\n"                                             \
 174 "       andb    #~(1<<(%c3&7)),%a4:w\n" /* mask this interrupt */          \
 175         /* get old IPL from stack frame */                                 \
 176 "       bfextu  %%sp@(%c2){#5,#3},%%d0\n"                                  \
 177 "       movew   %%sr,%%d1\n"                                               \
 178 "       bfins   %%d0,%%d1{#21,#3}\n"                                       \
 179 "       movew   %%d1,%%sr\n"            /* set IPL = previous value */     \
 180 "       addql   #1,%a0\n"                                                  \
 181 "       lea     %a1,%%a0\n"                                                \
 182 "       pea     %%sp@\n"                /* push addr of frame */           \
 183 "       movel   %%a0@(4),%%sp@-\n"      /* push handler data */            \
 184 "       pea     (%c3+8)\n"              /* push int number */              \
 185 "       movel   %%a0@,%%a0\n"                                              \
 186 "       jbsr    %%a0@\n"                /* call the handler */             \
 187 "       addql   #8,%%sp\n"                                                 \
 188 "       addql   #4,%%sp\n"                                                 \
 189 "       orw     #0x0600,%%sr\n"                                            \
 190 "       andw    #0xfeff,%%sr\n"         /* set IPL = 6 again */            \
 191 "       orb     #(1<<(%c3&7)),%a4:w\n"  /* now unmask the int again */     \
 192 "       jbra    ret_from_interrupt\n"                                      \
 193          : : "i" (&kstat_cpu(0).irqs[n+8]), "i" (&irq_handler[n+8]),       \
 194              "n" (PT_OFF_SR), "n" (n),                                     \
 195              "i" (n & 8 ? (n & 16 ? &tt_mfp.int_mk_a : &mfp.int_mk_a)      \
 196                         : (n & 16 ? &tt_mfp.int_mk_b : &mfp.int_mk_b)),    \
 197              "m" (preempt_count()), "di" (HARDIRQ_OFFSET)                  \
 198 );                                                                         \
 199         for (;;);                       /* fake noreturn */                \
 200 }
 201
 202 BUILD_SLOW_IRQ(0);
 203 BUILD_SLOW_IRQ(1);
 204 BUILD_SLOW_IRQ(2);
 205 BUILD_SLOW_IRQ(3);
 206 BUILD_SLOW_IRQ(4);
 207 BUILD_SLOW_IRQ(5);
 208 BUILD_SLOW_IRQ(6);
 209 BUILD_SLOW_IRQ(7);
 210 BUILD_SLOW_IRQ(8);
 211 BUILD_SLOW_IRQ(9);
 212 BUILD_SLOW_IRQ(10);
 213 BUILD_SLOW_IRQ(11);
 214 BUILD_SLOW_IRQ(12);
 215 BUILD_SLOW_IRQ(13);
 216 BUILD_SLOW_IRQ(14);
 217 BUILD_SLOW_IRQ(15);
 218 BUILD_SLOW_IRQ(16);
 219 BUILD_SLOW_IRQ(17);
 220 BUILD_SLOW_IRQ(18);
 221 BUILD_SLOW_IRQ(19);
 222 BUILD_SLOW_IRQ(20);
 223 BUILD_SLOW_IRQ(21);
 224 BUILD_SLOW_IRQ(22);
 225 BUILD_SLOW_IRQ(23);
 226 BUILD_SLOW_IRQ(24);
 227 BUILD_SLOW_IRQ(25);
 228 BUILD_SLOW_IRQ(26);
 229 BUILD_SLOW_IRQ(27);
 230 BUILD_SLOW_IRQ(28);
 231 BUILD_SLOW_IRQ(29);
 232 BUILD_SLOW_IRQ(30);
 233 BUILD_SLOW_IRQ(31);
 234
 235 asm_irq_handler slow_handlers[32] = {
 236         [0]     = atari_slow_irq_0_handler,
 237         [1]     = atari_slow_irq_1_handler,
 238         [2]     = atari_slow_irq_2_handler,
 239         [3]     = atari_slow_irq_3_handler,
 240         [4]     = atari_slow_irq_4_handler,
 241         [5]     = atari_slow_irq_5_handler,
 242         [6]     = atari_slow_irq_6_handler,
 243         [7]     = atari_slow_irq_7_handler,
 244         [8]     = atari_slow_irq_8_handler,
 245         [9]     = atari_slow_irq_9_handler,
 246         [10]    = atari_slow_irq_10_handler,
 247         [11]    = atari_slow_irq_11_handler,
 248         [12]    = atari_slow_irq_12_handler,
 249         [13]    = atari_slow_irq_13_handler,
 250         [14]    = atari_slow_irq_14_handler,
 251         [15]    = atari_slow_irq_15_handler,
 252         [16]    = atari_slow_irq_16_handler,
 253         [17]    = atari_slow_irq_17_handler,
 254         [18]    = atari_slow_irq_18_handler,
 255         [19]    = atari_slow_irq_19_handler,
 256         [20]    = atari_slow_irq_20_handler,
 257         [21]    = atari_slow_irq_21_handler,
 258         [22]    = atari_slow_irq_22_handler,
 259         [23]    = atari_slow_irq_23_handler,
 260         [24]    = atari_slow_irq_24_handler,
 261         [25]    = atari_slow_irq_25_handler,
 262         [26]    = atari_slow_irq_26_handler,
 263         [27]    = atari_slow_irq_27_handler,
 264         [28]    = atari_slow_irq_28_handler,
 265         [29]    = atari_slow_irq_29_handler,
 266         [30]    = atari_slow_irq_30_handler,
 267         [31]    = atari_slow_irq_31_handler
 268 };
 269
 270 asmlinkage void atari_fast_irq_handler( void );
 271 asmlinkage void atari_prio_irq_handler( void );
 272
 273 /* Dummy function to allow asm with operands.  */
 274 void atari_fast_prio_irq_dummy (void) {
 275 __asm__ (__ALIGN_STR "\n"
 276 "atari_fast_irq_handler:\n\t"
 277         "orw    #0x700,%%sr\n"          /* disable all interrupts */
 278 "atari_prio_irq_handler:\n\t"
 279         "addl   %3,%2\n\t"              /* preempt_count() += HARDIRQ_OFFSET */
 280         SAVE_ALL_INT "\n\t"
 281         GET_CURRENT(%%d0) "\n\t"
 282         /* get vector number from stack frame and convert to source */
 283         "bfextu %%sp@(%c1){#4,#10},%%d0\n\t"
 284         "subw   #(0x40-8),%%d0\n\t"
 285         "jpl    1f\n\t"
 286         "addw   #(0x40-8-0x18),%%d0\n"
 287     "1:\tlea    %a0,%%a0\n\t"
 288         "addql  #1,%%a0@(%%d0:l:4)\n\t"
 289         "lea    irq_handler,%%a0\n\t"
 290         "lea    %%a0@(%%d0:l:8),%%a0\n\t"
 291         "pea    %%sp@\n\t"              /* push frame address */
 292         "movel  %%a0@(4),%%sp@-\n\t"    /* push handler data */
 293         "movel  %%d0,%%sp@-\n\t"        /* push int number */
 294         "movel  %%a0@,%%a0\n\t"
 295         "jsr    %%a0@\n\t"              /* and call the handler */
 296         "addql  #8,%%sp\n\t"
 297         "addql  #4,%%sp\n\t"
 298         "jbra   ret_from_interrupt"
 299          : : "i" (&kstat_cpu(0).irqs), "n" (PT_OFF_FORMATVEC),
 300              "m" (preempt_count()), "di" (HARDIRQ_OFFSET)
 301 );
 302         for (;;);
 303 }
 304
 305 /* GK:
 306  * HBL IRQ handler for Falcon. Nobody needs it :-)
 307  * ++andreas: raise ipl to disable further HBLANK interrupts.
 308  */
 309 asmlinkage void falcon_hblhandler(void);
 310 asm(".text\n"
 311 __ALIGN_STR "\n\t"
 312 "falcon_hblhandler:\n\t"
 313         "orw    #0x200,%sp@\n\t"        /* set saved ipl to 2 */
 314         "rte");
 315
 316 /* Defined in entry.S; only increments 'num_spurious' */
 317 asmlinkage void bad_interrupt(void);
 318
 319 extern void atari_microwire_cmd( int cmd );
 320
 321 extern int atari_SCC_reset_done;
 322
 323 /*
 324  * void atari_init_IRQ (void)
 325  *
 326  * Parameters:  None
 327  *
 328  * Returns:     Nothing
 329  *
 330  * This function should be called during kernel startup to initialize
 331  * the atari IRQ handling routines.
 332  */
 333
 334 void __init atari_init_IRQ(void)
 335 {
 336         int i;
 337
 338         /* initialize the vector table */
 339         for (i = 0; i < NUM_INT_SOURCES; ++i) {
 340                 vectors[IRQ_SOURCE_TO_VECTOR(i)] = bad_interrupt;
 341         }
 342
 343         /* Initialize the MFP(s) */
 344
 345 #ifdef ATARI_USE_SOFTWARE_EOI
 346         mfp.vec_adr  = 0x48;    /* Software EOI-Mode */
 347 #else
 348         mfp.vec_adr  = 0x40;    /* Automatic EOI-Mode */
 349 #endif
 350         mfp.int_en_a = 0x00;    /* turn off MFP-Ints */
 351         mfp.int_en_b = 0x00;
 352         mfp.int_mk_a = 0xff;    /* no Masking */
 353         mfp.int_mk_b = 0xff;
 354
 355         if (ATARIHW_PRESENT(TT_MFP)) {
 356 #ifdef ATARI_USE_SOFTWARE_EOI
 357                 tt_mfp.vec_adr  = 0x58;         /* Software EOI-Mode */
 358 #else
 359                 tt_mfp.vec_adr  = 0x50;         /* Automatic EOI-Mode */
 360 #endif
 361                 tt_mfp.int_en_a = 0x00;         /* turn off MFP-Ints */
 362                 tt_mfp.int_en_b = 0x00;
 363                 tt_mfp.int_mk_a = 0xff;         /* no Masking */
 364                 tt_mfp.int_mk_b = 0xff;
 365         }
 366
 367         if (ATARIHW_PRESENT(SCC) && !atari_SCC_reset_done) {
 368                 scc.cha_a_ctrl = 9;
 369                 MFPDELAY();
 370                 scc.cha_a_ctrl = (char) 0xc0; /* hardware reset */
 371         }
 372
 373         if (ATARIHW_PRESENT(SCU)) {
 374                 /* init the SCU if present */
 375                 tt_scu.sys_mask = 0x10;         /* enable VBL (for the cursor) and
 376                                                                          * disable HSYNC interrupts (who
 377                                                                          * needs them?)  MFP and SCC are
 378                                                                          * enabled in VME mask
 379                                                                          */
 380                 tt_scu.vme_mask = 0x60;         /* enable MFP and SCC ints */
 381         }
 382         else {
 383                 /* If no SCU and no Hades, the HSYNC interrupt needs to be
 384                  * disabled this way. (Else _inthandler in kernel/sys_call.S
 385                  * gets overruns)
 386                  */
 387
 388                 if (!MACH_IS_HADES)
 389                         vectors[VEC_INT2] = falcon_hblhandler;
 390         }
 391
 392         if (ATARIHW_PRESENT(PCM_8BIT) && ATARIHW_PRESENT(MICROWIRE)) {
 393                 /* Initialize the LM1992 Sound Controller to enable
 394                    the PSG sound.  This is misplaced here, it should
 395                    be in an atasound_init(), that doesn't exist yet. */
 396                 atari_microwire_cmd(MW_LM1992_PSG_HIGH);
 397         }
 398
 399         stdma_init();
 400
 401         /* Initialize the PSG: all sounds off, both ports output */
 402         sound_ym.rd_data_reg_sel = 7;
 403         sound_ym.wd_data = 0xff;
 404 }
 405
 406
 407 static irqreturn_t atari_call_irq_list( int irq, void *dev_id, struct pt_regs *fp )
 408 {
 409         irq_node_t *node;
 410
 411         for (node = (irq_node_t *)dev_id; node; node = node->next)
 412                 node->handler(irq, node->dev_id, fp);
 413         return IRQ_HANDLED;
 414 }
 415
 416
 417 /*
 418  * atari_request_irq : add an interrupt service routine for a particular
 419  *                     machine specific interrupt source.
 420  *                     If the addition was successful, it returns 0.
 421  */
 422
 423 int atari_request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *),
 424                       unsigned long flags, const char *devname, void *dev_id)
 425 {
 426         int vector;
 427         unsigned long oflags = flags;
 428
 429         /*
 430          * The following is a hack to make some PCI card drivers work,
 431          * which set the SA_SHIRQ flag.
 432          */
 433
 434         flags &= ~SA_SHIRQ;
 435
 436         if (flags == SA_INTERRUPT) {
 437                 printk ("%s: SA_INTERRUPT changed to IRQ_TYPE_SLOW for %s\n",
 438                         __FUNCTION__, devname);
 439                 flags = IRQ_TYPE_SLOW;
 440         }
 441         if (flags < IRQ_TYPE_SLOW || flags > IRQ_TYPE_PRIO) {
 442                 printk ("%s: Bad irq type 0x%lx <0x%lx> requested from %s\n",
 443                         __FUNCTION__, flags, oflags, devname);
 444                 return -EINVAL;
 445         }
 446         if (!IS_VALID_INTNO(irq)) {
 447                 printk ("%s: Unknown irq %d requested from %s\n",
 448                         __FUNCTION__, irq, devname);
 449                 return -ENXIO;
 450         }
 451         vector = IRQ_SOURCE_TO_VECTOR(irq);
 452
 453         /*
 454          * Check type/source combination: slow ints are (currently)
 455          * only possible for MFP-interrupts.
 456          */
 457         if (flags == IRQ_TYPE_SLOW &&
 458                 (irq < STMFP_SOURCE_BASE || irq >= SCC_SOURCE_BASE)) {
 459                 printk ("%s: Slow irq requested for non-MFP source %d from %s\n",
 460                         __FUNCTION__, irq, devname);
 461                 return -EINVAL;
 462         }
 463
 464         if (vectors[vector] == bad_interrupt) {
 465                 /* int has no handler yet */
 466                 irq_handler[irq].handler = handler;
 467                 irq_handler[irq].dev_id  = dev_id;
 468                 irq_param[irq].flags   = flags;
 469                 irq_param[irq].devname = devname;
 470                 vectors[vector] =
 471                         (flags == IRQ_TYPE_SLOW) ? slow_handlers[irq-STMFP_SOURCE_BASE] :
 472                         (flags == IRQ_TYPE_FAST) ? atari_fast_irq_handler :
 473                                                   atari_prio_irq_handler;
 474                 /* If MFP int, also enable and umask it */
 475                 atari_turnon_irq(irq);
 476                 atari_enable_irq(irq);
 477
 478                 return 0;
 479         }
 480         else if (irq_param[irq].flags == flags) {
 481                 /* old handler is of same type -> handlers can be chained */
 482                 irq_node_t *node;
 483                 unsigned long flags;
 484
 485                 local_irq_save(flags);
 486
 487                 if (irq_handler[irq].handler != atari_call_irq_list) {
 488                         /* Only one handler yet, make a node for this first one */
 489                         if (!(node = new_irq_node()))
 490                                 return -ENOMEM;
 491                         node->handler = irq_handler[irq].handler;
 492                         node->dev_id  = irq_handler[irq].dev_id;
 493                         node->devname = irq_param[irq].devname;
 494                         node->next = NULL;
 495
 496                         irq_handler[irq].handler = atari_call_irq_list;
 497                         irq_handler[irq].dev_id  = node;
 498                         irq_param[irq].devname   = "chained";
 499                 }
 500
 501                 if (!(node = new_irq_node()))
 502                         return -ENOMEM;
 503                 node->handler = handler;
 504                 node->dev_id  = dev_id;
 505                 node->devname = devname;
 506                 /* new handlers are put in front of the queue */
 507                 node->next = irq_handler[irq].dev_id;
 508                 irq_handler[irq].dev_id = node;
 509
 510                 local_irq_restore(flags);
 511                 return 0;
 512         } else {
 513                 printk ("%s: Irq %d allocated by other type int (call from %s)\n",
 514                         __FUNCTION__, irq, devname);
 515                 return -EBUSY;
 516         }
 517 }
 518
 519 void atari_free_irq(unsigned int irq, void *dev_id)
 520 {
 521         unsigned long flags;
 522         int vector;
 523         irq_node_t **list, *node;
 524
 525         if (!IS_VALID_INTNO(irq)) {
 526                 printk("%s: Unknown irq %d\n", __FUNCTION__, irq);
 527                 return;
 528         }
 529
 530         vector = IRQ_SOURCE_TO_VECTOR(irq);
 531         if (vectors[vector] == bad_interrupt)
 532                 goto not_found;
 533
 534         local_irq_save(flags);
 535
 536         if (irq_handler[irq].handler != atari_call_irq_list) {
 537                 /* It's the only handler for the interrupt */
 538                 if (irq_handler[irq].dev_id != dev_id) {
 539                         local_irq_restore(flags);
 540                         goto not_found;
 541                 }
 542                 irq_handler[irq].handler = NULL;
 543                 irq_handler[irq].dev_id  = NULL;
 544                 irq_param[irq].devname   = NULL;
 545                 vectors[vector] = bad_interrupt;
 546                 /* If MFP int, also disable it */
 547                 atari_disable_irq(irq);
 548                 atari_turnoff_irq(irq);
 549
 550                 local_irq_restore(flags);
 551                 return;
 552         }
 553
 554         /* The interrupt is chained, find the irq on the list */
 555         for(list = (irq_node_t **)&irq_handler[irq].dev_id; *list; list = &(*list)->next) {
 556                 if ((*list)->dev_id == dev_id) break;
 557         }
 558         if (!*list) {
 559                 local_irq_restore(flags);
 560                 goto not_found;
 561         }
 562
 563         (*list)->handler = NULL; /* Mark it as free for reallocation */
 564         *list = (*list)->next;
 565
 566         /* If there's now only one handler, unchain the interrupt, i.e. plug in
 567          * the handler directly again and omit atari_call_irq_list */
 568         node = (irq_node_t *)irq_handler[irq].dev_id;
 569         if (node && !node->next) {
 570                 irq_handler[irq].handler = node->handler;
 571                 irq_handler[irq].dev_id  = node->dev_id;
 572                 irq_param[irq].devname   = node->devname;
 573                 node->handler = NULL; /* Mark it as free for reallocation */
 574         }
 575
 576         local_irq_restore(flags);
 577         return;
 578
 579 not_found:
 580         printk("%s: tried to remove invalid irq\n", __FUNCTION__);
 581         return;
 582 }
 583
 584
 585 /*
 586  * atari_register_vme_int() returns the number of a free interrupt vector for
 587  * hardware with a programmable int vector (probably a VME board).
 588  */
 589
 590 unsigned long atari_register_vme_int(void)
 591 {
 592         int i;
 593
 594         for(i = 0; i < 32; i++)
 595                 if((free_vme_vec_bitmap & (1 << i)) == 0)
 596                         break;
 597
 598         if(i == 16)
 599                 return 0;
 600
 601         free_vme_vec_bitmap |= 1 << i;
 602         return (VME_SOURCE_BASE + i);
 603 }
 604
 605
 606 void atari_unregister_vme_int(unsigned long irq)
 607 {
 608         if(irq >= VME_SOURCE_BASE && irq < VME_SOURCE_BASE + VME_MAX_SOURCES) {
 609                 irq -= VME_SOURCE_BASE;
 610                 free_vme_vec_bitmap &= ~(1 << irq);
 611         }
 612 }
 613
 614
 615 int show_atari_interrupts(struct seq_file *p, void *v)
 616 {
 617         int i;
 618
 619         for (i = 0; i < NUM_INT_SOURCES; ++i) {
 620                 if (vectors[IRQ_SOURCE_TO_VECTOR(i)] == bad_interrupt)
 621                         continue;
 622                 if (i < STMFP_SOURCE_BASE)
 623                         seq_printf(p, "auto %2d: %10u ",
 624                                        i, kstat_cpu(0).irqs[i]);
 625                 else
 626                         seq_printf(p, "vec $%02x: %10u ",
 627                                        IRQ_SOURCE_TO_VECTOR(i),
 628                                        kstat_cpu(0).irqs[i]);
 629
 630                 if (irq_handler[i].handler != atari_call_irq_list) {
 631                         seq_printf(p, "%s\n", irq_param[i].devname);
 632                 }
 633                 else {
 634                         irq_node_t *n;
 635                         for( n = (irq_node_t *)irq_handler[i].dev_id; n; n = n->next ) {
 636                                 seq_printf(p, "%s\n", n->devname);
 637                                 if (n->next)
 638                                         seq_puts(p, "                    " );
 639                         }
 640                 }
 641         }
 642         if (num_spurious)
 643                 seq_printf(p, "spurio.: %10u\n", num_spurious);
 644
 645         return 0;
 646 }
 647
 648