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