max77686.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816
  1. // SPDX-License-Identifier: GPL-2.0+
  2. /*
  3. * Copyright (C) 2012-2015 Samsung Electronics
  4. *
  5. * Rajeshwari Shinde <rajeshwari.s@samsung.com>
  6. * Przemyslaw Marczak <p.marczak@samsung.com>
  7. */
  8. #include <common.h>
  9. #include <fdtdec.h>
  10. #include <errno.h>
  11. #include <dm.h>
  12. #include <i2c.h>
  13. #include <power/pmic.h>
  14. #include <power/regulator.h>
  15. #include <power/max77686_pmic.h>
  16. #define MODE(_id, _val, _name) { \
  17. .id = _id, \
  18. .register_value = _val, \
  19. .name = _name, \
  20. }
  21. /* LDO: 1,3,4,5,9,17,18,19,20,21,22,23,24,26,26,27 */
  22. static struct dm_regulator_mode max77686_ldo_mode_standby1[] = {
  23. MODE(OPMODE_OFF, MAX77686_LDO_MODE_OFF, "OFF"),
  24. MODE(OPMODE_LPM, MAX77686_LDO_MODE_LPM, "LPM"),
  25. MODE(OPMODE_STANDBY_LPM, MAX77686_LDO_MODE_STANDBY_LPM, "ON/LPM"),
  26. MODE(OPMODE_ON, MAX77686_LDO_MODE_ON, "ON"),
  27. };
  28. /* LDO: 2,6,7,8,10,11,12,14,15,16 */
  29. static struct dm_regulator_mode max77686_ldo_mode_standby2[] = {
  30. MODE(OPMODE_OFF, MAX77686_LDO_MODE_OFF, "OFF"),
  31. MODE(OPMODE_STANDBY, MAX77686_LDO_MODE_STANDBY, "ON/OFF"),
  32. MODE(OPMODE_STANDBY_LPM, MAX77686_LDO_MODE_STANDBY_LPM, "ON/LPM"),
  33. MODE(OPMODE_ON, MAX77686_LDO_MODE_ON, "ON"),
  34. };
  35. /* Buck: 1 */
  36. static struct dm_regulator_mode max77686_buck_mode_standby[] = {
  37. MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
  38. MODE(OPMODE_STANDBY, MAX77686_BUCK_MODE_STANDBY, "ON/OFF"),
  39. MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
  40. };
  41. /* Buck: 2,3,4 */
  42. static struct dm_regulator_mode max77686_buck_mode_lpm[] = {
  43. MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
  44. MODE(OPMODE_STANDBY, MAX77686_BUCK_MODE_STANDBY, "ON/OFF"),
  45. MODE(OPMODE_LPM, MAX77686_BUCK_MODE_LPM, "LPM"),
  46. MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
  47. };
  48. /* Buck: 5,6,7,8,9 */
  49. static struct dm_regulator_mode max77686_buck_mode_onoff[] = {
  50. MODE(OPMODE_OFF, MAX77686_BUCK_MODE_OFF, "OFF"),
  51. MODE(OPMODE_ON, MAX77686_BUCK_MODE_ON, "ON"),
  52. };
  53. static const char max77686_buck_ctrl[] = {
  54. 0xff, 0x10, 0x12, 0x1c, 0x26, 0x30, 0x32, 0x34, 0x36, 0x38
  55. };
  56. static const char max77686_buck_out[] = {
  57. 0xff, 0x11, 0x14, 0x1e, 0x28, 0x31, 0x33, 0x35, 0x37, 0x39
  58. };
  59. static int max77686_buck_volt2hex(int buck, int uV)
  60. {
  61. int hex = 0;
  62. int hex_max = 0;
  63. switch (buck) {
  64. case 2:
  65. case 3:
  66. case 4:
  67. /* hex = (uV - 600000) / 12500; */
  68. hex = (uV - MAX77686_BUCK_UV_LMIN) / MAX77686_BUCK_UV_LSTEP;
  69. hex_max = MAX77686_BUCK234_VOLT_MAX_HEX;
  70. break;
  71. default:
  72. /*
  73. * hex = (uV - 750000) / 50000. We assume that dynamic voltage
  74. * scaling via GPIOs is not enabled and don't support that.
  75. * If this is enabled then the driver will need to take that
  76. * into account and check different registers depending on
  77. * the current setting. See the datasheet for details.
  78. */
  79. hex = (uV - MAX77686_BUCK_UV_HMIN) / MAX77686_BUCK_UV_HSTEP;
  80. hex_max = MAX77686_BUCK_VOLT_MAX_HEX;
  81. break;
  82. }
  83. if (hex >= 0 && hex <= hex_max)
  84. return hex;
  85. pr_err("Value: %d uV is wrong for BUCK%d", uV, buck);
  86. return -EINVAL;
  87. }
  88. static int max77686_buck_hex2volt(int buck, int hex)
  89. {
  90. unsigned uV = 0;
  91. int hex_max = 0;
  92. if (hex < 0)
  93. goto bad_hex;
  94. switch (buck) {
  95. case 2:
  96. case 3:
  97. case 4:
  98. hex_max = MAX77686_BUCK234_VOLT_MAX_HEX;
  99. if (hex > hex_max)
  100. goto bad_hex;
  101. /* uV = hex * 12500 + 600000; */
  102. uV = hex * MAX77686_BUCK_UV_LSTEP + MAX77686_BUCK_UV_LMIN;
  103. break;
  104. default:
  105. hex_max = MAX77686_BUCK_VOLT_MAX_HEX;
  106. if (hex > hex_max)
  107. goto bad_hex;
  108. /* uV = hex * 50000 + 750000; */
  109. uV = hex * MAX77686_BUCK_UV_HSTEP + MAX77686_BUCK_UV_HMIN;
  110. break;
  111. }
  112. return uV;
  113. bad_hex:
  114. pr_err("Value: %#x is wrong for BUCK%d", hex, buck);
  115. return -EINVAL;
  116. }
  117. static int max77686_ldo_volt2hex(int ldo, int uV)
  118. {
  119. int hex = 0;
  120. switch (ldo) {
  121. case 1:
  122. case 2:
  123. case 6:
  124. case 7:
  125. case 8:
  126. case 15:
  127. hex = (uV - MAX77686_LDO_UV_MIN) / MAX77686_LDO_UV_LSTEP;
  128. /* hex = (uV - 800000) / 25000; */
  129. break;
  130. default:
  131. hex = (uV - MAX77686_LDO_UV_MIN) / MAX77686_LDO_UV_HSTEP;
  132. /* hex = (uV - 800000) / 50000; */
  133. }
  134. if (hex >= 0 && hex <= MAX77686_LDO_VOLT_MAX_HEX)
  135. return hex;
  136. pr_err("Value: %d uV is wrong for LDO%d", uV, ldo);
  137. return -EINVAL;
  138. }
  139. static int max77686_ldo_hex2volt(int ldo, int hex)
  140. {
  141. unsigned int uV = 0;
  142. if (hex > MAX77686_LDO_VOLT_MAX_HEX)
  143. goto bad_hex;
  144. switch (ldo) {
  145. case 1:
  146. case 2:
  147. case 6:
  148. case 7:
  149. case 8:
  150. case 15:
  151. /* uV = hex * 25000 + 800000; */
  152. uV = hex * MAX77686_LDO_UV_LSTEP + MAX77686_LDO_UV_MIN;
  153. break;
  154. default:
  155. /* uV = hex * 50000 + 800000; */
  156. uV = hex * MAX77686_LDO_UV_HSTEP + MAX77686_LDO_UV_MIN;
  157. }
  158. return uV;
  159. bad_hex:
  160. pr_err("Value: %#x is wrong for ldo%d", hex, ldo);
  161. return -EINVAL;
  162. }
  163. static int max77686_ldo_hex2mode(int ldo, int hex)
  164. {
  165. if (hex > MAX77686_LDO_MODE_MASK)
  166. return -EINVAL;
  167. switch (hex) {
  168. case MAX77686_LDO_MODE_OFF:
  169. return OPMODE_OFF;
  170. case MAX77686_LDO_MODE_LPM: /* == MAX77686_LDO_MODE_STANDBY: */
  171. /* The same mode values but different meaning for each ldo */
  172. switch (ldo) {
  173. case 2:
  174. case 6:
  175. case 7:
  176. case 8:
  177. case 10:
  178. case 11:
  179. case 12:
  180. case 14:
  181. case 15:
  182. case 16:
  183. return OPMODE_STANDBY;
  184. default:
  185. return OPMODE_LPM;
  186. }
  187. case MAX77686_LDO_MODE_STANDBY_LPM:
  188. return OPMODE_STANDBY_LPM;
  189. case MAX77686_LDO_MODE_ON:
  190. return OPMODE_ON;
  191. default:
  192. return -EINVAL;
  193. }
  194. }
  195. static int max77686_buck_hex2mode(int buck, int hex)
  196. {
  197. if (hex > MAX77686_BUCK_MODE_MASK)
  198. return -EINVAL;
  199. switch (hex) {
  200. case MAX77686_BUCK_MODE_OFF:
  201. return OPMODE_OFF;
  202. case MAX77686_BUCK_MODE_ON:
  203. return OPMODE_ON;
  204. case MAX77686_BUCK_MODE_STANDBY:
  205. switch (buck) {
  206. case 1:
  207. case 2:
  208. case 3:
  209. case 4:
  210. return OPMODE_STANDBY;
  211. default:
  212. return -EINVAL;
  213. }
  214. case MAX77686_BUCK_MODE_LPM:
  215. switch (buck) {
  216. case 2:
  217. case 3:
  218. case 4:
  219. return OPMODE_LPM;
  220. default:
  221. return -EINVAL;
  222. }
  223. default:
  224. return -EINVAL;
  225. }
  226. }
  227. static int max77686_buck_modes(int buck, struct dm_regulator_mode **modesp)
  228. {
  229. int ret = -EINVAL;
  230. if (buck < 1 || buck > MAX77686_BUCK_NUM)
  231. return ret;
  232. switch (buck) {
  233. case 1:
  234. *modesp = max77686_buck_mode_standby;
  235. ret = ARRAY_SIZE(max77686_buck_mode_standby);
  236. break;
  237. case 2:
  238. case 3:
  239. case 4:
  240. *modesp = max77686_buck_mode_lpm;
  241. ret = ARRAY_SIZE(max77686_buck_mode_lpm);
  242. break;
  243. default:
  244. *modesp = max77686_buck_mode_onoff;
  245. ret = ARRAY_SIZE(max77686_buck_mode_onoff);
  246. }
  247. return ret;
  248. }
  249. static int max77686_ldo_modes(int ldo, struct dm_regulator_mode **modesp,
  250. struct udevice *dev)
  251. {
  252. int ret = -EINVAL;
  253. if (ldo < 1 || ldo > MAX77686_LDO_NUM)
  254. return ret;
  255. switch (ldo) {
  256. case 2:
  257. case 6:
  258. case 7:
  259. case 8:
  260. case 10:
  261. case 11:
  262. case 12:
  263. case 14:
  264. case 15:
  265. case 16:
  266. *modesp = max77686_ldo_mode_standby2;
  267. ret = ARRAY_SIZE(max77686_ldo_mode_standby2);
  268. break;
  269. default:
  270. *modesp = max77686_ldo_mode_standby1;
  271. ret = ARRAY_SIZE(max77686_ldo_mode_standby1);
  272. }
  273. return ret;
  274. }
  275. static int max77686_ldo_val(struct udevice *dev, int op, int *uV)
  276. {
  277. unsigned int adr;
  278. unsigned char val;
  279. int hex, ldo, ret;
  280. if (op == PMIC_OP_GET)
  281. *uV = 0;
  282. ldo = dev->driver_data;
  283. if (ldo < 1 || ldo > MAX77686_LDO_NUM) {
  284. pr_err("Wrong ldo number: %d", ldo);
  285. return -EINVAL;
  286. }
  287. adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
  288. ret = pmic_read(dev->parent, adr, &val, 1);
  289. if (ret)
  290. return ret;
  291. if (op == PMIC_OP_GET) {
  292. val &= MAX77686_LDO_VOLT_MASK;
  293. ret = max77686_ldo_hex2volt(ldo, val);
  294. if (ret < 0)
  295. return ret;
  296. *uV = ret;
  297. return 0;
  298. }
  299. hex = max77686_ldo_volt2hex(ldo, *uV);
  300. if (hex < 0)
  301. return hex;
  302. val &= ~MAX77686_LDO_VOLT_MASK;
  303. val |= hex;
  304. ret = pmic_write(dev->parent, adr, &val, 1);
  305. return ret;
  306. }
  307. static int max77686_buck_val(struct udevice *dev, int op, int *uV)
  308. {
  309. unsigned int mask, adr;
  310. unsigned char val;
  311. int hex, buck, ret;
  312. buck = dev->driver_data;
  313. if (buck < 1 || buck > MAX77686_BUCK_NUM) {
  314. pr_err("Wrong buck number: %d", buck);
  315. return -EINVAL;
  316. }
  317. if (op == PMIC_OP_GET)
  318. *uV = 0;
  319. /* &buck_out = ctrl + 1 */
  320. adr = max77686_buck_out[buck];
  321. /* mask */
  322. switch (buck) {
  323. case 2:
  324. case 3:
  325. case 4:
  326. mask = MAX77686_BUCK234_VOLT_MASK;
  327. break;
  328. default:
  329. mask = MAX77686_BUCK_VOLT_MASK;
  330. break;
  331. }
  332. ret = pmic_read(dev->parent, adr, &val, 1);
  333. if (ret)
  334. return ret;
  335. if (op == PMIC_OP_GET) {
  336. val &= mask;
  337. ret = max77686_buck_hex2volt(buck, val);
  338. if (ret < 0)
  339. return ret;
  340. *uV = ret;
  341. return 0;
  342. }
  343. hex = max77686_buck_volt2hex(buck, *uV);
  344. if (hex < 0)
  345. return hex;
  346. val &= ~mask;
  347. val |= hex;
  348. ret = pmic_write(dev->parent, adr, &val, 1);
  349. return ret;
  350. }
  351. static int max77686_ldo_mode(struct udevice *dev, int op, int *opmode)
  352. {
  353. unsigned int adr, mode;
  354. unsigned char val;
  355. int ldo, ret;
  356. if (op == PMIC_OP_GET)
  357. *opmode = -EINVAL;
  358. ldo = dev->driver_data;
  359. if (ldo < 1 || ldo > MAX77686_LDO_NUM) {
  360. pr_err("Wrong ldo number: %d", ldo);
  361. return -EINVAL;
  362. }
  363. adr = MAX77686_REG_PMIC_LDO1CTRL1 + ldo - 1;
  364. ret = pmic_read(dev->parent, adr, &val, 1);
  365. if (ret)
  366. return ret;
  367. if (op == PMIC_OP_GET) {
  368. val &= MAX77686_LDO_MODE_MASK;
  369. ret = max77686_ldo_hex2mode(ldo, val);
  370. if (ret < 0)
  371. return ret;
  372. *opmode = ret;
  373. return 0;
  374. }
  375. /* mode */
  376. switch (*opmode) {
  377. case OPMODE_OFF:
  378. mode = MAX77686_LDO_MODE_OFF;
  379. break;
  380. case OPMODE_LPM:
  381. switch (ldo) {
  382. case 2:
  383. case 6:
  384. case 7:
  385. case 8:
  386. case 10:
  387. case 11:
  388. case 12:
  389. case 14:
  390. case 15:
  391. case 16:
  392. return -EINVAL;
  393. default:
  394. mode = MAX77686_LDO_MODE_LPM;
  395. }
  396. break;
  397. case OPMODE_STANDBY:
  398. switch (ldo) {
  399. case 2:
  400. case 6:
  401. case 7:
  402. case 8:
  403. case 10:
  404. case 11:
  405. case 12:
  406. case 14:
  407. case 15:
  408. case 16:
  409. mode = MAX77686_LDO_MODE_STANDBY;
  410. break;
  411. default:
  412. return -EINVAL;
  413. }
  414. break;
  415. case OPMODE_STANDBY_LPM:
  416. mode = MAX77686_LDO_MODE_STANDBY_LPM;
  417. break;
  418. case OPMODE_ON:
  419. mode = MAX77686_LDO_MODE_ON;
  420. break;
  421. default:
  422. mode = 0xff;
  423. }
  424. if (mode == 0xff) {
  425. pr_err("Wrong mode: %d for ldo%d", *opmode, ldo);
  426. return -EINVAL;
  427. }
  428. val &= ~MAX77686_LDO_MODE_MASK;
  429. val |= mode;
  430. ret = pmic_write(dev->parent, adr, &val, 1);
  431. return ret;
  432. }
  433. static int max77686_ldo_enable(struct udevice *dev, int op, bool *enable)
  434. {
  435. int ret, on_off;
  436. if (op == PMIC_OP_GET) {
  437. ret = max77686_ldo_mode(dev, op, &on_off);
  438. if (ret)
  439. return ret;
  440. switch (on_off) {
  441. case OPMODE_OFF:
  442. *enable = false;
  443. break;
  444. case OPMODE_ON:
  445. *enable = true;
  446. break;
  447. default:
  448. return -EINVAL;
  449. }
  450. } else if (op == PMIC_OP_SET) {
  451. if (*enable)
  452. on_off = OPMODE_ON;
  453. else
  454. on_off = OPMODE_OFF;
  455. ret = max77686_ldo_mode(dev, op, &on_off);
  456. if (ret)
  457. return ret;
  458. }
  459. return 0;
  460. }
  461. static int max77686_buck_mode(struct udevice *dev, int op, int *opmode)
  462. {
  463. unsigned int mask, adr, mode, mode_shift;
  464. unsigned char val;
  465. int buck, ret;
  466. buck = dev->driver_data;
  467. if (buck < 1 || buck > MAX77686_BUCK_NUM) {
  468. pr_err("Wrong buck number: %d", buck);
  469. return -EINVAL;
  470. }
  471. adr = max77686_buck_ctrl[buck];
  472. /* mask */
  473. switch (buck) {
  474. case 2:
  475. case 3:
  476. case 4:
  477. mode_shift = MAX77686_BUCK_MODE_SHIFT_2;
  478. break;
  479. default:
  480. mode_shift = MAX77686_BUCK_MODE_SHIFT_1;
  481. }
  482. mask = MAX77686_BUCK_MODE_MASK << mode_shift;
  483. ret = pmic_read(dev->parent, adr, &val, 1);
  484. if (ret)
  485. return ret;
  486. if (op == PMIC_OP_GET) {
  487. val &= mask;
  488. val >>= mode_shift;
  489. ret = max77686_buck_hex2mode(buck, val);
  490. if (ret < 0)
  491. return ret;
  492. *opmode = ret;
  493. return 0;
  494. }
  495. /* mode */
  496. switch (*opmode) {
  497. case OPMODE_OFF:
  498. mode = MAX77686_BUCK_MODE_OFF;
  499. break;
  500. case OPMODE_STANDBY:
  501. switch (buck) {
  502. case 1:
  503. case 2:
  504. case 3:
  505. case 4:
  506. mode = MAX77686_BUCK_MODE_STANDBY << mode_shift;
  507. break;
  508. default:
  509. mode = 0xff;
  510. }
  511. break;
  512. case OPMODE_LPM:
  513. switch (buck) {
  514. case 2:
  515. case 3:
  516. case 4:
  517. mode = MAX77686_BUCK_MODE_LPM << mode_shift;
  518. break;
  519. default:
  520. mode = 0xff;
  521. }
  522. break;
  523. case OPMODE_ON:
  524. mode = MAX77686_BUCK_MODE_ON << mode_shift;
  525. break;
  526. default:
  527. mode = 0xff;
  528. }
  529. if (mode == 0xff) {
  530. pr_err("Wrong mode: %d for buck: %d\n", *opmode, buck);
  531. return -EINVAL;
  532. }
  533. val &= ~mask;
  534. val |= mode;
  535. ret = pmic_write(dev->parent, adr, &val, 1);
  536. return ret;
  537. }
  538. static int max77686_buck_enable(struct udevice *dev, int op, bool *enable)
  539. {
  540. int ret, on_off;
  541. if (op == PMIC_OP_GET) {
  542. ret = max77686_buck_mode(dev, op, &on_off);
  543. if (ret)
  544. return ret;
  545. switch (on_off) {
  546. case OPMODE_OFF:
  547. *enable = false;
  548. break;
  549. case OPMODE_ON:
  550. *enable = true;
  551. break;
  552. default:
  553. return -EINVAL;
  554. }
  555. } else if (op == PMIC_OP_SET) {
  556. if (*enable)
  557. on_off = OPMODE_ON;
  558. else
  559. on_off = OPMODE_OFF;
  560. ret = max77686_buck_mode(dev, op, &on_off);
  561. if (ret)
  562. return ret;
  563. }
  564. return 0;
  565. }
  566. static int max77686_ldo_probe(struct udevice *dev)
  567. {
  568. struct dm_regulator_uclass_plat *uc_pdata;
  569. uc_pdata = dev_get_uclass_plat(dev);
  570. uc_pdata->type = REGULATOR_TYPE_LDO;
  571. uc_pdata->mode_count = max77686_ldo_modes(dev->driver_data,
  572. &uc_pdata->mode, dev);
  573. return 0;
  574. }
  575. static int ldo_get_value(struct udevice *dev)
  576. {
  577. int uV;
  578. int ret;
  579. ret = max77686_ldo_val(dev, PMIC_OP_GET, &uV);
  580. if (ret)
  581. return ret;
  582. return uV;
  583. }
  584. static int ldo_set_value(struct udevice *dev, int uV)
  585. {
  586. return max77686_ldo_val(dev, PMIC_OP_SET, &uV);
  587. }
  588. static int ldo_get_enable(struct udevice *dev)
  589. {
  590. bool enable = false;
  591. int ret;
  592. ret = max77686_ldo_enable(dev, PMIC_OP_GET, &enable);
  593. if (ret)
  594. return ret;
  595. return enable;
  596. }
  597. static int ldo_set_enable(struct udevice *dev, bool enable)
  598. {
  599. return max77686_ldo_enable(dev, PMIC_OP_SET, &enable);
  600. }
  601. static int ldo_get_mode(struct udevice *dev)
  602. {
  603. int mode;
  604. int ret;
  605. ret = max77686_ldo_mode(dev, PMIC_OP_GET, &mode);
  606. if (ret)
  607. return ret;
  608. return mode;
  609. }
  610. static int ldo_set_mode(struct udevice *dev, int mode)
  611. {
  612. return max77686_ldo_mode(dev, PMIC_OP_SET, &mode);
  613. }
  614. static int max77686_buck_probe(struct udevice *dev)
  615. {
  616. struct dm_regulator_uclass_plat *uc_pdata;
  617. uc_pdata = dev_get_uclass_plat(dev);
  618. uc_pdata->type = REGULATOR_TYPE_BUCK;
  619. uc_pdata->mode_count = max77686_buck_modes(dev->driver_data,
  620. &uc_pdata->mode);
  621. return 0;
  622. }
  623. static int buck_get_value(struct udevice *dev)
  624. {
  625. int uV;
  626. int ret;
  627. ret = max77686_buck_val(dev, PMIC_OP_GET, &uV);
  628. if (ret)
  629. return ret;
  630. return uV;
  631. }
  632. static int buck_set_value(struct udevice *dev, int uV)
  633. {
  634. return max77686_buck_val(dev, PMIC_OP_SET, &uV);
  635. }
  636. static int buck_get_enable(struct udevice *dev)
  637. {
  638. bool enable = false;
  639. int ret;
  640. ret = max77686_buck_enable(dev, PMIC_OP_GET, &enable);
  641. if (ret)
  642. return ret;
  643. return enable;
  644. }
  645. static int buck_set_enable(struct udevice *dev, bool enable)
  646. {
  647. return max77686_buck_enable(dev, PMIC_OP_SET, &enable);
  648. }
  649. static int buck_get_mode(struct udevice *dev)
  650. {
  651. int mode;
  652. int ret;
  653. ret = max77686_buck_mode(dev, PMIC_OP_GET, &mode);
  654. if (ret)
  655. return ret;
  656. return mode;
  657. }
  658. static int buck_set_mode(struct udevice *dev, int mode)
  659. {
  660. return max77686_buck_mode(dev, PMIC_OP_SET, &mode);
  661. }
  662. static const struct dm_regulator_ops max77686_ldo_ops = {
  663. .get_value = ldo_get_value,
  664. .set_value = ldo_set_value,
  665. .get_enable = ldo_get_enable,
  666. .set_enable = ldo_set_enable,
  667. .get_mode = ldo_get_mode,
  668. .set_mode = ldo_set_mode,
  669. };
  670. U_BOOT_DRIVER(max77686_ldo) = {
  671. .name = MAX77686_LDO_DRIVER,
  672. .id = UCLASS_REGULATOR,
  673. .ops = &max77686_ldo_ops,
  674. .probe = max77686_ldo_probe,
  675. };
  676. static const struct dm_regulator_ops max77686_buck_ops = {
  677. .get_value = buck_get_value,
  678. .set_value = buck_set_value,
  679. .get_enable = buck_get_enable,
  680. .set_enable = buck_set_enable,
  681. .get_mode = buck_get_mode,
  682. .set_mode = buck_set_mode,
  683. };
  684. U_BOOT_DRIVER(max77686_buck) = {
  685. .name = MAX77686_BUCK_DRIVER,
  686. .id = UCLASS_REGULATOR,
  687. .ops = &max77686_buck_ops,
  688. .probe = max77686_buck_probe,
  689. };