Skip to content

Commit 169dc2a

Browse files
dlechjic23
dlech
authored and
jic23
committed
staging: iio: resolver: ad2s1210: simplify code with guard(mutex)
We can simplify the code and get rid of most of the gotos by using guard(mutex) from cleanup.h. Signed-off-by: David Lechner <dlechner@baylibre.com> Link: https://lore.kernel.org/r/20231010-ad2s1210-mainline-v5-3-35a0f6ffa04a@baylibre.com Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>
1 parent 4efa877 commit 169dc2a

1 file changed

Lines changed: 49 additions & 104 deletions

File tree

‎drivers/staging/iio/resolver/ad2s1210.c‎

Lines changed: 49 additions & 104 deletions
Original file line numberDiff line numberDiff line change
@@ -47,6 +47,7 @@
4747

4848
#include <linux/bitfield.h>
4949
#include <linux/bits.h>
50+
#include <linux/cleanup.h>
5051
#include <linux/clk.h>
5152
#include <linux/delay.h>
5253
#include <linux/device.h>
@@ -447,7 +448,8 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev,
447448
s64 timestamp;
448449
int ret;
449450

450-
mutex_lock(&st->lock);
451+
guard(mutex)(&st->lock);
452+
451453
ad2s1210_toggle_sample_line(st);
452454
timestamp = iio_get_time_ns(indio_dev);
453455

@@ -459,14 +461,13 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev,
459461
ret = ad2s1210_set_mode(st, MOD_VEL);
460462
break;
461463
default:
462-
ret = -EINVAL;
463-
break;
464+
return -EINVAL;
464465
}
465466
if (ret < 0)
466-
goto error_ret;
467+
return ret;
467468
ret = spi_read(st->sdev, &st->sample, 3);
468469
if (ret < 0)
469-
goto error_ret;
470+
return ret;
470471

471472
switch (chan->type) {
472473
case IIO_ANGL:
@@ -478,26 +479,21 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev,
478479
ret = IIO_VAL_INT;
479480
break;
480481
default:
481-
ret = -EINVAL;
482-
break;
482+
return -EINVAL;
483483
}
484484

485485
ad2s1210_push_events(indio_dev, st->sample.fault, timestamp);
486486

487-
error_ret:
488-
mutex_unlock(&st->lock);
489487
return ret;
490488
}
491489

492490
static int ad2s1210_get_hysteresis(struct ad2s1210_state *st, int *val)
493491
{
494492
int ret;
495493

496-
mutex_lock(&st->lock);
494+
guard(mutex)(&st->lock);
497495
ret = regmap_test_bits(st->regmap, AD2S1210_REG_CONTROL,
498496
AD2S1210_ENABLE_HYSTERESIS);
499-
mutex_unlock(&st->lock);
500-
501497
if (ret < 0)
502498
return ret;
503499

@@ -507,27 +503,20 @@ static int ad2s1210_get_hysteresis(struct ad2s1210_state *st, int *val)
507503

508504
static int ad2s1210_set_hysteresis(struct ad2s1210_state *st, int val)
509505
{
510-
int ret;
511-
512-
mutex_lock(&st->lock);
513-
ret = regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
514-
AD2S1210_ENABLE_HYSTERESIS,
515-
val ? AD2S1210_ENABLE_HYSTERESIS : 0);
516-
mutex_unlock(&st->lock);
517-
518-
return ret;
506+
guard(mutex)(&st->lock);
507+
return regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
508+
AD2S1210_ENABLE_HYSTERESIS,
509+
val ? AD2S1210_ENABLE_HYSTERESIS : 0);
519510
}
520511

521512
static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st,
522513
int *val, int *val2)
523514
{
524515
int ret;
525516

526-
mutex_lock(&st->lock);
517+
guard(mutex)(&st->lock);
527518
ret = regmap_test_bits(st->regmap, AD2S1210_REG_CONTROL,
528519
AD2S1210_PHASE_LOCK_RANGE_44);
529-
mutex_unlock(&st->lock);
530-
531520
if (ret < 0)
532521
return ret;
533522

@@ -547,7 +536,7 @@ static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st,
547536
static int ad2s1210_set_phase_lock_range(struct ad2s1210_state *st,
548537
int val, int val2)
549538
{
550-
int deg, ret;
539+
int deg;
551540

552541
/* convert radians to degrees - only two allowable values */
553542
if (val == PHASE_44_DEG_TO_RAD_INT && val2 == PHASE_44_DEG_TO_RAD_MICRO)
@@ -558,12 +547,10 @@ static int ad2s1210_set_phase_lock_range(struct ad2s1210_state *st,
558547
else
559548
return -EINVAL;
560549

561-
mutex_lock(&st->lock);
562-
ret = regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
563-
AD2S1210_PHASE_LOCK_RANGE_44,
564-
deg == 44 ? AD2S1210_PHASE_LOCK_RANGE_44 : 0);
565-
mutex_unlock(&st->lock);
566-
return ret;
550+
guard(mutex)(&st->lock);
551+
return regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,
552+
AD2S1210_PHASE_LOCK_RANGE_44,
553+
deg == 44 ? AD2S1210_PHASE_LOCK_RANGE_44 : 0);
567554
}
568555

569556
/* map resolution to microradians/LSB for LOT registers */
@@ -580,10 +567,8 @@ static int ad2s1210_get_voltage_threshold(struct ad2s1210_state *st,
580567
unsigned int reg_val;
581568
int ret;
582569

583-
mutex_lock(&st->lock);
570+
guard(mutex)(&st->lock);
584571
ret = regmap_read(st->regmap, reg, &reg_val);
585-
mutex_unlock(&st->lock);
586-
587572
if (ret < 0)
588573
return ret;
589574

@@ -595,15 +580,11 @@ static int ad2s1210_set_voltage_threshold(struct ad2s1210_state *st,
595580
unsigned int reg, int val)
596581
{
597582
unsigned int reg_val;
598-
int ret;
599583

600584
reg_val = val / THRESHOLD_MILLIVOLT_PER_LSB;
601585

602-
mutex_lock(&st->lock);
603-
ret = regmap_write(st->regmap, reg, reg_val);
604-
mutex_unlock(&st->lock);
605-
606-
return ret;
586+
guard(mutex)(&st->lock);
587+
return regmap_write(st->regmap, reg, reg_val);
607588
}
608589

609590
static int ad2s1210_get_lot_high_threshold(struct ad2s1210_state *st,
@@ -612,10 +593,8 @@ static int ad2s1210_get_lot_high_threshold(struct ad2s1210_state *st,
612593
unsigned int reg_val;
613594
int ret;
614595

615-
mutex_lock(&st->lock);
596+
guard(mutex)(&st->lock);
616597
ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &reg_val);
617-
mutex_unlock(&st->lock);
618-
619598
if (ret < 0)
620599
return ret;
621600

@@ -634,33 +613,28 @@ static int ad2s1210_set_lot_high_threshold(struct ad2s1210_state *st,
634613
if (val != 0)
635614
return -EINVAL;
636615

637-
mutex_lock(&st->lock);
616+
guard(mutex)(&st->lock);
638617
/*
639618
* We need to read both high and low registers first so we can preserve
640619
* the hysteresis.
641620
*/
642621
ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &high_reg_val);
643622
if (ret < 0)
644-
goto error_ret;
623+
return ret;
645624

646625
ret = regmap_read(st->regmap, AD2S1210_REG_LOT_LOW_THRD, &low_reg_val);
647626
if (ret < 0)
648-
goto error_ret;
627+
return ret;
649628

650629
hysteresis = high_reg_val - low_reg_val;
651630
high_reg_val = val2 / ad2s1210_lot_threshold_urad_per_lsb[st->resolution];
652631
low_reg_val = high_reg_val - hysteresis;
653632

654633
ret = regmap_write(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, high_reg_val);
655634
if (ret < 0)
656-
goto error_ret;
657-
658-
ret = regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD, low_reg_val);
659-
660-
error_ret:
661-
mutex_unlock(&st->lock);
635+
return ret;
662636

663-
return ret;
637+
return regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD, low_reg_val);
664638
}
665639

666640
static int ad2s1210_get_lot_low_threshold(struct ad2s1210_state *st,
@@ -669,16 +643,13 @@ static int ad2s1210_get_lot_low_threshold(struct ad2s1210_state *st,
669643
unsigned int high_reg_val, low_reg_val;
670644
int ret;
671645

672-
mutex_lock(&st->lock);
646+
guard(mutex)(&st->lock);
647+
673648
ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &high_reg_val);
674649
if (ret < 0)
675-
goto error_ret;
650+
return ret;
676651

677652
ret = regmap_read(st->regmap, AD2S1210_REG_LOT_LOW_THRD, &low_reg_val);
678-
679-
error_ret:
680-
mutex_unlock(&st->lock);
681-
682653
if (ret < 0)
683654
return ret;
684655

@@ -701,50 +672,38 @@ static int ad2s1210_set_lot_low_threshold(struct ad2s1210_state *st,
701672

702673
hysteresis = val2 / ad2s1210_lot_threshold_urad_per_lsb[st->resolution];
703674

704-
mutex_lock(&st->lock);
675+
guard(mutex)(&st->lock);
676+
705677
ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &reg_val);
706678
if (ret < 0)
707-
goto error_ret;
679+
return ret;
708680

709-
ret = regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD,
681+
return regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD,
710682
reg_val - hysteresis);
711-
712-
error_ret:
713-
mutex_unlock(&st->lock);
714-
715-
return ret;
716683
}
717684

718685
static int ad2s1210_get_excitation_frequency(struct ad2s1210_state *st, int *val)
719686
{
720687
unsigned int reg_val;
721688
int ret;
722689

723-
mutex_lock(&st->lock);
690+
guard(mutex)(&st->lock);
691+
724692
ret = regmap_read(st->regmap, AD2S1210_REG_EXCIT_FREQ, &reg_val);
725693
if (ret < 0)
726-
goto error_ret;
694+
return ret;
727695

728696
*val = reg_val * st->clkin_hz / (1 << 15);
729-
ret = IIO_VAL_INT;
730-
731-
error_ret:
732-
mutex_unlock(&st->lock);
733-
return ret;
697+
return IIO_VAL_INT;
734698
}
735699

736700
static int ad2s1210_set_excitation_frequency(struct ad2s1210_state *st, int val)
737701
{
738-
int ret;
739-
740702
if (val < AD2S1210_MIN_EXCIT || val > AD2S1210_MAX_EXCIT)
741703
return -EINVAL;
742704

743-
mutex_lock(&st->lock);
744-
ret = ad2s1210_reinit_excitation_frequency(st, val);
745-
mutex_unlock(&st->lock);
746-
747-
return ret;
705+
guard(mutex)(&st->lock);
706+
return ad2s1210_reinit_excitation_frequency(st, val);
748707
}
749708

750709
static const int ad2s1210_velocity_scale[] = {
@@ -1020,10 +979,8 @@ static ssize_t event_attr_voltage_reg_show(struct device *dev,
1020979
unsigned int value;
1021980
int ret;
1022981

1023-
mutex_lock(&st->lock);
982+
guard(mutex)(&st->lock);
1024983
ret = regmap_read(st->regmap, iattr->address, &value);
1025-
mutex_unlock(&st->lock);
1026-
1027984
if (ret < 0)
1028985
return ret;
1029986

@@ -1043,11 +1000,9 @@ static ssize_t event_attr_voltage_reg_store(struct device *dev,
10431000
if (ret)
10441001
return -EINVAL;
10451002

1046-
mutex_lock(&st->lock);
1003+
guard(mutex)(&st->lock);
10471004
ret = regmap_write(st->regmap, iattr->address,
10481005
data / THRESHOLD_MILLIVOLT_PER_LSB);
1049-
mutex_unlock(&st->lock);
1050-
10511006
if (ret < 0)
10521007
return ret;
10531008

@@ -1121,7 +1076,7 @@ static int ad2s1210_initial(struct ad2s1210_state *st)
11211076
unsigned int data;
11221077
int ret;
11231078

1124-
mutex_lock(&st->lock);
1079+
guard(mutex)(&st->lock);
11251080

11261081
/* Use default config register value plus resolution from devicetree. */
11271082
data = FIELD_PREP(AD2S1210_PHASE_LOCK_RANGE_44, 1);
@@ -1131,13 +1086,9 @@ static int ad2s1210_initial(struct ad2s1210_state *st)
11311086

11321087
ret = regmap_write(st->regmap, AD2S1210_REG_CONTROL, data);
11331088
if (ret < 0)
1134-
goto error_ret;
1135-
1136-
ret = ad2s1210_reinit_excitation_frequency(st, AD2S1210_DEF_EXCIT);
1089+
return ret;
11371090

1138-
error_ret:
1139-
mutex_unlock(&st->lock);
1140-
return ret;
1091+
return ad2s1210_reinit_excitation_frequency(st, AD2S1210_DEF_EXCIT);
11411092
}
11421093

11431094
static int ad2s1210_read_label(struct iio_dev *indio_dev,
@@ -1281,18 +1232,13 @@ static int ad2s1210_debugfs_reg_access(struct iio_dev *indio_dev,
12811232
unsigned int *readval)
12821233
{
12831234
struct ad2s1210_state *st = iio_priv(indio_dev);
1284-
int ret;
12851235

1286-
mutex_lock(&st->lock);
1236+
guard(mutex)(&st->lock);
12871237

12881238
if (readval)
1289-
ret = regmap_read(st->regmap, reg, readval);
1290-
else
1291-
ret = regmap_write(st->regmap, reg, writeval);
1292-
1293-
mutex_unlock(&st->lock);
1239+
return regmap_read(st->regmap, reg, readval);
12941240

1295-
return ret;
1241+
return regmap_write(st->regmap, reg, writeval);
12961242
}
12971243

12981244
static irqreturn_t ad2s1210_trigger_handler(int irq, void *p)
@@ -1303,7 +1249,7 @@ static irqreturn_t ad2s1210_trigger_handler(int irq, void *p)
13031249
size_t chan = 0;
13041250
int ret;
13051251

1306-
mutex_lock(&st->lock);
1252+
guard(mutex)(&st->lock);
13071253

13081254
memset(&st->scan, 0, sizeof(st->scan));
13091255
ad2s1210_toggle_sample_line(st);
@@ -1336,7 +1282,6 @@ static irqreturn_t ad2s1210_trigger_handler(int irq, void *p)
13361282
iio_push_to_buffers_with_timestamp(indio_dev, &st->scan, pf->timestamp);
13371283

13381284
error_ret:
1339-
mutex_unlock(&st->lock);
13401285
iio_trigger_notify_done(indio_dev->trig);
13411286

13421287
return IRQ_HANDLED;

0 commit comments

Comments
 (0)