if (lh->descs[i])
                        gpiod_free(lh->descs[i]);
        kfree(lh->label);
-       put_device(&lh->gdev->dev);
+       gpio_device_put(lh->gdev);
        kfree(lh);
 }
 
        lh = kzalloc(sizeof(*lh), GFP_KERNEL);
        if (!lh)
                return -ENOMEM;
-       lh->gdev = gdev;
-       get_device(&gdev->dev);
+       lh->gdev = gpio_device_get(gdev);
 
        if (handlereq.consumer_label[0] != '\0') {
                /* label is only initialized if consumer_label is set */
        }
        kfifo_free(&lr->events);
        kfree(lr->label);
-       put_device(&lr->gdev->dev);
+       gpio_device_put(lr->gdev);
        kfree(lr);
 }
 
        if (!lr)
                return -ENOMEM;
 
-       lr->gdev = gdev;
-       get_device(&gdev->dev);
+       lr->gdev = gpio_device_get(gdev);
 
        for (i = 0; i < ulr.num_lines; i++) {
                lr->lines[i].req = lr;
        if (le->desc)
                gpiod_free(le->desc);
        kfree(le->label);
-       put_device(&le->gdev->dev);
+       gpio_device_put(le->gdev);
        kfree(le);
 }
 
        le = kzalloc(sizeof(*le), GFP_KERNEL);
        if (!le)
                return -ENOMEM;
-       le->gdev = gdev;
-       get_device(&gdev->dev);
+       le->gdev = gpio_device_get(gdev);
 
        if (eventreq.consumer_label[0] != '\0') {
                /* label is only initialized if consumer_label is set */
 
        init_waitqueue_head(&cdev->wait);
        INIT_KFIFO(cdev->events);
-       cdev->gdev = gdev;
+       cdev->gdev = gpio_device_get(gdev);
 
        cdev->lineinfo_changed_nb.notifier_call = lineinfo_changed_notify;
        ret = blocking_notifier_chain_register(&gdev->notifier,
        if (ret)
                goto out_free_bitmap;
 
-       get_device(&gdev->dev);
        file->private_data = cdev;
 
        ret = nonseekable_open(inode, file);
        blocking_notifier_chain_unregister(&gdev->notifier,
                                           &cdev->lineinfo_changed_nb);
 out_free_bitmap:
+       gpio_device_put(gdev);
        bitmap_free(cdev->watched_lines);
 out_free_cdev:
        kfree(cdev);
        bitmap_free(cdev->watched_lines);
        blocking_notifier_chain_unregister(&gdev->notifier,
                                           &cdev->lineinfo_changed_nb);
-       put_device(&gdev->dev);
+       gpio_device_put(gdev);
        kfree(cdev);
 
        return 0;
 
        gpiochip_free_valid_mask(gc);
        if (gdev->dev.release) {
                /* release() has been registered by gpiochip_setup_dev() */
-               put_device(&gdev->dev);
+               gpio_device_put(gdev);
                goto err_print_message;
        }
 err_remove_from_list:
         */
        gcdev_unregister(gdev);
        up_write(&gdev->sem);
-       put_device(&gdev->dev);
+       gpio_device_put(gdev);
 }
 EXPORT_SYMBOL_GPL(gpiochip_remove);
 
 int gpiod_request(struct gpio_desc *desc, const char *label)
 {
        int ret = -EPROBE_DEFER;
-       struct gpio_device *gdev;
 
        VALIDATE_DESC(desc);
-       gdev = desc->gdev;
 
-       if (try_module_get(gdev->owner)) {
+       if (try_module_get(desc->gdev->owner)) {
                ret = gpiod_request_commit(desc, label);
                if (ret)
-                       module_put(gdev->owner);
+                       module_put(desc->gdev->owner);
                else
-                       get_device(&gdev->dev);
+                       gpio_device_get(desc->gdev);
        }
 
        if (ret)
 {
        if (desc && desc->gdev && gpiod_free_commit(desc)) {
                module_put(desc->gdev->owner);
-               put_device(&desc->gdev->dev);
+               gpio_device_put(desc->gdev);
        } else {
                WARN_ON(extra_checks);
        }
 
        return container_of(dev, struct gpio_device, dev);
 }
 
+static inline struct gpio_device *gpio_device_get(struct gpio_device *gdev)
+{
+       return to_gpio_device(get_device(&gdev->dev));
+}
+
+static inline void gpio_device_put(struct gpio_device *gdev)
+{
+       put_device(&gdev->dev);
+}
+
 /* gpio suffixes used for ACPI and device tree lookup */
 static __maybe_unused const char * const gpio_suffixes[] = { "gpios", "gpio" };