1 /* 2 * linux/kernel/irq/chip.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, for irq-chip 8 * based architectures. 9 * 10 * Detailed information is available in Documentation/DocBook/genericirq 11 */ 12 13 #include <linux/irq.h> 14 #include <linux/module.h> 15 #include <linux/interrupt.h> 16 #include <linux/kernel_stat.h> 17 18 #include "internals.h" 19 20 /** 21 * set_irq_chip - set the irq chip for an irq 22 * @irq: irq number 23 * @chip: pointer to irq chip description structure 24 */ 25 int set_irq_chip(unsigned int irq, struct irq_chip *chip) 26 { 27 struct irq_desc *desc; 28 unsigned long flags; 29 30 if (irq >= NR_IRQS) { 31 printk(KERN_ERR "Trying to install chip for IRQ%d\n", irq); 32 WARN_ON(1); 33 return -EINVAL; 34 } 35 36 if (!chip) 37 chip = &no_irq_chip; 38 39 desc = irq_desc + irq; 40 spin_lock_irqsave(&desc->lock, flags); 41 irq_chip_set_defaults(chip); 42 desc->chip = chip; 43 /* 44 * For compatibility only: 45 */ 46 desc->chip = chip; 47 spin_unlock_irqrestore(&desc->lock, flags); 48 49 return 0; 50 } 51 EXPORT_SYMBOL(set_irq_chip); 52 53 /** 54 * set_irq_type - set the irq type for an irq 55 * @irq: irq number 56 * @type: interrupt type - see include/linux/interrupt.h 57 */ 58 int set_irq_type(unsigned int irq, unsigned int type) 59 { 60 struct irq_desc *desc; 61 unsigned long flags; 62 int ret = -ENXIO; 63 64 if (irq >= NR_IRQS) { 65 printk(KERN_ERR "Trying to set irq type for IRQ%d\n", irq); 66 return -ENODEV; 67 } 68 69 desc = irq_desc + irq; 70 if (desc->chip->set_type) { 71 spin_lock_irqsave(&desc->lock, flags); 72 ret = desc->chip->set_type(irq, type); 73 spin_unlock_irqrestore(&desc->lock, flags); 74 } 75 return ret; 76 } 77 EXPORT_SYMBOL(set_irq_type); 78 79 /** 80 * set_irq_data - set irq type data for an irq 81 * @irq: Interrupt number 82 * @data: Pointer to interrupt specific data 83 * 84 * Set the hardware irq controller data for an irq 85 */ 86 int set_irq_data(unsigned int irq, void *data) 87 { 88 struct irq_desc *desc; 89 unsigned long flags; 90 91 if (irq >= NR_IRQS) { 92 printk(KERN_ERR 93 "Trying to install controller data for IRQ%d\n", irq); 94 return -EINVAL; 95 } 96 97 desc = irq_desc + irq; 98 spin_lock_irqsave(&desc->lock, flags); 99 desc->handler_data = data; 100 spin_unlock_irqrestore(&desc->lock, flags); 101 return 0; 102 } 103 EXPORT_SYMBOL(set_irq_data); 104 105 /** 106 * set_irq_chip_data - set irq chip data for an irq 107 * @irq: Interrupt number 108 * @data: Pointer to chip specific data 109 * 110 * Set the hardware irq chip data for an irq 111 */ 112 int set_irq_chip_data(unsigned int irq, void *data) 113 { 114 struct irq_desc *desc = irq_desc + irq; 115 unsigned long flags; 116 117 if (irq >= NR_IRQS || !desc->chip) { 118 printk(KERN_ERR "BUG: bad set_irq_chip_data(IRQ#%d)\n", irq); 119 return -EINVAL; 120 } 121 122 spin_lock_irqsave(&desc->lock, flags); 123 desc->chip_data = data; 124 spin_unlock_irqrestore(&desc->lock, flags); 125 126 return 0; 127 } 128 EXPORT_SYMBOL(set_irq_chip_data); 129 130 /* 131 * default enable function 132 */ 133 static void default_enable(unsigned int irq) 134 { 135 struct irq_desc *desc = irq_desc + irq; 136 137 desc->chip->unmask(irq); 138 desc->status &= ~IRQ_MASKED; 139 } 140 141 /* 142 * default disable function 143 */ 144 static void default_disable(unsigned int irq) 145 { 146 struct irq_desc *desc = irq_desc + irq; 147 148 if (!(desc->status & IRQ_DELAYED_DISABLE)) 149 irq_desc[irq].chip->mask(irq); 150 } 151 152 /* 153 * default startup function 154 */ 155 static unsigned int default_startup(unsigned int irq) 156 { 157 irq_desc[irq].chip->enable(irq); 158 159 return 0; 160 } 161 162 /* 163 * Fixup enable/disable function pointers 164 */ 165 void irq_chip_set_defaults(struct irq_chip *chip) 166 { 167 if (!chip->enable) 168 chip->enable = default_enable; 169 if (!chip->disable) 170 chip->disable = default_disable; 171 if (!chip->startup) 172 chip->startup = default_startup; 173 if (!chip->shutdown) 174 chip->shutdown = chip->disable; 175 if (!chip->name) 176 chip->name = chip->typename; 177 } 178 179 static inline void mask_ack_irq(struct irq_desc *desc, int irq) 180 { 181 if (desc->chip->mask_ack) 182 desc->chip->mask_ack(irq); 183 else { 184 desc->chip->mask(irq); 185 desc->chip->ack(irq); 186 } 187 } 188 189 /** 190 * handle_simple_irq - Simple and software-decoded IRQs. 191 * @irq: the interrupt number 192 * @desc: the interrupt description structure for this irq 193 * @regs: pointer to a register structure 194 * 195 * Simple interrupts are either sent from a demultiplexing interrupt 196 * handler or come from hardware, where no interrupt hardware control 197 * is necessary. 198 * 199 * Note: The caller is expected to handle the ack, clear, mask and 200 * unmask issues if necessary. 201 */ 202 void fastcall 203 handle_simple_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs) 204 { 205 struct irqaction *action; 206 irqreturn_t action_ret; 207 const unsigned int cpu = smp_processor_id(); 208 209 spin_lock(&desc->lock); 210 211 if (unlikely(desc->status & IRQ_INPROGRESS)) 212 goto out_unlock; 213 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING); 214 kstat_cpu(cpu).irqs[irq]++; 215 216 action = desc->action; 217 if (unlikely(!action || (desc->status & IRQ_DISABLED))) 218 goto out_unlock; 219 220 desc->status |= IRQ_INPROGRESS; 221 spin_unlock(&desc->lock); 222 223 action_ret = handle_IRQ_event(irq, regs, action); 224 if (!noirqdebug) 225 note_interrupt(irq, desc, action_ret, regs); 226 227 spin_lock(&desc->lock); 228 desc->status &= ~IRQ_INPROGRESS; 229 out_unlock: 230 spin_unlock(&desc->lock); 231 } 232 233 /** 234 * handle_level_irq - Level type irq handler 235 * @irq: the interrupt number 236 * @desc: the interrupt description structure for this irq 237 * @regs: pointer to a register structure 238 * 239 * Level type interrupts are active as long as the hardware line has 240 * the active level. This may require to mask the interrupt and unmask 241 * it after the associated handler has acknowledged the device, so the 242 * interrupt line is back to inactive. 243 */ 244 void fastcall 245 handle_level_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs) 246 { 247 unsigned int cpu = smp_processor_id(); 248 struct irqaction *action; 249 irqreturn_t action_ret; 250 251 spin_lock(&desc->lock); 252 mask_ack_irq(desc, irq); 253 254 if (unlikely(desc->status & IRQ_INPROGRESS)) 255 goto out_unlock; 256 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING); 257 kstat_cpu(cpu).irqs[irq]++; 258 259 /* 260 * If its disabled or no action available 261 * keep it masked and get out of here 262 */ 263 action = desc->action; 264 if (unlikely(!action || (desc->status & IRQ_DISABLED))) { 265 desc->status |= IRQ_PENDING; 266 goto out_unlock; 267 } 268 269 desc->status |= IRQ_INPROGRESS; 270 desc->status &= ~IRQ_PENDING; 271 spin_unlock(&desc->lock); 272 273 action_ret = handle_IRQ_event(irq, regs, action); 274 if (!noirqdebug) 275 note_interrupt(irq, desc, action_ret, regs); 276 277 spin_lock(&desc->lock); 278 desc->status &= ~IRQ_INPROGRESS; 279 if (!(desc->status & IRQ_DISABLED) && desc->chip->unmask) 280 desc->chip->unmask(irq); 281 out_unlock: 282 spin_unlock(&desc->lock); 283 } 284 285 /** 286 * handle_fasteoi_irq - irq handler for transparent controllers 287 * @irq: the interrupt number 288 * @desc: the interrupt description structure for this irq 289 * @regs: pointer to a register structure 290 * 291 * Only a single callback will be issued to the chip: an ->eoi() 292 * call when the interrupt has been serviced. This enables support 293 * for modern forms of interrupt handlers, which handle the flow 294 * details in hardware, transparently. 295 */ 296 void fastcall 297 handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc, 298 struct pt_regs *regs) 299 { 300 unsigned int cpu = smp_processor_id(); 301 struct irqaction *action; 302 irqreturn_t action_ret; 303 304 spin_lock(&desc->lock); 305 306 if (unlikely(desc->status & IRQ_INPROGRESS)) 307 goto out; 308 309 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING); 310 kstat_cpu(cpu).irqs[irq]++; 311 312 /* 313 * If its disabled or no action available 314 * keep it masked and get out of here 315 */ 316 action = desc->action; 317 if (unlikely(!action || (desc->status & IRQ_DISABLED))) { 318 desc->status |= IRQ_PENDING; 319 goto out; 320 } 321 322 desc->status |= IRQ_INPROGRESS; 323 desc->status &= ~IRQ_PENDING; 324 spin_unlock(&desc->lock); 325 326 action_ret = handle_IRQ_event(irq, regs, action); 327 if (!noirqdebug) 328 note_interrupt(irq, desc, action_ret, regs); 329 330 spin_lock(&desc->lock); 331 desc->status &= ~IRQ_INPROGRESS; 332 out: 333 desc->chip->eoi(irq); 334 335 spin_unlock(&desc->lock); 336 } 337 338 /** 339 * handle_edge_irq - edge type IRQ handler 340 * @irq: the interrupt number 341 * @desc: the interrupt description structure for this irq 342 * @regs: pointer to a register structure 343 * 344 * Interrupt occures on the falling and/or rising edge of a hardware 345 * signal. The occurence is latched into the irq controller hardware 346 * and must be acked in order to be reenabled. After the ack another 347 * interrupt can happen on the same source even before the first one 348 * is handled by the assosiacted event handler. If this happens it 349 * might be necessary to disable (mask) the interrupt depending on the 350 * controller hardware. This requires to reenable the interrupt inside 351 * of the loop which handles the interrupts which have arrived while 352 * the handler was running. If all pending interrupts are handled, the 353 * loop is left. 354 */ 355 void fastcall 356 handle_edge_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs) 357 { 358 const unsigned int cpu = smp_processor_id(); 359 360 spin_lock(&desc->lock); 361 362 desc->status &= ~(IRQ_REPLAY | IRQ_WAITING); 363 364 /* 365 * If we're currently running this IRQ, or its disabled, 366 * we shouldn't process the IRQ. Mark it pending, handle 367 * the necessary masking and go out 368 */ 369 if (unlikely((desc->status & (IRQ_INPROGRESS | IRQ_DISABLED)) || 370 !desc->action)) { 371 desc->status |= (IRQ_PENDING | IRQ_MASKED); 372 mask_ack_irq(desc, irq); 373 goto out_unlock; 374 } 375 376 kstat_cpu(cpu).irqs[irq]++; 377 378 /* Start handling the irq */ 379 desc->chip->ack(irq); 380 381 /* Mark the IRQ currently in progress.*/ 382 desc->status |= IRQ_INPROGRESS; 383 384 do { 385 struct irqaction *action = desc->action; 386 irqreturn_t action_ret; 387 388 if (unlikely(!action)) { 389 desc->chip->mask(irq); 390 goto out_unlock; 391 } 392 393 /* 394 * When another irq arrived while we were handling 395 * one, we could have masked the irq. 396 * Renable it, if it was not disabled in meantime. 397 */ 398 if (unlikely((desc->status & 399 (IRQ_PENDING | IRQ_MASKED | IRQ_DISABLED)) == 400 (IRQ_PENDING | IRQ_MASKED))) { 401 desc->chip->unmask(irq); 402 desc->status &= ~IRQ_MASKED; 403 } 404 405 desc->status &= ~IRQ_PENDING; 406 spin_unlock(&desc->lock); 407 action_ret = handle_IRQ_event(irq, regs, action); 408 if (!noirqdebug) 409 note_interrupt(irq, desc, action_ret, regs); 410 spin_lock(&desc->lock); 411 412 } while ((desc->status & (IRQ_PENDING | IRQ_DISABLED)) == IRQ_PENDING); 413 414 desc->status &= ~IRQ_INPROGRESS; 415 out_unlock: 416 spin_unlock(&desc->lock); 417 } 418 419 #ifdef CONFIG_SMP 420 /** 421 * handle_percpu_IRQ - Per CPU local irq handler 422 * @irq: the interrupt number 423 * @desc: the interrupt description structure for this irq 424 * @regs: pointer to a register structure 425 * 426 * Per CPU interrupts on SMP machines without locking requirements 427 */ 428 void fastcall 429 handle_percpu_irq(unsigned int irq, struct irq_desc *desc, struct pt_regs *regs) 430 { 431 irqreturn_t action_ret; 432 433 kstat_this_cpu.irqs[irq]++; 434 435 if (desc->chip->ack) 436 desc->chip->ack(irq); 437 438 action_ret = handle_IRQ_event(irq, regs, desc->action); 439 if (!noirqdebug) 440 note_interrupt(irq, desc, action_ret, regs); 441 442 if (desc->chip->eoi) 443 desc->chip->eoi(irq); 444 } 445 446 #endif /* CONFIG_SMP */ 447 448 void 449 __set_irq_handler(unsigned int irq, 450 void fastcall (*handle)(unsigned int, irq_desc_t *, 451 struct pt_regs *), 452 int is_chained) 453 { 454 struct irq_desc *desc; 455 unsigned long flags; 456 457 if (irq >= NR_IRQS) { 458 printk(KERN_ERR 459 "Trying to install type control for IRQ%d\n", irq); 460 return; 461 } 462 463 desc = irq_desc + irq; 464 465 if (!handle) 466 handle = handle_bad_irq; 467 468 if (desc->chip == &no_irq_chip) { 469 printk(KERN_WARNING "Trying to install %sinterrupt handler " 470 "for IRQ%d\n", is_chained ? "chained " : " ", irq); 471 /* 472 * Some ARM implementations install a handler for really dumb 473 * interrupt hardware without setting an irq_chip. This worked 474 * with the ARM no_irq_chip but the check in setup_irq would 475 * prevent us to setup the interrupt at all. Switch it to 476 * dummy_irq_chip for easy transition. 477 */ 478 desc->chip = &dummy_irq_chip; 479 } 480 481 spin_lock_irqsave(&desc->lock, flags); 482 483 /* Uninstall? */ 484 if (handle == handle_bad_irq) { 485 if (desc->chip != &no_irq_chip) { 486 desc->chip->mask(irq); 487 desc->chip->ack(irq); 488 } 489 desc->status |= IRQ_DISABLED; 490 desc->depth = 1; 491 } 492 desc->handle_irq = handle; 493 494 if (handle != handle_bad_irq && is_chained) { 495 desc->status &= ~IRQ_DISABLED; 496 desc->status |= IRQ_NOREQUEST | IRQ_NOPROBE; 497 desc->depth = 0; 498 desc->chip->unmask(irq); 499 } 500 spin_unlock_irqrestore(&desc->lock, flags); 501 } 502 503 void 504 set_irq_chip_and_handler(unsigned int irq, struct irq_chip *chip, 505 void fastcall (*handle)(unsigned int, 506 struct irq_desc *, 507 struct pt_regs *)) 508 { 509 set_irq_chip(irq, chip); 510 __set_irq_handler(irq, handle, 0); 511 } 512 513 /* 514 * Get a descriptive string for the highlevel handler, for 515 * /proc/interrupts output: 516 */ 517 const char * 518 handle_irq_name(void fastcall (*handle)(unsigned int, struct irq_desc *, 519 struct pt_regs *)) 520 { 521 if (handle == handle_level_irq) 522 return "level "; 523 if (handle == handle_fasteoi_irq) 524 return "fasteoi"; 525 if (handle == handle_edge_irq) 526 return "edge "; 527 if (handle == handle_simple_irq) 528 return "simple "; 529 #ifdef CONFIG_SMP 530 if (handle == handle_percpu_irq) 531 return "percpu "; 532 #endif 533 if (handle == handle_bad_irq) 534 return "bad "; 535 536 return NULL; 537 } 538