git.oblomov.eu Git - linux-2.6/blob - kernel/irq/handle.c

   1 /*
   2  * linux/kernel/irq/handle.c
   3  *
   4  * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar
   5  * Copyright (C) 2005-2006, Thomas Gleixner, Russell King
   6  *
   7  * This file contains the core interrupt handling code.
   8  *
   9  * Detailed information is available in Documentation/DocBook/genericirq
  10  *
  11  */
  12
  13 #include <linux/irq.h>
  14 #include <linux/module.h>
  15 #include <linux/random.h>
  16 #include <linux/interrupt.h>
  17 #include <linux/kernel_stat.h>
  18 #include <linux/rculist.h>
  19 #include <linux/hash.h>
  20
  21 #include "internals.h"
  22
  23 /*
  24  * lockdep: we want to handle all irq_desc locks as a single lock-class:
  25  */
  26 struct lock_class_key irq_desc_lock_class;
  27
  28 /**
  29  * handle_bad_irq - handle spurious and unhandled irqs
  30  * @irq:       the interrupt number
  31  * @desc:      description of the interrupt
  32  *
  33  * Handles spurious and unhandled IRQ's. It also prints a debugmessage.
  34  */
  35 void handle_bad_irq(unsigned int irq, struct irq_desc *desc)
  36 {
  37         print_irq_desc(irq, desc);
  38         kstat_incr_irqs_this_cpu(irq, desc);
  39         ack_bad_irq(irq);
  40 }
  41
  42 /*
  43  * Linux has a controller-independent interrupt architecture.
  44  * Every controller has a 'controller-template', that is used
  45  * by the main code to do the right thing. Each driver-visible
  46  * interrupt source is transparently wired to the appropriate
  47  * controller. Thus drivers need not be aware of the
  48  * interrupt-controller.
  49  *
  50  * The code is designed to be easily extended with new/different
  51  * interrupt controllers, without having to do assembly magic or
  52  * having to touch the generic code.
  53  *
  54  * Controller mappings for all interrupt sources:
  55  */
  56 int nr_irqs = NR_IRQS;
  57 EXPORT_SYMBOL_GPL(nr_irqs);
  58
  59 #ifdef CONFIG_SPARSE_IRQ
  60 static struct irq_desc irq_desc_init = {
  61         .irq        = -1,
  62         .status     = IRQ_DISABLED,
  63         .chip       = &no_irq_chip,
  64         .handle_irq = handle_bad_irq,
  65         .depth      = 1,
  66         .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
  67 #ifdef CONFIG_SMP
  68         .affinity   = CPU_MASK_ALL
  69 #endif
  70 };
  71
  72 void init_kstat_irqs(struct irq_desc *desc, int cpu, int nr)
  73 {
  74         unsigned long bytes;
  75         char *ptr;
  76         int node;
  77
  78         /* Compute how many bytes we need per irq and allocate them */
  79         bytes = nr * sizeof(unsigned int);
  80
  81         node = cpu_to_node(cpu);
  82         ptr = kzalloc_node(bytes, GFP_ATOMIC, node);
  83         printk(KERN_DEBUG "  alloc kstat_irqs on cpu %d node %d\n", cpu, node);
  84
  85         if (ptr)
  86                 desc->kstat_irqs = (unsigned int *)ptr;
  87 }
  88
  89 int __weak arch_init_chip_data(struct irq_desc *desc, int cpu)
  90 {
  91         return 0;
  92 }
  93
  94 static void init_one_irq_desc(int irq, struct irq_desc *desc, int cpu)
  95 {
  96         memcpy(desc, &irq_desc_init, sizeof(struct irq_desc));
  97
  98         spin_lock_init(&desc->lock);
  99         desc->irq = irq;
 100 #ifdef CONFIG_SMP
 101         desc->cpu = cpu;
 102 #endif
 103         lockdep_set_class(&desc->lock, &irq_desc_lock_class);
 104         init_kstat_irqs(desc, cpu, nr_cpu_ids);
 105         if (!desc->kstat_irqs) {
 106                 printk(KERN_ERR "can not alloc kstat_irqs\n");
 107                 BUG_ON(1);
 108         }
 109         arch_init_chip_data(desc, cpu);
 110 }
 111
 112 /*
 113  * Protect the sparse_irqs:
 114  */
 115 DEFINE_SPINLOCK(sparse_irq_lock);
 116
 117 struct irq_desc *irq_desc_ptrs[NR_IRQS] __read_mostly;
 118
 119 static struct irq_desc irq_desc_legacy[NR_IRQS_LEGACY] __cacheline_aligned_in_smp = {
 120         [0 ... NR_IRQS_LEGACY-1] = {
 121                 .irq        = -1,
 122                 .status     = IRQ_DISABLED,
 123                 .chip       = &no_irq_chip,
 124                 .handle_irq = handle_bad_irq,
 125                 .depth      = 1,
 126                 .lock       = __SPIN_LOCK_UNLOCKED(irq_desc_init.lock),
 127 #ifdef CONFIG_SMP
 128                 .affinity   = CPU_MASK_ALL
 129 #endif
 130         }
 131 };
 132
 133 /* FIXME: use bootmem alloc ...*/
 134 static unsigned int kstat_irqs_legacy[NR_IRQS_LEGACY][NR_CPUS];
 135
 136 int __init early_irq_init(void)
 137 {
 138         struct irq_desc *desc;
 139         int legacy_count;
 140         int i;
 141
 142         desc = irq_desc_legacy;
 143         legacy_count = ARRAY_SIZE(irq_desc_legacy);
 144
 145         for (i = 0; i < legacy_count; i++) {
 146                 desc[i].irq = i;
 147                 desc[i].kstat_irqs = kstat_irqs_legacy[i];
 148
 149                 irq_desc_ptrs[i] = desc + i;
 150         }
 151
 152         for (i = legacy_count; i < NR_IRQS; i++)
 153                 irq_desc_ptrs[i] = NULL;
 154
 155         return arch_early_irq_init();
 156 }
 157
 158 struct irq_desc *irq_to_desc(unsigned int irq)
 159 {
 160         return (irq < NR_IRQS) ? irq_desc_ptrs[irq] : NULL;
 161 }
 162
 163 struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
 164 {
 165         struct irq_desc *desc;
 166         unsigned long flags;
 167         int node;
 168
 169         if (irq >= NR_IRQS) {
 170                 printk(KERN_WARNING "irq >= NR_IRQS in irq_to_desc_alloc: %d %d\n",
 171                                 irq, NR_IRQS);
 172                 WARN_ON(1);
 173                 return NULL;
 174         }
 175
 176         desc = irq_desc_ptrs[irq];
 177         if (desc)
 178                 return desc;
 179
 180         spin_lock_irqsave(&sparse_irq_lock, flags);
 181
 182         /* We have to check it to avoid races with another CPU */
 183         desc = irq_desc_ptrs[irq];
 184         if (desc)
 185                 goto out_unlock;
 186
 187         node = cpu_to_node(cpu);
 188         desc = kzalloc_node(sizeof(*desc), GFP_ATOMIC, node);
 189         printk(KERN_DEBUG "  alloc irq_desc for %d on cpu %d node %d\n",
 190                  irq, cpu, node);
 191         if (!desc) {
 192                 printk(KERN_ERR "can not alloc irq_desc\n");
 193                 BUG_ON(1);
 194         }
 195         init_one_irq_desc(irq, desc, cpu);
 196
 197         irq_desc_ptrs[irq] = desc;
 198
 199 out_unlock:
 200         spin_unlock_irqrestore(&sparse_irq_lock, flags);
 201
 202         return desc;
 203 }
 204
 205 #else /* !CONFIG_SPARSE_IRQ */
 206
 207 struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
 208         [0 ... NR_IRQS-1] = {
 209                 .status = IRQ_DISABLED,
 210                 .chip = &no_irq_chip,
 211                 .handle_irq = handle_bad_irq,
 212                 .depth = 1,
 213                 .lock = __SPIN_LOCK_UNLOCKED(irq_desc->lock),
 214 #ifdef CONFIG_SMP
 215                 .affinity = CPU_MASK_ALL
 216 #endif
 217         }
 218 };
 219
 220 struct irq_desc *irq_to_desc(unsigned int irq)
 221 {
 222         return (irq < NR_IRQS) ? irq_desc + irq : NULL;
 223 }
 224
 225 struct irq_desc *irq_to_desc_alloc_cpu(unsigned int irq, int cpu)
 226 {
 227         return irq_to_desc(irq);
 228 }
 229 #endif /* !CONFIG_SPARSE_IRQ */
 230
 231 /*
 232  * What should we do if we get a hw irq event on an illegal vector?
 233  * Each architecture has to answer this themself.
 234  */
 235 static void ack_bad(unsigned int irq)
 236 {
 237         struct irq_desc *desc = irq_to_desc(irq);
 238
 239         print_irq_desc(irq, desc);
 240         ack_bad_irq(irq);
 241 }
 242
 243 /*
 244  * NOP functions
 245  */
 246 static void noop(unsigned int irq)
 247 {
 248 }
 249
 250 static unsigned int noop_ret(unsigned int irq)
 251 {
 252         return 0;
 253 }
 254
 255 /*
 256  * Generic no controller implementation
 257  */
 258 struct irq_chip no_irq_chip = {
 259         .name           = "none",
 260         .startup        = noop_ret,
 261         .shutdown       = noop,
 262         .enable         = noop,
 263         .disable        = noop,
 264         .ack            = ack_bad,
 265         .end            = noop,
 266 };
 267
 268 /*
 269  * Generic dummy implementation which can be used for
 270  * real dumb interrupt sources
 271  */
 272 struct irq_chip dummy_irq_chip = {
 273         .name           = "dummy",
 274         .startup        = noop_ret,
 275         .shutdown       = noop,
 276         .enable         = noop,
 277         .disable        = noop,
 278         .ack            = noop,
 279         .mask           = noop,
 280         .unmask         = noop,
 281         .end            = noop,
 282 };
 283
 284 /*
 285  * Special, empty irq handler:
 286  */
 287 irqreturn_t no_action(int cpl, void *dev_id)
 288 {
 289         return IRQ_NONE;
 290 }
 291
 292 /**
 293  * handle_IRQ_event - irq action chain handler
 294  * @irq:        the interrupt number
 295  * @action:     the interrupt action chain for this irq
 296  *
 297  * Handles the action chain of an irq event
 298  */
 299 irqreturn_t handle_IRQ_event(unsigned int irq, struct irqaction *action)
 300 {
 301         irqreturn_t ret, retval = IRQ_NONE;
 302         unsigned int status = 0;
 303
 304         if (!(action->flags & IRQF_DISABLED))
 305                 local_irq_enable_in_hardirq();
 306
 307         do {
 308                 ret = action->handler(irq, action->dev_id);
 309                 if (ret == IRQ_HANDLED)
 310                         status |= action->flags;
 311                 retval |= ret;
 312                 action = action->next;
 313         } while (action);
 314
 315         if (status & IRQF_SAMPLE_RANDOM)
 316                 add_interrupt_randomness(irq);
 317         local_irq_disable();
 318
 319         return retval;
 320 }
 321
 322 #ifndef CONFIG_GENERIC_HARDIRQS_NO__DO_IRQ
 323 /**
 324  * __do_IRQ - original all in one highlevel IRQ handler
 325  * @irq:        the interrupt number
 326  *
 327  * __do_IRQ handles all normal device IRQ's (the special
 328  * SMP cross-CPU interrupts have their own specific
 329  * handlers).
 330  *
 331  * This is the original x86 implementation which is used for every
 332  * interrupt type.
 333  */
 334 unsigned int __do_IRQ(unsigned int irq)
 335 {
 336         struct irq_desc *desc = irq_to_desc(irq);
 337         struct irqaction *action;
 338         unsigned int status;
 339
 340         kstat_incr_irqs_this_cpu(irq, desc);
 341
 342         if (CHECK_IRQ_PER_CPU(desc->status)) {
 343                 irqreturn_t action_ret;
 344
 345                 /*
 346                  * No locking required for CPU-local interrupts:
 347                  */
 348                 if (desc->chip->ack) {
 349                         desc->chip->ack(irq);
 350                         /* get new one */
 351                         desc = irq_remap_to_desc(irq, desc);
 352                 }
 353                 if (likely(!(desc->status & IRQ_DISABLED))) {
 354                         action_ret = handle_IRQ_event(irq, desc->action);
 355                         if (!noirqdebug)
 356                                 note_interrupt(irq, desc, action_ret);
 357                 }
 358                 desc->chip->end(irq);
 359                 return 1;
 360         }
 361
 362         spin_lock(&desc->lock);
 363         if (desc->chip->ack) {
 364                 desc->chip->ack(irq);
 365                 desc = irq_remap_to_desc(irq, desc);
 366         }
 367         /*
 368          * REPLAY is when Linux resends an IRQ that was dropped earlier
 369          * WAITING is used by probe to mark irqs that are being tested
 370          */
 371         status = desc->status & ~(IRQ_REPLAY | IRQ_WAITING);
 372         status |= IRQ_PENDING; /* we _want_ to handle it */
 373
 374         /*
 375          * If the IRQ is disabled for whatever reason, we cannot
 376          * use the action we have.
 377          */
 378         action = NULL;
 379         if (likely(!(status & (IRQ_DISABLED | IRQ_INPROGRESS)))) {
 380                 action = desc->action;
 381                 status &= ~IRQ_PENDING; /* we commit to handling */
 382                 status |= IRQ_INPROGRESS; /* we are handling it */
 383         }
 384         desc->status = status;
 385
 386         /*
 387          * If there is no IRQ handler or it was disabled, exit early.
 388          * Since we set PENDING, if another processor is handling
 389          * a different instance of this same irq, the other processor
 390          * will take care of it.
 391          */
 392         if (unlikely(!action))
 393                 goto out;
 394
 395         /*
 396          * Edge triggered interrupts need to remember
 397          * pending events.
 398          * This applies to any hw interrupts that allow a second
 399          * instance of the same irq to arrive while we are in do_IRQ
 400          * or in the handler. But the code here only handles the _second_
 401          * instance of the irq, not the third or fourth. So it is mostly
 402          * useful for irq hardware that does not mask cleanly in an
 403          * SMP environment.
 404          */
 405         for (;;) {
 406                 irqreturn_t action_ret;
 407
 408                 spin_unlock(&desc->lock);
 409
 410                 action_ret = handle_IRQ_event(irq, action);
 411                 if (!noirqdebug)
 412                         note_interrupt(irq, desc, action_ret);
 413
 414                 spin_lock(&desc->lock);
 415                 if (likely(!(desc->status & IRQ_PENDING)))
 416                         break;
 417                 desc->status &= ~IRQ_PENDING;
 418         }
 419         desc->status &= ~IRQ_INPROGRESS;
 420
 421 out:
 422         /*
 423          * The ->end() handler has to deal with interrupts which got
 424          * disabled while the handler was running.
 425          */
 426         desc->chip->end(irq);
 427         spin_unlock(&desc->lock);
 428
 429         return 1;
 430 }
 431 #endif
 432
 433 void early_init_irq_lock_class(void)
 434 {
 435         struct irq_desc *desc;
 436         int i;
 437
 438         for_each_irq_desc(i, desc) {
 439                 lockdep_set_class(&desc->lock, &irq_desc_lock_class);
 440         }
 441 }
 442
 443 #ifdef CONFIG_SPARSE_IRQ
 444 unsigned int kstat_irqs_cpu(unsigned int irq, int cpu)
 445 {
 446         struct irq_desc *desc = irq_to_desc(irq);
 447         return desc ? desc->kstat_irqs[cpu] : 0;
 448 }
 449 #endif
 450 EXPORT_SYMBOL(kstat_irqs_cpu);
 451