drivers/i2c/busses/i2c-cbus-gpio.c

   1 /*
   2  * CBUS I2C driver for Nokia Internet Tablets.
   3  *
   4  * Copyright (C) 2004-2010 Nokia Corporation
   5  *
   6  * Based on code written by Juha Yrjölä, David Weinehall, Mikko Ylinen and
   7  * Felipe Balbi. Converted to I2C driver by Aaro Koskinen.
   8  *
   9  * This file is subject to the terms and conditions of the GNU General
  10  * Public License. See the file "COPYING" in the main directory of this
  11  * archive for more details.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  16  * GNU General Public License for more details.
  17  */
  18
  19 #include <linux/io.h>
  20 #include <linux/i2c.h>
  21 #include <linux/gpio.h>
  22 #include <linux/slab.h>
  23 #include <linux/delay.h>
  24 #include <linux/errno.h>
  25 #include <linux/kernel.h>
  26 #include <linux/module.h>
  27 #include <linux/of_gpio.h>
  28 #include <linux/interrupt.h>
  29 #include <linux/platform_device.h>
  30 #include <linux/platform_data/i2c-cbus-gpio.h>
  31
  32 /*
  33  * Bit counts are derived from Nokia implementation. These should be checked
  34  * if other CBUS implementations appear.
  35  */
  36 #define CBUS_ADDR_BITS  3
  37 #define CBUS_REG_BITS   5
  38
  39 struct cbus_host {
  40         spinlock_t      lock;           /* host lock */
  41         struct device   *dev;
  42         int             clk_gpio;
  43         int             dat_gpio;
  44         int             sel_gpio;
  45 };
  46
  47 /**
  48  * cbus_send_bit - sends one bit over the bus
  49  * @host: the host we're using
  50  * @bit: one bit of information to send
  51  */
  52 static void cbus_send_bit(struct cbus_host *host, unsigned bit)
  53 {
  54         gpio_set_value(host->dat_gpio, bit ? 1 : 0);
  55         gpio_set_value(host->clk_gpio, 1);
  56         gpio_set_value(host->clk_gpio, 0);
  57 }
  58
  59 /**
  60  * cbus_send_data - sends @len amount of data over the bus
  61  * @host: the host we're using
  62  * @data: the data to send
  63  * @len: size of the transfer
  64  */
  65 static void cbus_send_data(struct cbus_host *host, unsigned data, unsigned len)
  66 {
  67         int i;
  68
  69         for (i = len; i > 0; i--)
  70                 cbus_send_bit(host, data & (1 << (i - 1)));
  71 }
  72
  73 /**
  74  * cbus_receive_bit - receives one bit from the bus
  75  * @host: the host we're using
  76  */
  77 static int cbus_receive_bit(struct cbus_host *host)
  78 {
  79         int ret;
  80
  81         gpio_set_value(host->clk_gpio, 1);
  82         ret = gpio_get_value(host->dat_gpio);
  83         gpio_set_value(host->clk_gpio, 0);
  84         return ret;
  85 }
  86
  87 /**
  88  * cbus_receive_word - receives 16-bit word from the bus
  89  * @host: the host we're using
  90  */
  91 static int cbus_receive_word(struct cbus_host *host)
  92 {
  93         int ret = 0;
  94         int i;
  95
  96         for (i = 16; i > 0; i--) {
  97                 int bit = cbus_receive_bit(host);
  98
  99                 if (bit < 0)
 100                         return bit;
 101
 102                 if (bit)
 103                         ret |= 1 << (i - 1);
 104         }
 105         return ret;
 106 }
 107
 108 /**
 109  * cbus_transfer - transfers data over the bus
 110  * @host: the host we're using
 111  * @rw: read/write flag
 112  * @dev: device address
 113  * @reg: register address
 114  * @data: if @rw == I2C_SBUS_WRITE data to send otherwise 0
 115  */
 116 static int cbus_transfer(struct cbus_host *host, char rw, unsigned dev,
 117                          unsigned reg, unsigned data)
 118 {
 119         unsigned long flags;
 120         int ret;
 121
 122         /* We don't want interrupts disturbing our transfer */
 123         spin_lock_irqsave(&host->lock, flags);
 124
 125         /* Reset state and start of transfer, SEL stays down during transfer */
 126         gpio_set_value(host->sel_gpio, 0);
 127
 128         /* Set the DAT pin to output */
 129         gpio_direction_output(host->dat_gpio, 1);
 130
 131         /* Send the device address */
 132         cbus_send_data(host, dev, CBUS_ADDR_BITS);
 133
 134         /* Send the rw flag */
 135         cbus_send_bit(host, rw == I2C_SMBUS_READ);
 136
 137         /* Send the register address */
 138         cbus_send_data(host, reg, CBUS_REG_BITS);
 139
 140         if (rw == I2C_SMBUS_WRITE) {
 141                 cbus_send_data(host, data, 16);
 142                 ret = 0;
 143         } else {
 144                 ret = gpio_direction_input(host->dat_gpio);
 145                 if (ret) {
 146                         dev_dbg(host->dev, "failed setting direction\n");
 147                         goto out;
 148                 }
 149                 gpio_set_value(host->clk_gpio, 1);
 150
 151                 ret = cbus_receive_word(host);
 152                 if (ret < 0) {
 153                         dev_dbg(host->dev, "failed receiving data\n");
 154                         goto out;
 155                 }
 156         }
 157
 158         /* Indicate end of transfer, SEL goes up until next transfer */
 159         gpio_set_value(host->sel_gpio, 1);
 160         gpio_set_value(host->clk_gpio, 1);
 161         gpio_set_value(host->clk_gpio, 0);
 162
 163 out:
 164         spin_unlock_irqrestore(&host->lock, flags);
 165
 166         return ret;
 167 }
 168
 169 static int cbus_i2c_smbus_xfer(struct i2c_adapter       *adapter,
 170                                u16                      addr,
 171                                unsigned short           flags,
 172                                char                     read_write,
 173                                u8                       command,
 174                                int                      size,
 175                                union i2c_smbus_data     *data)
 176 {
 177         struct cbus_host *chost = i2c_get_adapdata(adapter);
 178         int ret;
 179
 180         if (size != I2C_SMBUS_WORD_DATA)
 181                 return -EINVAL;
 182
 183         ret = cbus_transfer(chost, read_write == I2C_SMBUS_READ, addr,
 184                             command, data->word);
 185         if (ret < 0)
 186                 return ret;
 187
 188         if (read_write == I2C_SMBUS_READ)
 189                 data->word = ret;
 190
 191         return 0;
 192 }
 193
 194 static u32 cbus_i2c_func(struct i2c_adapter *adapter)
 195 {
 196         return I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_WRITE_WORD_DATA;
 197 }
 198
 199 static const struct i2c_algorithm cbus_i2c_algo = {
 200         .smbus_xfer     = cbus_i2c_smbus_xfer,
 201         .functionality  = cbus_i2c_func,
 202 };
 203
 204 static int cbus_i2c_remove(struct platform_device *pdev)
 205 {
 206         struct i2c_adapter *adapter = platform_get_drvdata(pdev);
 207
 208         i2c_del_adapter(adapter);
 209
 210         return 0;
 211 }
 212
 213 static int cbus_i2c_probe(struct platform_device *pdev)
 214 {
 215         struct i2c_adapter *adapter;
 216         struct cbus_host *chost;
 217         int ret;
 218
 219         adapter = devm_kzalloc(&pdev->dev, sizeof(struct i2c_adapter),
 220                                GFP_KERNEL);
 221         if (!adapter)
 222                 return -ENOMEM;
 223
 224         chost = devm_kzalloc(&pdev->dev, sizeof(*chost), GFP_KERNEL);
 225         if (!chost)
 226                 return -ENOMEM;
 227
 228         if (pdev->dev.of_node) {
 229                 struct device_node *dnode = pdev->dev.of_node;
 230                 if (of_gpio_count(dnode) != 3)
 231                         return -ENODEV;
 232                 chost->clk_gpio = of_get_gpio(dnode, 0);
 233                 chost->dat_gpio = of_get_gpio(dnode, 1);
 234                 chost->sel_gpio = of_get_gpio(dnode, 2);
 235         } else if (dev_get_platdata(&pdev->dev)) {
 236                 struct i2c_cbus_platform_data *pdata =
 237                         dev_get_platdata(&pdev->dev);
 238                 chost->clk_gpio = pdata->clk_gpio;
 239                 chost->dat_gpio = pdata->dat_gpio;
 240                 chost->sel_gpio = pdata->sel_gpio;
 241         } else {
 242                 return -ENODEV;
 243         }
 244
 245         adapter->owner          = THIS_MODULE;
 246         adapter->class          = I2C_CLASS_HWMON;
 247         adapter->dev.parent     = &pdev->dev;
 248         adapter->dev.of_node    = pdev->dev.of_node;
 249         adapter->nr             = pdev->id;
 250         adapter->timeout        = HZ;
 251         adapter->algo           = &cbus_i2c_algo;
 252         strlcpy(adapter->name, "CBUS I2C adapter", sizeof(adapter->name));
 253
 254         spin_lock_init(&chost->lock);
 255         chost->dev = &pdev->dev;
 256
 257         ret = devm_gpio_request_one(&pdev->dev, chost->clk_gpio,
 258                                     GPIOF_OUT_INIT_LOW, "CBUS clk");
 259         if (ret)
 260                 return ret;
 261
 262         ret = devm_gpio_request_one(&pdev->dev, chost->dat_gpio, GPIOF_IN,
 263                                     "CBUS data");
 264         if (ret)
 265                 return ret;
 266
 267         ret = devm_gpio_request_one(&pdev->dev, chost->sel_gpio,
 268                                     GPIOF_OUT_INIT_HIGH, "CBUS sel");
 269         if (ret)
 270                 return ret;
 271
 272         i2c_set_adapdata(adapter, chost);
 273         platform_set_drvdata(pdev, adapter);
 274
 275         return i2c_add_numbered_adapter(adapter);
 276 }
 277
 278 #if defined(CONFIG_OF)
 279 static const struct of_device_id i2c_cbus_dt_ids[] = {
 280         { .compatible = "i2c-cbus-gpio", },
 281         { }
 282 };
 283 MODULE_DEVICE_TABLE(of, i2c_cbus_dt_ids);
 284 #endif
 285
 286 static struct platform_driver cbus_i2c_driver = {
 287         .probe  = cbus_i2c_probe,
 288         .remove = cbus_i2c_remove,
 289         .driver = {
 290                 .owner  = THIS_MODULE,
 291                 .name   = "i2c-cbus-gpio",
 292                 .of_match_table = of_match_ptr(i2c_cbus_dt_ids),
 293         },
 294 };
 295 module_platform_driver(cbus_i2c_driver);
 296
 297 MODULE_ALIAS("platform:i2c-cbus-gpio");
 298 MODULE_DESCRIPTION("CBUS I2C driver");
 299 MODULE_AUTHOR("Juha Yrjölä");
 300 MODULE_AUTHOR("David Weinehall");
 301 MODULE_AUTHOR("Mikko Ylinen");
 302 MODULE_AUTHOR("Felipe Balbi");
 303 MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>");
 304 MODULE_LICENSE("GPL");