1 // SPDX-License-Identifier: GPL-2.0-only 2 /* 3 * Bitbanging I2C bus driver using the GPIO API 4 * 5 * Copyright (C) 2007 Atmel Corporation 6 */ 7 #include <linux/completion.h> 8 #include <linux/debugfs.h> 9 #include <linux/delay.h> 10 #include <linux/gpio/consumer.h> 11 #include <linux/i2c-algo-bit.h> 12 #include <linux/i2c.h> 13 #include <linux/init.h> 14 #include <linux/interrupt.h> 15 #include <linux/module.h> 16 #include <linux/platform_data/i2c-gpio.h> 17 #include <linux/platform_device.h> 18 #include <linux/property.h> 19 #include <linux/slab.h> 20 21 struct i2c_gpio_private_data { 22 struct gpio_desc *sda; 23 struct gpio_desc *scl; 24 struct i2c_adapter adap; 25 struct i2c_algo_bit_data bit_data; 26 struct i2c_gpio_platform_data pdata; 27 #ifdef CONFIG_I2C_GPIO_FAULT_INJECTOR 28 struct dentry *debug_dir; 29 /* these must be protected by bus lock */ 30 struct completion scl_irq_completion; 31 u64 scl_irq_data; 32 #endif 33 }; 34 35 /* 36 * Toggle SDA by changing the output value of the pin. This is only 37 * valid for pins configured as open drain (i.e. setting the value 38 * high effectively turns off the output driver.) 39 */ 40 static void i2c_gpio_setsda_val(void *data, int state) 41 { 42 struct i2c_gpio_private_data *priv = data; 43 44 gpiod_set_value_cansleep(priv->sda, state); 45 } 46 47 /* 48 * Toggle SCL by changing the output value of the pin. This is used 49 * for pins that are configured as open drain and for output-only 50 * pins. The latter case will break the i2c protocol, but it will 51 * often work in practice. 52 */ 53 static void i2c_gpio_setscl_val(void *data, int state) 54 { 55 struct i2c_gpio_private_data *priv = data; 56 57 gpiod_set_value_cansleep(priv->scl, state); 58 } 59 60 static int i2c_gpio_getsda(void *data) 61 { 62 struct i2c_gpio_private_data *priv = data; 63 64 return gpiod_get_value_cansleep(priv->sda); 65 } 66 67 static int i2c_gpio_getscl(void *data) 68 { 69 struct i2c_gpio_private_data *priv = data; 70 71 return gpiod_get_value_cansleep(priv->scl); 72 } 73 74 #ifdef CONFIG_I2C_GPIO_FAULT_INJECTOR 75 static struct dentry *i2c_gpio_debug_dir; 76 77 #define setsda(bd, val) ((bd)->setsda((bd)->data, val)) 78 #define setscl(bd, val) ((bd)->setscl((bd)->data, val)) 79 #define getsda(bd) ((bd)->getsda((bd)->data)) 80 #define getscl(bd) ((bd)->getscl((bd)->data)) 81 82 #define WIRE_ATTRIBUTE(wire) \ 83 static int fops_##wire##_get(void *data, u64 *val) \ 84 { \ 85 struct i2c_gpio_private_data *priv = data; \ 86 \ 87 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \ 88 *val = get##wire(&priv->bit_data); \ 89 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \ 90 return 0; \ 91 } \ 92 static int fops_##wire##_set(void *data, u64 val) \ 93 { \ 94 struct i2c_gpio_private_data *priv = data; \ 95 \ 96 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \ 97 set##wire(&priv->bit_data, val); \ 98 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); \ 99 return 0; \ 100 } \ 101 DEFINE_DEBUGFS_ATTRIBUTE(fops_##wire, fops_##wire##_get, fops_##wire##_set, "%llu\n") 102 103 WIRE_ATTRIBUTE(scl); 104 WIRE_ATTRIBUTE(sda); 105 106 static void i2c_gpio_incomplete_transfer(struct i2c_gpio_private_data *priv, 107 u32 pattern, u8 pattern_size) 108 { 109 struct i2c_algo_bit_data *bit_data = &priv->bit_data; 110 int i; 111 112 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); 113 114 /* START condition */ 115 setsda(bit_data, 0); 116 udelay(bit_data->udelay); 117 118 /* Send pattern, request ACK, don't send STOP */ 119 for (i = pattern_size - 1; i >= 0; i--) { 120 setscl(bit_data, 0); 121 udelay(bit_data->udelay / 2); 122 setsda(bit_data, (pattern >> i) & 1); 123 udelay((bit_data->udelay + 1) / 2); 124 setscl(bit_data, 1); 125 udelay(bit_data->udelay); 126 } 127 128 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); 129 } 130 131 static int fops_incomplete_addr_phase_set(void *data, u64 addr) 132 { 133 struct i2c_gpio_private_data *priv = data; 134 u32 pattern; 135 136 if (addr > 0x7f) 137 return -EINVAL; 138 139 /* ADDR (7 bit) + RD (1 bit) + Client ACK, keep SDA hi (1 bit) */ 140 pattern = (addr << 2) | 3; 141 142 i2c_gpio_incomplete_transfer(priv, pattern, 9); 143 144 return 0; 145 } 146 DEFINE_DEBUGFS_ATTRIBUTE(fops_incomplete_addr_phase, NULL, fops_incomplete_addr_phase_set, "%llu\n"); 147 148 static int fops_incomplete_write_byte_set(void *data, u64 addr) 149 { 150 struct i2c_gpio_private_data *priv = data; 151 u32 pattern; 152 153 if (addr > 0x7f) 154 return -EINVAL; 155 156 /* ADDR (7 bit) + WR (1 bit) + Client ACK (1 bit) */ 157 pattern = (addr << 2) | 1; 158 /* 0x00 (8 bit) + Client ACK, keep SDA hi (1 bit) */ 159 pattern = (pattern << 9) | 1; 160 161 i2c_gpio_incomplete_transfer(priv, pattern, 18); 162 163 return 0; 164 } 165 DEFINE_DEBUGFS_ATTRIBUTE(fops_incomplete_write_byte, NULL, fops_incomplete_write_byte_set, "%llu\n"); 166 167 static int i2c_gpio_fi_act_on_scl_irq(struct i2c_gpio_private_data *priv, 168 irqreturn_t handler(int, void*)) 169 { 170 int ret, irq = gpiod_to_irq(priv->scl); 171 172 if (irq < 0) 173 return irq; 174 175 i2c_lock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); 176 177 ret = gpiod_direction_input(priv->scl); 178 if (ret) 179 goto unlock; 180 181 reinit_completion(&priv->scl_irq_completion); 182 183 ret = request_irq(irq, handler, IRQF_TRIGGER_FALLING, 184 "i2c_gpio_fault_injector_scl_irq", priv); 185 if (ret) 186 goto output; 187 188 wait_for_completion_interruptible(&priv->scl_irq_completion); 189 190 free_irq(irq, priv); 191 output: 192 ret = gpiod_direction_output(priv->scl, 1) ?: ret; 193 unlock: 194 i2c_unlock_bus(&priv->adap, I2C_LOCK_ROOT_ADAPTER); 195 196 return ret; 197 } 198 199 static irqreturn_t lose_arbitration_irq(int irq, void *dev_id) 200 { 201 struct i2c_gpio_private_data *priv = dev_id; 202 203 setsda(&priv->bit_data, 0); 204 udelay(priv->scl_irq_data); 205 setsda(&priv->bit_data, 1); 206 207 complete(&priv->scl_irq_completion); 208 209 return IRQ_HANDLED; 210 } 211 212 static int fops_lose_arbitration_set(void *data, u64 duration) 213 { 214 struct i2c_gpio_private_data *priv = data; 215 216 if (duration > 100 * 1000) 217 return -EINVAL; 218 219 priv->scl_irq_data = duration; 220 /* 221 * Interrupt on falling SCL. This ensures that the master under test has 222 * really started the transfer. Interrupt on falling SDA did only 223 * exercise 'bus busy' detection on some HW but not 'arbitration lost'. 224 * Note that the interrupt latency may cause the first bits to be 225 * transmitted correctly. 226 */ 227 return i2c_gpio_fi_act_on_scl_irq(priv, lose_arbitration_irq); 228 } 229 DEFINE_DEBUGFS_ATTRIBUTE(fops_lose_arbitration, NULL, fops_lose_arbitration_set, "%llu\n"); 230 231 static irqreturn_t inject_panic_irq(int irq, void *dev_id) 232 { 233 struct i2c_gpio_private_data *priv = dev_id; 234 235 udelay(priv->scl_irq_data); 236 panic("I2C fault injector induced panic"); 237 238 return IRQ_HANDLED; 239 } 240 241 static int fops_inject_panic_set(void *data, u64 duration) 242 { 243 struct i2c_gpio_private_data *priv = data; 244 245 if (duration > 100 * 1000) 246 return -EINVAL; 247 248 priv->scl_irq_data = duration; 249 /* 250 * Interrupt on falling SCL. This ensures that the master under test has 251 * really started the transfer. 252 */ 253 return i2c_gpio_fi_act_on_scl_irq(priv, inject_panic_irq); 254 } 255 DEFINE_DEBUGFS_ATTRIBUTE(fops_inject_panic, NULL, fops_inject_panic_set, "%llu\n"); 256 257 static void i2c_gpio_fault_injector_init(struct platform_device *pdev) 258 { 259 struct i2c_gpio_private_data *priv = platform_get_drvdata(pdev); 260 261 /* 262 * If there will be a debugfs-dir per i2c adapter somewhen, put the 263 * 'fault-injector' dir there. Until then, we have a global dir with 264 * all adapters as subdirs. 265 */ 266 if (!i2c_gpio_debug_dir) { 267 i2c_gpio_debug_dir = debugfs_create_dir("i2c-fault-injector", NULL); 268 if (!i2c_gpio_debug_dir) 269 return; 270 } 271 272 priv->debug_dir = debugfs_create_dir(pdev->name, i2c_gpio_debug_dir); 273 if (!priv->debug_dir) 274 return; 275 276 init_completion(&priv->scl_irq_completion); 277 278 debugfs_create_file_unsafe("incomplete_address_phase", 0200, priv->debug_dir, 279 priv, &fops_incomplete_addr_phase); 280 debugfs_create_file_unsafe("incomplete_write_byte", 0200, priv->debug_dir, 281 priv, &fops_incomplete_write_byte); 282 if (priv->bit_data.getscl) { 283 debugfs_create_file_unsafe("inject_panic", 0200, priv->debug_dir, 284 priv, &fops_inject_panic); 285 debugfs_create_file_unsafe("lose_arbitration", 0200, priv->debug_dir, 286 priv, &fops_lose_arbitration); 287 } 288 debugfs_create_file_unsafe("scl", 0600, priv->debug_dir, priv, &fops_scl); 289 debugfs_create_file_unsafe("sda", 0600, priv->debug_dir, priv, &fops_sda); 290 } 291 292 static void i2c_gpio_fault_injector_exit(struct platform_device *pdev) 293 { 294 struct i2c_gpio_private_data *priv = platform_get_drvdata(pdev); 295 296 debugfs_remove_recursive(priv->debug_dir); 297 } 298 #else 299 static inline void i2c_gpio_fault_injector_init(struct platform_device *pdev) {} 300 static inline void i2c_gpio_fault_injector_exit(struct platform_device *pdev) {} 301 #endif /* CONFIG_I2C_GPIO_FAULT_INJECTOR*/ 302 303 /* Get i2c-gpio properties from DT or ACPI table */ 304 static void i2c_gpio_get_properties(struct device *dev, 305 struct i2c_gpio_platform_data *pdata) 306 { 307 u32 reg; 308 309 device_property_read_u32(dev, "i2c-gpio,delay-us", &pdata->udelay); 310 311 if (!device_property_read_u32(dev, "i2c-gpio,timeout-ms", ®)) 312 pdata->timeout = msecs_to_jiffies(reg); 313 314 pdata->sda_is_open_drain = 315 device_property_read_bool(dev, "i2c-gpio,sda-open-drain"); 316 pdata->scl_is_open_drain = 317 device_property_read_bool(dev, "i2c-gpio,scl-open-drain"); 318 pdata->scl_is_output_only = 319 device_property_read_bool(dev, "i2c-gpio,scl-output-only"); 320 pdata->sda_is_output_only = 321 device_property_read_bool(dev, "i2c-gpio,sda-output-only"); 322 pdata->sda_has_no_pullup = 323 device_property_read_bool(dev, "i2c-gpio,sda-has-no-pullup"); 324 pdata->scl_has_no_pullup = 325 device_property_read_bool(dev, "i2c-gpio,scl-has-no-pullup"); 326 } 327 328 static struct gpio_desc *i2c_gpio_get_desc(struct device *dev, 329 const char *con_id, 330 unsigned int index, 331 enum gpiod_flags gflags) 332 { 333 struct gpio_desc *retdesc; 334 int ret; 335 336 retdesc = devm_gpiod_get(dev, con_id, gflags); 337 if (!IS_ERR(retdesc)) { 338 dev_dbg(dev, "got GPIO from name %s\n", con_id); 339 return retdesc; 340 } 341 342 retdesc = devm_gpiod_get_index(dev, NULL, index, gflags); 343 if (!IS_ERR(retdesc)) { 344 dev_dbg(dev, "got GPIO from index %u\n", index); 345 return retdesc; 346 } 347 348 ret = PTR_ERR(retdesc); 349 350 /* FIXME: hack in the old code, is this really necessary? */ 351 if (ret == -EINVAL) 352 retdesc = ERR_PTR(-EPROBE_DEFER); 353 354 /* This happens if the GPIO driver is not yet probed, let's defer */ 355 if (ret == -ENOENT) 356 retdesc = ERR_PTR(-EPROBE_DEFER); 357 358 if (PTR_ERR(retdesc) != -EPROBE_DEFER) 359 dev_err(dev, "error trying to get descriptor: %d\n", ret); 360 361 return retdesc; 362 } 363 364 static int i2c_gpio_probe(struct platform_device *pdev) 365 { 366 struct i2c_gpio_private_data *priv; 367 struct i2c_gpio_platform_data *pdata; 368 struct i2c_algo_bit_data *bit_data; 369 struct i2c_adapter *adap; 370 struct device *dev = &pdev->dev; 371 struct fwnode_handle *fwnode = dev_fwnode(dev); 372 enum gpiod_flags gflags; 373 int ret; 374 375 priv = devm_kzalloc(dev, sizeof(*priv), GFP_KERNEL); 376 if (!priv) 377 return -ENOMEM; 378 379 adap = &priv->adap; 380 bit_data = &priv->bit_data; 381 pdata = &priv->pdata; 382 383 if (fwnode) { 384 i2c_gpio_get_properties(dev, pdata); 385 } else { 386 /* 387 * If all platform data settings are zero it is OK 388 * to not provide any platform data from the board. 389 */ 390 if (dev_get_platdata(dev)) 391 memcpy(pdata, dev_get_platdata(dev), sizeof(*pdata)); 392 } 393 394 /* 395 * First get the GPIO pins; if it fails, we'll defer the probe. 396 * If the SCL/SDA lines are marked "open drain" by platform data or 397 * device tree then this means that something outside of our control is 398 * marking these lines to be handled as open drain, and we should just 399 * handle them as we handle any other output. Else we enforce open 400 * drain as this is required for an I2C bus. 401 */ 402 if (pdata->sda_is_open_drain || pdata->sda_has_no_pullup) 403 gflags = GPIOD_OUT_HIGH; 404 else 405 gflags = GPIOD_OUT_HIGH_OPEN_DRAIN; 406 priv->sda = i2c_gpio_get_desc(dev, "sda", 0, gflags); 407 if (IS_ERR(priv->sda)) 408 return PTR_ERR(priv->sda); 409 410 if (pdata->scl_is_open_drain || pdata->scl_has_no_pullup) 411 gflags = GPIOD_OUT_HIGH; 412 else 413 gflags = GPIOD_OUT_HIGH_OPEN_DRAIN; 414 priv->scl = i2c_gpio_get_desc(dev, "scl", 1, gflags); 415 if (IS_ERR(priv->scl)) 416 return PTR_ERR(priv->scl); 417 418 if (gpiod_cansleep(priv->sda) || gpiod_cansleep(priv->scl)) 419 dev_warn(dev, "Slow GPIO pins might wreak havoc into I2C/SMBus bus timing"); 420 else 421 bit_data->can_do_atomic = true; 422 423 bit_data->setsda = i2c_gpio_setsda_val; 424 bit_data->setscl = i2c_gpio_setscl_val; 425 426 if (!pdata->scl_is_output_only) 427 bit_data->getscl = i2c_gpio_getscl; 428 if (!pdata->sda_is_output_only) 429 bit_data->getsda = i2c_gpio_getsda; 430 431 if (pdata->udelay) 432 bit_data->udelay = pdata->udelay; 433 else if (pdata->scl_is_output_only) 434 bit_data->udelay = 50; /* 10 kHz */ 435 else 436 bit_data->udelay = 5; /* 100 kHz */ 437 438 if (pdata->timeout) 439 bit_data->timeout = pdata->timeout; 440 else 441 bit_data->timeout = HZ / 10; /* 100 ms */ 442 443 bit_data->data = priv; 444 445 adap->owner = THIS_MODULE; 446 if (fwnode) 447 strscpy(adap->name, dev_name(dev), sizeof(adap->name)); 448 else 449 snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id); 450 451 adap->algo_data = bit_data; 452 adap->class = I2C_CLASS_HWMON | I2C_CLASS_SPD; 453 adap->dev.parent = dev; 454 device_set_node(&adap->dev, fwnode); 455 456 adap->nr = pdev->id; 457 ret = i2c_bit_add_numbered_bus(adap); 458 if (ret) 459 return ret; 460 461 platform_set_drvdata(pdev, priv); 462 463 /* 464 * FIXME: using global GPIO numbers is not helpful. If/when we 465 * get accessors to get the actual name of the GPIO line, 466 * from the descriptor, then provide that instead. 467 */ 468 dev_info(dev, "using lines %u (SDA) and %u (SCL%s)\n", 469 desc_to_gpio(priv->sda), desc_to_gpio(priv->scl), 470 pdata->scl_is_output_only 471 ? ", no clock stretching" : ""); 472 473 i2c_gpio_fault_injector_init(pdev); 474 475 return 0; 476 } 477 478 static int i2c_gpio_remove(struct platform_device *pdev) 479 { 480 struct i2c_gpio_private_data *priv; 481 struct i2c_adapter *adap; 482 483 i2c_gpio_fault_injector_exit(pdev); 484 485 priv = platform_get_drvdata(pdev); 486 adap = &priv->adap; 487 488 i2c_del_adapter(adap); 489 490 return 0; 491 } 492 493 static const struct of_device_id i2c_gpio_dt_ids[] = { 494 { .compatible = "i2c-gpio", }, 495 { /* sentinel */ } 496 }; 497 498 MODULE_DEVICE_TABLE(of, i2c_gpio_dt_ids); 499 500 static const struct acpi_device_id i2c_gpio_acpi_match[] = { 501 { "LOON0005" }, /* LoongArch */ 502 { } 503 }; 504 MODULE_DEVICE_TABLE(acpi, i2c_gpio_acpi_match); 505 506 static struct platform_driver i2c_gpio_driver = { 507 .driver = { 508 .name = "i2c-gpio", 509 .of_match_table = i2c_gpio_dt_ids, 510 .acpi_match_table = i2c_gpio_acpi_match, 511 }, 512 .probe = i2c_gpio_probe, 513 .remove = i2c_gpio_remove, 514 }; 515 516 static int __init i2c_gpio_init(void) 517 { 518 int ret; 519 520 ret = platform_driver_register(&i2c_gpio_driver); 521 if (ret) 522 printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret); 523 524 return ret; 525 } 526 subsys_initcall(i2c_gpio_init); 527 528 static void __exit i2c_gpio_exit(void) 529 { 530 platform_driver_unregister(&i2c_gpio_driver); 531 } 532 module_exit(i2c_gpio_exit); 533 534 MODULE_AUTHOR("Haavard Skinnemoen (Atmel)"); 535 MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver"); 536 MODULE_LICENSE("GPL v2"); 537 MODULE_ALIAS("platform:i2c-gpio"); 538