rcar_iic.c 5.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Renesas RCar IIC driver
  4. *
  5. * Copyright (C) 2017 Marek Vasut <marek.vasut@gmail.com>
  6. *
  7. * Based on
  8. * Copyright (C) 2011, 2013 Renesas Solutions Corp.
  9. * Copyright (C) 2011, 2013 Nobuhiro Iwamatsu <nobuhiro.iwamatsu.yj@renesas.com>
  10. */
  11. #include <common.h>
  12. #include <clk.h>
  13. #include <dm.h>
  14. #include <i2c.h>
  15. #include <asm/io.h>
  16. #include <linux/bitops.h>
  17. #include <linux/delay.h>
  18. struct rcar_iic_priv {
  19. void __iomem *base;
  20. struct clk clk;
  21. u8 iccl;
  22. u8 icch;
  23. };
  24. #define RCAR_IIC_ICDR 0x00
  25. #define RCAR_IIC_ICCR 0x04
  26. #define RCAR_IIC_ICSR 0x08
  27. #define RCAR_IIC_ICIC 0x0c
  28. #define RCAR_IIC_ICCL 0x10
  29. #define RCAR_IIC_ICCH 0x14
  30. /* ICCR */
  31. #define RCAR_IIC_ICCR_ICE BIT(7)
  32. #define RCAR_IIC_ICCR_RACK BIT(6)
  33. #define RCAR_IIC_ICCR_RTS BIT(4)
  34. #define RCAR_IIC_ICCR_BUSY BIT(2)
  35. #define RCAR_IIC_ICCR_SCP BIT(0)
  36. /* ICSR / ICIC */
  37. #define RCAR_IC_BUSY BIT(4)
  38. #define RCAR_IC_TACK BIT(2)
  39. #define RCAR_IC_DTE BIT(0)
  40. #define IRQ_WAIT 1000
  41. static void sh_irq_dte(struct udevice *dev)
  42. {
  43. struct rcar_iic_priv *priv = dev_get_priv(dev);
  44. int i;
  45. for (i = 0; i < IRQ_WAIT; i++) {
  46. if (RCAR_IC_DTE & readb(priv->base + RCAR_IIC_ICSR))
  47. break;
  48. udelay(10);
  49. }
  50. }
  51. static int sh_irq_dte_with_tack(struct udevice *dev)
  52. {
  53. struct rcar_iic_priv *priv = dev_get_priv(dev);
  54. u8 icsr;
  55. int i;
  56. for (i = 0; i < IRQ_WAIT; i++) {
  57. icsr = readb(priv->base + RCAR_IIC_ICSR);
  58. if (RCAR_IC_DTE & icsr)
  59. break;
  60. if (RCAR_IC_TACK & icsr)
  61. return -ETIMEDOUT;
  62. udelay(10);
  63. }
  64. return 0;
  65. }
  66. static void sh_irq_busy(struct udevice *dev)
  67. {
  68. struct rcar_iic_priv *priv = dev_get_priv(dev);
  69. int i;
  70. for (i = 0; i < IRQ_WAIT; i++) {
  71. if (!(RCAR_IC_BUSY & readb(priv->base + RCAR_IIC_ICSR)))
  72. break;
  73. udelay(10);
  74. }
  75. }
  76. static int rcar_iic_set_addr(struct udevice *dev, u8 chip, u8 read)
  77. {
  78. struct rcar_iic_priv *priv = dev_get_priv(dev);
  79. clrbits_8(priv->base + RCAR_IIC_ICCR, RCAR_IIC_ICCR_ICE);
  80. setbits_8(priv->base + RCAR_IIC_ICCR, RCAR_IIC_ICCR_ICE);
  81. writeb(priv->iccl, priv->base + RCAR_IIC_ICCL);
  82. writeb(priv->icch, priv->base + RCAR_IIC_ICCH);
  83. writeb(RCAR_IC_TACK, priv->base + RCAR_IIC_ICIC);
  84. writeb(RCAR_IIC_ICCR_ICE | RCAR_IIC_ICCR_RTS | RCAR_IIC_ICCR_BUSY,
  85. priv->base + RCAR_IIC_ICCR);
  86. sh_irq_dte(dev);
  87. clrbits_8(priv->base + RCAR_IIC_ICSR, RCAR_IC_TACK);
  88. writeb(chip << 1 | read, priv->base + RCAR_IIC_ICDR);
  89. return sh_irq_dte_with_tack(dev);
  90. }
  91. static void rcar_iic_finish(struct udevice *dev)
  92. {
  93. struct rcar_iic_priv *priv = dev_get_priv(dev);
  94. writeb(0, priv->base + RCAR_IIC_ICSR);
  95. clrbits_8(priv->base + RCAR_IIC_ICCR, RCAR_IIC_ICCR_ICE);
  96. }
  97. static int rcar_iic_read_common(struct udevice *dev, struct i2c_msg *msg)
  98. {
  99. struct rcar_iic_priv *priv = dev_get_priv(dev);
  100. int i, ret = -EREMOTEIO;
  101. if (rcar_iic_set_addr(dev, msg->addr, 1) != 0)
  102. goto err;
  103. udelay(10);
  104. writeb(RCAR_IIC_ICCR_ICE | RCAR_IIC_ICCR_SCP,
  105. priv->base + RCAR_IIC_ICCR);
  106. for (i = 0; i < msg->len; i++) {
  107. if (sh_irq_dte_with_tack(dev) != 0)
  108. goto err;
  109. msg->buf[i] = readb(priv->base + RCAR_IIC_ICDR) & 0xff;
  110. if (msg->len - 1 == i) {
  111. writeb(RCAR_IIC_ICCR_ICE | RCAR_IIC_ICCR_RACK,
  112. priv->base + RCAR_IIC_ICCR);
  113. }
  114. }
  115. sh_irq_busy(dev);
  116. ret = 0;
  117. err:
  118. rcar_iic_finish(dev);
  119. return ret;
  120. }
  121. static int rcar_iic_write_common(struct udevice *dev, struct i2c_msg *msg)
  122. {
  123. struct rcar_iic_priv *priv = dev_get_priv(dev);
  124. int i, ret = -EREMOTEIO;
  125. if (rcar_iic_set_addr(dev, msg->addr, 0) != 0)
  126. goto err;
  127. udelay(10);
  128. for (i = 0; i < msg->len; i++) {
  129. writeb(msg->buf[i], priv->base + RCAR_IIC_ICDR);
  130. if (sh_irq_dte_with_tack(dev) != 0)
  131. goto err;
  132. }
  133. if (msg->flags & I2C_M_STOP) {
  134. writeb(RCAR_IIC_ICCR_ICE | RCAR_IIC_ICCR_RTS,
  135. priv->base + RCAR_IIC_ICCR);
  136. if (sh_irq_dte_with_tack(dev) != 0)
  137. goto err;
  138. }
  139. sh_irq_busy(dev);
  140. ret = 0;
  141. err:
  142. rcar_iic_finish(dev);
  143. return ret;
  144. }
  145. static int rcar_iic_xfer(struct udevice *dev, struct i2c_msg *msg, int nmsgs)
  146. {
  147. int ret;
  148. for (; nmsgs > 0; nmsgs--, msg++) {
  149. if (msg->flags & I2C_M_RD)
  150. ret = rcar_iic_read_common(dev, msg);
  151. else
  152. ret = rcar_iic_write_common(dev, msg);
  153. if (ret)
  154. return -EREMOTEIO;
  155. }
  156. return ret;
  157. }
  158. static int rcar_iic_set_speed(struct udevice *dev, uint speed)
  159. {
  160. struct rcar_iic_priv *priv = dev_get_priv(dev);
  161. const unsigned int ratio_high = 4;
  162. const unsigned int ratio_low = 5;
  163. int clkrate, denom;
  164. clkrate = clk_get_rate(&priv->clk);
  165. if (clkrate < 0)
  166. return clkrate;
  167. /*
  168. * Calculate the value for ICCL and ICCH. From the data sheet:
  169. * iccl = (p-clock / transfer-rate) * (L / (L + H))
  170. * icch = (p clock / transfer rate) * (H / (L + H))
  171. * where L and H are the SCL low and high ratio.
  172. */
  173. denom = speed * (ratio_high + ratio_low);
  174. priv->iccl = DIV_ROUND_CLOSEST(clkrate * ratio_low, denom);
  175. priv->icch = DIV_ROUND_CLOSEST(clkrate * ratio_high, denom);
  176. return 0;
  177. }
  178. static int rcar_iic_probe_chip(struct udevice *dev, uint addr, uint flags)
  179. {
  180. struct rcar_iic_priv *priv = dev_get_priv(dev);
  181. int ret;
  182. rcar_iic_set_addr(dev, addr, 1);
  183. writeb(RCAR_IIC_ICCR_ICE | RCAR_IIC_ICCR_SCP,
  184. priv->base + RCAR_IIC_ICCR);
  185. ret = sh_irq_dte_with_tack(dev);
  186. rcar_iic_finish(dev);
  187. return ret;
  188. }
  189. static int rcar_iic_probe(struct udevice *dev)
  190. {
  191. struct rcar_iic_priv *priv = dev_get_priv(dev);
  192. int ret;
  193. priv->base = dev_read_addr_ptr(dev);
  194. ret = clk_get_by_index(dev, 0, &priv->clk);
  195. if (ret)
  196. return ret;
  197. ret = clk_enable(&priv->clk);
  198. if (ret)
  199. return ret;
  200. rcar_iic_finish(dev);
  201. return rcar_iic_set_speed(dev, I2C_SPEED_STANDARD_RATE);
  202. }
  203. static const struct dm_i2c_ops rcar_iic_ops = {
  204. .xfer = rcar_iic_xfer,
  205. .probe_chip = rcar_iic_probe_chip,
  206. .set_bus_speed = rcar_iic_set_speed,
  207. };
  208. static const struct udevice_id rcar_iic_ids[] = {
  209. { .compatible = "renesas,rmobile-iic" },
  210. { }
  211. };
  212. U_BOOT_DRIVER(iic_rcar) = {
  213. .name = "iic_rcar",
  214. .id = UCLASS_I2C,
  215. .of_match = rcar_iic_ids,
  216. .probe = rcar_iic_probe,
  217. .priv_auto = sizeof(struct rcar_iic_priv),
  218. .ops = &rcar_iic_ops,
  219. };