arch/cris/kernel/irq.c

   1 /*
   2  *
   3  *      linux/arch/cris/kernel/irq.c
   4  *
   5  *      Copyright (c) 2000,2001 Axis Communications AB
   6  *
   7  *      Authors: Bjorn Wesen (bjornw@axis.com)
   8  *
   9  * This file contains the code used by various IRQ handling routines:
  10  * asking for different IRQ's should be done through these routines
  11  * instead of just grabbing them. Thus setups with different IRQ numbers
  12  * shouldn't result in any weird surprises, and installing new handlers
  13  * should be easier.
  14  *
  15  * Notice Linux/CRIS: these routines do not care about SMP
  16  *
  17  */
  18
  19 /*
  20  * IRQ's are in fact implemented a bit like signal handlers for the kernel.
  21  * Naturally it's not a 1:1 relation, but there are similarities.
  22  */
  23
  24 #include <linux/config.h>
  25 #include <linux/module.h>
  26 #include <linux/ptrace.h>
  27
  28 #include <linux/kernel_stat.h>
  29 #include <linux/signal.h>
  30 #include <linux/sched.h>
  31 #include <linux/ioport.h>
  32 #include <linux/interrupt.h>
  33 #include <linux/timex.h>
  34 #include <linux/slab.h>
  35 #include <linux/random.h>
  36 #include <linux/init.h>
  37 #include <linux/seq_file.h>
  38 #include <linux/errno.h>
  39 #include <linux/bitops.h>
  40
  41 #include <asm/io.h>
  42
  43 /* Defined in arch specific irq.c */
  44 extern void arch_setup_irq(int irq);
  45 extern void arch_free_irq(int irq);
  46
  47 void
  48 disable_irq(unsigned int irq_nr)
  49 {
  50         unsigned long flags;
  51
  52         local_save_flags(flags);
  53         local_irq_disable();
  54         mask_irq(irq_nr);
  55         local_irq_restore(flags);
  56 }
  57
  58 void
  59 enable_irq(unsigned int irq_nr)
  60 {
  61         unsigned long flags;
  62         local_save_flags(flags);
  63         local_irq_disable();
  64         unmask_irq(irq_nr);
  65         local_irq_restore(flags);
  66 }
  67
  68 unsigned long
  69 probe_irq_on()
  70 {
  71         return 0;
  72 }
  73
  74 EXPORT_SYMBOL(probe_irq_on);
  75
  76 int
  77 probe_irq_off(unsigned long x)
  78 {
  79         return 0;
  80 }
  81
  82 EXPORT_SYMBOL(probe_irq_off);
  83
  84 /*
  85  * Initial irq handlers.
  86  */
  87
  88 static struct irqaction *irq_action[NR_IRQS];
  89
  90 int show_interrupts(struct seq_file *p, void *v)
  91 {
  92         int i = *(loff_t *) v;
  93         struct irqaction * action;
  94         unsigned long flags;
  95
  96         if (i < NR_IRQS) {
  97                 local_irq_save(flags);
  98                 action = irq_action[i];
  99                 if (!action)
 100                         goto skip;
 101                 seq_printf(p, "%2d: %10u %c %s",
 102                         i, kstat_this_cpu.irqs[i],
 103                         (action->flags & SA_INTERRUPT) ? '+' : ' ',
 104                         action->name);
 105                 for (action = action->next; action; action = action->next) {
 106                         seq_printf(p, ",%s %s",
 107                                 (action->flags & SA_INTERRUPT) ? " +" : "",
 108                                 action->name);
 109                 }
 110                 seq_putc(p, '\n');
 111 skip:
 112                 local_irq_restore(flags);
 113         }
 114         return 0;
 115 }
 116
 117 /* called by the assembler IRQ entry functions defined in irq.h
 118  * to dispatch the interrupts to registred handlers
 119  * interrupts are disabled upon entry - depending on if the
 120  * interrupt was registred with SA_INTERRUPT or not, interrupts
 121  * are re-enabled or not.
 122  */
 123
 124 asmlinkage void do_IRQ(int irq, struct pt_regs * regs)
 125 {
 126         struct irqaction *action;
 127         int do_random, cpu;
 128         int ret, retval = 0;
 129
 130         cpu = smp_processor_id();
 131         irq_enter();
 132         kstat_cpu(cpu).irqs[irq - FIRST_IRQ]++;
 133         action = irq_action[irq - FIRST_IRQ];
 134
 135         if (action) {
 136                 if (!(action->flags & SA_INTERRUPT))
 137                         local_irq_enable();
 138                 do_random = 0;
 139                 do {
 140                         ret = action->handler(irq, action->dev_id, regs);
 141                         if (ret == IRQ_HANDLED)
 142                                 do_random |= action->flags;
 143                         retval |= ret;
 144                         action = action->next;
 145                 } while (action);
 146
 147                 if (retval != 1) {
 148                         if (retval) {
 149                                 printk("irq event %d: bogus retval mask %x\n",
 150                                         irq, retval);
 151                         } else {
 152                                 printk("irq %d: nobody cared\n", irq);
 153                         }
 154                 }
 155
 156                 if (do_random & SA_SAMPLE_RANDOM)
 157                         add_interrupt_randomness(irq);
 158                 local_irq_disable();
 159         }
 160         irq_exit();
 161 }
 162
 163 /* this function links in a handler into the chain of handlers for the
 164    given irq, and if the irq has never been registred, the appropriate
 165    handler is entered into the interrupt vector
 166 */
 167
 168 int setup_irq(int irq, struct irqaction * new)
 169 {
 170         int shared = 0;
 171         struct irqaction *old, **p;
 172         unsigned long flags;
 173
 174         p = irq_action + irq - FIRST_IRQ;
 175         if ((old = *p) != NULL) {
 176                 /* Can't share interrupts unless both agree to */
 177                 if (!(old->flags & new->flags & SA_SHIRQ))
 178                         return -EBUSY;
 179
 180                 /* Can't share interrupts unless both are same type */
 181                 if ((old->flags ^ new->flags) & SA_INTERRUPT)
 182                         return -EBUSY;
 183
 184                 /* add new interrupt at end of irq queue */
 185                 do {
 186                         p = &old->next;
 187                         old = *p;
 188                 } while (old);
 189                 shared = 1;
 190         }
 191
 192         if (new->flags & SA_SAMPLE_RANDOM)
 193                 rand_initialize_irq(irq);
 194
 195         local_save_flags(flags);
 196         local_irq_disable();
 197         *p = new;
 198
 199         if (!shared) {
 200                 /* if the irq wasn't registred before, enter it into the vector table
 201                    and unmask it physically
 202                 */
 203                 arch_setup_irq(irq);
 204                 unmask_irq(irq);
 205         }
 206
 207         local_irq_restore(flags);
 208         return 0;
 209 }
 210
 211 /* this function is called by a driver to register an irq handler
 212    Valid flags:
 213    SA_INTERRUPT -> it's a fast interrupt, handler called with irq disabled and
 214                    no signal checking etc is performed upon exit
 215    SA_SHIRQ -> the interrupt can be shared between different handlers, the handler
 216                 is required to check if the irq was "aimed" at it explicitely
 217    SA_RANDOM -> the interrupt will add to the random generators entropy
 218 */
 219
 220 int request_irq(unsigned int irq,
 221                 irqreturn_t (*handler)(int, void *, struct pt_regs *),
 222                 unsigned long irqflags,
 223                 const char * devname,
 224                 void *dev_id)
 225 {
 226         int retval;
 227         struct irqaction * action;
 228
 229         if(!handler)
 230                 return -EINVAL;
 231
 232         /* allocate and fill in a handler structure and setup the irq */
 233
 234         action = (struct irqaction *)kmalloc(sizeof(struct irqaction), GFP_KERNEL);
 235         if (!action)
 236                 return -ENOMEM;
 237
 238         action->handler = handler;
 239         action->flags = irqflags;
 240         cpus_clear(action->mask);
 241         action->name = devname;
 242         action->next = NULL;
 243         action->dev_id = dev_id;
 244
 245         retval = setup_irq(irq, action);
 246
 247         if (retval)
 248                 kfree(action);
 249         return retval;
 250 }
 251
 252 EXPORT_SYMBOL(request_irq);
 253
 254 void free_irq(unsigned int irq, void *dev_id)
 255 {
 256         struct irqaction * action, **p;
 257         unsigned long flags;
 258
 259         if (irq >= NR_IRQS) {
 260                 printk("Trying to free IRQ%d\n",irq);
 261                 return;
 262         }
 263         for (p = irq - FIRST_IRQ + irq_action; (action = *p) != NULL; p = &action->next) {
 264                 if (action->dev_id != dev_id)
 265                         continue;
 266
 267                 /* Found it - now free it */
 268                 local_save_flags(flags);
 269                 local_irq_disable();
 270                 *p = action->next;
 271                 if (!irq_action[irq - FIRST_IRQ]) {
 272                         mask_irq(irq);
 273                         arch_free_irq(irq);
 274                 }
 275                 local_irq_restore(flags);
 276                 kfree(action);
 277                 return;
 278         }
 279         printk("Trying to free free IRQ%d\n",irq);
 280 }
 281
 282 EXPORT_SYMBOL(free_irq);
 283
 284 void weird_irq(void)
 285 {
 286         local_irq_disable();
 287         printk("weird irq\n");
 288         while(1);
 289 }
 290
 291 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)
 292 /* Used by other archs to show/control IRQ steering during SMP */
 293 void __init
 294 init_irq_proc(void)
 295 {
 296 }
 297 #endif