zm7300.c 3.5 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235
  1. /*
  2. * Copyright 2013 Freescale Semiconductor, Inc.
  3. *
  4. * SPDX-License-Identifier: GPL-2.0+
  5. */
  6. /* Power-One ZM7300 DPM */
  7. #include "zm7300.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. u8 d;
  132. d = dpm_rrp(reg);
  133. return d;
  134. }
  135. /* ZM_write --
  136. Steps:
  137. a. Write data to the register
  138. b. Read data from register and compare to written value
  139. c. Return return_code & voltage_read
  140. */
  141. u8 zm_write(u8 reg, u8 data)
  142. {
  143. u8 d;
  144. /* write data to register */
  145. dpm_wrp(reg, data);
  146. /* read register and compare to written value */
  147. d = dpm_rrp(reg);
  148. if (d != data) {
  149. printf("zm_write : Comparison register data failed\n");
  150. return -1;
  151. }
  152. return d;
  153. }
  154. /* zm_write_out_voltage
  155. * voltage in 1/10 mV
  156. */
  157. int zm_write_voltage(int voltage)
  158. {
  159. u8 reg = 0x7, vid;
  160. uint16_t voltage_read;
  161. u8 ret;
  162. vid = (voltage - 5000) / ZM_STEP;
  163. ret = zm_write(reg, vid);
  164. if (ret != -1) {
  165. voltage_read = hex_to_1_10mv[ret];
  166. debug("voltage set to %dmV\n", voltage_read/10);
  167. return voltage_read;
  168. }
  169. return -1;
  170. }
  171. /* zm_read_out_voltage
  172. * voltage in 1/10 mV
  173. */
  174. int zm_read_voltage(void)
  175. {
  176. u8 reg = 0x7;
  177. u8 ret;
  178. int voltage;
  179. ret = zm_read(reg);
  180. if (ret != -1) {
  181. voltage = hex_to_1_10mv[ret];
  182. debug("Voltage read is %dmV\n", voltage/10);
  183. return voltage;
  184. } else {
  185. return -1;
  186. }
  187. }
  188. int zm_disable_wp()
  189. {
  190. u8 new_wp_value;
  191. /* Disable using Write-Protect register 0x96 */
  192. new_wp_value = 0x8;
  193. if ((dpm_wrm(DPM_WP, new_wp_value)) < 0) {
  194. printf("Disable Write-Protect register failed\n");
  195. return -1;
  196. }
  197. return 0;
  198. }
  199. int zm_enable_wp()
  200. {
  201. u8 orig_wp_value;
  202. orig_wp_value = 0x0;
  203. /* Enable using Write-Protect register 0x96 */
  204. if ((dpm_wrm(DPM_WP, orig_wp_value)) < 0) {
  205. printf("Enable Write-Protect register failed\n");
  206. return -1;
  207. }
  208. return 0;
  209. }