Branch data Line data Source code
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 : : #define pr_fmt(fmt) "genirq: " fmt
11 : :
12 : : #include <linux/irq.h>
13 : : #include <linux/kthread.h>
14 : : #include <linux/module.h>
15 : : #include <linux/random.h>
16 : : #include <linux/interrupt.h>
17 : : #include <linux/slab.h>
18 : : #include <linux/sched.h>
19 : : #include <linux/sched/rt.h>
20 : : #include <linux/task_work.h>
21 : :
22 : : #include "internals.h"
23 : :
24 : : #ifdef CONFIG_IRQ_FORCED_THREADING
25 : : __read_mostly bool force_irqthreads;
26 : :
27 : 0 : static int __init setup_forced_irqthreads(char *arg)
28 : : {
29 : 0 : force_irqthreads = true;
30 : 0 : return 0;
31 : : }
32 : : early_param("threadirqs", setup_forced_irqthreads);
33 : : #endif
34 : :
35 : : /**
36 : : * synchronize_irq - wait for pending IRQ handlers (on other CPUs)
37 : : * @irq: interrupt number to wait for
38 : : *
39 : : * This function waits for any pending IRQ handlers for this interrupt
40 : : * to complete before returning. If you use this function while
41 : : * holding a resource the IRQ handler may need you will deadlock.
42 : : *
43 : : * This function may be called - with care - from IRQ context.
44 : : */
45 : 0 : void synchronize_irq(unsigned int irq)
46 : : {
47 : 0 : struct irq_desc *desc = irq_to_desc(irq);
48 : : bool inprogress;
49 : :
50 [ # # ]: 0 : if (!desc)
51 : 0 : return;
52 : :
53 : : do {
54 : : unsigned long flags;
55 : :
56 : : /*
57 : : * Wait until we're out of the critical section. This might
58 : : * give the wrong answer due to the lack of memory barriers.
59 : : */
60 [ # # ]: 0 : while (irqd_irq_inprogress(&desc->irq_data))
61 : 0 : cpu_relax();
62 : :
63 : : /* Ok, that indicated we're done: double-check carefully. */
64 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
65 : : inprogress = irqd_irq_inprogress(&desc->irq_data);
66 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
67 : :
68 : : /* Oops, that failed? */
69 [ # # ]: 0 : } while (inprogress);
70 : :
71 : : /*
72 : : * We made sure that no hardirq handler is running. Now verify
73 : : * that no threaded handlers are active.
74 : : */
75 [ # # ][ # # ]: 0 : wait_event(desc->wait_for_threads, !atomic_read(&desc->threads_active));
76 : : }
77 : : EXPORT_SYMBOL(synchronize_irq);
78 : :
79 : : #ifdef CONFIG_SMP
80 : : cpumask_var_t irq_default_affinity;
81 : :
82 : : /**
83 : : * irq_can_set_affinity - Check if the affinity of a given irq can be set
84 : : * @irq: Interrupt to check
85 : : *
86 : : */
87 : 0 : int irq_can_set_affinity(unsigned int irq)
88 : : {
89 : 0 : struct irq_desc *desc = irq_to_desc(irq);
90 : :
91 [ # # ][ # # ]: 0 : if (!desc || !irqd_can_balance(&desc->irq_data) ||
[ # # ]
92 [ # # ]: 0 : !desc->irq_data.chip || !desc->irq_data.chip->irq_set_affinity)
93 : : return 0;
94 : :
95 : 0 : return 1;
96 : : }
97 : :
98 : : /**
99 : : * irq_set_thread_affinity - Notify irq threads to adjust affinity
100 : : * @desc: irq descriptor which has affitnity changed
101 : : *
102 : : * We just set IRQTF_AFFINITY and delegate the affinity setting
103 : : * to the interrupt thread itself. We can not call
104 : : * set_cpus_allowed_ptr() here as we hold desc->lock and this
105 : : * code can be called from hard interrupt context.
106 : : */
107 : 0 : void irq_set_thread_affinity(struct irq_desc *desc)
108 : : {
109 : 402497 : struct irqaction *action = desc->action;
110 : :
111 [ + + ]: 804994 : while (action) {
112 [ - + ]: 402497 : if (action->thread)
113 : 0 : set_bit(IRQTF_AFFINITY, &action->thread_flags);
114 : 402497 : action = action->next;
115 : : }
116 : 402497 : }
117 : :
118 : : #ifdef CONFIG_GENERIC_PENDING_IRQ
119 : : static inline bool irq_can_move_pcntxt(struct irq_data *data)
120 : : {
121 : : return irqd_can_move_in_process_context(data);
122 : : }
123 : : static inline bool irq_move_pending(struct irq_data *data)
124 : : {
125 : : return irqd_is_setaffinity_pending(data);
126 : : }
127 : : static inline void
128 : : irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask)
129 : : {
130 : : cpumask_copy(desc->pending_mask, mask);
131 : : }
132 : : static inline void
133 : : irq_get_pending(struct cpumask *mask, struct irq_desc *desc)
134 : : {
135 : : cpumask_copy(mask, desc->pending_mask);
136 : : }
137 : : #else
138 : : static inline bool irq_can_move_pcntxt(struct irq_data *data) { return true; }
139 : : static inline bool irq_move_pending(struct irq_data *data) { return false; }
140 : : static inline void
141 : : irq_copy_pending(struct irq_desc *desc, const struct cpumask *mask) { }
142 : : static inline void
143 : : irq_get_pending(struct cpumask *mask, struct irq_desc *desc) { }
144 : : #endif
145 : :
146 : 0 : int irq_do_set_affinity(struct irq_data *data, const struct cpumask *mask,
147 : : bool force)
148 : : {
149 : : struct irq_desc *desc = irq_data_to_desc(data);
150 : : struct irq_chip *chip = irq_data_get_irq_chip(data);
151 : : int ret;
152 : :
153 : 402497 : ret = chip->irq_set_affinity(data, mask, false);
154 [ + - - ]: 402497 : switch (ret) {
155 : : case IRQ_SET_MASK_OK:
156 : : cpumask_copy(data->affinity, mask);
157 : : case IRQ_SET_MASK_OK_NOCOPY:
158 : 402497 : irq_set_thread_affinity(desc);
159 : : ret = 0;
160 : : }
161 : :
162 : 0 : return ret;
163 : : }
164 : :
165 : 0 : int __irq_set_affinity_locked(struct irq_data *data, const struct cpumask *mask)
166 : : {
167 : : struct irq_chip *chip = irq_data_get_irq_chip(data);
168 : : struct irq_desc *desc = irq_data_to_desc(data);
169 : : int ret = 0;
170 : :
171 [ + - ][ + - ]: 402497 : if (!chip || !chip->irq_set_affinity)
172 : : return -EINVAL;
173 : :
174 : : if (irq_can_move_pcntxt(data)) {
175 : 402497 : ret = irq_do_set_affinity(data, mask, false);
176 : : } else {
177 : : irqd_set_move_pending(data);
178 : : irq_copy_pending(desc, mask);
179 : : }
180 : :
181 [ - + ]: 402497 : if (desc->affinity_notify) {
182 : : kref_get(&desc->affinity_notify->kref);
183 : 0 : schedule_work(&desc->affinity_notify->work);
184 : : }
185 : : irqd_set(data, IRQD_AFFINITY_SET);
186 : :
187 : 402497 : return ret;
188 : : }
189 : :
190 : : /**
191 : : * irq_set_affinity - Set the irq affinity of a given irq
192 : : * @irq: Interrupt to set affinity
193 : : * @mask: cpumask
194 : : *
195 : : */
196 : 0 : int irq_set_affinity(unsigned int irq, const struct cpumask *mask)
197 : : {
198 : 402497 : struct irq_desc *desc = irq_to_desc(irq);
199 : : unsigned long flags;
200 : : int ret;
201 : :
202 [ + - ]: 402497 : if (!desc)
203 : : return -EINVAL;
204 : :
205 : 402497 : raw_spin_lock_irqsave(&desc->lock, flags);
206 : 402497 : ret = __irq_set_affinity_locked(irq_desc_get_irq_data(desc), mask);
207 : 402497 : raw_spin_unlock_irqrestore(&desc->lock, flags);
208 : 402497 : return ret;
209 : : }
210 : :
211 : 0 : int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
212 : : {
213 : : unsigned long flags;
214 : : struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
215 : :
216 [ # # ]: 0 : if (!desc)
217 : : return -EINVAL;
218 : 0 : desc->affinity_hint = m;
219 : 0 : irq_put_desc_unlock(desc, flags);
220 : 0 : return 0;
221 : : }
222 : : EXPORT_SYMBOL_GPL(irq_set_affinity_hint);
223 : :
224 : 0 : static void irq_affinity_notify(struct work_struct *work)
225 : : {
226 : 0 : struct irq_affinity_notify *notify =
227 : : container_of(work, struct irq_affinity_notify, work);
228 : 0 : struct irq_desc *desc = irq_to_desc(notify->irq);
229 : : cpumask_var_t cpumask;
230 : : unsigned long flags;
231 : :
232 [ # # ]: 0 : if (!desc || !alloc_cpumask_var(&cpumask, GFP_KERNEL))
233 : : goto out;
234 : :
235 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
236 : : if (irq_move_pending(&desc->irq_data))
237 : : irq_get_pending(cpumask, desc);
238 : : else
239 : : cpumask_copy(cpumask, desc->irq_data.affinity);
240 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
241 : :
242 : 0 : notify->notify(notify, cpumask);
243 : :
244 : : free_cpumask_var(cpumask);
245 : : out:
246 : 0 : kref_put(¬ify->kref, notify->release);
247 : 0 : }
248 : :
249 : : /**
250 : : * irq_set_affinity_notifier - control notification of IRQ affinity changes
251 : : * @irq: Interrupt for which to enable/disable notification
252 : : * @notify: Context for notification, or %NULL to disable
253 : : * notification. Function pointers must be initialised;
254 : : * the other fields will be initialised by this function.
255 : : *
256 : : * Must be called in process context. Notification may only be enabled
257 : : * after the IRQ is allocated and must be disabled before the IRQ is
258 : : * freed using free_irq().
259 : : */
260 : : int
261 : 0 : irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify)
262 : : {
263 : 0 : struct irq_desc *desc = irq_to_desc(irq);
264 : : struct irq_affinity_notify *old_notify;
265 : : unsigned long flags;
266 : :
267 : : /* The release function is promised process context */
268 : : might_sleep();
269 : :
270 [ # # ]: 0 : if (!desc)
271 : : return -EINVAL;
272 : :
273 : : /* Complete initialisation of *notify */
274 [ # # ]: 0 : if (notify) {
275 : 0 : notify->irq = irq;
276 : : kref_init(¬ify->kref);
277 : 0 : INIT_WORK(¬ify->work, irq_affinity_notify);
278 : : }
279 : :
280 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
281 : 0 : old_notify = desc->affinity_notify;
282 : 0 : desc->affinity_notify = notify;
283 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
284 : :
285 [ # # ]: 0 : if (old_notify)
286 : 0 : kref_put(&old_notify->kref, old_notify->release);
287 : :
288 : : return 0;
289 : : }
290 : : EXPORT_SYMBOL_GPL(irq_set_affinity_notifier);
291 : :
292 : : #ifndef CONFIG_AUTO_IRQ_AFFINITY
293 : : /*
294 : : * Generic version of the affinity autoselector.
295 : : */
296 : : static int
297 : 0 : setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask)
298 : : {
299 : : struct cpumask *set = irq_default_affinity;
300 : 0 : int node = desc->irq_data.node;
301 : :
302 : : /* Excludes PER_CPU and NO_BALANCE interrupts */
303 [ # # ]: 0 : if (!irq_can_set_affinity(irq))
304 : : return 0;
305 : :
306 : : /*
307 : : * Preserve an userspace affinity setup, but make sure that
308 : : * one of the targets is online.
309 : : */
310 [ # # ]: 0 : if (irqd_has_set(&desc->irq_data, IRQD_AFFINITY_SET)) {
311 [ # # ]: 0 : if (cpumask_intersects(desc->irq_data.affinity,
312 : : cpu_online_mask))
313 : 0 : set = desc->irq_data.affinity;
314 : : else
315 : : irqd_clear(&desc->irq_data, IRQD_AFFINITY_SET);
316 : : }
317 : :
318 : 0 : cpumask_and(mask, cpu_online_mask, set);
319 [ # # ]: 0 : if (node != NUMA_NO_NODE) {
320 : : const struct cpumask *nodemask = cpumask_of_node(node);
321 : :
322 : : /* make sure at least one of the cpus in nodemask is online */
323 [ # # ]: 0 : if (cpumask_intersects(mask, nodemask))
324 : : cpumask_and(mask, mask, nodemask);
325 : : }
326 : 0 : irq_do_set_affinity(&desc->irq_data, mask, false);
327 : 0 : return 0;
328 : : }
329 : : #else
330 : : static inline int
331 : : setup_affinity(unsigned int irq, struct irq_desc *d, struct cpumask *mask)
332 : : {
333 : : return irq_select_affinity(irq);
334 : : }
335 : : #endif
336 : :
337 : : /*
338 : : * Called when affinity is set via /proc/irq
339 : : */
340 : 0 : int irq_select_affinity_usr(unsigned int irq, struct cpumask *mask)
341 : : {
342 : 0 : struct irq_desc *desc = irq_to_desc(irq);
343 : : unsigned long flags;
344 : : int ret;
345 : :
346 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
347 : 0 : ret = setup_affinity(irq, desc, mask);
348 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
349 : 0 : return ret;
350 : : }
351 : :
352 : : #else
353 : : static inline int
354 : : setup_affinity(unsigned int irq, struct irq_desc *desc, struct cpumask *mask)
355 : : {
356 : : return 0;
357 : : }
358 : : #endif
359 : :
360 : 0 : void __disable_irq(struct irq_desc *desc, unsigned int irq, bool suspend)
361 : : {
362 [ # # ]: 0 : if (suspend) {
363 [ # # ][ # # ]: 0 : if (!desc->action || (desc->action->flags & IRQF_NO_SUSPEND))
364 : 0 : return;
365 : 0 : desc->istate |= IRQS_SUSPENDED;
366 : : }
367 : :
368 [ # # ]: 0 : if (!desc->depth++)
369 : 0 : irq_disable(desc);
370 : : }
371 : :
372 : 0 : static int __disable_irq_nosync(unsigned int irq)
373 : : {
374 : : unsigned long flags;
375 : : struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
376 : :
377 [ # # ]: 0 : if (!desc)
378 : : return -EINVAL;
379 : 0 : __disable_irq(desc, irq, false);
380 : 0 : irq_put_desc_busunlock(desc, flags);
381 : 0 : return 0;
382 : : }
383 : :
384 : : /**
385 : : * disable_irq_nosync - disable an irq without waiting
386 : : * @irq: Interrupt to disable
387 : : *
388 : : * Disable the selected interrupt line. Disables and Enables are
389 : : * nested.
390 : : * Unlike disable_irq(), this function does not ensure existing
391 : : * instances of the IRQ handler have completed before returning.
392 : : *
393 : : * This function may be called from IRQ context.
394 : : */
395 : 0 : void disable_irq_nosync(unsigned int irq)
396 : : {
397 : 0 : __disable_irq_nosync(irq);
398 : 0 : }
399 : : EXPORT_SYMBOL(disable_irq_nosync);
400 : :
401 : : /**
402 : : * disable_irq - disable an irq and wait for completion
403 : : * @irq: Interrupt to disable
404 : : *
405 : : * Disable the selected interrupt line. Enables and Disables are
406 : : * nested.
407 : : * This function waits for any pending IRQ handlers for this interrupt
408 : : * to complete before returning. If you use this function while
409 : : * holding a resource the IRQ handler may need you will deadlock.
410 : : *
411 : : * This function may be called - with care - from IRQ context.
412 : : */
413 : 0 : void disable_irq(unsigned int irq)
414 : : {
415 [ # # ]: 0 : if (!__disable_irq_nosync(irq))
416 : 0 : synchronize_irq(irq);
417 : 0 : }
418 : : EXPORT_SYMBOL(disable_irq);
419 : :
420 : 0 : void __enable_irq(struct irq_desc *desc, unsigned int irq, bool resume)
421 : : {
422 [ # # ]: 0 : if (resume) {
423 [ # # ]: 0 : if (!(desc->istate & IRQS_SUSPENDED)) {
424 [ # # ]: 0 : if (!desc->action)
425 : : return;
426 [ # # ]: 0 : if (!(desc->action->flags & IRQF_FORCE_RESUME))
427 : : return;
428 : : /* Pretend that it got disabled ! */
429 : 0 : desc->depth++;
430 : : }
431 : 0 : desc->istate &= ~IRQS_SUSPENDED;
432 : : }
433 : :
434 [ # # # ]: 0 : switch (desc->depth) {
435 : : case 0:
436 : : err_out:
437 : 0 : WARN(1, KERN_WARNING "Unbalanced enable for IRQ %d\n", irq);
438 : 0 : break;
439 : : case 1: {
440 [ # # ]: 0 : if (desc->istate & IRQS_SUSPENDED)
441 : : goto err_out;
442 : : /* Prevent probing on this irq: */
443 : : irq_settings_set_noprobe(desc);
444 : 0 : irq_enable(desc);
445 : 0 : check_irq_resend(desc, irq);
446 : : /* fall-through */
447 : : }
448 : : default:
449 : 0 : desc->depth--;
450 : : }
451 : : }
452 : :
453 : : /**
454 : : * enable_irq - enable handling of an irq
455 : : * @irq: Interrupt to enable
456 : : *
457 : : * Undoes the effect of one call to disable_irq(). If this
458 : : * matches the last disable, processing of interrupts on this
459 : : * IRQ line is re-enabled.
460 : : *
461 : : * This function may be called from IRQ context only when
462 : : * desc->irq_data.chip->bus_lock and desc->chip->bus_sync_unlock are NULL !
463 : : */
464 : 0 : void enable_irq(unsigned int irq)
465 : : {
466 : : unsigned long flags;
467 : : struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
468 : :
469 [ # # ]: 0 : if (!desc)
470 : 0 : return;
471 [ # # ][ # # ]: 0 : if (WARN(!desc->irq_data.chip,
472 : : KERN_ERR "enable_irq before setup/request_irq: irq %u\n", irq))
473 : : goto out;
474 : :
475 : 0 : __enable_irq(desc, irq, false);
476 : : out:
477 : 0 : irq_put_desc_busunlock(desc, flags);
478 : : }
479 : : EXPORT_SYMBOL(enable_irq);
480 : :
481 : 0 : static int set_irq_wake_real(unsigned int irq, unsigned int on)
482 : : {
483 : 0 : struct irq_desc *desc = irq_to_desc(irq);
484 : : int ret = -ENXIO;
485 : :
486 [ # # ]: 0 : if (irq_desc_get_chip(desc)->flags & IRQCHIP_SKIP_SET_WAKE)
487 : : return 0;
488 : :
489 [ # # ]: 0 : if (desc->irq_data.chip->irq_set_wake)
490 : 0 : ret = desc->irq_data.chip->irq_set_wake(&desc->irq_data, on);
491 : :
492 : 0 : return ret;
493 : : }
494 : :
495 : : /**
496 : : * irq_set_irq_wake - control irq power management wakeup
497 : : * @irq: interrupt to control
498 : : * @on: enable/disable power management wakeup
499 : : *
500 : : * Enable/disable power management wakeup mode, which is
501 : : * disabled by default. Enables and disables must match,
502 : : * just as they match for non-wakeup mode support.
503 : : *
504 : : * Wakeup mode lets this IRQ wake the system from sleep
505 : : * states like "suspend to RAM".
506 : : */
507 : 0 : int irq_set_irq_wake(unsigned int irq, unsigned int on)
508 : : {
509 : : unsigned long flags;
510 : : struct irq_desc *desc = irq_get_desc_buslock(irq, &flags, IRQ_GET_DESC_CHECK_GLOBAL);
511 : : int ret = 0;
512 : :
513 [ # # ]: 0 : if (!desc)
514 : : return -EINVAL;
515 : :
516 : : /* wakeup-capable irqs can be shared between drivers that
517 : : * don't need to have the same sleep mode behaviors.
518 : : */
519 [ # # ]: 0 : if (on) {
520 [ # # ]: 0 : if (desc->wake_depth++ == 0) {
521 : 0 : ret = set_irq_wake_real(irq, on);
522 [ # # ]: 0 : if (ret)
523 : 0 : desc->wake_depth = 0;
524 : : else
525 : : irqd_set(&desc->irq_data, IRQD_WAKEUP_STATE);
526 : : }
527 : : } else {
528 [ # # ]: 0 : if (desc->wake_depth == 0) {
529 : 0 : WARN(1, "Unbalanced IRQ %d wake disable\n", irq);
530 [ # # ]: 0 : } else if (--desc->wake_depth == 0) {
531 : 0 : ret = set_irq_wake_real(irq, on);
532 [ # # ]: 0 : if (ret)
533 : 0 : desc->wake_depth = 1;
534 : : else
535 : : irqd_clear(&desc->irq_data, IRQD_WAKEUP_STATE);
536 : : }
537 : : }
538 : 0 : irq_put_desc_busunlock(desc, flags);
539 : 0 : return ret;
540 : : }
541 : : EXPORT_SYMBOL(irq_set_irq_wake);
542 : :
543 : : /*
544 : : * Internal function that tells the architecture code whether a
545 : : * particular irq has been exclusively allocated or is available
546 : : * for driver use.
547 : : */
548 : 0 : int can_request_irq(unsigned int irq, unsigned long irqflags)
549 : : {
550 : : unsigned long flags;
551 : 0 : struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
552 : : int canrequest = 0;
553 : :
554 [ # # ]: 0 : if (!desc)
555 : : return 0;
556 : :
557 [ # # ]: 0 : if (irq_settings_can_request(desc)) {
558 [ # # ][ # # ]: 0 : if (!desc->action ||
559 : 0 : irqflags & desc->action->flags & IRQF_SHARED)
560 : : canrequest = 1;
561 : : }
562 : 0 : irq_put_desc_unlock(desc, flags);
563 : 0 : return canrequest;
564 : : }
565 : :
566 : 0 : int __irq_set_trigger(struct irq_desc *desc, unsigned int irq,
567 : : unsigned long flags)
568 : : {
569 : 0 : struct irq_chip *chip = desc->irq_data.chip;
570 : : int ret, unmask = 0;
571 : :
572 [ # # ][ # # ]: 0 : if (!chip || !chip->irq_set_type) {
573 : : /*
574 : : * IRQF_TRIGGER_* but the PIC does not support multiple
575 : : * flow-types?
576 : : */
577 : : pr_debug("No set_type function for IRQ %d (%s)\n", irq,
578 : : chip ? (chip->name ? : "unknown") : "unknown");
579 : : return 0;
580 : : }
581 : :
582 : 0 : flags &= IRQ_TYPE_SENSE_MASK;
583 : :
584 [ # # ]: 0 : if (chip->flags & IRQCHIP_SET_TYPE_MASKED) {
585 [ # # ]: 0 : if (!irqd_irq_masked(&desc->irq_data))
586 : 0 : mask_irq(desc);
587 [ # # ]: 0 : if (!irqd_irq_disabled(&desc->irq_data))
588 : : unmask = 1;
589 : : }
590 : :
591 : : /* caller masked out all except trigger mode flags */
592 : 0 : ret = chip->irq_set_type(&desc->irq_data, flags);
593 : :
594 [ # # # ]: 0 : switch (ret) {
595 : : case IRQ_SET_MASK_OK:
596 : : irqd_clear(&desc->irq_data, IRQD_TRIGGER_MASK);
597 : : irqd_set(&desc->irq_data, flags);
598 : :
599 : : case IRQ_SET_MASK_OK_NOCOPY:
600 : : flags = irqd_get_trigger_type(&desc->irq_data);
601 : : irq_settings_set_trigger_mask(desc, flags);
602 : : irqd_clear(&desc->irq_data, IRQD_LEVEL);
603 : : irq_settings_clr_level(desc);
604 [ # # ]: 0 : if (flags & IRQ_TYPE_LEVEL_MASK) {
605 : : irq_settings_set_level(desc);
606 : : irqd_set(&desc->irq_data, IRQD_LEVEL);
607 : : }
608 : :
609 : : ret = 0;
610 : : break;
611 : : default:
612 : 0 : pr_err("Setting trigger mode %lu for irq %u failed (%pF)\n",
613 : : flags, irq, chip->irq_set_type);
614 : : }
615 [ # # ]: 0 : if (unmask)
616 : 0 : unmask_irq(desc);
617 : 0 : return ret;
618 : : }
619 : :
620 : : #ifdef CONFIG_HARDIRQS_SW_RESEND
621 : 0 : int irq_set_parent(int irq, int parent_irq)
622 : : {
623 : : unsigned long flags;
624 : 0 : struct irq_desc *desc = irq_get_desc_lock(irq, &flags, 0);
625 : :
626 [ # # ]: 0 : if (!desc)
627 : : return -EINVAL;
628 : :
629 : 0 : desc->parent_irq = parent_irq;
630 : :
631 : 0 : irq_put_desc_unlock(desc, flags);
632 : 0 : return 0;
633 : : }
634 : : #endif
635 : :
636 : : /*
637 : : * Default primary interrupt handler for threaded interrupts. Is
638 : : * assigned as primary handler when request_threaded_irq is called
639 : : * with handler == NULL. Useful for oneshot interrupts.
640 : : */
641 : 0 : static irqreturn_t irq_default_primary_handler(int irq, void *dev_id)
642 : : {
643 : 0 : return IRQ_WAKE_THREAD;
644 : : }
645 : :
646 : : /*
647 : : * Primary handler for nested threaded interrupts. Should never be
648 : : * called.
649 : : */
650 : 0 : static irqreturn_t irq_nested_primary_handler(int irq, void *dev_id)
651 : : {
652 : 0 : WARN(1, "Primary handler called for nested irq %d\n", irq);
653 : 0 : return IRQ_NONE;
654 : : }
655 : :
656 : 0 : static int irq_wait_for_interrupt(struct irqaction *action)
657 : : {
658 : 0 : set_current_state(TASK_INTERRUPTIBLE);
659 : :
660 [ # # ]: 0 : while (!kthread_should_stop()) {
661 : :
662 [ # # ]: 0 : if (test_and_clear_bit(IRQTF_RUNTHREAD,
663 : : &action->thread_flags)) {
664 : 0 : __set_current_state(TASK_RUNNING);
665 : 0 : return 0;
666 : : }
667 : 0 : schedule();
668 : 0 : set_current_state(TASK_INTERRUPTIBLE);
669 : : }
670 : 0 : __set_current_state(TASK_RUNNING);
671 : 0 : return -1;
672 : : }
673 : :
674 : : /*
675 : : * Oneshot interrupts keep the irq line masked until the threaded
676 : : * handler finished. unmask if the interrupt has not been disabled and
677 : : * is marked MASKED.
678 : : */
679 : 0 : static void irq_finalize_oneshot(struct irq_desc *desc,
680 : : struct irqaction *action)
681 : : {
682 [ # # ]: 0 : if (!(desc->istate & IRQS_ONESHOT))
683 : 0 : return;
684 : : again:
685 : : chip_bus_lock(desc);
686 : 0 : raw_spin_lock_irq(&desc->lock);
687 : :
688 : : /*
689 : : * Implausible though it may be we need to protect us against
690 : : * the following scenario:
691 : : *
692 : : * The thread is faster done than the hard interrupt handler
693 : : * on the other CPU. If we unmask the irq line then the
694 : : * interrupt can come in again and masks the line, leaves due
695 : : * to IRQS_INPROGRESS and the irq line is masked forever.
696 : : *
697 : : * This also serializes the state of shared oneshot handlers
698 : : * versus "desc->threads_onehsot |= action->thread_mask;" in
699 : : * irq_wake_thread(). See the comment there which explains the
700 : : * serialization.
701 : : */
702 [ # # ]: 0 : if (unlikely(irqd_irq_inprogress(&desc->irq_data))) {
703 : : raw_spin_unlock_irq(&desc->lock);
704 : : chip_bus_sync_unlock(desc);
705 : 0 : cpu_relax();
706 : 0 : goto again;
707 : : }
708 : :
709 : : /*
710 : : * Now check again, whether the thread should run. Otherwise
711 : : * we would clear the threads_oneshot bit of this thread which
712 : : * was just set.
713 : : */
714 [ # # ]: 0 : if (test_bit(IRQTF_RUNTHREAD, &action->thread_flags))
715 : : goto out_unlock;
716 : :
717 : 0 : desc->threads_oneshot &= ~action->thread_mask;
718 : :
719 [ # # ][ # # ]: 0 : if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
[ # # ]
720 : : irqd_irq_masked(&desc->irq_data))
721 : 0 : unmask_irq(desc);
722 : :
723 : : out_unlock:
724 : : raw_spin_unlock_irq(&desc->lock);
725 : : chip_bus_sync_unlock(desc);
726 : : }
727 : :
728 : : #ifdef CONFIG_SMP
729 : : /*
730 : : * Check whether we need to chasnge the affinity of the interrupt thread.
731 : : */
732 : : static void
733 : 0 : irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action)
734 : : {
735 : : cpumask_var_t mask;
736 : : bool valid = true;
737 : :
738 [ # # ]: 0 : if (!test_and_clear_bit(IRQTF_AFFINITY, &action->thread_flags))
739 : 0 : return;
740 : :
741 : : /*
742 : : * In case we are out of memory we set IRQTF_AFFINITY again and
743 : : * try again next time
744 : : */
745 : : if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
746 : : set_bit(IRQTF_AFFINITY, &action->thread_flags);
747 : : return;
748 : : }
749 : :
750 : 0 : raw_spin_lock_irq(&desc->lock);
751 : : /*
752 : : * This code is triggered unconditionally. Check the affinity
753 : : * mask pointer. For CPU_MASK_OFFSTACK=n this is optimized out.
754 : : */
755 [ # # ]: 0 : if (desc->irq_data.affinity)
756 : : cpumask_copy(mask, desc->irq_data.affinity);
757 : : else
758 : : valid = false;
759 : : raw_spin_unlock_irq(&desc->lock);
760 : :
761 [ # # ]: 0 : if (valid)
762 : 0 : set_cpus_allowed_ptr(current, mask);
763 : : free_cpumask_var(mask);
764 : : }
765 : : #else
766 : : static inline void
767 : : irq_thread_check_affinity(struct irq_desc *desc, struct irqaction *action) { }
768 : : #endif
769 : :
770 : : /*
771 : : * Interrupts which are not explicitely requested as threaded
772 : : * interrupts rely on the implicit bh/preempt disable of the hard irq
773 : : * context. So we need to disable bh here to avoid deadlocks and other
774 : : * side effects.
775 : : */
776 : : static irqreturn_t
777 : 0 : irq_forced_thread_fn(struct irq_desc *desc, struct irqaction *action)
778 : : {
779 : : irqreturn_t ret;
780 : :
781 : 0 : local_bh_disable();
782 : 0 : ret = action->thread_fn(action->irq, action->dev_id);
783 : 0 : irq_finalize_oneshot(desc, action);
784 : 0 : local_bh_enable();
785 : 0 : return ret;
786 : : }
787 : :
788 : : /*
789 : : * Interrupts explicitly requested as threaded interrupts want to be
790 : : * preemtible - many of them need to sleep and wait for slow busses to
791 : : * complete.
792 : : */
793 : 0 : static irqreturn_t irq_thread_fn(struct irq_desc *desc,
794 : : struct irqaction *action)
795 : : {
796 : : irqreturn_t ret;
797 : :
798 : 0 : ret = action->thread_fn(action->irq, action->dev_id);
799 : 0 : irq_finalize_oneshot(desc, action);
800 : 0 : return ret;
801 : : }
802 : :
803 : 0 : static void wake_threads_waitq(struct irq_desc *desc)
804 : : {
805 [ # # ][ # # ]: 0 : if (atomic_dec_and_test(&desc->threads_active) &&
806 : : waitqueue_active(&desc->wait_for_threads))
807 : 0 : wake_up(&desc->wait_for_threads);
808 : 0 : }
809 : :
810 : 0 : static void irq_thread_dtor(struct callback_head *unused)
811 : : {
812 : 0 : struct task_struct *tsk = current;
813 : : struct irq_desc *desc;
814 : : struct irqaction *action;
815 : :
816 [ # # ][ # # ]: 0 : if (WARN_ON_ONCE(!(current->flags & PF_EXITING)))
[ # # ][ # # ]
817 : 0 : return;
818 : :
819 : 0 : action = kthread_data(tsk);
820 : :
821 : 0 : pr_err("exiting task \"%s\" (%d) is an active IRQ thread (irq %d)\n",
822 : : tsk->comm, tsk->pid, action->irq);
823 : :
824 : :
825 : 0 : desc = irq_to_desc(action->irq);
826 : : /*
827 : : * If IRQTF_RUNTHREAD is set, we need to decrement
828 : : * desc->threads_active and wake possible waiters.
829 : : */
830 [ # # ]: 0 : if (test_and_clear_bit(IRQTF_RUNTHREAD, &action->thread_flags))
831 : 0 : wake_threads_waitq(desc);
832 : :
833 : : /* Prevent a stale desc->threads_oneshot */
834 : 0 : irq_finalize_oneshot(desc, action);
835 : : }
836 : :
837 : : /*
838 : : * Interrupt handler thread
839 : : */
840 : 0 : static int irq_thread(void *data)
841 : : {
842 : : struct callback_head on_exit_work;
843 : : struct irqaction *action = data;
844 : 0 : struct irq_desc *desc = irq_to_desc(action->irq);
845 : : irqreturn_t (*handler_fn)(struct irq_desc *desc,
846 : : struct irqaction *action);
847 : :
848 [ # # ][ # # ]: 0 : if (force_irqthreads && test_bit(IRQTF_FORCED_THREAD,
849 : : &action->thread_flags))
850 : : handler_fn = irq_forced_thread_fn;
851 : : else
852 : : handler_fn = irq_thread_fn;
853 : :
854 : : init_task_work(&on_exit_work, irq_thread_dtor);
855 : 0 : task_work_add(current, &on_exit_work, false);
856 : :
857 : 0 : irq_thread_check_affinity(desc, action);
858 : :
859 [ # # ]: 0 : while (!irq_wait_for_interrupt(action)) {
860 : : irqreturn_t action_ret;
861 : :
862 : 0 : irq_thread_check_affinity(desc, action);
863 : :
864 : 0 : action_ret = handler_fn(desc, action);
865 [ # # ]: 0 : if (!noirqdebug)
866 : 0 : note_interrupt(action->irq, desc, action_ret);
867 : :
868 : 0 : wake_threads_waitq(desc);
869 : : }
870 : :
871 : : /*
872 : : * This is the regular exit path. __free_irq() is stopping the
873 : : * thread via kthread_stop() after calling
874 : : * synchronize_irq(). So neither IRQTF_RUNTHREAD nor the
875 : : * oneshot mask bit can be set. We cannot verify that as we
876 : : * cannot touch the oneshot mask at this point anymore as
877 : : * __setup_irq() might have given out currents thread_mask
878 : : * again.
879 : : */
880 : 0 : task_work_cancel(current, irq_thread_dtor);
881 : 0 : return 0;
882 : : }
883 : :
884 : 0 : static void irq_setup_forced_threading(struct irqaction *new)
885 : : {
886 [ # # ]: 0 : if (!force_irqthreads)
887 : : return;
888 [ # # ]: 0 : if (new->flags & (IRQF_NO_THREAD | IRQF_PERCPU | IRQF_ONESHOT))
889 : : return;
890 : :
891 : 0 : new->flags |= IRQF_ONESHOT;
892 : :
893 [ # # ]: 0 : if (!new->thread_fn) {
894 : 0 : set_bit(IRQTF_FORCED_THREAD, &new->thread_flags);
895 : 0 : new->thread_fn = new->handler;
896 : 0 : new->handler = irq_default_primary_handler;
897 : : }
898 : : }
899 : :
900 : : /*
901 : : * Internal function to register an irqaction - typically used to
902 : : * allocate special interrupts that are part of the architecture.
903 : : */
904 : : static int
905 : 0 : __setup_irq(unsigned int irq, struct irq_desc *desc, struct irqaction *new)
906 : : {
907 : : struct irqaction *old, **old_ptr;
908 : : unsigned long flags, thread_mask = 0;
909 : : int ret, nested, shared = 0;
910 : : cpumask_var_t mask;
911 : :
912 [ # # ]: 0 : if (!desc)
913 : : return -EINVAL;
914 : :
915 [ # # ]: 0 : if (desc->irq_data.chip == &no_irq_chip)
916 : : return -ENOSYS;
917 [ # # ]: 0 : if (!try_module_get(desc->owner))
918 : : return -ENODEV;
919 : :
920 : : /*
921 : : * Check whether the interrupt nests into another interrupt
922 : : * thread.
923 : : */
924 : 0 : nested = irq_settings_is_nested_thread(desc);
925 [ # # ]: 0 : if (nested) {
926 [ # # ]: 0 : if (!new->thread_fn) {
927 : : ret = -EINVAL;
928 : : goto out_mput;
929 : : }
930 : : /*
931 : : * Replace the primary handler which was provided from
932 : : * the driver for non nested interrupt handling by the
933 : : * dummy function which warns when called.
934 : : */
935 : 0 : new->handler = irq_nested_primary_handler;
936 : : } else {
937 [ # # ]: 0 : if (irq_settings_can_thread(desc))
938 : 0 : irq_setup_forced_threading(new);
939 : : }
940 : :
941 : : /*
942 : : * Create a handler thread when a thread function is supplied
943 : : * and the interrupt does not nest into another interrupt
944 : : * thread.
945 : : */
946 [ # # ][ # # ]: 0 : if (new->thread_fn && !nested) {
947 : : struct task_struct *t;
948 : : static const struct sched_param param = {
949 : : .sched_priority = MAX_USER_RT_PRIO/2,
950 : : };
951 : :
952 : 0 : t = kthread_create(irq_thread, new, "irq/%d-%s", irq,
953 : : new->name);
954 [ # # ]: 0 : if (IS_ERR(t)) {
955 : : ret = PTR_ERR(t);
956 : 0 : goto out_mput;
957 : : }
958 : :
959 : 0 : sched_setscheduler_nocheck(t, SCHED_FIFO, ¶m);
960 : :
961 : : /*
962 : : * We keep the reference to the task struct even if
963 : : * the thread dies to avoid that the interrupt code
964 : : * references an already freed task_struct.
965 : : */
966 : 0 : get_task_struct(t);
967 : 0 : new->thread = t;
968 : : /*
969 : : * Tell the thread to set its affinity. This is
970 : : * important for shared interrupt handlers as we do
971 : : * not invoke setup_affinity() for the secondary
972 : : * handlers as everything is already set up. Even for
973 : : * interrupts marked with IRQF_NO_BALANCE this is
974 : : * correct as we want the thread to move to the cpu(s)
975 : : * on which the requesting code placed the interrupt.
976 : : */
977 : 0 : set_bit(IRQTF_AFFINITY, &new->thread_flags);
978 : : }
979 : :
980 : : if (!alloc_cpumask_var(&mask, GFP_KERNEL)) {
981 : : ret = -ENOMEM;
982 : : goto out_thread;
983 : : }
984 : :
985 : : /*
986 : : * Drivers are often written to work w/o knowledge about the
987 : : * underlying irq chip implementation, so a request for a
988 : : * threaded irq without a primary hard irq context handler
989 : : * requires the ONESHOT flag to be set. Some irq chips like
990 : : * MSI based interrupts are per se one shot safe. Check the
991 : : * chip flags, so we can avoid the unmask dance at the end of
992 : : * the threaded handler for those.
993 : : */
994 [ # # ]: 0 : if (desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)
995 : 0 : new->flags &= ~IRQF_ONESHOT;
996 : :
997 : : /*
998 : : * The following block of code has to be executed atomically
999 : : */
1000 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
1001 : 0 : old_ptr = &desc->action;
1002 : 0 : old = *old_ptr;
1003 [ # # ]: 0 : if (old) {
1004 : : /*
1005 : : * Can't share interrupts unless both agree to and are
1006 : : * the same type (level, edge, polarity). So both flag
1007 : : * fields must have IRQF_SHARED set and the bits which
1008 : : * set the trigger type must match. Also all must
1009 : : * agree on ONESHOT.
1010 : : */
1011 [ # # ]: 0 : if (!((old->flags & new->flags) & IRQF_SHARED) ||
1012 [ # # ]: 0 : ((old->flags ^ new->flags) & IRQF_TRIGGER_MASK) ||
1013 : : ((old->flags ^ new->flags) & IRQF_ONESHOT))
1014 : : goto mismatch;
1015 : :
1016 : : /* All handlers must agree on per-cpuness */
1017 [ # # ]: 0 : if ((old->flags & IRQF_PERCPU) !=
1018 : : (new->flags & IRQF_PERCPU))
1019 : : goto mismatch;
1020 : :
1021 : : /* add new interrupt at end of irq queue */
1022 : : do {
1023 : : /*
1024 : : * Or all existing action->thread_mask bits,
1025 : : * so we can find the next zero bit for this
1026 : : * new action.
1027 : : */
1028 : 0 : thread_mask |= old->thread_mask;
1029 : 0 : old_ptr = &old->next;
1030 : 0 : old = *old_ptr;
1031 [ # # ]: 0 : } while (old);
1032 : : shared = 1;
1033 : : }
1034 : :
1035 : : /*
1036 : : * Setup the thread mask for this irqaction for ONESHOT. For
1037 : : * !ONESHOT irqs the thread mask is 0 so we can avoid a
1038 : : * conditional in irq_wake_thread().
1039 : : */
1040 [ # # ]: 0 : if (new->flags & IRQF_ONESHOT) {
1041 : : /*
1042 : : * Unlikely to have 32 resp 64 irqs sharing one line,
1043 : : * but who knows.
1044 : : */
1045 [ # # ]: 0 : if (thread_mask == ~0UL) {
1046 : : ret = -EBUSY;
1047 : : goto out_mask;
1048 : : }
1049 : : /*
1050 : : * The thread_mask for the action is or'ed to
1051 : : * desc->thread_active to indicate that the
1052 : : * IRQF_ONESHOT thread handler has been woken, but not
1053 : : * yet finished. The bit is cleared when a thread
1054 : : * completes. When all threads of a shared interrupt
1055 : : * line have completed desc->threads_active becomes
1056 : : * zero and the interrupt line is unmasked. See
1057 : : * handle.c:irq_wake_thread() for further information.
1058 : : *
1059 : : * If no thread is woken by primary (hard irq context)
1060 : : * interrupt handlers, then desc->threads_active is
1061 : : * also checked for zero to unmask the irq line in the
1062 : : * affected hard irq flow handlers
1063 : : * (handle_[fasteoi|level]_irq).
1064 : : *
1065 : : * The new action gets the first zero bit of
1066 : : * thread_mask assigned. See the loop above which or's
1067 : : * all existing action->thread_mask bits.
1068 : : */
1069 : 0 : new->thread_mask = 1 << ffz(thread_mask);
1070 : :
1071 [ # # ][ # # ]: 0 : } else if (new->handler == irq_default_primary_handler &&
1072 : 0 : !(desc->irq_data.chip->flags & IRQCHIP_ONESHOT_SAFE)) {
1073 : : /*
1074 : : * The interrupt was requested with handler = NULL, so
1075 : : * we use the default primary handler for it. But it
1076 : : * does not have the oneshot flag set. In combination
1077 : : * with level interrupts this is deadly, because the
1078 : : * default primary handler just wakes the thread, then
1079 : : * the irq lines is reenabled, but the device still
1080 : : * has the level irq asserted. Rinse and repeat....
1081 : : *
1082 : : * While this works for edge type interrupts, we play
1083 : : * it safe and reject unconditionally because we can't
1084 : : * say for sure which type this interrupt really
1085 : : * has. The type flags are unreliable as the
1086 : : * underlying chip implementation can override them.
1087 : : */
1088 : 0 : pr_err("Threaded irq requested with handler=NULL and !ONESHOT for irq %d\n",
1089 : : irq);
1090 : : ret = -EINVAL;
1091 : 0 : goto out_mask;
1092 : : }
1093 : :
1094 [ # # ]: 0 : if (!shared) {
1095 : 0 : init_waitqueue_head(&desc->wait_for_threads);
1096 : :
1097 : : /* Setup the type (level, edge polarity) if configured: */
1098 [ # # ]: 0 : if (new->flags & IRQF_TRIGGER_MASK) {
1099 : 0 : ret = __irq_set_trigger(desc, irq,
1100 : : new->flags & IRQF_TRIGGER_MASK);
1101 : :
1102 [ # # ]: 0 : if (ret)
1103 : : goto out_mask;
1104 : : }
1105 : :
1106 : 0 : desc->istate &= ~(IRQS_AUTODETECT | IRQS_SPURIOUS_DISABLED | \
1107 : : IRQS_ONESHOT | IRQS_WAITING);
1108 : : irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
1109 : :
1110 [ # # ]: 0 : if (new->flags & IRQF_PERCPU) {
1111 : : irqd_set(&desc->irq_data, IRQD_PER_CPU);
1112 : : irq_settings_set_per_cpu(desc);
1113 : : }
1114 : :
1115 [ # # ]: 0 : if (new->flags & IRQF_ONESHOT)
1116 : 0 : desc->istate |= IRQS_ONESHOT;
1117 : :
1118 [ # # ]: 0 : if (irq_settings_can_autoenable(desc))
1119 : 0 : irq_startup(desc, true);
1120 : : else
1121 : : /* Undo nested disables: */
1122 : 0 : desc->depth = 1;
1123 : :
1124 : : /* Exclude IRQ from balancing if requested */
1125 [ # # ]: 0 : if (new->flags & IRQF_NOBALANCING) {
1126 : : irq_settings_set_no_balancing(desc);
1127 : : irqd_set(&desc->irq_data, IRQD_NO_BALANCING);
1128 : : }
1129 : :
1130 : : /* Set default affinity mask once everything is setup */
1131 : 0 : setup_affinity(irq, desc, mask);
1132 : :
1133 [ # # ]: 0 : } else if (new->flags & IRQF_TRIGGER_MASK) {
1134 : : unsigned int nmsk = new->flags & IRQF_TRIGGER_MASK;
1135 : : unsigned int omsk = irq_settings_get_trigger_mask(desc);
1136 : :
1137 [ # # ]: 0 : if (nmsk != omsk)
1138 : : /* hope the handler works with current trigger mode */
1139 : 0 : pr_warning("irq %d uses trigger mode %u; requested %u\n",
1140 : : irq, nmsk, omsk);
1141 : : }
1142 : :
1143 : 0 : new->irq = irq;
1144 : 0 : *old_ptr = new;
1145 : :
1146 : : /* Reset broken irq detection when installing new handler */
1147 : 0 : desc->irq_count = 0;
1148 : 0 : desc->irqs_unhandled = 0;
1149 : :
1150 : : /*
1151 : : * Check whether we disabled the irq via the spurious handler
1152 : : * before. Reenable it and give it another chance.
1153 : : */
1154 [ # # ][ # # ]: 0 : if (shared && (desc->istate & IRQS_SPURIOUS_DISABLED)) {
1155 : 0 : desc->istate &= ~IRQS_SPURIOUS_DISABLED;
1156 : 0 : __enable_irq(desc, irq, false);
1157 : : }
1158 : :
1159 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
1160 : :
1161 : : /*
1162 : : * Strictly no need to wake it up, but hung_task complains
1163 : : * when no hard interrupt wakes the thread up.
1164 : : */
1165 [ # # ]: 0 : if (new->thread)
1166 : 0 : wake_up_process(new->thread);
1167 : :
1168 : 0 : register_irq_proc(irq, desc);
1169 : 0 : new->dir = NULL;
1170 : 0 : register_handler_proc(irq, new);
1171 : : free_cpumask_var(mask);
1172 : :
1173 : 0 : return 0;
1174 : :
1175 : : mismatch:
1176 [ # # ]: 0 : if (!(new->flags & IRQF_PROBE_SHARED)) {
1177 : 0 : pr_err("Flags mismatch irq %d. %08x (%s) vs. %08x (%s)\n",
1178 : : irq, new->flags, new->name, old->flags, old->name);
1179 : : #ifdef CONFIG_DEBUG_SHIRQ
1180 : : dump_stack();
1181 : : #endif
1182 : : }
1183 : : ret = -EBUSY;
1184 : :
1185 : : out_mask:
1186 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
1187 : : free_cpumask_var(mask);
1188 : :
1189 : : out_thread:
1190 [ # # ]: 0 : if (new->thread) {
1191 : : struct task_struct *t = new->thread;
1192 : :
1193 : 0 : new->thread = NULL;
1194 : 0 : kthread_stop(t);
1195 : : put_task_struct(t);
1196 : : }
1197 : : out_mput:
1198 : 0 : module_put(desc->owner);
1199 : 0 : return ret;
1200 : : }
1201 : :
1202 : : /**
1203 : : * setup_irq - setup an interrupt
1204 : : * @irq: Interrupt line to setup
1205 : : * @act: irqaction for the interrupt
1206 : : *
1207 : : * Used to statically setup interrupts in the early boot process.
1208 : : */
1209 : 0 : int setup_irq(unsigned int irq, struct irqaction *act)
1210 : : {
1211 : : int retval;
1212 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1213 : :
1214 [ # # ][ # # ]: 0 : if (WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1215 : : return -EINVAL;
1216 : : chip_bus_lock(desc);
1217 : 0 : retval = __setup_irq(irq, desc, act);
1218 : : chip_bus_sync_unlock(desc);
1219 : :
1220 : 0 : return retval;
1221 : : }
1222 : : EXPORT_SYMBOL_GPL(setup_irq);
1223 : :
1224 : : /*
1225 : : * Internal function to unregister an irqaction - used to free
1226 : : * regular and special interrupts that are part of the architecture.
1227 : : */
1228 : 0 : static struct irqaction *__free_irq(unsigned int irq, void *dev_id)
1229 : : {
1230 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1231 : : struct irqaction *action, **action_ptr;
1232 : : unsigned long flags;
1233 : :
1234 [ # # ]: 0 : WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
1235 : :
1236 [ # # ]: 0 : if (!desc)
1237 : : return NULL;
1238 : :
1239 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
1240 : :
1241 : : /*
1242 : : * There can be multiple actions per IRQ descriptor, find the right
1243 : : * one based on the dev_id:
1244 : : */
1245 : 0 : action_ptr = &desc->action;
1246 : : for (;;) {
1247 : 0 : action = *action_ptr;
1248 : :
1249 [ # # ]: 0 : if (!action) {
1250 : 0 : WARN(1, "Trying to free already-free IRQ %d\n", irq);
1251 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
1252 : :
1253 : 0 : return NULL;
1254 : : }
1255 : :
1256 [ # # ]: 0 : if (action->dev_id == dev_id)
1257 : : break;
1258 : 0 : action_ptr = &action->next;
1259 : 0 : }
1260 : :
1261 : : /* Found it - now remove it from the list of entries: */
1262 : 0 : *action_ptr = action->next;
1263 : :
1264 : : /* If this was the last handler, shut down the IRQ line: */
1265 [ # # ]: 0 : if (!desc->action)
1266 : 0 : irq_shutdown(desc);
1267 : :
1268 : : #ifdef CONFIG_SMP
1269 : : /* make sure affinity_hint is cleaned up */
1270 [ # # ][ # # ]: 0 : if (WARN_ON_ONCE(desc->affinity_hint))
[ # # ][ # # ]
1271 : 0 : desc->affinity_hint = NULL;
1272 : : #endif
1273 : :
1274 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
1275 : :
1276 : 0 : unregister_handler_proc(irq, action);
1277 : :
1278 : : /* Make sure it's not being used on another CPU: */
1279 : 0 : synchronize_irq(irq);
1280 : :
1281 : : #ifdef CONFIG_DEBUG_SHIRQ
1282 : : /*
1283 : : * It's a shared IRQ -- the driver ought to be prepared for an IRQ
1284 : : * event to happen even now it's being freed, so let's make sure that
1285 : : * is so by doing an extra call to the handler ....
1286 : : *
1287 : : * ( We do this after actually deregistering it, to make sure that a
1288 : : * 'real' IRQ doesn't run in * parallel with our fake. )
1289 : : */
1290 : : if (action->flags & IRQF_SHARED) {
1291 : : local_irq_save(flags);
1292 : : action->handler(irq, dev_id);
1293 : : local_irq_restore(flags);
1294 : : }
1295 : : #endif
1296 : :
1297 [ # # ]: 0 : if (action->thread) {
1298 : 0 : kthread_stop(action->thread);
1299 : 0 : put_task_struct(action->thread);
1300 : : }
1301 : :
1302 : 0 : module_put(desc->owner);
1303 : 0 : return action;
1304 : : }
1305 : :
1306 : : /**
1307 : : * remove_irq - free an interrupt
1308 : : * @irq: Interrupt line to free
1309 : : * @act: irqaction for the interrupt
1310 : : *
1311 : : * Used to remove interrupts statically setup by the early boot process.
1312 : : */
1313 : 0 : void remove_irq(unsigned int irq, struct irqaction *act)
1314 : : {
1315 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1316 : :
1317 [ # # ][ # # ]: 0 : if (desc && !WARN_ON(irq_settings_is_per_cpu_devid(desc)))
[ # # ]
1318 : 0 : __free_irq(irq, act->dev_id);
1319 : 0 : }
1320 : : EXPORT_SYMBOL_GPL(remove_irq);
1321 : :
1322 : : /**
1323 : : * free_irq - free an interrupt allocated with request_irq
1324 : : * @irq: Interrupt line to free
1325 : : * @dev_id: Device identity to free
1326 : : *
1327 : : * Remove an interrupt handler. The handler is removed and if the
1328 : : * interrupt line is no longer in use by any driver it is disabled.
1329 : : * On a shared IRQ the caller must ensure the interrupt is disabled
1330 : : * on the card it drives before calling this function. The function
1331 : : * does not return until any executing interrupts for this IRQ
1332 : : * have completed.
1333 : : *
1334 : : * This function must not be called from interrupt context.
1335 : : */
1336 : 0 : void free_irq(unsigned int irq, void *dev_id)
1337 : : {
1338 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1339 : :
1340 [ # # ][ # # ]: 0 : if (!desc || WARN_ON(irq_settings_is_per_cpu_devid(desc)))
[ # # ]
1341 : 0 : return;
1342 : :
1343 : : #ifdef CONFIG_SMP
1344 [ # # ][ # # ]: 0 : if (WARN_ON(desc->affinity_notify))
1345 : 0 : desc->affinity_notify = NULL;
1346 : : #endif
1347 : :
1348 : : chip_bus_lock(desc);
1349 : 0 : kfree(__free_irq(irq, dev_id));
1350 : : chip_bus_sync_unlock(desc);
1351 : : }
1352 : : EXPORT_SYMBOL(free_irq);
1353 : :
1354 : : /**
1355 : : * request_threaded_irq - allocate an interrupt line
1356 : : * @irq: Interrupt line to allocate
1357 : : * @handler: Function to be called when the IRQ occurs.
1358 : : * Primary handler for threaded interrupts
1359 : : * If NULL and thread_fn != NULL the default
1360 : : * primary handler is installed
1361 : : * @thread_fn: Function called from the irq handler thread
1362 : : * If NULL, no irq thread is created
1363 : : * @irqflags: Interrupt type flags
1364 : : * @devname: An ascii name for the claiming device
1365 : : * @dev_id: A cookie passed back to the handler function
1366 : : *
1367 : : * This call allocates interrupt resources and enables the
1368 : : * interrupt line and IRQ handling. From the point this
1369 : : * call is made your handler function may be invoked. Since
1370 : : * your handler function must clear any interrupt the board
1371 : : * raises, you must take care both to initialise your hardware
1372 : : * and to set up the interrupt handler in the right order.
1373 : : *
1374 : : * If you want to set up a threaded irq handler for your device
1375 : : * then you need to supply @handler and @thread_fn. @handler is
1376 : : * still called in hard interrupt context and has to check
1377 : : * whether the interrupt originates from the device. If yes it
1378 : : * needs to disable the interrupt on the device and return
1379 : : * IRQ_WAKE_THREAD which will wake up the handler thread and run
1380 : : * @thread_fn. This split handler design is necessary to support
1381 : : * shared interrupts.
1382 : : *
1383 : : * Dev_id must be globally unique. Normally the address of the
1384 : : * device data structure is used as the cookie. Since the handler
1385 : : * receives this value it makes sense to use it.
1386 : : *
1387 : : * If your interrupt is shared you must pass a non NULL dev_id
1388 : : * as this is required when freeing the interrupt.
1389 : : *
1390 : : * Flags:
1391 : : *
1392 : : * IRQF_SHARED Interrupt is shared
1393 : : * IRQF_TRIGGER_* Specify active edge(s) or level
1394 : : *
1395 : : */
1396 : 0 : int request_threaded_irq(unsigned int irq, irq_handler_t handler,
1397 : : irq_handler_t thread_fn, unsigned long irqflags,
1398 : : const char *devname, void *dev_id)
1399 : : {
1400 : : struct irqaction *action;
1401 : 0 : struct irq_desc *desc;
1402 : : int retval;
1403 : :
1404 : : /*
1405 : : * Sanity-check: shared interrupts must pass in a real dev-ID,
1406 : : * otherwise we'll have trouble later trying to figure out
1407 : : * which interrupt is which (messes up the interrupt freeing
1408 : : * logic etc).
1409 : : */
1410 [ # # ][ # # ]: 0 : if ((irqflags & IRQF_SHARED) && !dev_id)
1411 : : return -EINVAL;
1412 : :
1413 : 0 : desc = irq_to_desc(irq);
1414 [ # # ]: 0 : if (!desc)
1415 : : return -EINVAL;
1416 : :
1417 [ # # ][ # # ]: 0 : if (!irq_settings_can_request(desc) ||
1418 [ # # ]: 0 : WARN_ON(irq_settings_is_per_cpu_devid(desc)))
1419 : : return -EINVAL;
1420 : :
1421 [ # # ]: 0 : if (!handler) {
1422 [ # # ]: 0 : if (!thread_fn)
1423 : : return -EINVAL;
1424 : : handler = irq_default_primary_handler;
1425 : : }
1426 : :
1427 : : action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1428 [ # # ]: 0 : if (!action)
1429 : : return -ENOMEM;
1430 : :
1431 : 0 : action->handler = handler;
1432 : 0 : action->thread_fn = thread_fn;
1433 : 0 : action->flags = irqflags;
1434 : 0 : action->name = devname;
1435 : 0 : action->dev_id = dev_id;
1436 : :
1437 : : chip_bus_lock(desc);
1438 : 0 : retval = __setup_irq(irq, desc, action);
1439 : : chip_bus_sync_unlock(desc);
1440 : :
1441 [ # # ]: 0 : if (retval)
1442 : 0 : kfree(action);
1443 : :
1444 : : #ifdef CONFIG_DEBUG_SHIRQ_FIXME
1445 : : if (!retval && (irqflags & IRQF_SHARED)) {
1446 : : /*
1447 : : * It's a shared IRQ -- the driver ought to be prepared for it
1448 : : * to happen immediately, so let's make sure....
1449 : : * We disable the irq to make sure that a 'real' IRQ doesn't
1450 : : * run in parallel with our fake.
1451 : : */
1452 : : unsigned long flags;
1453 : :
1454 : : disable_irq(irq);
1455 : : local_irq_save(flags);
1456 : :
1457 : : handler(irq, dev_id);
1458 : :
1459 : : local_irq_restore(flags);
1460 : : enable_irq(irq);
1461 : : }
1462 : : #endif
1463 : 0 : return retval;
1464 : : }
1465 : : EXPORT_SYMBOL(request_threaded_irq);
1466 : :
1467 : : /**
1468 : : * request_any_context_irq - allocate an interrupt line
1469 : : * @irq: Interrupt line to allocate
1470 : : * @handler: Function to be called when the IRQ occurs.
1471 : : * Threaded handler for threaded interrupts.
1472 : : * @flags: Interrupt type flags
1473 : : * @name: An ascii name for the claiming device
1474 : : * @dev_id: A cookie passed back to the handler function
1475 : : *
1476 : : * This call allocates interrupt resources and enables the
1477 : : * interrupt line and IRQ handling. It selects either a
1478 : : * hardirq or threaded handling method depending on the
1479 : : * context.
1480 : : *
1481 : : * On failure, it returns a negative value. On success,
1482 : : * it returns either IRQC_IS_HARDIRQ or IRQC_IS_NESTED.
1483 : : */
1484 : 0 : int request_any_context_irq(unsigned int irq, irq_handler_t handler,
1485 : : unsigned long flags, const char *name, void *dev_id)
1486 : : {
1487 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1488 : : int ret;
1489 : :
1490 [ # # ]: 0 : if (!desc)
1491 : : return -EINVAL;
1492 : :
1493 [ # # ]: 0 : if (irq_settings_is_nested_thread(desc)) {
1494 : 0 : ret = request_threaded_irq(irq, NULL, handler,
1495 : : flags, name, dev_id);
1496 [ # # ]: 0 : return !ret ? IRQC_IS_NESTED : ret;
1497 : : }
1498 : :
1499 : : ret = request_irq(irq, handler, flags, name, dev_id);
1500 : 0 : return !ret ? IRQC_IS_HARDIRQ : ret;
1501 : : }
1502 : : EXPORT_SYMBOL_GPL(request_any_context_irq);
1503 : :
1504 : 0 : void enable_percpu_irq(unsigned int irq, unsigned int type)
1505 : : {
1506 : 0 : unsigned int cpu = smp_processor_id();
1507 : : unsigned long flags;
1508 : : struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1509 : :
1510 [ # # ]: 0 : if (!desc)
1511 : 0 : return;
1512 : :
1513 : 0 : type &= IRQ_TYPE_SENSE_MASK;
1514 [ # # ]: 0 : if (type != IRQ_TYPE_NONE) {
1515 : : int ret;
1516 : :
1517 : 0 : ret = __irq_set_trigger(desc, irq, type);
1518 : :
1519 [ # # ]: 0 : if (ret) {
1520 : 0 : WARN(1, "failed to set type for IRQ%d\n", irq);
1521 : 0 : goto out;
1522 : : }
1523 : : }
1524 : :
1525 : 0 : irq_percpu_enable(desc, cpu);
1526 : : out:
1527 : 0 : irq_put_desc_unlock(desc, flags);
1528 : : }
1529 : : EXPORT_SYMBOL_GPL(enable_percpu_irq);
1530 : :
1531 : 0 : void disable_percpu_irq(unsigned int irq)
1532 : : {
1533 : 0 : unsigned int cpu = smp_processor_id();
1534 : : unsigned long flags;
1535 : : struct irq_desc *desc = irq_get_desc_lock(irq, &flags, IRQ_GET_DESC_CHECK_PERCPU);
1536 : :
1537 [ # # ]: 0 : if (!desc)
1538 : 0 : return;
1539 : :
1540 : 0 : irq_percpu_disable(desc, cpu);
1541 : 0 : irq_put_desc_unlock(desc, flags);
1542 : : }
1543 : : EXPORT_SYMBOL_GPL(disable_percpu_irq);
1544 : :
1545 : : /*
1546 : : * Internal function to unregister a percpu irqaction.
1547 : : */
1548 : 0 : static struct irqaction *__free_percpu_irq(unsigned int irq, void __percpu *dev_id)
1549 : : {
1550 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1551 : : struct irqaction *action;
1552 : : unsigned long flags;
1553 : :
1554 [ # # ]: 0 : WARN(in_interrupt(), "Trying to free IRQ %d from IRQ context!\n", irq);
1555 : :
1556 [ # # ]: 0 : if (!desc)
1557 : : return NULL;
1558 : :
1559 : 0 : raw_spin_lock_irqsave(&desc->lock, flags);
1560 : :
1561 : 0 : action = desc->action;
1562 [ # # ][ # # ]: 0 : if (!action || action->percpu_dev_id != dev_id) {
1563 : 0 : WARN(1, "Trying to free already-free IRQ %d\n", irq);
1564 : 0 : goto bad;
1565 : : }
1566 : :
1567 [ # # ]: 0 : if (!cpumask_empty(desc->percpu_enabled)) {
1568 : 0 : WARN(1, "percpu IRQ %d still enabled on CPU%d!\n",
1569 : : irq, cpumask_first(desc->percpu_enabled));
1570 : 0 : goto bad;
1571 : : }
1572 : :
1573 : : /* Found it - now remove it from the list of entries: */
1574 : 0 : desc->action = NULL;
1575 : :
1576 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
1577 : :
1578 : 0 : unregister_handler_proc(irq, action);
1579 : :
1580 : 0 : module_put(desc->owner);
1581 : 0 : return action;
1582 : :
1583 : : bad:
1584 : 0 : raw_spin_unlock_irqrestore(&desc->lock, flags);
1585 : 0 : return NULL;
1586 : : }
1587 : :
1588 : : /**
1589 : : * remove_percpu_irq - free a per-cpu interrupt
1590 : : * @irq: Interrupt line to free
1591 : : * @act: irqaction for the interrupt
1592 : : *
1593 : : * Used to remove interrupts statically setup by the early boot process.
1594 : : */
1595 : 0 : void remove_percpu_irq(unsigned int irq, struct irqaction *act)
1596 : : {
1597 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1598 : :
1599 [ # # ][ # # ]: 0 : if (desc && irq_settings_is_per_cpu_devid(desc))
1600 : 0 : __free_percpu_irq(irq, act->percpu_dev_id);
1601 : 0 : }
1602 : :
1603 : : /**
1604 : : * free_percpu_irq - free an interrupt allocated with request_percpu_irq
1605 : : * @irq: Interrupt line to free
1606 : : * @dev_id: Device identity to free
1607 : : *
1608 : : * Remove a percpu interrupt handler. The handler is removed, but
1609 : : * the interrupt line is not disabled. This must be done on each
1610 : : * CPU before calling this function. The function does not return
1611 : : * until any executing interrupts for this IRQ have completed.
1612 : : *
1613 : : * This function must not be called from interrupt context.
1614 : : */
1615 : 0 : void free_percpu_irq(unsigned int irq, void __percpu *dev_id)
1616 : : {
1617 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1618 : :
1619 [ # # ][ # # ]: 0 : if (!desc || !irq_settings_is_per_cpu_devid(desc))
1620 : 0 : return;
1621 : :
1622 : : chip_bus_lock(desc);
1623 : 0 : kfree(__free_percpu_irq(irq, dev_id));
1624 : : chip_bus_sync_unlock(desc);
1625 : : }
1626 : :
1627 : : /**
1628 : : * setup_percpu_irq - setup a per-cpu interrupt
1629 : : * @irq: Interrupt line to setup
1630 : : * @act: irqaction for the interrupt
1631 : : *
1632 : : * Used to statically setup per-cpu interrupts in the early boot process.
1633 : : */
1634 : 0 : int setup_percpu_irq(unsigned int irq, struct irqaction *act)
1635 : : {
1636 : 0 : struct irq_desc *desc = irq_to_desc(irq);
1637 : : int retval;
1638 : :
1639 [ # # ][ # # ]: 0 : if (!desc || !irq_settings_is_per_cpu_devid(desc))
1640 : : return -EINVAL;
1641 : : chip_bus_lock(desc);
1642 : 0 : retval = __setup_irq(irq, desc, act);
1643 : : chip_bus_sync_unlock(desc);
1644 : :
1645 : 0 : return retval;
1646 : : }
1647 : :
1648 : : /**
1649 : : * request_percpu_irq - allocate a percpu interrupt line
1650 : : * @irq: Interrupt line to allocate
1651 : : * @handler: Function to be called when the IRQ occurs.
1652 : : * @devname: An ascii name for the claiming device
1653 : : * @dev_id: A percpu cookie passed back to the handler function
1654 : : *
1655 : : * This call allocates interrupt resources, but doesn't
1656 : : * automatically enable the interrupt. It has to be done on each
1657 : : * CPU using enable_percpu_irq().
1658 : : *
1659 : : * Dev_id must be globally unique. It is a per-cpu variable, and
1660 : : * the handler gets called with the interrupted CPU's instance of
1661 : : * that variable.
1662 : : */
1663 : 0 : int request_percpu_irq(unsigned int irq, irq_handler_t handler,
1664 : : const char *devname, void __percpu *dev_id)
1665 : : {
1666 : : struct irqaction *action;
1667 : 0 : struct irq_desc *desc;
1668 : : int retval;
1669 : :
1670 [ # # ]: 0 : if (!dev_id)
1671 : : return -EINVAL;
1672 : :
1673 : 0 : desc = irq_to_desc(irq);
1674 [ # # ][ # # ]: 0 : if (!desc || !irq_settings_can_request(desc) ||
[ # # ]
1675 : : !irq_settings_is_per_cpu_devid(desc))
1676 : : return -EINVAL;
1677 : :
1678 : : action = kzalloc(sizeof(struct irqaction), GFP_KERNEL);
1679 [ # # ]: 0 : if (!action)
1680 : : return -ENOMEM;
1681 : :
1682 : 0 : action->handler = handler;
1683 : 0 : action->flags = IRQF_PERCPU | IRQF_NO_SUSPEND;
1684 : 0 : action->name = devname;
1685 : 0 : action->percpu_dev_id = dev_id;
1686 : :
1687 : : chip_bus_lock(desc);
1688 : 0 : retval = __setup_irq(irq, desc, action);
1689 : : chip_bus_sync_unlock(desc);
1690 : :
1691 [ # # ]: 0 : if (retval)
1692 : 0 : kfree(action);
1693 : :
1694 : 0 : return retval;
1695 : : }
|
