Linux Kernel  3.7.1
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Macros Groups Pages
i2c-gpio.c
Go to the documentation of this file.
1 /*
2  * Bitbanging I2C bus driver using the GPIO API
3  *
4  * Copyright (C) 2007 Atmel Corporation
5  *
6  * This program is free software; you can redistribute it and/or modify
7  * it under the terms of the GNU General Public License version 2 as
8  * published by the Free Software Foundation.
9  */
10 #include <linux/i2c.h>
11 #include <linux/i2c-algo-bit.h>
12 #include <linux/i2c-gpio.h>
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/slab.h>
16 #include <linux/platform_device.h>
17 #include <linux/gpio.h>
18 #include <linux/of_gpio.h>
19 #include <linux/of_i2c.h>
20 
22  struct i2c_adapter adap;
25 };
26 
27 /* Toggle SDA by changing the direction of the pin */
28 static void i2c_gpio_setsda_dir(void *data, int state)
29 {
31 
32  if (state)
34  else
35  gpio_direction_output(pdata->sda_pin, 0);
36 }
37 
38 /*
39  * Toggle SDA by changing the output value of the pin. This is only
40  * valid for pins configured as open drain (i.e. setting the value
41  * high effectively turns off the output driver.)
42  */
43 static void i2c_gpio_setsda_val(void *data, int state)
44 {
45  struct i2c_gpio_platform_data *pdata = data;
46 
47  gpio_set_value(pdata->sda_pin, state);
48 }
49 
50 /* Toggle SCL by changing the direction of the pin. */
51 static void i2c_gpio_setscl_dir(void *data, int state)
52 {
53  struct i2c_gpio_platform_data *pdata = data;
54 
55  if (state)
57  else
58  gpio_direction_output(pdata->scl_pin, 0);
59 }
60 
61 /*
62  * Toggle SCL by changing the output value of the pin. This is used
63  * for pins that are configured as open drain and for output-only
64  * pins. The latter case will break the i2c protocol, but it will
65  * often work in practice.
66  */
67 static void i2c_gpio_setscl_val(void *data, int state)
68 {
69  struct i2c_gpio_platform_data *pdata = data;
70 
71  gpio_set_value(pdata->scl_pin, state);
72 }
73 
74 static int i2c_gpio_getsda(void *data)
75 {
76  struct i2c_gpio_platform_data *pdata = data;
77 
78  return gpio_get_value(pdata->sda_pin);
79 }
80 
81 static int i2c_gpio_getscl(void *data)
82 {
83  struct i2c_gpio_platform_data *pdata = data;
84 
85  return gpio_get_value(pdata->scl_pin);
86 }
87 
88 static int __devinit of_i2c_gpio_probe(struct device_node *np,
89  struct i2c_gpio_platform_data *pdata)
90 {
91  u32 reg;
92 
93  if (of_gpio_count(np) < 2)
94  return -ENODEV;
95 
96  pdata->sda_pin = of_get_gpio(np, 0);
97  pdata->scl_pin = of_get_gpio(np, 1);
98 
99  if (!gpio_is_valid(pdata->sda_pin) || !gpio_is_valid(pdata->scl_pin)) {
100  pr_err("%s: invalid GPIO pins, sda=%d/scl=%d\n",
101  np->full_name, pdata->sda_pin, pdata->scl_pin);
102  return -ENODEV;
103  }
104 
105  of_property_read_u32(np, "i2c-gpio,delay-us", &pdata->udelay);
106 
107  if (!of_property_read_u32(np, "i2c-gpio,timeout-ms", &reg))
108  pdata->timeout = msecs_to_jiffies(reg);
109 
110  pdata->sda_is_open_drain =
111  of_property_read_bool(np, "i2c-gpio,sda-open-drain");
112  pdata->scl_is_open_drain =
113  of_property_read_bool(np, "i2c-gpio,scl-open-drain");
114  pdata->scl_is_output_only =
115  of_property_read_bool(np, "i2c-gpio,scl-output-only");
116 
117  return 0;
118 }
119 
120 static int __devinit i2c_gpio_probe(struct platform_device *pdev)
121 {
122  struct i2c_gpio_private_data *priv;
124  struct i2c_algo_bit_data *bit_data;
125  struct i2c_adapter *adap;
126  int ret;
127 
128  priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL);
129  if (!priv)
130  return -ENOMEM;
131  adap = &priv->adap;
132  bit_data = &priv->bit_data;
133  pdata = &priv->pdata;
134 
135  if (pdev->dev.of_node) {
136  ret = of_i2c_gpio_probe(pdev->dev.of_node, pdata);
137  if (ret)
138  return ret;
139  } else {
140  if (!pdev->dev.platform_data)
141  return -ENXIO;
142  memcpy(pdata, pdev->dev.platform_data, sizeof(*pdata));
143  }
144 
145  ret = gpio_request(pdata->sda_pin, "sda");
146  if (ret)
147  goto err_request_sda;
148  ret = gpio_request(pdata->scl_pin, "scl");
149  if (ret)
150  goto err_request_scl;
151 
152  if (pdata->sda_is_open_drain) {
153  gpio_direction_output(pdata->sda_pin, 1);
154  bit_data->setsda = i2c_gpio_setsda_val;
155  } else {
157  bit_data->setsda = i2c_gpio_setsda_dir;
158  }
159 
160  if (pdata->scl_is_open_drain || pdata->scl_is_output_only) {
161  gpio_direction_output(pdata->scl_pin, 1);
162  bit_data->setscl = i2c_gpio_setscl_val;
163  } else {
165  bit_data->setscl = i2c_gpio_setscl_dir;
166  }
167 
168  if (!pdata->scl_is_output_only)
169  bit_data->getscl = i2c_gpio_getscl;
170  bit_data->getsda = i2c_gpio_getsda;
171 
172  if (pdata->udelay)
173  bit_data->udelay = pdata->udelay;
174  else if (pdata->scl_is_output_only)
175  bit_data->udelay = 50; /* 10 kHz */
176  else
177  bit_data->udelay = 5; /* 100 kHz */
178 
179  if (pdata->timeout)
180  bit_data->timeout = pdata->timeout;
181  else
182  bit_data->timeout = HZ / 10; /* 100 ms */
183 
184  bit_data->data = pdata;
185 
186  adap->owner = THIS_MODULE;
187  snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);
188  adap->algo_data = bit_data;
190  adap->dev.parent = &pdev->dev;
191  adap->dev.of_node = pdev->dev.of_node;
192 
193  adap->nr = pdev->id;
194  ret = i2c_bit_add_numbered_bus(adap);
195  if (ret)
196  goto err_add_bus;
197 
199 
200  platform_set_drvdata(pdev, priv);
201 
202  dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n",
203  pdata->sda_pin, pdata->scl_pin,
204  pdata->scl_is_output_only
205  ? ", no clock stretching" : "");
206 
207  return 0;
208 
209 err_add_bus:
210  gpio_free(pdata->scl_pin);
211 err_request_scl:
212  gpio_free(pdata->sda_pin);
213 err_request_sda:
214  return ret;
215 }
216 
217 static int __devexit i2c_gpio_remove(struct platform_device *pdev)
218 {
219  struct i2c_gpio_private_data *priv;
221  struct i2c_adapter *adap;
222 
223  priv = platform_get_drvdata(pdev);
224  adap = &priv->adap;
225  pdata = &priv->pdata;
226 
227  i2c_del_adapter(adap);
228  gpio_free(pdata->scl_pin);
229  gpio_free(pdata->sda_pin);
230 
231  return 0;
232 }
233 
234 #if defined(CONFIG_OF)
235 static const struct of_device_id i2c_gpio_dt_ids[] = {
236  { .compatible = "i2c-gpio", },
237  { /* sentinel */ }
238 };
239 
240 MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids);
241 #endif
242 
243 static struct platform_driver i2c_gpio_driver = {
244  .driver = {
245  .name = "i2c-gpio",
246  .owner = THIS_MODULE,
247  .of_match_table = of_match_ptr(i2c_gpio_dt_ids),
248  },
249  .probe = i2c_gpio_probe,
250  .remove = __devexit_p(i2c_gpio_remove),
251 };
252 
253 static int __init i2c_gpio_init(void)
254 {
255  int ret;
256 
257  ret = platform_driver_register(&i2c_gpio_driver);
258  if (ret)
259  printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);
260 
261  return ret;
262 }
263 subsys_initcall(i2c_gpio_init);
264 
265 static void __exit i2c_gpio_exit(void)
266 {
267  platform_driver_unregister(&i2c_gpio_driver);
268 }
269 module_exit(i2c_gpio_exit);
270 
271 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
272 MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver");
273 MODULE_LICENSE("GPL");
274 MODULE_ALIAS("platform:i2c-gpio");