arch/m68k/mac/via.c

   1 /*
   2  *      6522 Versatile Interface Adapter (VIA)
   3  *
   4  *      There are two of these on the Mac II. Some IRQs are vectored
   5  *      via them as are assorted bits and bobs - eg RTC, ADB.
   6  *
   7  * CSA: Motorola seems to have removed documentation on the 6522 from
   8  * their web site; try
   9  *     http://nerini.drf.com/vectrex/other/text/chips/6522/
  10  *     http://www.zymurgy.net/classic/vic20/vicdet1.htm
  11  * and
  12  *     http://193.23.168.87/mikro_laborversuche/via_iobaustein/via6522_1.html
  13  * for info.  A full-text web search on 6522 AND VIA will probably also
  14  * net some usefulness. <cananian@alumni.princeton.edu> 20apr1999
  15  *
  16  * Additional data is here (the SY6522 was used in the Mac II etc):
  17  *     http://www.6502.org/documents/datasheets/synertek/synertek_sy6522.pdf
  18  *     http://www.6502.org/documents/datasheets/synertek/synertek_sy6522_programming_reference.pdf
  19  *
  20  * PRAM/RTC access algorithms are from the NetBSD RTC toolkit version 1.08b
  21  * by Erik Vogan and adapted to Linux by Joshua M. Thompson (funaho@jurai.org)
  22  *
  23  */
  24
  25 #include <linux/types.h>
  26 #include <linux/kernel.h>
  27 #include <linux/mm.h>
  28 #include <linux/delay.h>
  29 #include <linux/init.h>
  30 #include <linux/module.h>
  31 #ifdef CONFIG_GENERIC_HARDIRQS
  32 #include <linux/irq.h>
  33 #endif
  34
  35 #include <asm/bootinfo.h>
  36 #include <asm/macintosh.h>
  37 #include <asm/macints.h>
  38 #include <asm/mac_via.h>
  39 #include <asm/mac_psc.h>
  40 #include <asm/mac_oss.h>
  41
  42 volatile __u8 *via1, *via2;
  43 int rbv_present;
  44 int via_alt_mapping;
  45 EXPORT_SYMBOL(via_alt_mapping);
  46 static __u8 rbv_clear;
  47
  48 /*
  49  * Globals for accessing the VIA chip registers without having to
  50  * check if we're hitting a real VIA or an RBV. Normally you could
  51  * just hit the combined register (ie, vIER|rIER) but that seems to
  52  * break on AV Macs...probably because they actually decode more than
  53  * eight address bits. Why can't Apple engineers at least be
  54  * _consistently_ lazy?                          - 1999-05-21 (jmt)
  55  */
  56
  57 static int gIER,gIFR,gBufA,gBufB;
  58
  59 /*
  60  * Timer defs.
  61  */
  62
  63 #define TICK_SIZE               10000
  64 #define MAC_CLOCK_TICK          (783300/HZ)             /* ticks per HZ */
  65 #define MAC_CLOCK_LOW           (MAC_CLOCK_TICK&0xFF)
  66 #define MAC_CLOCK_HIGH          (MAC_CLOCK_TICK>>8)
  67
  68 /* To disable a NuBus slot on Quadras we make that slot IRQ line an output set
  69  * high. On RBV we just use the slot interrupt enable register. On Macs with
  70  * genuine VIA chips we must use nubus_disabled to keep track of disabled slot
  71  * interrupts. When any slot IRQ is disabled we mask the (edge triggered) CA1
  72  * or "SLOTS" interrupt. When no slot is disabled, we unmask the CA1 interrupt.
  73  * So, on genuine VIAs, having more than one NuBus IRQ can mean trouble,
  74  * because closing one of those drivers can mask all of the NuBus interrupts.
  75  * Also, since we can't mask the unregistered slot IRQs on genuine VIAs, it's
  76  * possible to get interrupts from cards that MacOS or the ROM has configured
  77  * but we have not. FWIW, "Designing Cards and Drivers for Macintosh II and
  78  * Macintosh SE", page 9-8, says, a slot IRQ with no driver would crash MacOS.
  79  */
  80 static u8 nubus_disabled;
  81
  82 void via_debug_dump(void);
  83 irqreturn_t via1_irq(int, void *);
  84 irqreturn_t via2_irq(int, void *);
  85 irqreturn_t via_nubus_irq(int, void *);
  86 void via_irq_enable(int irq);
  87 void via_irq_disable(int irq);
  88 void via_irq_clear(int irq);
  89
  90 /*
  91  * Initialize the VIAs
  92  *
  93  * First we figure out where they actually _are_ as well as what type of
  94  * VIA we have for VIA2 (it could be a real VIA or an RBV or even an OSS.)
  95  * Then we pretty much clear them out and disable all IRQ sources.
  96  *
  97  * Note: the OSS is actually "detected" here and not in oss_init(). It just
  98  *       seems more logical to do it here since via_init() needs to know
  99  *       these things anyways.
 100  */
 101
 102 void __init via_init(void)
 103 {
 104         switch(macintosh_config->via_type) {
 105
 106                 /* IIci, IIsi, IIvx, IIvi (P6xx), LC series */
 107
 108                 case MAC_VIA_IIci:
 109                         via1 = (void *) VIA1_BASE;
 110                         if (macintosh_config->ident == MAC_MODEL_IIFX) {
 111                                 via2 = NULL;
 112                                 rbv_present = 0;
 113                                 oss_present = 1;
 114                         } else {
 115                                 via2 = (void *) RBV_BASE;
 116                                 rbv_present = 1;
 117                                 oss_present = 0;
 118                         }
 119                         if (macintosh_config->ident == MAC_MODEL_LCIII) {
 120                                 rbv_clear = 0x00;
 121                         } else {
 122                                 /* on most RBVs (& unlike the VIAs), you   */
 123                                 /* need to set bit 7 when you write to IFR */
 124                                 /* in order for your clear to occur.       */
 125                                 rbv_clear = 0x80;
 126                         }
 127                         gIER = rIER;
 128                         gIFR = rIFR;
 129                         gBufA = rSIFR;
 130                         gBufB = rBufB;
 131                         break;
 132
 133                 /* Quadra and early MacIIs agree on the VIA locations */
 134
 135                 case MAC_VIA_QUADRA:
 136                 case MAC_VIA_II:
 137                         via1 = (void *) VIA1_BASE;
 138                         via2 = (void *) VIA2_BASE;
 139                         rbv_present = 0;
 140                         oss_present = 0;
 141                         rbv_clear = 0x00;
 142                         gIER = vIER;
 143                         gIFR = vIFR;
 144                         gBufA = vBufA;
 145                         gBufB = vBufB;
 146                         break;
 147                 default:
 148                         panic("UNKNOWN VIA TYPE");
 149         }
 150
 151         printk(KERN_INFO "VIA1 at %p is a 6522 or clone\n", via1);
 152
 153         printk(KERN_INFO "VIA2 at %p is ", via2);
 154         if (rbv_present) {
 155                 printk("an RBV\n");
 156         } else if (oss_present) {
 157                 printk("an OSS\n");
 158         } else {
 159                 printk("a 6522 or clone\n");
 160         }
 161
 162 #ifdef DEBUG_VIA
 163         via_debug_dump();
 164 #endif
 165
 166         /*
 167          * Shut down all IRQ sources, reset the timers, and
 168          * kill the timer latch on VIA1.
 169          */
 170
 171         via1[vIER] = 0x7F;
 172         via1[vIFR] = 0x7F;
 173         via1[vT1LL] = 0;
 174         via1[vT1LH] = 0;
 175         via1[vT1CL] = 0;
 176         via1[vT1CH] = 0;
 177         via1[vT2CL] = 0;
 178         via1[vT2CH] = 0;
 179         via1[vACR] &= ~0xC0; /* setup T1 timer with no PB7 output */
 180         via1[vACR] &= ~0x03; /* disable port A & B latches */
 181
 182         /*
 183          * SE/30: disable video IRQ
 184          * XXX: testing for SE/30 VBL
 185          */
 186
 187         if (macintosh_config->ident == MAC_MODEL_SE30) {
 188                 via1[vDirB] |= 0x40;
 189                 via1[vBufB] |= 0x40;
 190         }
 191
 192         /*
 193          * Set the RTC bits to a known state: all lines to outputs and
 194          * RTC disabled (yes that's 0 to enable and 1 to disable).
 195          */
 196
 197         via1[vDirB] |= (VIA1B_vRTCEnb | VIA1B_vRTCClk | VIA1B_vRTCData);
 198         via1[vBufB] |= (VIA1B_vRTCEnb | VIA1B_vRTCClk);
 199
 200         /* Everything below this point is VIA2/RBV only... */
 201
 202         if (oss_present)
 203                 return;
 204
 205         /* Some machines support an alternate IRQ mapping that spreads  */
 206         /* Ethernet and Sound out to their own autolevel IRQs and moves */
 207         /* VIA1 to level 6. A/UX uses this mapping and we do too.  Note */
 208         /* that the IIfx emulates this alternate mapping using the OSS. */
 209
 210         via_alt_mapping = 0;
 211         if (macintosh_config->via_type == MAC_VIA_QUADRA)
 212                 switch (macintosh_config->ident) {
 213                 case MAC_MODEL_C660:
 214                 case MAC_MODEL_Q840:
 215                         /* not applicable */
 216                         break;
 217                 case MAC_MODEL_P588:
 218                 case MAC_MODEL_TV:
 219                 case MAC_MODEL_PB140:
 220                 case MAC_MODEL_PB145:
 221                 case MAC_MODEL_PB160:
 222                 case MAC_MODEL_PB165:
 223                 case MAC_MODEL_PB165C:
 224                 case MAC_MODEL_PB170:
 225                 case MAC_MODEL_PB180:
 226                 case MAC_MODEL_PB180C:
 227                 case MAC_MODEL_PB190:
 228                 case MAC_MODEL_PB520:
 229                         /* not yet tested */
 230                         break;
 231                 default:
 232                         via_alt_mapping = 1;
 233                         via1[vDirB] |= 0x40;
 234                         via1[vBufB] &= ~0x40;
 235                         break;
 236                 }
 237
 238         /*
 239          * Now initialize VIA2. For RBV we just kill all interrupts;
 240          * for a regular VIA we also reset the timers and stuff.
 241          */
 242
 243         via2[gIER] = 0x7F;
 244         via2[gIFR] = 0x7F | rbv_clear;
 245         if (!rbv_present) {
 246                 via2[vT1LL] = 0;
 247                 via2[vT1LH] = 0;
 248                 via2[vT1CL] = 0;
 249                 via2[vT1CH] = 0;
 250                 via2[vT2CL] = 0;
 251                 via2[vT2CH] = 0;
 252                 via2[vACR] &= ~0xC0; /* setup T1 timer with no PB7 output */
 253                 via2[vACR] &= ~0x03; /* disable port A & B latches */
 254         }
 255
 256         /*
 257          * Set vPCR for control line interrupts (but not on RBV)
 258          */
 259         if (!rbv_present) {
 260                 /* For all VIA types, CA1 (SLOTS IRQ) and CB1 (ASC IRQ)
 261                  * are made negative edge triggered here.
 262                  */
 263                 if (macintosh_config->scsi_type == MAC_SCSI_OLD) {
 264                         /* CB2 (IRQ) indep. input, positive edge */
 265                         /* CA2 (DRQ) indep. input, positive edge */
 266                         via2[vPCR] = 0x66;
 267                 } else {
 268                         /* CB2 (IRQ) indep. input, negative edge */
 269                         /* CA2 (DRQ) indep. input, negative edge */
 270                         via2[vPCR] = 0x22;
 271                 }
 272         }
 273 }
 274
 275 /*
 276  * Start the 100 Hz clock
 277  */
 278
 279 void __init via_init_clock(irq_handler_t func)
 280 {
 281         via1[vACR] |= 0x40;
 282         via1[vT1LL] = MAC_CLOCK_LOW;
 283         via1[vT1LH] = MAC_CLOCK_HIGH;
 284         via1[vT1CL] = MAC_CLOCK_LOW;
 285         via1[vT1CH] = MAC_CLOCK_HIGH;
 286
 287         if (request_irq(IRQ_MAC_TIMER_1, func, 0, "timer", func))
 288                 pr_err("Couldn't register %s interrupt\n", "timer");
 289 }
 290
 291 /*
 292  * Register the interrupt dispatchers for VIA or RBV machines only.
 293  */
 294
 295 void __init via_register_interrupts(void)
 296 {
 297         if (via_alt_mapping) {
 298                 if (request_irq(IRQ_AUTO_1, via1_irq, 0, "software",
 299                                 (void *)via1))
 300                         pr_err("Couldn't register %s interrupt\n", "software");
 301                 if (request_irq(IRQ_AUTO_6, via1_irq, 0, "via1", (void *)via1))
 302                         pr_err("Couldn't register %s interrupt\n", "via1");
 303         } else {
 304                 if (request_irq(IRQ_AUTO_1, via1_irq, 0, "via1", (void *)via1))
 305                         pr_err("Couldn't register %s interrupt\n", "via1");
 306         }
 307         if (request_irq(IRQ_AUTO_2, via2_irq, 0, "via2", (void *)via2))
 308                 pr_err("Couldn't register %s interrupt\n", "via2");
 309         if (request_irq(IRQ_MAC_NUBUS, via_nubus_irq, 0, "nubus",
 310                         (void *)via2))
 311                 pr_err("Couldn't register %s interrupt\n", "nubus");
 312 }
 313
 314 /*
 315  * Debugging dump, used in various places to see what's going on.
 316  */
 317
 318 void via_debug_dump(void)
 319 {
 320         printk(KERN_DEBUG "VIA1: DDRA = 0x%02X DDRB = 0x%02X ACR = 0x%02X\n",
 321                 (uint) via1[vDirA], (uint) via1[vDirB], (uint) via1[vACR]);
 322         printk(KERN_DEBUG "         PCR = 0x%02X  IFR = 0x%02X IER = 0x%02X\n",
 323                 (uint) via1[vPCR], (uint) via1[vIFR], (uint) via1[vIER]);
 324         if (oss_present) {
 325                 printk(KERN_DEBUG "VIA2: <OSS>\n");
 326         } else if (rbv_present) {
 327                 printk(KERN_DEBUG "VIA2:  IFR = 0x%02X  IER = 0x%02X\n",
 328                         (uint) via2[rIFR], (uint) via2[rIER]);
 329                 printk(KERN_DEBUG "      SIFR = 0x%02X SIER = 0x%02X\n",
 330                         (uint) via2[rSIFR], (uint) via2[rSIER]);
 331         } else {
 332                 printk(KERN_DEBUG "VIA2: DDRA = 0x%02X DDRB = 0x%02X ACR = 0x%02X\n",
 333                         (uint) via2[vDirA], (uint) via2[vDirB],
 334                         (uint) via2[vACR]);
 335                 printk(KERN_DEBUG "         PCR = 0x%02X  IFR = 0x%02X IER = 0x%02X\n",
 336                         (uint) via2[vPCR],
 337                         (uint) via2[vIFR], (uint) via2[vIER]);
 338         }
 339 }
 340
 341 /*
 342  * This is always executed with interrupts disabled.
 343  *
 344  * TBI: get time offset between scheduling timer ticks
 345  */
 346
 347 unsigned long mac_gettimeoffset (void)
 348 {
 349         unsigned long ticks, offset = 0;
 350
 351         /* read VIA1 timer 2 current value */
 352         ticks = via1[vT1CL] | (via1[vT1CH] << 8);
 353         /* The probability of underflow is less than 2% */
 354         if (ticks > MAC_CLOCK_TICK - MAC_CLOCK_TICK / 50)
 355                 /* Check for pending timer interrupt in VIA1 IFR */
 356                 if (via1[vIFR] & 0x40) offset = TICK_SIZE;
 357
 358         ticks = MAC_CLOCK_TICK - ticks;
 359         ticks = ticks * 10000L / MAC_CLOCK_TICK;
 360
 361         return ticks + offset;
 362 }
 363
 364 /*
 365  * Flush the L2 cache on Macs that have it by flipping
 366  * the system into 24-bit mode for an instant.
 367  */
 368
 369 void via_flush_cache(void)
 370 {
 371         via2[gBufB] &= ~VIA2B_vMode32;
 372         via2[gBufB] |= VIA2B_vMode32;
 373 }
 374
 375 /*
 376  * Return the status of the L2 cache on a IIci
 377  */
 378
 379 int via_get_cache_disable(void)
 380 {
 381         /* Safeguard against being called accidentally */
 382         if (!via2) {
 383                 printk(KERN_ERR "via_get_cache_disable called on a non-VIA machine!\n");
 384                 return 1;
 385         }
 386
 387         return (int) via2[gBufB] & VIA2B_vCDis;
 388 }
 389
 390 /*
 391  * Initialize VIA2 for Nubus access
 392  */
 393
 394 void __init via_nubus_init(void)
 395 {
 396         /* unlock nubus transactions */
 397
 398         if ((macintosh_config->adb_type != MAC_ADB_PB1) &&
 399             (macintosh_config->adb_type != MAC_ADB_PB2)) {
 400                 /* set the line to be an output on non-RBV machines */
 401                 if (!rbv_present)
 402                         via2[vDirB] |= 0x02;
 403
 404                 /* this seems to be an ADB bit on PMU machines */
 405                 /* according to MkLinux.  -- jmt               */
 406                 via2[gBufB] |= 0x02;
 407         }
 408
 409         /* Disable all the slot interrupts (where possible). */
 410
 411         switch (macintosh_config->via_type) {
 412         case MAC_VIA_II:
 413                 /* Just make the port A lines inputs. */
 414                 switch(macintosh_config->ident) {
 415                 case MAC_MODEL_II:
 416                 case MAC_MODEL_IIX:
 417                 case MAC_MODEL_IICX:
 418                 case MAC_MODEL_SE30:
 419                         /* The top two bits are RAM size outputs. */
 420                         via2[vDirA] &= 0xC0;
 421                         break;
 422                 default:
 423                         via2[vDirA] &= 0x80;
 424                 }
 425                 break;
 426         case MAC_VIA_IIci:
 427                 /* RBV. Disable all the slot interrupts. SIER works like IER. */
 428                 via2[rSIER] = 0x7F;
 429                 break;
 430         case MAC_VIA_QUADRA:
 431                 /* Disable the inactive slot interrupts by making those lines outputs. */
 432                 if ((macintosh_config->adb_type != MAC_ADB_PB1) &&
 433                     (macintosh_config->adb_type != MAC_ADB_PB2)) {
 434                         via2[vBufA] |= 0x7F;
 435                         via2[vDirA] |= 0x7F;
 436                 }
 437                 break;
 438         }
 439 }
 440
 441 /*
 442  * The generic VIA interrupt routines (shamelessly stolen from Alan Cox's
 443  * via6522.c :-), disable/pending masks added.
 444  */
 445
 446 irqreturn_t via1_irq(int irq, void *dev_id)
 447 {
 448         int irq_num;
 449         unsigned char irq_bit, events;
 450
 451         events = via1[vIFR] & via1[vIER] & 0x7F;
 452         if (!events)
 453                 return IRQ_NONE;
 454
 455         irq_num = VIA1_SOURCE_BASE;
 456         irq_bit = 1;
 457         do {
 458                 if (events & irq_bit) {
 459                         via1[vIFR] = irq_bit;
 460                         generic_handle_irq(irq_num);
 461                 }
 462                 ++irq_num;
 463                 irq_bit <<= 1;
 464         } while (events >= irq_bit);
 465         return IRQ_HANDLED;
 466 }
 467
 468 irqreturn_t via2_irq(int irq, void *dev_id)
 469 {
 470         int irq_num;
 471         unsigned char irq_bit, events;
 472
 473         events = via2[gIFR] & via2[gIER] & 0x7F;
 474         if (!events)
 475                 return IRQ_NONE;
 476
 477         irq_num = VIA2_SOURCE_BASE;
 478         irq_bit = 1;
 479         do {
 480                 if (events & irq_bit) {
 481                         via2[gIFR] = irq_bit | rbv_clear;
 482                         generic_handle_irq(irq_num);
 483                 }
 484                 ++irq_num;
 485                 irq_bit <<= 1;
 486         } while (events >= irq_bit);
 487         return IRQ_HANDLED;
 488 }
 489
 490 /*
 491  * Dispatch Nubus interrupts. We are called as a secondary dispatch by the
 492  * VIA2 dispatcher as a fast interrupt handler.
 493  */
 494
 495 irqreturn_t via_nubus_irq(int irq, void *dev_id)
 496 {
 497         int slot_irq;
 498         unsigned char slot_bit, events;
 499
 500         events = ~via2[gBufA] & 0x7F;
 501         if (rbv_present)
 502                 events &= via2[rSIER];
 503         else
 504                 events &= ~via2[vDirA];
 505         if (!events)
 506                 return IRQ_NONE;
 507
 508         do {
 509                 slot_irq = IRQ_NUBUS_F;
 510                 slot_bit = 0x40;
 511                 do {
 512                         if (events & slot_bit) {
 513                                 events &= ~slot_bit;
 514                                 generic_handle_irq(slot_irq);
 515                         }
 516                         --slot_irq;
 517                         slot_bit >>= 1;
 518                 } while (events);
 519
 520                 /* clear the CA1 interrupt and make certain there's no more. */
 521                 via2[gIFR] = 0x02 | rbv_clear;
 522                 events = ~via2[gBufA] & 0x7F;
 523                 if (rbv_present)
 524                         events &= via2[rSIER];
 525                 else
 526                         events &= ~via2[vDirA];
 527         } while (events);
 528         return IRQ_HANDLED;
 529 }
 530
 531 void via_irq_enable(int irq) {
 532         int irq_src     = IRQ_SRC(irq);
 533         int irq_idx     = IRQ_IDX(irq);
 534
 535 #ifdef DEBUG_IRQUSE
 536         printk(KERN_DEBUG "via_irq_enable(%d)\n", irq);
 537 #endif
 538
 539         if (irq_src == 1) {
 540                 via1[vIER] = IER_SET_BIT(irq_idx);
 541         } else if (irq_src == 2) {
 542                 if (irq != IRQ_MAC_NUBUS || nubus_disabled == 0)
 543                         via2[gIER] = IER_SET_BIT(irq_idx);
 544         } else if (irq_src == 7) {
 545                 switch (macintosh_config->via_type) {
 546                 case MAC_VIA_II:
 547                         nubus_disabled &= ~(1 << irq_idx);
 548                         /* Enable the CA1 interrupt when no slot is disabled. */
 549                         if (!nubus_disabled)
 550                                 via2[gIER] = IER_SET_BIT(1);
 551                         break;
 552                 case MAC_VIA_IIci:
 553                         /* On RBV, enable the slot interrupt.
 554                          * SIER works like IER.
 555                          */
 556                         via2[rSIER] = IER_SET_BIT(irq_idx);
 557                         break;
 558                 case MAC_VIA_QUADRA:
 559                         /* Make the port A line an input to enable the slot irq.
 560                          * But not on PowerBooks, that's ADB.
 561                          */
 562                         if ((macintosh_config->adb_type != MAC_ADB_PB1) &&
 563                             (macintosh_config->adb_type != MAC_ADB_PB2))
 564                                 via2[vDirA] &= ~(1 << irq_idx);
 565                         break;
 566                 }
 567         }
 568 }
 569
 570 void via_irq_disable(int irq) {
 571         int irq_src     = IRQ_SRC(irq);
 572         int irq_idx     = IRQ_IDX(irq);
 573
 574 #ifdef DEBUG_IRQUSE
 575         printk(KERN_DEBUG "via_irq_disable(%d)\n", irq);
 576 #endif
 577
 578         if (irq_src == 1) {
 579                 via1[vIER] = IER_CLR_BIT(irq_idx);
 580         } else if (irq_src == 2) {
 581                 via2[gIER] = IER_CLR_BIT(irq_idx);
 582         } else if (irq_src == 7) {
 583                 switch (macintosh_config->via_type) {
 584                 case MAC_VIA_II:
 585                         nubus_disabled |= 1 << irq_idx;
 586                         if (nubus_disabled)
 587                                 via2[gIER] = IER_CLR_BIT(1);
 588                         break;
 589                 case MAC_VIA_IIci:
 590                         via2[rSIER] = IER_CLR_BIT(irq_idx);
 591                         break;
 592                 case MAC_VIA_QUADRA:
 593                         if ((macintosh_config->adb_type != MAC_ADB_PB1) &&
 594                             (macintosh_config->adb_type != MAC_ADB_PB2))
 595                                 via2[vDirA] |= 1 << irq_idx;
 596                         break;
 597                 }
 598         }
 599 }
 600
 601 void via_irq_clear(int irq) {
 602         int irq_src     = IRQ_SRC(irq);
 603         int irq_idx     = IRQ_IDX(irq);
 604         int irq_bit     = 1 << irq_idx;
 605
 606         if (irq_src == 1) {
 607                 via1[vIFR] = irq_bit;
 608         } else if (irq_src == 2) {
 609                 via2[gIFR] = irq_bit | rbv_clear;
 610         } else if (irq_src == 7) {
 611                 /* FIXME: There is no way to clear an individual nubus slot
 612                  * IRQ flag, other than getting the device to do it.
 613                  */
 614         }
 615 }
 616
 617 /*
 618  * Returns nonzero if an interrupt is pending on the given
 619  * VIA/IRQ combination.
 620  */
 621
 622 int via_irq_pending(int irq)
 623 {
 624         int irq_src     = IRQ_SRC(irq);
 625         int irq_idx     = IRQ_IDX(irq);
 626         int irq_bit     = 1 << irq_idx;
 627
 628         if (irq_src == 1) {
 629                 return via1[vIFR] & irq_bit;
 630         } else if (irq_src == 2) {
 631                 return via2[gIFR] & irq_bit;
 632         } else if (irq_src == 7) {
 633                 /* Always 0 for MAC_VIA_QUADRA if the slot irq is disabled. */
 634                 return ~via2[gBufA] & irq_bit;
 635         }
 636         return 0;
 637 }
 638
 639 void via1_set_head(int head)
 640 {
 641         if (head == 0)
 642                 via1[vBufA] &= ~VIA1A_vHeadSel;
 643         else
 644                 via1[vBufA] |= VIA1A_vHeadSel;
 645 }
 646 EXPORT_SYMBOL(via1_set_head);