arch/arm26/kernel/irq.c

   1 /*
   2  *  linux/arch/arm/kernel/irq.c
   3  *
   4  *  Copyright (C) 1992 Linus Torvalds
   5  *  Modifications for ARM processor Copyright (C) 1995-2000 Russell King.
   6  *  'Borrowed' for ARM26 and (C) 2003 Ian Molton.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 as
  10  * published by the Free Software Foundation.
  11  *
  12  *  This file contains the code used by various IRQ handling routines:
  13  *  asking for different IRQ's should be done through these routines
  14  *  instead of just grabbing them. Thus setups with different IRQ numbers
  15  *  shouldn't result in any weird surprises, and installing new handlers
  16  *  should be easier.
  17  *
  18  *  IRQ's are in fact implemented a bit like signal handlers for the kernel.
  19  *  Naturally it's not a 1:1 relation, but there are similarities.
  20  */
  21 #include <linux/config.h>
  22 #include <linux/module.h>
  23 #include <linux/ptrace.h>
  24 #include <linux/kernel_stat.h>
  25 #include <linux/signal.h>
  26 #include <linux/sched.h>
  27 #include <linux/ioport.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/slab.h>
  30 #include <linux/random.h>
  31 #include <linux/smp.h>
  32 #include <linux/init.h>
  33 #include <linux/seq_file.h>
  34 #include <linux/errno.h>
  35
  36 #include <asm/irq.h>
  37 #include <asm/system.h>
  38 #include <asm/irqchip.h>
  39
  40 //FIXME - this ought to be in a header IMO
  41 void __init arc_init_irq(void);
  42
  43 /*
  44  * Maximum IRQ count.  Currently, this is arbitary.  However, it should
  45  * not be set too low to prevent false triggering.  Conversely, if it
  46  * is set too high, then you could miss a stuck IRQ.
  47  *
  48  * FIXME Maybe we ought to set a timer and re-enable the IRQ at a later time?
  49  */
  50 #define MAX_IRQ_CNT     100000
  51
  52 static volatile unsigned long irq_err_count;
  53 static spinlock_t irq_controller_lock = SPIN_LOCK_UNLOCKED;
  54
  55 struct irqdesc irq_desc[NR_IRQS];
  56
  57 /*
  58  * Dummy mask/unmask handler
  59  */
  60 void dummy_mask_unmask_irq(unsigned int irq)
  61 {
  62 }
  63
  64 void do_bad_IRQ(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
  65 {
  66         irq_err_count += 1;
  67         printk(KERN_ERR "IRQ: spurious interrupt %d\n", irq);
  68 }
  69
  70 static struct irqchip bad_chip = {
  71         .ack    = dummy_mask_unmask_irq,
  72         .mask   = dummy_mask_unmask_irq,
  73         .unmask = dummy_mask_unmask_irq,
  74 };
  75
  76 static struct irqdesc bad_irq_desc = {
  77         .chip   = &bad_chip,
  78         .handle = do_bad_IRQ,
  79         .depth  = 1,
  80 };
  81
  82 /**
  83  *      disable_irq - disable an irq and wait for completion
  84  *      @irq: Interrupt to disable
  85  *
  86  *      Disable the selected interrupt line.  We do this lazily.
  87  *
  88  *      This function may be called from IRQ context.
  89  */
  90 void disable_irq(unsigned int irq)
  91 {
  92         struct irqdesc *desc = irq_desc + irq;
  93         unsigned long flags;
  94         spin_lock_irqsave(&irq_controller_lock, flags);
  95         if (!desc->depth++)
  96                 desc->enabled = 0;
  97         spin_unlock_irqrestore(&irq_controller_lock, flags);
  98 }
  99
 100 /**
 101  *      enable_irq - enable interrupt handling on an irq
 102  *      @irq: Interrupt to enable
 103  *
 104  *      Re-enables the processing of interrupts on this IRQ line.
 105  *      Note that this may call the interrupt handler, so you may
 106  *      get unexpected results if you hold IRQs disabled.
 107  *
 108  *      This function may be called from IRQ context.
 109  */
 110 void enable_irq(unsigned int irq)
 111 {
 112         struct irqdesc *desc = irq_desc + irq;
 113         unsigned long flags;
 114         int pending = 0;
 115
 116         spin_lock_irqsave(&irq_controller_lock, flags);
 117         if (unlikely(!desc->depth)) {
 118                 printk("enable_irq(%u) unbalanced from %p\n", irq,
 119                         __builtin_return_address(0)); //FIXME bum addresses reported - why?
 120         } else if (!--desc->depth) {
 121                 desc->probing = 0;
 122                 desc->enabled = 1;
 123                 desc->chip->unmask(irq);
 124                 pending = desc->pending;
 125                 desc->pending = 0;
 126                 /*
 127                  * If the interrupt was waiting to be processed,
 128                  * retrigger it.
 129                  */
 130                 if (pending)
 131                         desc->chip->rerun(irq);
 132         }
 133         spin_unlock_irqrestore(&irq_controller_lock, flags);
 134 }
 135
 136 int show_interrupts(struct seq_file *p, void *v)
 137 {
 138         int i = *(loff_t *) v;
 139         struct irqaction * action;
 140
 141         if (i < NR_IRQS) {
 142                 action = irq_desc[i].action;
 143                 if (!action)
 144                         continue;
 145                 seq_printf(p, "%3d: %10u ", i, kstat_irqs(i));
 146                 seq_printf(p, "  %s", action->name);
 147                 for (action = action->next; action; action = action->next) {
 148                         seq_printf(p, ", %s", action->name);
 149                 }
 150                 seq_putc(p, '\n');
 151         } else if (i == NR_IRQS) {
 152                 show_fiq_list(p, v);
 153                 seq_printf(p, "Err: %10lu\n", irq_err_count);
 154         }
 155         return 0;
 156 }
 157
 158 /*
 159  * IRQ lock detection.
 160  *
 161  * Hopefully, this should get us out of a few locked situations.
 162  * However, it may take a while for this to happen, since we need
 163  * a large number if IRQs to appear in the same jiffie with the
 164  * same instruction pointer (or within 2 instructions).
 165  */
 166 static int check_irq_lock(struct irqdesc *desc, int irq, struct pt_regs *regs)
 167 {
 168         unsigned long instr_ptr = instruction_pointer(regs);
 169
 170         if (desc->lck_jif == jiffies &&
 171             desc->lck_pc >= instr_ptr && desc->lck_pc < instr_ptr + 8) {
 172                 desc->lck_cnt += 1;
 173
 174                 if (desc->lck_cnt > MAX_IRQ_CNT) {
 175                         printk(KERN_ERR "IRQ LOCK: IRQ%d is locking the system, disabled\n", irq);
 176                         return 1;
 177                 }
 178         } else {
 179                 desc->lck_cnt = 0;
 180                 desc->lck_pc  = instruction_pointer(regs);
 181                 desc->lck_jif = jiffies;
 182         }
 183         return 0;
 184 }
 185
 186 static void
 187 __do_irq(unsigned int irq, struct irqaction *action, struct pt_regs *regs)
 188 {
 189         unsigned int status;
 190
 191         spin_unlock(&irq_controller_lock);
 192         if (!(action->flags & SA_INTERRUPT))
 193                 local_irq_enable();
 194
 195         status = 0;
 196         do {
 197                 status |= action->flags;
 198                 action->handler(irq, action->dev_id, regs);
 199                 action = action->next;
 200         } while (action);
 201
 202         if (status & SA_SAMPLE_RANDOM)
 203                 add_interrupt_randomness(irq);
 204
 205         spin_lock_irq(&irq_controller_lock);
 206 }
 207
 208 /*
 209  * This is for software-decoded IRQs.  The caller is expected to
 210  * handle the ack, clear, mask and unmask issues.
 211  */
 212 void
 213 do_simple_IRQ(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
 214 {
 215         struct irqaction *action;
 216         const int cpu = smp_processor_id();
 217
 218         desc->triggered = 1;
 219
 220         kstat_cpu(cpu).irqs[irq]++;
 221
 222         action = desc->action;
 223         if (action)
 224                 __do_irq(irq, desc->action, regs);
 225 }
 226
 227 /*
 228  * Most edge-triggered IRQ implementations seem to take a broken
 229  * approach to this.  Hence the complexity.
 230  */
 231 void
 232 do_edge_IRQ(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
 233 {
 234         const int cpu = smp_processor_id();
 235
 236         desc->triggered = 1;
 237
 238         /*
 239          * If we're currently running this IRQ, or its disabled,
 240          * we shouldn't process the IRQ.  Instead, turn on the
 241          * hardware masks.
 242          */
 243         if (unlikely(desc->running || !desc->enabled))
 244                 goto running;
 245
 246         /*
 247          * Acknowledge and clear the IRQ, but don't mask it.
 248          */
 249         desc->chip->ack(irq);
 250
 251         /*
 252          * Mark the IRQ currently in progress.
 253          */
 254         desc->running = 1;
 255
 256         kstat_cpu(cpu).irqs[irq]++;
 257
 258         do {
 259                 struct irqaction *action;
 260
 261                 action = desc->action;
 262                 if (!action)
 263                         break;
 264
 265                 if (desc->pending && desc->enabled) {
 266                         desc->pending = 0;
 267                         desc->chip->unmask(irq);
 268                 }
 269
 270                 __do_irq(irq, action, regs);
 271         } while (desc->pending);
 272
 273         desc->running = 0;
 274
 275         /*
 276          * If we were disabled or freed, shut down the handler.
 277          */
 278         if (likely(desc->action && !check_irq_lock(desc, irq, regs)))
 279                 return;
 280
 281  running:
 282         /*
 283          * We got another IRQ while this one was masked or
 284          * currently running.  Delay it.
 285          */
 286         desc->pending = 1;
 287         desc->chip->mask(irq);
 288         desc->chip->ack(irq);
 289 }
 290
 291 /*
 292  * Level-based IRQ handler.  Nice and simple.
 293  */
 294 void
 295 do_level_IRQ(unsigned int irq, struct irqdesc *desc, struct pt_regs *regs)
 296 {
 297         struct irqaction *action;
 298         const int cpu = smp_processor_id();
 299
 300         desc->triggered = 1;
 301
 302         /*
 303          * Acknowledge, clear _AND_ disable the interrupt.
 304          */
 305         desc->chip->ack(irq);
 306
 307         if (likely(desc->enabled)) {
 308                 kstat_cpu(cpu).irqs[irq]++;
 309
 310                 /*
 311                  * Return with this interrupt masked if no action
 312                  */
 313                 action = desc->action;
 314                 if (action) {
 315                         __do_irq(irq, desc->action, regs);
 316
 317                         if (likely(desc->enabled &&
 318                                    !check_irq_lock(desc, irq, regs)))
 319                                 desc->chip->unmask(irq);
 320                 }
 321         }
 322 }
 323
 324 /*
 325  * do_IRQ handles all hardware IRQ's.  Decoded IRQs should not
 326  * come via this function.  Instead, they should provide their
 327  * own 'handler'
 328  */
 329 asmlinkage void asm_do_IRQ(int irq, struct pt_regs *regs)
 330 {
 331         struct irqdesc *desc = irq_desc + irq;
 332
 333         /*
 334          * Some hardware gives randomly wrong interrupts.  Rather
 335          * than crashing, do something sensible.
 336          */
 337         if (irq >= NR_IRQS)
 338                 desc = &bad_irq_desc;
 339
 340         irq_enter();
 341         spin_lock(&irq_controller_lock);
 342         desc->handle(irq, desc, regs);
 343         spin_unlock(&irq_controller_lock);
 344         irq_exit();
 345 }
 346
 347 void __set_irq_handler(unsigned int irq, irq_handler_t handle, int is_chained)
 348 {
 349         struct irqdesc *desc;
 350         unsigned long flags;
 351
 352         if (irq >= NR_IRQS) {
 353                 printk(KERN_ERR "Trying to install handler for IRQ%d\n", irq);
 354                 return;
 355         }
 356
 357         if (handle == NULL)
 358                 handle = do_bad_IRQ;
 359
 360         desc = irq_desc + irq;
 361
 362         if (is_chained && desc->chip == &bad_chip)
 363                 printk(KERN_WARNING "Trying to install chained handler for IRQ%d\n", irq);
 364
 365         spin_lock_irqsave(&irq_controller_lock, flags);
 366         if (handle == do_bad_IRQ) {
 367                 desc->chip->mask(irq);
 368                 desc->chip->ack(irq);
 369                 desc->depth = 1;
 370                 desc->enabled = 0;
 371         }
 372         desc->handle = handle;
 373         if (handle != do_bad_IRQ && is_chained) {
 374                 desc->valid = 0;
 375                 desc->probe_ok = 0;
 376                 desc->depth = 0;
 377                 desc->chip->unmask(irq);
 378         }
 379         spin_unlock_irqrestore(&irq_controller_lock, flags);
 380 }
 381
 382 void set_irq_chip(unsigned int irq, struct irqchip *chip)
 383 {
 384         struct irqdesc *desc;
 385         unsigned long flags;
 386
 387         if (irq >= NR_IRQS) {
 388                 printk(KERN_ERR "Trying to install chip for IRQ%d\n", irq);
 389                 return;
 390         }
 391
 392         if (chip == NULL)
 393                 chip = &bad_chip;
 394
 395         desc = irq_desc + irq;
 396         spin_lock_irqsave(&irq_controller_lock, flags);
 397         desc->chip = chip;
 398         spin_unlock_irqrestore(&irq_controller_lock, flags);
 399 }
 400
 401 int set_irq_type(unsigned int irq, unsigned int type)
 402 {
 403         struct irqdesc *desc;
 404         unsigned long flags;
 405         int ret = -ENXIO;
 406
 407         if (irq >= NR_IRQS) {
 408                 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq);
 409                 return -ENODEV;
 410         }
 411
 412         desc = irq_desc + irq;
 413         if (desc->chip->type) {
 414                 spin_lock_irqsave(&irq_controller_lock, flags);
 415                 ret = desc->chip->type(irq, type);
 416                 spin_unlock_irqrestore(&irq_controller_lock, flags);
 417         }
 418
 419         return ret;
 420 }
 421
 422 void set_irq_flags(unsigned int irq, unsigned int iflags)
 423 {
 424         struct irqdesc *desc;
 425         unsigned long flags;
 426
 427         if (irq >= NR_IRQS) {
 428                 printk(KERN_ERR "Trying to set irq flags for IRQ%d\n", irq);
 429                 return;
 430         }
 431
 432         desc = irq_desc + irq;
 433         spin_lock_irqsave(&irq_controller_lock, flags);
 434         desc->valid = (iflags & IRQF_VALID) != 0;
 435         desc->probe_ok = (iflags & IRQF_PROBE) != 0;
 436         desc->noautoenable = (iflags & IRQF_NOAUTOEN) != 0;
 437         spin_unlock_irqrestore(&irq_controller_lock, flags);
 438 }
 439
 440 int setup_irq(unsigned int irq, struct irqaction *new)
 441 {
 442         int shared = 0;
 443         struct irqaction *old, **p;
 444         unsigned long flags;
 445         struct irqdesc *desc;
 446
 447         /*
 448          * Some drivers like serial.c use request_irq() heavily,
 449          * so we have to be careful not to interfere with a
 450          * running system.
 451          */
 452         if (new->flags & SA_SAMPLE_RANDOM) {
 453                 /*
 454                  * This function might sleep, we want to call it first,
 455                  * outside of the atomic block.
 456                  * Yes, this might clear the entropy pool if the wrong
 457                  * driver is attempted to be loaded, without actually
 458                  * installing a new handler, but is this really a problem,
 459                  * only the sysadmin is able to do this.
 460                  */
 461                 rand_initialize_irq(irq);
 462         }
 463
 464         /*
 465          * The following block of code has to be executed atomically
 466          */
 467         desc = irq_desc + irq;
 468         spin_lock_irqsave(&irq_controller_lock, flags);
 469         p = &desc->action;
 470         if ((old = *p) != NULL) {
 471                 /* Can't share interrupts unless both agree to */
 472                 if (!(old->flags & new->flags & SA_SHIRQ)) {
 473                         spin_unlock_irqrestore(&irq_controller_lock, flags);
 474                         return -EBUSY;
 475                 }
 476
 477                 /* add new interrupt at end of irq queue */
 478                 do {
 479                         p = &old->next;
 480                         old = *p;
 481                 } while (old);
 482                 shared = 1;
 483         }
 484
 485         *p = new;
 486
 487         if (!shared) {
 488                 desc->probing = 0;
 489                 desc->running = 0;
 490                 desc->pending = 0;
 491                 desc->depth = 1;
 492                 if (!desc->noautoenable) {
 493                         desc->depth = 0;
 494                         desc->enabled = 1;
 495                         desc->chip->unmask(irq);
 496                 }
 497         }
 498
 499         spin_unlock_irqrestore(&irq_controller_lock, flags);
 500         return 0;
 501 }
 502
 503 /**
 504  *      request_irq - allocate an interrupt line
 505  *      @irq: Interrupt line to allocate
 506  *      @handler: Function to be called when the IRQ occurs
 507  *      @irqflags: Interrupt type flags
 508  *      @devname: An ascii name for the claiming device
 509  *      @dev_id: A cookie passed back to the handler function
 510  *
 511  *      This call allocates interrupt resources and enables the
 512  *      interrupt line and IRQ handling. From the point this
 513  *      call is made your handler function may be invoked. Since
 514  *      your handler function must clear any interrupt the board
 515  *      raises, you must take care both to initialise your hardware
 516  *      and to set up the interrupt handler in the right order.
 517  *
 518  *      Dev_id must be globally unique. Normally the address of the
 519  *      device data structure is used as the cookie. Since the handler
 520  *      receives this value it makes sense to use it.
 521  *
 522  *      If your interrupt is shared you must pass a non NULL dev_id
 523  *      as this is required when freeing the interrupt.
 524  *
 525  *      Flags:
 526  *
 527  *      SA_SHIRQ                Interrupt is shared
 528  *
 529  *      SA_INTERRUPT            Disable local interrupts while processing
 530  *
 531  *      SA_SAMPLE_RANDOM        The interrupt can be used for entropy
 532  *
 533  */
 534
 535 //FIXME - handler used to return void - whats the significance of the change?
 536 int request_irq(unsigned int irq, irqreturn_t (*handler)(int, void *, struct pt_regs *),
 537                  unsigned long irq_flags, const char * devname, void *dev_id)
 538 {
 539         unsigned long retval;
 540         struct irqaction *action;
 541
 542         if (irq >= NR_IRQS || !irq_desc[irq].valid || !handler ||
 543             (irq_flags & SA_SHIRQ && !dev_id))
 544                 return -EINVAL;
 545
 546         action = (struct irqaction *)kmalloc(sizeof(struct irqaction), GFP_KERNEL);
 547         if (!action)
 548                 return -ENOMEM;
 549
 550         action->handler = handler;
 551         action->flags = irq_flags;
 552         action->mask = 0;
 553         action->name = devname;
 554         action->next = NULL;
 555         action->dev_id = dev_id;
 556
 557         retval = setup_irq(irq, action);
 558
 559         if (retval)
 560                 kfree(action);
 561         return retval;
 562 }
 563
 564 EXPORT_SYMBOL(request_irq);
 565
 566 /**
 567  *      free_irq - free an interrupt
 568  *      @irq: Interrupt line to free
 569  *      @dev_id: Device identity to free
 570  *
 571  *      Remove an interrupt handler. The handler is removed and if the
 572  *      interrupt line is no longer in use by any driver it is disabled.
 573  *      On a shared IRQ the caller must ensure the interrupt is disabled
 574  *      on the card it drives before calling this function.
 575  *
 576  *      This function may be called from interrupt context.
 577  */
 578 void free_irq(unsigned int irq, void *dev_id)
 579 {
 580         struct irqaction * action, **p;
 581         unsigned long flags;
 582
 583         if (irq >= NR_IRQS || !irq_desc[irq].valid) {
 584                 printk(KERN_ERR "Trying to free IRQ%d\n",irq);
 585 #ifdef CONFIG_DEBUG_ERRORS
 586                 __backtrace();
 587 #endif
 588                 return;
 589         }
 590
 591         spin_lock_irqsave(&irq_controller_lock, flags);
 592         for (p = &irq_desc[irq].action; (action = *p) != NULL; p = &action->next) {
 593                 if (action->dev_id != dev_id)
 594                         continue;
 595
 596                 /* Found it - now free it */
 597                 *p = action->next;
 598                 kfree(action);
 599                 goto out;
 600         }
 601         printk(KERN_ERR "Trying to free free IRQ%d\n",irq);
 602 #ifdef CONFIG_DEBUG_ERRORS
 603         __backtrace();
 604 #endif
 605 out:
 606         spin_unlock_irqrestore(&irq_controller_lock, flags);
 607 }
 608
 609 EXPORT_SYMBOL(free_irq);
 610
 611 /* Start the interrupt probing.  Unlike other architectures,
 612  * we don't return a mask of interrupts from probe_irq_on,
 613  * but return the number of interrupts enabled for the probe.
 614  * The interrupts which have been enabled for probing is
 615  * instead recorded in the irq_desc structure.
 616  */
 617 unsigned long probe_irq_on(void)
 618 {
 619         unsigned int i, irqs = 0;
 620         unsigned long delay;
 621
 622         /*
 623          * first snaffle up any unassigned but
 624          * probe-able interrupts
 625          */
 626         spin_lock_irq(&irq_controller_lock);
 627         for (i = 0; i < NR_IRQS; i++) {
 628                 if (!irq_desc[i].probe_ok || irq_desc[i].action)
 629                         continue;
 630
 631                 irq_desc[i].probing = 1;
 632                 irq_desc[i].triggered = 0;
 633                 if (irq_desc[i].chip->type)
 634                         irq_desc[i].chip->type(i, IRQT_PROBE);
 635                 irq_desc[i].chip->unmask(i);
 636                 irqs += 1;
 637         }
 638         spin_unlock_irq(&irq_controller_lock);
 639
 640         /*
 641          * wait for spurious interrupts to mask themselves out again
 642          */
 643         for (delay = jiffies + HZ/10; time_before(jiffies, delay); )
 644                 /* min 100ms delay */;
 645
 646         /*
 647          * now filter out any obviously spurious interrupts
 648          */
 649         spin_lock_irq(&irq_controller_lock);
 650         for (i = 0; i < NR_IRQS; i++) {
 651                 if (irq_desc[i].probing && irq_desc[i].triggered) {
 652                         irq_desc[i].probing = 0;
 653                         irqs -= 1;
 654                 }
 655         }
 656         spin_unlock_irq(&irq_controller_lock);
 657
 658         return irqs;
 659 }
 660
 661 EXPORT_SYMBOL(probe_irq_on);
 662
 663 /*
 664  * Possible return values:
 665  *  >= 0 - interrupt number
 666  *    -1 - no interrupt/many interrupts
 667  */
 668 int probe_irq_off(unsigned long irqs)
 669 {
 670         unsigned int i;
 671         int irq_found = NO_IRQ;
 672
 673         /*
 674          * look at the interrupts, and find exactly one
 675          * that we were probing has been triggered
 676          */
 677         spin_lock_irq(&irq_controller_lock);
 678         for (i = 0; i < NR_IRQS; i++) {
 679                 if (irq_desc[i].probing &&
 680                     irq_desc[i].triggered) {
 681                         if (irq_found != NO_IRQ) {
 682                                 irq_found = NO_IRQ;
 683                                 goto out;
 684                         }
 685                         irq_found = i;
 686                 }
 687         }
 688
 689         if (irq_found == -1)
 690                 irq_found = NO_IRQ;
 691 out:
 692         spin_unlock_irq(&irq_controller_lock);
 693
 694         return irq_found;
 695 }
 696
 697 EXPORT_SYMBOL(probe_irq_off);
 698
 699 void __init init_irq_proc(void)
 700 {
 701 }
 702
 703 void __init init_IRQ(void)
 704 {
 705         struct irqdesc *desc;
 706         extern void init_dma(void);
 707         int irq;
 708
 709         for (irq = 0, desc = irq_desc; irq < NR_IRQS; irq++, desc++)
 710                 *desc = bad_irq_desc;
 711
 712         arc_init_irq();
 713         init_dma();
 714 }