i2c-gpio.c 8.2 KB

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