arch/mips/emma/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/emma/emma2rh.h>
  32
  33 void ll_emma2rh_sw_irq_enable(int reg);
  34 void ll_emma2rh_sw_irq_disable(int reg);
  35 void ll_emma2rh_gpio_irq_enable(int reg);
  36 void ll_emma2rh_gpio_irq_disable(int reg);
  37
  38 static void emma2rh_sw_irq_enable(unsigned int irq)
  39 {
  40         ll_emma2rh_sw_irq_enable(irq - EMMA2RH_SW_IRQ_BASE);
  41 }
  42
  43 static void emma2rh_sw_irq_disable(unsigned int irq)
  44 {
  45         ll_emma2rh_sw_irq_disable(irq - EMMA2RH_SW_IRQ_BASE);
  46 }
  47
  48 struct irq_chip emma2rh_sw_irq_controller = {
  49         .name = "emma2rh_sw_irq",
  50         .ack = emma2rh_sw_irq_disable,
  51         .mask = emma2rh_sw_irq_disable,
  52         .mask_ack = emma2rh_sw_irq_disable,
  53         .unmask = emma2rh_sw_irq_enable,
  54 };
  55
  56 void emma2rh_sw_irq_init(void)
  57 {
  58         u32 i;
  59
  60         for (i = 0; i < NUM_EMMA2RH_IRQ_SW; i++)
  61                 set_irq_chip_and_handler(EMMA2RH_SW_IRQ_BASE + i,
  62                                          &emma2rh_sw_irq_controller,
  63                                          handle_level_irq);
  64 }
  65
  66 void ll_emma2rh_sw_irq_enable(int irq)
  67 {
  68         u32 reg;
  69
  70         db_assert(irq >= 0);
  71         db_assert(irq < NUM_EMMA2RH_IRQ_SW);
  72
  73         reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
  74         reg |= 1 << irq;
  75         emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
  76 }
  77
  78 void ll_emma2rh_sw_irq_disable(int irq)
  79 {
  80         u32 reg;
  81
  82         db_assert(irq >= 0);
  83         db_assert(irq < 32);
  84
  85         reg = emma2rh_in32(EMMA2RH_BHIF_SW_INT_EN);
  86         reg &= ~(1 << irq);
  87         emma2rh_out32(EMMA2RH_BHIF_SW_INT_EN, reg);
  88 }
  89
  90 static void emma2rh_gpio_irq_enable(unsigned int irq)
  91 {
  92         ll_emma2rh_gpio_irq_enable(irq - EMMA2RH_GPIO_IRQ_BASE);
  93 }
  94
  95 static void emma2rh_gpio_irq_disable(unsigned int irq)
  96 {
  97         ll_emma2rh_gpio_irq_disable(irq - EMMA2RH_GPIO_IRQ_BASE);
  98 }
  99
 100 static void emma2rh_gpio_irq_ack(unsigned int irq)
 101 {
 102         irq -= EMMA2RH_GPIO_IRQ_BASE;
 103         emma2rh_out32(EMMA2RH_GPIO_INT_ST, ~(1 << irq));
 104         ll_emma2rh_gpio_irq_disable(irq);
 105 }
 106
 107 static void emma2rh_gpio_irq_end(unsigned int irq)
 108 {
 109         if (!(irq_desc[irq].status & (IRQ_DISABLED | IRQ_INPROGRESS)))
 110                 ll_emma2rh_gpio_irq_enable(irq - EMMA2RH_GPIO_IRQ_BASE);
 111 }
 112
 113 struct irq_chip emma2rh_gpio_irq_controller = {
 114         .name = "emma2rh_gpio_irq",
 115         .ack = emma2rh_gpio_irq_ack,
 116         .mask = emma2rh_gpio_irq_disable,
 117         .mask_ack = emma2rh_gpio_irq_ack,
 118         .unmask = emma2rh_gpio_irq_enable,
 119         .end = emma2rh_gpio_irq_end,
 120 };
 121
 122 void emma2rh_gpio_irq_init(void)
 123 {
 124         u32 i;
 125
 126         for (i = 0; i < NUM_EMMA2RH_IRQ_GPIO; i++)
 127                 set_irq_chip(EMMA2RH_GPIO_IRQ_BASE + i,
 128                              &emma2rh_gpio_irq_controller);
 129 }
 130
 131 void ll_emma2rh_gpio_irq_enable(int irq)
 132 {
 133         u32 reg;
 134
 135         db_assert(irq >= 0);
 136         db_assert(irq < NUM_EMMA2RH_IRQ_GPIO);
 137
 138         reg = emma2rh_in32(EMMA2RH_GPIO_INT_MASK);
 139         reg |= 1 << irq;
 140         emma2rh_out32(EMMA2RH_GPIO_INT_MASK, reg);
 141 }
 142
 143 void ll_emma2rh_gpio_irq_disable(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 }