rockchip_rng.c 5.3 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (c) 2020 Fuzhou Rockchip Electronics Co., Ltd
  4. */
  5. #include <asm/arch-rockchip/hardware.h>
  6. #include <asm/io.h>
  7. #include <common.h>
  8. #include <dm.h>
  9. #include <linux/bitops.h>
  10. #include <linux/iopoll.h>
  11. #include <linux/string.h>
  12. #include <rng.h>
  13. #define RK_HW_RNG_MAX 32
  14. #define _SBF(s, v) ((v) << (s))
  15. /* start of CRYPTO V1 register define */
  16. #define CRYPTO_V1_CTRL 0x0008
  17. #define CRYPTO_V1_RNG_START BIT(8)
  18. #define CRYPTO_V1_RNG_FLUSH BIT(9)
  19. #define CRYPTO_V1_TRNG_CTRL 0x0200
  20. #define CRYPTO_V1_OSC_ENABLE BIT(16)
  21. #define CRYPTO_V1_TRNG_SAMPLE_PERIOD(x) (x)
  22. #define CRYPTO_V1_TRNG_DOUT_0 0x0204
  23. /* end of CRYPTO V1 register define */
  24. /* start of CRYPTO V2 register define */
  25. #define CRYPTO_V2_RNG_CTL 0x0400
  26. #define CRYPTO_V2_RNG_64_BIT_LEN _SBF(4, 0x00)
  27. #define CRYPTO_V2_RNG_128_BIT_LEN _SBF(4, 0x01)
  28. #define CRYPTO_V2_RNG_192_BIT_LEN _SBF(4, 0x02)
  29. #define CRYPTO_V2_RNG_256_BIT_LEN _SBF(4, 0x03)
  30. #define CRYPTO_V2_RNG_FATESY_SOC_RING _SBF(2, 0x00)
  31. #define CRYPTO_V2_RNG_SLOWER_SOC_RING_0 _SBF(2, 0x01)
  32. #define CRYPTO_V2_RNG_SLOWER_SOC_RING_1 _SBF(2, 0x02)
  33. #define CRYPTO_V2_RNG_SLOWEST_SOC_RING _SBF(2, 0x03)
  34. #define CRYPTO_V2_RNG_ENABLE BIT(1)
  35. #define CRYPTO_V2_RNG_START BIT(0)
  36. #define CRYPTO_V2_RNG_SAMPLE_CNT 0x0404
  37. #define CRYPTO_V2_RNG_DOUT_0 0x0410
  38. /* end of CRYPTO V2 register define */
  39. #define RK_RNG_TIME_OUT 50000 /* max 50ms */
  40. struct rk_rng_soc_data {
  41. int (*rk_rng_read)(struct udevice *dev, void *data, size_t len);
  42. };
  43. struct rk_rng_platdata {
  44. fdt_addr_t base;
  45. struct rk_rng_soc_data *soc_data;
  46. };
  47. static int rk_rng_read_regs(fdt_addr_t addr, void *buf, size_t size)
  48. {
  49. u32 count = RK_HW_RNG_MAX / sizeof(u32);
  50. u32 reg, tmp_len;
  51. if (size > RK_HW_RNG_MAX)
  52. return -EINVAL;
  53. while (size && count) {
  54. reg = readl(addr);
  55. tmp_len = min(size, sizeof(u32));
  56. memcpy(buf, &reg, tmp_len);
  57. addr += sizeof(u32);
  58. buf += tmp_len;
  59. size -= tmp_len;
  60. count--;
  61. }
  62. return 0;
  63. }
  64. static int rk_v1_rng_read(struct udevice *dev, void *data, size_t len)
  65. {
  66. struct rk_rng_platdata *pdata = dev_get_priv(dev);
  67. u32 reg = 0;
  68. int retval;
  69. if (len > RK_HW_RNG_MAX)
  70. return -EINVAL;
  71. /* enable osc_ring to get entropy, sample period is set as 100 */
  72. writel(CRYPTO_V1_OSC_ENABLE | CRYPTO_V1_TRNG_SAMPLE_PERIOD(100),
  73. pdata->base + CRYPTO_V1_TRNG_CTRL);
  74. rk_clrsetreg(pdata->base + CRYPTO_V1_CTRL, CRYPTO_V1_RNG_START,
  75. CRYPTO_V1_RNG_START);
  76. retval = readl_poll_timeout(pdata->base + CRYPTO_V1_CTRL, reg,
  77. !(reg & CRYPTO_V1_RNG_START),
  78. RK_RNG_TIME_OUT);
  79. if (retval)
  80. goto exit;
  81. rk_rng_read_regs(pdata->base + CRYPTO_V1_TRNG_DOUT_0, data, len);
  82. exit:
  83. /* close TRNG */
  84. rk_clrreg(pdata->base + CRYPTO_V1_CTRL, CRYPTO_V1_RNG_START);
  85. return 0;
  86. }
  87. static int rk_v2_rng_read(struct udevice *dev, void *data, size_t len)
  88. {
  89. struct rk_rng_platdata *pdata = dev_get_priv(dev);
  90. u32 reg = 0;
  91. int retval;
  92. if (len > RK_HW_RNG_MAX)
  93. return -EINVAL;
  94. /* enable osc_ring to get entropy, sample period is set as 100 */
  95. writel(100, pdata->base + CRYPTO_V2_RNG_SAMPLE_CNT);
  96. reg |= CRYPTO_V2_RNG_256_BIT_LEN;
  97. reg |= CRYPTO_V2_RNG_SLOWER_SOC_RING_0;
  98. reg |= CRYPTO_V2_RNG_ENABLE;
  99. reg |= CRYPTO_V2_RNG_START;
  100. rk_clrsetreg(pdata->base + CRYPTO_V2_RNG_CTL, 0xffff, reg);
  101. retval = readl_poll_timeout(pdata->base + CRYPTO_V2_RNG_CTL, reg,
  102. !(reg & CRYPTO_V2_RNG_START),
  103. RK_RNG_TIME_OUT);
  104. if (retval)
  105. goto exit;
  106. rk_rng_read_regs(pdata->base + CRYPTO_V2_RNG_DOUT_0, data, len);
  107. exit:
  108. /* close TRNG */
  109. rk_clrreg(pdata->base + CRYPTO_V2_RNG_CTL, 0xffff);
  110. return retval;
  111. }
  112. static int rockchip_rng_read(struct udevice *dev, void *data, size_t len)
  113. {
  114. unsigned char *buf = data;
  115. unsigned int i;
  116. int ret = -EIO;
  117. struct rk_rng_platdata *pdata = dev_get_priv(dev);
  118. if (!len)
  119. return 0;
  120. if (!pdata->soc_data || !pdata->soc_data->rk_rng_read)
  121. return -EINVAL;
  122. for (i = 0; i < len / RK_HW_RNG_MAX; i++, buf += RK_HW_RNG_MAX) {
  123. ret = pdata->soc_data->rk_rng_read(dev, buf, RK_HW_RNG_MAX);
  124. if (ret)
  125. goto exit;
  126. }
  127. if (len % RK_HW_RNG_MAX)
  128. ret = pdata->soc_data->rk_rng_read(dev, buf,
  129. len % RK_HW_RNG_MAX);
  130. exit:
  131. return ret;
  132. }
  133. static int rockchip_rng_ofdata_to_platdata(struct udevice *dev)
  134. {
  135. struct rk_rng_platdata *pdata = dev_get_priv(dev);
  136. memset(pdata, 0x00, sizeof(*pdata));
  137. pdata->base = (fdt_addr_t)dev_read_addr_ptr(dev);
  138. if (!pdata->base)
  139. return -ENOMEM;
  140. return 0;
  141. }
  142. static int rockchip_rng_probe(struct udevice *dev)
  143. {
  144. struct rk_rng_platdata *pdata = dev_get_priv(dev);
  145. pdata->soc_data = (struct rk_rng_soc_data *)dev_get_driver_data(dev);
  146. return 0;
  147. }
  148. static const struct rk_rng_soc_data rk_rng_v1_soc_data = {
  149. .rk_rng_read = rk_v1_rng_read,
  150. };
  151. static const struct rk_rng_soc_data rk_rng_v2_soc_data = {
  152. .rk_rng_read = rk_v2_rng_read,
  153. };
  154. static const struct dm_rng_ops rockchip_rng_ops = {
  155. .read = rockchip_rng_read,
  156. };
  157. static const struct udevice_id rockchip_rng_match[] = {
  158. {
  159. .compatible = "rockchip,cryptov1-rng",
  160. .data = (ulong)&rk_rng_v1_soc_data,
  161. },
  162. {
  163. .compatible = "rockchip,cryptov2-rng",
  164. .data = (ulong)&rk_rng_v2_soc_data,
  165. },
  166. {},
  167. };
  168. U_BOOT_DRIVER(rockchip_rng) = {
  169. .name = "rockchip-rng",
  170. .id = UCLASS_RNG,
  171. .of_match = rockchip_rng_match,
  172. .ops = &rockchip_rng_ops,
  173. .probe = rockchip_rng_probe,
  174. .ofdata_to_platdata = rockchip_rng_ofdata_to_platdata,
  175. .priv_auto_alloc_size = sizeof(struct rk_rng_platdata),
  176. };