Linux kernel mirror (for testing)
git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git
kernel
os
linux
iio: trigger: stm32-timer-trigger: Add check for clk_enable()
Add check for the return value of clk_enable() in order to catch the
potential exception.
Reviewed-by: David Lechner <dlechner@baylibre.com>
Signed-off-by: Jiasheng Jiang <jiashengjiangcool@gmail.com>
Link: https://patch.msgid.link/20241123220149.30655-1-jiashengjiangcool@gmail.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
authored by
Jiasheng Jiang
and committed by
Jonathan Cameron
c437190c
e895f2ed
+29
-19
+29
-19
drivers/iio/trigger/stm32-timer-trigger.c
+29
-19
drivers/iio/trigger/stm32-timer-trigger.c
···
119
119
unsigned int frequency)
120
120
{
121
121
unsigned long long prd, div;
122
-
int prescaler = 0;
122
+
int prescaler = 0, ret;
123
123
u32 ccer;
124
124
125
125
/* Period and prescaler values depends of clock rate */
···
150
150
if (ccer & TIM_CCER_CCXE)
151
151
return -EBUSY;
152
152
153
-
mutex_lock(&priv->lock);
153
+
guard(mutex)(&priv->lock);
154
154
if (!priv->enabled) {
155
155
priv->enabled = true;
156
-
clk_enable(priv->clk);
156
+
ret = clk_enable(priv->clk);
157
+
if (ret)
158
+
return ret;
157
159
}
158
160
159
161
regmap_write(priv->regmap, TIM_PSC, prescaler);
···
175
173
176
174
/* Enable controller */
177
175
regmap_set_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN);
178
-
mutex_unlock(&priv->lock);
179
176
180
177
return 0;
181
178
}
···
308
307
struct stm32_timer_trigger *priv = dev_get_drvdata(dev);
309
308
struct iio_trigger *trig = to_iio_trigger(dev);
310
309
u32 mask, shift, master_mode_max;
311
-
int i;
310
+
int i, ret;
312
311
313
312
if (stm32_timer_is_trgo2_name(trig->name)) {
314
313
mask = TIM_CR2_MMS2;
···
323
322
for (i = 0; i <= master_mode_max; i++) {
324
323
if (!strncmp(master_mode_table[i], buf,
325
324
strlen(master_mode_table[i]))) {
326
-
mutex_lock(&priv->lock);
325
+
guard(mutex)(&priv->lock);
327
326
if (!priv->enabled) {
328
327
/* Clock should be enabled first */
329
328
priv->enabled = true;
330
-
clk_enable(priv->clk);
329
+
ret = clk_enable(priv->clk);
330
+
if (ret)
331
+
return ret;
331
332
}
332
333
regmap_update_bits(priv->regmap, TIM_CR2, mask,
333
334
i << shift);
334
-
mutex_unlock(&priv->lock);
335
335
return len;
336
336
}
337
337
}
···
484
482
int val, int val2, long mask)
485
483
{
486
484
struct stm32_timer_trigger *priv = iio_priv(indio_dev);
485
+
int ret;
487
486
488
487
switch (mask) {
489
488
case IIO_CHAN_INFO_RAW:
···
494
491
/* fixed scale */
495
492
return -EINVAL;
496
493
497
-
case IIO_CHAN_INFO_ENABLE:
498
-
mutex_lock(&priv->lock);
494
+
case IIO_CHAN_INFO_ENABLE: {
495
+
guard(mutex)(&priv->lock);
499
496
if (val) {
500
497
if (!priv->enabled) {
501
498
priv->enabled = true;
502
-
clk_enable(priv->clk);
499
+
ret = clk_enable(priv->clk);
500
+
if (ret)
501
+
return ret;
503
502
}
504
503
regmap_set_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN);
505
504
} else {
···
511
506
clk_disable(priv->clk);
512
507
}
513
508
}
514
-
mutex_unlock(&priv->lock);
509
+
515
510
return 0;
516
511
}
517
-
518
-
return -EINVAL;
512
+
default:
513
+
return -EINVAL;
514
+
}
519
515
}
520
516
521
517
static int stm32_counter_validate_trigger(struct iio_dev *indio_dev,
···
608
602
{
609
603
struct stm32_timer_trigger *priv = iio_priv(indio_dev);
610
604
int sms = stm32_enable_mode2sms(mode);
605
+
int ret;
611
606
612
607
if (sms < 0)
613
608
return sms;
···
616
609
* Triggered mode sets CEN bit automatically by hardware. So, first
617
610
* enable counter clock, so it can use it. Keeps it in sync with CEN.
618
611
*/
619
-
mutex_lock(&priv->lock);
620
-
if (sms == 6 && !priv->enabled) {
621
-
clk_enable(priv->clk);
622
-
priv->enabled = true;
612
+
scoped_guard(mutex, &priv->lock) {
613
+
if (sms == 6 && !priv->enabled) {
614
+
ret = clk_enable(priv->clk);
615
+
if (ret)
616
+
return ret;
617
+
618
+
priv->enabled = true;
619
+
}
623
620
}
624
-
mutex_unlock(&priv->lock);
625
621
626
622
regmap_update_bits(priv->regmap, TIM_SMCR, TIM_SMCR_SMS, sms);
627
623