i2c-gpio.c 8.6 KB

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