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.h> 19 #include <linux/of_gpio.h> 20 21 struct i2c_gpio_private_data { 22 struct i2c_adapter adap; 23 struct i2c_algo_bit_data bit_data; 24 struct i2c_gpio_platform_data pdata; 25 }; 26 27 /* Toggle SDA by changing the direction of the pin */ 28 static void i2c_gpio_setsda_dir(void *data, int state) 29 { 30 struct i2c_gpio_platform_data *pdata = data; 31 32 if (state) 33 gpio_direction_input(pdata->sda_pin); 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) 56 gpio_direction_input(pdata->scl_pin); 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 of_i2c_gpio_get_pins(struct device_node *np, 89 unsigned int *sda_pin, unsigned int *scl_pin) 90 { 91 if (of_gpio_count(np) < 2) 92 return -ENODEV; 93 94 *sda_pin = of_get_gpio(np, 0); 95 *scl_pin = of_get_gpio(np, 1); 96 97 if (!gpio_is_valid(*sda_pin) || !gpio_is_valid(*scl_pin)) { 98 pr_err("%s: invalid GPIO pins, sda=%d/scl=%d\n", 99 np->full_name, *sda_pin, *scl_pin); 100 return -ENODEV; 101 } 102 103 return 0; 104 } 105 106 static void of_i2c_gpio_get_props(struct device_node *np, 107 struct i2c_gpio_platform_data *pdata) 108 { 109 u32 reg; 110 111 of_property_read_u32(np, "i2c-gpio,delay-us", &pdata->udelay); 112 113 if (!of_property_read_u32(np, "i2c-gpio,timeout-ms", ®)) 114 pdata->timeout = msecs_to_jiffies(reg); 115 116 pdata->sda_is_open_drain = 117 of_property_read_bool(np, "i2c-gpio,sda-open-drain"); 118 pdata->scl_is_open_drain = 119 of_property_read_bool(np, "i2c-gpio,scl-open-drain"); 120 pdata->scl_is_output_only = 121 of_property_read_bool(np, "i2c-gpio,scl-output-only"); 122 } 123 124 static int i2c_gpio_probe(struct platform_device *pdev) 125 { 126 struct i2c_gpio_private_data *priv; 127 struct i2c_gpio_platform_data *pdata; 128 struct i2c_algo_bit_data *bit_data; 129 struct i2c_adapter *adap; 130 unsigned int sda_pin, scl_pin; 131 int ret; 132 133 /* First get the GPIO pins; if it fails, we'll defer the probe. */ 134 if (pdev->dev.of_node) { 135 ret = of_i2c_gpio_get_pins(pdev->dev.of_node, 136 &sda_pin, &scl_pin); 137 if (ret) 138 return ret; 139 } else { 140 if (!dev_get_platdata(&pdev->dev)) 141 return -ENXIO; 142 pdata = dev_get_platdata(&pdev->dev); 143 sda_pin = pdata->sda_pin; 144 scl_pin = pdata->scl_pin; 145 } 146 147 ret = gpio_request(sda_pin, "sda"); 148 if (ret) { 149 if (ret == -EINVAL) 150 ret = -EPROBE_DEFER; /* Try again later */ 151 goto err_request_sda; 152 } 153 ret = gpio_request(scl_pin, "scl"); 154 if (ret) { 155 if (ret == -EINVAL) 156 ret = -EPROBE_DEFER; /* Try again later */ 157 goto err_request_scl; 158 } 159 160 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 161 if (!priv) { 162 ret = -ENOMEM; 163 goto err_add_bus; 164 } 165 adap = &priv->adap; 166 bit_data = &priv->bit_data; 167 pdata = &priv->pdata; 168 169 if (pdev->dev.of_node) { 170 pdata->sda_pin = sda_pin; 171 pdata->scl_pin = scl_pin; 172 of_i2c_gpio_get_props(pdev->dev.of_node, pdata); 173 } else { 174 memcpy(pdata, dev_get_platdata(&pdev->dev), sizeof(*pdata)); 175 } 176 177 if (pdata->sda_is_open_drain) { 178 gpio_direction_output(pdata->sda_pin, 1); 179 bit_data->setsda = i2c_gpio_setsda_val; 180 } else { 181 gpio_direction_input(pdata->sda_pin); 182 bit_data->setsda = i2c_gpio_setsda_dir; 183 } 184 185 if (pdata->scl_is_open_drain || pdata->scl_is_output_only) { 186 gpio_direction_output(pdata->scl_pin, 1); 187 bit_data->setscl = i2c_gpio_setscl_val; 188 } else { 189 gpio_direction_input(pdata->scl_pin); 190 bit_data->setscl = i2c_gpio_setscl_dir; 191 } 192 193 if (!pdata->scl_is_output_only) 194 bit_data->getscl = i2c_gpio_getscl; 195 bit_data->getsda = i2c_gpio_getsda; 196 197 if (pdata->udelay) 198 bit_data->udelay = pdata->udelay; 199 else if (pdata->scl_is_output_only) 200 bit_data->udelay = 50; /* 10 kHz */ 201 else 202 bit_data->udelay = 5; /* 100 kHz */ 203 204 if (pdata->timeout) 205 bit_data->timeout = pdata->timeout; 206 else 207 bit_data->timeout = HZ / 10; /* 100 ms */ 208 209 bit_data->data = pdata; 210 211 adap->owner = THIS_MODULE; 212 if (pdev->dev.of_node) 213 strlcpy(adap->name, dev_name(&pdev->dev), sizeof(adap->name)); 214 else 215 snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id); 216 217 adap->algo_data = bit_data; 218 adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 219 adap->dev.parent = &pdev->dev; 220 adap->dev.of_node = pdev->dev.of_node; 221 222 adap->nr = pdev->id; 223 ret = i2c_bit_add_numbered_bus(adap); 224 if (ret) 225 goto err_add_bus; 226 227 platform_set_drvdata(pdev, priv); 228 229 dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n", 230 pdata->sda_pin, pdata->scl_pin, 231 pdata->scl_is_output_only 232 ? ", no clock stretching" : ""); 233 234 return 0; 235 236 err_add_bus: 237 gpio_free(scl_pin); 238 err_request_scl: 239 gpio_free(sda_pin); 240 err_request_sda: 241 return ret; 242 } 243 244 static int i2c_gpio_remove(struct platform_device *pdev) 245 { 246 struct i2c_gpio_private_data *priv; 247 struct i2c_gpio_platform_data *pdata; 248 struct i2c_adapter *adap; 249 250 priv = platform_get_drvdata(pdev); 251 adap = &priv->adap; 252 pdata = &priv->pdata; 253 254 i2c_del_adapter(adap); 255 gpio_free(pdata->scl_pin); 256 gpio_free(pdata->sda_pin); 257 258 return 0; 259 } 260 261 #if defined(CONFIG_OF) 262 static const struct of_device_id i2c_gpio_dt_ids[] = { 263 { .compatible = "i2c-gpio", }, 264 { /* sentinel */ } 265 }; 266 267 MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids); 268 #endif 269 270 static struct platform_driver i2c_gpio_driver = { 271 .driver = { 272 .name = "i2c-gpio", 273 .owner = THIS_MODULE, 274 .of_match_table = of_match_ptr(i2c_gpio_dt_ids), 275 }, 276 .probe = i2c_gpio_probe, 277 .remove = i2c_gpio_remove, 278 }; 279 280 static int __init i2c_gpio_init(void) 281 { 282 int ret; 283 284 ret = platform_driver_register(&i2c_gpio_driver); 285 if (ret) 286 printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret); 287 288 return ret; 289 } 290 subsys_initcall(i2c_gpio_init); 291 292 static void __exit i2c_gpio_exit(void) 293 { 294 platform_driver_unregister(&i2c_gpio_driver); 295 } 296 module_exit(i2c_gpio_exit); 297 298 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)"); 299 MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver"); 300 MODULE_LICENSE("GPL"); 301 MODULE_ALIAS("platform:i2c-gpio"); 302