0001
0002
0003
0004
0005
0006
0007 #include <linux/completion.h>
0008 #include <linux/debugfs.h>
0009 #include <linux/delay.h>
0010 #include <linux/gpio/consumer.h>
0011 #include <linux/i2c-algo-bit.h>
0012 #include <linux/i2c.h>
0013 #include <linux/init.h>
0014 #include <linux/interrupt.h>
0015 #include <linux/module.h>
0016 #include <linux/of.h>
0017 #include <linux/platform_data/i2c-gpio.h>
0018 #include <linux/platform_device.h>
0019 #include <linux/slab.h>
0020
0021 struct i2c_gpio_private_data {
0022 struct gpio_desc *sda;
0023 struct gpio_desc *scl;
0024 struct i2c_adapter adap;
0025 struct i2c_algo_bit_data bit_data;
0026 struct i2c_gpio_platform_data pdata;
0027 #ifdef CONFIG_I2C_GPIO_FAULT_INJECTOR
0028 struct dentry *debug_dir;
0029
0030 struct completion scl_irq_completion;
0031 u64 scl_irq_data;
0032 #endif
0033 };
0034
0035
0036
0037
0038
0039
0040 static void i2c_gpio_setsda_val(void *data, int state)
0041 {
0042 struct i2c_gpio_private_data *priv = data;
0043
0044 gpiod_set_value_cansleep(priv->sda, state);
0045 }
0046
0047
0048
0049
0050
0051
0052
0053 static void i2c_gpio_setscl_val(void *data, int state)
0054 {
0055 struct i2c_gpio_private_data *priv = data;
0056
0057 gpiod_set_value_cansleep(priv->scl, state);
0058 }
0059
0060 static int i2c_gpio_getsda(void *data)
0061 {
0062 struct i2c_gpio_private_data *priv = data;
0063
0064 return gpiod_get_value_cansleep(priv->sda);
0065 }
0066
0067 static int i2c_gpio_getscl(void *data)
0068 {
0069 struct i2c_gpio_private_data *priv = data;
0070
0071 return gpiod_get_value_cansleep(priv->scl);
0072 }
0073
0074 #ifdef CONFIG_I2C_GPIO_FAULT_INJECTOR
0075 static struct dentry *i2c_gpio_debug_dir;
0076
0077 #define setsda(bd, val) ((bd)->setsda((bd)->data, val))
0078 #define setscl(bd, val) ((bd)->setscl((bd)->data, val))
0079 #define getsda(bd) ((bd)->getsda((bd)->data))
0080 #define getscl(bd) ((bd)->getscl((bd)->data))
0081
0082 #define WIRE_ATTRIBUTE(wire) \
0083 static int fops_##wire##_get(void *data, u64 *val) \
0084 { \
0085 struct i2c_gpio_private_data *priv = data; \
0086 \
0087 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \
0088 *val = get##wire(&priv->bit_data); \
0089 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \
0090 return 0; \
0091 } \
0092 static int fops_##wire##_set(void *data, u64 val) \
0093 { \
0094 struct i2c_gpio_private_data *priv = data; \
0095 \
0096 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \
0097 set##wire(&priv->bit_data, val); \
0098 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \
0099 return 0; \
0100 } \
0101 DEFINE_DEBUGFS_ATTRIBUTE(fops_##wire, fops_##wire##_get, fops_##wire##_set, "%llu\n")
0102
0103 WIRE_ATTRIBUTE(scl);
0104 WIRE_ATTRIBUTE(sda);
0105
0106 static void i2c_gpio_incomplete_transfer(struct i2c_gpio_private_data *priv,
0107 u32 pattern, u8 pattern_size)
0108 {
0109 struct i2c_algo_bit_data *bit_data = &priv->bit_data;
0110 int i;
0111
0112 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER);
0113
0114
0115 setsda(bit_data, 0);
0116 udelay(bit_data->udelay);
0117
0118
0119 for (i = pattern_size - 1; i >= 0; i--) {
0120 setscl(bit_data, 0);
0121 udelay(bit_data->udelay / 2);
0122 setsda(bit_data, (pattern >> i) & 1);
0123 udelay((bit_data->udelay + 1) / 2);
0124 setscl(bit_data, 1);
0125 udelay(bit_data->udelay);
0126 }
0127
0128 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER);
0129 }
0130
0131 static int fops_incomplete_addr_phase_set(void *data, u64 addr)
0132 {
0133 struct i2c_gpio_private_data *priv = data;
0134 u32 pattern;
0135
0136 if (addr > 0x7f)
0137 return -EINVAL;
0138
0139
0140 pattern = (addr << 2) | 3;
0141
0142 i2c_gpio_incomplete_transfer(priv, pattern, 9);
0143
0144 return 0;
0145 }
0146 DEFINE_DEBUGFS_ATTRIBUTE(fops_incomplete_addr_phase, NULL, fops_incomplete_addr_phase_set, "%llu\n");
0147
0148 static int fops_incomplete_write_byte_set(void *data, u64 addr)
0149 {
0150 struct i2c_gpio_private_data *priv = data;
0151 u32 pattern;
0152
0153 if (addr > 0x7f)
0154 return -EINVAL;
0155
0156
0157 pattern = (addr << 2) | 1;
0158
0159 pattern = (pattern << 9) | 1;
0160
0161 i2c_gpio_incomplete_transfer(priv, pattern, 18);
0162
0163 return 0;
0164 }
0165 DEFINE_DEBUGFS_ATTRIBUTE(fops_incomplete_write_byte, NULL, fops_incomplete_write_byte_set, "%llu\n");
0166
0167 static int i2c_gpio_fi_act_on_scl_irq(struct i2c_gpio_private_data *priv,
0168 irqreturn_t handler(int, void*))
0169 {
0170 int ret, irq = gpiod_to_irq(priv->scl);
0171
0172 if (irq < 0)
0173 return irq;
0174
0175 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER);
0176
0177 ret = gpiod_direction_input(priv->scl);
0178 if (ret)
0179 goto unlock;
0180
0181 reinit_completion(&priv->scl_irq_completion);
0182
0183 ret = request_irq(irq, handler, IRQF_TRIGGER_FALLING,
0184 "i2c_gpio_fault_injector_scl_irq", priv);
0185 if (ret)
0186 goto output;
0187
0188 wait_for_completion_interruptible(&priv->scl_irq_completion);
0189
0190 free_irq(irq, priv);
0191 output:
0192 ret = gpiod_direction_output(priv->scl, 1) ?: ret;
0193 unlock:
0194 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER);
0195
0196 return ret;
0197 }
0198
0199 static irqreturn_t lose_arbitration_irq(int irq, void *dev_id)
0200 {
0201 struct i2c_gpio_private_data *priv = dev_id;
0202
0203 setsda(&priv->bit_data, 0);
0204 udelay(priv->scl_irq_data);
0205 setsda(&priv->bit_data, 1);
0206
0207 complete(&priv->scl_irq_completion);
0208
0209 return IRQ_HANDLED;
0210 }
0211
0212 static int fops_lose_arbitration_set(void *data, u64 duration)
0213 {
0214 struct i2c_gpio_private_data *priv = data;
0215
0216 if (duration > 100 * 1000)
0217 return -EINVAL;
0218
0219 priv->scl_irq_data = duration;
0220
0221
0222
0223
0224
0225
0226
0227 return i2c_gpio_fi_act_on_scl_irq(priv, lose_arbitration_irq);
0228 }
0229 DEFINE_DEBUGFS_ATTRIBUTE(fops_lose_arbitration, NULL, fops_lose_arbitration_set, "%llu\n");
0230
0231 static irqreturn_t inject_panic_irq(int irq, void *dev_id)
0232 {
0233 struct i2c_gpio_private_data *priv = dev_id;
0234
0235 udelay(priv->scl_irq_data);
0236 panic("I2C fault injector induced panic");
0237
0238 return IRQ_HANDLED;
0239 }
0240
0241 static int fops_inject_panic_set(void *data, u64 duration)
0242 {
0243 struct i2c_gpio_private_data *priv = data;
0244
0245 if (duration > 100 * 1000)
0246 return -EINVAL;
0247
0248 priv->scl_irq_data = duration;
0249
0250
0251
0252
0253 return i2c_gpio_fi_act_on_scl_irq(priv, inject_panic_irq);
0254 }
0255 DEFINE_DEBUGFS_ATTRIBUTE(fops_inject_panic, NULL, fops_inject_panic_set, "%llu\n");
0256
0257 static void i2c_gpio_fault_injector_init(struct platform_device *pdev)
0258 {
0259 struct i2c_gpio_private_data *priv = platform_get_drvdata(pdev);
0260
0261
0262
0263
0264
0265
0266 if (!i2c_gpio_debug_dir) {
0267 i2c_gpio_debug_dir = debugfs_create_dir("i2c-fault-injector", NULL);
0268 if (!i2c_gpio_debug_dir)
0269 return;
0270 }
0271
0272 priv->debug_dir = debugfs_create_dir(pdev->name, i2c_gpio_debug_dir);
0273 if (!priv->debug_dir)
0274 return;
0275
0276 init_completion(&priv->scl_irq_completion);
0277
0278 debugfs_create_file_unsafe("incomplete_address_phase", 0200, priv->debug_dir,
0279 priv, &fops_incomplete_addr_phase);
0280 debugfs_create_file_unsafe("incomplete_write_byte", 0200, priv->debug_dir,
0281 priv, &fops_incomplete_write_byte);
0282 if (priv->bit_data.getscl) {
0283 debugfs_create_file_unsafe("inject_panic", 0200, priv->debug_dir,
0284 priv, &fops_inject_panic);
0285 debugfs_create_file_unsafe("lose_arbitration", 0200, priv->debug_dir,
0286 priv, &fops_lose_arbitration);
0287 }
0288 debugfs_create_file_unsafe("scl", 0600, priv->debug_dir, priv, &fops_scl);
0289 debugfs_create_file_unsafe("sda", 0600, priv->debug_dir, priv, &fops_sda);
0290 }
0291
0292 static void i2c_gpio_fault_injector_exit(struct platform_device *pdev)
0293 {
0294 struct i2c_gpio_private_data *priv = platform_get_drvdata(pdev);
0295
0296 debugfs_remove_recursive(priv->debug_dir);
0297 }
0298 #else
0299 static inline void i2c_gpio_fault_injector_init(struct platform_device *pdev) {}
0300 static inline void i2c_gpio_fault_injector_exit(struct platform_device *pdev) {}
0301 #endif
0302
0303 static void of_i2c_gpio_get_props(struct device_node *np,
0304 struct i2c_gpio_platform_data *pdata)
0305 {
0306 u32 reg;
0307
0308 of_property_read_u32(np, "i2c-gpio,delay-us", &pdata->udelay);
0309
0310 if (!of_property_read_u32(np, "i2c-gpio,timeout-ms", ®))
0311 pdata->timeout = msecs_to_jiffies(reg);
0312
0313 pdata->sda_is_open_drain =
0314 of_property_read_bool(np, "i2c-gpio,sda-open-drain");
0315 pdata->scl_is_open_drain =
0316 of_property_read_bool(np, "i2c-gpio,scl-open-drain");
0317 pdata->scl_is_output_only =
0318 of_property_read_bool(np, "i2c-gpio,scl-output-only");
0319 }
0320
0321 static struct gpio_desc *i2c_gpio_get_desc(struct device *dev,
0322 const char *con_id,
0323 unsigned int index,
0324 enum gpiod_flags gflags)
0325 {
0326 struct gpio_desc *retdesc;
0327 int ret;
0328
0329 retdesc = devm_gpiod_get(dev, con_id, gflags);
0330 if (!IS_ERR(retdesc)) {
0331 dev_dbg(dev, "got GPIO from name %s\n", con_id);
0332 return retdesc;
0333 }
0334
0335 retdesc = devm_gpiod_get_index(dev, NULL, index, gflags);
0336 if (!IS_ERR(retdesc)) {
0337 dev_dbg(dev, "got GPIO from index %u\n", index);
0338 return retdesc;
0339 }
0340
0341 ret = PTR_ERR(retdesc);
0342
0343
0344 if (ret == -EINVAL)
0345 retdesc = ERR_PTR(-EPROBE_DEFER);
0346
0347
0348 if (ret == -ENOENT)
0349 retdesc = ERR_PTR(-EPROBE_DEFER);
0350
0351 if (PTR_ERR(retdesc) != -EPROBE_DEFER)
0352 dev_err(dev, "error trying to get descriptor: %d\n", ret);
0353
0354 return retdesc;
0355 }
0356
0357 static int i2c_gpio_probe(struct platform_device *pdev)
0358 {
0359 struct i2c_gpio_private_data *priv;
0360 struct i2c_gpio_platform_data *pdata;
0361 struct i2c_algo_bit_data *bit_data;
0362 struct i2c_adapter *adap;
0363 struct device *dev = &pdev->dev;
0364 struct device_node *np = dev->of_node;
0365 enum gpiod_flags gflags;
0366 int ret;
0367
0368 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL);
0369 if (!priv)
0370 return -ENOMEM;
0371
0372 adap = &priv->adap;
0373 bit_data = &priv->bit_data;
0374 pdata = &priv->pdata;
0375
0376 if (np) {
0377 of_i2c_gpio_get_props(np, pdata);
0378 } else {
0379
0380
0381
0382
0383 if (dev_get_platdata(dev))
0384 memcpy(pdata, dev_get_platdata(dev), sizeof(*pdata));
0385 }
0386
0387
0388
0389
0390
0391
0392
0393
0394
0395 if (pdata->sda_is_open_drain)
0396 gflags = GPIOD_OUT_HIGH;
0397 else
0398 gflags = GPIOD_OUT_HIGH_OPEN_DRAIN;
0399 priv->sda = i2c_gpio_get_desc(dev, "sda", 0, gflags);
0400 if (IS_ERR(priv->sda))
0401 return PTR_ERR(priv->sda);
0402
0403 if (pdata->scl_is_open_drain)
0404 gflags = GPIOD_OUT_HIGH;
0405 else
0406 gflags = GPIOD_OUT_HIGH_OPEN_DRAIN;
0407 priv->scl = i2c_gpio_get_desc(dev, "scl", 1, gflags);
0408 if (IS_ERR(priv->scl))
0409 return PTR_ERR(priv->scl);
0410
0411 if (gpiod_cansleep(priv->sda) || gpiod_cansleep(priv->scl))
0412 dev_warn(dev, "Slow GPIO pins might wreak havoc into I2C/SMBus bus timing");
0413 else
0414 bit_data->can_do_atomic = true;
0415
0416 bit_data->setsda = i2c_gpio_setsda_val;
0417 bit_data->setscl = i2c_gpio_setscl_val;
0418
0419 if (!pdata->scl_is_output_only)
0420 bit_data->getscl = i2c_gpio_getscl;
0421 bit_data->getsda = i2c_gpio_getsda;
0422
0423 if (pdata->udelay)
0424 bit_data->udelay = pdata->udelay;
0425 else if (pdata->scl_is_output_only)
0426 bit_data->udelay = 50;
0427 else
0428 bit_data->udelay = 5;
0429
0430 if (pdata->timeout)
0431 bit_data->timeout = pdata->timeout;
0432 else
0433 bit_data->timeout = HZ / 10;
0434
0435 bit_data->data = priv;
0436
0437 adap->owner = THIS_MODULE;
0438 if (np)
0439 strscpy(adap->name, dev_name(dev), sizeof(adap->name));
0440 else
0441 snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id);
0442
0443 adap->algo_data = bit_data;
0444 adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD;
0445 adap->dev.parent = dev;
0446 adap->dev.of_node = np;
0447
0448 adap->nr = pdev->id;
0449 ret = i2c_bit_add_numbered_bus(adap);
0450 if (ret)
0451 return ret;
0452
0453 platform_set_drvdata(pdev, priv);
0454
0455
0456
0457
0458
0459
0460 dev_info(dev, "using lines %u (SDA) and %u (SCL%s)\n",
0461 desc_to_gpio(priv->sda), desc_to_gpio(priv->scl),
0462 pdata->scl_is_output_only
0463 ? ", no clock stretching" : "");
0464
0465 i2c_gpio_fault_injector_init(pdev);
0466
0467 return 0;
0468 }
0469
0470 static int i2c_gpio_remove(struct platform_device *pdev)
0471 {
0472 struct i2c_gpio_private_data *priv;
0473 struct i2c_adapter *adap;
0474
0475 i2c_gpio_fault_injector_exit(pdev);
0476
0477 priv = platform_get_drvdata(pdev);
0478 adap = &priv->adap;
0479
0480 i2c_del_adapter(adap);
0481
0482 return 0;
0483 }
0484
0485 #if defined(CONFIG_OF)
0486 static const struct of_device_id i2c_gpio_dt_ids[] = {
0487 { .compatible = "i2c-gpio", },
0488 { }
0489 };
0490
0491 MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids);
0492 #endif
0493
0494 static struct platform_driver i2c_gpio_driver = {
0495 .driver = {
0496 .name = "i2c-gpio",
0497 .of_match_table = of_match_ptr(i2c_gpio_dt_ids),
0498 },
0499 .probe = i2c_gpio_probe,
0500 .remove = i2c_gpio_remove,
0501 };
0502
0503 static int __init i2c_gpio_init(void)
0504 {
0505 int ret;
0506
0507 ret = platform_driver_register(&i2c_gpio_driver);
0508 if (ret)
0509 printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret);
0510
0511 return ret;
0512 }
0513 subsys_initcall(i2c_gpio_init);
0514
0515 static void __exit i2c_gpio_exit(void)
0516 {
0517 platform_driver_unregister(&i2c_gpio_driver);
0518 }
0519 module_exit(i2c_gpio_exit);
0520
0521 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)");
0522 MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver");
0523 MODULE_LICENSE("GPL v2");
0524 MODULE_ALIAS("platform:i2c-gpio");