da9062-regulator.c 33 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056
  1. // SPDX-License-Identifier: GPL-2.0+
  2. //
  3. // Regulator device driver for DA9061 and DA9062.
  4. // Copyright (C) 2015-2017 Dialog Semiconductor
  5. #include <linux/kernel.h>
  6. #include <linux/module.h>
  7. #include <linux/init.h>
  8. #include <linux/err.h>
  9. #include <linux/slab.h>
  10. #include <linux/of.h>
  11. #include <linux/platform_device.h>
  12. #include <linux/regmap.h>
  13. #include <linux/regulator/driver.h>
  14. #include <linux/regulator/machine.h>
  15. #include <linux/regulator/of_regulator.h>
  16. #include <linux/mfd/da9062/core.h>
  17. #include <linux/mfd/da9062/registers.h>
  18. #include <dt-bindings/regulator/dlg,da9063-regulator.h>
  19. /* Regulator IDs */
  20. enum {
  21. DA9061_ID_BUCK1,
  22. DA9061_ID_BUCK2,
  23. DA9061_ID_BUCK3,
  24. DA9061_ID_LDO1,
  25. DA9061_ID_LDO2,
  26. DA9061_ID_LDO3,
  27. DA9061_ID_LDO4,
  28. DA9061_MAX_REGULATORS,
  29. };
  30. enum {
  31. DA9062_ID_BUCK1,
  32. DA9062_ID_BUCK2,
  33. DA9062_ID_BUCK3,
  34. DA9062_ID_BUCK4,
  35. DA9062_ID_LDO1,
  36. DA9062_ID_LDO2,
  37. DA9062_ID_LDO3,
  38. DA9062_ID_LDO4,
  39. DA9062_MAX_REGULATORS,
  40. };
  41. /* Regulator capabilities and registers description */
  42. struct da9062_regulator_info {
  43. struct regulator_desc desc;
  44. /* Main register fields */
  45. struct reg_field mode;
  46. struct reg_field suspend;
  47. struct reg_field sleep;
  48. struct reg_field suspend_sleep;
  49. unsigned int suspend_vsel_reg;
  50. /* Event detection bit */
  51. struct reg_field oc_event;
  52. };
  53. /* Single regulator settings */
  54. struct da9062_regulator {
  55. struct regulator_desc desc;
  56. struct regulator_dev *rdev;
  57. struct da9062 *hw;
  58. const struct da9062_regulator_info *info;
  59. struct regmap_field *mode;
  60. struct regmap_field *suspend;
  61. struct regmap_field *sleep;
  62. struct regmap_field *suspend_sleep;
  63. };
  64. /* Encapsulates all information for the regulators driver */
  65. struct da9062_regulators {
  66. int irq_ldo_lim;
  67. unsigned n_regulators;
  68. /* Array size to be defined during init. Keep at end. */
  69. struct da9062_regulator regulator[];
  70. };
  71. /* Regulator operations */
  72. /* Current limits array (in uA)
  73. * - DA9061_ID_[BUCK1|BUCK3]
  74. * - DA9062_ID_[BUCK1|BUCK2|BUCK4]
  75. * Entry indexes corresponds to register values.
  76. */
  77. static const unsigned int da9062_buck_a_limits[] = {
  78. 500000, 600000, 700000, 800000, 900000, 1000000, 1100000, 1200000,
  79. 1300000, 1400000, 1500000, 1600000, 1700000, 1800000, 1900000, 2000000
  80. };
  81. /* Current limits array (in uA)
  82. * - DA9061_ID_BUCK2
  83. * - DA9062_ID_BUCK3
  84. * Entry indexes corresponds to register values.
  85. */
  86. static const unsigned int da9062_buck_b_limits[] = {
  87. 1500000, 1600000, 1700000, 1800000, 1900000, 2000000, 2100000, 2200000,
  88. 2300000, 2400000, 2500000, 2600000, 2700000, 2800000, 2900000, 3000000
  89. };
  90. static unsigned int da9062_map_buck_mode(unsigned int mode)
  91. {
  92. switch (mode) {
  93. case DA9063_BUCK_MODE_SLEEP:
  94. return REGULATOR_MODE_STANDBY;
  95. case DA9063_BUCK_MODE_SYNC:
  96. return REGULATOR_MODE_FAST;
  97. case DA9063_BUCK_MODE_AUTO:
  98. return REGULATOR_MODE_NORMAL;
  99. default:
  100. return REGULATOR_MODE_INVALID;
  101. }
  102. }
  103. static int da9062_buck_set_mode(struct regulator_dev *rdev, unsigned mode)
  104. {
  105. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  106. unsigned val;
  107. switch (mode) {
  108. case REGULATOR_MODE_FAST:
  109. val = DA9063_BUCK_MODE_SYNC;
  110. break;
  111. case REGULATOR_MODE_NORMAL:
  112. val = DA9063_BUCK_MODE_AUTO;
  113. break;
  114. case REGULATOR_MODE_STANDBY:
  115. val = DA9063_BUCK_MODE_SLEEP;
  116. break;
  117. default:
  118. return -EINVAL;
  119. }
  120. return regmap_field_write(regl->mode, val);
  121. }
  122. /*
  123. * Bucks use single mode register field for normal operation
  124. * and suspend state.
  125. * There are 3 modes to map to: FAST, NORMAL, and STANDBY.
  126. */
  127. static unsigned da9062_buck_get_mode(struct regulator_dev *rdev)
  128. {
  129. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  130. unsigned int val;
  131. int ret;
  132. ret = regmap_field_read(regl->mode, &val);
  133. if (ret < 0)
  134. return ret;
  135. switch (val) {
  136. default:
  137. /* Sleep flag bit decides the mode */
  138. break;
  139. case DA9063_BUCK_MODE_SLEEP:
  140. return REGULATOR_MODE_STANDBY;
  141. case DA9063_BUCK_MODE_SYNC:
  142. return REGULATOR_MODE_FAST;
  143. case DA9063_BUCK_MODE_AUTO:
  144. return REGULATOR_MODE_NORMAL;
  145. }
  146. ret = regmap_field_read(regl->sleep, &val);
  147. if (ret < 0)
  148. return 0;
  149. if (val)
  150. return REGULATOR_MODE_STANDBY;
  151. else
  152. return REGULATOR_MODE_FAST;
  153. }
  154. /*
  155. * LDOs use sleep flags - one for normal and one for suspend state.
  156. * There are 2 modes to map to: NORMAL and STANDBY (sleep) for each state.
  157. */
  158. static int da9062_ldo_set_mode(struct regulator_dev *rdev, unsigned mode)
  159. {
  160. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  161. unsigned val;
  162. switch (mode) {
  163. case REGULATOR_MODE_NORMAL:
  164. val = 0;
  165. break;
  166. case REGULATOR_MODE_STANDBY:
  167. val = 1;
  168. break;
  169. default:
  170. return -EINVAL;
  171. }
  172. return regmap_field_write(regl->sleep, val);
  173. }
  174. static unsigned da9062_ldo_get_mode(struct regulator_dev *rdev)
  175. {
  176. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  177. int ret, val;
  178. ret = regmap_field_read(regl->sleep, &val);
  179. if (ret < 0)
  180. return 0;
  181. if (val)
  182. return REGULATOR_MODE_STANDBY;
  183. else
  184. return REGULATOR_MODE_NORMAL;
  185. }
  186. static int da9062_buck_get_status(struct regulator_dev *rdev)
  187. {
  188. int ret = regulator_is_enabled_regmap(rdev);
  189. if (ret == 0) {
  190. ret = REGULATOR_STATUS_OFF;
  191. } else if (ret > 0) {
  192. ret = da9062_buck_get_mode(rdev);
  193. if (ret > 0)
  194. ret = regulator_mode_to_status(ret);
  195. else if (ret == 0)
  196. ret = -EIO;
  197. }
  198. return ret;
  199. }
  200. static int da9062_ldo_get_status(struct regulator_dev *rdev)
  201. {
  202. int ret = regulator_is_enabled_regmap(rdev);
  203. if (ret == 0) {
  204. ret = REGULATOR_STATUS_OFF;
  205. } else if (ret > 0) {
  206. ret = da9062_ldo_get_mode(rdev);
  207. if (ret > 0)
  208. ret = regulator_mode_to_status(ret);
  209. else if (ret == 0)
  210. ret = -EIO;
  211. }
  212. return ret;
  213. }
  214. static int da9062_set_suspend_voltage(struct regulator_dev *rdev, int uv)
  215. {
  216. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  217. const struct da9062_regulator_info *rinfo = regl->info;
  218. int ret, sel;
  219. sel = regulator_map_voltage_linear(rdev, uv, uv);
  220. if (sel < 0)
  221. return sel;
  222. sel <<= ffs(rdev->desc->vsel_mask) - 1;
  223. ret = regmap_update_bits(regl->hw->regmap, rinfo->suspend_vsel_reg,
  224. rdev->desc->vsel_mask, sel);
  225. return ret;
  226. }
  227. static int da9062_suspend_enable(struct regulator_dev *rdev)
  228. {
  229. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  230. return regmap_field_write(regl->suspend, 1);
  231. }
  232. static int da9062_suspend_disable(struct regulator_dev *rdev)
  233. {
  234. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  235. return regmap_field_write(regl->suspend, 0);
  236. }
  237. static int da9062_buck_set_suspend_mode(struct regulator_dev *rdev,
  238. unsigned mode)
  239. {
  240. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  241. int val;
  242. switch (mode) {
  243. case REGULATOR_MODE_FAST:
  244. val = DA9063_BUCK_MODE_SYNC;
  245. break;
  246. case REGULATOR_MODE_NORMAL:
  247. val = DA9063_BUCK_MODE_AUTO;
  248. break;
  249. case REGULATOR_MODE_STANDBY:
  250. val = DA9063_BUCK_MODE_SLEEP;
  251. break;
  252. default:
  253. return -EINVAL;
  254. }
  255. return regmap_field_write(regl->mode, val);
  256. }
  257. static int da9062_ldo_set_suspend_mode(struct regulator_dev *rdev,
  258. unsigned mode)
  259. {
  260. struct da9062_regulator *regl = rdev_get_drvdata(rdev);
  261. unsigned val;
  262. switch (mode) {
  263. case REGULATOR_MODE_NORMAL:
  264. val = 0;
  265. break;
  266. case REGULATOR_MODE_STANDBY:
  267. val = 1;
  268. break;
  269. default:
  270. return -EINVAL;
  271. }
  272. return regmap_field_write(regl->suspend_sleep, val);
  273. }
  274. static const struct regulator_ops da9062_buck_ops = {
  275. .enable = regulator_enable_regmap,
  276. .disable = regulator_disable_regmap,
  277. .is_enabled = regulator_is_enabled_regmap,
  278. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  279. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  280. .list_voltage = regulator_list_voltage_linear,
  281. .set_current_limit = regulator_set_current_limit_regmap,
  282. .get_current_limit = regulator_get_current_limit_regmap,
  283. .set_mode = da9062_buck_set_mode,
  284. .get_mode = da9062_buck_get_mode,
  285. .get_status = da9062_buck_get_status,
  286. .set_suspend_voltage = da9062_set_suspend_voltage,
  287. .set_suspend_enable = da9062_suspend_enable,
  288. .set_suspend_disable = da9062_suspend_disable,
  289. .set_suspend_mode = da9062_buck_set_suspend_mode,
  290. };
  291. static const struct regulator_ops da9062_ldo_ops = {
  292. .enable = regulator_enable_regmap,
  293. .disable = regulator_disable_regmap,
  294. .is_enabled = regulator_is_enabled_regmap,
  295. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  296. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  297. .list_voltage = regulator_list_voltage_linear,
  298. .set_mode = da9062_ldo_set_mode,
  299. .get_mode = da9062_ldo_get_mode,
  300. .get_status = da9062_ldo_get_status,
  301. .set_suspend_voltage = da9062_set_suspend_voltage,
  302. .set_suspend_enable = da9062_suspend_enable,
  303. .set_suspend_disable = da9062_suspend_disable,
  304. .set_suspend_mode = da9062_ldo_set_suspend_mode,
  305. };
  306. /* DA9061 Regulator information */
  307. static const struct da9062_regulator_info local_da9061_regulator_info[] = {
  308. {
  309. .desc.id = DA9061_ID_BUCK1,
  310. .desc.name = "DA9061 BUCK1",
  311. .desc.of_match = of_match_ptr("buck1"),
  312. .desc.regulators_node = of_match_ptr("regulators"),
  313. .desc.ops = &da9062_buck_ops,
  314. .desc.min_uV = (300) * 1000,
  315. .desc.uV_step = (10) * 1000,
  316. .desc.n_voltages = ((1570) - (300))/(10) + 1,
  317. .desc.curr_table = da9062_buck_a_limits,
  318. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
  319. .desc.csel_reg = DA9062AA_BUCK_ILIM_C,
  320. .desc.csel_mask = DA9062AA_BUCK1_ILIM_MASK,
  321. .desc.enable_reg = DA9062AA_BUCK1_CONT,
  322. .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
  323. .desc.vsel_reg = DA9062AA_VBUCK1_A,
  324. .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
  325. .desc.linear_min_sel = 0,
  326. .desc.of_map_mode = da9062_map_buck_mode,
  327. .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
  328. __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
  329. sizeof(unsigned int) * 8 -
  330. __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
  331. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
  332. __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
  333. sizeof(unsigned int) * 8 -
  334. __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
  335. .suspend_vsel_reg = DA9062AA_VBUCK1_B,
  336. .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
  337. __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
  338. sizeof(unsigned int) * 8 -
  339. __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
  340. .suspend = REG_FIELD(DA9062AA_BUCK1_CONT,
  341. __builtin_ffs((int)DA9062AA_BUCK1_CONF_MASK) - 1,
  342. sizeof(unsigned int) * 8 -
  343. __builtin_clz(DA9062AA_BUCK1_CONF_MASK) - 1),
  344. },
  345. {
  346. .desc.id = DA9061_ID_BUCK2,
  347. .desc.name = "DA9061 BUCK2",
  348. .desc.of_match = of_match_ptr("buck2"),
  349. .desc.regulators_node = of_match_ptr("regulators"),
  350. .desc.ops = &da9062_buck_ops,
  351. .desc.min_uV = (800) * 1000,
  352. .desc.uV_step = (20) * 1000,
  353. .desc.n_voltages = ((3340) - (800))/(20) + 1,
  354. .desc.curr_table = da9062_buck_b_limits,
  355. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
  356. .desc.csel_reg = DA9062AA_BUCK_ILIM_A,
  357. .desc.csel_mask = DA9062AA_BUCK3_ILIM_MASK,
  358. .desc.enable_reg = DA9062AA_BUCK3_CONT,
  359. .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
  360. .desc.vsel_reg = DA9062AA_VBUCK3_A,
  361. .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
  362. .desc.linear_min_sel = 0,
  363. .desc.of_map_mode = da9062_map_buck_mode,
  364. .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
  365. __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
  366. sizeof(unsigned int) * 8 -
  367. __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
  368. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
  369. __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
  370. sizeof(unsigned int) * 8 -
  371. __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
  372. .suspend_vsel_reg = DA9062AA_VBUCK3_B,
  373. .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
  374. __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
  375. sizeof(unsigned int) * 8 -
  376. __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
  377. .suspend = REG_FIELD(DA9062AA_BUCK3_CONT,
  378. __builtin_ffs((int)DA9062AA_BUCK3_CONF_MASK) - 1,
  379. sizeof(unsigned int) * 8 -
  380. __builtin_clz(DA9062AA_BUCK3_CONF_MASK) - 1),
  381. },
  382. {
  383. .desc.id = DA9061_ID_BUCK3,
  384. .desc.name = "DA9061 BUCK3",
  385. .desc.of_match = of_match_ptr("buck3"),
  386. .desc.regulators_node = of_match_ptr("regulators"),
  387. .desc.ops = &da9062_buck_ops,
  388. .desc.min_uV = (530) * 1000,
  389. .desc.uV_step = (10) * 1000,
  390. .desc.n_voltages = ((1800) - (530))/(10) + 1,
  391. .desc.curr_table = da9062_buck_a_limits,
  392. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
  393. .desc.csel_reg = DA9062AA_BUCK_ILIM_B,
  394. .desc.csel_mask = DA9062AA_BUCK4_ILIM_MASK,
  395. .desc.enable_reg = DA9062AA_BUCK4_CONT,
  396. .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
  397. .desc.vsel_reg = DA9062AA_VBUCK4_A,
  398. .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
  399. .desc.linear_min_sel = 0,
  400. .desc.of_map_mode = da9062_map_buck_mode,
  401. .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
  402. __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
  403. sizeof(unsigned int) * 8 -
  404. __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
  405. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
  406. __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
  407. sizeof(unsigned int) * 8 -
  408. __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
  409. .suspend_vsel_reg = DA9062AA_VBUCK4_B,
  410. .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
  411. __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
  412. sizeof(unsigned int) * 8 -
  413. __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
  414. .suspend = REG_FIELD(DA9062AA_BUCK4_CONT,
  415. __builtin_ffs((int)DA9062AA_BUCK4_CONF_MASK) - 1,
  416. sizeof(unsigned int) * 8 -
  417. __builtin_clz(DA9062AA_BUCK4_CONF_MASK) - 1),
  418. },
  419. {
  420. .desc.id = DA9061_ID_LDO1,
  421. .desc.name = "DA9061 LDO1",
  422. .desc.of_match = of_match_ptr("ldo1"),
  423. .desc.regulators_node = of_match_ptr("regulators"),
  424. .desc.ops = &da9062_ldo_ops,
  425. .desc.min_uV = (900) * 1000,
  426. .desc.uV_step = (50) * 1000,
  427. .desc.n_voltages = ((3600) - (900))/(50) + 1
  428. + DA9062AA_VLDO_A_MIN_SEL,
  429. .desc.enable_reg = DA9062AA_LDO1_CONT,
  430. .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
  431. .desc.vsel_reg = DA9062AA_VLDO1_A,
  432. .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
  433. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  434. .sleep = REG_FIELD(DA9062AA_VLDO1_A,
  435. __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
  436. sizeof(unsigned int) * 8 -
  437. __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
  438. .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
  439. __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
  440. sizeof(unsigned int) * 8 -
  441. __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
  442. .suspend_vsel_reg = DA9062AA_VLDO1_B,
  443. .suspend = REG_FIELD(DA9062AA_LDO1_CONT,
  444. __builtin_ffs((int)DA9062AA_LDO1_CONF_MASK) - 1,
  445. sizeof(unsigned int) * 8 -
  446. __builtin_clz(DA9062AA_LDO1_CONF_MASK) - 1),
  447. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  448. __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
  449. sizeof(unsigned int) * 8 -
  450. __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
  451. },
  452. {
  453. .desc.id = DA9061_ID_LDO2,
  454. .desc.name = "DA9061 LDO2",
  455. .desc.of_match = of_match_ptr("ldo2"),
  456. .desc.regulators_node = of_match_ptr("regulators"),
  457. .desc.ops = &da9062_ldo_ops,
  458. .desc.min_uV = (900) * 1000,
  459. .desc.uV_step = (50) * 1000,
  460. .desc.n_voltages = ((3600) - (900))/(50) + 1
  461. + DA9062AA_VLDO_A_MIN_SEL,
  462. .desc.enable_reg = DA9062AA_LDO2_CONT,
  463. .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
  464. .desc.vsel_reg = DA9062AA_VLDO2_A,
  465. .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
  466. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  467. .sleep = REG_FIELD(DA9062AA_VLDO2_A,
  468. __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
  469. sizeof(unsigned int) * 8 -
  470. __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
  471. .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
  472. __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
  473. sizeof(unsigned int) * 8 -
  474. __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
  475. .suspend_vsel_reg = DA9062AA_VLDO2_B,
  476. .suspend = REG_FIELD(DA9062AA_LDO2_CONT,
  477. __builtin_ffs((int)DA9062AA_LDO2_CONF_MASK) - 1,
  478. sizeof(unsigned int) * 8 -
  479. __builtin_clz(DA9062AA_LDO2_CONF_MASK) - 1),
  480. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  481. __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
  482. sizeof(unsigned int) * 8 -
  483. __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
  484. },
  485. {
  486. .desc.id = DA9061_ID_LDO3,
  487. .desc.name = "DA9061 LDO3",
  488. .desc.of_match = of_match_ptr("ldo3"),
  489. .desc.regulators_node = of_match_ptr("regulators"),
  490. .desc.ops = &da9062_ldo_ops,
  491. .desc.min_uV = (900) * 1000,
  492. .desc.uV_step = (50) * 1000,
  493. .desc.n_voltages = ((3600) - (900))/(50) + 1
  494. + DA9062AA_VLDO_A_MIN_SEL,
  495. .desc.enable_reg = DA9062AA_LDO3_CONT,
  496. .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
  497. .desc.vsel_reg = DA9062AA_VLDO3_A,
  498. .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
  499. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  500. .sleep = REG_FIELD(DA9062AA_VLDO3_A,
  501. __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
  502. sizeof(unsigned int) * 8 -
  503. __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
  504. .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
  505. __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
  506. sizeof(unsigned int) * 8 -
  507. __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
  508. .suspend_vsel_reg = DA9062AA_VLDO3_B,
  509. .suspend = REG_FIELD(DA9062AA_LDO3_CONT,
  510. __builtin_ffs((int)DA9062AA_LDO3_CONF_MASK) - 1,
  511. sizeof(unsigned int) * 8 -
  512. __builtin_clz(DA9062AA_LDO3_CONF_MASK) - 1),
  513. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  514. __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
  515. sizeof(unsigned int) * 8 -
  516. __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
  517. },
  518. {
  519. .desc.id = DA9061_ID_LDO4,
  520. .desc.name = "DA9061 LDO4",
  521. .desc.of_match = of_match_ptr("ldo4"),
  522. .desc.regulators_node = of_match_ptr("regulators"),
  523. .desc.ops = &da9062_ldo_ops,
  524. .desc.min_uV = (900) * 1000,
  525. .desc.uV_step = (50) * 1000,
  526. .desc.n_voltages = ((3600) - (900))/(50) + 1
  527. + DA9062AA_VLDO_A_MIN_SEL,
  528. .desc.enable_reg = DA9062AA_LDO4_CONT,
  529. .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
  530. .desc.vsel_reg = DA9062AA_VLDO4_A,
  531. .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
  532. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  533. .sleep = REG_FIELD(DA9062AA_VLDO4_A,
  534. __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
  535. sizeof(unsigned int) * 8 -
  536. __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
  537. .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
  538. __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
  539. sizeof(unsigned int) * 8 -
  540. __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
  541. .suspend_vsel_reg = DA9062AA_VLDO4_B,
  542. .suspend = REG_FIELD(DA9062AA_LDO4_CONT,
  543. __builtin_ffs((int)DA9062AA_LDO4_CONF_MASK) - 1,
  544. sizeof(unsigned int) * 8 -
  545. __builtin_clz(DA9062AA_LDO4_CONF_MASK) - 1),
  546. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  547. __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
  548. sizeof(unsigned int) * 8 -
  549. __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
  550. },
  551. };
  552. /* DA9062 Regulator information */
  553. static const struct da9062_regulator_info local_da9062_regulator_info[] = {
  554. {
  555. .desc.id = DA9062_ID_BUCK1,
  556. .desc.name = "DA9062 BUCK1",
  557. .desc.of_match = of_match_ptr("buck1"),
  558. .desc.regulators_node = of_match_ptr("regulators"),
  559. .desc.ops = &da9062_buck_ops,
  560. .desc.min_uV = (300) * 1000,
  561. .desc.uV_step = (10) * 1000,
  562. .desc.n_voltages = ((1570) - (300))/(10) + 1,
  563. .desc.curr_table = da9062_buck_a_limits,
  564. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
  565. .desc.csel_reg = DA9062AA_BUCK_ILIM_C,
  566. .desc.csel_mask = DA9062AA_BUCK1_ILIM_MASK,
  567. .desc.enable_reg = DA9062AA_BUCK1_CONT,
  568. .desc.enable_mask = DA9062AA_BUCK1_EN_MASK,
  569. .desc.vsel_reg = DA9062AA_VBUCK1_A,
  570. .desc.vsel_mask = DA9062AA_VBUCK1_A_MASK,
  571. .desc.linear_min_sel = 0,
  572. .desc.of_map_mode = da9062_map_buck_mode,
  573. .sleep = REG_FIELD(DA9062AA_VBUCK1_A,
  574. __builtin_ffs((int)DA9062AA_BUCK1_SL_A_MASK) - 1,
  575. sizeof(unsigned int) * 8 -
  576. __builtin_clz((DA9062AA_BUCK1_SL_A_MASK)) - 1),
  577. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK1_B,
  578. __builtin_ffs((int)DA9062AA_BUCK1_SL_B_MASK) - 1,
  579. sizeof(unsigned int) * 8 -
  580. __builtin_clz((DA9062AA_BUCK1_SL_B_MASK)) - 1),
  581. .suspend_vsel_reg = DA9062AA_VBUCK1_B,
  582. .mode = REG_FIELD(DA9062AA_BUCK1_CFG,
  583. __builtin_ffs((int)DA9062AA_BUCK1_MODE_MASK) - 1,
  584. sizeof(unsigned int) * 8 -
  585. __builtin_clz((DA9062AA_BUCK1_MODE_MASK)) - 1),
  586. .suspend = REG_FIELD(DA9062AA_BUCK1_CONT,
  587. __builtin_ffs((int)DA9062AA_BUCK1_CONF_MASK) - 1,
  588. sizeof(unsigned int) * 8 -
  589. __builtin_clz(DA9062AA_BUCK1_CONF_MASK) - 1),
  590. },
  591. {
  592. .desc.id = DA9062_ID_BUCK2,
  593. .desc.name = "DA9062 BUCK2",
  594. .desc.of_match = of_match_ptr("buck2"),
  595. .desc.regulators_node = of_match_ptr("regulators"),
  596. .desc.ops = &da9062_buck_ops,
  597. .desc.min_uV = (300) * 1000,
  598. .desc.uV_step = (10) * 1000,
  599. .desc.n_voltages = ((1570) - (300))/(10) + 1,
  600. .desc.curr_table = da9062_buck_a_limits,
  601. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
  602. .desc.csel_reg = DA9062AA_BUCK_ILIM_C,
  603. .desc.csel_mask = DA9062AA_BUCK2_ILIM_MASK,
  604. .desc.enable_reg = DA9062AA_BUCK2_CONT,
  605. .desc.enable_mask = DA9062AA_BUCK2_EN_MASK,
  606. .desc.vsel_reg = DA9062AA_VBUCK2_A,
  607. .desc.vsel_mask = DA9062AA_VBUCK2_A_MASK,
  608. .desc.linear_min_sel = 0,
  609. .desc.of_map_mode = da9062_map_buck_mode,
  610. .sleep = REG_FIELD(DA9062AA_VBUCK2_A,
  611. __builtin_ffs((int)DA9062AA_BUCK2_SL_A_MASK) - 1,
  612. sizeof(unsigned int) * 8 -
  613. __builtin_clz((DA9062AA_BUCK2_SL_A_MASK)) - 1),
  614. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK2_B,
  615. __builtin_ffs((int)DA9062AA_BUCK2_SL_B_MASK) - 1,
  616. sizeof(unsigned int) * 8 -
  617. __builtin_clz((DA9062AA_BUCK2_SL_B_MASK)) - 1),
  618. .suspend_vsel_reg = DA9062AA_VBUCK2_B,
  619. .mode = REG_FIELD(DA9062AA_BUCK2_CFG,
  620. __builtin_ffs((int)DA9062AA_BUCK2_MODE_MASK) - 1,
  621. sizeof(unsigned int) * 8 -
  622. __builtin_clz((DA9062AA_BUCK2_MODE_MASK)) - 1),
  623. .suspend = REG_FIELD(DA9062AA_BUCK2_CONT,
  624. __builtin_ffs((int)DA9062AA_BUCK2_CONF_MASK) - 1,
  625. sizeof(unsigned int) * 8 -
  626. __builtin_clz(DA9062AA_BUCK2_CONF_MASK) - 1),
  627. },
  628. {
  629. .desc.id = DA9062_ID_BUCK3,
  630. .desc.name = "DA9062 BUCK3",
  631. .desc.of_match = of_match_ptr("buck3"),
  632. .desc.regulators_node = of_match_ptr("regulators"),
  633. .desc.ops = &da9062_buck_ops,
  634. .desc.min_uV = (800) * 1000,
  635. .desc.uV_step = (20) * 1000,
  636. .desc.n_voltages = ((3340) - (800))/(20) + 1,
  637. .desc.curr_table = da9062_buck_b_limits,
  638. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_b_limits),
  639. .desc.csel_reg = DA9062AA_BUCK_ILIM_A,
  640. .desc.csel_mask = DA9062AA_BUCK3_ILIM_MASK,
  641. .desc.enable_reg = DA9062AA_BUCK3_CONT,
  642. .desc.enable_mask = DA9062AA_BUCK3_EN_MASK,
  643. .desc.vsel_reg = DA9062AA_VBUCK3_A,
  644. .desc.vsel_mask = DA9062AA_VBUCK3_A_MASK,
  645. .desc.linear_min_sel = 0,
  646. .desc.of_map_mode = da9062_map_buck_mode,
  647. .sleep = REG_FIELD(DA9062AA_VBUCK3_A,
  648. __builtin_ffs((int)DA9062AA_BUCK3_SL_A_MASK) - 1,
  649. sizeof(unsigned int) * 8 -
  650. __builtin_clz((DA9062AA_BUCK3_SL_A_MASK)) - 1),
  651. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK3_B,
  652. __builtin_ffs((int)DA9062AA_BUCK3_SL_B_MASK) - 1,
  653. sizeof(unsigned int) * 8 -
  654. __builtin_clz((DA9062AA_BUCK3_SL_B_MASK)) - 1),
  655. .suspend_vsel_reg = DA9062AA_VBUCK3_B,
  656. .mode = REG_FIELD(DA9062AA_BUCK3_CFG,
  657. __builtin_ffs((int)DA9062AA_BUCK3_MODE_MASK) - 1,
  658. sizeof(unsigned int) * 8 -
  659. __builtin_clz((DA9062AA_BUCK3_MODE_MASK)) - 1),
  660. .suspend = REG_FIELD(DA9062AA_BUCK3_CONT,
  661. __builtin_ffs((int)DA9062AA_BUCK3_CONF_MASK) - 1,
  662. sizeof(unsigned int) * 8 -
  663. __builtin_clz(DA9062AA_BUCK3_CONF_MASK) - 1),
  664. },
  665. {
  666. .desc.id = DA9062_ID_BUCK4,
  667. .desc.name = "DA9062 BUCK4",
  668. .desc.of_match = of_match_ptr("buck4"),
  669. .desc.regulators_node = of_match_ptr("regulators"),
  670. .desc.ops = &da9062_buck_ops,
  671. .desc.min_uV = (530) * 1000,
  672. .desc.uV_step = (10) * 1000,
  673. .desc.n_voltages = ((1800) - (530))/(10) + 1,
  674. .desc.curr_table = da9062_buck_a_limits,
  675. .desc.n_current_limits = ARRAY_SIZE(da9062_buck_a_limits),
  676. .desc.csel_reg = DA9062AA_BUCK_ILIM_B,
  677. .desc.csel_mask = DA9062AA_BUCK4_ILIM_MASK,
  678. .desc.enable_reg = DA9062AA_BUCK4_CONT,
  679. .desc.enable_mask = DA9062AA_BUCK4_EN_MASK,
  680. .desc.vsel_reg = DA9062AA_VBUCK4_A,
  681. .desc.vsel_mask = DA9062AA_VBUCK4_A_MASK,
  682. .desc.linear_min_sel = 0,
  683. .desc.of_map_mode = da9062_map_buck_mode,
  684. .sleep = REG_FIELD(DA9062AA_VBUCK4_A,
  685. __builtin_ffs((int)DA9062AA_BUCK4_SL_A_MASK) - 1,
  686. sizeof(unsigned int) * 8 -
  687. __builtin_clz((DA9062AA_BUCK4_SL_A_MASK)) - 1),
  688. .suspend_sleep = REG_FIELD(DA9062AA_VBUCK4_B,
  689. __builtin_ffs((int)DA9062AA_BUCK4_SL_B_MASK) - 1,
  690. sizeof(unsigned int) * 8 -
  691. __builtin_clz((DA9062AA_BUCK4_SL_B_MASK)) - 1),
  692. .suspend_vsel_reg = DA9062AA_VBUCK4_B,
  693. .mode = REG_FIELD(DA9062AA_BUCK4_CFG,
  694. __builtin_ffs((int)DA9062AA_BUCK4_MODE_MASK) - 1,
  695. sizeof(unsigned int) * 8 -
  696. __builtin_clz((DA9062AA_BUCK4_MODE_MASK)) - 1),
  697. .suspend = REG_FIELD(DA9062AA_BUCK4_CONT,
  698. __builtin_ffs((int)DA9062AA_BUCK4_CONF_MASK) - 1,
  699. sizeof(unsigned int) * 8 -
  700. __builtin_clz(DA9062AA_BUCK4_CONF_MASK) - 1),
  701. },
  702. {
  703. .desc.id = DA9062_ID_LDO1,
  704. .desc.name = "DA9062 LDO1",
  705. .desc.of_match = of_match_ptr("ldo1"),
  706. .desc.regulators_node = of_match_ptr("regulators"),
  707. .desc.ops = &da9062_ldo_ops,
  708. .desc.min_uV = (900) * 1000,
  709. .desc.uV_step = (50) * 1000,
  710. .desc.n_voltages = ((3600) - (900))/(50) + 1
  711. + DA9062AA_VLDO_A_MIN_SEL,
  712. .desc.enable_reg = DA9062AA_LDO1_CONT,
  713. .desc.enable_mask = DA9062AA_LDO1_EN_MASK,
  714. .desc.vsel_reg = DA9062AA_VLDO1_A,
  715. .desc.vsel_mask = DA9062AA_VLDO1_A_MASK,
  716. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  717. .sleep = REG_FIELD(DA9062AA_VLDO1_A,
  718. __builtin_ffs((int)DA9062AA_LDO1_SL_A_MASK) - 1,
  719. sizeof(unsigned int) * 8 -
  720. __builtin_clz((DA9062AA_LDO1_SL_A_MASK)) - 1),
  721. .suspend_sleep = REG_FIELD(DA9062AA_VLDO1_B,
  722. __builtin_ffs((int)DA9062AA_LDO1_SL_B_MASK) - 1,
  723. sizeof(unsigned int) * 8 -
  724. __builtin_clz((DA9062AA_LDO1_SL_B_MASK)) - 1),
  725. .suspend_vsel_reg = DA9062AA_VLDO1_B,
  726. .suspend = REG_FIELD(DA9062AA_LDO1_CONT,
  727. __builtin_ffs((int)DA9062AA_LDO1_CONF_MASK) - 1,
  728. sizeof(unsigned int) * 8 -
  729. __builtin_clz(DA9062AA_LDO1_CONF_MASK) - 1),
  730. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  731. __builtin_ffs((int)DA9062AA_LDO1_ILIM_MASK) - 1,
  732. sizeof(unsigned int) * 8 -
  733. __builtin_clz((DA9062AA_LDO1_ILIM_MASK)) - 1),
  734. },
  735. {
  736. .desc.id = DA9062_ID_LDO2,
  737. .desc.name = "DA9062 LDO2",
  738. .desc.of_match = of_match_ptr("ldo2"),
  739. .desc.regulators_node = of_match_ptr("regulators"),
  740. .desc.ops = &da9062_ldo_ops,
  741. .desc.min_uV = (900) * 1000,
  742. .desc.uV_step = (50) * 1000,
  743. .desc.n_voltages = ((3600) - (900))/(50) + 1
  744. + DA9062AA_VLDO_A_MIN_SEL,
  745. .desc.enable_reg = DA9062AA_LDO2_CONT,
  746. .desc.enable_mask = DA9062AA_LDO2_EN_MASK,
  747. .desc.vsel_reg = DA9062AA_VLDO2_A,
  748. .desc.vsel_mask = DA9062AA_VLDO2_A_MASK,
  749. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  750. .sleep = REG_FIELD(DA9062AA_VLDO2_A,
  751. __builtin_ffs((int)DA9062AA_LDO2_SL_A_MASK) - 1,
  752. sizeof(unsigned int) * 8 -
  753. __builtin_clz((DA9062AA_LDO2_SL_A_MASK)) - 1),
  754. .suspend_sleep = REG_FIELD(DA9062AA_VLDO2_B,
  755. __builtin_ffs((int)DA9062AA_LDO2_SL_B_MASK) - 1,
  756. sizeof(unsigned int) * 8 -
  757. __builtin_clz((DA9062AA_LDO2_SL_B_MASK)) - 1),
  758. .suspend_vsel_reg = DA9062AA_VLDO2_B,
  759. .suspend = REG_FIELD(DA9062AA_LDO2_CONT,
  760. __builtin_ffs((int)DA9062AA_LDO2_CONF_MASK) - 1,
  761. sizeof(unsigned int) * 8 -
  762. __builtin_clz(DA9062AA_LDO2_CONF_MASK) - 1),
  763. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  764. __builtin_ffs((int)DA9062AA_LDO2_ILIM_MASK) - 1,
  765. sizeof(unsigned int) * 8 -
  766. __builtin_clz((DA9062AA_LDO2_ILIM_MASK)) - 1),
  767. },
  768. {
  769. .desc.id = DA9062_ID_LDO3,
  770. .desc.name = "DA9062 LDO3",
  771. .desc.of_match = of_match_ptr("ldo3"),
  772. .desc.regulators_node = of_match_ptr("regulators"),
  773. .desc.ops = &da9062_ldo_ops,
  774. .desc.min_uV = (900) * 1000,
  775. .desc.uV_step = (50) * 1000,
  776. .desc.n_voltages = ((3600) - (900))/(50) + 1
  777. + DA9062AA_VLDO_A_MIN_SEL,
  778. .desc.enable_reg = DA9062AA_LDO3_CONT,
  779. .desc.enable_mask = DA9062AA_LDO3_EN_MASK,
  780. .desc.vsel_reg = DA9062AA_VLDO3_A,
  781. .desc.vsel_mask = DA9062AA_VLDO3_A_MASK,
  782. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  783. .sleep = REG_FIELD(DA9062AA_VLDO3_A,
  784. __builtin_ffs((int)DA9062AA_LDO3_SL_A_MASK) - 1,
  785. sizeof(unsigned int) * 8 -
  786. __builtin_clz((DA9062AA_LDO3_SL_A_MASK)) - 1),
  787. .suspend_sleep = REG_FIELD(DA9062AA_VLDO3_B,
  788. __builtin_ffs((int)DA9062AA_LDO3_SL_B_MASK) - 1,
  789. sizeof(unsigned int) * 8 -
  790. __builtin_clz((DA9062AA_LDO3_SL_B_MASK)) - 1),
  791. .suspend_vsel_reg = DA9062AA_VLDO3_B,
  792. .suspend = REG_FIELD(DA9062AA_LDO3_CONT,
  793. __builtin_ffs((int)DA9062AA_LDO3_CONF_MASK) - 1,
  794. sizeof(unsigned int) * 8 -
  795. __builtin_clz(DA9062AA_LDO3_CONF_MASK) - 1),
  796. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  797. __builtin_ffs((int)DA9062AA_LDO3_ILIM_MASK) - 1,
  798. sizeof(unsigned int) * 8 -
  799. __builtin_clz((DA9062AA_LDO3_ILIM_MASK)) - 1),
  800. },
  801. {
  802. .desc.id = DA9062_ID_LDO4,
  803. .desc.name = "DA9062 LDO4",
  804. .desc.of_match = of_match_ptr("ldo4"),
  805. .desc.regulators_node = of_match_ptr("regulators"),
  806. .desc.ops = &da9062_ldo_ops,
  807. .desc.min_uV = (900) * 1000,
  808. .desc.uV_step = (50) * 1000,
  809. .desc.n_voltages = ((3600) - (900))/(50) + 1
  810. + DA9062AA_VLDO_A_MIN_SEL,
  811. .desc.enable_reg = DA9062AA_LDO4_CONT,
  812. .desc.enable_mask = DA9062AA_LDO4_EN_MASK,
  813. .desc.vsel_reg = DA9062AA_VLDO4_A,
  814. .desc.vsel_mask = DA9062AA_VLDO4_A_MASK,
  815. .desc.linear_min_sel = DA9062AA_VLDO_A_MIN_SEL,
  816. .sleep = REG_FIELD(DA9062AA_VLDO4_A,
  817. __builtin_ffs((int)DA9062AA_LDO4_SL_A_MASK) - 1,
  818. sizeof(unsigned int) * 8 -
  819. __builtin_clz((DA9062AA_LDO4_SL_A_MASK)) - 1),
  820. .suspend_sleep = REG_FIELD(DA9062AA_VLDO4_B,
  821. __builtin_ffs((int)DA9062AA_LDO4_SL_B_MASK) - 1,
  822. sizeof(unsigned int) * 8 -
  823. __builtin_clz((DA9062AA_LDO4_SL_B_MASK)) - 1),
  824. .suspend_vsel_reg = DA9062AA_VLDO4_B,
  825. .suspend = REG_FIELD(DA9062AA_LDO4_CONT,
  826. __builtin_ffs((int)DA9062AA_LDO4_CONF_MASK) - 1,
  827. sizeof(unsigned int) * 8 -
  828. __builtin_clz(DA9062AA_LDO4_CONF_MASK) - 1),
  829. .oc_event = REG_FIELD(DA9062AA_STATUS_D,
  830. __builtin_ffs((int)DA9062AA_LDO4_ILIM_MASK) - 1,
  831. sizeof(unsigned int) * 8 -
  832. __builtin_clz((DA9062AA_LDO4_ILIM_MASK)) - 1),
  833. },
  834. };
  835. /* Regulator interrupt handlers */
  836. static irqreturn_t da9062_ldo_lim_event(int irq, void *data)
  837. {
  838. struct da9062_regulators *regulators = data;
  839. struct da9062 *hw = regulators->regulator[0].hw;
  840. struct da9062_regulator *regl;
  841. int handled = IRQ_NONE;
  842. int bits, i, ret;
  843. ret = regmap_read(hw->regmap, DA9062AA_STATUS_D, &bits);
  844. if (ret < 0) {
  845. dev_err(hw->dev,
  846. "Failed to read LDO overcurrent indicator\n");
  847. goto ldo_lim_error;
  848. }
  849. for (i = regulators->n_regulators - 1; i >= 0; i--) {
  850. regl = &regulators->regulator[i];
  851. if (regl->info->oc_event.reg != DA9062AA_STATUS_D)
  852. continue;
  853. if (BIT(regl->info->oc_event.lsb) & bits) {
  854. regulator_notifier_call_chain(regl->rdev,
  855. REGULATOR_EVENT_OVER_CURRENT, NULL);
  856. handled = IRQ_HANDLED;
  857. }
  858. }
  859. ldo_lim_error:
  860. return handled;
  861. }
  862. static int da9062_regulator_probe(struct platform_device *pdev)
  863. {
  864. struct da9062 *chip = dev_get_drvdata(pdev->dev.parent);
  865. struct da9062_regulators *regulators;
  866. struct da9062_regulator *regl;
  867. struct regulator_config config = { };
  868. const struct da9062_regulator_info *rinfo;
  869. int irq, n, ret;
  870. int max_regulators;
  871. switch (chip->chip_type) {
  872. case COMPAT_TYPE_DA9061:
  873. max_regulators = DA9061_MAX_REGULATORS;
  874. rinfo = local_da9061_regulator_info;
  875. break;
  876. case COMPAT_TYPE_DA9062:
  877. max_regulators = DA9062_MAX_REGULATORS;
  878. rinfo = local_da9062_regulator_info;
  879. break;
  880. default:
  881. dev_err(chip->dev, "Unrecognised chip type\n");
  882. return -ENODEV;
  883. }
  884. /* Allocate memory required by usable regulators */
  885. regulators = devm_kzalloc(&pdev->dev, struct_size(regulators, regulator,
  886. max_regulators), GFP_KERNEL);
  887. if (!regulators)
  888. return -ENOMEM;
  889. regulators->n_regulators = max_regulators;
  890. platform_set_drvdata(pdev, regulators);
  891. for (n = 0; n < regulators->n_regulators; n++) {
  892. /* Initialise regulator structure */
  893. regl = &regulators->regulator[n];
  894. regl->hw = chip;
  895. regl->info = &rinfo[n];
  896. regl->desc = regl->info->desc;
  897. regl->desc.type = REGULATOR_VOLTAGE;
  898. regl->desc.owner = THIS_MODULE;
  899. if (regl->info->mode.reg) {
  900. regl->mode = devm_regmap_field_alloc(
  901. &pdev->dev,
  902. chip->regmap,
  903. regl->info->mode);
  904. if (IS_ERR(regl->mode))
  905. return PTR_ERR(regl->mode);
  906. }
  907. if (regl->info->suspend.reg) {
  908. regl->suspend = devm_regmap_field_alloc(
  909. &pdev->dev,
  910. chip->regmap,
  911. regl->info->suspend);
  912. if (IS_ERR(regl->suspend))
  913. return PTR_ERR(regl->suspend);
  914. }
  915. if (regl->info->sleep.reg) {
  916. regl->sleep = devm_regmap_field_alloc(
  917. &pdev->dev,
  918. chip->regmap,
  919. regl->info->sleep);
  920. if (IS_ERR(regl->sleep))
  921. return PTR_ERR(regl->sleep);
  922. }
  923. if (regl->info->suspend_sleep.reg) {
  924. regl->suspend_sleep = devm_regmap_field_alloc(
  925. &pdev->dev,
  926. chip->regmap,
  927. regl->info->suspend_sleep);
  928. if (IS_ERR(regl->suspend_sleep))
  929. return PTR_ERR(regl->suspend_sleep);
  930. }
  931. /* Register regulator */
  932. memset(&config, 0, sizeof(config));
  933. config.dev = chip->dev;
  934. config.driver_data = regl;
  935. config.regmap = chip->regmap;
  936. regl->rdev = devm_regulator_register(&pdev->dev, &regl->desc,
  937. &config);
  938. if (IS_ERR(regl->rdev)) {
  939. dev_err(&pdev->dev,
  940. "Failed to register %s regulator\n",
  941. regl->desc.name);
  942. return PTR_ERR(regl->rdev);
  943. }
  944. }
  945. /* LDOs overcurrent event support */
  946. irq = platform_get_irq_byname(pdev, "LDO_LIM");
  947. if (irq < 0)
  948. return irq;
  949. regulators->irq_ldo_lim = irq;
  950. ret = devm_request_threaded_irq(&pdev->dev, irq,
  951. NULL, da9062_ldo_lim_event,
  952. IRQF_TRIGGER_LOW | IRQF_ONESHOT,
  953. "LDO_LIM", regulators);
  954. if (ret) {
  955. dev_warn(&pdev->dev,
  956. "Failed to request LDO_LIM IRQ.\n");
  957. regulators->irq_ldo_lim = -ENXIO;
  958. }
  959. return 0;
  960. }
  961. static struct platform_driver da9062_regulator_driver = {
  962. .driver = {
  963. .name = "da9062-regulators",
  964. },
  965. .probe = da9062_regulator_probe,
  966. };
  967. static int __init da9062_regulator_init(void)
  968. {
  969. return platform_driver_register(&da9062_regulator_driver);
  970. }
  971. subsys_initcall(da9062_regulator_init);
  972. static void __exit da9062_regulator_cleanup(void)
  973. {
  974. platform_driver_unregister(&da9062_regulator_driver);
  975. }
  976. module_exit(da9062_regulator_cleanup);
  977. /* Module information */
  978. MODULE_AUTHOR("S Twiss <stwiss.opensource@diasemi.com>");
  979. MODULE_DESCRIPTION("REGULATOR device driver for Dialog DA9062 and DA9061");
  980. MODULE_LICENSE("GPL");
  981. MODULE_ALIAS("platform:da9062-regulators");