| Message ID | 4067fc67ef617edbaea0de21241d59d6ff8eaf98.1737985435.git.Jonathan.Santos@analog.com (mailing list archive) |
|---|---|
| State | Changes Requested |
| Headers | show |
| Series | Add features, improvements, and fixes | expand |
On 1/27/25 9:13 AM, Jonathan Santos wrote: > From: Sergiu Cuciurean <sergiu.cuciurean@analog.com> > > The AD7768-1 has the ability to control other local hardware (such as gain > stages),to power down other blocks in the signal chain, or read local > status signals over the SPI interface. > > This change exports the AD7768-1's four gpios and makes them accessible > at an upper layer. > > Co-developed-by: Jonathan Santos <Jonathan.Santos@analog.com> > Signed-off-by: Jonathan Santos <Jonathan.Santos@analog.com> > Signed-off-by: Sergiu Cuciurean <sergiu.cuciurean@analog.com> > --- > v2 Changes: > * Replaced mutex for iio_device_claim_direct_mode(). > * Use gpio-controller property to conditionally enable the > GPIO support. > * OBS: when the GPIO is configured as output, we should read > the current state value from AD7768_REG_GPIO_WRITE. > --- > drivers/iio/adc/ad7768-1.c | 148 ++++++++++++++++++++++++++++++++++++- > 1 file changed, 146 insertions(+), 2 deletions(-) > > diff --git a/drivers/iio/adc/ad7768-1.c b/drivers/iio/adc/ad7768-1.c > index c540583808c2..e3ea078e6ec4 100644 > --- a/drivers/iio/adc/ad7768-1.c > +++ b/drivers/iio/adc/ad7768-1.c > @@ -9,6 +9,8 @@ > #include <linux/delay.h> > #include <linux/device.h> > #include <linux/err.h> > +#include <linux/gpio.h> > +#include <linux/gpio/driver.h> > #include <linux/gpio/consumer.h> > #include <linux/kernel.h> > #include <linux/module.h> > @@ -79,6 +81,19 @@ > #define AD7768_CONV_MODE_MSK GENMASK(2, 0) > #define AD7768_CONV_MODE(x) FIELD_PREP(AD7768_CONV_MODE_MSK, x) > > +/* AD7768_REG_GPIO_CONTROL */ > +#define AD7768_GPIO_UNIVERSAL_EN BIT(7) > +#define AD7768_GPIO_CONTROL_MSK GENMASK(3, 0) > + > +/* AD7768_REG_GPIO_WRITE */ > +#define AD7768_GPIO_WRITE_MSK GENMASK(3, 0) > + > +/* AD7768_REG_GPIO_READ */ > +#define AD7768_GPIO_READ_MSK GENMASK(3, 0) > + > +#define AD7768_GPIO_INPUT(x) 0x00 > +#define AD7768_GPIO_OUTPUT(x) BIT(x) > + > #define AD7768_RD_FLAG_MSK(x) (BIT(6) | ((x) & 0x3F)) > #define AD7768_WR_FLAG_MSK(x) ((x) & 0x3F) > > @@ -160,6 +175,8 @@ struct ad7768_state { > struct regulator *vref; > struct mutex lock; > struct clk *mclk; > + struct gpio_chip gpiochip; > + unsigned int gpio_avail_map; > unsigned int mclk_freq; > unsigned int samp_freq; > struct completion completion; > @@ -309,6 +326,125 @@ static int ad7768_set_dig_fil(struct ad7768_state *st, > return 0; > } > > +static int ad7768_gpio_direction_input(struct gpio_chip *chip, unsigned int offset) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return ret; Missing iio_device_release_direct_mode() here and in other functions. (And we are in the process of removing iio_device_claim_direct_scoped(), so don't use that.) > + > + return regmap_update_bits(st->regmap, > + AD7768_REG_GPIO_CONTROL, > + BIT(offset), > + AD7768_GPIO_INPUT(offset)); Can be simplified to regmap_clear_bits(), then we can get rid of the odd AD7768_GPIO_INPUT macro that ignores the argument. > +} > + > +static int ad7768_gpio_direction_output(struct gpio_chip *chip, > + unsigned int offset, int value) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return ret; > + > + return regmap_update_bits(st->regmap, > + AD7768_REG_GPIO_CONTROL, > + BIT(offset), > + AD7768_GPIO_OUTPUT(offset)); And regmap_set_bits() here. > +} > + > +static int ad7768_gpio_get(struct gpio_chip *chip, unsigned int offset) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + unsigned int val; > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return ret; > + > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); > + if (ret < 0) > + return ret; > + > + if (val & BIT(offset)) > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_WRITE, &val); > + else > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_READ, &val); Can we get a comment explaining why GPIO_READ doesn't work in output mode? Or if it does work, we can simplify this function. > + if (ret < 0) > + return ret; > + > + return !!(val & BIT(offset)); > +} > + > +static void ad7768_gpio_set(struct gpio_chip *chip, unsigned int offset, int value) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + unsigned int val; > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return; > + > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); > + if (ret < 0) > + return; > + > + if (val & BIT(offset)) > + regmap_update_bits(st->regmap, > + AD7768_REG_GPIO_WRITE, > + BIT(offset), > + (value << offset)); Can remove extra (). > +} > + > +static int ad7768_gpio_request(struct gpio_chip *chip, unsigned int offset) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + > + if (!(st->gpio_avail_map & BIT(offset))) > + return -ENODEV; > + > + st->gpio_avail_map &= ~BIT(offset); Is this really needed? It seems like GPIO core would be keeping track already. Also would need a .free callback to undo this action. It seems like most ADC's with GPIO controllers don't implement .request though. > + > + return 0; > +} > +
On Mon, 27 Jan 2025 12:13:45 -0300 Jonathan Santos <Jonathan.Santos@analog.com> wrote: > From: Sergiu Cuciurean <sergiu.cuciurean@analog.com> > > The AD7768-1 has the ability to control other local hardware (such as gain > stages),to power down other blocks in the signal chain, or read local > status signals over the SPI interface. > > This change exports the AD7768-1's four gpios and makes them accessible > at an upper layer. > > Co-developed-by: Jonathan Santos <Jonathan.Santos@analog.com> > Signed-off-by: Jonathan Santos <Jonathan.Santos@analog.com> > Signed-off-by: Sergiu Cuciurean <sergiu.cuciurean@analog.com> As David observed, the direct mode release calls are missing. Also, there are a few places where you wrap lines much shorter than needed. > +static int ad7768_gpio_direction_output(struct gpio_chip *chip, > + unsigned int offset, int value) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); > + if (ret) > + return ret; > + > + return regmap_update_bits(st->regmap, > + AD7768_REG_GPIO_CONTROL, > + BIT(offset), > + AD7768_GPIO_OUTPUT(offset)); Again, wrap less. > +} > + > +static int ad7768_gpio_get(struct gpio_chip *chip, unsigned int offset) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + unsigned int val; > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); You aren't releasing it. That should have deadlocked the second time you called this. > + if (ret) > + return ret; > + > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); > + if (ret < 0) > + return ret; > + > + if (val & BIT(offset)) > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_WRITE, &val); > + else > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_READ, &val); > + if (ret < 0) > + return ret; > + > + return !!(val & BIT(offset)); > +} > + > +static void ad7768_gpio_set(struct gpio_chip *chip, unsigned int offset, int value) > +{ > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > + struct ad7768_state *st = iio_priv(indio_dev); > + unsigned int val; > + int ret; > + > + ret = iio_device_claim_direct_mode(indio_dev); As above, needs a matching release. May mean you want to factor out the guts of this as a helper function so you can still do direct returns on error. > + if (ret) > + return; > + > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); > + if (ret < 0) > + return; > + > + if (val & BIT(offset)) > + regmap_update_bits(st->regmap, > + AD7768_REG_GPIO_WRITE, > + BIT(offset), > + (value << offset)); Wrap a little less and drop the unnecessary brackets. regmap_update_bits(st->regmap, AD7768_REG_GPIO_WRITE, BIT(offset), value << offset); Also, check return value? > +} > + > + > +static int ad7768_gpio_init(struct iio_dev *indio_dev) > +{ > + struct ad7768_state *st = iio_priv(indio_dev); > + int ret; > + > + ret = regmap_write(st->regmap, AD7768_REG_GPIO_CONTROL, > + AD7768_GPIO_UNIVERSAL_EN); > + if (ret < 0) > + return ret; > + > + st->gpio_avail_map = AD7768_GPIO_CONTROL_MSK; > + st->gpiochip.label = "ad7768_1_gpios"; > + st->gpiochip.base = -1; > + st->gpiochip.ngpio = 4; > + st->gpiochip.parent = &st->spi->dev; > + st->gpiochip.can_sleep = true; > + st->gpiochip.direction_input = ad7768_gpio_direction_input; > + st->gpiochip.direction_output = ad7768_gpio_direction_output; > + st->gpiochip.get = ad7768_gpio_get; > + st->gpiochip.set = ad7768_gpio_set; > + st->gpiochip.request = ad7768_gpio_request; > + st->gpiochip.owner = THIS_MODULE; Might not be worth it but I'd be tempted to do st->gpiochip = (struct gpio_chip) { .label = "ad7768_1_gpios", .base = -1, .ngpio = 4, ... }; perhaps. This one is entirely up to your preference. > + > + return gpiochip_add_data(&st->gpiochip, indio_dev); > +} > +
On 01/27, David Lechner wrote: > On 1/27/25 9:13 AM, Jonathan Santos wrote: > > From: Sergiu Cuciurean <sergiu.cuciurean@analog.com> > > > > The AD7768-1 has the ability to control other local hardware (such as gain > > stages),to power down other blocks in the signal chain, or read local > > status signals over the SPI interface. > > > > This change exports the AD7768-1's four gpios and makes them accessible > > at an upper layer. > > > > Co-developed-by: Jonathan Santos <Jonathan.Santos@analog.com> > > Signed-off-by: Jonathan Santos <Jonathan.Santos@analog.com> > > Signed-off-by: Sergiu Cuciurean <sergiu.cuciurean@analog.com> > > --- > > v2 Changes: > > * Replaced mutex for iio_device_claim_direct_mode(). > > * Use gpio-controller property to conditionally enable the > > GPIO support. > > * OBS: when the GPIO is configured as output, we should read > > the current state value from AD7768_REG_GPIO_WRITE. > > --- > > drivers/iio/adc/ad7768-1.c | 148 ++++++++++++++++++++++++++++++++++++- > > 1 file changed, 146 insertions(+), 2 deletions(-) > > > > diff --git a/drivers/iio/adc/ad7768-1.c b/drivers/iio/adc/ad7768-1.c > > index c540583808c2..e3ea078e6ec4 100644 > > --- a/drivers/iio/adc/ad7768-1.c > > +++ b/drivers/iio/adc/ad7768-1.c > > @@ -9,6 +9,8 @@ > > #include <linux/delay.h> > > #include <linux/device.h> > > #include <linux/err.h> > > +#include <linux/gpio.h> > > +#include <linux/gpio/driver.h> > > #include <linux/gpio/consumer.h> > > #include <linux/kernel.h> > > #include <linux/module.h> > > @@ -79,6 +81,19 @@ > > #define AD7768_CONV_MODE_MSK GENMASK(2, 0) > > #define AD7768_CONV_MODE(x) FIELD_PREP(AD7768_CONV_MODE_MSK, x) > > > > +/* AD7768_REG_GPIO_CONTROL */ > > +#define AD7768_GPIO_UNIVERSAL_EN BIT(7) > > +#define AD7768_GPIO_CONTROL_MSK GENMASK(3, 0) > > + > > +/* AD7768_REG_GPIO_WRITE */ > > +#define AD7768_GPIO_WRITE_MSK GENMASK(3, 0) > > + > > +/* AD7768_REG_GPIO_READ */ > > +#define AD7768_GPIO_READ_MSK GENMASK(3, 0) > > + > > +#define AD7768_GPIO_INPUT(x) 0x00 > > +#define AD7768_GPIO_OUTPUT(x) BIT(x) > > + > > #define AD7768_RD_FLAG_MSK(x) (BIT(6) | ((x) & 0x3F)) > > #define AD7768_WR_FLAG_MSK(x) ((x) & 0x3F) > > > > @@ -160,6 +175,8 @@ struct ad7768_state { > > struct regulator *vref; > > struct mutex lock; > > struct clk *mclk; > > + struct gpio_chip gpiochip; > > + unsigned int gpio_avail_map; > > unsigned int mclk_freq; > > unsigned int samp_freq; > > struct completion completion; > > @@ -309,6 +326,125 @@ static int ad7768_set_dig_fil(struct ad7768_state *st, > > return 0; > > } > > > > +static int ad7768_gpio_direction_input(struct gpio_chip *chip, unsigned int offset) > > +{ > > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > > + struct ad7768_state *st = iio_priv(indio_dev); > > + int ret; > > + > > + ret = iio_device_claim_direct_mode(indio_dev); > > + if (ret) > > + return ret; > > Missing iio_device_release_direct_mode() here and in other functions. > > (And we are in the process of removing iio_device_claim_direct_scoped(), so > don't use that.) > Sure, my mistake. I am fixing this. > > + > > + return regmap_update_bits(st->regmap, > > + AD7768_REG_GPIO_CONTROL, > > + BIT(offset), > > + AD7768_GPIO_INPUT(offset)); > > Can be simplified to regmap_clear_bits(), then we can get rid of the odd > AD7768_GPIO_INPUT macro that ignores the argument. > > > +} > > + > > +static int ad7768_gpio_direction_output(struct gpio_chip *chip, > > + unsigned int offset, int value) > > +{ > > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > > + struct ad7768_state *st = iio_priv(indio_dev); > > + int ret; > > + > > + ret = iio_device_claim_direct_mode(indio_dev); > > + if (ret) > > + return ret; > > + > > + return regmap_update_bits(st->regmap, > > + AD7768_REG_GPIO_CONTROL, > > + BIT(offset), > > + AD7768_GPIO_OUTPUT(offset)); > > And regmap_set_bits() here. > > > +} > > + > > +static int ad7768_gpio_get(struct gpio_chip *chip, unsigned int offset) > > +{ > > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > > + struct ad7768_state *st = iio_priv(indio_dev); > > + unsigned int val; > > + int ret; > > + > > + ret = iio_device_claim_direct_mode(indio_dev); > > + if (ret) > > + return ret; > > + > > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); > > + if (ret < 0) > > + return ret; > > + > > + if (val & BIT(offset)) > > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_WRITE, &val); > > + else > > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_READ, &val); > > Can we get a comment explaining why GPIO_READ doesn't work in output mode? > > Or if it does work, we can simplify this function. > > The datasheet does not mention this; I reached this conclusion through testing. It seems they separate the output state from the read register. Anyway, I will add a comment. > > + if (ret < 0) > > + return ret; > > + > > + return !!(val & BIT(offset)); > > +} > > + > > +static void ad7768_gpio_set(struct gpio_chip *chip, unsigned int offset, int value) > > +{ > > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > > + struct ad7768_state *st = iio_priv(indio_dev); > > + unsigned int val; > > + int ret; > > + > > + ret = iio_device_claim_direct_mode(indio_dev); > > + if (ret) > > + return; > > + > > + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); > > + if (ret < 0) > > + return; > > + > > + if (val & BIT(offset)) > > + regmap_update_bits(st->regmap, > > + AD7768_REG_GPIO_WRITE, > > + BIT(offset), > > + (value << offset)); > > Can remove extra (). > > > +} > > + > > +static int ad7768_gpio_request(struct gpio_chip *chip, unsigned int offset) > > +{ > > + struct iio_dev *indio_dev = gpiochip_get_data(chip); > > + struct ad7768_state *st = iio_priv(indio_dev); > > + > > + if (!(st->gpio_avail_map & BIT(offset))) > > + return -ENODEV; > > + > > + st->gpio_avail_map &= ~BIT(offset); > > Is this really needed? It seems like GPIO core would be keeping track already. > > Also would need a .free callback to undo this action. > > It seems like most ADC's with GPIO controllers don't implement .request though. > Indeed, .request is optional and does not seem to make a pratical difference if the core handles that. If that is the case i can remove this > > + > > + return 0; > > +} > > +
diff --git a/drivers/iio/adc/ad7768-1.c b/drivers/iio/adc/ad7768-1.c index c540583808c2..e3ea078e6ec4 100644 --- a/drivers/iio/adc/ad7768-1.c +++ b/drivers/iio/adc/ad7768-1.c @@ -9,6 +9,8 @@ #include <linux/delay.h> #include <linux/device.h> #include <linux/err.h> +#include <linux/gpio.h> +#include <linux/gpio/driver.h> #include <linux/gpio/consumer.h> #include <linux/kernel.h> #include <linux/module.h> @@ -79,6 +81,19 @@ #define AD7768_CONV_MODE_MSK GENMASK(2, 0) #define AD7768_CONV_MODE(x) FIELD_PREP(AD7768_CONV_MODE_MSK, x) +/* AD7768_REG_GPIO_CONTROL */ +#define AD7768_GPIO_UNIVERSAL_EN BIT(7) +#define AD7768_GPIO_CONTROL_MSK GENMASK(3, 0) + +/* AD7768_REG_GPIO_WRITE */ +#define AD7768_GPIO_WRITE_MSK GENMASK(3, 0) + +/* AD7768_REG_GPIO_READ */ +#define AD7768_GPIO_READ_MSK GENMASK(3, 0) + +#define AD7768_GPIO_INPUT(x) 0x00 +#define AD7768_GPIO_OUTPUT(x) BIT(x) + #define AD7768_RD_FLAG_MSK(x) (BIT(6) | ((x) & 0x3F)) #define AD7768_WR_FLAG_MSK(x) ((x) & 0x3F) @@ -160,6 +175,8 @@ struct ad7768_state { struct regulator *vref; struct mutex lock; struct clk *mclk; + struct gpio_chip gpiochip; + unsigned int gpio_avail_map; unsigned int mclk_freq; unsigned int samp_freq; struct completion completion; @@ -309,6 +326,125 @@ static int ad7768_set_dig_fil(struct ad7768_state *st, return 0; } +static int ad7768_gpio_direction_input(struct gpio_chip *chip, unsigned int offset) +{ + struct iio_dev *indio_dev = gpiochip_get_data(chip); + struct ad7768_state *st = iio_priv(indio_dev); + int ret; + + ret = iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + return regmap_update_bits(st->regmap, + AD7768_REG_GPIO_CONTROL, + BIT(offset), + AD7768_GPIO_INPUT(offset)); +} + +static int ad7768_gpio_direction_output(struct gpio_chip *chip, + unsigned int offset, int value) +{ + struct iio_dev *indio_dev = gpiochip_get_data(chip); + struct ad7768_state *st = iio_priv(indio_dev); + int ret; + + ret = iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + return regmap_update_bits(st->regmap, + AD7768_REG_GPIO_CONTROL, + BIT(offset), + AD7768_GPIO_OUTPUT(offset)); +} + +static int ad7768_gpio_get(struct gpio_chip *chip, unsigned int offset) +{ + struct iio_dev *indio_dev = gpiochip_get_data(chip); + struct ad7768_state *st = iio_priv(indio_dev); + unsigned int val; + int ret; + + ret = iio_device_claim_direct_mode(indio_dev); + if (ret) + return ret; + + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); + if (ret < 0) + return ret; + + if (val & BIT(offset)) + ret = regmap_read(st->regmap, AD7768_REG_GPIO_WRITE, &val); + else + ret = regmap_read(st->regmap, AD7768_REG_GPIO_READ, &val); + if (ret < 0) + return ret; + + return !!(val & BIT(offset)); +} + +static void ad7768_gpio_set(struct gpio_chip *chip, unsigned int offset, int value) +{ + struct iio_dev *indio_dev = gpiochip_get_data(chip); + struct ad7768_state *st = iio_priv(indio_dev); + unsigned int val; + int ret; + + ret = iio_device_claim_direct_mode(indio_dev); + if (ret) + return; + + ret = regmap_read(st->regmap, AD7768_REG_GPIO_CONTROL, &val); + if (ret < 0) + return; + + if (val & BIT(offset)) + regmap_update_bits(st->regmap, + AD7768_REG_GPIO_WRITE, + BIT(offset), + (value << offset)); +} + +static int ad7768_gpio_request(struct gpio_chip *chip, unsigned int offset) +{ + struct iio_dev *indio_dev = gpiochip_get_data(chip); + struct ad7768_state *st = iio_priv(indio_dev); + + if (!(st->gpio_avail_map & BIT(offset))) + return -ENODEV; + + st->gpio_avail_map &= ~BIT(offset); + + return 0; +} + +static int ad7768_gpio_init(struct iio_dev *indio_dev) +{ + struct ad7768_state *st = iio_priv(indio_dev); + int ret; + + ret = regmap_write(st->regmap, AD7768_REG_GPIO_CONTROL, + AD7768_GPIO_UNIVERSAL_EN); + if (ret < 0) + return ret; + + st->gpio_avail_map = AD7768_GPIO_CONTROL_MSK; + st->gpiochip.label = "ad7768_1_gpios"; + st->gpiochip.base = -1; + st->gpiochip.ngpio = 4; + st->gpiochip.parent = &st->spi->dev; + st->gpiochip.can_sleep = true; + st->gpiochip.direction_input = ad7768_gpio_direction_input; + st->gpiochip.direction_output = ad7768_gpio_direction_output; + st->gpiochip.get = ad7768_gpio_get; + st->gpiochip.set = ad7768_gpio_set; + st->gpiochip.request = ad7768_gpio_request; + st->gpiochip.owner = THIS_MODULE; + + return gpiochip_add_data(&st->gpiochip, indio_dev); +} + static int ad7768_set_freq(struct ad7768_state *st, unsigned int freq) { @@ -457,8 +593,9 @@ static const struct iio_info ad7768_info = { .debugfs_reg_access = &ad7768_reg_access, }; -static int ad7768_setup(struct ad7768_state *st) +static int ad7768_setup(struct iio_dev *indio_dev) { + struct ad7768_state *st = iio_priv(indio_dev); int ret; st->gpio_reset = devm_gpiod_get_optional(&st->spi->dev, "reset", @@ -491,6 +628,13 @@ static int ad7768_setup(struct ad7768_state *st) if (IS_ERR(st->gpio_sync_in)) return PTR_ERR(st->gpio_sync_in); + /* Only create a Chip GPIO if flagged for it */ + if (device_property_read_bool(&st->spi->dev, "gpio-controller")) { + ret = ad7768_gpio_init(indio_dev); + if (ret < 0) + return ret; + } + /* Set the default sampling frequency to 32000 kSPS */ return ad7768_set_freq(st, 32000); } @@ -708,7 +852,7 @@ static int ad7768_probe(struct spi_device *spi) return ret; } - ret = ad7768_setup(st); + ret = ad7768_setup(indio_dev); if (ret < 0) { dev_err(&spi->dev, "AD7768 setup failed\n"); return ret;