1 /* 2 * linux/kernel/irq/manage.c 3 * 4 * Copyright (C) 1992, 1998-2006 Linus Torvalds, Ingo Molnar 5 * Copyright (C) 2005-2006 Thomas Gleixner 6 * 7 * This file contains driver APIs to the irq subsystem. 8 */ 9 10 #include <linux/irq.h> 11 #include <linux/module.h> 12 #include <linux/random.h> 13 #include <linux/interrupt.h> 14 15 #include "internals.h" 16 17 #ifdef CONFIG_SMP 18 19 /** 20 * synchronize_irq - wait for pending IRQ handlers (on other CPUs) 21 * @irq: interrupt number to wait for 22 * 23 * This function waits for any pending IRQ handlers for this interrupt 24 * to complete before returning. If you use this function while 25 * holding a resource the IRQ handler may need you will deadlock. 26 * 27 * This function may be called - with care - from IRQ context. 28 */ 29 void synchronize_irq(unsigned int irq) 30 { 31 struct irq_desc *desc = irq_desc + irq; 32 33 if (irq >= NR_IRQS) 34 return; 35 36 while (desc->status & IRQ_INPROGRESS) 37 cpu_relax(); 38 } 39 EXPORT_SYMBOL(synchronize_irq); 40 41 #endif 42 43 /** 44 * disable_irq_nosync - disable an irq without waiting 45 * @irq: Interrupt to disable 46 * 47 * Disable the selected interrupt line. Disables and Enables are 48 * nested. 49 * Unlike disable_irq(), this function does not ensure existing 50 * instances of the IRQ handler have completed before returning. 51 * 52 * This function may be called from IRQ context. 53 */ 54 void disable_irq_nosync(unsigned int irq) 55 { 56 struct irq_desc *desc = irq_desc + irq; 57 unsigned long flags; 58 59 if (irq >= NR_IRQS) 60 return; 61 62 spin_lock_irqsave(&desc->lock, flags); 63 if (!desc->depth++) { 64 desc->status |= IRQ_DISABLED; 65 desc->chip->disable(irq); 66 } 67 spin_unlock_irqrestore(&desc->lock, flags); 68 } 69 EXPORT_SYMBOL(disable_irq_nosync); 70 71 /** 72 * disable_irq - disable an irq and wait for completion 73 * @irq: Interrupt to disable 74 * 75 * Disable the selected interrupt line. Enables and Disables are 76 * nested. 77 * This function waits for any pending IRQ handlers for this interrupt 78 * to complete before returning. If you use this function while 79 * holding a resource the IRQ handler may need you will deadlock. 80 * 81 * This function may be called - with care - from IRQ context. 82 */ 83 void disable_irq(unsigned int irq) 84 { 85 struct irq_desc *desc = irq_desc + irq; 86 87 if (irq >= NR_IRQS) 88 return; 89 90 disable_irq_nosync(irq); 91 if (desc->action) 92 synchronize_irq(irq); 93 } 94 EXPORT_SYMBOL(disable_irq); 95 96 /** 97 * enable_irq - enable handling of an irq 98 * @irq: Interrupt to enable 99 * 100 * Undoes the effect of one call to disable_irq(). If this 101 * matches the last disable, processing of interrupts on this 102 * IRQ line is re-enabled. 103 * 104 * This function may be called from IRQ context. 105 */ 106 void enable_irq(unsigned int irq) 107 { 108 struct irq_desc *desc = irq_desc + irq; 109 unsigned long flags; 110 111 if (irq >= NR_IRQS) 112 return; 113 114 spin_lock_irqsave(&desc->lock, flags); 115 switch (desc->depth) { 116 case 0: 117 printk(KERN_WARNING "Unbalanced enable for IRQ %d\n", irq); 118 WARN_ON(1); 119 break; 120 case 1: { 121 unsigned int status = desc->status & ~IRQ_DISABLED; 122 123 /* Prevent probing on this irq: */ 124 desc->status = status | IRQ_NOPROBE; 125 check_irq_resend(desc, irq); 126 /* fall-through */ 127 } 128 default: 129 desc->depth--; 130 } 131 spin_unlock_irqrestore(&desc->lock, flags); 132 } 133 EXPORT_SYMBOL(enable_irq); 134 135 /** 136 * set_irq_wake - control irq power management wakeup 137 * @irq: interrupt to control 138 * @on: enable/disable power management wakeup 139 * 140 * Enable/disable power management wakeup mode, which is 141 * disabled by default. Enables and disables must match, 142 * just as they match for non-wakeup mode support. 143 * 144 * Wakeup mode lets this IRQ wake the system from sleep 145 * states like "suspend to RAM". 146 */ 147 int set_irq_wake(unsigned int irq, unsigned int on) 148 { 149 struct irq_desc *desc = irq_desc + irq; 150 unsigned long flags; 151 int ret = -ENXIO; 152 int (*set_wake)(unsigned, unsigned) = desc->chip->set_wake; 153 154 /* wakeup-capable irqs can be shared between drivers that 155 * don't need to have the same sleep mode behaviors. 156 */ 157 spin_lock_irqsave(&desc->lock, flags); 158 if (on) { 159 if (desc->wake_depth++ == 0) 160 desc->status |= IRQ_WAKEUP; 161 else 162 set_wake = NULL; 163 } else { 164 if (desc->wake_depth == 0) { 165 printk(KERN_WARNING "Unbalanced IRQ %d " 166 "wake disable\n", irq); 167 WARN_ON(1); 168 } else if (--desc->wake_depth == 0) 169 desc->status &= ~IRQ_WAKEUP; 170 else 171 set_wake = NULL; 172 } 173 if (set_wake) 174 ret = desc->chip->set_wake(irq, on); 175 spin_unlock_irqrestore(&desc->lock, flags); 176 return ret; 177 } 178 EXPORT_SYMBOL(set_irq_wake); 179 180 /* 181 * Internal function that tells the architecture code whether a 182 * particular irq has been exclusively allocated or is available 183 * for driver use. 184 */ 185 int can_request_irq(unsigned int irq, unsigned long irqflags) 186 { 187 struct irqaction *action; 188 189 if (irq >= NR_IRQS || irq_desc[irq].status & IRQ_NOREQUEST) 190 return 0; 191 192 action = irq_desc[irq].action; 193 if (action) 194 if (irqflags & action->flags & IRQF_SHARED) 195 action = NULL; 196 197 return !action; 198 } 199 200 void compat_irq_chip_set_default_handler(struct irq_desc *desc) 201 { 202 /* 203 * If the architecture still has not overriden 204 * the flow handler then zap the default. This 205 * should catch incorrect flow-type setting. 206 */ 207 if (desc->handle_irq == &handle_bad_irq) 208 desc->handle_irq = NULL; 209 } 210 211 /* 212 * Internal function to register an irqaction - typically used to 213 * allocate special interrupts that are part of the architecture. 214 */ 215 int setup_irq(unsigned int irq, struct irqaction *new) 216 { 217 struct irq_desc *desc = irq_desc + irq; 218 struct irqaction *old, **p; 219 unsigned long flags; 220 int shared = 0; 221 222 if (irq >= NR_IRQS) 223 return -EINVAL; 224 225 if (desc->chip == &no_irq_chip) 226 return -ENOSYS; 227 /* 228 * Some drivers like serial.c use request_irq() heavily, 229 * so we have to be careful not to interfere with a 230 * running system. 231 */ 232 if (new->flags & IRQF_SAMPLE_RANDOM) { 233 /* 234 * This function might sleep, we want to call it first, 235 * outside of the atomic block. 236 * Yes, this might clear the entropy pool if the wrong 237 * driver is attempted to be loaded, without actually 238 * installing a new handler, but is this really a problem, 239 * only the sysadmin is able to do this. 240 */ 241 rand_initialize_irq(irq); 242 } 243 244 /* 245 * The following block of code has to be executed atomically 246 */ 247 spin_lock_irqsave(&desc->lock, flags); 248 p = &desc->action; 249 old = *p; 250 if (old) { 251 /* 252 * Can't share interrupts unless both agree to and are 253 * the same type (level, edge, polarity). So both flag 254 * fields must have IRQF_SHARED set and the bits which 255 * set the trigger type must match. 256 */ 257 if (!((old->flags & new->flags) & IRQF_SHARED) || 258 ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK)) 259 goto mismatch; 260 261 #if defined(CONFIG_IRQ_PER_CPU) 262 /* All handlers must agree on per-cpuness */ 263 if ((old->flags & IRQF_PERCPU) != 264 (new->flags & IRQF_PERCPU)) 265 goto mismatch; 266 #endif 267 268 /* add new interrupt at end of irq queue */ 269 do { 270 p = &old->next; 271 old = *p; 272 } while (old); 273 shared = 1; 274 } 275 276 *p = new; 277 #if defined(CONFIG_IRQ_PER_CPU) 278 if (new->flags & IRQF_PERCPU) 279 desc->status |= IRQ_PER_CPU; 280 #endif 281 if (!shared) { 282 irq_chip_set_defaults(desc->chip); 283 284 /* Setup the type (level, edge polarity) if configured: */ 285 if (new->flags & IRQF_TRIGGER_MASK) { 286 if (desc->chip && desc->chip->set_type) 287 desc->chip->set_type(irq, 288 new->flags & IRQF_TRIGGER_MASK); 289 else 290 /* 291 * IRQF_TRIGGER_* but the PIC does not support 292 * multiple flow-types? 293 */ 294 printk(KERN_WARNING "No IRQF_TRIGGER set_type " 295 "function for IRQ %d (%s)\n", irq, 296 desc->chip ? desc->chip->name : 297 "unknown"); 298 } else 299 compat_irq_chip_set_default_handler(desc); 300 301 desc->status &= ~(IRQ_AUTODETECT | IRQ_WAITING | 302 IRQ_INPROGRESS); 303 304 if (!(desc->status & IRQ_NOAUTOEN)) { 305 desc->depth = 0; 306 desc->status &= ~IRQ_DISABLED; 307 if (desc->chip->startup) 308 desc->chip->startup(irq); 309 else 310 desc->chip->enable(irq); 311 } else 312 /* Undo nested disables: */ 313 desc->depth = 1; 314 } 315 spin_unlock_irqrestore(&desc->lock, flags); 316 317 new->irq = irq; 318 register_irq_proc(irq); 319 new->dir = NULL; 320 register_handler_proc(irq, new); 321 322 return 0; 323 324 mismatch: 325 spin_unlock_irqrestore(&desc->lock, flags); 326 if (!(new->flags & IRQF_PROBE_SHARED)) { 327 printk(KERN_ERR "IRQ handler type mismatch for IRQ %d\n", irq); 328 dump_stack(); 329 } 330 return -EBUSY; 331 } 332 333 /** 334 * free_irq - free an interrupt 335 * @irq: Interrupt line to free 336 * @dev_id: Device identity to free 337 * 338 * Remove an interrupt handler. The handler is removed and if the 339 * interrupt line is no longer in use by any driver it is disabled. 340 * On a shared IRQ the caller must ensure the interrupt is disabled 341 * on the card it drives before calling this function. The function 342 * does not return until any executing interrupts for this IRQ 343 * have completed. 344 * 345 * This function must not be called from interrupt context. 346 */ 347 void free_irq(unsigned int irq, void *dev_id) 348 { 349 struct irq_desc *desc; 350 struct irqaction **p; 351 unsigned long flags; 352 353 WARN_ON(in_interrupt()); 354 if (irq >= NR_IRQS) 355 return; 356 357 desc = irq_desc + irq; 358 spin_lock_irqsave(&desc->lock, flags); 359 p = &desc->action; 360 for (;;) { 361 struct irqaction *action = *p; 362 363 if (action) { 364 struct irqaction **pp = p; 365 366 p = &action->next; 367 if (action->dev_id != dev_id) 368 continue; 369 370 /* Found it - now remove it from the list of entries */ 371 *pp = action->next; 372 373 /* Currently used only by UML, might disappear one day.*/ 374 #ifdef CONFIG_IRQ_RELEASE_METHOD 375 if (desc->chip->release) 376 desc->chip->release(irq, dev_id); 377 #endif 378 379 if (!desc->action) { 380 desc->status |= IRQ_DISABLED; 381 if (desc->chip->shutdown) 382 desc->chip->shutdown(irq); 383 else 384 desc->chip->disable(irq); 385 } 386 spin_unlock_irqrestore(&desc->lock, flags); 387 unregister_handler_proc(irq, action); 388 389 /* Make sure it's not being used on another CPU */ 390 synchronize_irq(irq); 391 kfree(action); 392 return; 393 } 394 printk(KERN_ERR "Trying to free already-free IRQ %d\n", irq); 395 spin_unlock_irqrestore(&desc->lock, flags); 396 return; 397 } 398 } 399 EXPORT_SYMBOL(free_irq); 400 401 /** 402 * request_irq - allocate an interrupt line 403 * @irq: Interrupt line to allocate 404 * @handler: Function to be called when the IRQ occurs 405 * @irqflags: Interrupt type flags 406 * @devname: An ascii name for the claiming device 407 * @dev_id: A cookie passed back to the handler function 408 * 409 * This call allocates interrupt resources and enables the 410 * interrupt line and IRQ handling. From the point this 411 * call is made your handler function may be invoked. Since 412 * your handler function must clear any interrupt the board 413 * raises, you must take care both to initialise your hardware 414 * and to set up the interrupt handler in the right order. 415 * 416 * Dev_id must be globally unique. Normally the address of the 417 * device data structure is used as the cookie. Since the handler 418 * receives this value it makes sense to use it. 419 * 420 * If your interrupt is shared you must pass a non NULL dev_id 421 * as this is required when freeing the interrupt. 422 * 423 * Flags: 424 * 425 * IRQF_SHARED Interrupt is shared 426 * IRQF_DISABLED Disable local interrupts while processing 427 * IRQF_SAMPLE_RANDOM The interrupt can be used for entropy 428 * 429 */ 430 int request_irq(unsigned int irq, 431 irqreturn_t (*handler)(int, void *, struct pt_regs *), 432 unsigned long irqflags, const char *devname, void *dev_id) 433 { 434 struct irqaction *action; 435 int retval; 436 437 #ifdef CONFIG_LOCKDEP 438 /* 439 * Lockdep wants atomic interrupt handlers: 440 */ 441 irqflags |= SA_INTERRUPT; 442 #endif 443 /* 444 * Sanity-check: shared interrupts must pass in a real dev-ID, 445 * otherwise we'll have trouble later trying to figure out 446 * which interrupt is which (messes up the interrupt freeing 447 * logic etc). 448 */ 449 if ((irqflags & IRQF_SHARED) && !dev_id) 450 return -EINVAL; 451 if (irq >= NR_IRQS) 452 return -EINVAL; 453 if (irq_desc[irq].status & IRQ_NOREQUEST) 454 return -EINVAL; 455 if (!handler) 456 return -EINVAL; 457 458 action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC); 459 if (!action) 460 return -ENOMEM; 461 462 action->handler = handler; 463 action->flags = irqflags; 464 cpus_clear(action->mask); 465 action->name = devname; 466 action->next = NULL; 467 action->dev_id = dev_id; 468 469 select_smp_affinity(irq); 470 471 retval = setup_irq(irq, action); 472 if (retval) 473 kfree(action); 474 475 return retval; 476 } 477 EXPORT_SYMBOL(request_irq); 478 479