w1: gpio: rename pointer to driver data from pdata to ddata

pdata is a relict when this was still platform data.

Signed-off-by: Uwe Kleine-König <u.kleine-koenig@pengutronix.de>
Link: https://lore.kernel.org/r/f863cacc485a701268164c9734b6d4aef23dae3e.1701727212.git.u.kleine-koenig@pengutronix.de
Signed-off-by: Krzysztof Kozlowski <krzysztof.kozlowski@linaro.org>

diff --git a/drivers/w1/masters/w1-gpio.c b/drivers/w1/masters/w1-gpio.c
index 67596428f69b14f19d532d649bb9394766607ff4..05c67038ed20c35e99ff9bbb6de4a771fdf0c74d 100644 (file)
--- a/drivers/w1/masters/w1-gpio.c
+++ b/drivers/w1/masters/w1-gpio.c
@@ -25,25 +25,25 @@ struct w1_gpio_ddata {
 
 static u8 w1_gpio_set_pullup(void *data, int delay)
 {
-       struct w1_gpio_ddata *pdata = data;
+       struct w1_gpio_ddata *ddata = data;
 
        if (delay) {
-               pdata->pullup_duration = delay;
+               ddata->pullup_duration = delay;
        } else {
-               if (pdata->pullup_duration) {
+               if (ddata->pullup_duration) {
                        /*
                         * This will OVERRIDE open drain emulation and force-pull
                         * the line high for some time.
                         */
-                       gpiod_set_raw_value(pdata->gpiod, 1);
-                       msleep(pdata->pullup_duration);
+                       gpiod_set_raw_value(ddata->gpiod, 1);
+                       msleep(ddata->pullup_duration);
                        /*
                         * This will simply set the line as input since we are doing
                         * open drain emulation in the GPIO library.
                         */
-                       gpiod_set_value(pdata->gpiod, 1);
+                       gpiod_set_value(ddata->gpiod, 1);
                }
-               pdata->pullup_duration = 0;
+               ddata->pullup_duration = 0;
        }
 
        return 0;
@@ -51,16 +51,16 @@ static u8 w1_gpio_set_pullup(void *data, int delay)
 
 static void w1_gpio_write_bit(void *data, u8 bit)
 {
-       struct w1_gpio_ddata *pdata = data;
+       struct w1_gpio_ddata *ddata = data;
 
-       gpiod_set_value(pdata->gpiod, bit);
+       gpiod_set_value(ddata->gpiod, bit);
 }
 
 static u8 w1_gpio_read_bit(void *data)
 {
-       struct w1_gpio_ddata *pdata = data;
+       struct w1_gpio_ddata *ddata = data;
 
-       return gpiod_get_value(pdata->gpiod) ? 1 : 0;
+       return gpiod_get_value(ddata->gpiod) ? 1 : 0;
 }
 
 #if defined(CONFIG_OF)
@@ -74,15 +74,15 @@ MODULE_DEVICE_TABLE(of, w1_gpio_dt_ids);
 static int w1_gpio_probe(struct platform_device *pdev)
 {
        struct w1_bus_master *master;
-       struct w1_gpio_ddata *pdata;
+       struct w1_gpio_ddata *ddata;
        struct device *dev = &pdev->dev;
        struct device_node *np = dev->of_node;
        /* Enforce open drain mode by default */
        enum gpiod_flags gflags = GPIOD_OUT_LOW_OPEN_DRAIN;
        int err;
 
-       pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
-       if (!pdata)
+       ddata = devm_kzalloc(&pdev->dev, sizeof(*ddata), GFP_KERNEL);
+       if (!ddata)
                return -ENOMEM;
 
        /*
@@ -99,23 +99,23 @@ static int w1_gpio_probe(struct platform_device *pdev)
        if (!master)
                return -ENOMEM;
 
-       pdata->gpiod = devm_gpiod_get_index(dev, NULL, 0, gflags);
-       if (IS_ERR(pdata->gpiod)) {
+       ddata->gpiod = devm_gpiod_get_index(dev, NULL, 0, gflags);
+       if (IS_ERR(ddata->gpiod)) {
                dev_err(dev, "gpio_request (pin) failed\n");
-               return PTR_ERR(pdata->gpiod);
+               return PTR_ERR(ddata->gpiod);
        }
 
-       pdata->pullup_gpiod =
+       ddata->pullup_gpiod =
                devm_gpiod_get_index_optional(dev, NULL, 1, GPIOD_OUT_LOW);
-       if (IS_ERR(pdata->pullup_gpiod)) {
+       if (IS_ERR(ddata->pullup_gpiod)) {
                dev_err(dev, "gpio_request_one "
                        "(ext_pullup_enable_pin) failed\n");
-               return PTR_ERR(pdata->pullup_gpiod);
+               return PTR_ERR(ddata->pullup_gpiod);
        }
 
-       master->data = pdata;
+       master->data = ddata;
        master->read_bit = w1_gpio_read_bit;
-       gpiod_direction_output(pdata->gpiod, 1);
+       gpiod_direction_output(ddata->gpiod, 1);
        master->write_bit = w1_gpio_write_bit;
 
        /*
@@ -133,8 +133,8 @@ static int w1_gpio_probe(struct platform_device *pdev)
                return err;
        }
 
-       if (pdata->pullup_gpiod)
-               gpiod_set_value(pdata->pullup_gpiod, 1);
+       if (ddata->pullup_gpiod)
+               gpiod_set_value(ddata->pullup_gpiod, 1);
 
        platform_set_drvdata(pdev, master);
 
@@ -144,10 +144,10 @@ static int w1_gpio_probe(struct platform_device *pdev)
 static int w1_gpio_remove(struct platform_device *pdev)
 {
        struct w1_bus_master *master = platform_get_drvdata(pdev);
-       struct w1_gpio_ddata *pdata = master->data;
+       struct w1_gpio_ddata *ddata = master->data;
 
-       if (pdata->pullup_gpiod)
-               gpiod_set_value(pdata->pullup_gpiod, 0);
+       if (ddata->pullup_gpiod)
+               gpiod_set_value(ddata->pullup_gpiod, 0);
 
        w1_remove_master_device(master);