arch/mips/emma2rh/markeins/irq_markeins.c

   1 /*
   2  *  arch/mips/emma2rh/markeins/irq_markeins.c
   3  *      This file defines the irq handler for Mark-eins.
   4  *
   5  *  Copyright (C) NEC Electronics Corporation 2004-2006
   6  *
   7  *  This file is based on the arch/mips/ddb5xxx/ddb5477/irq_5477.c
   8  *
   9  *      Copyright 2001 MontaVista Software Inc.
  10  *
  11  *  This program is free software; you can redistribute it and/or modify
  12  *  it under the terms of the GNU General Public License as published by
  13  *  the Free Software Foundation; either version 2 of the License, or
  14  *  (at your option) any later version.
  15  *
  16  *  This program is distributed in the hope that it will be useful,
  17  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  *  GNU General Public License for more details.
  20  *
  21  *  You should have received a copy of the GNU General Public License
  22  *  along with this program; if not, write to the Free Software
  23  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25 #include <linux/interrupt.h>
  26 #include <linux/irq.h>
  27 #include <linux/types.h>
  28 #include <linux/ptrace.h>
  29
  30 #include <asm/debug.h>
  31 #include <asm/emma2rh/emma2rh.h>
  32
  33 static int emma2rh_sw_irq_base = -1;
  34 static int emma2rh_gpio_irq_base = -1;
  35
  36 void ll_emma2rh_sw_irq_enable(int reg);
  37 void ll_emma2rh_sw_irq_disable(int reg);
  38 void ll_emma2rh_gpio_irq_enable(int reg);
  39 void ll_emma2rh_gpio_irq_disable(int reg);
  40
  41 static void emma2rh_sw_irq_enable(unsigned int irq)
  42 {
  43         ll_emma2rh_sw_irq_enable(irq - emma2rh_sw_irq_base);
  44 }
  45
  46 static void emma2rh_sw_irq_disable(unsigned int irq)
  47 {
  48         ll_emma2rh_sw_irq_disable(irq - emma2rh_sw_irq_base);
  49 }
  50
  51 static void emma2rh_sw_irq_end(unsigned int irq)
  52 {
  53         if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
  54                 ll_emma2rh_sw_irq_enable(irq - emma2rh_sw_irq_base);
  55 }
  56
  57 struct irq_chip emma2rh_sw_irq_controller = {
  58         .typename = "emma2rh_sw_irq",
  59         .ack = emma2rh_sw_irq_disable,
  60         .mask = emma2rh_sw_irq_disable,
  61         .mask_ack = emma2rh_sw_irq_disable,
  62         .unmask = emma2rh_sw_irq_enable,
  63         .end = emma2rh_sw_irq_end,
  64 };
  65
  66 void emma2rh_sw_irq_init(u32 irq_base)
  67 {
  68         u32 i;
  69
  70         for (i = irq_base; i < irq_base + NUM_EMMA2RH_IRQ_SW; i++)
  71                 set_irq_chip(i, &emma2rh_sw_irq_controller);
  72
  73         emma2rh_sw_irq_base = irq_base;
  74 }
  75
  76 void ll_emma2rh_sw_irq_enable(int irq)
  77 {
  78         u32 reg;
  79
  80         db_assert(irq >= 0);
  81         db_assert(irq < NUM_EMMA2RH_IRQ_SW);
  82
  83         reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
  84         reg |= 1 << irq;
  85         emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
  86 }
  87
  88 void ll_emma2rh_sw_irq_disable(int irq)
  89 {
  90         u32 reg;
  91
  92         db_assert(irq >= 0);
  93         db_assert(irq < 32);
  94
  95         reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
  96         reg &= ~(1 << irq);
  97         emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
  98 }
  99
 100 static void emma2rh_gpio_irq_enable(unsigned int irq)
 101 {
 102         ll_emma2rh_gpio_irq_enable(irq - emma2rh_gpio_irq_base);
 103 }
 104
 105 static void emma2rh_gpio_irq_disable(unsigned int irq)
 106 {
 107         ll_emma2rh_gpio_irq_disable(irq - emma2rh_gpio_irq_base);
 108 }
 109
 110 static void emma2rh_gpio_irq_ack(unsigned int irq)
 111 {
 112         irq -= emma2rh_gpio_irq_base;
 113         emma2rh_out32(EMMA2RH_GPIO_INT_ST, ~(1 << irq));
 114         ll_emma2rh_gpio_irq_disable(irq);
 115 }
 116
 117 static void emma2rh_gpio_irq_end(unsigned int irq)
 118 {
 119         if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
 120                 ll_emma2rh_gpio_irq_enable(irq - emma2rh_gpio_irq_base);
 121 }
 122
 123 struct irq_chip emma2rh_gpio_irq_controller = {
 124         .typename = "emma2rh_gpio_irq",
 125         .ack = emma2rh_gpio_irq_ack,
 126         .mask = emma2rh_gpio_irq_disable,
 127         .mask_ack = emma2rh_gpio_irq_ack,
 128         .unmask = emma2rh_gpio_irq_enable,
 129         .end = emma2rh_gpio_irq_end,
 130 };
 131
 132 void emma2rh_gpio_irq_init(u32 irq_base)
 133 {
 134         u32 i;
 135
 136         for (i = irq_base; i < irq_base + NUM_EMMA2RH_IRQ_GPIO; i++)
 137                 set_irq_chip(i, &emma2rh_gpio_irq_controller);
 138
 139         emma2rh_gpio_irq_base = irq_base;
 140 }
 141
 142 void ll_emma2rh_gpio_irq_enable(int irq)
 143 {
 144         u32 reg;
 145
 146         db_assert(irq >= 0);
 147         db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
 148
 149         reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
 150         reg |= 1 << irq;
 151         emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
 152 }
 153
 154 void ll_emma2rh_gpio_irq_disable(int irq)
 155 {
 156         u32 reg;
 157
 158         db_assert(irq >= 0);
 159         db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
 160
 161         reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
 162         reg &= ~(1 << irq);
 163         emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
 164 }