kernel/linux/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
  40 #include <asm/io.h>
  41 #include <asm/bitops.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 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                         do_random |= action->flags;
 141                         retval |= action->handler(irq, action->dev_id, regs);
 142                         action = action->next;
 143                 } while (action);
 144
 145                 if (retval != 1) {
 146                         if (retval) {
 147                                 printk("irq event %d: bogus retval mask %x\n",
 148                                         irq, retval);
 149                         } else {
 150                                 printk("irq %d: nobody cared\n", irq);
 151                         }
 152                 }
 153
 154                 if (do_random & SA_SAMPLE_RANDOM)
 155                         add_interrupt_randomness(irq);
 156                 local_irq_disable();
 157         }
 158         irq_exit();
 159
 160         if (softirq_pending(cpu))
 161                 do_softirq();
 162
 163         /* unmasking and bottom half handling is done magically for us. */
 164 }
 165
 166 /* this function links in a handler into the chain of handlers for the
 167    given irq, and if the irq has never been registred, the appropriate
 168    handler is entered into the interrupt vector
 169 */
 170
 171 int setup_irq(int irq, struct irqaction * new)
 172 {
 173         int shared = 0;
 174         struct irqaction *old, **p;
 175         unsigned long flags;
 176
 177         p = irq_action + irq - FIRST_IRQ;
 178         if ((old = *p) != NULL) {
 179                 /* Can't share interrupts unless both agree to */
 180                 if (!(old->flags & new->flags & SA_SHIRQ))
 181                         return -EBUSY;
 182
 183                 /* Can't share interrupts unless both are same type */
 184                 if ((old->flags ^ new->flags) & SA_INTERRUPT)
 185                         return -EBUSY;
 186
 187                 /* add new interrupt at end of irq queue */
 188                 do {
 189                         p = &old->next;
 190                         old = *p;
 191                 } while (old);
 192                 shared = 1;
 193         }
 194
 195         if (new->flags & SA_SAMPLE_RANDOM)
 196                 rand_initialize_irq(irq);
 197
 198         local_save_flags(flags);
 199         local_irq_disable();
 200         *p = new;
 201
 202         if (!shared) {
 203                 /* if the irq wasn't registred before, enter it into the vector table
 204                    and unmask it physically
 205                 */
 206                 arch_setup_irq(irq);
 207                 unmask_irq(irq);
 208         }
 209
 210         local_irq_restore(flags);
 211         return 0;
 212 }
 213
 214 /* this function is called by a driver to register an irq handler
 215    Valid flags:
 216    SA_INTERRUPT -> it's a fast interrupt, handler called with irq disabled and
 217                    no signal checking etc is performed upon exit
 218    SA_SHIRQ -> the interrupt can be shared between different handlers, the handler
 219                 is required to check if the irq was "aimed" at it explicitely
 220    SA_RANDOM -> the interrupt will add to the random generators entropy
 221 */
 222
 223 int request_irq(unsigned int irq,
 224                 irqreturn_t (*handler)(int, void *, struct pt_regs *),
 225                 unsigned long irqflags,
 226                 const char * devname,
 227                 void *dev_id)
 228 {
 229         int retval;
 230         struct irqaction * action;
 231
 232         if(!handler)
 233                 return -EINVAL;
 234
 235         /* allocate and fill in a handler structure and setup the irq */
 236
 237         action = (struct irqaction *)kmalloc(sizeof(struct irqaction), GFP_KERNEL);
 238         if (!action)
 239                 return -ENOMEM;
 240
 241         action->handler = handler;
 242         action->flags = irqflags;
 243         cpus_clear(action->mask);
 244         action->name = devname;
 245         action->next = NULL;
 246         action->dev_id = dev_id;
 247
 248         retval = setup_irq(irq, action);
 249
 250         if (retval)
 251                 kfree(action);
 252         return retval;
 253 }
 254
 255 EXPORT_SYMBOL(request_irq);
 256
 257 void free_irq(unsigned int irq, void *dev_id)
 258 {
 259         struct irqaction * action, **p;
 260         unsigned long flags;
 261
 262         if (irq >= NR_IRQS) {
 263                 printk("Trying to free IRQ%d\n",irq);
 264                 return;
 265         }
 266         for (p = irq - FIRST_IRQ + irq_action; (action = *p) != NULL; p = &action->next) {
 267                 if (action->dev_id != dev_id)
 268                         continue;
 269
 270                 /* Found it - now free it */
 271                 local_save_flags(flags);
 272                 local_irq_disable();
 273                 *p = action->next;
 274                 if (!irq_action[irq - FIRST_IRQ]) {
 275                         mask_irq(irq);
 276                         arch_free_irq(irq);
 277                 }
 278                 local_irq_restore(flags);
 279                 kfree(action);
 280                 return;
 281         }
 282         printk("Trying to free free IRQ%d\n",irq);
 283 }
 284
 285 EXPORT_SYMBOL(free_irq);
 286
 287 void weird_irq(void)
 288 {
 289         local_irq_disable();
 290         printk("weird irq\n");
 291         while(1);
 292 }
 293
 294 #if defined(CONFIG_PROC_FS) && defined(CONFIG_SYSCTL)
 295 /* Used by other archs to show/control IRQ steering during SMP */
 296 void __init
 297 init_irq_proc(void)
 298 {
 299 }
 300 #endif