git.oblomov.eu Git - linux-2.6/blob - 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(unsigned int irq)
  59 {
  60         unsigned long flags;
  61         unsigned long mask;
  62         unsigned int reg;
  63         unsigned char bit;
  64
  65         irq -= START_EXT_IRQS;
  66         reg = EPLD_MASK_BASE + ((irq / 8) << 2);
  67         bit = 1<<(irq % 8);
  68         local_irq_save(flags);
  69         mask = ctrl_inl(reg);
  70         mask |= bit;
  71         ctrl_outl(mask, reg);
  72         local_irq_restore(flags);
  73 }
  74
  75 void disable_cayman_irq(unsigned int irq)
  76 {
  77         unsigned long flags;
  78         unsigned long mask;
  79         unsigned int reg;
  80         unsigned char bit;
  81
  82         irq -= START_EXT_IRQS;
  83         reg = EPLD_MASK_BASE + ((irq / 8) << 2);
  84         bit = 1<<(irq % 8);
  85         local_irq_save(flags);
  86         mask = ctrl_inl(reg);
  87         mask &= ~bit;
  88         ctrl_outl(mask, reg);
  89         local_irq_restore(flags);
  90 }
  91
  92 static void ack_cayman_irq(unsigned int irq)
  93 {
  94         disable_cayman_irq(irq);
  95 }
  96
  97 static void end_cayman_irq(unsigned int irq)
  98 {
  99         if (!(irq_desc[irq].status & (IRQ_DISABLED|IRQ_INPROGRESS)))
 100                 enable_cayman_irq(irq);
 101 }
 102
 103 static unsigned int startup_cayman_irq(unsigned int irq)
 104 {
 105         enable_cayman_irq(irq);
 106         return 0; /* never anything pending */
 107 }
 108
 109 static void shutdown_cayman_irq(unsigned int irq)
 110 {
 111         disable_cayman_irq(irq);
 112 }
 113
 114 struct hw_interrupt_type cayman_irq_type = {
 115         .typename       = "Cayman-IRQ",
 116         .startup        = startup_cayman_irq,
 117         .shutdown       = shutdown_cayman_irq,
 118         .enable         = enable_cayman_irq,
 119         .disable        = disable_cayman_irq,
 120         .ack            = ack_cayman_irq,
 121         .end            = end_cayman_irq,
 122 };
 123
 124 int cayman_irq_demux(int evt)
 125 {
 126         int irq = intc_evt_to_irq[evt];
 127
 128         if (irq == SMSC_IRQ) {
 129                 unsigned long status;
 130                 int i;
 131
 132                 status = ctrl_inl(EPLD_STATUS_BASE) &
 133                          ctrl_inl(EPLD_MASK_BASE) & 0xff;
 134                 if (status == 0) {
 135                         irq = -1;
 136                 } else {
 137                         for (i=0; i<8; i++) {
 138                                 if (status & (1<<i))
 139                                         break;
 140                         }
 141                         irq = START_EXT_IRQS + i;
 142                 }
 143         }
 144
 145         if (irq == PCI2_IRQ) {
 146                 unsigned long status;
 147                 int i;
 148
 149                 status = ctrl_inl(EPLD_STATUS_BASE + 3 * sizeof(u32)) &
 150                          ctrl_inl(EPLD_MASK_BASE + 3 * sizeof(u32)) & 0xff;
 151                 if (status == 0) {
 152                         irq = -1;
 153                 } else {
 154                         for (i=0; i<8; i++) {
 155                                 if (status & (1<<i))
 156                                         break;
 157                         }
 158                         irq = START_EXT_IRQS + (3 * 8) + i;
 159                 }
 160         }
 161
 162         return irq;
 163 }
 164
 165 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)
 166 int cayman_irq_describe(char* p, int irq)
 167 {
 168         if (irq < NR_INTC_IRQS) {
 169                 return intc_irq_describe(p, irq);
 170         } else if (irq < NR_INTC_IRQS + 8) {
 171                 return sprintf(p, "(SMSC %d)", irq - NR_INTC_IRQS);
 172         } else if ((irq >= NR_INTC_IRQS + 24) && (irq < NR_INTC_IRQS + 32)) {
 173                 return sprintf(p, "(PCI2 %d)", irq - (NR_INTC_IRQS + 24));
 174         }
 175
 176         return 0;
 177 }
 178 #endif
 179
 180 void init_cayman_irq(void)
 181 {
 182         int i;
 183
 184         epld_virt = onchip_remap(EPLD_BASE, 1024, "EPLD");
 185         if (!epld_virt) {
 186                 printk(KERN_ERR "Cayman IRQ: Unable to remap EPLD\n");
 187                 return;
 188         }
 189
 190         for (i=0; i<NR_EXT_IRQS; i++) {
 191                 irq_desc[START_EXT_IRQS + i].chip = &cayman_irq_type;
 192         }
 193
 194         /* Setup the SMSC interrupt */
 195         setup_irq(SMSC_IRQ, &cayman_action_smsc);
 196         setup_irq(PCI2_IRQ, &cayman_action_pci2);
 197 }