iio: adc: xilinx: use more devres helpers and remove remove()

In order to simplify resource management and error paths in probe() and
entirely drop the remove() callback - use devres helpers wherever
possible. Define devm actions for cancelling the delayed work and
disabling the clock.

Signed-off-by: Bartosz Golaszewski <bgolaszewski@baylibre.com>
Tested-by: Anand Ashok Dumbre <anandash@xilinx.com>
Reviewed-by: Anand Ashok Dumbre <anandash@xilinx.com>
Link: https://lore.kernel.org/r/20201130142759.28216-4-brgl@bgdev.pl
Signed-off-by: Jonathan Cameron <Jonathan.Cameron@huawei.com>

diff --git a/drivers/iio/adc/xilinx-xadc-core.c b/drivers/iio/adc/xilinx-xadc-core.c
index 6ef3323541cc2ce120b4e17fc4a42118e93b2ba5..34800dccbf698bff2edbd52a150215bbb2bdba2f 100644 (file)
--- a/drivers/iio/adc/xilinx-xadc-core.c
+++ b/drivers/iio/adc/xilinx-xadc-core.c
@@ -738,11 +738,12 @@ static const struct iio_trigger_ops xadc_trigger_ops = {
 static struct iio_trigger *xadc_alloc_trigger(struct iio_dev *indio_dev,
        const char *name)
 {
+       struct device *dev = indio_dev->dev.parent;
        struct iio_trigger *trig;
        int ret;
 
-       trig = iio_trigger_alloc("%s%d-%s", indio_dev->name,
-                               indio_dev->id, name);
+       trig = devm_iio_trigger_alloc(dev, "%s%d-%s", indio_dev->name,
+                                     indio_dev->id, name);
        if (trig == NULL)
                return ERR_PTR(-ENOMEM);
 
@@ -750,15 +751,11 @@ static struct iio_trigger *xadc_alloc_trigger(struct iio_dev *indio_dev,
        trig->ops = &xadc_trigger_ops;
        iio_trigger_set_drvdata(trig, iio_priv(indio_dev));
 
-       ret = iio_trigger_register(trig);
+       ret = devm_iio_trigger_register(dev, trig);
        if (ret)
-               goto error_free_trig;
+               return ERR_PTR(ret);
 
        return trig;
-
-error_free_trig:
-       iio_trigger_free(trig);
-       return ERR_PTR(ret);
 }
 
 static int xadc_power_adc_b(struct xadc *xadc, unsigned int seq_mode)
@@ -1293,6 +1290,20 @@ static const char * const xadc_type_names[] = {
        [XADC_TYPE_US] = "xilinx-system-monitor",
 };
 
+static void xadc_clk_disable_unprepare(void *data)
+{
+       struct clk *clk = data;
+
+       clk_disable_unprepare(clk);
+}
+
+static void xadc_cancel_delayed_work(void *data)
+{
+       struct delayed_work *work = data;
+
+       cancel_delayed_work_sync(work);
+}
+
 static int xadc_probe(struct platform_device *pdev)
 {
        struct device *dev = &pdev->dev;
@@ -1341,34 +1352,35 @@ static int xadc_probe(struct platform_device *pdev)
                return ret;
 
        if (xadc->ops->flags & XADC_FLAGS_BUFFERED) {
-               ret = iio_triggered_buffer_setup(indio_dev,
-                       &iio_pollfunc_store_time, &xadc_trigger_handler,
-                       &xadc_buffer_ops);
+               ret = devm_iio_triggered_buffer_setup(dev, indio_dev,
+                                                     &iio_pollfunc_store_time,
+                                                     &xadc_trigger_handler,
+                                                     &xadc_buffer_ops);
                if (ret)
                        return ret;
 
                xadc->convst_trigger = xadc_alloc_trigger(indio_dev, "convst");
-               if (IS_ERR(xadc->convst_trigger)) {
-                       ret = PTR_ERR(xadc->convst_trigger);
-                       goto err_triggered_buffer_cleanup;
-               }
+               if (IS_ERR(xadc->convst_trigger))
+                       return PTR_ERR(xadc->convst_trigger);
+
                xadc->samplerate_trigger = xadc_alloc_trigger(indio_dev,
                        "samplerate");
-               if (IS_ERR(xadc->samplerate_trigger)) {
-                       ret = PTR_ERR(xadc->samplerate_trigger);
-                       goto err_free_convst_trigger;
-               }
+               if (IS_ERR(xadc->samplerate_trigger))
+                       return PTR_ERR(xadc->samplerate_trigger);
        }
 
        xadc->clk = devm_clk_get(dev, NULL);
-       if (IS_ERR(xadc->clk)) {
-               ret = PTR_ERR(xadc->clk);
-               goto err_free_samplerate_trigger;
-       }
+       if (IS_ERR(xadc->clk))
+               return PTR_ERR(xadc->clk);
 
        ret = clk_prepare_enable(xadc->clk);
        if (ret)
-               goto err_free_samplerate_trigger;
+               return ret;
+
+       ret = devm_add_action_or_reset(dev,
+                                      xadc_clk_disable_unprepare, xadc->clk);
+       if (ret)
+               return ret;
 
        /*
         * Make sure not to exceed the maximum samplerate since otherwise the
@@ -1377,22 +1389,28 @@ static int xadc_probe(struct platform_device *pdev)
        if (xadc->ops->flags & XADC_FLAGS_BUFFERED) {
                ret = xadc_read_samplerate(xadc);
                if (ret < 0)
-                       goto err_free_samplerate_trigger;
+                       return ret;
+
                if (ret > XADC_MAX_SAMPLERATE) {
                        ret = xadc_write_samplerate(xadc, XADC_MAX_SAMPLERATE);
                        if (ret < 0)
-                               goto err_free_samplerate_trigger;
+                               return ret;
                }
        }
 
-       ret = request_irq(xadc->irq, xadc->ops->interrupt_handler, 0,
-                         dev_name(dev), indio_dev);
+       ret = devm_request_irq(dev, xadc->irq, xadc->ops->interrupt_handler, 0,
+                              dev_name(dev), indio_dev);
+       if (ret)
+               return ret;
+
+       ret = devm_add_action_or_reset(dev, xadc_cancel_delayed_work,
+                                      &xadc->zynq_unmask_work);
        if (ret)
-               goto err_clk_disable_unprepare;
+               return ret;
 
        ret = xadc->ops->setup(pdev, indio_dev, xadc->irq);
        if (ret)
-               goto err_free_irq;
+               return ret;
 
        for (i = 0; i < 16; i++)
                xadc_read_adc_reg(xadc, XADC_REG_THRESHOLD(i),
@@ -1400,7 +1418,7 @@ static int xadc_probe(struct platform_device *pdev)
 
        ret = xadc_write_adc_reg(xadc, XADC_REG_CONF0, conf0);
        if (ret)
-               goto err_free_irq;
+               return ret;
 
        bipolar_mask = 0;
        for (i = 0; i < indio_dev->num_channels; i++) {
@@ -1410,17 +1428,18 @@ static int xadc_probe(struct platform_device *pdev)
 
        ret = xadc_write_adc_reg(xadc, XADC_REG_INPUT_MODE(0), bipolar_mask);
        if (ret)
-               goto err_free_irq;
+               return ret;
+
        ret = xadc_write_adc_reg(xadc, XADC_REG_INPUT_MODE(1),
                bipolar_mask >> 16);
        if (ret)
-               goto err_free_irq;
+               return ret;
 
        /* Disable all alarms */
        ret = xadc_update_adc_reg(xadc, XADC_REG_CONF1, XADC_CONF1_ALARM_MASK,
                                  XADC_CONF1_ALARM_MASK);
        if (ret)
-               goto err_free_irq;
+               return ret;
 
        /* Set thresholds to min/max */
        for (i = 0; i < 16; i++) {
@@ -1435,59 +1454,17 @@ static int xadc_probe(struct platform_device *pdev)
                ret = xadc_write_adc_reg(xadc, XADC_REG_THRESHOLD(i),
                        xadc->threshold[i]);
                if (ret)
-                       goto err_free_irq;
+                       return ret;
        }
 
        /* Go to non-buffered mode */
        xadc_postdisable(indio_dev);
 
-       ret = iio_device_register(indio_dev);
-       if (ret)
-               goto err_free_irq;
-
-       platform_set_drvdata(pdev, indio_dev);
-
-       return 0;
-
-err_free_irq:
-       free_irq(xadc->irq, indio_dev);
-       cancel_delayed_work_sync(&xadc->zynq_unmask_work);
-err_clk_disable_unprepare:
-       clk_disable_unprepare(xadc->clk);
-err_free_samplerate_trigger:
-       if (xadc->ops->flags & XADC_FLAGS_BUFFERED)
-               iio_trigger_free(xadc->samplerate_trigger);
-err_free_convst_trigger:
-       if (xadc->ops->flags & XADC_FLAGS_BUFFERED)
-               iio_trigger_free(xadc->convst_trigger);
-err_triggered_buffer_cleanup:
-       if (xadc->ops->flags & XADC_FLAGS_BUFFERED)
-               iio_triggered_buffer_cleanup(indio_dev);
-
-       return ret;
-}
-
-static int xadc_remove(struct platform_device *pdev)
-{
-       struct iio_dev *indio_dev = platform_get_drvdata(pdev);
-       struct xadc *xadc = iio_priv(indio_dev);
-
-       iio_device_unregister(indio_dev);
-       if (xadc->ops->flags & XADC_FLAGS_BUFFERED) {
-               iio_trigger_free(xadc->samplerate_trigger);
-               iio_trigger_free(xadc->convst_trigger);
-               iio_triggered_buffer_cleanup(indio_dev);
-       }
-       free_irq(xadc->irq, indio_dev);
-       cancel_delayed_work_sync(&xadc->zynq_unmask_work);
-       clk_disable_unprepare(xadc->clk);
-
-       return 0;
+       return devm_iio_device_register(dev, indio_dev);
 }
 
 static struct platform_driver xadc_driver = {
        .probe = xadc_probe,
-       .remove = xadc_remove,
        .driver = {
                .name = "xadc",
                .of_match_table = xadc_of_match_table,