s2mps11_regulator.c 11 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608
  1. // SPDX-License-Identifier: GPL-2.0
  2. /*
  3. * Copyright (C) 2018 Samsung Electronics
  4. * Jaehoon Chung <jh80.chung@samsung.com>
  5. */
  6. #include <common.h>
  7. #include <fdtdec.h>
  8. #include <errno.h>
  9. #include <dm.h>
  10. #include <i2c.h>
  11. #include <linux/delay.h>
  12. #include <power/pmic.h>
  13. #include <power/regulator.h>
  14. #include <power/s2mps11.h>
  15. #define MODE(_id, _val, _name) { \
  16. .id = _id, \
  17. .register_value = _val, \
  18. .name = _name, \
  19. }
  20. /* BUCK : 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 */
  21. static struct dm_regulator_mode s2mps11_buck_modes[] = {
  22. MODE(OP_OFF, S2MPS11_BUCK_MODE_OFF, "OFF"),
  23. MODE(OP_STANDBY, S2MPS11_BUCK_MODE_STANDBY, "ON/OFF"),
  24. MODE(OP_ON, S2MPS11_BUCK_MODE_STANDBY, "ON"),
  25. };
  26. static struct dm_regulator_mode s2mps11_ldo_modes[] = {
  27. MODE(OP_OFF, S2MPS11_LDO_MODE_OFF, "OFF"),
  28. MODE(OP_STANDBY, S2MPS11_LDO_MODE_STANDBY, "ON/OFF"),
  29. MODE(OP_STANDBY_LPM, S2MPS11_LDO_MODE_STANDBY_LPM, "ON/LPM"),
  30. MODE(OP_ON, S2MPS11_LDO_MODE_ON, "ON"),
  31. };
  32. static const char s2mps11_buck_ctrl[] = {
  33. 0xff, 0x25, 0x27, 0x29, 0x2b, 0x2d, 0x33, 0x35, 0x37, 0x39, 0x3b
  34. };
  35. static const char s2mps11_buck_out[] = {
  36. 0xff, 0x26, 0x28, 0x2a, 0x2c, 0x2f, 0x34, 0x36, 0x38, 0x3a, 0x3c
  37. };
  38. static int s2mps11_buck_hex2volt(int buck, int hex)
  39. {
  40. unsigned int uV = 0;
  41. if (hex < 0)
  42. goto bad;
  43. switch (buck) {
  44. case 7:
  45. case 8:
  46. case 10:
  47. if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX)
  48. goto bad;
  49. uV = hex * S2MPS11_BUCK_HSTEP + S2MPS11_BUCK_UV_HMIN;
  50. break;
  51. case 9:
  52. if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX)
  53. goto bad;
  54. uV = hex * S2MPS11_BUCK9_STEP * 2 + S2MPS11_BUCK9_UV_MIN;
  55. break;
  56. default:
  57. if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX)
  58. goto bad;
  59. else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX)
  60. goto bad;
  61. uV = hex * S2MPS11_BUCK_LSTEP + S2MPS11_BUCK_UV_MIN;
  62. break;
  63. }
  64. return uV;
  65. bad:
  66. pr_err("Value: %#x is wrong for BUCK%d", hex, buck);
  67. return -EINVAL;
  68. }
  69. static int s2mps11_buck_volt2hex(int buck, int uV)
  70. {
  71. int hex;
  72. switch (buck) {
  73. case 7:
  74. case 8:
  75. case 10:
  76. hex = (uV - S2MPS11_BUCK_UV_HMIN) / S2MPS11_BUCK_HSTEP;
  77. if (hex > S2MPS11_BUCK7_8_10_VOLT_MAX_HEX)
  78. goto bad;
  79. break;
  80. case 9:
  81. hex = (uV - S2MPS11_BUCK9_UV_MIN) / S2MPS11_BUCK9_STEP;
  82. if (hex > S2MPS11_BUCK9_VOLT_MAX_HEX)
  83. goto bad;
  84. break;
  85. default:
  86. hex = (uV - S2MPS11_BUCK_UV_MIN) / S2MPS11_BUCK_LSTEP;
  87. if (buck == 5 && hex > S2MPS11_BUCK5_VOLT_MAX_HEX)
  88. goto bad;
  89. else if (buck != 5 && hex > S2MPS11_BUCK_VOLT_MAX_HEX)
  90. goto bad;
  91. break;
  92. };
  93. if (hex >= 0)
  94. return hex;
  95. bad:
  96. pr_err("Value: %d uV is wrong for BUCK%d", uV, buck);
  97. return -EINVAL;
  98. }
  99. static int s2mps11_buck_val(struct udevice *dev, int op, int *uV)
  100. {
  101. int hex, buck, ret;
  102. u32 mask, addr;
  103. u8 val;
  104. buck = dev->driver_data;
  105. if (buck < 1 || buck > S2MPS11_BUCK_NUM) {
  106. pr_err("Wrong buck number: %d\n", buck);
  107. return -EINVAL;
  108. }
  109. if (op == PMIC_OP_GET)
  110. *uV = 0;
  111. addr = s2mps11_buck_out[buck];
  112. switch (buck) {
  113. case 9:
  114. mask = S2MPS11_BUCK9_VOLT_MASK;
  115. break;
  116. default:
  117. mask = S2MPS11_BUCK_VOLT_MASK;
  118. break;
  119. }
  120. ret = pmic_read(dev->parent, addr, &val, 1);
  121. if (ret)
  122. return ret;
  123. if (op == PMIC_OP_GET) {
  124. val &= mask;
  125. ret = s2mps11_buck_hex2volt(buck, val);
  126. if (ret < 0)
  127. return ret;
  128. *uV = ret;
  129. return 0;
  130. }
  131. hex = s2mps11_buck_volt2hex(buck, *uV);
  132. if (hex < 0)
  133. return hex;
  134. val &= ~mask;
  135. val |= hex;
  136. ret = pmic_write(dev->parent, addr, &val, 1);
  137. return ret;
  138. }
  139. static int s2mps11_buck_mode(struct udevice *dev, int op, int *opmode)
  140. {
  141. unsigned int addr, mode;
  142. unsigned char val;
  143. int buck, ret;
  144. buck = dev->driver_data;
  145. if (buck < 1 || buck > S2MPS11_BUCK_NUM) {
  146. pr_err("Wrong buck number: %d\n", buck);
  147. return -EINVAL;
  148. }
  149. addr = s2mps11_buck_ctrl[buck];
  150. ret = pmic_read(dev->parent, addr, &val, 1);
  151. if (ret)
  152. return ret;
  153. if (op == PMIC_OP_GET) {
  154. val &= (S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT);
  155. switch (val) {
  156. case S2MPS11_BUCK_MODE_OFF:
  157. *opmode = OP_OFF;
  158. break;
  159. case S2MPS11_BUCK_MODE_STANDBY:
  160. *opmode = OP_STANDBY;
  161. break;
  162. case S2MPS11_BUCK_MODE_ON:
  163. *opmode = OP_ON;
  164. break;
  165. default:
  166. return -EINVAL;
  167. }
  168. return 0;
  169. }
  170. switch (*opmode) {
  171. case OP_OFF:
  172. mode = S2MPS11_BUCK_MODE_OFF;
  173. break;
  174. case OP_STANDBY:
  175. mode = S2MPS11_BUCK_MODE_STANDBY;
  176. break;
  177. case OP_ON:
  178. mode = S2MPS11_BUCK_MODE_ON;
  179. break;
  180. default:
  181. pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck);
  182. return -EINVAL;
  183. }
  184. val &= ~(S2MPS11_BUCK_MODE_MASK << S2MPS11_BUCK_MODE_SHIFT);
  185. val |= mode;
  186. ret = pmic_write(dev->parent, addr, &val, 1);
  187. return ret;
  188. }
  189. static int s2mps11_buck_enable(struct udevice *dev, int op, bool *enable)
  190. {
  191. int ret, on_off;
  192. if (op == PMIC_OP_GET) {
  193. ret = s2mps11_buck_mode(dev, op, &on_off);
  194. if (ret)
  195. return ret;
  196. switch (on_off) {
  197. case OP_OFF:
  198. *enable = false;
  199. break;
  200. case OP_ON:
  201. *enable = true;
  202. break;
  203. default:
  204. return -EINVAL;
  205. }
  206. } else if (op == PMIC_OP_SET) {
  207. if (*enable)
  208. on_off = OP_ON;
  209. else
  210. on_off = OP_OFF;
  211. ret = s2mps11_buck_mode(dev, op, &on_off);
  212. if (ret)
  213. return ret;
  214. }
  215. return 0;
  216. }
  217. static int buck_get_value(struct udevice *dev)
  218. {
  219. int uV;
  220. int ret;
  221. ret = s2mps11_buck_val(dev, PMIC_OP_GET, &uV);
  222. if (ret)
  223. return ret;
  224. return uV;
  225. }
  226. static int buck_set_value(struct udevice *dev, int uV)
  227. {
  228. return s2mps11_buck_val(dev, PMIC_OP_SET, &uV);
  229. }
  230. static int buck_get_enable(struct udevice *dev)
  231. {
  232. bool enable = false;
  233. int ret;
  234. ret = s2mps11_buck_enable(dev, PMIC_OP_GET, &enable);
  235. if (ret)
  236. return ret;
  237. return enable;
  238. }
  239. static int buck_set_enable(struct udevice *dev, bool enable)
  240. {
  241. return s2mps11_buck_enable(dev, PMIC_OP_SET, &enable);
  242. }
  243. static int buck_get_mode(struct udevice *dev)
  244. {
  245. int mode;
  246. int ret;
  247. ret = s2mps11_buck_mode(dev, PMIC_OP_GET, &mode);
  248. if (ret)
  249. return ret;
  250. return mode;
  251. }
  252. static int buck_set_mode(struct udevice *dev, int mode)
  253. {
  254. return s2mps11_buck_mode(dev, PMIC_OP_SET, &mode);
  255. }
  256. static int s2mps11_buck_probe(struct udevice *dev)
  257. {
  258. struct dm_regulator_uclass_plat *uc_pdata;
  259. uc_pdata = dev_get_uclass_plat(dev);
  260. uc_pdata->type = REGULATOR_TYPE_BUCK;
  261. uc_pdata->mode = s2mps11_buck_modes;
  262. uc_pdata->mode_count = ARRAY_SIZE(s2mps11_buck_modes);
  263. return 0;
  264. }
  265. static const struct dm_regulator_ops s2mps11_buck_ops = {
  266. .get_value = buck_get_value,
  267. .set_value = buck_set_value,
  268. .get_enable = buck_get_enable,
  269. .set_enable = buck_set_enable,
  270. .get_mode = buck_get_mode,
  271. .set_mode = buck_set_mode,
  272. };
  273. U_BOOT_DRIVER(s2mps11_buck) = {
  274. .name = S2MPS11_BUCK_DRIVER,
  275. .id = UCLASS_REGULATOR,
  276. .ops = &s2mps11_buck_ops,
  277. .probe = s2mps11_buck_probe,
  278. };
  279. static int s2mps11_ldo_hex2volt(int ldo, int hex)
  280. {
  281. unsigned int uV = 0;
  282. if (hex > S2MPS11_LDO_VOLT_MAX_HEX) {
  283. pr_err("Value: %#x is wrong for LDO%d", hex, ldo);
  284. return -EINVAL;
  285. }
  286. switch (ldo) {
  287. case 1:
  288. case 6:
  289. case 11:
  290. case 22:
  291. case 23:
  292. case 27:
  293. case 35:
  294. uV = hex * S2MPS11_LDO_STEP + S2MPS11_LDO_UV_MIN;
  295. break;
  296. default:
  297. uV = hex * S2MPS11_LDO_STEP * 2 + S2MPS11_LDO_UV_MIN;
  298. break;
  299. }
  300. return uV;
  301. }
  302. static int s2mps11_ldo_volt2hex(int ldo, int uV)
  303. {
  304. int hex = 0;
  305. switch (ldo) {
  306. case 1:
  307. case 6:
  308. case 11:
  309. case 22:
  310. case 23:
  311. case 27:
  312. case 35:
  313. hex = (uV - S2MPS11_LDO_UV_MIN) / S2MPS11_LDO_STEP;
  314. break;
  315. default:
  316. hex = (uV - S2MPS11_LDO_UV_MIN) / (S2MPS11_LDO_STEP * 2);
  317. break;
  318. }
  319. if (hex >= 0 && hex <= S2MPS11_LDO_VOLT_MAX_HEX)
  320. return hex;
  321. pr_err("Value: %d uV is wrong for LDO%d", uV, ldo);
  322. return -EINVAL;
  323. return 0;
  324. }
  325. static int s2mps11_ldo_val(struct udevice *dev, int op, int *uV)
  326. {
  327. unsigned int addr;
  328. unsigned char val;
  329. int hex, ldo, ret;
  330. ldo = dev->driver_data;
  331. if (ldo < 1 || ldo > S2MPS11_LDO_NUM) {
  332. pr_err("Wrong ldo number: %d\n", ldo);
  333. return -EINVAL;
  334. }
  335. addr = S2MPS11_REG_L1CTRL + ldo - 1;
  336. ret = pmic_read(dev->parent, addr, &val, 1);
  337. if (ret)
  338. return ret;
  339. if (op == PMIC_OP_GET) {
  340. *uV = 0;
  341. val &= S2MPS11_LDO_VOLT_MASK;
  342. ret = s2mps11_ldo_hex2volt(ldo, val);
  343. if (ret < 0)
  344. return ret;
  345. *uV = ret;
  346. return 0;
  347. }
  348. hex = s2mps11_ldo_volt2hex(ldo, *uV);
  349. if (hex < 0)
  350. return hex;
  351. val &= ~S2MPS11_LDO_VOLT_MASK;
  352. val |= hex;
  353. ret = pmic_write(dev->parent, addr, &val, 1);
  354. return ret;
  355. }
  356. static int s2mps11_ldo_mode(struct udevice *dev, int op, int *opmode)
  357. {
  358. unsigned int addr, mode;
  359. unsigned char val;
  360. int ldo, ret;
  361. ldo = dev->driver_data;
  362. if (ldo < 1 || ldo > S2MPS11_LDO_NUM) {
  363. pr_err("Wrong ldo number: %d\n", ldo);
  364. return -EINVAL;
  365. }
  366. addr = S2MPS11_REG_L1CTRL + ldo - 1;
  367. ret = pmic_read(dev->parent, addr, &val, 1);
  368. if (ret)
  369. return ret;
  370. if (op == PMIC_OP_GET) {
  371. val &= (S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT);
  372. switch (val) {
  373. case S2MPS11_LDO_MODE_OFF:
  374. *opmode = OP_OFF;
  375. break;
  376. case S2MPS11_LDO_MODE_STANDBY:
  377. *opmode = OP_STANDBY;
  378. break;
  379. case S2MPS11_LDO_MODE_STANDBY_LPM:
  380. *opmode = OP_STANDBY_LPM;
  381. break;
  382. case S2MPS11_LDO_MODE_ON:
  383. *opmode = OP_ON;
  384. break;
  385. default:
  386. return -EINVAL;
  387. }
  388. return 0;
  389. }
  390. switch (*opmode) {
  391. case OP_OFF:
  392. mode = S2MPS11_LDO_MODE_OFF;
  393. break;
  394. case OP_STANDBY:
  395. mode = S2MPS11_LDO_MODE_STANDBY;
  396. break;
  397. case OP_STANDBY_LPM:
  398. mode = S2MPS11_LDO_MODE_STANDBY_LPM;
  399. break;
  400. case OP_ON:
  401. mode = S2MPS11_LDO_MODE_ON;
  402. break;
  403. default:
  404. pr_err("Wrong mode: %d for ldo: %d\n", *opmode, ldo);
  405. return -EINVAL;
  406. }
  407. val &= ~(S2MPS11_LDO_MODE_MASK << S2MPS11_LDO_MODE_SHIFT);
  408. val |= mode;
  409. ret = pmic_write(dev->parent, addr, &val, 1);
  410. return ret;
  411. }
  412. static int s2mps11_ldo_enable(struct udevice *dev, int op, bool *enable)
  413. {
  414. int ret, on_off;
  415. if (op == PMIC_OP_GET) {
  416. ret = s2mps11_ldo_mode(dev, op, &on_off);
  417. if (ret)
  418. return ret;
  419. switch (on_off) {
  420. case OP_OFF:
  421. *enable = false;
  422. break;
  423. case OP_ON:
  424. *enable = true;
  425. break;
  426. default:
  427. return -EINVAL;
  428. }
  429. } else if (op == PMIC_OP_SET) {
  430. if (*enable)
  431. on_off = OP_ON;
  432. else
  433. on_off = OP_OFF;
  434. ret = s2mps11_ldo_mode(dev, op, &on_off);
  435. if (ret)
  436. return ret;
  437. }
  438. return 0;
  439. }
  440. static int ldo_get_value(struct udevice *dev)
  441. {
  442. int uV;
  443. int ret;
  444. ret = s2mps11_ldo_val(dev, PMIC_OP_GET, &uV);
  445. if (ret)
  446. return ret;
  447. return uV;
  448. }
  449. static int ldo_set_value(struct udevice *dev, int uV)
  450. {
  451. return s2mps11_ldo_val(dev, PMIC_OP_SET, &uV);
  452. }
  453. static int ldo_get_enable(struct udevice *dev)
  454. {
  455. bool enable = false;
  456. int ret;
  457. ret = s2mps11_ldo_enable(dev, PMIC_OP_GET, &enable);
  458. if (ret)
  459. return ret;
  460. return enable;
  461. }
  462. static int ldo_set_enable(struct udevice *dev, bool enable)
  463. {
  464. int ret;
  465. ret = s2mps11_ldo_enable(dev, PMIC_OP_SET, &enable);
  466. if (ret)
  467. return ret;
  468. /* Wait the "enable delay" for voltage to start to rise */
  469. udelay(15);
  470. return 0;
  471. }
  472. static int ldo_get_mode(struct udevice *dev)
  473. {
  474. int mode, ret;
  475. ret = s2mps11_ldo_mode(dev, PMIC_OP_GET, &mode);
  476. if (ret)
  477. return ret;
  478. return mode;
  479. }
  480. static int ldo_set_mode(struct udevice *dev, int mode)
  481. {
  482. return s2mps11_ldo_mode(dev, PMIC_OP_SET, &mode);
  483. }
  484. static int s2mps11_ldo_probe(struct udevice *dev)
  485. {
  486. struct dm_regulator_uclass_plat *uc_pdata;
  487. uc_pdata = dev_get_uclass_plat(dev);
  488. uc_pdata->type = REGULATOR_TYPE_LDO;
  489. uc_pdata->mode = s2mps11_ldo_modes;
  490. uc_pdata->mode_count = ARRAY_SIZE(s2mps11_ldo_modes);
  491. return 0;
  492. }
  493. static const struct dm_regulator_ops s2mps11_ldo_ops = {
  494. .get_value = ldo_get_value,
  495. .set_value = ldo_set_value,
  496. .get_enable = ldo_get_enable,
  497. .set_enable = ldo_set_enable,
  498. .get_mode = ldo_get_mode,
  499. .set_mode = ldo_set_mode,
  500. };
  501. U_BOOT_DRIVER(s2mps11_ldo) = {
  502. .name = S2MPS11_LDO_DRIVER,
  503. .id = UCLASS_REGULATOR,
  504. .ops = &s2mps11_ldo_ops,
  505. .probe = s2mps11_ldo_probe,
  506. };