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_and_handler(i, &emma2rh_sw_irq_controller,
  72                                          handle_level_irq);
  73
  74         emma2rh_sw_irq_base = irq_base;
  75 }
  76
  77 void ll_emma2rh_sw_irq_enable(int irq)
  78 {
  79         u32 reg;
  80
  81         db_assert(irq >= 0);
  82         db_assert(irq < NUM_EMMA2RH_IRQ_SW);
  83
  84         reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
  85         reg |= 1 << irq;
  86         emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
  87 }
  88
  89 void ll_emma2rh_sw_irq_disable(int irq)
  90 {
  91         u32 reg;
  92
  93         db_assert(irq >= 0);
  94         db_assert(irq < 32);
  95
  96         reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
  97         reg &= ~(1 << irq);
  98         emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
  99 }
 100
 101 static void emma2rh_gpio_irq_enable(unsigned int irq)
 102 {
 103         ll_emma2rh_gpio_irq_enable(irq - emma2rh_gpio_irq_base);
 104 }
 105
 106 static void emma2rh_gpio_irq_disable(unsigned int irq)
 107 {
 108         ll_emma2rh_gpio_irq_disable(irq - emma2rh_gpio_irq_base);
 109 }
 110
 111 static void emma2rh_gpio_irq_ack(unsigned int irq)
 112 {
 113         irq -= emma2rh_gpio_irq_base;
 114         emma2rh_out32(EMMA2RH_GPIO_INT_ST, ~(1 << irq));
 115         ll_emma2rh_gpio_irq_disable(irq);
 116 }
 117
 118 static void emma2rh_gpio_irq_end(unsigned int irq)
 119 {
 120         if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
 121                 ll_emma2rh_gpio_irq_enable(irq - emma2rh_gpio_irq_base);
 122 }
 123
 124 struct irq_chip emma2rh_gpio_irq_controller = {
 125         .typename = "emma2rh_gpio_irq",
 126         .ack = emma2rh_gpio_irq_ack,
 127         .mask = emma2rh_gpio_irq_disable,
 128         .mask_ack = emma2rh_gpio_irq_ack,
 129         .unmask = emma2rh_gpio_irq_enable,
 130         .end = emma2rh_gpio_irq_end,
 131 };
 132
 133 void emma2rh_gpio_irq_init(u32 irq_base)
 134 {
 135         u32 i;
 136
 137         for (i = irq_base; i < irq_base + NUM_EMMA2RH_IRQ_GPIO; i++)
 138                 set_irq_chip(i, &emma2rh_gpio_irq_controller);
 139
 140         emma2rh_gpio_irq_base = irq_base;
 141 }
 142
 143 void ll_emma2rh_gpio_irq_enable(int irq)
 144 {
 145         u32 reg;
 146
 147         db_assert(irq >= 0);
 148         db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
 149
 150         reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
 151         reg |= 1 << irq;
 152         emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
 153 }
 154
 155 void ll_emma2rh_gpio_irq_disable(int irq)
 156 {
 157         u32 reg;
 158
 159         db_assert(irq >= 0);
 160         db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
 161
 162         reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
 163         reg &= ~(1 << irq);
 164         emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
 165 }