gpio: sodaville: Convert to use managed functions pcim_* and devm_*

This makes the error handling much more simpler than open-coding everything
and in addition makes the probe function smaller an tidier.

Signed-off-by: Andy Shevchenko <andriy.shevchenko@linux.intel.com>

1 files changed, 18 insertions, 34 deletions

diff --git a/drivers/gpio/gpio-sodaville.c b/drivers/gpio/gpio-sodaville.c
index f60da83349ef..633f363946b7 100644
--- a/drivers/gpio/gpio-sodaville.c
+++ b/drivers/gpio/gpio-sodaville.c
@@ -155,8 +155,10 @@ static int sdv_register_irqsupport(struct sdv_gpio_chip_data *sd,
          * we unmask & ACK the IRQ before the source of the interrupt is gone
          * then the interrupt is active again.
          */
-        sd->gc = irq_alloc_generic_chip("sdv-gpio", 1, sd->irq_base,
-                        sd->gpio_pub_base, handle_fasteoi_irq);
+        sd->gc = devm_irq_alloc_generic_chip(&pdev->dev, "sdv-gpio", 1,
+                                             sd->irq_base,
+                                             sd->gpio_pub_base,
+                                             handle_fasteoi_irq);
         if (!sd->gc)
                 return -ENOMEM;
 
@@ -186,70 +188,52 @@ static int sdv_gpio_probe(struct pci_dev *pdev,
                                         const struct pci_device_id *pci_id)
 {
         struct sdv_gpio_chip_data *sd;
-        unsigned long addr;
-        const void *prop;
-        int len;
         int ret;
         u32 mux_val;
 
-        sd = kzalloc(sizeof(struct sdv_gpio_chip_data), GFP_KERNEL);
+        sd = devm_kzalloc(&pdev->dev, sizeof(*sd), GFP_KERNEL);
         if (!sd)
                 return -ENOMEM;
-        ret = pci_enable_device(pdev);
+
+        ret = pcim_enable_device(pdev);
         if (ret) {
                 dev_err(&pdev->dev, "can't enable device.\n");
-                goto done;
+                return ret;
         }
 
-        ret = pci_request_region(pdev, GPIO_BAR, DRV_NAME);
+        ret = pcim_iomap_regions(pdev, 1 << GPIO_BAR, DRV_NAME);
         if (ret) {
                 dev_err(&pdev->dev, "can't alloc PCI BAR #%d\n", GPIO_BAR);
-                goto disable_pci;
+                return ret;
         }
 
-        addr = pci_resource_start(pdev, GPIO_BAR);
-        if (!addr) {
-                ret = -ENODEV;
-                goto release_reg;
-        }
-        sd->gpio_pub_base = ioremap(addr, pci_resource_len(pdev, GPIO_BAR));
+        sd->gpio_pub_base = pcim_iomap_table(pdev)[GPIO_BAR];
 
-        prop = of_get_property(pdev->dev.of_node, "intel,muxctl", &len);
-        if (prop && len == 4) {
-                mux_val = of_read_number(prop, 1);
+        ret = of_property_read_u32(pdev->dev.of_node, "intel,muxctl", &mux_val);
+        if (!ret)
                 writel(mux_val, sd->gpio_pub_base + GPMUXCTL);
-        }
 
         ret = bgpio_init(&sd->chip, &pdev->dev, 4,
                         sd->gpio_pub_base + GPINR, sd->gpio_pub_base + GPOUTR,
                         NULL, sd->gpio_pub_base + GPOER, NULL, 0);
         if (ret)
-                goto unmap;
+                return ret;
+
         sd->chip.ngpio = SDV_NUM_PUB_GPIOS;
 
-        ret = gpiochip_add_data(&sd->chip, sd);
+        ret = devm_gpiochip_add_data(&pdev->dev, &sd->chip, sd);
         if (ret < 0) {
                 dev_err(&pdev->dev, "gpiochip_add() failed.\n");
-                goto unmap;
+                return ret;
         }
 
         ret = sdv_register_irqsupport(sd, pdev);
         if (ret)
-                goto unmap;
+                return ret;
 
         pci_set_drvdata(pdev, sd);
         dev_info(&pdev->dev, "Sodaville GPIO driver registered.\n");
         return 0;
-
-unmap:
-        iounmap(sd->gpio_pub_base);
-release_reg:
-        pci_release_region(pdev, GPIO_BAR);
-disable_pci:
-        pci_disable_device(pdev);
-done:
-        kfree(sd);
-        return ret;
 }
 
 static const struct pci_device_id sdv_gpio_pci_ids[] = {