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