zm7300.c 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright 2013 Freescale Semiconductor, Inc.
  4. */
  5. /* Power-One ZM7300 DPM */
  6. #include "zm7300.h"
  7. #include <log.h>
  8. #define DPM_WP 0x96
  9. #define WRP_OPCODE 0x01
  10. #define WRM_OPCODE 0x02
  11. #define RRP_OPCODE 0x11
  12. #define DPM_SUCCESS 0x01
  13. #define DPM_EXEC_FAIL 0x00
  14. static const uint16_t hex_to_1_10mv[] = {
  15. 5000,
  16. 5125,
  17. 5250,
  18. 5375,
  19. 5500,
  20. 5625,
  21. 5750,
  22. 5875,
  23. 6000,
  24. 6125,
  25. 6250,
  26. 6375,
  27. 6500,
  28. 6625,
  29. 6750,
  30. 6875,
  31. 7000,
  32. 7125,
  33. 7250,
  34. 7375,
  35. 7500,
  36. 7625,
  37. 7750,
  38. 7875,
  39. 8000,
  40. 8125,
  41. 8250,
  42. 8375,
  43. 8500,
  44. 8625,
  45. 8750,
  46. 8875,
  47. 9000,
  48. 9125,
  49. 9250,
  50. 9375,
  51. 9500, /* 0.95mV */
  52. 9625,
  53. 9750,
  54. 9875,
  55. 10000, /* 1.0V */
  56. 10125,
  57. 10250,
  58. 10375,
  59. 10500,
  60. 10625,
  61. 10750,
  62. 10875,
  63. 11000,
  64. 11125,
  65. 11250,
  66. 11375,
  67. 11500,
  68. 11625,
  69. 11750,
  70. 11875,
  71. 12000,
  72. 12125,
  73. 12250,
  74. 12375,
  75. 0, /* reserved */
  76. };
  77. /* Read Data d from Register r of POL p */
  78. u8 dpm_rrp(uchar r)
  79. {
  80. u8 ret[5];
  81. ret[0] = RRP_OPCODE;
  82. /* POL is 0 */
  83. ret[1] = 0;
  84. ret[2] = r;
  85. i2c_read(I2C_DPM_ADDR, 0, -3, ret, 2);
  86. if (ret[1] == DPM_SUCCESS) { /* the DPM returned success as status */
  87. debug("RRP_OPCODE returned success data is %x\n", ret[0]);
  88. return ret[0];
  89. } else {
  90. return -1;
  91. }
  92. }
  93. /* Write Data d into DPM register r (RAM) */
  94. int dpm_wrm(u8 r, u8 d)
  95. {
  96. u8 ret[5];
  97. ret[0] = WRM_OPCODE;
  98. ret[1] = r;
  99. ret[2] = d;
  100. i2c_read(I2C_DPM_ADDR, 0, -3, ret, 1);
  101. if (ret[0] == DPM_SUCCESS) { /* the DPM returned success as status */
  102. debug("WRM_OPCODE returned success data is %x\n", ret[0]);
  103. return ret[0];
  104. } else {
  105. return -1;
  106. }
  107. }
  108. /* Write Data d into Register r of POL(s) a */
  109. int dpm_wrp(u8 r, u8 d)
  110. {
  111. u8 ret[7];
  112. ret[0] = WRP_OPCODE;
  113. /* only POL0 is present */
  114. ret[1] = 0x01;
  115. ret[2] = 0x00;
  116. ret[3] = 0x00;
  117. ret[4] = 0x00;
  118. ret[5] = r;
  119. ret[6] = d;
  120. i2c_read(I2C_DPM_ADDR, 0, -7, ret, 1);
  121. if (ret[0] == DPM_SUCCESS) { /* the DPM returned success as status */
  122. debug("WRP_OPCODE returned success data is %x\n", ret[0]);
  123. return 0;
  124. } else {
  125. return -1;
  126. }
  127. }
  128. /* Uses the DPM command RRP */
  129. u8 zm_read(uchar reg)
  130. {
  131. return dpm_rrp(reg);
  132. }
  133. /* ZM_write --
  134. Steps:
  135. a. Write data to the register
  136. b. Read data from register and compare to written value
  137. c. Return return_code & voltage_read
  138. */
  139. u8 zm_write(u8 reg, u8 data)
  140. {
  141. u8 d;
  142. /* write data to register */
  143. dpm_wrp(reg, data);
  144. /* read register and compare to written value */
  145. d = dpm_rrp(reg);
  146. if (d != data) {
  147. printf("zm_write : Comparison register data failed\n");
  148. return -1;
  149. }
  150. return d;
  151. }
  152. /* zm_write_out_voltage
  153. * voltage in 1/10 mV
  154. */
  155. int zm_write_voltage(int voltage)
  156. {
  157. u8 reg = 0x7, vid;
  158. uint16_t voltage_read;
  159. u8 ret;
  160. vid = (voltage - 5000) / ZM_STEP;
  161. ret = zm_write(reg, vid);
  162. if (ret != -1) {
  163. voltage_read = hex_to_1_10mv[ret];
  164. debug("voltage set to %dmV\n", voltage_read/10);
  165. return voltage_read;
  166. }
  167. return -1;
  168. }
  169. /* zm_read_out_voltage
  170. * voltage in 1/10 mV
  171. */
  172. int zm_read_voltage(void)
  173. {
  174. u8 reg = 0x7;
  175. u8 ret;
  176. int voltage;
  177. ret = zm_read(reg);
  178. if (ret != -1) {
  179. voltage = hex_to_1_10mv[ret];
  180. debug("Voltage read is %dmV\n", voltage/10);
  181. return voltage;
  182. } else {
  183. return -1;
  184. }
  185. }
  186. int zm_disable_wp()
  187. {
  188. u8 new_wp_value;
  189. /* Disable using Write-Protect register 0x96 */
  190. new_wp_value = 0x8;
  191. if ((dpm_wrm(DPM_WP, new_wp_value)) < 0) {
  192. printf("Disable Write-Protect register failed\n");
  193. return -1;
  194. }
  195. return 0;
  196. }
  197. int zm_enable_wp()
  198. {
  199. u8 orig_wp_value;
  200. orig_wp_value = 0x0;
  201. /* Enable using Write-Protect register 0x96 */
  202. if ((dpm_wrm(DPM_WP, orig_wp_value)) < 0) {
  203. printf("Enable Write-Protect register failed\n");
  204. return -1;
  205. }
  206. return 0;
  207. }