arch/sh/boards/mach-cayman/irq.c

   1 /*
   2  * arch/sh/mach-cayman/irq.c - SH-5 Cayman Interrupt Support
   3  *
   4  * This file handles the board specific parts of the Cayman interrupt system
   5  *
   6  * Copyright (C) 2002 Stuart Menefy
   7  *
   8  * This file is subject to the terms and conditions of the GNU General Public
   9  * License.  See the file "COPYING" in the main directory of this archive
  10  * for more details.
  11  */
  12 #include <linux/io.h>
  13 #include <linux/irq.h>
  14 #include <linux/interrupt.h>
  15 #include <linux/signal.h>
  16 #include <cpu/irq.h>
  17 #include <asm/page.h>
  18
  19 /* Setup for the SMSC FDC37C935 / LAN91C100FD */
  20 #define SMSC_IRQ         IRQ_IRL1
  21
  22 /* Setup for PCI Bus 2, which transmits interrupts via the EPLD */
  23 #define PCI2_IRQ         IRQ_IRL3
  24
  25 unsigned long epld_virt;
  26
  27 #define EPLD_BASE        0x04002000
  28 #define EPLD_STATUS_BASE (epld_virt + 0x10)
  29 #define EPLD_MASK_BASE   (epld_virt + 0x20)
  30
  31 /* Note the SMSC SuperIO chip and SMSC LAN chip interrupts are all muxed onto
  32    the same SH-5 interrupt */
  33
  34 static irqreturn_t cayman_interrupt_smsc(int irq, void *dev_id)
  35 {
  36         printk(KERN_INFO "CAYMAN: spurious SMSC interrupt\n");
  37         return IRQ_NONE;
  38 }
  39
  40 static irqreturn_t cayman_interrupt_pci2(int irq, void *dev_id)
  41 {
  42         printk(KERN_INFO "CAYMAN: spurious PCI interrupt, IRQ %d\n", irq);
  43         return IRQ_NONE;
  44 }
  45
  46 static struct irqaction cayman_action_smsc = {
  47         .name           = "Cayman SMSC Mux",
  48         .handler        = cayman_interrupt_smsc,
  49         .flags          = IRQF_DISABLED,
  50 };
  51
  52 static struct irqaction cayman_action_pci2 = {
  53         .name           = "Cayman PCI2 Mux",
  54         .handler        = cayman_interrupt_pci2,
  55         .flags          = IRQF_DISABLED,
  56 };
  57
  58 static void enable_cayman_irq(struct irq_data *data)
  59 {
  60         unsigned int irq = data->irq;
  61         unsigned long flags;
  62         unsigned long mask;
  63         unsigned int reg;
  64         unsigned char bit;
  65
  66         irq -= START_EXT_IRQS;
  67         reg = EPLD_MASK_BASE + ((irq / 8) << 2);
  68         bit = 1<<(irq % 8);
  69         local_irq_save(flags);
  70         mask = __raw_readl(reg);
  71         mask |= bit;
  72         __raw_writel(mask, reg);
  73         local_irq_restore(flags);
  74 }
  75
  76 static void disable_cayman_irq(struct irq_data *data)
  77 {
  78         unsigned int irq = data->irq;
  79         unsigned long flags;
  80         unsigned long mask;
  81         unsigned int reg;
  82         unsigned char bit;
  83
  84         irq -= START_EXT_IRQS;
  85         reg = EPLD_MASK_BASE + ((irq / 8) << 2);
  86         bit = 1<<(irq % 8);
  87         local_irq_save(flags);
  88         mask = __raw_readl(reg);
  89         mask &= ~bit;
  90         __raw_writel(mask, reg);
  91         local_irq_restore(flags);
  92 }
  93
  94 struct irq_chip cayman_irq_type = {
  95         .name           = "Cayman-IRQ",
  96         .irq_unmask     = enable_cayman_irq,
  97         .irq_mask       = disable_cayman_irq,
  98 };
  99
 100 int cayman_irq_demux(int evt)
 101 {
 102         int irq = intc_evt_to_irq[evt];
 103
 104         if (irq == SMSC_IRQ) {
 105                 unsigned long status;
 106                 int i;
 107
 108                 status = __raw_readl(EPLD_STATUS_BASE) &
 109                          __raw_readl(EPLD_MASK_BASE) & 0xff;
 110                 if (status == 0) {
 111                         irq = -1;
 112                 } else {
 113                         for (i=0; i<8; i++) {
 114                                 if (status & (1<<i))
 115                                         break;
 116                         }
 117                         irq = START_EXT_IRQS + i;
 118                 }
 119         }
 120
 121         if (irq == PCI2_IRQ) {
 122                 unsigned long status;
 123                 int i;
 124
 125                 status = __raw_readl(EPLD_STATUS_BASE + 3 * sizeof(u32)) &
 126                          __raw_readl(EPLD_MASK_BASE + 3 * sizeof(u32)) & 0xff;
 127                 if (status == 0) {
 128                         irq = -1;
 129                 } else {
 130                         for (i=0; i<8; i++) {
 131                                 if (status & (1<<i))
 132                                         break;
 133                         }
 134                         irq = START_EXT_IRQS + (3 * 8) + i;
 135                 }
 136         }
 137
 138         return irq;
 139 }
 140
 141 void init_cayman_irq(void)
 142 {
 143         int i;
 144
 145         epld_virt = (unsigned long)ioremap_nocache(EPLD_BASE, 1024);
 146         if (!epld_virt) {
 147                 printk(KERN_ERR "Cayman IRQ: Unable to remap EPLD\n");
 148                 return;
 149         }
 150
 151         for (i = 0; i < NR_EXT_IRQS; i++) {
 152                 irq_set_chip_and_handler(START_EXT_IRQS + i,
 153                                          &cayman_irq_type, handle_level_irq);
 154         }
 155
 156         /* Setup the SMSC interrupt */
 157         setup_irq(SMSC_IRQ, &cayman_action_smsc);
 158         setup_irq(PCI2_IRQ, &cayman_action_pci2);
 159 }