static int scoop_remove(struct platform_device *pdev)
 {
        struct scoop_dev *sdev = platform_get_drvdata(pdev);
-       int ret;
 
        if (!sdev)
                return -EINVAL;
 
-       if (sdev->gpio.base != -1) {
-               ret = gpiochip_remove(&sdev->gpio);
-               if (ret) {
-                       dev_err(&pdev->dev, "Can't remove gpio chip: %d\n", ret);
-                       return ret;
-               }
-       }
+       if (sdev->gpio.base != -1)
+               gpiochip_remove(&sdev->gpio);
 
        platform_set_drvdata(pdev, NULL);
        iounmap(sdev->base);
 
        if (platform_device_add(pdev))
                goto out_pdev;
        return;
+
 out_pdev:
        platform_device_put(pdev);
 out_gpio:
-       if (gpiochip_remove(&iocled->chip))
-               return;
+       gpiochip_remove(&iocled->chip);
 out_unmap:
        iounmap(iocled->mmioaddr);
 out_free:
 
 
 static int mcu_gpiochip_remove(struct mcu *mcu)
 {
-       return gpiochip_remove(&mcu->gc);
+       gpiochip_remove(&mcu->gc);
+       return 0;
 }
 
 static int mcu_probe(struct i2c_client *client, const struct i2c_device_id *id)
 
        return 0;
 
 err_irq:
-       ret = gpiochip_remove(&x3proto_gpio_chip);
-       if (unlikely(ret))
-               pr_err("Failed deregistering GPIO\n");
-
+       gpiochip_remove(&x3proto_gpio_chip);
+       ret = 0;
 err_gpio:
        synchronize_irq(ilsel);
 
 
 int bcma_gpio_unregister(struct bcma_drv_cc *cc)
 {
        bcma_gpio_irq_domain_exit(cc);
-       return gpiochip_remove(&cc->gpio);
+       gpiochip_remove(&cc->gpio);
+       return 0;
 }
 
        return 0;
 
 err_rm_gpiochip:
-       if (gpiochip_remove(chip))
-               dev_err(&pdev->dev, "Failed to remove gpio chip\n");
+       gpiochip_remove(chip);
 err_disable_clk:
        clk_disable_unprepare(gpio->clk);
 
 
        return ret;
 
 err_gpiochip_remove:
-       if (gpiochip_remove(&dev->gc) < 0)
-               hid_err(hdev, "error removing gpio chip\n");
+       gpiochip_remove(&dev->gc);
 err_free_i2c:
        i2c_del_adapter(&dev->adap);
 err_free_dev:
        struct cp2112_device *dev = hid_get_drvdata(hdev);
 
        sysfs_remove_group(&hdev->dev.kobj, &cp2112_attr_group);
-       if (gpiochip_remove(&dev->gc))
-               hid_err(hdev, "unable to remove gpio chip\n");
+       gpiochip_remove(&dev->gc);
        i2c_del_adapter(&dev->adap);
        /* i2c_del_adapter has finished removing all i2c devices from our
         * adapter. Well behaved devices should no longer call our cp2112_xfer
 
                        dev_warn(dev, "teardown failed %d\n", error);
        }
 
-       error = gpiochip_remove(&kpad->gc);
-       if (error)
-               dev_warn(dev, "gpiochip_remove failed %d\n", error);
+       gpiochip_remove(&kpad->gc);
 }
 #else
 static inline int adp5588_gpio_add(struct adp5588_kpad *kpad)
 
                        dev_warn(dev, "teardown failed %d\n", error);
        }
 
-       error = gpiochip_remove(&kpad->gc);
-       if (error)
-               dev_warn(dev, "gpiochip_remove failed %d\n", error);
+       gpiochip_remove(&kpad->gc);
 }
 #else
 static inline int adp5589_gpio_add(struct adp5589_kpad *kpad)
 
 static void ad7879_gpio_remove(struct ad7879 *ts)
 {
        const struct ad7879_platform_data *pdata = dev_get_platdata(ts->dev);
-       int ret;
 
-       if (pdata->gpio_export) {
-               ret = gpiochip_remove(&ts->gc);
-               if (ret)
-                       dev_err(ts->dev, "failed to remove gpio %d\n",
-                               ts->gc.base);
-       }
+       if (pdata->gpio_export)
+               gpiochip_remove(&ts->gc);
+
 }
 #else
 static inline int ad7879_gpio_add(struct ad7879 *ts,
 
        }
 
 #ifdef CONFIG_LEDS_PCA9532_GPIO
-       if (data->gpio.dev) {
-               int err = gpiochip_remove(&data->gpio);
-               if (err) {
-                       dev_err(&data->client->dev, "%s failed, %d\n",
-                                               "gpiochip_remove()", err);
-                       return err;
-               }
-       }
+       if (data->gpio.dev)
+               gpiochip_remove(&data->gpio);
 #endif
 
        return 0;
 
 
 static void tca6507_remove_gpio(struct tca6507_chip *tca)
 {
-       if (tca->gpio.ngpio) {
-               int err = gpiochip_remove(&tca->gpio);
-               dev_err(&tca->client->dev, "%s failed, %d\n",
-                       "gpiochip_remove()", err);
-       }
+       if (tca->gpio.ngpio)
+               gpiochip_remove(&tca->gpio);
 }
 #else /* CONFIG_GPIOLIB */
 static int tca6507_probe_gpios(struct i2c_client *client,
 
 static void cxd2820r_release(struct dvb_frontend *fe)
 {
        struct cxd2820r_priv *priv = fe->demodulator_priv;
-       int uninitialized_var(ret); /* silence compiler warning */
 
        dev_dbg(&priv->i2c->dev, "%s\n", __func__);
 
 #ifdef CONFIG_GPIOLIB
        /* remove GPIOs */
-       if (priv->gpio_chip.label) {
-               ret = gpiochip_remove(&priv->gpio_chip);
-               if (ret)
-                       dev_err(&priv->i2c->dev, "%s: gpiochip_remove() " \
-                                       "failed=%d\n", KBUILD_MODNAME, ret);
-       }
+       if (priv->gpio_chip.label)
+               gpiochip_remove(&priv->gpio_chip);
+
 #endif
        kfree(priv);
        return;
 
 {
        struct asic3 *asic = platform_get_drvdata(pdev);
 
-       return gpiochip_remove(&asic->gpio);
+       gpiochip_remove(&asic->gpio);
+       return 0;
 }
 
 static void asic3_clk_enable(struct asic3 *asic, struct asic3_clk *clk)
 
 
        ret = gpiochip_add(&(chip->chip_in));
        if (ret) {
-               int error;
-
                dev_warn(dev, "Unable to register input GPIOs for 0x%x: %d\n",
                         plat_chip_data->addr, ret);
-
-               error = gpiochip_remove(&(chip->chip_out));
-               if (error)
-                       dev_warn(dev, "Error while trying to unregister gpio chip: %d\n", error);
-
+               gpiochip_remove(&(chip->chip_out));
                return ret;
        }
 
 
        struct sm501_gpio *gpio = &sm->gpio;
        resource_size_t iobase = sm->io_res->start + SM501_GPIO;
        int ret;
-       int tmp;
 
        dev_dbg(sm->dev, "registering gpio block %08llx\n",
                (unsigned long long)iobase);
        return 0;
 
  err_low_chip:
-       tmp = gpiochip_remove(&gpio->low.gpio);
-       if (tmp) {
-               dev_err(sm->dev, "cannot remove low chip, cannot tidy up\n");
-               return ret;
-       }
+       gpiochip_remove(&gpio->low.gpio);
 
  err_mapped:
        iounmap(gpio->regs);
 static void sm501_gpio_remove(struct sm501_devdata *sm)
 {
        struct sm501_gpio *gpio = &sm->gpio;
-       int ret;
 
        if (!sm->gpio.registered)
                return;
 
-       ret = gpiochip_remove(&gpio->low.gpio);
-       if (ret)
-               dev_err(sm->dev, "cannot remove low chip, cannot tidy up\n");
-
-       ret = gpiochip_remove(&gpio->high.gpio);
-       if (ret)
-               dev_err(sm->dev, "cannot remove high chip, cannot tidy up\n");
+       gpiochip_remove(&gpio->low.gpio);
+       gpiochip_remove(&gpio->high.gpio);
 
        iounmap(gpio->regs);
        release_resource(gpio->regs_res);
 
        struct tc6393xb_platform_data *tcpd = dev_get_platdata(&dev->dev);
        struct tc6393xb *tc6393xb;
        struct resource *iomem, *rscr;
-       int ret, temp;
+       int ret;
 
        iomem = platform_get_resource(dev, IORESOURCE_MEM, 0);
        if (!iomem)
 
 err_gpio_add:
        if (tc6393xb->gpio.base != -1)
-               temp = gpiochip_remove(&tc6393xb->gpio);
+               gpiochip_remove(&tc6393xb->gpio);
        tcpd->disable(dev);
 err_enable:
        clk_disable(tc6393xb->clk);
 
        tc6393xb_detach_irq(dev);
 
-       if (tc6393xb->gpio.base != -1) {
-               ret = gpiochip_remove(&tc6393xb->gpio);
-               if (ret) {
-                       dev_err(&dev->dev, "Can't remove gpio chip: %d\n", ret);
-                       return ret;
-               }
-       }
+       if (tc6393xb->gpio.base != -1)
+               gpiochip_remove(&tc6393xb->gpio);
 
        ret = tcpd->disable(dev);
        clk_disable(tc6393xb->clk);
 
        struct ucb1x00_plat_data *pdata = mcp->attached_device.platform_data;
        struct ucb1x00 *ucb = mcp_get_drvdata(mcp);
        struct list_head *l, *n;
-       int ret;
 
        mutex_lock(&ucb1x00_mutex);
        list_del(&ucb->node);
        }
        mutex_unlock(&ucb1x00_mutex);
 
-       if (ucb->gpio.base != -1) {
-               ret = gpiochip_remove(&ucb->gpio);
-               if (ret)
-                       dev_err(&ucb->dev, "Can't remove gpio chip: %d\n", ret);
-       }
+       if (ucb->gpio.base != -1)
+               gpiochip_remove(&ucb->gpio);
 
        irq_set_chained_handler(ucb->irq, NULL);
        irq_free_descs(ucb->irq_base, 16);
 
        return 0;
 
 fail_request_irq:
-       if (gpiochip_remove(&pg->chip))
-               pr_err("gpiochip_remove failed\n");
+       gpiochip_remove(&pg->chip);
 err:
        iounmap(pg->gpiointr);
 err2:
 
 {
        if (ssb_chipco_available(&bus->chipco) ||
            ssb_extif_available(&bus->extif)) {
-               return gpiochip_remove(&bus->gpio);
+               gpiochip_remove(&bus->gpio);
+               return 0;
        } else {
                SSB_WARN_ON(1);
        }
 
 {
        const char *label = card->gc.label;
 
-       if (gpiochip_remove(&(card->gc)))
-               dev_err(&card->vdev->dev, "Failed to remove GPIO\n");
-
+       gpiochip_remove(&(card->gc));
        kfree(label);
 }
 
 
        mutex_destroy(&s->mutex);
 
 #ifdef CONFIG_GPIOLIB
-       WARN_ON(gpiochip_remove(&s->gpio));
+       gpiochip_remove(&s->gpio);
 
 out_uart:
 #endif
 static int max310x_remove(struct device *dev)
 {
        struct max310x_port *s = dev_get_drvdata(dev);
-       int i, ret = 0;
+       int i;
 
 #ifdef CONFIG_GPIOLIB
-       ret = gpiochip_remove(&s->gpio);
-       if (ret)
-               return ret;
+       gpiochip_remove(&s->gpio);
 #endif
 
        for (i = 0; i < s->uart.nr; i++) {
        uart_unregister_driver(&s->uart);
        clk_disable_unprepare(s->clk);
 
-       return ret;
+       return 0;
 }
 
 static const struct of_device_id __maybe_unused max310x_dt_ids[] = {
 
 static int viafb_gpio_remove(struct platform_device *platdev)
 {
        unsigned long flags;
-       int ret = 0, i;
+       int i;
 
 #ifdef CONFIG_PM
        viafb_pm_unregister(&viafb_gpio_pm_hooks);
         * Get unregistered.
         */
        if (viafb_gpio_config.gpio_chip.ngpio > 0) {
-               ret = gpiochip_remove(&viafb_gpio_config.gpio_chip);
-               if (ret) { /* Somebody still using it? */
-                       printk(KERN_ERR "Viafb: GPIO remove failed\n");
-                       return ret;
-               }
+               gpiochip_remove(&viafb_gpio_config.gpio_chip);
        }
        /*
         * Disable the ports.
                viafb_gpio_disable(viafb_gpio_config.active_gpios[i]);
        viafb_gpio_config.gpio_chip.ngpio = 0;
        spin_unlock_irqrestore(&viafb_gpio_config.vdev->reg_lock, flags);
-       return ret;
+       return 0;
 }
 
 static struct platform_driver via_gpio_driver = {
 
 static void wm5100_free_gpio(struct i2c_client *i2c)
 {
        struct wm5100_priv *wm5100 = i2c_get_clientdata(i2c);
-       int ret;
 
-       ret = gpiochip_remove(&wm5100->gpio_chip);
-       if (ret != 0)
-               dev_err(&i2c->dev, "Failed to remove GPIOs: %d\n", ret);
+       gpiochip_remove(&wm5100->gpio_chip);
 }
 #else
 static void wm5100_init_gpio(struct i2c_client *i2c)
 
 
 static void wm8903_free_gpio(struct wm8903_priv *wm8903)
 {
-       int ret;
-
-       ret = gpiochip_remove(&wm8903->gpio_chip);
-       if (ret != 0)
-               dev_err(wm8903->dev, "Failed to remove GPIOs: %d\n", ret);
+       gpiochip_remove(&wm8903->gpio_chip);
 }
 #else
 static void wm8903_init_gpio(struct wm8903_priv *wm8903)
 
 static void wm8962_free_gpio(struct snd_soc_codec *codec)
 {
        struct wm8962_priv *wm8962 = snd_soc_codec_get_drvdata(codec);
-       int ret;
 
-       ret = gpiochip_remove(&wm8962->gpio_chip);
-       if (ret != 0)
-               dev_err(codec->dev, "Failed to remove GPIOs: %d\n", ret);
+       gpiochip_remove(&wm8962->gpio_chip);
 }
 #else
 static void wm8962_init_gpio(struct snd_soc_codec *codec)
 
 
 static void wm8996_free_gpio(struct wm8996_priv *wm8996)
 {
-       int ret;
-
-       ret = gpiochip_remove(&wm8996->gpio_chip);
-       if (ret != 0)
-               dev_err(wm8996->dev, "Failed to remove GPIOs: %d\n", ret);
+       gpiochip_remove(&wm8996->gpio_chip);
 }
 #else
 static void wm8996_init_gpio(struct wm8996_priv *wm8996)