1 /* 2 * linux/kernel/irq/manage.c 3 * 4 * Copyright (C) 1992, 1998-2004 Linus Torvalds, Ingo Molnar 5 * 6 * This file contains driver APIs to the irq subsystem. 7 */ 8 9 #include <linux/config.h> 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 cpumask_t irq_affinity[NR_IRQS] = { [0 ... NR_IRQS-1] = CPU_MASK_ALL }; 20 21 #if defined (CONFIG_GENERIC_PENDING_IRQ) || defined (CONFIG_IRQBALANCE) 22 cpumask_t __cacheline_aligned pending_irq_cpumask[NR_IRQS]; 23 #endif 24 25 /** 26 * synchronize_irq - wait for pending IRQ handlers (on other CPUs) 27 * 28 * This function waits for any pending IRQ handlers for this interrupt 29 * to complete before returning. If you use this function while 30 * holding a resource the IRQ handler may need you will deadlock. 31 * 32 * This function may be called - with care - from IRQ context. 33 */ 34 void synchronize_irq(unsigned int irq) 35 { 36 struct irq_desc *desc = irq_desc + irq; 37 38 while (desc->status & IRQ_INPROGRESS) 39 cpu_relax(); 40 } 41 42 EXPORT_SYMBOL(synchronize_irq); 43 44 #endif 45 46 /** 47 * disable_irq_nosync - disable an irq without waiting 48 * @irq: Interrupt to disable 49 * 50 * Disable the selected interrupt line. Disables and Enables are 51 * nested. 52 * Unlike disable_irq(), this function does not ensure existing 53 * instances of the IRQ handler have completed before returning. 54 * 55 * This function may be called from IRQ context. 56 */ 57 void disable_irq_nosync(unsigned int irq) 58 { 59 irq_desc_t *desc = irq_desc + irq; 60 unsigned long flags; 61 62 spin_lock_irqsave(&desc->lock, flags); 63 if (!desc->depth++) { 64 desc->status |= IRQ_DISABLED; 65 desc->handler->disable(irq); 66 } 67 spin_unlock_irqrestore(&desc->lock, flags); 68 } 69 70 EXPORT_SYMBOL(disable_irq_nosync); 71 72 /** 73 * disable_irq - disable an irq and wait for completion 74 * @irq: Interrupt to disable 75 * 76 * Disable the selected interrupt line. Enables and Disables are 77 * nested. 78 * This function waits for any pending IRQ handlers for this interrupt 79 * to complete before returning. If you use this function while 80 * holding a resource the IRQ handler may need you will deadlock. 81 * 82 * This function may be called - with care - from IRQ context. 83 */ 84 void disable_irq(unsigned int irq) 85 { 86 irq_desc_t *desc = irq_desc + irq; 87 88 disable_irq_nosync(irq); 89 if (desc->action) 90 synchronize_irq(irq); 91 } 92 93 EXPORT_SYMBOL(disable_irq); 94 95 /** 96 * enable_irq - enable handling of an irq 97 * @irq: Interrupt to enable 98 * 99 * Undoes the effect of one call to disable_irq(). If this 100 * matches the last disable, processing of interrupts on this 101 * IRQ line is re-enabled. 102 * 103 * This function may be called from IRQ context. 104 */ 105 void enable_irq(unsigned int irq) 106 { 107 irq_desc_t *desc = irq_desc + irq; 108 unsigned long flags; 109 110 spin_lock_irqsave(&desc->lock, flags); 111 switch (desc->depth) { 112 case 0: 113 WARN_ON(1); 114 break; 115 case 1: { 116 unsigned int status = desc->status & ~IRQ_DISABLED; 117 118 desc->status = status; 119 if ((status & (IRQ_PENDING | IRQ_REPLAY)) == IRQ_PENDING) { 120 desc->status = status | IRQ_REPLAY; 121 hw_resend_irq(desc->handler,irq); 122 } 123 desc->handler->enable(irq); 124 /* fall-through */ 125 } 126 default: 127 desc->depth--; 128 } 129 spin_unlock_irqrestore(&desc->lock, flags); 130 } 131 132 EXPORT_SYMBOL(enable_irq); 133 134 /* 135 * Internal function that tells the architecture code whether a 136 * particular irq has been exclusively allocated or is available 137 * for driver use. 138 */ 139 int can_request_irq(unsigned int irq, unsigned long irqflags) 140 { 141 struct irqaction *action; 142 143 if (irq >= NR_IRQS) 144 return 0; 145 146 action = irq_desc[irq].action; 147 if (action) 148 if (irqflags & action->flags & SA_SHIRQ) 149 action = NULL; 150 151 return !action; 152 } 153 154 /* 155 * Internal function to register an irqaction - typically used to 156 * allocate special interrupts that are part of the architecture. 157 */ 158 int setup_irq(unsigned int irq, struct irqaction * new) 159 { 160 struct irq_desc *desc = irq_desc + irq; 161 struct irqaction *old, **p; 162 unsigned long flags; 163 int shared = 0; 164 165 if (desc->handler == &no_irq_type) 166 return -ENOSYS; 167 /* 168 * Some drivers like serial.c use request_irq() heavily, 169 * so we have to be careful not to interfere with a 170 * running system. 171 */ 172 if (new->flags & SA_SAMPLE_RANDOM) { 173 /* 174 * This function might sleep, we want to call it first, 175 * outside of the atomic block. 176 * Yes, this might clear the entropy pool if the wrong 177 * driver is attempted to be loaded, without actually 178 * installing a new handler, but is this really a problem, 179 * only the sysadmin is able to do this. 180 */ 181 rand_initialize_irq(irq); 182 } 183 184 /* 185 * The following block of code has to be executed atomically 186 */ 187 spin_lock_irqsave(&desc->lock,flags); 188 p = &desc->action; 189 if ((old = *p) != NULL) { 190 /* Can't share interrupts unless both agree to */ 191 if (!(old->flags & new->flags & SA_SHIRQ)) { 192 spin_unlock_irqrestore(&desc->lock,flags); 193 return -EBUSY; 194 } 195 196 /* add new interrupt at end of irq queue */ 197 do { 198 p = &old->next; 199 old = *p; 200 } while (old); 201 shared = 1; 202 } 203 204 *p = new; 205 206 if (!shared) { 207 desc->depth = 0; 208 desc->status &= ~(IRQ_DISABLED | IRQ_AUTODETECT | 209 IRQ_WAITING | IRQ_INPROGRESS); 210 if (desc->handler->startup) 211 desc->handler->startup(irq); 212 else 213 desc->handler->enable(irq); 214 } 215 spin_unlock_irqrestore(&desc->lock,flags); 216 217 new->irq = irq; 218 register_irq_proc(irq); 219 new->dir = NULL; 220 register_handler_proc(irq, new); 221 222 return 0; 223 } 224 225 /** 226 * free_irq - free an interrupt 227 * @irq: Interrupt line to free 228 * @dev_id: Device identity to free 229 * 230 * Remove an interrupt handler. The handler is removed and if the 231 * interrupt line is no longer in use by any driver it is disabled. 232 * On a shared IRQ the caller must ensure the interrupt is disabled 233 * on the card it drives before calling this function. The function 234 * does not return until any executing interrupts for this IRQ 235 * have completed. 236 * 237 * This function must not be called from interrupt context. 238 */ 239 void free_irq(unsigned int irq, void *dev_id) 240 { 241 struct irq_desc *desc; 242 struct irqaction **p; 243 unsigned long flags; 244 245 if (irq >= NR_IRQS) 246 return; 247 248 desc = irq_desc + irq; 249 spin_lock_irqsave(&desc->lock,flags); 250 p = &desc->action; 251 for (;;) { 252 struct irqaction * action = *p; 253 254 if (action) { 255 struct irqaction **pp = p; 256 257 p = &action->next; 258 if (action->dev_id != dev_id) 259 continue; 260 261 /* Found it - now remove it from the list of entries */ 262 *pp = action->next; 263 264 /* Currently used only by UML, might disappear one day.*/ 265 #ifdef CONFIG_IRQ_RELEASE_METHOD 266 if (desc->handler->release) 267 desc->handler->release(irq, dev_id); 268 #endif 269 270 if (!desc->action) { 271 desc->status |= IRQ_DISABLED; 272 if (desc->handler->shutdown) 273 desc->handler->shutdown(irq); 274 else 275 desc->handler->disable(irq); 276 } 277 spin_unlock_irqrestore(&desc->lock,flags); 278 unregister_handler_proc(irq, action); 279 280 /* Make sure it's not being used on another CPU */ 281 synchronize_irq(irq); 282 kfree(action); 283 return; 284 } 285 printk(KERN_ERR "Trying to free free IRQ%d\n",irq); 286 spin_unlock_irqrestore(&desc->lock,flags); 287 return; 288 } 289 } 290 291 EXPORT_SYMBOL(free_irq); 292 293 /** 294 * request_irq - allocate an interrupt line 295 * @irq: Interrupt line to allocate 296 * @handler: Function to be called when the IRQ occurs 297 * @irqflags: Interrupt type flags 298 * @devname: An ascii name for the claiming device 299 * @dev_id: A cookie passed back to the handler function 300 * 301 * This call allocates interrupt resources and enables the 302 * interrupt line and IRQ handling. From the point this 303 * call is made your handler function may be invoked. Since 304 * your handler function must clear any interrupt the board 305 * raises, you must take care both to initialise your hardware 306 * and to set up the interrupt handler in the right order. 307 * 308 * Dev_id must be globally unique. Normally the address of the 309 * device data structure is used as the cookie. Since the handler 310 * receives this value it makes sense to use it. 311 * 312 * If your interrupt is shared you must pass a non NULL dev_id 313 * as this is required when freeing the interrupt. 314 * 315 * Flags: 316 * 317 * SA_SHIRQ Interrupt is shared 318 * SA_INTERRUPT Disable local interrupts while processing 319 * SA_SAMPLE_RANDOM The interrupt can be used for entropy 320 * 321 */ 322 int request_irq(unsigned int irq, 323 irqreturn_t (*handler)(int, void *, struct pt_regs *), 324 unsigned long irqflags, const char * devname, void *dev_id) 325 { 326 struct irqaction * action; 327 int retval; 328 329 /* 330 * Sanity-check: shared interrupts must pass in a real dev-ID, 331 * otherwise we'll have trouble later trying to figure out 332 * which interrupt is which (messes up the interrupt freeing 333 * logic etc). 334 */ 335 if ((irqflags & SA_SHIRQ) && !dev_id) 336 return -EINVAL; 337 if (irq >= NR_IRQS) 338 return -EINVAL; 339 if (!handler) 340 return -EINVAL; 341 342 action = kmalloc(sizeof(struct irqaction), GFP_ATOMIC); 343 if (!action) 344 return -ENOMEM; 345 346 action->handler = handler; 347 action->flags = irqflags; 348 cpus_clear(action->mask); 349 action->name = devname; 350 action->next = NULL; 351 action->dev_id = dev_id; 352 353 retval = setup_irq(irq, action); 354 if (retval) 355 kfree(action); 356 357 return retval; 358 } 359 360 EXPORT_SYMBOL(request_irq); 361 362