| Message ID | 20241108200900.44727-1-jiashengjiangcool@gmail.com (mailing list archive) |
|---|---|
| State | Changes Requested |
| Headers | show |
| Series | [v2] iio: trigger: stm32-timer-trigger: Add check for clk_enable() | expand |
On Fri, 8 Nov 2024 20:09:00 +0000 Jiasheng Jiang <jiashengjiangcool@gmail.com> wrote: > Add check for the return value of clk_enable() in order to catch the > potential exception. > > Signed-off-by: Jiasheng Jiang <jiashengjiangcool@gmail.com> Hi, In principle this is fine, but I'd rather we made use of guard() / scoped_guard() rather than adding the explicit unlocks. If you do that as a precursor patch in appropriate places in the driver then this will be a little cleaner. Note I'll not be taking this until next cycle now anyway. Jonathan > --- > Changelog: > > v1 -> v2: > > 1. Remove unsuitable dev_err_probe(). > --- > drivers/iio/trigger/stm32-timer-trigger.c | 32 ++++++++++++++++++----- > 1 file changed, 25 insertions(+), 7 deletions(-) > > diff --git a/drivers/iio/trigger/stm32-timer-trigger.c b/drivers/iio/trigger/stm32-timer-trigger.c > index 0684329956d9..e1e077122f73 100644 > --- a/drivers/iio/trigger/stm32-timer-trigger.c > +++ b/drivers/iio/trigger/stm32-timer-trigger.c > @@ -119,7 +119,7 @@ static int stm32_timer_start(struct stm32_timer_trigger *priv, > unsigned int frequency) > { > unsigned long long prd, div; > - int prescaler = 0; > + int prescaler = 0, ret; > u32 ccer; > > /* Period and prescaler values depends of clock rate */ > @@ -153,7 +153,11 @@ static int stm32_timer_start(struct stm32_timer_trigger *priv, > mutex_lock(&priv->lock); > if (!priv->enabled) { > priv->enabled = true; > - clk_enable(priv->clk); > + ret = clk_enable(priv->clk); > + if (ret) { > + mutex_unlock(&priv->lock); as below guard() for when the mutex is locked is cleaner. > + return ret; > + } > } > > regmap_write(priv->regmap, TIM_PSC, prescaler); > @@ -307,7 +311,7 @@ static ssize_t stm32_tt_store_master_mode(struct device *dev, > struct stm32_timer_trigger *priv = dev_get_drvdata(dev); > struct iio_trigger *trig = to_iio_trigger(dev); > u32 mask, shift, master_mode_max; > - int i; > + int i, ret; > > if (stm32_timer_is_trgo2_name(trig->name)) { > mask = TIM_CR2_MMS2; > @@ -326,7 +330,11 @@ static ssize_t stm32_tt_store_master_mode(struct device *dev, > if (!priv->enabled) { > /* Clock should be enabled first */ > priv->enabled = true; > - clk_enable(priv->clk); > + ret = clk_enable(priv->clk); > + if (ret) { > + mutex_unlock(&priv->lock); As below. Prefer use of guard() so we don't have to handle the unlock manually. > + return ret; > + } > } > regmap_update_bits(priv->regmap, TIM_CR2, mask, > i << shift); > @@ -482,6 +490,7 @@ static int stm32_counter_write_raw(struct iio_dev *indio_dev, > int val, int val2, long mask) > { > struct stm32_timer_trigger *priv = iio_priv(indio_dev); > + int ret; > > switch (mask) { > case IIO_CHAN_INFO_RAW: > @@ -496,7 +505,11 @@ static int stm32_counter_write_raw(struct iio_dev *indio_dev, > if (val) { > if (!priv->enabled) { > priv->enabled = true; > - clk_enable(priv->clk); > + ret = clk_enable(priv->clk); > + if (ret) { > + mutex_unlock(&priv->lock); Add include of cleanup.h and swithch the place where the mutex is locked to guard(mutex)(&priv->lock); then remember to drop the explicit unlocks. > + return ret; > + } > } > regmap_set_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN); > } else { > @@ -601,7 +614,7 @@ static int stm32_set_enable_mode(struct iio_dev *indio_dev, > unsigned int mode) > { > struct stm32_timer_trigger *priv = iio_priv(indio_dev); > - int sms = stm32_enable_mode2sms(mode); > + int sms = stm32_enable_mode2sms(mode), ret; > > if (sms < 0) > return sms; > @@ -611,7 +624,12 @@ static int stm32_set_enable_mode(struct iio_dev *indio_dev, > */ > mutex_lock(&priv->lock); Perhaps scoped_guard() is appropriate here. > if (sms == 6 && !priv->enabled) { > - clk_enable(priv->clk); > + ret = clk_enable(priv->clk); > + if (ret) { > + mutex_unlock(&priv->lock); > + return ret; > + } > + > priv->enabled = true; > } > mutex_unlock(&priv->lock);
On Sat, Nov 9, 2024 at 8:38 AM Jonathan Cameron <jic23@kernel.org> wrote: > > On Fri, 8 Nov 2024 20:09:00 +0000 > Jiasheng Jiang <jiashengjiangcool@gmail.com> wrote: > > > Add check for the return value of clk_enable() in order to catch the > > potential exception. > > > > Signed-off-by: Jiasheng Jiang <jiashengjiangcool@gmail.com> > Hi, > > In principle this is fine, but I'd rather we made use of guard() > / scoped_guard() rather than adding the explicit unlocks. > > If you do that as a precursor patch in appropriate places > in the driver then this will be a little cleaner. > > Note I'll not be taking this until next cycle now anyway. > > Jonathan > > > --- > > Changelog: > > > > v1 -> v2: > > > > 1. Remove unsuitable dev_err_probe(). > > --- > > drivers/iio/trigger/stm32-timer-trigger.c | 32 ++++++++++++++++++----- > > 1 file changed, 25 insertions(+), 7 deletions(-) > > > > diff --git a/drivers/iio/trigger/stm32-timer-trigger.c b/drivers/iio/trigger/stm32-timer-trigger.c > > index 0684329956d9..e1e077122f73 100644 > > --- a/drivers/iio/trigger/stm32-timer-trigger.c > > +++ b/drivers/iio/trigger/stm32-timer-trigger.c > > @@ -119,7 +119,7 @@ static int stm32_timer_start(struct stm32_timer_trigger *priv, > > unsigned int frequency) > > { > > unsigned long long prd, div; > > - int prescaler = 0; > > + int prescaler = 0, ret; > > u32 ccer; > > > > /* Period and prescaler values depends of clock rate */ > > @@ -153,7 +153,11 @@ static int stm32_timer_start(struct stm32_timer_trigger *priv, > > mutex_lock(&priv->lock); > > if (!priv->enabled) { > > priv->enabled = true; > > - clk_enable(priv->clk); > > + ret = clk_enable(priv->clk); > > + if (ret) { > > + mutex_unlock(&priv->lock); > > as below guard() for when the mutex is locked is cleaner. > > > + return ret; > > + } > > } > > > > regmap_write(priv->regmap, TIM_PSC, prescaler); > > @@ -307,7 +311,7 @@ static ssize_t stm32_tt_store_master_mode(struct device *dev, > > struct stm32_timer_trigger *priv = dev_get_drvdata(dev); > > struct iio_trigger *trig = to_iio_trigger(dev); > > u32 mask, shift, master_mode_max; > > - int i; > > + int i, ret; > > > > if (stm32_timer_is_trgo2_name(trig->name)) { > > mask = TIM_CR2_MMS2; > > @@ -326,7 +330,11 @@ static ssize_t stm32_tt_store_master_mode(struct device *dev, > > if (!priv->enabled) { > > /* Clock should be enabled first */ > > priv->enabled = true; > > - clk_enable(priv->clk); > > + ret = clk_enable(priv->clk); > > + if (ret) { > > + mutex_unlock(&priv->lock); > As below. Prefer use of guard() so we don't have to handle the unlock manually. > > + return ret; > > + } > > } > > regmap_update_bits(priv->regmap, TIM_CR2, mask, > > i << shift); > > @@ -482,6 +490,7 @@ static int stm32_counter_write_raw(struct iio_dev *indio_dev, > > int val, int val2, long mask) > > { > > struct stm32_timer_trigger *priv = iio_priv(indio_dev); > > + int ret; > > > > switch (mask) { > > case IIO_CHAN_INFO_RAW: > > @@ -496,7 +505,11 @@ static int stm32_counter_write_raw(struct iio_dev *indio_dev, > > if (val) { > > if (!priv->enabled) { > > priv->enabled = true; > > - clk_enable(priv->clk); > > + ret = clk_enable(priv->clk); > > + if (ret) { > > + mutex_unlock(&priv->lock); > Add include of cleanup.h and swithch the place where the mutex is locked to > guard(mutex)(&priv->lock); > then remember to drop the explicit unlocks. I found that cleanup.h is already included. Moreover, since labels cannot be followed by declarations, I encountered a compilation error when using guard(). Therefore, I switched to using scoped_guard(). > > > + return ret; > > + } > > } > > regmap_set_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN); > > } else { > > @@ -601,7 +614,7 @@ static int stm32_set_enable_mode(struct iio_dev *indio_dev, > > unsigned int mode) > > { > > struct stm32_timer_trigger *priv = iio_priv(indio_dev); > > - int sms = stm32_enable_mode2sms(mode); > > + int sms = stm32_enable_mode2sms(mode), ret; > > > > if (sms < 0) > > return sms; > > @@ -611,7 +624,12 @@ static int stm32_set_enable_mode(struct iio_dev *indio_dev, > > */ > > mutex_lock(&priv->lock); > > Perhaps scoped_guard() is appropriate here. > > > if (sms == 6 && !priv->enabled) { > > - clk_enable(priv->clk); > > + ret = clk_enable(priv->clk); > > + if (ret) { > > + mutex_unlock(&priv->lock); > > + return ret; > > + } > > + > > priv->enabled = true; > > } > > mutex_unlock(&priv->lock); > Thanks, I will submit a v2 to simplify code with cleanup helpers. -Jiasheng
diff --git a/drivers/iio/trigger/stm32-timer-trigger.c b/drivers/iio/trigger/stm32-timer-trigger.c index 0684329956d9..e1e077122f73 100644 --- a/drivers/iio/trigger/stm32-timer-trigger.c +++ b/drivers/iio/trigger/stm32-timer-trigger.c @@ -119,7 +119,7 @@ static int stm32_timer_start(struct stm32_timer_trigger *priv, unsigned int frequency) { unsigned long long prd, div; - int prescaler = 0; + int prescaler = 0, ret; u32 ccer; /* Period and prescaler values depends of clock rate */ @@ -153,7 +153,11 @@ static int stm32_timer_start(struct stm32_timer_trigger *priv, mutex_lock(&priv->lock); if (!priv->enabled) { priv->enabled = true; - clk_enable(priv->clk); + ret = clk_enable(priv->clk); + if (ret) { + mutex_unlock(&priv->lock); + return ret; + } } regmap_write(priv->regmap, TIM_PSC, prescaler); @@ -307,7 +311,7 @@ static ssize_t stm32_tt_store_master_mode(struct device *dev, struct stm32_timer_trigger *priv = dev_get_drvdata(dev); struct iio_trigger *trig = to_iio_trigger(dev); u32 mask, shift, master_mode_max; - int i; + int i, ret; if (stm32_timer_is_trgo2_name(trig->name)) { mask = TIM_CR2_MMS2; @@ -326,7 +330,11 @@ static ssize_t stm32_tt_store_master_mode(struct device *dev, if (!priv->enabled) { /* Clock should be enabled first */ priv->enabled = true; - clk_enable(priv->clk); + ret = clk_enable(priv->clk); + if (ret) { + mutex_unlock(&priv->lock); + return ret; + } } regmap_update_bits(priv->regmap, TIM_CR2, mask, i << shift); @@ -482,6 +490,7 @@ static int stm32_counter_write_raw(struct iio_dev *indio_dev, int val, int val2, long mask) { struct stm32_timer_trigger *priv = iio_priv(indio_dev); + int ret; switch (mask) { case IIO_CHAN_INFO_RAW: @@ -496,7 +505,11 @@ static int stm32_counter_write_raw(struct iio_dev *indio_dev, if (val) { if (!priv->enabled) { priv->enabled = true; - clk_enable(priv->clk); + ret = clk_enable(priv->clk); + if (ret) { + mutex_unlock(&priv->lock); + return ret; + } } regmap_set_bits(priv->regmap, TIM_CR1, TIM_CR1_CEN); } else { @@ -601,7 +614,7 @@ static int stm32_set_enable_mode(struct iio_dev *indio_dev, unsigned int mode) { struct stm32_timer_trigger *priv = iio_priv(indio_dev); - int sms = stm32_enable_mode2sms(mode); + int sms = stm32_enable_mode2sms(mode), ret; if (sms < 0) return sms; @@ -611,7 +624,12 @@ static int stm32_set_enable_mode(struct iio_dev *indio_dev, */ mutex_lock(&priv->lock); if (sms == 6 && !priv->enabled) { - clk_enable(priv->clk); + ret = clk_enable(priv->clk); + if (ret) { + mutex_unlock(&priv->lock); + return ret; + } + priv->enabled = true; } mutex_unlock(&priv->lock);
Add check for the return value of clk_enable() in order to catch the potential exception. Signed-off-by: Jiasheng Jiang <jiashengjiangcool@gmail.com> --- Changelog: v1 -> v2: 1. Remove unsuitable dev_err_probe(). --- drivers/iio/trigger/stm32-timer-trigger.c | 32 ++++++++++++++++++----- 1 file changed, 25 insertions(+), 7 deletions(-)