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