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