err.no Git - linux-2.6/blob - arch/m68k/mac/oss.c

   1 /*
   2  *      OSS handling
   3  *      Written by Joshua M. Thompson (funaho@jurai.org)
   4  *
   5  *
   6  *      This chip is used in the IIfx in place of VIA #2. It acts like a fancy
   7  *      VIA chip with prorammable interrupt levels.
   8  *
   9  * 990502 (jmt) - Major rewrite for new interrupt architecture as well as some
  10  *                recent insights into OSS operational details.
  11  * 990610 (jmt) - Now taking fulll advantage of the OSS. Interrupts are mapped
  12  *                to mostly match the A/UX interrupt scheme supported on the
  13  *                VIA side. Also added support for enabling the ISM irq again
  14  *                since we now have a functional IOP manager.
  15  */
  16
  17 #include <linux/types.h>
  18 #include <linux/kernel.h>
  19 #include <linux/mm.h>
  20 #include <linux/delay.h>
  21 #include <linux/init.h>
  22
  23 #include <asm/bootinfo.h>
  24 #include <asm/machw.h>
  25 #include <asm/macintosh.h>
  26 #include <asm/macints.h>
  27 #include <asm/mac_via.h>
  28 #include <asm/mac_oss.h>
  29
  30 int oss_present;
  31 volatile struct mac_oss *oss;
  32
  33 irqreturn_t oss_irq(int, void *);
  34 irqreturn_t oss_nubus_irq(int, void *);
  35
  36 extern irqreturn_t via1_irq(int, void *);
  37 extern irqreturn_t mac_scc_dispatch(int, void *);
  38
  39 /*
  40  * Initialize the OSS
  41  *
  42  * The OSS "detection" code is actually in via_init() which is always called
  43  * before us. Thus we can count on oss_present being valid on entry.
  44  */
  45
  46 void __init oss_init(void)
  47 {
  48         int i;
  49
  50         if (!oss_present) return;
  51
  52         oss = (struct mac_oss *) OSS_BASE;
  53
  54         /* Disable all interrupts. Unlike a VIA it looks like we    */
  55         /* do this by setting the source's interrupt level to zero. */
  56
  57         for (i = 0; i <= OSS_NUM_SOURCES; i++) {
  58                 oss->irq_level[i] = OSS_IRQLEV_DISABLED;
  59         }
  60         /* If we disable VIA1 here, we never really handle it... */
  61         oss->irq_level[OSS_VIA1] = OSS_IRQLEV_VIA1;
  62 }
  63
  64 /*
  65  * Register the OSS and NuBus interrupt dispatchers.
  66  */
  67
  68 void __init oss_register_interrupts(void)
  69 {
  70         request_irq(OSS_IRQLEV_SCSI, oss_irq, IRQ_FLG_LOCK,
  71                         "scsi", (void *) oss);
  72         request_irq(OSS_IRQLEV_IOPSCC, mac_scc_dispatch, IRQ_FLG_LOCK,
  73                         "scc", mac_scc_dispatch);
  74         request_irq(OSS_IRQLEV_NUBUS, oss_nubus_irq, IRQ_FLG_LOCK,
  75                         "nubus", (void *) oss);
  76         request_irq(OSS_IRQLEV_SOUND, oss_irq, IRQ_FLG_LOCK,
  77                         "sound", (void *) oss);
  78         request_irq(OSS_IRQLEV_VIA1, via1_irq, IRQ_FLG_LOCK,
  79                         "via1", (void *) via1);
  80 }
  81
  82 /*
  83  * Initialize OSS for Nubus access
  84  */
  85
  86 void __init oss_nubus_init(void)
  87 {
  88 }
  89
  90 /*
  91  * Handle miscellaneous OSS interrupts. Right now that's just sound
  92  * and SCSI; everything else is routed to its own autovector IRQ.
  93  */
  94
  95 irqreturn_t oss_irq(int irq, void *dev_id)
  96 {
  97         int events;
  98
  99         events = oss->irq_pending & (OSS_IP_SOUND|OSS_IP_SCSI);
 100         if (!events)
 101                 return IRQ_NONE;
 102
 103 #ifdef DEBUG_IRQS
 104         if ((console_loglevel == 10) && !(events & OSS_IP_SCSI)) {
 105                 printk("oss_irq: irq %d events = 0x%04X\n", irq,
 106                         (int) oss->irq_pending);
 107         }
 108 #endif
 109         /* FIXME: how do you clear a pending IRQ?    */
 110
 111         if (events & OSS_IP_SOUND) {
 112                 oss->irq_pending &= ~OSS_IP_SOUND;
 113                 /* FIXME: call sound handler */
 114         } else if (events & OSS_IP_SCSI) {
 115                 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED;
 116                 oss->irq_pending &= ~OSS_IP_SCSI;
 117                 m68k_handle_int(IRQ_MAC_SCSI);
 118                 oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI;
 119         } else {
 120                 /* FIXME: error check here? */
 121         }
 122         return IRQ_HANDLED;
 123 }
 124
 125 /*
 126  * Nubus IRQ handler, OSS style
 127  *
 128  * Unlike the VIA/RBV this is on its own autovector interrupt level.
 129  */
 130
 131 irqreturn_t oss_nubus_irq(int irq, void *dev_id)
 132 {
 133         int events, irq_bit, i;
 134
 135         events = oss->irq_pending & OSS_IP_NUBUS;
 136         if (!events)
 137                 return IRQ_NONE;
 138
 139 #ifdef DEBUG_NUBUS_INT
 140         if (console_loglevel > 7) {
 141                 printk("oss_nubus_irq: events = 0x%04X\n", events);
 142         }
 143 #endif
 144         /* There are only six slots on the OSS, not seven */
 145
 146         i = 6;
 147         irq_bit = 0x40;
 148         do {
 149                 --i;
 150                 irq_bit >>= 1;
 151                 if (events & irq_bit) {
 152                         oss->irq_level[i] = OSS_IRQLEV_DISABLED;
 153                         oss->irq_pending &= ~irq_bit;
 154                         m68k_handle_int(NUBUS_SOURCE_BASE + i);
 155                         oss->irq_level[i] = OSS_IRQLEV_NUBUS;
 156                 }
 157         } while(events & (irq_bit - 1));
 158         return IRQ_HANDLED;
 159 }
 160
 161 /*
 162  * Enable an OSS interrupt
 163  *
 164  * It looks messy but it's rather straightforward. The switch() statement
 165  * just maps the machspec interrupt numbers to the right OSS interrupt
 166  * source (if the OSS handles that interrupt) and then sets the interrupt
 167  * level for that source to nonzero, thus enabling the interrupt.
 168  */
 169
 170 void oss_irq_enable(int irq) {
 171 #ifdef DEBUG_IRQUSE
 172         printk("oss_irq_enable(%d)\n", irq);
 173 #endif
 174         switch(irq) {
 175                 case IRQ_SCC:
 176                 case IRQ_SCCA:
 177                 case IRQ_SCCB:
 178                         oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_IOPSCC;
 179                         break;
 180                 case IRQ_MAC_ADB:
 181                         oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_IOPISM;
 182                         break;
 183                 case IRQ_MAC_SCSI:
 184                         oss->irq_level[OSS_SCSI] = OSS_IRQLEV_SCSI;
 185                         break;
 186                 case IRQ_NUBUS_9:
 187                 case IRQ_NUBUS_A:
 188                 case IRQ_NUBUS_B:
 189                 case IRQ_NUBUS_C:
 190                 case IRQ_NUBUS_D:
 191                 case IRQ_NUBUS_E:
 192                         irq -= NUBUS_SOURCE_BASE;
 193                         oss->irq_level[irq] = OSS_IRQLEV_NUBUS;
 194                         break;
 195 #ifdef DEBUG_IRQUSE
 196                 default:
 197                         printk("%s unknown irq %d\n",__FUNCTION__, irq);
 198                         break;
 199 #endif
 200         }
 201 }
 202
 203 /*
 204  * Disable an OSS interrupt
 205  *
 206  * Same as above except we set the source's interrupt level to zero,
 207  * to disable the interrupt.
 208  */
 209
 210 void oss_irq_disable(int irq) {
 211 #ifdef DEBUG_IRQUSE
 212         printk("oss_irq_disable(%d)\n", irq);
 213 #endif
 214         switch(irq) {
 215                 case IRQ_SCC:
 216                 case IRQ_SCCA:
 217                 case IRQ_SCCB:
 218                         oss->irq_level[OSS_IOPSCC] = OSS_IRQLEV_DISABLED;
 219                         break;
 220                 case IRQ_MAC_ADB:
 221                         oss->irq_level[OSS_IOPISM] = OSS_IRQLEV_DISABLED;
 222                         break;
 223                 case IRQ_MAC_SCSI:
 224                         oss->irq_level[OSS_SCSI] = OSS_IRQLEV_DISABLED;
 225                         break;
 226                 case IRQ_NUBUS_9:
 227                 case IRQ_NUBUS_A:
 228                 case IRQ_NUBUS_B:
 229                 case IRQ_NUBUS_C:
 230                 case IRQ_NUBUS_D:
 231                 case IRQ_NUBUS_E:
 232                         irq -= NUBUS_SOURCE_BASE;
 233                         oss->irq_level[irq] = OSS_IRQLEV_DISABLED;
 234                         break;
 235 #ifdef DEBUG_IRQUSE
 236                 default:
 237                         printk("%s unknown irq %d\n", __FUNCTION__, irq);
 238                         break;
 239 #endif
 240         }
 241 }
 242
 243 /*
 244  * Clear an OSS interrupt
 245  *
 246  * Not sure if this works or not but it's the only method I could
 247  * think of based on the contents of the mac_oss structure.
 248  */
 249
 250 void oss_irq_clear(int irq) {
 251         /* FIXME: how to do this on OSS? */
 252         switch(irq) {
 253                 case IRQ_SCC:
 254                 case IRQ_SCCA:
 255                 case IRQ_SCCB:
 256                         oss->irq_pending &= ~OSS_IP_IOPSCC;
 257                         break;
 258                 case IRQ_MAC_ADB:
 259                         oss->irq_pending &= ~OSS_IP_IOPISM;
 260                         break;
 261                 case IRQ_MAC_SCSI:
 262                         oss->irq_pending &= ~OSS_IP_SCSI;
 263                         break;
 264                 case IRQ_NUBUS_9:
 265                 case IRQ_NUBUS_A:
 266                 case IRQ_NUBUS_B:
 267                 case IRQ_NUBUS_C:
 268                 case IRQ_NUBUS_D:
 269                 case IRQ_NUBUS_E:
 270                         irq -= NUBUS_SOURCE_BASE;
 271                         oss->irq_pending &= ~(1 << irq);
 272                         break;
 273         }
 274 }
 275
 276 /*
 277  * Check to see if a specific OSS interrupt is pending
 278  */
 279
 280 int oss_irq_pending(int irq)
 281 {
 282         switch(irq) {
 283                 case IRQ_SCC:
 284                 case IRQ_SCCA:
 285                 case IRQ_SCCB:
 286                         return oss->irq_pending & OSS_IP_IOPSCC;
 287                         break;
 288                 case IRQ_MAC_ADB:
 289                         return oss->irq_pending & OSS_IP_IOPISM;
 290                         break;
 291                 case IRQ_MAC_SCSI:
 292                         return oss->irq_pending & OSS_IP_SCSI;
 293                         break;
 294                 case IRQ_NUBUS_9:
 295                 case IRQ_NUBUS_A:
 296                 case IRQ_NUBUS_B:
 297                 case IRQ_NUBUS_C:
 298                 case IRQ_NUBUS_D:
 299                 case IRQ_NUBUS_E:
 300                         irq -= NUBUS_SOURCE_BASE;
 301                         return oss->irq_pending & (1 << irq);
 302                         break;
 303         }
 304         return 0;
 305 }