Skip to content

Commit b00bee8

Browse files
KAGA-KOKOKAGA-KOKO
committed
irqchip: Convert generic irqchip locking to guards
Conversion was done with Coccinelle and a few manual fixups. In a few interrupt chip callbacks this changes replaces raw_spin_lock_irqsave() with a guard(raw_spinlock). That's intended and correct because those interrupt chip callbacks are invoked with the interrupt descriptor lock held and interrupts disabled. No point in using the irqsave variant. No functional change. Signed-off-by: Thomas Gleixner <tglx@linutronix.de> Reviewed-by: Linus Walleij <linus.walleij@linaro.org> Link: https://lore.kernel.org/all/20250313142524.325627746@linutronix.de
1 parent 9949aec commit b00bee8

14 files changed

Lines changed: 56 additions & 127 deletions

‎drivers/irqchip/irq-al-fic.c‎

Lines changed: 5 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -65,15 +65,13 @@ static int al_fic_irq_set_type(struct irq_data *data, unsigned int flow_type)
6565
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(data);
6666
struct al_fic *fic = gc->private;
6767
enum al_fic_state new_state;
68-
int ret = 0;
6968

70-
irq_gc_lock(gc);
69+
guard(raw_spinlock)(&gc->lock);
7170

7271
if (((flow_type & IRQ_TYPE_SENSE_MASK) != IRQ_TYPE_LEVEL_HIGH) &&
7372
((flow_type & IRQ_TYPE_SENSE_MASK) != IRQ_TYPE_EDGE_RISING)) {
7473
pr_debug("fic doesn't support flow type %d\n", flow_type);
75-
ret = -EINVAL;
76-
goto err;
74+
return -EINVAL;
7775
}
7876

7977
new_state = (flow_type & IRQ_TYPE_LEVEL_HIGH) ?
@@ -91,16 +89,10 @@ static int al_fic_irq_set_type(struct irq_data *data, unsigned int flow_type)
9189
if (fic->state == AL_FIC_UNCONFIGURED) {
9290
al_fic_set_trigger(fic, gc, new_state);
9391
} else if (fic->state != new_state) {
94-
pr_debug("fic %s state already configured to %d\n",
95-
fic->name, fic->state);
96-
ret = -EINVAL;
97-
goto err;
92+
pr_debug("fic %s state already configured to %d\n", fic->name, fic->state);
93+
return -EINVAL;
9894
}
99-
100-
err:
101-
irq_gc_unlock(gc);
102-
103-
return ret;
95+
return 0;
10496
}
10597

10698
static void al_fic_irq_handler(struct irq_desc *desc)

‎drivers/irqchip/irq-atmel-aic.c‎

Lines changed: 6 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -78,9 +78,8 @@ static int aic_retrigger(struct irq_data *d)
7878
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
7979

8080
/* Enable interrupt on AIC5 */
81-
irq_gc_lock(gc);
81+
guard(raw_spinlock)(&gc->lock);
8282
irq_reg_writel(gc, d->mask, AT91_AIC_ISCR);
83-
irq_gc_unlock(gc);
8483

8584
return 1;
8685
}
@@ -106,30 +105,27 @@ static void aic_suspend(struct irq_data *d)
106105
{
107106
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
108107

109-
irq_gc_lock(gc);
108+
guard(raw_spinlock)(&gc->lock);
110109
irq_reg_writel(gc, gc->mask_cache, AT91_AIC_IDCR);
111110
irq_reg_writel(gc, gc->wake_active, AT91_AIC_IECR);
112-
irq_gc_unlock(gc);
113111
}
114112

115113
static void aic_resume(struct irq_data *d)
116114
{
117115
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
118116

119-
irq_gc_lock(gc);
117+
guard(raw_spinlock)(&gc->lock);
120118
irq_reg_writel(gc, gc->wake_active, AT91_AIC_IDCR);
121119
irq_reg_writel(gc, gc->mask_cache, AT91_AIC_IECR);
122-
irq_gc_unlock(gc);
123120
}
124121

125122
static void aic_pm_shutdown(struct irq_data *d)
126123
{
127124
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
128125

129-
irq_gc_lock(gc);
126+
guard(raw_spinlock)(&gc->lock);
130127
irq_reg_writel(gc, 0xffffffff, AT91_AIC_IDCR);
131128
irq_reg_writel(gc, 0xffffffff, AT91_AIC_ICCR);
132-
irq_gc_unlock(gc);
133129
}
134130
#else
135131
#define aic_suspend NULL
@@ -175,10 +171,8 @@ static int aic_irq_domain_xlate(struct irq_domain *d,
175171
{
176172
struct irq_domain_chip_generic *dgc = d->gc;
177173
struct irq_chip_generic *gc;
178-
unsigned long flags;
179174
unsigned smr;
180-
int idx;
181-
int ret;
175+
int idx, ret;
182176

183177
if (!dgc)
184178
return -EINVAL;
@@ -194,11 +188,10 @@ static int aic_irq_domain_xlate(struct irq_domain *d,
194188

195189
gc = dgc->gc[idx];
196190

197-
irq_gc_lock_irqsave(gc, flags);
191+
guard(raw_spinlock_irq)(&gc->lock);
198192
smr = irq_reg_readl(gc, AT91_AIC_SMR(*out_hwirq));
199193
aic_common_set_priority(intspec[2], &smr);
200194
irq_reg_writel(gc, smr, AT91_AIC_SMR(*out_hwirq));
201-
irq_gc_unlock_irqrestore(gc, flags);
202195

203196
return ret;
204197
}

‎drivers/irqchip/irq-atmel-aic5.c‎

Lines changed: 8 additions & 20 deletions
Original file line numberDiff line numberDiff line change
@@ -92,11 +92,10 @@ static void aic5_mask(struct irq_data *d)
9292
* Disable interrupt on AIC5. We always take the lock of the
9393
* first irq chip as all chips share the same registers.
9494
*/
95-
irq_gc_lock(bgc);
95+
guard(raw_spinlock)(&bgc->lock);
9696
irq_reg_writel(gc, d->hwirq, AT91_AIC5_SSR);
9797
irq_reg_writel(gc, 1, AT91_AIC5_IDCR);
9898
gc->mask_cache &= ~d->mask;
99-
irq_gc_unlock(bgc);
10099
}
101100

102101
static void aic5_unmask(struct irq_data *d)
@@ -109,11 +108,10 @@ static void aic5_unmask(struct irq_data *d)
109108
* Enable interrupt on AIC5. We always take the lock of the
110109
* first irq chip as all chips share the same registers.
111110
*/
112-
irq_gc_lock(bgc);
111+
guard(raw_spinlock)(&bgc->lock);
113112
irq_reg_writel(gc, d->hwirq, AT91_AIC5_SSR);
114113
irq_reg_writel(gc, 1, AT91_AIC5_IECR);
115114
gc->mask_cache |= d->mask;
116-
irq_gc_unlock(bgc);
117115
}
118116

119117
static int aic5_retrigger(struct irq_data *d)
@@ -122,11 +120,9 @@ static int aic5_retrigger(struct irq_data *d)
122120
struct irq_chip_generic *bgc = irq_get_domain_generic_chip(domain, 0);
123121

124122
/* Enable interrupt on AIC5 */
125-
irq_gc_lock(bgc);
123+
guard(raw_spinlock)(&bgc->lock);
126124
irq_reg_writel(bgc, d->hwirq, AT91_AIC5_SSR);
127125
irq_reg_writel(bgc, 1, AT91_AIC5_ISCR);
128-
irq_gc_unlock(bgc);
129-
130126
return 1;
131127
}
132128

@@ -137,14 +133,12 @@ static int aic5_set_type(struct irq_data *d, unsigned type)
137133
unsigned int smr;
138134
int ret;
139135

140-
irq_gc_lock(bgc);
136+
guard(raw_spinlock)(&bgc->lock);
141137
irq_reg_writel(bgc, d->hwirq, AT91_AIC5_SSR);
142138
smr = irq_reg_readl(bgc, AT91_AIC5_SMR);
143139
ret = aic_common_set_type(d, type, &smr);
144140
if (!ret)
145141
irq_reg_writel(bgc, smr, AT91_AIC5_SMR);
146-
irq_gc_unlock(bgc);
147-
148142
return ret;
149143
}
150144

@@ -166,7 +160,7 @@ static void aic5_suspend(struct irq_data *d)
166160
smr_cache[i] = irq_reg_readl(bgc, AT91_AIC5_SMR);
167161
}
168162

169-
irq_gc_lock(bgc);
163+
guard(raw_spinlock)(&bgc->lock);
170164
for (i = 0; i < dgc->irqs_per_chip; i++) {
171165
mask = 1 << i;
172166
if ((mask & gc->mask_cache) == (mask & gc->wake_active))
@@ -178,7 +172,6 @@ static void aic5_suspend(struct irq_data *d)
178172
else
179173
irq_reg_writel(bgc, 1, AT91_AIC5_IDCR);
180174
}
181-
irq_gc_unlock(bgc);
182175
}
183176

184177
static void aic5_resume(struct irq_data *d)
@@ -190,7 +183,7 @@ static void aic5_resume(struct irq_data *d)
190183
int i;
191184
u32 mask;
192185

193-
irq_gc_lock(bgc);
186+
guard(raw_spinlock)(&bgc->lock);
194187

195188
if (smr_cache) {
196189
irq_reg_writel(bgc, 0xffffffff, AT91_AIC5_SPU);
@@ -214,7 +207,6 @@ static void aic5_resume(struct irq_data *d)
214207
else
215208
irq_reg_writel(bgc, 1, AT91_AIC5_IDCR);
216209
}
217-
irq_gc_unlock(bgc);
218210
}
219211

220212
static void aic5_pm_shutdown(struct irq_data *d)
@@ -225,13 +217,12 @@ static void aic5_pm_shutdown(struct irq_data *d)
225217
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
226218
int i;
227219

228-
irq_gc_lock(bgc);
220+
guard(raw_spinlock)(&bgc->lock);
229221
for (i = 0; i < dgc->irqs_per_chip; i++) {
230222
irq_reg_writel(bgc, i + gc->irq_base, AT91_AIC5_SSR);
231223
irq_reg_writel(bgc, 1, AT91_AIC5_IDCR);
232224
irq_reg_writel(bgc, 1, AT91_AIC5_ICCR);
233225
}
234-
irq_gc_unlock(bgc);
235226
}
236227
#else
237228
#define aic5_suspend NULL
@@ -277,7 +268,6 @@ static int aic5_irq_domain_xlate(struct irq_domain *d,
277268
unsigned int *out_type)
278269
{
279270
struct irq_chip_generic *bgc = irq_get_domain_generic_chip(d, 0);
280-
unsigned long flags;
281271
unsigned smr;
282272
int ret;
283273

@@ -289,13 +279,11 @@ static int aic5_irq_domain_xlate(struct irq_domain *d,
289279
if (ret)
290280
return ret;
291281

292-
irq_gc_lock_irqsave(bgc, flags);
282+
guard(raw_spinlock_irq)(&bgc->lock);
293283
irq_reg_writel(bgc, *out_hwirq, AT91_AIC5_SSR);
294284
smr = irq_reg_readl(bgc, AT91_AIC5_SMR);
295285
aic_common_set_priority(intspec[2], &smr);
296286
irq_reg_writel(bgc, smr, AT91_AIC5_SMR);
297-
irq_gc_unlock_irqrestore(bgc, flags);
298-
299287
return ret;
300288
}
301289

‎drivers/irqchip/irq-bcm7120-l2.c‎

Lines changed: 9 additions & 13 deletions
Original file line numberDiff line numberDiff line change
@@ -63,16 +63,15 @@ static void bcm7120_l2_intc_irq_handle(struct irq_desc *desc)
6363

6464
for (idx = 0; idx < b->n_words; idx++) {
6565
int base = idx * IRQS_PER_WORD;
66-
struct irq_chip_generic *gc =
67-
irq_get_domain_generic_chip(b->domain, base);
66+
struct irq_chip_generic *gc;
6867
unsigned long pending;
6968
int hwirq;
7069

71-
irq_gc_lock(gc);
72-
pending = irq_reg_readl(gc, b->stat_offset[idx]) &
73-
gc->mask_cache &
74-
data->irq_map_mask[idx];
75-
irq_gc_unlock(gc);
70+
gc = irq_get_domain_generic_chip(b->domain, base);
71+
scoped_guard (raw_spinlock, &gc->lock) {
72+
pending = irq_reg_readl(gc, b->stat_offset[idx]) & gc->mask_cache &
73+
data->irq_map_mask[idx];
74+
}
7675

7776
for_each_set_bit(hwirq, &pending, IRQS_PER_WORD)
7877
generic_handle_domain_irq(b->domain, base + hwirq);
@@ -86,21 +85,18 @@ static void bcm7120_l2_intc_suspend(struct irq_chip_generic *gc)
8685
struct bcm7120_l2_intc_data *b = gc->private;
8786
struct irq_chip_type *ct = gc->chip_types;
8887

89-
irq_gc_lock(gc);
88+
guard(raw_spinlock)(&gc->lock);
9089
if (b->can_wake)
91-
irq_reg_writel(gc, gc->mask_cache | gc->wake_active,
92-
ct->regs.mask);
93-
irq_gc_unlock(gc);
90+
irq_reg_writel(gc, gc->mask_cache | gc->wake_active, ct->regs.mask);
9491
}
9592

9693
static void bcm7120_l2_intc_resume(struct irq_chip_generic *gc)
9794
{
9895
struct irq_chip_type *ct = gc->chip_types;
9996

10097
/* Restore the saved mask */
101-
irq_gc_lock(gc);
98+
guard(raw_spinlock)(&gc->lock);
10299
irq_reg_writel(gc, gc->mask_cache, ct->regs.mask);
103-
irq_gc_unlock(gc);
104100
}
105101

106102
static int bcm7120_l2_intc_init_one(struct device_node *dn,

‎drivers/irqchip/irq-brcmstb-l2.c‎

Lines changed: 2 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -97,9 +97,8 @@ static void __brcmstb_l2_intc_suspend(struct irq_data *d, bool save)
9797
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
9898
struct irq_chip_type *ct = irq_data_get_chip_type(d);
9999
struct brcmstb_l2_intc_data *b = gc->private;
100-
unsigned long flags;
101100

102-
irq_gc_lock_irqsave(gc, flags);
101+
guard(raw_spinlock_irqsave)(&gc->lock);
103102
/* Save the current mask */
104103
if (save)
105104
b->saved_mask = irq_reg_readl(gc, ct->regs.mask);
@@ -109,7 +108,6 @@ static void __brcmstb_l2_intc_suspend(struct irq_data *d, bool save)
109108
irq_reg_writel(gc, ~gc->wake_active, ct->regs.disable);
110109
irq_reg_writel(gc, gc->wake_active, ct->regs.enable);
111110
}
112-
irq_gc_unlock_irqrestore(gc, flags);
113111
}
114112

115113
static void brcmstb_l2_intc_shutdown(struct irq_data *d)
@@ -127,9 +125,8 @@ static void brcmstb_l2_intc_resume(struct irq_data *d)
127125
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
128126
struct irq_chip_type *ct = irq_data_get_chip_type(d);
129127
struct brcmstb_l2_intc_data *b = gc->private;
130-
unsigned long flags;
131128

132-
irq_gc_lock_irqsave(gc, flags);
129+
guard(raw_spinlock_irqsave)(&gc->lock);
133130
if (ct->chip.irq_ack) {
134131
/* Clear unmasked non-wakeup interrupts */
135132
irq_reg_writel(gc, ~b->saved_mask & ~gc->wake_active,
@@ -139,7 +136,6 @@ static void brcmstb_l2_intc_resume(struct irq_data *d)
139136
/* Restore the saved mask */
140137
irq_reg_writel(gc, b->saved_mask, ct->regs.disable);
141138
irq_reg_writel(gc, ~b->saved_mask, ct->regs.enable);
142-
irq_gc_unlock_irqrestore(gc, flags);
143139
}
144140

145141
static int __init brcmstb_l2_intc_of_init(struct device_node *np,

‎drivers/irqchip/irq-csky-apb-intc.c‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -50,11 +50,10 @@ static void irq_ck_mask_set_bit(struct irq_data *d)
5050
unsigned long ifr = ct->regs.mask - 8;
5151
u32 mask = d->mask;
5252

53-
irq_gc_lock(gc);
53+
guard(raw_spinlock)(&gc->lock);
5454
*ct->mask_cache |= mask;
5555
irq_reg_writel(gc, *ct->mask_cache, ct->regs.mask);
5656
irq_reg_writel(gc, irq_reg_readl(gc, ifr) & ~mask, ifr);
57-
irq_gc_unlock(gc);
5857
}
5958

6059
static void __init ck_set_gc(struct device_node *node, void __iomem *reg_base,

‎drivers/irqchip/irq-dw-apb-ictl.c‎

Lines changed: 1 addition & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -101,10 +101,9 @@ static void dw_apb_ictl_resume(struct irq_data *d)
101101
struct irq_chip_generic *gc = irq_data_get_irq_chip_data(d);
102102
struct irq_chip_type *ct = irq_data_get_chip_type(d);
103103

104-
irq_gc_lock(gc);
104+
guard(raw_spinlock)(&gc->lock);
105105
writel_relaxed(~0, gc->reg_base + ct->regs.enable);
106106
writel_relaxed(*ct->mask_cache, gc->reg_base + ct->regs.mask);
107-
irq_gc_unlock(gc);
108107
}
109108
#else
110109
#define dw_apb_ictl_resume NULL

‎drivers/irqchip/irq-ingenic-tcu.c‎

Lines changed: 3 additions & 6 deletions
Original file line numberDiff line numberDiff line change
@@ -52,11 +52,10 @@ static void ingenic_tcu_gc_unmask_enable_reg(struct irq_data *d)
5252
struct regmap *map = gc->private;
5353
u32 mask = d->mask;
5454

55-
irq_gc_lock(gc);
55+
guard(raw_spinlock)(&gc->lock);
5656
regmap_write(map, ct->regs.ack, mask);
5757
regmap_write(map, ct->regs.enable, mask);
5858
*ct->mask_cache |= mask;
59-
irq_gc_unlock(gc);
6059
}
6160

6261
static void ingenic_tcu_gc_mask_disable_reg(struct irq_data *d)
@@ -66,10 +65,9 @@ static void ingenic_tcu_gc_mask_disable_reg(struct irq_data *d)
6665
struct regmap *map = gc->private;
6766
u32 mask = d->mask;
6867

69-
irq_gc_lock(gc);
68+
guard(raw_spinlock)(&gc->lock);
7069
regmap_write(map, ct->regs.disable, mask);
7170
*ct->mask_cache &= ~mask;
72-
irq_gc_unlock(gc);
7371
}
7472

7573
static void ingenic_tcu_gc_mask_disable_reg_and_ack(struct irq_data *d)
@@ -79,10 +77,9 @@ static void ingenic_tcu_gc_mask_disable_reg_and_ack(struct irq_data *d)
7977
struct regmap *map = gc->private;
8078
u32 mask = d->mask;
8179

82-
irq_gc_lock(gc);
80+
guard(raw_spinlock)(&gc->lock);
8381
regmap_write(map, ct->regs.ack, mask);
8482
regmap_write(map, ct->regs.disable, mask);
85-
irq_gc_unlock(gc);
8683
}
8784

8885
static int __init ingenic_tcu_irq_init(struct device_node *np,

0 commit comments

Comments
 (0)