Commit 169dc2ad authored by David Lechner's avatar David Lechner Committed by Jonathan Cameron
Browse files

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: default avatarDavid Lechner <dlechner@baylibre.com>
Link: https://lore.kernel.org/r/20231010-ad2s1210-mainline-v5-3-35a0f6ffa04a@baylibre.com


Signed-off-by: default avatarJonathan Cameron <Jonathan.Cameron@huawei.com>
parent 4efa877a

drivers/staging/iio/resolver/ad2s1210.c

+49 −104
Original line number Diff line number Diff line
@@ -47,6 +47,7 @@ 


#include <linux/bitfield.h>

#include <linux/bits.h>

#include <linux/cleanup.h>

#include <linux/clk.h>

#include <linux/delay.h>

#include <linux/device.h>
@@ -447,7 +448,8 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev, 
	s64 timestamp;

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	ad2s1210_toggle_sample_line(st);

	timestamp = iio_get_time_ns(indio_dev);
@@ -459,14 +461,13 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev, 
		ret = ad2s1210_set_mode(st, MOD_VEL);

		break;

	default:

		ret = -EINVAL;

		break;

		return -EINVAL;

	}

	if (ret < 0)

		goto error_ret;

		return ret;

	ret = spi_read(st->sdev, &st->sample, 3);

	if (ret < 0)

		goto error_ret;

		return ret;



	switch (chan->type) {

	case IIO_ANGL:
@@ -478,14 +479,11 @@ static int ad2s1210_single_conversion(struct iio_dev *indio_dev, 
		ret = IIO_VAL_INT;

		break;

	default:

		ret = -EINVAL;

		break;

		return -EINVAL;

	}



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



error_ret:

	mutex_unlock(&st->lock);

	return ret;

}
@@ -493,11 +491,9 @@ static int ad2s1210_get_hysteresis(struct ad2s1210_state *st, int *val) 
{

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	ret = regmap_test_bits(st->regmap, AD2S1210_REG_CONTROL,

			       AD2S1210_ENABLE_HYSTERESIS);

	mutex_unlock(&st->lock);



	if (ret < 0)

		return ret;
@@ -507,15 +503,10 @@ static int ad2s1210_get_hysteresis(struct ad2s1210_state *st, int *val) 


static int ad2s1210_set_hysteresis(struct ad2s1210_state *st, int val)

{

	int ret;



	mutex_lock(&st->lock);

	ret = regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,

	guard(mutex)(&st->lock);

	return regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,

				  AD2S1210_ENABLE_HYSTERESIS,

				  val ? AD2S1210_ENABLE_HYSTERESIS : 0);

	mutex_unlock(&st->lock);



	return ret;

}



static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st,
@@ -523,11 +514,9 @@ static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st, 
{

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	ret = regmap_test_bits(st->regmap, AD2S1210_REG_CONTROL,

			       AD2S1210_PHASE_LOCK_RANGE_44);

	mutex_unlock(&st->lock);



	if (ret < 0)

		return ret;
@@ -547,7 +536,7 @@ static int ad2s1210_get_phase_lock_range(struct ad2s1210_state *st, 
static int ad2s1210_set_phase_lock_range(struct ad2s1210_state *st,

					 int val, int val2)

{

	int deg, ret;

	int deg;



	/* convert radians to degrees - only two allowable values */

	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, 
	else

		return -EINVAL;



	mutex_lock(&st->lock);

	ret = regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,

	guard(mutex)(&st->lock);

	return regmap_update_bits(st->regmap, AD2S1210_REG_CONTROL,

				  AD2S1210_PHASE_LOCK_RANGE_44,

				  deg == 44 ? AD2S1210_PHASE_LOCK_RANGE_44 : 0);

	mutex_unlock(&st->lock);

	return ret;

}



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

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	ret = regmap_read(st->regmap, reg, &reg_val);

	mutex_unlock(&st->lock);



	if (ret < 0)

		return ret;
@@ -595,15 +580,11 @@ static int ad2s1210_set_voltage_threshold(struct ad2s1210_state *st, 
					  unsigned int reg, int val)

{

	unsigned int reg_val;

	int ret;



	reg_val = val / THRESHOLD_MILLIVOLT_PER_LSB;



	mutex_lock(&st->lock);

	ret = regmap_write(st->regmap, reg, reg_val);

	mutex_unlock(&st->lock);



	return ret;

	guard(mutex)(&st->lock);

	return regmap_write(st->regmap, reg, reg_val);

}



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, 
	unsigned int reg_val;

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &reg_val);

	mutex_unlock(&st->lock);



	if (ret < 0)

		return ret;
@@ -634,18 +613,18 @@ static int ad2s1210_set_lot_high_threshold(struct ad2s1210_state *st, 
	if (val != 0)

		return -EINVAL;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	/*

	 * We need to read both high and low registers first so we can preserve

	 * the hysteresis.

	 */

	ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &high_reg_val);

	if (ret < 0)

		goto error_ret;

		return ret;



	ret = regmap_read(st->regmap, AD2S1210_REG_LOT_LOW_THRD, &low_reg_val);

	if (ret < 0)

		goto error_ret;

		return ret;



	hysteresis = high_reg_val - low_reg_val;

	high_reg_val = val2 / ad2s1210_lot_threshold_urad_per_lsb[st->resolution];
@@ -653,14 +632,9 @@ static int ad2s1210_set_lot_high_threshold(struct ad2s1210_state *st, 


	ret = regmap_write(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, high_reg_val);

	if (ret < 0)

		goto error_ret;



	ret = regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD, low_reg_val);



error_ret:

	mutex_unlock(&st->lock);



		return ret;



	return regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD, low_reg_val);

}



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, 
	unsigned int high_reg_val, low_reg_val;

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &high_reg_val);

	if (ret < 0)

		goto error_ret;

		return ret;



	ret = regmap_read(st->regmap, AD2S1210_REG_LOT_LOW_THRD, &low_reg_val);



error_ret:

	mutex_unlock(&st->lock);



	if (ret < 0)

		return ret;
@@ -701,18 +672,14 @@ static int ad2s1210_set_lot_low_threshold(struct ad2s1210_state *st, 


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



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	ret = regmap_read(st->regmap, AD2S1210_REG_LOT_HIGH_THRD, &reg_val);

	if (ret < 0)

		goto error_ret;

		return ret;



	ret = regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD,

	return regmap_write(st->regmap, AD2S1210_REG_LOT_LOW_THRD,

			   reg_val - hysteresis);



error_ret:

	mutex_unlock(&st->lock);



	return ret;

}



static int ad2s1210_get_excitation_frequency(struct ad2s1210_state *st, int *val)
@@ -720,31 +687,23 @@ static int ad2s1210_get_excitation_frequency(struct ad2s1210_state *st, int *val 
	unsigned int reg_val;

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	ret = regmap_read(st->regmap, AD2S1210_REG_EXCIT_FREQ, &reg_val);

	if (ret < 0)

		goto error_ret;

		return ret;



	*val = reg_val * st->clkin_hz / (1 << 15);

	ret = IIO_VAL_INT;



error_ret:

	mutex_unlock(&st->lock);

	return ret;

	return IIO_VAL_INT;

}



static int ad2s1210_set_excitation_frequency(struct ad2s1210_state *st, int val)

{

	int ret;



	if (val < AD2S1210_MIN_EXCIT || val > AD2S1210_MAX_EXCIT)

		return -EINVAL;



	mutex_lock(&st->lock);

	ret = ad2s1210_reinit_excitation_frequency(st, val);

	mutex_unlock(&st->lock);



	return ret;

	guard(mutex)(&st->lock);

	return ad2s1210_reinit_excitation_frequency(st, val);

}



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

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	ret = regmap_read(st->regmap, iattr->address, &value);

	mutex_unlock(&st->lock);



	if (ret < 0)

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

		return -EINVAL;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);

	ret = regmap_write(st->regmap, iattr->address,

			   data / THRESHOLD_MILLIVOLT_PER_LSB);

	mutex_unlock(&st->lock);



	if (ret < 0)

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

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	/* Use default config register value plus resolution from devicetree. */

	data = FIELD_PREP(AD2S1210_PHASE_LOCK_RANGE_44, 1);
@@ -1131,13 +1086,9 @@ static int ad2s1210_initial(struct ad2s1210_state *st) 


	ret = regmap_write(st->regmap, AD2S1210_REG_CONTROL, data);

	if (ret < 0)

		goto error_ret;



	ret = ad2s1210_reinit_excitation_frequency(st, AD2S1210_DEF_EXCIT);



error_ret:

	mutex_unlock(&st->lock);

		return ret;



	return ad2s1210_reinit_excitation_frequency(st, AD2S1210_DEF_EXCIT);

}



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, 
				       unsigned int *readval)

{

	struct ad2s1210_state *st = iio_priv(indio_dev);

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	if (readval)

		ret = regmap_read(st->regmap, reg, readval);

	else

		ret = regmap_write(st->regmap, reg, writeval);

		return regmap_read(st->regmap, reg, readval);



	mutex_unlock(&st->lock);



	return ret;

	return regmap_write(st->regmap, reg, writeval);

}



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

	int ret;



	mutex_lock(&st->lock);

	guard(mutex)(&st->lock);



	memset(&st->scan, 0, sizeof(st->scan));

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



error_ret:

	mutex_unlock(&st->lock);

	iio_trigger_notify_done(indio_dev->trig);



	return IRQ_HANDLED;