genirq: Move INPROGRESS, MASKED and DISABLED state flags to irq_data

We really need these flags for some of the interrupt chips. Move it from internal state to irq_data and provide proper accessors.

Thomas Gleixner committed 15 years ago

Commit 32f41251 parent c2d0c559 files · +64 −59Browse files

Showing the changes to kernel (8 of 9 files). Show all

Unified · Split

8 files

kernel/irq/chip.c +19 −21
kernel/irq/debug.h +7 −3
kernel/irq/handle.c +2 −2
kernel/irq/internals.h +0 −6
kernel/irq/irqdesc.c +0 −2
kernel/irq/manage.c +14 −16
kernel/irq/migration.c +2 −2
kernel/irq/spurious.c +5 −5

kernel/irq/chip.c+19−21

@@ -140,27 +140,25 @@ EXPORT_SYMBOL_GPL(irq_get_irq_data); · 139 unmodified lines
140	140
141	141	static void irq_state_clr_disabled(struct irq_desc *desc)
142	142	{
143		− desc->istate &= ~IRQS_DISABLED;
144	143	irqd_clear(&desc->irq_data, IRQD_IRQ_DISABLED);
145	144	irq_compat_clr_disabled(desc);
146	145	}
147	146
148	147	static void irq_state_set_disabled(struct irq_desc *desc)
149	148	{
150		− desc->istate \|= IRQS_DISABLED;
151	149	irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
152	150	irq_compat_set_disabled(desc);
153	151	}
154	152
155	153	static void irq_state_clr_masked(struct irq_desc *desc)
156	154	{
157		− desc->istate &= ~IRQS_MASKED;
	155	+ irqd_clear(&desc->irq_data, IRQD_IRQ_MASKED);
158	156	irq_compat_clr_masked(desc);
159	157	}
160	158
161	159	static void irq_state_set_masked(struct irq_desc *desc)
162	160	{
163		− desc->istate \|= IRQS_MASKED;
	161	+ irqd_set(&desc->irq_data, IRQD_IRQ_MASKED);
164	162	irq_compat_set_masked(desc);
165	163	}
166	164
@@ -380,11 +378,11 @@ void handle_nested_irq(unsigned int irq) · 213 unmodified lines
380	378	kstat_incr_irqs_this_cpu(irq, desc);
381	379
382	380	action = desc->action;
383		− if (unlikely(!action \|\| (desc->istate & IRQS_DISABLED)))
	381	+ if (unlikely(!action \|\| irqd_irq_disabled(&desc->irq_data)))
384	382	goto out_unlock;
385	383
386	384	irq_compat_set_progress(desc);
387		− desc->istate \|= IRQS_INPROGRESS;
	385	+ irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
388	386	raw_spin_unlock_irq(&desc->lock);
389	387
390	388	action_ret = action->thread_fn(action->irq, action->dev_id);
@@ -392,7 +390,7 @@ void handle_nested_irq(unsigned int irq) · 1 unmodified line
392	390	note_interrupt(irq, desc, action_ret);
393	391
394	392	raw_spin_lock_irq(&desc->lock);
395		− desc->istate &= ~IRQS_INPROGRESS;
	393	+ irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
396	394	irq_compat_clr_progress(desc);
397	395
398	396	out_unlock:
@@ -424,14 +422,14 @@ handle_simple_irq(unsigned int irq, struct irq_desc *desc) · 25 unmodified lines
424	422	{
425	423	raw_spin_lock(&desc->lock);
426	424
427		− if (unlikely(desc->istate & IRQS_INPROGRESS))
	425	+ if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
428	426	if (!irq_check_poll(desc))
429	427	goto out_unlock;
430	428
431	429	desc->istate &= ~(IRQS_REPLAY \| IRQS_WAITING);
432	430	kstat_incr_irqs_this_cpu(irq, desc);
433	431
434		− if (unlikely(!desc->action \|\| (desc->istate & IRQS_DISABLED)))
	432	+ if (unlikely(!desc->action \|\| irqd_irq_disabled(&desc->irq_data)))
435	433	goto out_unlock;
436	434
437	435	handle_irq_event(desc);
@@ -456,7 +454,7 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc) · 18 unmodified lines
456	454	raw_spin_lock(&desc->lock);
457	455	mask_ack_irq(desc);
458	456
459		− if (unlikely(desc->istate & IRQS_INPROGRESS))
	457	+ if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
460	458	if (!irq_check_poll(desc))
461	459	goto out_unlock;
462	460
@@ -467,12 +465,12 @@ handle_level_irq(unsigned int irq, struct irq_desc *desc) · 4 unmodified lines
467	465	* If its disabled or no action available
468	466	* keep it masked and get out of here
469	467	*/
470		− if (unlikely(!desc->action \|\| (desc->istate & IRQS_DISABLED)))
	468	+ if (unlikely(!desc->action \|\| irqd_irq_disabled(&desc->irq_data)))
471	469	goto out_unlock;
472	470
473	471	handle_irq_event(desc);
474	472
475		− if (!(desc->istate & (IRQS_DISABLED \| IRQS_ONESHOT)))
	473	+ if (!irqd_irq_disabled(&desc->irq_data) && !(desc->istate & IRQS_ONESHOT))
476	474	unmask_irq(desc);
477	475	out_unlock:
478	476	raw_spin_unlock(&desc->lock);
@@ -504,7 +502,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc) · 25 unmodified lines
504	502	{
505	503	raw_spin_lock(&desc->lock);
506	504
507		− if (unlikely(desc->istate & IRQS_INPROGRESS))
	505	+ if (unlikely(irqd_irq_inprogress(&desc->irq_data)))
508	506	if (!irq_check_poll(desc))
509	507	goto out;
510	508
@@ -515,7 +513,7 @@ handle_fasteoi_irq(unsigned int irq, struct irq_desc *desc) · 4 unmodified lines
515	513	* If its disabled or no action available
516	514	* then mask it and get out of here:
517	515	*/
518		− if (unlikely(!desc->action \|\| (desc->istate & IRQS_DISABLED))) {
	516	+ if (unlikely(!desc->action \|\| irqd_irq_disabled(&desc->irq_data))) {
519	517	irq_compat_set_pending(desc);
520	518	desc->istate \|= IRQS_PENDING;
521	519	mask_irq(desc);
@@ -566,8 +564,8 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc) · 44 unmodified lines
566	564	* we shouldn't process the IRQ. Mark it pending, handle
567	565	* the necessary masking and go out
568	566	*/
569		− if (unlikely((desc->istate & (IRQS_DISABLED \| IRQS_INPROGRESS) \|\|
570		− !desc->action))) {
	567	+ if (unlikely(irqd_irq_disabled(&desc->irq_data) \|\|
	568	+ irqd_irq_inprogress(&desc->irq_data) \|\| !desc->action)) {
571	569	if (!irq_check_poll(desc)) {
572	570	irq_compat_set_pending(desc);
573	571	desc->istate \|= IRQS_PENDING;
@@ -592,15 +590,15 @@ handle_edge_irq(unsigned int irq, struct irq_desc *desc) · 18 unmodified lines
592	590	* Renable it, if it was not disabled in meantime.
593	591	*/
594	592	if (unlikely(desc->istate & IRQS_PENDING)) {
595		− if (!(desc->istate & IRQS_DISABLED) &&
596		− (desc->istate & IRQS_MASKED))
	593	+ if (!irqd_irq_disabled(&desc->irq_data) &&
	594	+ irqd_irq_masked(&desc->irq_data))
597	595	unmask_irq(desc);
598	596	}
599	597
600	598	handle_irq_event(desc);
601	599
602	600	} while ((desc->istate & IRQS_PENDING) &&
603		− !(desc->istate & IRQS_DISABLED));
	601	+ !irqd_irq_disabled(&desc->irq_data));
604	602
605	603	out_unlock:
606	604	raw_spin_unlock(&desc->lock);
@@ -720,7 +718,7 @@ void irq_cpu_online(void) · 113 unmodified lines
720	718	chip = irq_data_get_irq_chip(&desc->irq_data);
721	719	if (chip && chip->irq_cpu_online &&
722	720	(!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) \|\|
723		− !(desc->istate & IRQS_DISABLED)))
	721	+ !irqd_irq_disabled(&desc->irq_data)))
724	722	chip->irq_cpu_online(&desc->irq_data);
725	723
726	724	raw_spin_unlock_irqrestore(&desc->lock, flags);
@@ -750,7 +748,7 @@ void irq_cpu_offline(void) · 23 unmodified lines
750	748	chip = irq_data_get_irq_chip(&desc->irq_data);
751	749	if (chip && chip->irq_cpu_offline &&
752	750	(!(chip->flags & IRQCHIP_ONOFFLINE_ENABLED) \|\|
753		− !(desc->istate & IRQS_DISABLED)))
	751	+ !irqd_irq_disabled(&desc->irq_data)))
754	752	chip->irq_cpu_offline(&desc->irq_data);
755	753
756	754	raw_spin_unlock_irqrestore(&desc->lock, flags);

kernel/irq/debug.h+7−3

@@ -6,6 +6,8 @@ · 5 unmodified lines
6	6
7	7	#define P(f) if (desc->status & f) printk("%14s set\n", #f)
8	8	#define PS(f) if (desc->istate & f) printk("%14s set\n", #f)
	9	+/* FIXME */
	10	+#define PD(f) do { } while (0)
9	11
10	12	static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc)
11	13	{
@@ -28,13 +30,15 @@ static inline void print_irq_desc(unsigned int irq, struct irq_desc *desc) · 16 unmodified lines
28	30	P(IRQ_NOAUTOEN);
29	31
30	32	PS(IRQS_AUTODETECT);
31		− PS(IRQS_INPROGRESS);
32	33	PS(IRQS_REPLAY);
33	34	PS(IRQS_WAITING);
34		− PS(IRQS_DISABLED);
35	35	PS(IRQS_PENDING);
36		− PS(IRQS_MASKED);
	36	+
	37	+ PD(IRQS_INPROGRESS);
	38	+ PD(IRQS_DISABLED);
	39	+ PD(IRQS_MASKED);
37	40	}
38	41
39	42	#undef P
40	43	#undef PS
	44	+#undef PD

kernel/irq/handle.c+2−2

@@ -178,13 +178,13 @@ irqreturn_t handle_irq_event(struct irq_desc *desc) · 177 unmodified lines
178	178	irq_compat_clr_pending(desc);
179	179	desc->istate &= ~IRQS_PENDING;
180	180	irq_compat_set_progress(desc);
181		− desc->istate \|= IRQS_INPROGRESS;
	181	+ irqd_set(&desc->irq_data, IRQD_IRQ_INPROGRESS);
182	182	raw_spin_unlock(&desc->lock);
183	183
184	184	ret = handle_irq_event_percpu(desc, action);
185	185
186	186	raw_spin_lock(&desc->lock);
187		− desc->istate &= ~IRQS_INPROGRESS;
	187	+ irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
188	188	irq_compat_clr_progress(desc);
189	189	return ret;
190	190	}

kernel/irq/internals.h+0−6

@@ -44,26 +44,20 @@ enum { · 43 unmodified lines
44	44	* IRQS_SPURIOUS_DISABLED - was disabled due to spurious interrupt
45	45	* detection
46	46	* IRQS_POLL_INPROGRESS - polling in progress
47		− * IRQS_INPROGRESS - Interrupt in progress
48	47	* IRQS_ONESHOT - irq is not unmasked in primary handler
49	48	* IRQS_REPLAY - irq is replayed
50	49	* IRQS_WAITING - irq is waiting
51		− * IRQS_DISABLED - irq is disabled
52	50	* IRQS_PENDING - irq is pending and replayed later
53		− * IRQS_MASKED - irq is masked
54	51	* IRQS_SUSPENDED - irq is suspended
55	52	*/
56	53	enum {
57	54	IRQS_AUTODETECT = 0x00000001,
58	55	IRQS_SPURIOUS_DISABLED = 0x00000002,
59	56	IRQS_POLL_INPROGRESS = 0x00000008,
60		− IRQS_INPROGRESS = 0x00000010,
61	57	IRQS_ONESHOT = 0x00000020,
62	58	IRQS_REPLAY = 0x00000040,
63	59	IRQS_WAITING = 0x00000080,
64		− IRQS_DISABLED = 0x00000100,
65	60	IRQS_PENDING = 0x00000200,
66		− IRQS_MASKED = 0x00000400,
67	61	IRQS_SUSPENDED = 0x00000800,
68	62	};
69	63

kernel/irq/irqdesc.c+0−2

@@ -81,7 +81,6 @@ static void desc_set_defaults(unsigned int irq, struct irq_desc *desc, int node) · 80 unmodified lines
81	81	desc->irq_data.msi_desc = NULL;
82	82	irq_settings_clr_and_set(desc, ~0, _IRQ_DEFAULT_INIT_FLAGS);
83	83	irqd_set(&desc->irq_data, IRQD_IRQ_DISABLED);
84		− desc->istate = IRQS_DISABLED;
85	84	desc->handle_irq = handle_bad_irq;
86	85	desc->depth = 1;
87	86	desc->irq_count = 0;
@@ -239,7 +238,6 @@ int __init early_irq_init(void) · 151 unmodified lines
239	238
240	239	struct irq_desc irq_desc[NR_IRQS] __cacheline_aligned_in_smp = {
241	240	[0 ... NR_IRQS-1] = {
242		− .istate = IRQS_DISABLED,
243	241	.handle_irq = handle_bad_irq,
244	242	.depth = 1,
245	243	.lock = __RAW_SPIN_LOCK_UNLOCKED(irq_desc->lock),

kernel/irq/manage.c+14−16

@@ -41,7 +41,7 @@ early_param("threadirqs", setup_forced_irqthreads); · 40 unmodified lines
41	41	void synchronize_irq(unsigned int irq)
42	42	{
43	43	struct irq_desc *desc = irq_to_desc(irq);
44		− unsigned int state;
	44	+ bool inprogress;
45	45
46	46	if (!desc)
47	47	return;
@@ -53,16 +53,16 @@ void synchronize_irq(unsigned int irq) · 5 unmodified lines
53	53	* Wait until we're out of the critical section. This might
54	54	* give the wrong answer due to the lack of memory barriers.
55	55	*/
56		− while (desc->istate & IRQS_INPROGRESS)
	56	+ while (irqd_irq_inprogress(&desc->irq_data))
57	57	cpu_relax();
58	58
59	59	/* Ok, that indicated we're done: double-check carefully. */
60	60	raw_spin_lock_irqsave(&desc->lock, flags);
61		− state = desc->istate;
	61	+ inprogress = irqd_irq_inprogress(&desc->irq_data);
62	62	raw_spin_unlock_irqrestore(&desc->lock, flags);
63	63
64	64	/* Oops, that failed? */
65		− } while (state & IRQS_INPROGRESS);
	65	+ } while (inprogress);
66	66
67	67	/*
68	68	* We made sure that no hardirq handler is running. Now verify
@@ -563,9 +563,9 @@ int __irq_set_trigger(struct irq_desc *desc, unsigned int irq, · 494 unmodified lines
563	563	flags &= IRQ_TYPE_SENSE_MASK;
564	564
565	565	if (chip->flags & IRQCHIP_SET_TYPE_MASKED) {
566		− if (!(desc->istate & IRQS_MASKED))
	566	+ if (!irqd_irq_masked(&desc->irq_data))
567	567	mask_irq(desc);
568		− if (!(desc->istate & IRQS_DISABLED))
	568	+ if (!irqd_irq_disabled(&desc->irq_data))
569	569	unmask = 1;
570	570	}
571	571
@@ -663,7 +663,7 @@ again: · 91 unmodified lines
663	663	* irq_wake_thread(). See the comment there which explains the
664	664	* serialization.
665	665	*/
666		− if (unlikely(desc->istate & IRQS_INPROGRESS)) {
	666	+ if (unlikely(irqd_irq_inprogress(&desc->irq_data))) {
667	667	raw_spin_unlock_irq(&desc->lock);
668	668	chip_bus_sync_unlock(desc);
669	669	cpu_relax();
@@ -680,12 +680,10 @@ again: · 10 unmodified lines
680	680
681	681	desc->threads_oneshot &= ~action->thread_mask;
682	682
683		− if (!desc->threads_oneshot && !(desc->istate & IRQS_DISABLED) &&
684		− (desc->istate & IRQS_MASKED)) {
685		− irq_compat_clr_masked(desc);
686		− desc->istate &= ~IRQS_MASKED;
687		− desc->irq_data.chip->irq_unmask(&desc->irq_data);
688		− }
	683	+ if (!desc->threads_oneshot && !irqd_irq_disabled(&desc->irq_data) &&
	684	+ irqd_irq_masked(&desc->irq_data))
	685	+ unmask_irq(desc);
	686	+
689	687	out_unlock:
690	688	raw_spin_unlock_irq(&desc->lock);
691	689	chip_bus_sync_unlock(desc);
@@ -779,7 +777,7 @@ static int irq_thread(void *data) · 87 unmodified lines
779	777	atomic_inc(&desc->threads_active);
780	778
781	779	raw_spin_lock_irq(&desc->lock);
782		− if (unlikely(desc->istate & IRQS_DISABLED)) {
	780	+ if (unlikely(irqd_irq_disabled(&desc->irq_data))) {
783	781	/*
784	782	* CHECKME: We might need a dedicated
785	783	* IRQ_THREAD_PENDING flag here, which
@@ -997,8 +995,8 @@ __setup_irq(unsigned int irq, struct irq_desc desc, struct irqaction new) · 211 unmodified lines
997	995	}
998	996
999	997	desc->istate &= ~(IRQS_AUTODETECT \| IRQS_SPURIOUS_DISABLED \| \
1000		− IRQS_INPROGRESS \| IRQS_ONESHOT \| \
1001		− IRQS_WAITING);
	998	+ IRQS_ONESHOT \| IRQS_WAITING);
	999	+ irqd_clear(&desc->irq_data, IRQD_IRQ_INPROGRESS);
1002	1000
1003	1001	if (new->flags & IRQF_PERCPU) {
1004	1002	irqd_set(&desc->irq_data, IRQD_PER_CPU);

kernel/irq/migration.c+2−2

@@ -66,7 +66,7 @@ void irq_move_irq(struct irq_data *idata) · 65 unmodified lines
66	66	if (likely(!irqd_is_setaffinity_pending(idata)))
67	67	return;
68	68
69		− if (unlikely(desc->istate & IRQS_DISABLED))
	69	+ if (unlikely(irqd_irq_disabled(idata)))
70	70	return;
71	71
72	72	/*
@@ -74,7 +74,7 @@ void irq_move_irq(struct irq_data *idata) · 1 unmodified line
74	74	* threaded interrupt with ONESHOT set, we can end up with an
75	75	* interrupt storm.
76	76	*/
77		− masked = desc->istate & IRQS_MASKED;
	77	+ masked = irqd_irq_masked(idata);
78	78	if (!masked)
79	79	idata->chip->irq_mask(idata);
80	80	irq_move_masked_irq(idata);

kernel/irq/spurious.c+5−5

@@ -45,12 +45,12 @@ bool irq_wait_for_poll(struct irq_desc *desc) · 44 unmodified lines
45	45	#ifdef CONFIG_SMP
46	46	do {
47	47	raw_spin_unlock(&desc->lock);
48		− while (desc->istate & IRQS_INPROGRESS)
	48	+ while (irqd_irq_inprogress(&desc->irq_data))
49	49	cpu_relax();
50	50	raw_spin_lock(&desc->lock);
51		− } while (desc->istate & IRQS_INPROGRESS);
	51	+ } while irqd_irq_inprogress(&desc->irq_data);
52	52	/* Might have been disabled in meantime */
53		− return !(desc->istate & IRQS_DISABLED) && desc->action;
	53	+ return !irqd_irq_disabled(&desc->irq_data) && desc->action;
54	54	#else
55	55	return false;
56	56	#endif
@@ -75,7 +75,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force) · 18 unmodified lines
75	75	* Do not poll disabled interrupts unless the spurious
76	76	* disabled poller asks explicitely.
77	77	*/
78		− if ((desc->istate & IRQS_DISABLED) && !force)
	78	+ if (irqd_irq_disabled(&desc->irq_data) && !force)
79	79	goto out;
80	80
81	81	/*
@@ -88,7 +88,7 @@ static int try_one_irq(int irq, struct irq_desc *desc, bool force) · 6 unmodified lines
88	88	goto out;
89	89
90	90	/* Already running on another processor */
91		− if (desc->istate & IRQS_INPROGRESS) {
	91	+ if (irqd_irq_inprogress(&desc->irq_data)) {
92	92	/*
93	93	* Already running: If it is shared get the other
94	94	* CPU to go looking for our mystery interrupt too

genirq: Move INPROGRESS, MASKED and DISABLED state flags to irq_data

Keyboard shortcuts

General

Issues and pull requests

Issues, pull requests and Inbox

Repository code