tps65910_regulator.c 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) EETS GmbH, 2017, Felix Brack <f.brack@eets.ch>
  4. */
  5. #include <common.h>
  6. #include <dm.h>
  7. #include <power/pmic.h>
  8. #include <power/regulator.h>
  9. #include <power/tps65910_pmic.h>
  10. #define VOUT_CHOICE_COUNT 4
  11. /*
  12. * struct regulator_props - Properties of a LDO and VIO SMPS regulator
  13. *
  14. * All of these regulators allow setting one out of four output voltages.
  15. * These output voltages are only achievable when supplying the regulator
  16. * with a minimum input voltage.
  17. *
  18. * @vin_min[]: minimum supply input voltage in uV required to achieve the
  19. * corresponding vout[] voltage
  20. * @vout[]: regulator output voltage in uV
  21. * @reg: I2C register used to set regulator voltage
  22. */
  23. struct regulator_props {
  24. int vin_min[VOUT_CHOICE_COUNT];
  25. int vout[VOUT_CHOICE_COUNT];
  26. int reg;
  27. };
  28. static const struct regulator_props ldo_props_vdig1 = {
  29. .vin_min = { 1700000, 2100000, 2700000, 3200000 },
  30. .vout = { 1200000, 1500000, 1800000, 2700000 },
  31. .reg = TPS65910_REG_VDIG1
  32. };
  33. static const struct regulator_props ldo_props_vdig2 = {
  34. .vin_min = { 1700000, 1700000, 1700000, 2700000 },
  35. .vout = { 1000000, 1100000, 1200000, 1800000 },
  36. .reg = TPS65910_REG_VDIG2
  37. };
  38. static const struct regulator_props ldo_props_vpll = {
  39. .vin_min = { 2700000, 2700000, 2700000, 3000000 },
  40. .vout = { 1000000, 1100000, 1800000, 2500000 },
  41. .reg = TPS65910_REG_VPLL
  42. };
  43. static const struct regulator_props ldo_props_vdac = {
  44. .vin_min = { 2700000, 3000000, 3200000, 3200000 },
  45. .vout = { 1800000, 2600000, 2800000, 2850000 },
  46. .reg = TPS65910_REG_VDAC
  47. };
  48. static const struct regulator_props ldo_props_vaux1 = {
  49. .vin_min = { 2700000, 3200000, 3200000, 3200000 },
  50. .vout = { 1800000, 2500000, 2800000, 2850000 },
  51. .reg = TPS65910_REG_VAUX1
  52. };
  53. static const struct regulator_props ldo_props_vaux2 = {
  54. .vin_min = { 2700000, 3200000, 3200000, 3600000 },
  55. .vout = { 1800000, 2800000, 2900000, 3300000 },
  56. .reg = TPS65910_REG_VAUX2
  57. };
  58. static const struct regulator_props ldo_props_vaux33 = {
  59. .vin_min = { 2700000, 2700000, 3200000, 3600000 },
  60. .vout = { 1800000, 2000000, 2800000, 3300000 },
  61. .reg = TPS65910_REG_VAUX33
  62. };
  63. static const struct regulator_props ldo_props_vmmc = {
  64. .vin_min = { 2700000, 3200000, 3200000, 3600000 },
  65. .vout = { 1800000, 2800000, 3000000, 3300000 },
  66. .reg = TPS65910_REG_VMMC
  67. };
  68. static const struct regulator_props smps_props_vio = {
  69. .vin_min = { 3200000, 3200000, 4000000, 4400000 },
  70. .vout = { 1500000, 1800000, 2500000, 3300000 },
  71. .reg = TPS65910_REG_VIO
  72. };
  73. /* lookup table of control registers indexed by regulator unit number */
  74. static const int ctrl_regs[] = {
  75. TPS65910_REG_VRTC,
  76. TPS65910_REG_VIO,
  77. TPS65910_REG_VDD1,
  78. TPS65910_REG_VDD2,
  79. TPS65910_REG_VDD3,
  80. TPS65910_REG_VDIG1,
  81. TPS65910_REG_VDIG2,
  82. TPS65910_REG_VPLL,
  83. TPS65910_REG_VDAC,
  84. TPS65910_REG_VAUX1,
  85. TPS65910_REG_VAUX2,
  86. TPS65910_REG_VAUX33,
  87. TPS65910_REG_VMMC
  88. };
  89. /* supply names as used in DT */
  90. static const char * const supply_names[] = {
  91. "vccio-supply",
  92. "vcc1-supply",
  93. "vcc2-supply",
  94. "vcc3-supply",
  95. "vcc4-supply",
  96. "vcc5-supply",
  97. "vcc6-supply",
  98. "vcc7-supply"
  99. };
  100. /* lookup table of regulator supplies indexed by regulator unit number */
  101. static const int regulator_supplies[] = {
  102. TPS65910_SUPPLY_VCC7,
  103. TPS65910_SUPPLY_VCCIO,
  104. TPS65910_SUPPLY_VCC1,
  105. TPS65910_SUPPLY_VCC2,
  106. TPS65910_SUPPLY_VCC7,
  107. TPS65910_SUPPLY_VCC6,
  108. TPS65910_SUPPLY_VCC6,
  109. TPS65910_SUPPLY_VCC5,
  110. TPS65910_SUPPLY_VCC5,
  111. TPS65910_SUPPLY_VCC4,
  112. TPS65910_SUPPLY_VCC4,
  113. TPS65910_SUPPLY_VCC3,
  114. TPS65910_SUPPLY_VCC3
  115. };
  116. static int get_ctrl_reg_from_unit_addr(const uint unit_addr)
  117. {
  118. if (unit_addr < ARRAY_SIZE(ctrl_regs))
  119. return ctrl_regs[unit_addr];
  120. return -ENXIO;
  121. }
  122. static int tps65910_regulator_get_value(struct udevice *dev,
  123. const struct regulator_props *rgp)
  124. {
  125. int sel, val, vout;
  126. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  127. int vin = pdata->supply;
  128. val = pmic_reg_read(dev->parent, rgp->reg);
  129. if (val < 0)
  130. return val;
  131. sel = (val & TPS65910_SEL_MASK) >> 2;
  132. vout = (vin >= *(rgp->vin_min + sel)) ? *(rgp->vout + sel) : 0;
  133. vout = ((val & TPS65910_SUPPLY_STATE_MASK) == 1) ? vout : 0;
  134. return vout;
  135. }
  136. static int tps65910_ldo_get_value(struct udevice *dev)
  137. {
  138. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  139. int vin;
  140. if (!pdata)
  141. return 0;
  142. vin = pdata->supply;
  143. switch (pdata->unit) {
  144. case TPS65910_UNIT_VRTC:
  145. /* VRTC is fixed and can't be turned off */
  146. return (vin >= 2500000) ? 1830000 : 0;
  147. case TPS65910_UNIT_VDIG1:
  148. return tps65910_regulator_get_value(dev, &ldo_props_vdig1);
  149. case TPS65910_UNIT_VDIG2:
  150. return tps65910_regulator_get_value(dev, &ldo_props_vdig2);
  151. case TPS65910_UNIT_VPLL:
  152. return tps65910_regulator_get_value(dev, &ldo_props_vpll);
  153. case TPS65910_UNIT_VDAC:
  154. return tps65910_regulator_get_value(dev, &ldo_props_vdac);
  155. case TPS65910_UNIT_VAUX1:
  156. return tps65910_regulator_get_value(dev, &ldo_props_vaux1);
  157. case TPS65910_UNIT_VAUX2:
  158. return tps65910_regulator_get_value(dev, &ldo_props_vaux2);
  159. case TPS65910_UNIT_VAUX33:
  160. return tps65910_regulator_get_value(dev, &ldo_props_vaux33);
  161. case TPS65910_UNIT_VMMC:
  162. return tps65910_regulator_get_value(dev, &ldo_props_vmmc);
  163. default:
  164. return 0;
  165. }
  166. }
  167. static int tps65910_regulator_set_value(struct udevice *dev,
  168. const struct regulator_props *ldo,
  169. int uV)
  170. {
  171. int val;
  172. int sel = 0;
  173. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  174. do {
  175. /* we only allow exact voltage matches */
  176. if (uV == *(ldo->vout + sel))
  177. break;
  178. } while (++sel < VOUT_CHOICE_COUNT);
  179. if (sel == VOUT_CHOICE_COUNT)
  180. return -EINVAL;
  181. if (pdata->supply < *(ldo->vin_min + sel))
  182. return -EINVAL;
  183. val = pmic_reg_read(dev->parent, ldo->reg);
  184. if (val < 0)
  185. return val;
  186. val &= ~TPS65910_SEL_MASK;
  187. val |= sel << 2;
  188. return pmic_reg_write(dev->parent, ldo->reg, val);
  189. }
  190. static int tps65910_ldo_set_value(struct udevice *dev, int uV)
  191. {
  192. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  193. int vin = pdata->supply;
  194. switch (pdata->unit) {
  195. case TPS65910_UNIT_VRTC:
  196. /* VRTC is fixed to 1.83V and can't be turned off */
  197. if (vin < 2500000)
  198. return -EINVAL;
  199. return 0;
  200. case TPS65910_UNIT_VDIG1:
  201. return tps65910_regulator_set_value(dev, &ldo_props_vdig1, uV);
  202. case TPS65910_UNIT_VDIG2:
  203. return tps65910_regulator_set_value(dev, &ldo_props_vdig2, uV);
  204. case TPS65910_UNIT_VPLL:
  205. return tps65910_regulator_set_value(dev, &ldo_props_vpll, uV);
  206. case TPS65910_UNIT_VDAC:
  207. return tps65910_regulator_set_value(dev, &ldo_props_vdac, uV);
  208. case TPS65910_UNIT_VAUX1:
  209. return tps65910_regulator_set_value(dev, &ldo_props_vaux1, uV);
  210. case TPS65910_UNIT_VAUX2:
  211. return tps65910_regulator_set_value(dev, &ldo_props_vaux2, uV);
  212. case TPS65910_UNIT_VAUX33:
  213. return tps65910_regulator_set_value(dev, &ldo_props_vaux33, uV);
  214. case TPS65910_UNIT_VMMC:
  215. return tps65910_regulator_set_value(dev, &ldo_props_vmmc, uV);
  216. default:
  217. return 0;
  218. }
  219. }
  220. static int tps65910_get_enable(struct udevice *dev)
  221. {
  222. int reg, val;
  223. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  224. reg = get_ctrl_reg_from_unit_addr(pdata->unit);
  225. if (reg < 0)
  226. return reg;
  227. val = pmic_reg_read(dev->parent, reg);
  228. if (val < 0)
  229. return val;
  230. /* bits 1:0 of regulator control register define state */
  231. return ((val & TPS65910_SUPPLY_STATE_MASK) == 1);
  232. }
  233. static int tps65910_set_enable(struct udevice *dev, bool enable)
  234. {
  235. int reg;
  236. uint clr, set;
  237. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  238. reg = get_ctrl_reg_from_unit_addr(pdata->unit);
  239. if (reg < 0)
  240. return reg;
  241. if (enable) {
  242. clr = TPS65910_SUPPLY_STATE_MASK & ~TPS65910_SUPPLY_STATE_ON;
  243. set = TPS65910_SUPPLY_STATE_MASK & TPS65910_SUPPLY_STATE_ON;
  244. } else {
  245. clr = TPS65910_SUPPLY_STATE_MASK & ~TPS65910_SUPPLY_STATE_OFF;
  246. set = TPS65910_SUPPLY_STATE_MASK & TPS65910_SUPPLY_STATE_OFF;
  247. }
  248. return pmic_clrsetbits(dev->parent, reg, clr, set);
  249. }
  250. static int buck_get_vdd1_vdd2_value(struct udevice *dev, int reg_vdd)
  251. {
  252. int gain;
  253. int val = pmic_reg_read(dev, reg_vdd);
  254. if (val < 0)
  255. return val;
  256. gain = (val & TPS65910_GAIN_SEL_MASK) >> 6;
  257. gain = (gain == 0) ? 1 : gain;
  258. val = pmic_reg_read(dev, reg_vdd + 1);
  259. if (val < 0)
  260. return val;
  261. if (val & TPS65910_VDD_SR_MASK)
  262. /* use smart reflex value instead */
  263. val = pmic_reg_read(dev, reg_vdd + 2);
  264. if (val < 0)
  265. return val;
  266. return (562500 + (val & TPS65910_VDD_SEL_MASK) * 12500) * gain;
  267. }
  268. static int tps65910_buck_get_value(struct udevice *dev)
  269. {
  270. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  271. switch (pdata->unit) {
  272. case TPS65910_UNIT_VIO:
  273. return tps65910_regulator_get_value(dev, &smps_props_vio);
  274. case TPS65910_UNIT_VDD1:
  275. return buck_get_vdd1_vdd2_value(dev->parent, TPS65910_REG_VDD1);
  276. case TPS65910_UNIT_VDD2:
  277. return buck_get_vdd1_vdd2_value(dev->parent, TPS65910_REG_VDD2);
  278. default:
  279. return 0;
  280. }
  281. }
  282. static int buck_set_vdd1_vdd2_value(struct udevice *dev, int uV)
  283. {
  284. int ret, reg_vdd, gain;
  285. int val;
  286. struct dm_regulator_uclass_platdata *uc_pdata;
  287. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  288. switch (pdata->unit) {
  289. case TPS65910_UNIT_VDD1:
  290. reg_vdd = TPS65910_REG_VDD1;
  291. break;
  292. case TPS65910_UNIT_VDD2:
  293. reg_vdd = TPS65910_REG_VDD2;
  294. break;
  295. default:
  296. return -EINVAL;
  297. }
  298. uc_pdata = dev_get_uclass_platdata(dev);
  299. /* check setpoint is within limits */
  300. if (uV < uc_pdata->min_uV) {
  301. pr_err("voltage %duV for %s too low\n", uV, dev->name);
  302. return -EINVAL;
  303. }
  304. if (uV > uc_pdata->max_uV) {
  305. pr_err("voltage %duV for %s too high\n", uV, dev->name);
  306. return -EINVAL;
  307. }
  308. val = pmic_reg_read(dev->parent, reg_vdd);
  309. if (val < 0)
  310. return val;
  311. gain = (val & TPS65910_GAIN_SEL_MASK) >> 6;
  312. gain = (gain == 0) ? 1 : gain;
  313. val = ((uV / gain) - 562500) / 12500;
  314. if (val < TPS65910_VDD_SEL_MIN || val > TPS65910_VDD_SEL_MAX)
  315. /*
  316. * Neither do we change the gain, nor do we allow shutdown or
  317. * any approximate value (for now)
  318. */
  319. return -EPERM;
  320. val &= TPS65910_VDD_SEL_MASK;
  321. ret = pmic_reg_write(dev->parent, reg_vdd + 1, val);
  322. if (ret)
  323. return ret;
  324. return 0;
  325. }
  326. static int tps65910_buck_set_value(struct udevice *dev, int uV)
  327. {
  328. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  329. if (pdata->unit == TPS65910_UNIT_VIO)
  330. return tps65910_regulator_set_value(dev, &smps_props_vio, uV);
  331. return buck_set_vdd1_vdd2_value(dev, uV);
  332. }
  333. static int tps65910_boost_get_value(struct udevice *dev)
  334. {
  335. int vout;
  336. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  337. vout = (pdata->supply >= 3000000) ? 5000000 : 0;
  338. return vout;
  339. }
  340. static int tps65910_regulator_ofdata_to_platdata(struct udevice *dev)
  341. {
  342. struct udevice *supply;
  343. int ret;
  344. const char *supply_name;
  345. struct tps65910_regulator_pdata *pdata = dev_get_platdata(dev);
  346. pdata->unit = dev_get_driver_data(dev);
  347. if (pdata->unit > TPS65910_UNIT_VMMC)
  348. return -EINVAL;
  349. supply_name = supply_names[regulator_supplies[pdata->unit]];
  350. debug("Looking up supply power %s\n", supply_name);
  351. ret = device_get_supply_regulator(dev->parent, supply_name, &supply);
  352. if (ret) {
  353. debug(" missing supply power %s\n", supply_name);
  354. return ret;
  355. }
  356. pdata->supply = regulator_get_value(supply);
  357. if (pdata->supply < 0) {
  358. debug(" invalid supply voltage for regulator %s\n",
  359. supply->name);
  360. return -EINVAL;
  361. }
  362. return 0;
  363. }
  364. static const struct dm_regulator_ops tps65910_boost_ops = {
  365. .get_value = tps65910_boost_get_value,
  366. .get_enable = tps65910_get_enable,
  367. .set_enable = tps65910_set_enable,
  368. };
  369. U_BOOT_DRIVER(tps65910_boost) = {
  370. .name = TPS65910_BOOST_DRIVER,
  371. .id = UCLASS_REGULATOR,
  372. .ops = &tps65910_boost_ops,
  373. .platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
  374. .ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
  375. };
  376. static const struct dm_regulator_ops tps65910_buck_ops = {
  377. .get_value = tps65910_buck_get_value,
  378. .set_value = tps65910_buck_set_value,
  379. .get_enable = tps65910_get_enable,
  380. .set_enable = tps65910_set_enable,
  381. };
  382. U_BOOT_DRIVER(tps65910_buck) = {
  383. .name = TPS65910_BUCK_DRIVER,
  384. .id = UCLASS_REGULATOR,
  385. .ops = &tps65910_buck_ops,
  386. .platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
  387. .ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
  388. };
  389. static const struct dm_regulator_ops tps65910_ldo_ops = {
  390. .get_value = tps65910_ldo_get_value,
  391. .set_value = tps65910_ldo_set_value,
  392. .get_enable = tps65910_get_enable,
  393. .set_enable = tps65910_set_enable,
  394. };
  395. U_BOOT_DRIVER(tps65910_ldo) = {
  396. .name = TPS65910_LDO_DRIVER,
  397. .id = UCLASS_REGULATOR,
  398. .ops = &tps65910_ldo_ops,
  399. .platdata_auto_alloc_size = sizeof(struct tps65910_regulator_pdata),
  400. .ofdata_to_platdata = tps65910_regulator_ofdata_to_platdata,
  401. };