rockchip-efuse.c 3.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * eFuse driver for Rockchip devices
  4. *
  5. * Copyright 2017, Theobroma Systems Design und Consulting GmbH
  6. * Written by Philipp Tomsich <philipp.tomsich@theobroma-systems.com>
  7. */
  8. #include <common.h>
  9. #include <asm/io.h>
  10. #include <command.h>
  11. #include <display_options.h>
  12. #include <dm.h>
  13. #include <linux/bitops.h>
  14. #include <linux/delay.h>
  15. #include <misc.h>
  16. #define RK3399_A_SHIFT 16
  17. #define RK3399_A_MASK 0x3ff
  18. #define RK3399_NFUSES 32
  19. #define RK3399_BYTES_PER_FUSE 4
  20. #define RK3399_STROBSFTSEL BIT(9)
  21. #define RK3399_RSB BIT(7)
  22. #define RK3399_PD BIT(5)
  23. #define RK3399_PGENB BIT(3)
  24. #define RK3399_LOAD BIT(2)
  25. #define RK3399_STROBE BIT(1)
  26. #define RK3399_CSB BIT(0)
  27. struct rockchip_efuse_regs {
  28. u32 ctrl; /* 0x00 efuse control register */
  29. u32 dout; /* 0x04 efuse data out register */
  30. u32 rf; /* 0x08 efuse redundancy bit used register */
  31. u32 _rsvd0;
  32. u32 jtag_pass; /* 0x10 JTAG password */
  33. u32 strobe_finish_ctrl;
  34. /* 0x14 efuse strobe finish control register */
  35. };
  36. struct rockchip_efuse_plat {
  37. void __iomem *base;
  38. struct clk *clk;
  39. };
  40. #if defined(DEBUG)
  41. static int dump_efuses(struct cmd_tbl *cmdtp, int flag,
  42. int argc, char *const argv[])
  43. {
  44. /*
  45. * N.B.: This function is tailored towards the RK3399 and assumes that
  46. * there's always 32 fuses x 32 bits (i.e. 128 bytes of data) to
  47. * be read.
  48. */
  49. struct udevice *dev;
  50. u8 fuses[128];
  51. int ret;
  52. /* retrieve the device */
  53. ret = uclass_get_device_by_driver(UCLASS_MISC,
  54. DM_DRIVER_GET(rockchip_efuse), &dev);
  55. if (ret) {
  56. printf("%s: no misc-device found\n", __func__);
  57. return 0;
  58. }
  59. ret = misc_read(dev, 0, &fuses, sizeof(fuses));
  60. if (ret < 0) {
  61. printf("%s: misc_read failed\n", __func__);
  62. return 0;
  63. }
  64. printf("efuse-contents:\n");
  65. print_buffer(0, fuses, 1, 128, 16);
  66. return 0;
  67. }
  68. U_BOOT_CMD(
  69. rk3399_dump_efuses, 1, 1, dump_efuses,
  70. "Dump the content of the efuses",
  71. ""
  72. );
  73. #endif
  74. static int rockchip_rk3399_efuse_read(struct udevice *dev, int offset,
  75. void *buf, int size)
  76. {
  77. struct rockchip_efuse_plat *plat = dev_get_plat(dev);
  78. struct rockchip_efuse_regs *efuse =
  79. (struct rockchip_efuse_regs *)plat->base;
  80. unsigned int addr_start, addr_end, addr_offset;
  81. u32 out_value;
  82. u8 bytes[RK3399_NFUSES * RK3399_BYTES_PER_FUSE];
  83. int i = 0;
  84. u32 addr;
  85. addr_start = offset / RK3399_BYTES_PER_FUSE;
  86. addr_offset = offset % RK3399_BYTES_PER_FUSE;
  87. addr_end = DIV_ROUND_UP(offset + size, RK3399_BYTES_PER_FUSE);
  88. /* cap to the size of the efuse block */
  89. if (addr_end > RK3399_NFUSES)
  90. addr_end = RK3399_NFUSES;
  91. writel(RK3399_LOAD | RK3399_PGENB | RK3399_STROBSFTSEL | RK3399_RSB,
  92. &efuse->ctrl);
  93. udelay(1);
  94. for (addr = addr_start; addr < addr_end; addr++) {
  95. setbits_le32(&efuse->ctrl,
  96. RK3399_STROBE | (addr << RK3399_A_SHIFT));
  97. udelay(1);
  98. out_value = readl(&efuse->dout);
  99. clrbits_le32(&efuse->ctrl, RK3399_STROBE);
  100. udelay(1);
  101. memcpy(&bytes[i], &out_value, RK3399_BYTES_PER_FUSE);
  102. i += RK3399_BYTES_PER_FUSE;
  103. }
  104. /* Switch to standby mode */
  105. writel(RK3399_PD | RK3399_CSB, &efuse->ctrl);
  106. memcpy(buf, bytes + addr_offset, size);
  107. return 0;
  108. }
  109. static int rockchip_efuse_read(struct udevice *dev, int offset,
  110. void *buf, int size)
  111. {
  112. return rockchip_rk3399_efuse_read(dev, offset, buf, size);
  113. }
  114. static const struct misc_ops rockchip_efuse_ops = {
  115. .read = rockchip_efuse_read,
  116. };
  117. static int rockchip_efuse_of_to_plat(struct udevice *dev)
  118. {
  119. struct rockchip_efuse_plat *plat = dev_get_plat(dev);
  120. plat->base = dev_read_addr_ptr(dev);
  121. return 0;
  122. }
  123. static const struct udevice_id rockchip_efuse_ids[] = {
  124. { .compatible = "rockchip,rk3399-efuse" },
  125. {}
  126. };
  127. U_BOOT_DRIVER(rockchip_efuse) = {
  128. .name = "rockchip_efuse",
  129. .id = UCLASS_MISC,
  130. .of_match = rockchip_efuse_ids,
  131. .of_to_plat = rockchip_efuse_of_to_plat,
  132. .plat_auto = sizeof(struct rockchip_efuse_plat),
  133. .ops = &rockchip_efuse_ops,
  134. };