i2c-gpio.c 8.3 KB

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