tps65910_regulator.c 12 KB

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