#include <linux/clkdev.h>
 #include <linux/irq.h>
 #include <linux/gpio.h>
+#include <linux/gpio/machine.h>
 #include <linux/kernel.h>
 #include <linux/init.h>
 #include <linux/mutex.h>
 #include <linux/platform_data/keypad-omap.h>
 #include <linux/platform_data/lcd-mipid.h>
 #include <linux/platform_data/gpio-omap.h>
-#include <linux/platform_data/i2c-cbus-gpio.h>
 
 #include <asm/mach-types.h>
 #include <asm/mach/arch.h>
 #endif
 
 #if IS_ENABLED(CONFIG_I2C_CBUS_GPIO)
-static struct i2c_cbus_platform_data nokia770_cbus_data = {
-       .clk_gpio = OMAP_MPUIO(9),
-       .dat_gpio = OMAP_MPUIO(10),
-       .sel_gpio = OMAP_MPUIO(11),
+static struct gpiod_lookup_table nokia770_cbus_gpio_table = {
+       .dev_id = "i2c-cbus-gpio.2",
+       .table = {
+               GPIO_LOOKUP_IDX("mpuio", 9, NULL, 0, 0), /* clk */
+               GPIO_LOOKUP_IDX("mpuio", 10, NULL, 1, 0), /* dat */
+               GPIO_LOOKUP_IDX("mpuio", 11, NULL, 2, 0), /* sel */
+               { },
+       },
 };
 
 static struct platform_device nokia770_cbus_device = {
        .name   = "i2c-cbus-gpio",
        .id     = 2,
-       .dev    = {
-               .platform_data = &nokia770_cbus_data,
-       },
 };
 
 static struct i2c_board_info nokia770_i2c_board_info_2[] __initdata = {
        nokia770_i2c_board_info_2[1].irq = gpio_to_irq(tahvo_irq_gpio);
        i2c_register_board_info(2, nokia770_i2c_board_info_2,
                                ARRAY_SIZE(nokia770_i2c_board_info_2));
+       gpiod_add_lookup_table(&nokia770_cbus_gpio_table);
        platform_device_register(&nokia770_cbus_device);
 }
 #else /* CONFIG_I2C_CBUS_GPIO */
 
 
 #include <linux/io.h>
 #include <linux/i2c.h>
-#include <linux/gpio.h>
 #include <linux/slab.h>
 #include <linux/delay.h>
 #include <linux/errno.h>
 #include <linux/kernel.h>
 #include <linux/module.h>
-#include <linux/of_gpio.h>
+#include <linux/gpio/consumer.h>
 #include <linux/interrupt.h>
 #include <linux/platform_device.h>
-#include <linux/platform_data/i2c-cbus-gpio.h>
 
 /*
  * Bit counts are derived from Nokia implementation. These should be checked
 struct cbus_host {
        spinlock_t      lock;           /* host lock */
        struct device   *dev;
-       int             clk_gpio;
-       int             dat_gpio;
-       int             sel_gpio;
+       struct gpio_desc *clk;
+       struct gpio_desc *dat;
+       struct gpio_desc *sel;
 };
 
 /**
  */
 static void cbus_send_bit(struct cbus_host *host, unsigned bit)
 {
-       gpio_set_value(host->dat_gpio, bit ? 1 : 0);
-       gpio_set_value(host->clk_gpio, 1);
-       gpio_set_value(host->clk_gpio, 0);
+       gpiod_set_value(host->dat, bit ? 1 : 0);
+       gpiod_set_value(host->clk, 1);
+       gpiod_set_value(host->clk, 0);
 }
 
 /**
 {
        int ret;
 
-       gpio_set_value(host->clk_gpio, 1);
-       ret = gpio_get_value(host->dat_gpio);
-       gpio_set_value(host->clk_gpio, 0);
+       gpiod_set_value(host->clk, 1);
+       ret = gpiod_get_value(host->dat);
+       gpiod_set_value(host->clk, 0);
        return ret;
 }
 
        spin_lock_irqsave(&host->lock, flags);
 
        /* Reset state and start of transfer, SEL stays down during transfer */
-       gpio_set_value(host->sel_gpio, 0);
+       gpiod_set_value(host->sel, 0);
 
        /* Set the DAT pin to output */
-       gpio_direction_output(host->dat_gpio, 1);
+       gpiod_direction_output(host->dat, 1);
 
        /* Send the device address */
        cbus_send_data(host, dev, CBUS_ADDR_BITS);
                cbus_send_data(host, data, 16);
                ret = 0;
        } else {
-               ret = gpio_direction_input(host->dat_gpio);
+               ret = gpiod_direction_input(host->dat);
                if (ret) {
                        dev_dbg(host->dev, "failed setting direction\n");
                        goto out;
                }
-               gpio_set_value(host->clk_gpio, 1);
+               gpiod_set_value(host->clk, 1);
 
                ret = cbus_receive_word(host);
                if (ret < 0) {
        }
 
        /* Indicate end of transfer, SEL goes up until next transfer */
-       gpio_set_value(host->sel_gpio, 1);
-       gpio_set_value(host->clk_gpio, 1);
-       gpio_set_value(host->clk_gpio, 0);
+       gpiod_set_value(host->sel, 1);
+       gpiod_set_value(host->clk, 1);
+       gpiod_set_value(host->clk, 0);
 
 out:
        spin_unlock_irqrestore(&host->lock, flags);
 {
        struct i2c_adapter *adapter;
        struct cbus_host *chost;
-       int ret;
 
        adapter = devm_kzalloc(&pdev->dev, sizeof(struct i2c_adapter),
                               GFP_KERNEL);
        if (!chost)
                return -ENOMEM;
 
-       if (pdev->dev.of_node) {
-               struct device_node *dnode = pdev->dev.of_node;
-               if (of_gpio_count(dnode) != 3)
-                       return -ENODEV;
-               chost->clk_gpio = of_get_gpio(dnode, 0);
-               chost->dat_gpio = of_get_gpio(dnode, 1);
-               chost->sel_gpio = of_get_gpio(dnode, 2);
-       } else if (dev_get_platdata(&pdev->dev)) {
-               struct i2c_cbus_platform_data *pdata =
-                       dev_get_platdata(&pdev->dev);
-               chost->clk_gpio = pdata->clk_gpio;
-               chost->dat_gpio = pdata->dat_gpio;
-               chost->sel_gpio = pdata->sel_gpio;
-       } else {
+       if (gpiod_count(&pdev->dev, NULL) != 3)
                return -ENODEV;
-       }
+       chost->clk = devm_gpiod_get_index(&pdev->dev, NULL, 0, GPIOD_OUT_LOW);
+       if (IS_ERR(chost->clk))
+               return PTR_ERR(chost->clk);
+       chost->dat = devm_gpiod_get_index(&pdev->dev, NULL, 1, GPIOD_IN);
+       if (IS_ERR(chost->dat))
+               return PTR_ERR(chost->dat);
+       chost->sel = devm_gpiod_get_index(&pdev->dev, NULL, 2, GPIOD_OUT_HIGH);
+       if (IS_ERR(chost->sel))
+               return PTR_ERR(chost->sel);
+       gpiod_set_consumer_name(chost->clk, "CBUS clk");
+       gpiod_set_consumer_name(chost->dat, "CBUS dat");
+       gpiod_set_consumer_name(chost->sel, "CBUS sel");
 
        adapter->owner          = THIS_MODULE;
        adapter->class          = I2C_CLASS_HWMON;
        spin_lock_init(&chost->lock);
        chost->dev = &pdev->dev;
 
-       ret = devm_gpio_request_one(&pdev->dev, chost->clk_gpio,
-                                   GPIOF_OUT_INIT_LOW, "CBUS clk");
-       if (ret)
-               return ret;
-
-       ret = devm_gpio_request_one(&pdev->dev, chost->dat_gpio, GPIOF_IN,
-                                   "CBUS data");
-       if (ret)
-               return ret;
-
-       ret = devm_gpio_request_one(&pdev->dev, chost->sel_gpio,
-                                   GPIOF_OUT_INIT_HIGH, "CBUS sel");
-       if (ret)
-               return ret;
-
        i2c_set_adapdata(adapter, chost);
        platform_set_drvdata(pdev, adapter);