Input: gpio_keys_polled - convert to devm-* API

Replace existing resource handling in the driver with managed device
resources, this ensures more consistent error values and simplifies error
handling paths:

kzalloc -> devm_kzalloc
gpio_request_one -> devm_gpio_request_one
input_allocate_polled_device -> devm_input_allocate_polled_device

Signed-off-by: Alexander Shiyan <shc_work@mail.ru>
Signed-off-by: Dmitry Torokhov <dmitry.torokhov@gmail.com>

diff --git a/drivers/input/keyboard/gpio_keys_polled.c b/drivers/input/keyboard/gpio_keys_polled.c
index bea53a633c52e2479e9dd06a3cfb20c3bd9758fd..432d36395f3503d7ffcaeae88fb6a02c85c48fd3 100644 (file)
--- a/drivers/input/keyboard/gpio_keys_polled.c
+++ b/drivers/input/keyboard/gpio_keys_polled.c
@@ -120,12 +120,10 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
        if (nbuttons == 0)
                return NULL;
 
-       pdata = kzalloc(sizeof(*pdata) + nbuttons * (sizeof *button),
-                       GFP_KERNEL);
-       if (!pdata) {
-               error = -ENOMEM;
-               goto err_out;
-       }
+       pdata = devm_kzalloc(dev, sizeof(*pdata) + nbuttons * sizeof(*button),
+                            GFP_KERNEL);
+       if (!pdata)
+               return ERR_PTR(-ENOMEM);
 
        pdata->buttons = (struct gpio_keys_button *)(pdata + 1);
        pdata->nbuttons = nbuttons;
@@ -151,7 +149,7 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                                dev_err(dev,
                                        "Failed to get gpio flags, error: %d\n",
                                        error);
-                       goto err_free_pdata;
+                       return ERR_PTR(error);
                }
 
                button = &pdata->buttons[i++];
@@ -162,8 +160,7 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                if (of_property_read_u32(pp, "linux,code", &button->code)) {
                        dev_err(dev, "Button without keycode: 0x%x\n",
                                button->gpio);
-                       error = -EINVAL;
-                       goto err_free_pdata;
+                       return ERR_PTR(-EINVAL);
                }
 
                button->desc = of_get_property(pp, "label", NULL);
@@ -178,17 +175,10 @@ static struct gpio_keys_platform_data *gpio_keys_polled_get_devtree_pdata(struct
                        button->debounce_interval = 5;
        }
 
-       if (pdata->nbuttons == 0) {
-               error = -EINVAL;
-               goto err_free_pdata;
-       }
+       if (pdata->nbuttons == 0)
+               return ERR_PTR(-EINVAL);
 
        return pdata;
-
-err_free_pdata:
-       kfree(pdata);
-err_out:
-       return ERR_PTR(error);
 }
 
 static const struct of_device_id gpio_keys_polled_of_match[] = {
@@ -213,6 +203,7 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
        struct gpio_keys_polled_dev *bdev;
        struct input_polled_dev *poll_dev;
        struct input_dev *input;
+       size_t size;
        int error;
        int i;
 
@@ -228,24 +219,21 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
 
        if (!pdata->poll_interval) {
                dev_err(dev, "missing poll_interval value\n");
-               error = -EINVAL;
-               goto err_free_pdata;
+               return -EINVAL;
        }
 
-       bdev = kzalloc(sizeof(struct gpio_keys_polled_dev) +
-                      pdata->nbuttons * sizeof(struct gpio_keys_button_data),
-                      GFP_KERNEL);
+       size = sizeof(struct gpio_keys_polled_dev) +
+                       pdata->nbuttons * sizeof(struct gpio_keys_button_data);
+       bdev = devm_kzalloc(&pdev->dev, size, GFP_KERNEL);
        if (!bdev) {
                dev_err(dev, "no memory for private data\n");
-               error = -ENOMEM;
-               goto err_free_pdata;
+               return -ENOMEM;
        }
 
-       poll_dev = input_allocate_polled_device();
+       poll_dev = devm_input_allocate_polled_device(&pdev->dev);
        if (!poll_dev) {
                dev_err(dev, "no memory for polled device\n");
-               error = -ENOMEM;
-               goto err_free_bdev;
+               return -ENOMEM;
        }
 
        poll_dev->private = bdev;
@@ -258,7 +246,6 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
 
        input->name = pdev->name;
        input->phys = DRV_NAME"/input0";
-       input->dev.parent = &pdev->dev;
 
        input->id.bustype = BUS_HOST;
        input->id.vendor = 0x0001;
@@ -277,16 +264,15 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
 
                if (button->wakeup) {
                        dev_err(dev, DRV_NAME " does not support wakeup\n");
-                       error = -EINVAL;
-                       goto err_free_gpio;
+                       return -EINVAL;
                }
 
-               error = gpio_request_one(gpio, GPIOF_IN,
-                                        button->desc ?: DRV_NAME);
+               error = devm_gpio_request_one(&pdev->dev, gpio, GPIOF_IN,
+                                             button->desc ? : DRV_NAME);
                if (error) {
                        dev_err(dev, "unable to claim gpio %u, err=%d\n",
                                gpio, error);
-                       goto err_free_gpio;
+                       return error;
                }
 
                bdata->can_sleep = gpio_cansleep(gpio);
@@ -306,7 +292,7 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
        if (error) {
                dev_err(dev, "unable to register polled device, err=%d\n",
                        error);
-               goto err_free_gpio;
+               return error;
        }
 
        /* report initial state of the buttons */
@@ -315,52 +301,10 @@ static int gpio_keys_polled_probe(struct platform_device *pdev)
                                             &bdev->data[i]);
 
        return 0;
-
-err_free_gpio:
-       while (--i >= 0)
-               gpio_free(pdata->buttons[i].gpio);
-
-       input_free_polled_device(poll_dev);
-
-err_free_bdev:
-       kfree(bdev);
-
-err_free_pdata:
-       /* If we have no platform_data, we allocated pdata dynamically.  */
-       if (!dev_get_platdata(&pdev->dev))
-               kfree(pdata);
-
-       return error;
-}
-
-static int gpio_keys_polled_remove(struct platform_device *pdev)
-{
-       struct gpio_keys_polled_dev *bdev = platform_get_drvdata(pdev);
-       const struct gpio_keys_platform_data *pdata = bdev->pdata;
-       int i;
-
-       input_unregister_polled_device(bdev->poll_dev);
-
-       for (i = 0; i < pdata->nbuttons; i++)
-               gpio_free(pdata->buttons[i].gpio);
-
-       input_free_polled_device(bdev->poll_dev);
-
-       /*
-        * If we had no platform_data, we allocated pdata dynamically and
-        * must free it here.
-        */
-       if (!dev_get_platdata(&pdev->dev))
-               kfree(pdata);
-
-       kfree(bdev);
-
-       return 0;
 }
 
 static struct platform_driver gpio_keys_polled_driver = {
        .probe  = gpio_keys_polled_probe,
-       .remove = gpio_keys_polled_remove,
        .driver = {
                .name   = DRV_NAME,
                .owner  = THIS_MODULE,