iio: health: afe4404: Do not store dev pointer in device struct

The device *dev is only used in probe(), so no need to store it
in the device local data struct. In all the places in probe()
we did use that, just use a new local variable for the same.

Signed-off-by: Andrew Davis <afd@ti.com>
Link: https://patch.msgid.link/20250813225840.576305-4-afd@ti.com
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/health/afe4404.c b/drivers/iio/health/afe4404.c
index b2727effecaaea0c970f769fd80106b16f8b2e51..29e030943f599b464634c483452ce9b623a16248 100644 (file)
--- a/drivers/iio/health/afe4404.c
+++ b/drivers/iio/health/afe4404.c
@@ -77,7 +77,6 @@ static const struct reg_field afe4404_reg_fields[] = {
 
 /**
  * struct afe4404_data - AFE4404 device instance data
- * @dev: Device structure
  * @regmap: Register map of the device
  * @fields: Register fields of the device
  * @regulator: Pointer to the regulator for the IC
@@ -86,7 +85,6 @@ static const struct reg_field afe4404_reg_fields[] = {
  * @buffer: Used to construct a scan to push to the iio buffer.
  */
 struct afe4404_data {
-       struct device *dev;
        struct regmap *regmap;
        struct regmap_field *fields[F_MAX_FIELDS];
        struct regulator *regulator;
@@ -468,62 +466,62 @@ static DEFINE_SIMPLE_DEV_PM_OPS(afe4404_pm_ops, afe4404_suspend,
 
 static int afe4404_probe(struct i2c_client *client)
 {
+       struct device *dev = &client->dev;
        struct iio_dev *indio_dev;
        struct afe4404_data *afe;
        int i, ret;
 
-       indio_dev = devm_iio_device_alloc(&client->dev, sizeof(*afe));
+       indio_dev = devm_iio_device_alloc(dev, sizeof(*afe));
        if (!indio_dev)
                return -ENOMEM;
 
        afe = iio_priv(indio_dev);
        i2c_set_clientdata(client, indio_dev);
 
-       afe->dev = &client->dev;
        afe->irq = client->irq;
 
        afe->regmap = devm_regmap_init_i2c(client, &afe4404_regmap_config);
        if (IS_ERR(afe->regmap)) {
-               dev_err(afe->dev, "Unable to allocate register map\n");
+               dev_err(dev, "Unable to allocate register map\n");
                return PTR_ERR(afe->regmap);
        }
 
        for (i = 0; i < F_MAX_FIELDS; i++) {
-               afe->fields[i] = devm_regmap_field_alloc(afe->dev, afe->regmap,
+               afe->fields[i] = devm_regmap_field_alloc(dev, afe->regmap,
                                                         afe4404_reg_fields[i]);
                if (IS_ERR(afe->fields[i])) {
-                       dev_err(afe->dev, "Unable to allocate regmap fields\n");
+                       dev_err(dev, "Unable to allocate regmap fields\n");
                        return PTR_ERR(afe->fields[i]);
                }
        }
 
-       afe->regulator = devm_regulator_get(afe->dev, "tx_sup");
+       afe->regulator = devm_regulator_get(dev, "tx_sup");
        if (IS_ERR(afe->regulator))
-               return dev_err_probe(afe->dev, PTR_ERR(afe->regulator),
+               return dev_err_probe(dev, PTR_ERR(afe->regulator),
                                     "Unable to get regulator\n");
 
        ret = regulator_enable(afe->regulator);
        if (ret) {
-               dev_err(afe->dev, "Unable to enable regulator\n");
+               dev_err(dev, "Unable to enable regulator\n");
                return ret;
        }
-       ret = devm_add_action_or_reset(afe->dev, afe4404_regulator_disable, afe->regulator);
+       ret = devm_add_action_or_reset(dev, afe4404_regulator_disable, afe->regulator);
        if (ret) {
-               dev_err(afe->dev, "Unable to enable regulator\n");
+               dev_err(dev, "Unable to enable regulator\n");
                return ret;
        }
 
        ret = regmap_write(afe->regmap, AFE440X_CONTROL0,
                           AFE440X_CONTROL0_SW_RESET);
        if (ret) {
-               dev_err(afe->dev, "Unable to reset device\n");
+               dev_err(dev, "Unable to reset device\n");
                return ret;
        }
 
        ret = regmap_multi_reg_write(afe->regmap, afe4404_reg_sequences,
                                     ARRAY_SIZE(afe4404_reg_sequences));
        if (ret) {
-               dev_err(afe->dev, "Unable to set register defaults\n");
+               dev_err(dev, "Unable to set register defaults\n");
                return ret;
        }
 
@@ -534,45 +532,45 @@ static int afe4404_probe(struct i2c_client *client)
        indio_dev->info = &afe4404_iio_info;
 
        if (afe->irq > 0) {
-               afe->trig = devm_iio_trigger_alloc(afe->dev,
+               afe->trig = devm_iio_trigger_alloc(dev,
                                                   "%s-dev%d",
                                                   indio_dev->name,
                                                   iio_device_id(indio_dev));
                if (!afe->trig) {
-                       dev_err(afe->dev, "Unable to allocate IIO trigger\n");
+                       dev_err(dev, "Unable to allocate IIO trigger\n");
                        return -ENOMEM;
                }
 
                iio_trigger_set_drvdata(afe->trig, indio_dev);
 
-               ret = devm_iio_trigger_register(afe->dev, afe->trig);
+               ret = devm_iio_trigger_register(dev, afe->trig);
                if (ret) {
-                       dev_err(afe->dev, "Unable to register IIO trigger\n");
+                       dev_err(dev, "Unable to register IIO trigger\n");
                        return ret;
                }
 
-               ret = devm_request_threaded_irq(afe->dev, afe->irq,
+               ret = devm_request_threaded_irq(dev, afe->irq,
                                                iio_trigger_generic_data_rdy_poll,
                                                NULL, IRQF_ONESHOT,
                                                AFE4404_DRIVER_NAME,
                                                afe->trig);
                if (ret) {
-                       dev_err(afe->dev, "Unable to request IRQ\n");
+                       dev_err(dev, "Unable to request IRQ\n");
                        return ret;
                }
        }
 
-       ret = devm_iio_triggered_buffer_setup(afe->dev, indio_dev,
+       ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
                                              &iio_pollfunc_store_time,
                                              afe4404_trigger_handler, NULL);
        if (ret) {
-               dev_err(afe->dev, "Unable to setup buffer\n");
+               dev_err(dev, "Unable to setup buffer\n");
                return ret;
        }
 
-       ret = devm_iio_device_register(afe->dev, indio_dev);
+       ret = devm_iio_device_register(dev, indio_dev);
        if (ret) {
-               dev_err(afe->dev, "Unable to register IIO device\n");
+               dev_err(dev, "Unable to register IIO device\n");
                return ret;
        }