u32 irq_usage;
        u32 dbck_enable_mask;
        bool dbck_enabled;
-       struct device *dev;
        bool is_mpuio;
        bool dbck_flag;
        bool loses_context;
        unsigned long flags;
 
        if (bank->non_wakeup_gpios & gpio_bit) {
-               dev_err(bank->dev,
+               dev_err(bank->chip.parent,
                        "Unable to modify wakeup on non-wakeup GPIO%d\n",
                        offset);
                return -EINVAL;
         * enable the bank module.
         */
        if (!BANK_USED(bank))
-               pm_runtime_get_sync(bank->dev);
+               pm_runtime_get_sync(chip->parent);
 
        raw_spin_lock_irqsave(&bank->lock, flags);
        omap_enable_gpio_module(bank, offset);
         * disable the bank module.
         */
        if (!BANK_USED(bank))
-               pm_runtime_put(bank->dev);
+               pm_runtime_put(chip->parent);
 }
 
 /*
        if (WARN_ON(!isr_reg))
                goto exit;
 
-       pm_runtime_get_sync(bank->dev);
+       pm_runtime_get_sync(bank->chip.parent);
 
        while (1) {
                u32 isr_saved, level_mask = 0;
                }
        }
 exit:
-       pm_runtime_put(bank->dev);
+       pm_runtime_put(bank->chip.parent);
        return IRQ_HANDLED;
 }
 
        struct gpio_bank *bank = omap_irq_data_get_bank(data);
 
        if (!BANK_USED(bank))
-               pm_runtime_get_sync(bank->dev);
+               pm_runtime_get_sync(bank->chip.parent);
 }
 
 static void gpio_irq_bus_sync_unlock(struct irq_data *data)
         * disable the bank module.
         */
        if (!BANK_USED(bank))
-               pm_runtime_put(bank->dev);
+               pm_runtime_put(bank->chip.parent);
 }
 
 static void omap_gpio_ack_irq(struct irq_data *d)
 
        ret = gpiochip_add_data(&bank->chip, bank);
        if (ret) {
-               dev_err(bank->dev, "Could not register gpio chip %d\n", ret);
+               dev_err(bank->chip.parent,
+                       "Could not register gpio chip %d\n", ret);
                return ret;
        }
 
         */
        irq_base = irq_alloc_descs(-1, 0, bank->width, 0);
        if (irq_base < 0) {
-               dev_err(bank->dev, "Couldn't allocate IRQ numbers\n");
+               dev_err(bank->chip.parent, "Couldn't allocate IRQ numbers\n");
                return -ENODEV;
        }
 #endif
                                   IRQ_TYPE_NONE);
 
        if (ret) {
-               dev_err(bank->dev, "Couldn't add irqchip to gpiochip %d\n", ret);
+               dev_err(bank->chip.parent,
+                       "Couldn't add irqchip to gpiochip %d\n", ret);
                gpiochip_remove(&bank->chip);
                return -ENODEV;
        }
 
        gpiochip_set_chained_irqchip(&bank->chip, irqc, bank->irq, NULL);
 
-       ret = devm_request_irq(bank->dev, bank->irq, omap_gpio_irq_handler,
-                              0, dev_name(bank->dev), bank);
+       ret = devm_request_irq(bank->chip.parent, bank->irq,
+                              omap_gpio_irq_handler,
+                              0, dev_name(bank->chip.parent), bank);
        if (ret)
                gpiochip_remove(&bank->chip);
 
                return bank->irq;
        }
 
-       bank->dev = dev;
        bank->chip.parent = dev;
        bank->chip.owner = THIS_MODULE;
        bank->dbck_flag = pdata->dbck_flag;
        }
 
        if (bank->dbck_flag) {
-               bank->dbck = devm_clk_get(bank->dev, "dbclk");
+               bank->dbck = devm_clk_get(dev, "dbclk");
                if (IS_ERR(bank->dbck)) {
-                       dev_err(bank->dev,
+                       dev_err(dev,
                                "Could not get gpio dbck. Disable debounce\n");
                        bank->dbck_flag = false;
                } else {
 
        platform_set_drvdata(pdev, bank);
 
-       pm_runtime_enable(bank->dev);
-       pm_runtime_irq_safe(bank->dev);
-       pm_runtime_get_sync(bank->dev);
+       pm_runtime_enable(dev);
+       pm_runtime_irq_safe(dev);
+       pm_runtime_get_sync(dev);
 
        if (bank->is_mpuio)
                omap_mpuio_init(bank);
 
        ret = omap_gpio_chip_init(bank, irqc);
        if (ret) {
-               pm_runtime_put_sync(bank->dev);
-               pm_runtime_disable(bank->dev);
+               pm_runtime_put_sync(dev);
+               pm_runtime_disable(dev);
                return ret;
        }
 
        omap_gpio_show_rev(bank);
 
-       pm_runtime_put(bank->dev);
+       pm_runtime_put(dev);
 
        list_add_tail(&bank->node, &omap_gpio_list);
 
 
        list_del(&bank->node);
        gpiochip_remove(&bank->chip);
-       pm_runtime_disable(bank->dev);
+       pm_runtime_disable(&pdev->dev);
        if (bank->dbck_flag)
                clk_unprepare(bank->dbck);
 
 update_gpio_context_count:
        if (bank->get_context_loss_count)
                bank->context_loss_count =
-                               bank->get_context_loss_count(bank->dev);
+                               bank->get_context_loss_count(dev);
 
        omap_gpio_dbck_disable(bank);
        raw_spin_unlock_irqrestore(&bank->lock, flags);
 
                if (bank->get_context_loss_count)
                        bank->context_loss_count =
-                               bank->get_context_loss_count(bank->dev);
+                               bank->get_context_loss_count(dev);
        }
 
        omap_gpio_dbck_enable(bank);
                if (!bank->get_context_loss_count) {
                        omap_gpio_restore_context(bank);
                } else {
-                       c = bank->get_context_loss_count(bank->dev);
+                       c = bank->get_context_loss_count(dev);
                        if (c != bank->context_loss_count) {
                                omap_gpio_restore_context(bank);
                        } else {
 
                bank->power_mode = pwr_mode;
 
-               pm_runtime_put_sync_suspend(bank->dev);
+               pm_runtime_put_sync_suspend(bank->chip.parent);
        }
 }
 
                if (!BANK_USED(bank) || !bank->loses_context)
                        continue;
 
-               pm_runtime_get_sync(bank->dev);
+               pm_runtime_get_sync(bank->chip.parent);
        }
 }
 #endif