i2c-versatile.c 6.0 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (c) 2018 Arm Ltd.
  4. * Author: Liviu Dudau <liviu.dudau@foss.arm.com>
  5. *
  6. */
  7. #include <common.h>
  8. #include <dm.h>
  9. #include <errno.h>
  10. #include <i2c.h>
  11. #include <asm/io.h>
  12. #include <clk.h>
  13. #include <linux/io.h>
  14. #define I2C_CONTROL_REG 0x00
  15. #define I2C_SET_REG 0x00
  16. #define I2C_CLEAR_REG 0x04
  17. #define SCL BIT(0)
  18. #define SDA BIT(1)
  19. struct versatile_i2c_priv {
  20. phys_addr_t base;
  21. u32 delay;
  22. };
  23. static inline void versatile_sda_set(struct versatile_i2c_priv *priv, u8 state)
  24. {
  25. writel(SDA, priv->base + (state ? I2C_SET_REG : I2C_CLEAR_REG));
  26. udelay(priv->delay);
  27. }
  28. static inline int versatile_sda_get(struct versatile_i2c_priv *priv)
  29. {
  30. int v = !!(readl(priv->base + I2C_CONTROL_REG) & SDA);
  31. udelay(priv->delay);
  32. return v;
  33. }
  34. static inline void versatile_scl_set(struct versatile_i2c_priv *priv, u8 state)
  35. {
  36. writel(SCL, priv->base + (state ? I2C_SET_REG : I2C_CLEAR_REG));
  37. udelay(priv->delay);
  38. }
  39. static inline int versatile_scl_get(struct versatile_i2c_priv *priv)
  40. {
  41. int v = !!(readl(priv->base + I2C_CONTROL_REG) & SCL);
  42. udelay(priv->delay);
  43. return v;
  44. }
  45. /* start: SDA goes from high to low while SCL is high */
  46. static void versatile_i2c_start(struct versatile_i2c_priv *priv)
  47. {
  48. udelay(priv->delay);
  49. versatile_sda_set(priv, 1);
  50. versatile_scl_set(priv, 1);
  51. versatile_sda_set(priv, 0);
  52. }
  53. /* stop: SDA goes from low to high while SCL is high */
  54. static void versatile_i2c_stop(struct versatile_i2c_priv *priv)
  55. {
  56. versatile_scl_set(priv, 0);
  57. versatile_sda_set(priv, 0);
  58. versatile_scl_set(priv, 1);
  59. versatile_sda_set(priv, 1);
  60. }
  61. /* read a bit from the SDA line (data or ACK/NACK) */
  62. static u8 versatile_i2c_read_bit(struct versatile_i2c_priv *priv)
  63. {
  64. versatile_scl_set(priv, 0);
  65. versatile_sda_set(priv, 1);
  66. versatile_scl_set(priv, 1);
  67. udelay(priv->delay);
  68. return (u8)versatile_sda_get(priv);
  69. }
  70. /* write a bit on the SDA line */
  71. static void versatile_i2c_write_bit(struct versatile_i2c_priv *priv, u8 bit)
  72. {
  73. versatile_scl_set(priv, 0);
  74. versatile_sda_set(priv, bit);
  75. versatile_scl_set(priv, 1);
  76. udelay(priv->delay);
  77. }
  78. /* send a reset sequence of 9 clocks with SDA high */
  79. static void versatile_i2c_reset_bus(struct versatile_i2c_priv *priv)
  80. {
  81. int i;
  82. for (i = 0; i < 9; i++)
  83. versatile_i2c_write_bit(priv, 1);
  84. versatile_i2c_stop(priv);
  85. }
  86. /* write byte without start/stop sequence */
  87. static int versatile_i2c_write_byte(struct versatile_i2c_priv *priv, u8 byte)
  88. {
  89. u8 nak, i;
  90. for (i = 0; i < 8; i++) {
  91. versatile_i2c_write_bit(priv, byte & 0x80);
  92. byte <<= 1;
  93. }
  94. /* read ACK */
  95. nak = versatile_i2c_read_bit(priv);
  96. versatile_scl_set(priv, 0);
  97. return nak; /* not a nack is an ack */
  98. }
  99. static int versatile_i2c_read_byte(struct versatile_i2c_priv *priv,
  100. u8 *byte, u8 ack)
  101. {
  102. u8 i;
  103. *byte = 0;
  104. for (i = 0; i < 8; i++) {
  105. *byte <<= 1;
  106. *byte |= versatile_i2c_read_bit(priv);
  107. }
  108. /* write the nack */
  109. versatile_i2c_write_bit(priv, ack);
  110. return 0;
  111. }
  112. static int versatile_i2c_send_slave_addr(struct versatile_i2c_priv *priv,
  113. struct i2c_msg *msg)
  114. {
  115. u8 addr;
  116. int ret;
  117. if (msg->flags & I2C_M_TEN) {
  118. /* 10-bit address, send extended address code first */
  119. addr = 0xf0 | ((msg->addr >> 7) & 0x06);
  120. ret = versatile_i2c_write_byte(priv, addr);
  121. if (ret) {
  122. versatile_i2c_stop(priv);
  123. return -EIO;
  124. }
  125. /* remaining bits */
  126. ret = versatile_i2c_write_byte(priv, msg->addr & 0xff);
  127. if (ret) {
  128. versatile_i2c_stop(priv);
  129. return -EIO;
  130. }
  131. /* reads need to resend the addr */
  132. if (msg->flags & I2C_M_RD) {
  133. versatile_i2c_start(priv);
  134. addr |= 1;
  135. ret = versatile_i2c_write_byte(priv, addr);
  136. if (ret) {
  137. versatile_i2c_stop(priv);
  138. return -EIO;
  139. }
  140. }
  141. } else {
  142. /* normal 7-bit address */
  143. addr = msg->addr << 1;
  144. if (msg->flags & I2C_M_RD)
  145. addr |= 1;
  146. ret = versatile_i2c_write_byte(priv, addr);
  147. if (ret) {
  148. versatile_i2c_stop(priv);
  149. return -EIO;
  150. }
  151. }
  152. return 0;
  153. }
  154. static int versatile_i2c_message_xfer(struct versatile_i2c_priv *priv,
  155. struct i2c_msg *msg)
  156. {
  157. int i, ret;
  158. u8 ack;
  159. versatile_i2c_start(priv);
  160. if (versatile_i2c_send_slave_addr(priv, msg))
  161. return -EIO;
  162. for (i = 0; i < msg->len; i++) {
  163. if (msg->flags & I2C_M_RD) {
  164. ack = (msg->len - i - 1) == 0 ? 1 : 0;
  165. ret = versatile_i2c_read_byte(priv, &msg->buf[i], ack);
  166. } else {
  167. ret = versatile_i2c_write_byte(priv, msg->buf[i]);
  168. }
  169. if (ret)
  170. break;
  171. }
  172. versatile_i2c_stop(priv);
  173. return ret;
  174. }
  175. static int versatile_i2c_xfer(struct udevice *bus,
  176. struct i2c_msg *msg, int nmsgs)
  177. {
  178. struct versatile_i2c_priv *priv = dev_get_priv(bus);
  179. int ret;
  180. for ( ; nmsgs > 0; nmsgs--, msg++) {
  181. ret = versatile_i2c_message_xfer(priv, msg);
  182. if (ret)
  183. return -EREMOTEIO;
  184. }
  185. return 0;
  186. }
  187. static int versatile_i2c_chip_probe(struct udevice *bus,
  188. uint chip, uint chip_flags)
  189. {
  190. /* probe the presence of a slave by writing a 0-size message */
  191. struct i2c_msg msg = { .addr = chip, .flags = chip_flags,
  192. .len = 0, .buf = NULL };
  193. struct versatile_i2c_priv *priv = dev_get_priv(bus);
  194. return versatile_i2c_message_xfer(priv, &msg);
  195. }
  196. static int versatile_i2c_set_bus_speed(struct udevice *bus, unsigned int speed)
  197. {
  198. struct versatile_i2c_priv *priv = dev_get_priv(bus);
  199. priv->delay = 1000000 / (speed << 2);
  200. versatile_i2c_reset_bus(priv);
  201. return 0;
  202. }
  203. static int versatile_i2c_probe(struct udevice *dev)
  204. {
  205. struct versatile_i2c_priv *priv = dev_get_priv(dev);
  206. priv->base = (phys_addr_t)dev_read_addr(dev);
  207. priv->delay = 25; /* 25us * 4 = 100kHz */
  208. /*
  209. * U-Boot still doesn't assign automatically
  210. * sequence numbers to devices
  211. */
  212. dev->req_seq = 1;
  213. return 0;
  214. }
  215. static const struct dm_i2c_ops versatile_i2c_ops = {
  216. .xfer = versatile_i2c_xfer,
  217. .probe_chip = versatile_i2c_chip_probe,
  218. .set_bus_speed = versatile_i2c_set_bus_speed,
  219. };
  220. static const struct udevice_id versatile_i2c_of_match[] = {
  221. { .compatible = "arm,versatile-i2c" },
  222. { }
  223. };
  224. U_BOOT_DRIVER(versatile_i2c) = {
  225. .name = "i2c-bus-versatile",
  226. .id = UCLASS_I2C,
  227. .of_match = versatile_i2c_of_match,
  228. .probe = versatile_i2c_probe,
  229. .priv_auto_alloc_size = sizeof(struct versatile_i2c_priv),
  230. .ops = &versatile_i2c_ops,
  231. };