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 = devm_gpio_request(&pdev->dev, sda_pin, "sda"); 151 if (ret) { 152 if (ret == -EINVAL) 153 ret = -EPROBE_DEFER; /* Try again later */ 154 return ret; 155 } 156 ret = devm_gpio_request(&pdev->dev, scl_pin, "scl"); 157 if (ret) { 158 if (ret == -EINVAL) 159 ret = -EPROBE_DEFER; /* Try again later */ 160 return ret; 161 } 162 163 priv = devm_kzalloc(&pdev->dev, sizeof(*priv), GFP_KERNEL); 164 if (!priv) 165 return -ENOMEM; 166 adap = &priv->adap; 167 bit_data = &priv->bit_data; 168 pdata = &priv->pdata; 169 170 if (pdev->dev.of_node) { 171 pdata->sda_pin = sda_pin; 172 pdata->scl_pin = scl_pin; 173 of_i2c_gpio_get_props(pdev->dev.of_node, pdata); 174 } else { 175 memcpy(pdata, dev_get_platdata(&pdev->dev), sizeof(*pdata)); 176 } 177 178 if (pdata->sda_is_open_drain) { 179 gpio_direction_output(pdata->sda_pin, 1); 180 bit_data->setsda = i2c_gpio_setsda_val; 181 } else { 182 gpio_direction_input(pdata->sda_pin); 183 bit_data->setsda = i2c_gpio_setsda_dir; 184 } 185 186 if (pdata->scl_is_open_drain || pdata->scl_is_output_only) { 187 gpio_direction_output(pdata->scl_pin, 1); 188 bit_data->setscl = i2c_gpio_setscl_val; 189 } else { 190 gpio_direction_input(pdata->scl_pin); 191 bit_data->setscl = i2c_gpio_setscl_dir; 192 } 193 194 if (!pdata->scl_is_output_only) 195 bit_data->getscl = i2c_gpio_getscl; 196 bit_data->getsda = i2c_gpio_getsda; 197 198 if (pdata->udelay) 199 bit_data->udelay = pdata->udelay; 200 else if (pdata->scl_is_output_only) 201 bit_data->udelay = 50; /* 10 kHz */ 202 else 203 bit_data->udelay = 5; /* 100 kHz */ 204 205 if (pdata->timeout) 206 bit_data->timeout = pdata->timeout; 207 else 208 bit_data->timeout = HZ / 10; /* 100 ms */ 209 210 bit_data->data = pdata; 211 212 adap->owner = THIS_MODULE; 213 if (pdev->dev.of_node) 214 strlcpy(adap->name, dev_name(&pdev->dev), sizeof(adap->name)); 215 else 216 snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id); 217 218 adap->algo_data = bit_data; 219 adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 220 adap->dev.parent = &pdev->dev; 221 adap->dev.of_node = pdev->dev.of_node; 222 223 adap->nr = pdev->id; 224 ret = i2c_bit_add_numbered_bus(adap); 225 if (ret) 226 return ret; 227 228 platform_set_drvdata(pdev, priv); 229 230 dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n", 231 pdata->sda_pin, pdata->scl_pin, 232 pdata->scl_is_output_only 233 ? ", no clock stretching" : ""); 234 235 return 0; 236 } 237 238 static int i2c_gpio_remove(struct platform_device *pdev) 239 { 240 struct i2c_gpio_private_data *priv; 241 struct i2c_adapter *adap; 242 243 priv = platform_get_drvdata(pdev); 244 adap = &priv->adap; 245 246 i2c_del_adapter(adap); 247 248 return 0; 249 } 250 251 #if defined(CONFIG_OF) 252 static const struct of_device_id i2c_gpio_dt_ids[] = { 253 { .compatible = "i2c-gpio", }, 254 { /* sentinel */ } 255 }; 256 257 MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids); 258 #endif 259 260 static struct platform_driver i2c_gpio_driver = { 261 .driver = { 262 .name = "i2c-gpio", 263 .of_match_table = of_match_ptr(i2c_gpio_dt_ids), 264 }, 265 .probe = i2c_gpio_probe, 266 .remove = i2c_gpio_remove, 267 }; 268 269 static int __init i2c_gpio_init(void) 270 { 271 int ret; 272 273 ret = platform_driver_register(&i2c_gpio_driver); 274 if (ret) 275 printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret); 276 277 return ret; 278 } 279 subsys_initcall(i2c_gpio_init); 280 281 static void __exit i2c_gpio_exit(void) 282 { 283 platform_driver_unregister(&i2c_gpio_driver); 284 } 285 module_exit(i2c_gpio_exit); 286 287 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)"); 288 MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver"); 289 MODULE_LICENSE("GPL"); 290 MODULE_ALIAS("platform:i2c-gpio"); 291