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/platform_device.h> 16 17 #include <asm/gpio.h> 18 19 /* Toggle SDA by changing the direction of the pin */ 20 static void i2c_gpio_setsda_dir(void *data, int state) 21 { 22 struct i2c_gpio_platform_data *pdata = data; 23 24 if (state) 25 gpio_direction_input(pdata->sda_pin); 26 else 27 gpio_direction_output(pdata->sda_pin, 0); 28 } 29 30 /* 31 * Toggle SDA by changing the output value of the pin. This is only 32 * valid for pins configured as open drain (i.e. setting the value 33 * high effectively turns off the output driver.) 34 */ 35 static void i2c_gpio_setsda_val(void *data, int state) 36 { 37 struct i2c_gpio_platform_data *pdata = data; 38 39 gpio_set_value(pdata->sda_pin, state); 40 } 41 42 /* Toggle SCL by changing the direction of the pin. */ 43 static void i2c_gpio_setscl_dir(void *data, int state) 44 { 45 struct i2c_gpio_platform_data *pdata = data; 46 47 if (state) 48 gpio_direction_input(pdata->scl_pin); 49 else 50 gpio_direction_output(pdata->scl_pin, 0); 51 } 52 53 /* 54 * Toggle SCL by changing the output value of the pin. This is used 55 * for pins that are configured as open drain and for output-only 56 * pins. The latter case will break the i2c protocol, but it will 57 * often work in practice. 58 */ 59 static void i2c_gpio_setscl_val(void *data, int state) 60 { 61 struct i2c_gpio_platform_data *pdata = data; 62 63 gpio_set_value(pdata->scl_pin, state); 64 } 65 66 static int i2c_gpio_getsda(void *data) 67 { 68 struct i2c_gpio_platform_data *pdata = data; 69 70 return gpio_get_value(pdata->sda_pin); 71 } 72 73 static int i2c_gpio_getscl(void *data) 74 { 75 struct i2c_gpio_platform_data *pdata = data; 76 77 return gpio_get_value(pdata->scl_pin); 78 } 79 80 static int __init i2c_gpio_probe(struct platform_device *pdev) 81 { 82 struct i2c_gpio_platform_data *pdata; 83 struct i2c_algo_bit_data *bit_data; 84 struct i2c_adapter *adap; 85 int ret; 86 87 pdata = pdev->dev.platform_data; 88 if (!pdata) 89 return -ENXIO; 90 91 ret = -ENOMEM; 92 adap = kzalloc(sizeof(struct i2c_adapter), GFP_KERNEL); 93 if (!adap) 94 goto err_alloc_adap; 95 bit_data = kzalloc(sizeof(struct i2c_algo_bit_data), GFP_KERNEL); 96 if (!bit_data) 97 goto err_alloc_bit_data; 98 99 ret = gpio_request(pdata->sda_pin, "sda"); 100 if (ret) 101 goto err_request_sda; 102 ret = gpio_request(pdata->scl_pin, "scl"); 103 if (ret) 104 goto err_request_scl; 105 106 if (pdata->sda_is_open_drain) { 107 gpio_direction_output(pdata->sda_pin, 1); 108 bit_data->setsda = i2c_gpio_setsda_val; 109 } else { 110 gpio_direction_input(pdata->sda_pin); 111 bit_data->setsda = i2c_gpio_setsda_dir; 112 } 113 114 if (pdata->scl_is_open_drain || pdata->scl_is_output_only) { 115 gpio_direction_output(pdata->scl_pin, 1); 116 bit_data->setscl = i2c_gpio_setscl_val; 117 } else { 118 gpio_direction_input(pdata->scl_pin); 119 bit_data->setscl = i2c_gpio_setscl_dir; 120 } 121 122 if (!pdata->scl_is_output_only) 123 bit_data->getscl = i2c_gpio_getscl; 124 bit_data->getsda = i2c_gpio_getsda; 125 126 if (pdata->udelay) 127 bit_data->udelay = pdata->udelay; 128 else if (pdata->scl_is_output_only) 129 bit_data->udelay = 50; /* 10 kHz */ 130 else 131 bit_data->udelay = 5; /* 100 kHz */ 132 133 if (pdata->timeout) 134 bit_data->timeout = pdata->timeout; 135 else 136 bit_data->timeout = HZ / 10; /* 100 ms */ 137 138 bit_data->data = pdata; 139 140 adap->owner = THIS_MODULE; 141 snprintf(adap->name, sizeof(adap->name), "i2c-gpio%d", pdev->id); 142 adap->algo_data = bit_data; 143 adap->dev.parent = &pdev->dev; 144 145 /* 146 * If "dev->id" is negative we consider it as zero. 147 * The reason to do so is to avoid sysfs names that only make 148 * sense when there are multiple adapters. 149 */ 150 adap->nr = (pdev->id != -1) ? pdev->id : 0; 151 ret = i2c_bit_add_numbered_bus(adap); 152 if (ret) 153 goto err_add_bus; 154 155 platform_set_drvdata(pdev, adap); 156 157 dev_info(&pdev->dev, "using pins %u (SDA) and %u (SCL%s)\n", 158 pdata->sda_pin, pdata->scl_pin, 159 pdata->scl_is_output_only 160 ? ", no clock stretching" : ""); 161 162 return 0; 163 164 err_add_bus: 165 gpio_free(pdata->scl_pin); 166 err_request_scl: 167 gpio_free(pdata->sda_pin); 168 err_request_sda: 169 kfree(bit_data); 170 err_alloc_bit_data: 171 kfree(adap); 172 err_alloc_adap: 173 return ret; 174 } 175 176 static int __exit i2c_gpio_remove(struct platform_device *pdev) 177 { 178 struct i2c_gpio_platform_data *pdata; 179 struct i2c_adapter *adap; 180 181 adap = platform_get_drvdata(pdev); 182 pdata = pdev->dev.platform_data; 183 184 i2c_del_adapter(adap); 185 gpio_free(pdata->scl_pin); 186 gpio_free(pdata->sda_pin); 187 kfree(adap->algo_data); 188 kfree(adap); 189 190 return 0; 191 } 192 193 static struct platform_driver i2c_gpio_driver = { 194 .driver = { 195 .name = "i2c-gpio", 196 .owner = THIS_MODULE, 197 }, 198 .remove = __exit_p(i2c_gpio_remove), 199 }; 200 201 static int __init i2c_gpio_init(void) 202 { 203 int ret; 204 205 ret = platform_driver_probe(&i2c_gpio_driver, i2c_gpio_probe); 206 if (ret) 207 printk(KERN_ERR "i2c-gpio: probe failed: %d\n", ret); 208 209 return ret; 210 } 211 module_init(i2c_gpio_init); 212 213 static void __exit i2c_gpio_exit(void) 214 { 215 platform_driver_unregister(&i2c_gpio_driver); 216 } 217 module_exit(i2c_gpio_exit); 218 219 MODULE_AUTHOR("Haavard Skinnemoen <hskinnemoen@atmel.com>"); 220 MODULE_DESCRIPTION("Platform-independent bitbanging I2C driver"); 221 MODULE_LICENSE("GPL"); 222