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/slab.h> 22 #include <linux/delay.h> 23 #include <linux/errno.h> 24 #include <linux/kernel.h> 25 #include <linux/module.h> 26 #include <linux/gpio/consumer.h> 27 #include <linux/interrupt.h> 28 #include <linux/platform_device.h> 29 30 /* 31 * Bit counts are derived from Nokia implementation. These should be checked 32 * if other CBUS implementations appear. 33 */ 34 #define CBUS_ADDR_BITS 3 35 #define CBUS_REG_BITS 5 36 37 struct cbus_host { 38 spinlock_t lock; /* host lock */ 39 struct device *dev; 40 struct gpio_desc *clk; 41 struct gpio_desc *dat; 42 struct gpio_desc *sel; 43 }; 44 45 /** 46 * cbus_send_bit - sends one bit over the bus 47 * @host: the host we're using 48 * @bit: one bit of information to send 49 */ 50 static void cbus_send_bit(struct cbus_host *host, unsigned bit) 51 { 52 gpiod_set_value(host->dat, bit ? 1 : 0); 53 gpiod_set_value(host->clk, 1); 54 gpiod_set_value(host->clk, 0); 55 } 56 57 /** 58 * cbus_send_data - sends @len amount of data over the bus 59 * @host: the host we're using 60 * @data: the data to send 61 * @len: size of the transfer 62 */ 63 static void cbus_send_data(struct cbus_host *host, unsigned data, unsigned len) 64 { 65 int i; 66 67 for (i = len; i > 0; i--) 68 cbus_send_bit(host, data & (1 << (i - 1))); 69 } 70 71 /** 72 * cbus_receive_bit - receives one bit from the bus 73 * @host: the host we're using 74 */ 75 static int cbus_receive_bit(struct cbus_host *host) 76 { 77 int ret; 78 79 gpiod_set_value(host->clk, 1); 80 ret = gpiod_get_value(host->dat); 81 gpiod_set_value(host->clk, 0); 82 return ret; 83 } 84 85 /** 86 * cbus_receive_word - receives 16-bit word from the bus 87 * @host: the host we're using 88 */ 89 static int cbus_receive_word(struct cbus_host *host) 90 { 91 int ret = 0; 92 int i; 93 94 for (i = 16; i > 0; i--) { 95 int bit = cbus_receive_bit(host); 96 97 if (bit < 0) 98 return bit; 99 100 if (bit) 101 ret |= 1 << (i - 1); 102 } 103 return ret; 104 } 105 106 /** 107 * cbus_transfer - transfers data over the bus 108 * @host: the host we're using 109 * @rw: read/write flag 110 * @dev: device address 111 * @reg: register address 112 * @data: if @rw == I2C_SBUS_WRITE data to send otherwise 0 113 */ 114 static int cbus_transfer(struct cbus_host *host, char rw, unsigned dev, 115 unsigned reg, unsigned data) 116 { 117 unsigned long flags; 118 int ret; 119 120 /* We don't want interrupts disturbing our transfer */ 121 spin_lock_irqsave(&host->lock, flags); 122 123 /* Reset state and start of transfer, SEL stays down during transfer */ 124 gpiod_set_value(host->sel, 0); 125 126 /* Set the DAT pin to output */ 127 gpiod_direction_output(host->dat, 1); 128 129 /* Send the device address */ 130 cbus_send_data(host, dev, CBUS_ADDR_BITS); 131 132 /* Send the rw flag */ 133 cbus_send_bit(host, rw == I2C_SMBUS_READ); 134 135 /* Send the register address */ 136 cbus_send_data(host, reg, CBUS_REG_BITS); 137 138 if (rw == I2C_SMBUS_WRITE) { 139 cbus_send_data(host, data, 16); 140 ret = 0; 141 } else { 142 ret = gpiod_direction_input(host->dat); 143 if (ret) { 144 dev_dbg(host->dev, "failed setting direction\n"); 145 goto out; 146 } 147 gpiod_set_value(host->clk, 1); 148 149 ret = cbus_receive_word(host); 150 if (ret < 0) { 151 dev_dbg(host->dev, "failed receiving data\n"); 152 goto out; 153 } 154 } 155 156 /* Indicate end of transfer, SEL goes up until next transfer */ 157 gpiod_set_value(host->sel, 1); 158 gpiod_set_value(host->clk, 1); 159 gpiod_set_value(host->clk, 0); 160 161 out: 162 spin_unlock_irqrestore(&host->lock, flags); 163 164 return ret; 165 } 166 167 static int cbus_i2c_smbus_xfer(struct i2c_adapter *adapter, 168 u16 addr, 169 unsigned short flags, 170 char read_write, 171 u8 command, 172 int size, 173 union i2c_smbus_data *data) 174 { 175 struct cbus_host *chost = i2c_get_adapdata(adapter); 176 int ret; 177 178 if (size != I2C_SMBUS_WORD_DATA) 179 return -EINVAL; 180 181 ret = cbus_transfer(chost, read_write == I2C_SMBUS_READ, addr, 182 command, data->word); 183 if (ret < 0) 184 return ret; 185 186 if (read_write == I2C_SMBUS_READ) 187 data->word = ret; 188 189 return 0; 190 } 191 192 static u32 cbus_i2c_func(struct i2c_adapter *adapter) 193 { 194 return I2C_FUNC_SMBUS_READ_WORD_DATA | I2C_FUNC_SMBUS_WRITE_WORD_DATA; 195 } 196 197 static const struct i2c_algorithm cbus_i2c_algo = { 198 .smbus_xfer = cbus_i2c_smbus_xfer, 199 .functionality = cbus_i2c_func, 200 }; 201 202 static int cbus_i2c_remove(struct platform_device *pdev) 203 { 204 struct i2c_adapter *adapter = platform_get_drvdata(pdev); 205 206 i2c_del_adapter(adapter); 207 208 return 0; 209 } 210 211 static int cbus_i2c_probe(struct platform_device *pdev) 212 { 213 struct i2c_adapter *adapter; 214 struct cbus_host *chost; 215 216 adapter = devm_kzalloc(&pdev->dev, sizeof(struct i2c_adapter), 217 GFP_KERNEL); 218 if (!adapter) 219 return -ENOMEM; 220 221 chost = devm_kzalloc(&pdev->dev, sizeof(*chost), GFP_KERNEL); 222 if (!chost) 223 return -ENOMEM; 224 225 if (gpiod_count(&pdev->dev, NULL) != 3) 226 return -ENODEV; 227 chost->clk = devm_gpiod_get_index(&pdev->dev, NULL, 0, GPIOD_OUT_LOW); 228 if (IS_ERR(chost->clk)) 229 return PTR_ERR(chost->clk); 230 chost->dat = devm_gpiod_get_index(&pdev->dev, NULL, 1, GPIOD_IN); 231 if (IS_ERR(chost->dat)) 232 return PTR_ERR(chost->dat); 233 chost->sel = devm_gpiod_get_index(&pdev->dev, NULL, 2, GPIOD_OUT_HIGH); 234 if (IS_ERR(chost->sel)) 235 return PTR_ERR(chost->sel); 236 gpiod_set_consumer_name(chost->clk, "CBUS clk"); 237 gpiod_set_consumer_name(chost->dat, "CBUS dat"); 238 gpiod_set_consumer_name(chost->sel, "CBUS sel"); 239 240 adapter->owner = THIS_MODULE; 241 adapter->class = I2C_CLASS_HWMON; 242 adapter->dev.parent = &pdev->dev; 243 adapter->dev.of_node = pdev->dev.of_node; 244 adapter->nr = pdev->id; 245 adapter->timeout = HZ; 246 adapter->algo = &cbus_i2c_algo; 247 strlcpy(adapter->name, "CBUS I2C adapter", sizeof(adapter->name)); 248 249 spin_lock_init(&chost->lock); 250 chost->dev = &pdev->dev; 251 252 i2c_set_adapdata(adapter, chost); 253 platform_set_drvdata(pdev, adapter); 254 255 return i2c_add_numbered_adapter(adapter); 256 } 257 258 #if defined(CONFIG_OF) 259 static const struct of_device_id i2c_cbus_dt_ids[] = { 260 { .compatible = "i2c-cbus-gpio", }, 261 { } 262 }; 263 MODULE_DEVICE_TABLE(of, i2c_cbus_dt_ids); 264 #endif 265 266 static struct platform_driver cbus_i2c_driver = { 267 .probe = cbus_i2c_probe, 268 .remove = cbus_i2c_remove, 269 .driver = { 270 .name = "i2c-cbus-gpio", 271 .of_match_table = of_match_ptr(i2c_cbus_dt_ids), 272 }, 273 }; 274 module_platform_driver(cbus_i2c_driver); 275 276 MODULE_ALIAS("platform:i2c-cbus-gpio"); 277 MODULE_DESCRIPTION("CBUS I2C driver"); 278 MODULE_AUTHOR("Juha Yrjölä"); 279 MODULE_AUTHOR("David Weinehall"); 280 MODULE_AUTHOR("Mikko Ylinen"); 281 MODULE_AUTHOR("Felipe Balbi"); 282 MODULE_AUTHOR("Aaro Koskinen <aaro.koskinen@iki.fi>"); 283 MODULE_LICENSE("GPL"); 284