pps: descriptor-based gpio

This patch changes the GPIO access for the pps-gpio driver from the
integer based API to the descriptor based API.

The integer based API is considered deprecated and the descriptor based
API is the preferred way to access GPIOs as per
Documentation/driver-api/gpio/intro.rst

No changes are made to userspace interfaces.

Link: http://lkml.kernel.org/r/20190324043305.6627-2-tom@aussec.com
Signed-off-by: Tom Burkart <tom@aussec.com>
Acked-by: Rodolfo Giometti <giometti@enneenne.com>
Reviewed-by: Philipp Zabel <philipp.zabel@gmail.com>
Cc: Lukas Senger <lukas@fridolin.com>
Cc: Rob Herring <robh@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/drivers/pps/clients/pps-gpio.c b/drivers/pps/clients/pps-gpio.c
index dd5d110..4e5e922 100644 (file)
--- a/drivers/pps/clients/pps-gpio.c
+++ b/drivers/pps/clients/pps-gpio.c
@@ -31,7 +31,7 @@
 #include <linux/slab.h>
 #include <linux/pps_kernel.h>
 #include <linux/pps-gpio.h>
-#include <linux/gpio.h>
+#include <linux/gpio/consumer.h>
 #include <linux/list.h>
 #include <linux/of_device.h>
 #include <linux/of_gpio.h>
@@ -41,9 +41,9 @@ struct pps_gpio_device_data {
        int irq;                        /* IRQ used as PPS source */
        struct pps_device *pps;         /* PPS source device */
        struct pps_source_info info;    /* PPS source information */
+       struct gpio_desc *gpio_pin;     /* GPIO port descriptors */
        bool assert_falling_edge;
        bool capture_clear;
-       unsigned int gpio_pin;
 };
 
 /*
@@ -61,18 +61,37 @@ static irqreturn_t pps_gpio_irq_handler(int irq, void *data)
 
        info = data;
 
-       rising_edge = gpio_get_value(info->gpio_pin);
+       rising_edge = gpiod_get_value(info->gpio_pin);
        if ((rising_edge && !info->assert_falling_edge) ||
                        (!rising_edge && info->assert_falling_edge))
                pps_event(info->pps, &ts, PPS_CAPTUREASSERT, NULL);
        else if (info->capture_clear &&
                        ((rising_edge && info->assert_falling_edge) ||
-                        (!rising_edge && !info->assert_falling_edge)))
+                       (!rising_edge && !info->assert_falling_edge)))
                pps_event(info->pps, &ts, PPS_CAPTURECLEAR, NULL);
 
        return IRQ_HANDLED;
 }
 
+static int pps_gpio_setup(struct platform_device *pdev)
+{
+       struct pps_gpio_device_data *data = platform_get_drvdata(pdev);
+       struct device_node *np = pdev->dev.of_node;
+
+       data->gpio_pin = devm_gpiod_get(&pdev->dev,
+               NULL,   /* request "gpios" */
+               GPIOD_IN);
+       if (IS_ERR(data->gpio_pin)) {
+               dev_err(&pdev->dev,
+                       "failed to request PPS GPIO\n");
+               return PTR_ERR(data->gpio_pin);
+       }
+
+       if (of_property_read_bool(np, "assert-falling-edge"))
+               data->assert_falling_edge = true;
+       return 0;
+}
+
 static unsigned long
 get_irqf_trigger_flags(const struct pps_gpio_device_data *data)
 {
@@ -90,53 +109,30 @@ get_irqf_trigger_flags(const struct pps_gpio_device_data *data)
 static int pps_gpio_probe(struct platform_device *pdev)
 {
        struct pps_gpio_device_data *data;
-       const char *gpio_label;
        int ret;
        int pps_default_params;
        const struct pps_gpio_platform_data *pdata = pdev->dev.platform_data;
-       struct device_node *np = pdev->dev.of_node;
 
        /* allocate space for device info */
-       data = devm_kzalloc(&pdev->dev, sizeof(struct pps_gpio_device_data),
-                       GFP_KERNEL);
+       data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL);
        if (!data)
                return -ENOMEM;
+       platform_set_drvdata(pdev, data);
 
+       /* GPIO setup */
        if (pdata) {
                data->gpio_pin = pdata->gpio_pin;
-               gpio_label = pdata->gpio_label;
 
                data->assert_falling_edge = pdata->assert_falling_edge;
                data->capture_clear = pdata->capture_clear;
        } else {
-               ret = of_get_gpio(np, 0);
-               if (ret < 0) {
-                       dev_err(&pdev->dev, "failed to get GPIO from device tree\n");
-                       return ret;
-               }
-               data->gpio_pin = ret;
-               gpio_label = PPS_GPIO_NAME;
-
-               if (of_get_property(np, "assert-falling-edge", NULL))
-                       data->assert_falling_edge = true;
-       }
-
-       /* GPIO setup */
-       ret = devm_gpio_request(&pdev->dev, data->gpio_pin, gpio_label);
-       if (ret) {
-               dev_err(&pdev->dev, "failed to request GPIO %u\n",
-                       data->gpio_pin);
-               return ret;
-       }
-
-       ret = gpio_direction_input(data->gpio_pin);
-       if (ret) {
-               dev_err(&pdev->dev, "failed to set pin direction\n");
-               return -EINVAL;
+               ret = pps_gpio_setup(pdev);
+               if (ret)
+                       return -EINVAL;
        }
 
        /* IRQ setup */
-       ret = gpio_to_irq(data->gpio_pin);
+       ret = gpiod_to_irq(data->gpio_pin);
        if (ret < 0) {
                dev_err(&pdev->dev, "failed to map GPIO to IRQ: %d\n", ret);
                return -EINVAL;
@@ -173,7 +169,6 @@ static int pps_gpio_probe(struct platform_device *pdev)
                return -EINVAL;
        }
 
-       platform_set_drvdata(pdev, data);
        dev_info(data->pps->dev, "Registered IRQ %d as PPS source\n",
                 data->irq);
 
@@ -209,4 +204,4 @@ MODULE_AUTHOR("Ricardo Martins <rasm@fe.up.pt>");
 MODULE_AUTHOR("James Nuss <jamesnuss@nanometrics.ca>");
 MODULE_DESCRIPTION("Use GPIO pin as PPS source");
 MODULE_LICENSE("GPL");
-MODULE_VERSION("1.0.0");
+MODULE_VERSION("1.1.0");

diff --git a/include/linux/pps-gpio.h b/include/linux/pps-gpio.h
index 56f35dd..f028d2c 100644 (file)
--- a/include/linux/pps-gpio.h
+++ b/include/linux/pps-gpio.h
@@ -23,10 +23,9 @@
 #define _PPS_GPIO_H
 
 struct pps_gpio_platform_data {
+       struct gpio_desc *gpio_pin;
        bool assert_falling_edge;
        bool capture_clear;
-       unsigned int gpio_pin;
-       const char *gpio_label;
 };
 
 #endif /* _PPS_GPIO_H */