1 /* 2 * (C) Copyright 2015, Samsung Electronics 3 * Przemyslaw Marczak <p.marczak@samsung.com> 4 * 5 * This file is based on: drivers/i2c/soft-i2c.c, 6 * with added driver-model support and code cleanup. 7 */ 8 #include <common.h> 9 #include <errno.h> 10 #include <dm.h> 11 #include <i2c.h> 12 #include <asm/gpio.h> 13 14 #define DEFAULT_UDELAY 5 15 #define RETRIES 0 16 #define I2C_ACK 0 17 #define I2C_NOACK 1 18 19 DECLARE_GLOBAL_DATA_PTR; 20 21 enum { 22 PIN_SDA = 0, 23 PIN_SCL, 24 PIN_COUNT, 25 }; 26 27 struct i2c_gpio_bus { 28 /** 29 * udelay - delay [us] between GPIO toggle operations, 30 * which is 1/4 of I2C speed clock period. 31 */ 32 int udelay; 33 /* sda, scl */ 34 struct gpio_desc gpios[PIN_COUNT]; 35 }; 36 37 static int i2c_gpio_sda_get(struct gpio_desc *sda) 38 { 39 return dm_gpio_get_value(sda); 40 } 41 42 static void i2c_gpio_sda_set(struct gpio_desc *sda, int bit) 43 { 44 if (bit) 45 dm_gpio_set_dir_flags(sda, GPIOD_IS_IN); 46 else 47 dm_gpio_set_dir_flags(sda, GPIOD_IS_OUT); 48 } 49 50 static void i2c_gpio_scl_set(struct gpio_desc *scl, int bit) 51 { 52 ulong flags = GPIOD_IS_OUT; 53 54 if (bit) 55 flags |= GPIOD_IS_OUT_ACTIVE; 56 dm_gpio_set_dir_flags(scl, flags); 57 } 58 59 static void i2c_gpio_write_bit(struct gpio_desc *scl, struct gpio_desc *sda, 60 int delay, uchar bit) 61 { 62 i2c_gpio_scl_set(scl, 0); 63 udelay(delay); 64 i2c_gpio_sda_set(sda, bit); 65 udelay(delay); 66 i2c_gpio_scl_set(scl, 1); 67 udelay(2 * delay); 68 } 69 70 static int i2c_gpio_read_bit(struct gpio_desc *scl, struct gpio_desc *sda, 71 int delay) 72 { 73 int value; 74 75 i2c_gpio_scl_set(scl, 1); 76 udelay(delay); 77 value = i2c_gpio_sda_get(sda); 78 udelay(delay); 79 i2c_gpio_scl_set(scl, 0); 80 udelay(2 * delay); 81 82 return value; 83 } 84 85 /* START: High -> Low on SDA while SCL is High */ 86 static void i2c_gpio_send_start(struct gpio_desc *scl, struct gpio_desc *sda, 87 int delay) 88 { 89 udelay(delay); 90 i2c_gpio_sda_set(sda, 1); 91 udelay(delay); 92 i2c_gpio_scl_set(scl, 1); 93 udelay(delay); 94 i2c_gpio_sda_set(sda, 0); 95 udelay(delay); 96 } 97 98 /* STOP: Low -> High on SDA while SCL is High */ 99 static void i2c_gpio_send_stop(struct gpio_desc *scl, struct gpio_desc *sda, 100 int delay) 101 { 102 i2c_gpio_scl_set(scl, 0); 103 udelay(delay); 104 i2c_gpio_sda_set(sda, 0); 105 udelay(delay); 106 i2c_gpio_scl_set(scl, 1); 107 udelay(delay); 108 i2c_gpio_sda_set(sda, 1); 109 udelay(delay); 110 } 111 112 /* ack should be I2C_ACK or I2C_NOACK */ 113 static void i2c_gpio_send_ack(struct gpio_desc *scl, struct gpio_desc *sda, 114 int delay, int ack) 115 { 116 i2c_gpio_write_bit(scl, sda, delay, ack); 117 i2c_gpio_scl_set(scl, 0); 118 udelay(delay); 119 } 120 121 /** 122 * Send a reset sequence consisting of 9 clocks with the data signal high 123 * to clock any confused device back into an idle state. Also send a 124 * <stop> at the end of the sequence for belts & suspenders. 125 */ 126 static void i2c_gpio_send_reset(struct gpio_desc *scl, struct gpio_desc *sda, 127 int delay) 128 { 129 int j; 130 131 for (j = 0; j < 9; j++) 132 i2c_gpio_write_bit(scl, sda, delay, 1); 133 134 i2c_gpio_send_stop(scl, sda, delay); 135 } 136 137 /* Set sda high with low clock, before reading slave data */ 138 static void i2c_gpio_sda_high(struct gpio_desc *scl, struct gpio_desc *sda, 139 int delay) 140 { 141 i2c_gpio_scl_set(scl, 0); 142 udelay(delay); 143 i2c_gpio_sda_set(sda, 1); 144 udelay(delay); 145 } 146 147 /* Send 8 bits and look for an acknowledgement */ 148 static int i2c_gpio_write_byte(struct gpio_desc *scl, struct gpio_desc *sda, 149 int delay, uchar data) 150 { 151 int j; 152 int nack; 153 154 for (j = 0; j < 8; j++) { 155 i2c_gpio_write_bit(scl, sda, delay, data & 0x80); 156 data <<= 1; 157 } 158 159 udelay(delay); 160 161 /* Look for an <ACK>(negative logic) and return it */ 162 i2c_gpio_sda_high(scl, sda, delay); 163 nack = i2c_gpio_read_bit(scl, sda, delay); 164 165 return nack; /* not a nack is an ack */ 166 } 167 168 /** 169 * if ack == I2C_ACK, ACK the byte so can continue reading, else 170 * send I2C_NOACK to end the read. 171 */ 172 static uchar i2c_gpio_read_byte(struct gpio_desc *scl, struct gpio_desc *sda, 173 int delay, int ack) 174 { 175 int data; 176 int j; 177 178 i2c_gpio_sda_high(scl, sda, delay); 179 data = 0; 180 for (j = 0; j < 8; j++) { 181 data <<= 1; 182 data |= i2c_gpio_read_bit(scl, sda, delay); 183 } 184 i2c_gpio_send_ack(scl, sda, delay, ack); 185 186 return data; 187 } 188 189 /* send start and the slave chip address */ 190 int i2c_send_slave_addr(struct gpio_desc *scl, struct gpio_desc *sda, int delay, 191 uchar chip) 192 { 193 i2c_gpio_send_start(scl, sda, delay); 194 195 if (i2c_gpio_write_byte(scl, sda, delay, chip)) { 196 i2c_gpio_send_stop(scl, sda, delay); 197 return -EIO; 198 } 199 200 return 0; 201 } 202 203 static int i2c_gpio_write_data(struct i2c_gpio_bus *bus, uchar chip, 204 uchar *buffer, int len, 205 bool end_with_repeated_start) 206 { 207 struct gpio_desc *scl = &bus->gpios[PIN_SCL]; 208 struct gpio_desc *sda = &bus->gpios[PIN_SDA]; 209 unsigned int delay = bus->udelay; 210 int failures = 0; 211 212 debug("%s: chip %x buffer %p len %d\n", __func__, chip, buffer, len); 213 214 if (i2c_send_slave_addr(scl, sda, delay, chip << 1)) { 215 debug("i2c_write, no chip responded %02X\n", chip); 216 return -EIO; 217 } 218 219 while (len-- > 0) { 220 if (i2c_gpio_write_byte(scl, sda, delay, *buffer++)) 221 failures++; 222 } 223 224 if (!end_with_repeated_start) { 225 i2c_gpio_send_stop(scl, sda, delay); 226 return failures; 227 } 228 229 if (i2c_send_slave_addr(scl, sda, delay, (chip << 1) | 0x1)) { 230 debug("i2c_write, no chip responded %02X\n", chip); 231 return -EIO; 232 } 233 234 return failures; 235 } 236 237 static int i2c_gpio_read_data(struct i2c_gpio_bus *bus, uchar chip, 238 uchar *buffer, int len) 239 { 240 struct gpio_desc *scl = &bus->gpios[PIN_SCL]; 241 struct gpio_desc *sda = &bus->gpios[PIN_SDA]; 242 unsigned int delay = bus->udelay; 243 244 debug("%s: chip %x buffer: %p len %d\n", __func__, chip, buffer, len); 245 246 while (len-- > 0) 247 *buffer++ = i2c_gpio_read_byte(scl, sda, delay, len == 0); 248 249 i2c_gpio_send_stop(scl, sda, delay); 250 251 return 0; 252 } 253 254 static int i2c_gpio_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs) 255 { 256 struct i2c_gpio_bus *bus = dev_get_priv(dev); 257 int ret; 258 259 for (; nmsgs > 0; nmsgs--, msg++) { 260 bool next_is_read = nmsgs > 1 && (msg[1].flags & I2C_M_RD); 261 262 if (msg->flags & I2C_M_RD) { 263 ret = i2c_gpio_read_data(bus, msg->addr, msg->buf, 264 msg->len); 265 } else { 266 ret = i2c_gpio_write_data(bus, msg->addr, msg->buf, 267 msg->len, next_is_read); 268 } 269 270 if (ret) 271 return -EREMOTEIO; 272 } 273 274 return 0; 275 } 276 277 static int i2c_gpio_probe(struct udevice *dev, uint chip, uint chip_flags) 278 { 279 struct i2c_gpio_bus *bus = dev_get_priv(dev); 280 struct gpio_desc *scl = &bus->gpios[PIN_SCL]; 281 struct gpio_desc *sda = &bus->gpios[PIN_SDA]; 282 unsigned int delay = bus->udelay; 283 int ret; 284 285 i2c_gpio_send_start(scl, sda, delay); 286 ret = i2c_gpio_write_byte(scl, sda, delay, (chip << 1) | 0); 287 i2c_gpio_send_stop(scl, sda, delay); 288 289 debug("%s: bus: %d (%s) chip: %x flags: %x ret: %d\n", 290 __func__, dev->seq, dev->name, chip, chip_flags, ret); 291 292 return ret; 293 } 294 295 static int i2c_gpio_set_bus_speed(struct udevice *dev, unsigned int speed_hz) 296 { 297 struct i2c_gpio_bus *bus = dev_get_priv(dev); 298 struct gpio_desc *scl = &bus->gpios[PIN_SCL]; 299 struct gpio_desc *sda = &bus->gpios[PIN_SDA]; 300 301 bus->udelay = 1000000 / (speed_hz << 2); 302 303 i2c_gpio_send_reset(scl, sda, bus->udelay); 304 305 return 0; 306 } 307 308 static int i2c_gpio_ofdata_to_platdata(struct udevice *dev) 309 { 310 struct i2c_gpio_bus *bus = dev_get_priv(dev); 311 const void *blob = gd->fdt_blob; 312 int node = dev_of_offset(dev); 313 int ret; 314 315 ret = gpio_request_list_by_name(dev, "gpios", bus->gpios, 316 ARRAY_SIZE(bus->gpios), 0); 317 if (ret < 0) 318 goto error; 319 320 bus->udelay = fdtdec_get_int(blob, node, "i2c-gpio,delay-us", 321 DEFAULT_UDELAY); 322 323 return 0; 324 error: 325 pr_err("Can't get %s gpios! Error: %d", dev->name, ret); 326 return ret; 327 } 328 329 static const struct dm_i2c_ops i2c_gpio_ops = { 330 .xfer = i2c_gpio_xfer, 331 .probe_chip = i2c_gpio_probe, 332 .set_bus_speed = i2c_gpio_set_bus_speed, 333 }; 334 335 static const struct udevice_id i2c_gpio_ids[] = { 336 { .compatible = "i2c-gpio" }, 337 { } 338 }; 339 340 U_BOOT_DRIVER(i2c_gpio) = { 341 .name = "i2c-gpio", 342 .id = UCLASS_I2C, 343 .of_match = i2c_gpio_ids, 344 .ofdata_to_platdata = i2c_gpio_ofdata_to_platdata, 345 .priv_auto_alloc_size = sizeof(struct i2c_gpio_bus), 346 .ops = &i2c_gpio_ops, 347 }; 348