Back to home page

OSCL-LXR

 
 

    


0001 // SPDX-License-Identifier: GPL-2.0-only
0002 /*
0003  * Bitbanging I2C bus driver using the GPIO API
0004  *
0005  * Copyright (C) 2007 Atmel Corporation
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     /* these must be protected by bus lock */
0030     struct completion scl_irq_completion;
0031     u64 scl_irq_data;
0032 #endif
0033 };
0034 
0035 /*
0036  * Toggle SDA by changing the output value of the pin. This is only
0037  * valid for pins configured as open drain (i.e. setting the value
0038  * high effectively turns off the output driver.)
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  * Toggle SCL by changing the output value of the pin. This is used
0049  * for pins that are configured as open drain and for output-only
0050  * pins. The latter case will break the i2c protocol, but it will
0051  * often work in practice.
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     /* START condition */
0115     setsda(bit_data, 0);
0116     udelay(bit_data->udelay);
0117 
0118     /* Send pattern, request ACK, don't send STOP */
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     /* ADDR (7 bit) + RD (1 bit) + Client ACK, keep SDA hi (1 bit) */
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     /* ADDR (7 bit) + WR (1 bit) + Client ACK (1 bit) */
0157     pattern = (addr << 2) | 1;
0158     /* 0x00 (8 bit) + Client ACK, keep SDA hi (1 bit) */
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      * Interrupt on falling SCL. This ensures that the master under test has
0222      * really started the transfer. Interrupt on falling SDA did only
0223      * exercise 'bus busy' detection on some HW but not 'arbitration lost'.
0224      * Note that the interrupt latency may cause the first bits to be
0225      * transmitted correctly.
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      * Interrupt on falling SCL. This ensures that the master under test has
0251      * really started the transfer.
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      * If there will be a debugfs-dir per i2c adapter somewhen, put the
0263      * 'fault-injector' dir there. Until then, we have a global dir with
0264      * all adapters as subdirs.
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 /* CONFIG_I2C_GPIO_FAULT_INJECTOR*/
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", &reg))
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     /* FIXME: hack in the old code, is this really necessary? */
0344     if (ret == -EINVAL)
0345         retdesc = ERR_PTR(-EPROBE_DEFER);
0346 
0347     /* This happens if the GPIO driver is not yet probed, let's defer */
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          * If all platform data settings are zero it is OK
0381          * to not provide any platform data from the board.
0382          */
0383         if (dev_get_platdata(dev))
0384             memcpy(pdata, dev_get_platdata(dev), sizeof(*pdata));
0385     }
0386 
0387     /*
0388      * First get the GPIO pins; if it fails, we'll defer the probe.
0389      * If the SCL/SDA lines are marked "open drain" by platform data or
0390      * device tree then this means that something outside of our control is
0391      * marking these lines to be handled as open drain, and we should just
0392      * handle them as we handle any other output. Else we enforce open
0393      * drain as this is required for an I2C bus.
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;          /* 10 kHz */
0427     else
0428         bit_data->udelay = 5;           /* 100 kHz */
0429 
0430     if (pdata->timeout)
0431         bit_data->timeout = pdata->timeout;
0432     else
0433         bit_data->timeout = HZ / 10;        /* 100 ms */
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      * FIXME: using global GPIO numbers is not helpful. If/when we
0457      * get accessors to get the actual name of the GPIO line,
0458      * from the descriptor, then provide that instead.
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     { /* sentinel */ }
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");