tps65941_regulator.c 7.8 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * (C) Copyright 2019
  4. * Texas Instruments Incorporated, <www.ti.com>
  5. *
  6. * Keerthy <j-keerthy@ti.com>
  7. */
  8. #include <common.h>
  9. #include <fdtdec.h>
  10. #include <errno.h>
  11. #include <dm.h>
  12. #include <i2c.h>
  13. #include <log.h>
  14. #include <linux/delay.h>
  15. #include <power/pmic.h>
  16. #include <power/regulator.h>
  17. #include <power/tps65941.h>
  18. static const char tps65941_buck_ctrl[TPS65941_BUCK_NUM] = {0x4, 0x6, 0x8, 0xA,
  19. 0xC};
  20. static const char tps65941_buck_vout[TPS65941_BUCK_NUM] = {0xE, 0x10, 0x12,
  21. 0x14, 0x16};
  22. static const char tps65941_ldo_ctrl[TPS65941_BUCK_NUM] = {0x1D, 0x1E, 0x1F,
  23. 0x20};
  24. static const char tps65941_ldo_vout[TPS65941_BUCK_NUM] = {0x23, 0x24, 0x25,
  25. 0x26};
  26. static int tps65941_buck_enable(struct udevice *dev, int op, bool *enable)
  27. {
  28. int ret;
  29. unsigned int adr;
  30. struct dm_regulator_uclass_platdata *uc_pdata;
  31. uc_pdata = dev_get_uclass_platdata(dev);
  32. adr = uc_pdata->ctrl_reg;
  33. ret = pmic_reg_read(dev->parent, adr);
  34. if (ret < 0)
  35. return ret;
  36. if (op == PMIC_OP_GET) {
  37. ret &= TPS65941_BUCK_MODE_MASK;
  38. if (ret)
  39. *enable = true;
  40. else
  41. *enable = false;
  42. return 0;
  43. } else if (op == PMIC_OP_SET) {
  44. if (*enable)
  45. ret |= TPS65941_BUCK_MODE_MASK;
  46. else
  47. ret &= ~TPS65941_BUCK_MODE_MASK;
  48. ret = pmic_reg_write(dev->parent, adr, ret);
  49. if (ret)
  50. return ret;
  51. }
  52. return 0;
  53. }
  54. static int tps65941_buck_volt2val(int uV)
  55. {
  56. if (uV > TPS65941_BUCK_VOLT_MAX)
  57. return -EINVAL;
  58. else if (uV > 1650000)
  59. return (uV - 1660000) / 20000 + 0xAB;
  60. else if (uV > 1110000)
  61. return (uV - 1110000) / 10000 + 0x73;
  62. else if (uV > 600000)
  63. return (uV - 600000) / 5000 + 0x0F;
  64. else if (uV >= 300000)
  65. return (uV - 300000) / 20000 + 0x00;
  66. else
  67. return -EINVAL;
  68. }
  69. static int tps65941_buck_val2volt(int val)
  70. {
  71. if (val > TPS65941_BUCK_VOLT_MAX_HEX)
  72. return -EINVAL;
  73. else if (val > 0xAB)
  74. return 1660000 + (val - 0xAB) * 20000;
  75. else if (val > 0x73)
  76. return 1100000 + (val - 0x73) * 10000;
  77. else if (val > 0xF)
  78. return 600000 + (val - 0xF) * 5000;
  79. else if (val >= 0x0)
  80. return 300000 + val * 5000;
  81. else
  82. return -EINVAL;
  83. }
  84. int tps65941_lookup_slew(int id)
  85. {
  86. switch (id) {
  87. case 0:
  88. return 33000;
  89. case 1:
  90. return 20000;
  91. case 2:
  92. return 10000;
  93. case 3:
  94. return 5000;
  95. case 4:
  96. return 2500;
  97. case 5:
  98. return 1300;
  99. case 6:
  100. return 630;
  101. case 7:
  102. return 310;
  103. default:
  104. return -1;
  105. }
  106. }
  107. static int tps65941_buck_val(struct udevice *dev, int op, int *uV)
  108. {
  109. unsigned int hex, adr;
  110. int ret, delta, uwait, slew;
  111. struct dm_regulator_uclass_platdata *uc_pdata;
  112. uc_pdata = dev_get_uclass_platdata(dev);
  113. if (op == PMIC_OP_GET)
  114. *uV = 0;
  115. adr = uc_pdata->volt_reg;
  116. ret = pmic_reg_read(dev->parent, adr);
  117. if (ret < 0)
  118. return ret;
  119. ret &= TPS65941_BUCK_VOLT_MASK;
  120. ret = tps65941_buck_val2volt(ret);
  121. if (ret < 0)
  122. return ret;
  123. if (op == PMIC_OP_GET) {
  124. *uV = ret;
  125. return 0;
  126. }
  127. /*
  128. * Compute the delta voltage, find the slew rate and wait
  129. * for the appropriate amount of time after voltage switch
  130. */
  131. if (*uV > ret)
  132. delta = *uV - ret;
  133. else
  134. delta = ret - *uV;
  135. slew = pmic_reg_read(dev->parent, uc_pdata->ctrl_reg + 1);
  136. if (slew < 0)
  137. return ret;
  138. slew &= TP65941_BUCK_CONF_SLEW_MASK;
  139. slew = tps65941_lookup_slew(slew);
  140. if (slew <= 0)
  141. return ret;
  142. uwait = delta / slew;
  143. hex = tps65941_buck_volt2val(*uV);
  144. if (hex < 0)
  145. return hex;
  146. ret &= 0x0;
  147. ret = hex;
  148. ret = pmic_reg_write(dev->parent, adr, ret);
  149. udelay(uwait);
  150. return ret;
  151. }
  152. static int tps65941_ldo_enable(struct udevice *dev, int op, bool *enable)
  153. {
  154. int ret;
  155. unsigned int adr;
  156. struct dm_regulator_uclass_platdata *uc_pdata;
  157. uc_pdata = dev_get_uclass_platdata(dev);
  158. adr = uc_pdata->ctrl_reg;
  159. ret = pmic_reg_read(dev->parent, adr);
  160. if (ret < 0)
  161. return ret;
  162. if (op == PMIC_OP_GET) {
  163. ret &= TPS65941_LDO_MODE_MASK;
  164. if (ret)
  165. *enable = true;
  166. else
  167. *enable = false;
  168. return 0;
  169. } else if (op == PMIC_OP_SET) {
  170. if (*enable)
  171. ret |= TPS65941_LDO_MODE_MASK;
  172. else
  173. ret &= ~TPS65941_LDO_MODE_MASK;
  174. ret = pmic_reg_write(dev->parent, adr, ret);
  175. if (ret)
  176. return ret;
  177. }
  178. return 0;
  179. }
  180. static int tps65941_ldo_val2volt(int val)
  181. {
  182. if (val > TPS65941_LDO_VOLT_MAX_HEX || val < TPS65941_LDO_VOLT_MIN_HEX)
  183. return -EINVAL;
  184. else if (val >= TPS65941_LDO_VOLT_MIN_HEX)
  185. return 600000 + (val - TPS65941_LDO_VOLT_MIN_HEX) * 50000;
  186. else
  187. return -EINVAL;
  188. }
  189. static int tps65941_ldo_val(struct udevice *dev, int op, int *uV)
  190. {
  191. unsigned int hex, adr;
  192. int ret;
  193. struct dm_regulator_uclass_platdata *uc_pdata;
  194. uc_pdata = dev_get_uclass_platdata(dev);
  195. if (op == PMIC_OP_GET)
  196. *uV = 0;
  197. adr = uc_pdata->volt_reg;
  198. ret = pmic_reg_read(dev->parent, adr);
  199. if (ret < 0)
  200. return ret;
  201. ret &= TPS65941_LDO_VOLT_MASK;
  202. ret = tps65941_ldo_val2volt(ret);
  203. if (ret < 0)
  204. return ret;
  205. if (op == PMIC_OP_GET) {
  206. *uV = ret;
  207. return 0;
  208. }
  209. hex = tps65941_buck_volt2val(*uV);
  210. if (hex < 0)
  211. return hex;
  212. ret &= 0x0;
  213. ret = hex;
  214. ret = pmic_reg_write(dev->parent, adr, ret);
  215. return ret;
  216. }
  217. static int tps65941_ldo_probe(struct udevice *dev)
  218. {
  219. struct dm_regulator_uclass_platdata *uc_pdata;
  220. int idx;
  221. uc_pdata = dev_get_uclass_platdata(dev);
  222. uc_pdata->type = REGULATOR_TYPE_LDO;
  223. idx = dev->driver_data;
  224. if (idx == 1 || idx == 2 || idx == 3 || idx == 4) {
  225. debug("Single phase regulator\n");
  226. } else {
  227. printf("Wrong ID for regulator\n");
  228. return -EINVAL;
  229. }
  230. uc_pdata->ctrl_reg = tps65941_ldo_ctrl[idx - 1];
  231. uc_pdata->volt_reg = tps65941_ldo_vout[idx - 1];
  232. return 0;
  233. }
  234. static int tps65941_buck_probe(struct udevice *dev)
  235. {
  236. struct dm_regulator_uclass_platdata *uc_pdata;
  237. int idx;
  238. uc_pdata = dev_get_uclass_platdata(dev);
  239. uc_pdata->type = REGULATOR_TYPE_BUCK;
  240. idx = dev->driver_data;
  241. if (idx == 1 || idx == 2 || idx == 3 || idx == 4 || idx == 5) {
  242. debug("Single phase regulator\n");
  243. } else if (idx == 12) {
  244. idx = 1;
  245. } else if (idx == 34) {
  246. idx = 3;
  247. } else if (idx == 1234) {
  248. idx = 1;
  249. } else {
  250. printf("Wrong ID for regulator\n");
  251. return -EINVAL;
  252. }
  253. uc_pdata->ctrl_reg = tps65941_buck_ctrl[idx - 1];
  254. uc_pdata->volt_reg = tps65941_buck_vout[idx - 1];
  255. return 0;
  256. }
  257. static int ldo_get_value(struct udevice *dev)
  258. {
  259. int uV;
  260. int ret;
  261. ret = tps65941_ldo_val(dev, PMIC_OP_GET, &uV);
  262. if (ret)
  263. return ret;
  264. return uV;
  265. }
  266. static int ldo_set_value(struct udevice *dev, int uV)
  267. {
  268. return tps65941_ldo_val(dev, PMIC_OP_SET, &uV);
  269. }
  270. static int ldo_get_enable(struct udevice *dev)
  271. {
  272. bool enable = false;
  273. int ret;
  274. ret = tps65941_ldo_enable(dev, PMIC_OP_GET, &enable);
  275. if (ret)
  276. return ret;
  277. return enable;
  278. }
  279. static int ldo_set_enable(struct udevice *dev, bool enable)
  280. {
  281. return tps65941_ldo_enable(dev, PMIC_OP_SET, &enable);
  282. }
  283. static int buck_get_value(struct udevice *dev)
  284. {
  285. int uV;
  286. int ret;
  287. ret = tps65941_buck_val(dev, PMIC_OP_GET, &uV);
  288. if (ret)
  289. return ret;
  290. return uV;
  291. }
  292. static int buck_set_value(struct udevice *dev, int uV)
  293. {
  294. return tps65941_buck_val(dev, PMIC_OP_SET, &uV);
  295. }
  296. static int buck_get_enable(struct udevice *dev)
  297. {
  298. bool enable = false;
  299. int ret;
  300. ret = tps65941_buck_enable(dev, PMIC_OP_GET, &enable);
  301. if (ret)
  302. return ret;
  303. return enable;
  304. }
  305. static int buck_set_enable(struct udevice *dev, bool enable)
  306. {
  307. return tps65941_buck_enable(dev, PMIC_OP_SET, &enable);
  308. }
  309. static const struct dm_regulator_ops tps65941_ldo_ops = {
  310. .get_value = ldo_get_value,
  311. .set_value = ldo_set_value,
  312. .get_enable = ldo_get_enable,
  313. .set_enable = ldo_set_enable,
  314. };
  315. U_BOOT_DRIVER(tps65941_ldo) = {
  316. .name = TPS65941_LDO_DRIVER,
  317. .id = UCLASS_REGULATOR,
  318. .ops = &tps65941_ldo_ops,
  319. .probe = tps65941_ldo_probe,
  320. };
  321. static const struct dm_regulator_ops tps65941_buck_ops = {
  322. .get_value = buck_get_value,
  323. .set_value = buck_set_value,
  324. .get_enable = buck_get_enable,
  325. .set_enable = buck_set_enable,
  326. };
  327. U_BOOT_DRIVER(tps65941_buck) = {
  328. .name = TPS65941_BUCK_DRIVER,
  329. .id = UCLASS_REGULATOR,
  330. .ops = &tps65941_buck_ops,
  331. .probe = tps65941_buck_probe,
  332. };