axp818.c 5.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * AXP818 driver based on AXP221 driver
  4. *
  5. *
  6. * (C) Copyright 2015 Vishnu Patekar <vishnuptekar0510@gmail.com>
  7. *
  8. * Based on axp221.c
  9. * (C) Copyright 2014 Hans de Goede <hdegoede@redhat.com>
  10. * (C) Copyright 2013 Oliver Schinagl <oliver@schinagl.nl>
  11. */
  12. #include <common.h>
  13. #include <command.h>
  14. #include <errno.h>
  15. #include <asm/arch/gpio.h>
  16. #include <asm/arch/pmic_bus.h>
  17. #include <axp_pmic.h>
  18. static u8 axp818_mvolt_to_cfg(int mvolt, int min, int max, int div)
  19. {
  20. if (mvolt < min)
  21. mvolt = min;
  22. else if (mvolt > max)
  23. mvolt = max;
  24. return (mvolt - min) / div;
  25. }
  26. int axp_set_dcdc1(unsigned int mvolt)
  27. {
  28. int ret;
  29. u8 cfg = axp818_mvolt_to_cfg(mvolt, 1600, 3400, 100);
  30. if (mvolt == 0)
  31. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL1,
  32. AXP818_OUTPUT_CTRL1_DCDC1_EN);
  33. ret = pmic_bus_write(AXP818_DCDC1_CTRL, cfg);
  34. if (ret)
  35. return ret;
  36. return pmic_bus_setbits(AXP818_OUTPUT_CTRL1,
  37. AXP818_OUTPUT_CTRL1_DCDC1_EN);
  38. }
  39. int axp_set_dcdc2(unsigned int mvolt)
  40. {
  41. int ret;
  42. u8 cfg;
  43. if (mvolt >= 1220)
  44. cfg = 70 + axp818_mvolt_to_cfg(mvolt, 1220, 1300, 20);
  45. else
  46. cfg = axp818_mvolt_to_cfg(mvolt, 500, 1200, 10);
  47. if (mvolt == 0)
  48. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL1,
  49. AXP818_OUTPUT_CTRL1_DCDC2_EN);
  50. ret = pmic_bus_write(AXP818_DCDC2_CTRL, cfg);
  51. if (ret)
  52. return ret;
  53. return pmic_bus_setbits(AXP818_OUTPUT_CTRL1,
  54. AXP818_OUTPUT_CTRL1_DCDC2_EN);
  55. }
  56. int axp_set_dcdc3(unsigned int mvolt)
  57. {
  58. int ret;
  59. u8 cfg;
  60. if (mvolt >= 1220)
  61. cfg = 70 + axp818_mvolt_to_cfg(mvolt, 1220, 1300, 20);
  62. else
  63. cfg = axp818_mvolt_to_cfg(mvolt, 500, 1200, 10);
  64. if (mvolt == 0)
  65. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL1,
  66. AXP818_OUTPUT_CTRL1_DCDC3_EN);
  67. ret = pmic_bus_write(AXP818_DCDC3_CTRL, cfg);
  68. if (ret)
  69. return ret;
  70. return pmic_bus_setbits(AXP818_OUTPUT_CTRL1,
  71. AXP818_OUTPUT_CTRL1_DCDC3_EN);
  72. }
  73. int axp_set_dcdc5(unsigned int mvolt)
  74. {
  75. int ret;
  76. u8 cfg;
  77. if (mvolt >= 1140)
  78. cfg = 32 + axp818_mvolt_to_cfg(mvolt, 1140, 1840, 20);
  79. else
  80. cfg = axp818_mvolt_to_cfg(mvolt, 800, 1120, 10);
  81. if (mvolt == 0)
  82. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL1,
  83. AXP818_OUTPUT_CTRL1_DCDC5_EN);
  84. ret = pmic_bus_write(AXP818_DCDC5_CTRL, cfg);
  85. if (ret)
  86. return ret;
  87. return pmic_bus_setbits(AXP818_OUTPUT_CTRL1,
  88. AXP818_OUTPUT_CTRL1_DCDC5_EN);
  89. }
  90. int axp_set_aldo(int aldo_num, unsigned int mvolt)
  91. {
  92. int ret;
  93. u8 cfg;
  94. if (aldo_num < 1 || aldo_num > 3)
  95. return -EINVAL;
  96. if (mvolt == 0)
  97. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL3,
  98. AXP818_OUTPUT_CTRL3_ALDO1_EN << (aldo_num - 1));
  99. cfg = axp818_mvolt_to_cfg(mvolt, 700, 3300, 100);
  100. ret = pmic_bus_write(AXP818_ALDO1_CTRL + (aldo_num - 1), cfg);
  101. if (ret)
  102. return ret;
  103. return pmic_bus_setbits(AXP818_OUTPUT_CTRL3,
  104. AXP818_OUTPUT_CTRL3_ALDO1_EN << (aldo_num - 1));
  105. }
  106. /* TODO: re-work other AXP drivers to consolidate ALDO functions. */
  107. int axp_set_aldo1(unsigned int mvolt)
  108. {
  109. return axp_set_aldo(1, mvolt);
  110. }
  111. int axp_set_aldo2(unsigned int mvolt)
  112. {
  113. return axp_set_aldo(2, mvolt);
  114. }
  115. int axp_set_aldo3(unsigned int mvolt)
  116. {
  117. return axp_set_aldo(3, mvolt);
  118. }
  119. int axp_set_dldo(int dldo_num, unsigned int mvolt)
  120. {
  121. int ret;
  122. u8 cfg;
  123. if (dldo_num < 1 || dldo_num > 4)
  124. return -EINVAL;
  125. if (mvolt == 0)
  126. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL2,
  127. AXP818_OUTPUT_CTRL2_DLDO1_EN << (dldo_num - 1));
  128. cfg = axp818_mvolt_to_cfg(mvolt, 700, 3300, 100);
  129. if (dldo_num == 2 && mvolt > 3300)
  130. cfg += 1 + axp818_mvolt_to_cfg(mvolt, 3400, 4200, 200);
  131. ret = pmic_bus_write(AXP818_DLDO1_CTRL + (dldo_num - 1), cfg);
  132. if (ret)
  133. return ret;
  134. return pmic_bus_setbits(AXP818_OUTPUT_CTRL2,
  135. AXP818_OUTPUT_CTRL2_DLDO1_EN << (dldo_num - 1));
  136. }
  137. int axp_set_eldo(int eldo_num, unsigned int mvolt)
  138. {
  139. int ret;
  140. u8 cfg;
  141. if (eldo_num < 1 || eldo_num > 3)
  142. return -EINVAL;
  143. if (mvolt == 0)
  144. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL2,
  145. AXP818_OUTPUT_CTRL2_ELDO1_EN << (eldo_num - 1));
  146. cfg = axp818_mvolt_to_cfg(mvolt, 700, 1900, 50);
  147. ret = pmic_bus_write(AXP818_ELDO1_CTRL + (eldo_num - 1), cfg);
  148. if (ret)
  149. return ret;
  150. return pmic_bus_setbits(AXP818_OUTPUT_CTRL2,
  151. AXP818_OUTPUT_CTRL2_ELDO1_EN << (eldo_num - 1));
  152. }
  153. int axp_set_fldo(int fldo_num, unsigned int mvolt)
  154. {
  155. int ret;
  156. u8 cfg;
  157. if (fldo_num < 1 || fldo_num > 3)
  158. return -EINVAL;
  159. if (mvolt == 0)
  160. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL3,
  161. AXP818_OUTPUT_CTRL3_FLDO1_EN << (fldo_num - 1));
  162. if (fldo_num < 3) {
  163. cfg = axp818_mvolt_to_cfg(mvolt, 700, 1450, 50);
  164. ret = pmic_bus_write(AXP818_FLDO1_CTRL + (fldo_num - 1), cfg);
  165. } else {
  166. /*
  167. * Special case for FLDO3, which is DCDC5 / 2 or FLDOIN / 2
  168. * Since FLDOIN is unknown, test against DCDC5.
  169. */
  170. if (mvolt * 2 == CONFIG_AXP_DCDC5_VOLT)
  171. ret = pmic_bus_clrbits(AXP818_FLDO2_3_CTRL,
  172. AXP818_FLDO2_3_CTRL_FLDO3_VOL);
  173. else
  174. ret = pmic_bus_setbits(AXP818_FLDO2_3_CTRL,
  175. AXP818_FLDO2_3_CTRL_FLDO3_VOL);
  176. }
  177. if (ret)
  178. return ret;
  179. return pmic_bus_setbits(AXP818_OUTPUT_CTRL3,
  180. AXP818_OUTPUT_CTRL3_FLDO1_EN << (fldo_num - 1));
  181. }
  182. int axp_set_sw(bool on)
  183. {
  184. if (on)
  185. return pmic_bus_setbits(AXP818_OUTPUT_CTRL2,
  186. AXP818_OUTPUT_CTRL2_SW_EN);
  187. return pmic_bus_clrbits(AXP818_OUTPUT_CTRL2,
  188. AXP818_OUTPUT_CTRL2_SW_EN);
  189. }
  190. int axp_init(void)
  191. {
  192. u8 axp_chip_id;
  193. int ret;
  194. ret = pmic_bus_init();
  195. if (ret)
  196. return ret;
  197. ret = pmic_bus_read(AXP818_CHIP_ID, &axp_chip_id);
  198. if (ret)
  199. return ret;
  200. if (!(axp_chip_id == 0x51))
  201. return -ENODEV;
  202. else
  203. return ret;
  204. return 0;
  205. }
  206. int do_poweroff(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
  207. {
  208. pmic_bus_write(AXP818_SHUTDOWN, AXP818_SHUTDOWN_POWEROFF);
  209. /* infinite loop during shutdown */
  210. while (1) {}
  211. /* not reached */
  212. return 0;
  213. }