bd718x7-regulator.c 47 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381138213831384138513861387138813891390139113921393139413951396139713981399140014011402140314041405140614071408140914101411141214131414141514161417141814191420142114221423142414251426142714281429143014311432143314341435143614371438143914401441144214431444144514461447144814491450145114521453145414551456145714581459146014611462146314641465146614671468146914701471147214731474147514761477147814791480148114821483148414851486148714881489149014911492149314941495149614971498149915001501150215031504150515061507150815091510151115121513151415151516151715181519152015211522152315241525152615271528152915301531153215331534153515361537153815391540154115421543154415451546154715481549155015511552155315541555155615571558155915601561156215631564156515661567156815691570157115721573157415751576157715781579158015811582158315841585
  1. // SPDX-License-Identifier: GPL-2.0
  2. // Copyright (C) 2018 ROHM Semiconductors
  3. // bd71837-regulator.c ROHM BD71837MWV/BD71847MWV regulator driver
  4. #include <linux/delay.h>
  5. #include <linux/err.h>
  6. #include <linux/interrupt.h>
  7. #include <linux/kernel.h>
  8. #include <linux/mfd/rohm-bd718x7.h>
  9. #include <linux/module.h>
  10. #include <linux/of.h>
  11. #include <linux/platform_device.h>
  12. #include <linux/regulator/driver.h>
  13. #include <linux/regulator/machine.h>
  14. #include <linux/regulator/of_regulator.h>
  15. #include <linux/slab.h>
  16. /* Typical regulator startup times as per data sheet in uS */
  17. #define BD71847_BUCK1_STARTUP_TIME 144
  18. #define BD71847_BUCK2_STARTUP_TIME 162
  19. #define BD71847_BUCK3_STARTUP_TIME 162
  20. #define BD71847_BUCK4_STARTUP_TIME 240
  21. #define BD71847_BUCK5_STARTUP_TIME 270
  22. #define BD71847_BUCK6_STARTUP_TIME 200
  23. #define BD71847_LDO1_STARTUP_TIME 440
  24. #define BD71847_LDO2_STARTUP_TIME 370
  25. #define BD71847_LDO3_STARTUP_TIME 310
  26. #define BD71847_LDO4_STARTUP_TIME 400
  27. #define BD71847_LDO5_STARTUP_TIME 530
  28. #define BD71847_LDO6_STARTUP_TIME 400
  29. #define BD71837_BUCK1_STARTUP_TIME 160
  30. #define BD71837_BUCK2_STARTUP_TIME 180
  31. #define BD71837_BUCK3_STARTUP_TIME 180
  32. #define BD71837_BUCK4_STARTUP_TIME 180
  33. #define BD71837_BUCK5_STARTUP_TIME 160
  34. #define BD71837_BUCK6_STARTUP_TIME 240
  35. #define BD71837_BUCK7_STARTUP_TIME 220
  36. #define BD71837_BUCK8_STARTUP_TIME 200
  37. #define BD71837_LDO1_STARTUP_TIME 440
  38. #define BD71837_LDO2_STARTUP_TIME 370
  39. #define BD71837_LDO3_STARTUP_TIME 310
  40. #define BD71837_LDO4_STARTUP_TIME 400
  41. #define BD71837_LDO5_STARTUP_TIME 310
  42. #define BD71837_LDO6_STARTUP_TIME 400
  43. #define BD71837_LDO7_STARTUP_TIME 530
  44. /*
  45. * BD718(37/47/50) have two "enable control modes". ON/OFF can either be
  46. * controlled by software - or by PMIC internal HW state machine. Whether
  47. * regulator should be under SW or HW control can be defined from device-tree.
  48. * Let's provide separate ops for regulators to use depending on the "enable
  49. * control mode".
  50. */
  51. #define BD718XX_HWOPNAME(swopname) swopname##_hwcontrol
  52. #define BD718XX_OPS(name, _list_voltage, _map_voltage, _set_voltage_sel, \
  53. _get_voltage_sel, _set_voltage_time_sel, _set_ramp_delay) \
  54. static const struct regulator_ops name = { \
  55. .enable = regulator_enable_regmap, \
  56. .disable = regulator_disable_regmap, \
  57. .is_enabled = regulator_is_enabled_regmap, \
  58. .list_voltage = (_list_voltage), \
  59. .map_voltage = (_map_voltage), \
  60. .set_voltage_sel = (_set_voltage_sel), \
  61. .get_voltage_sel = (_get_voltage_sel), \
  62. .set_voltage_time_sel = (_set_voltage_time_sel), \
  63. .set_ramp_delay = (_set_ramp_delay), \
  64. }; \
  65. \
  66. static const struct regulator_ops BD718XX_HWOPNAME(name) = { \
  67. .is_enabled = always_enabled_by_hwstate, \
  68. .list_voltage = (_list_voltage), \
  69. .map_voltage = (_map_voltage), \
  70. .set_voltage_sel = (_set_voltage_sel), \
  71. .get_voltage_sel = (_get_voltage_sel), \
  72. .set_voltage_time_sel = (_set_voltage_time_sel), \
  73. .set_ramp_delay = (_set_ramp_delay), \
  74. } \
  75. /*
  76. * BUCK1/2/3/4
  77. * BUCK1RAMPRATE[1:0] BUCK1 DVS ramp rate setting
  78. * 00: 10.00mV/usec 10mV 1uS
  79. * 01: 5.00mV/usec 10mV 2uS
  80. * 10: 2.50mV/usec 10mV 4uS
  81. * 11: 1.25mV/usec 10mV 8uS
  82. */
  83. static int bd718xx_buck1234_set_ramp_delay(struct regulator_dev *rdev,
  84. int ramp_delay)
  85. {
  86. int id = rdev_get_id(rdev);
  87. unsigned int ramp_value;
  88. dev_dbg(&rdev->dev, "Buck[%d] Set Ramp = %d\n", id + 1,
  89. ramp_delay);
  90. switch (ramp_delay) {
  91. case 1 ... 1250:
  92. ramp_value = BUCK_RAMPRATE_1P25MV;
  93. break;
  94. case 1251 ... 2500:
  95. ramp_value = BUCK_RAMPRATE_2P50MV;
  96. break;
  97. case 2501 ... 5000:
  98. ramp_value = BUCK_RAMPRATE_5P00MV;
  99. break;
  100. case 5001 ... 10000:
  101. ramp_value = BUCK_RAMPRATE_10P00MV;
  102. break;
  103. default:
  104. ramp_value = BUCK_RAMPRATE_10P00MV;
  105. dev_err(&rdev->dev,
  106. "%s: ramp_delay: %d not supported, setting 10000mV//us\n",
  107. rdev->desc->name, ramp_delay);
  108. }
  109. return regmap_update_bits(rdev->regmap, BD718XX_REG_BUCK1_CTRL + id,
  110. BUCK_RAMPRATE_MASK, ramp_value << 6);
  111. }
  112. /* These functions are used when regulators are under HW state machine control.
  113. * We assume PMIC is in RUN state because SW running and able to query the
  114. * status. Most of the regulators have fixed ON or OFF state at RUN/IDLE so for
  115. * them we just return a constant. BD71837 BUCK3 and BUCK4 are exceptions as
  116. * they support configuring the ON/OFF state for RUN.
  117. *
  118. * Note for next hacker - these PMICs have a register where the HW state can be
  119. * read. If assuming RUN appears to be false in your use-case - you can
  120. * implement state reading (although that is not going to be atomic) before
  121. * returning the enable state.
  122. */
  123. static int always_enabled_by_hwstate(struct regulator_dev *rdev)
  124. {
  125. return 1;
  126. }
  127. static int never_enabled_by_hwstate(struct regulator_dev *rdev)
  128. {
  129. return 0;
  130. }
  131. static int bd71837_get_buck34_enable_hwctrl(struct regulator_dev *rdev)
  132. {
  133. int ret;
  134. unsigned int val;
  135. ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
  136. if (ret)
  137. return ret;
  138. return !!(BD718XX_BUCK_RUN_ON & val);
  139. }
  140. /*
  141. * On BD71837 (not on BD71847, BD71850, ...)
  142. * Bucks 1 to 4 support DVS. PWM mode is used when voltage is changed.
  143. * Bucks 5 to 8 and LDOs can use PFM and must be disabled when voltage
  144. * is changed. Hence we return -EBUSY for these if voltage is changed
  145. * when BUCK/LDO is enabled.
  146. *
  147. * On BD71847, BD71850, ... The LDO voltage can be changed when LDO is
  148. * enabled. But if voltage is increased the LDO power-good monitoring
  149. * must be disabled for the duration of changing + 1mS to ensure voltage
  150. * has reached the higher level before HW does next under voltage detection
  151. * cycle.
  152. */
  153. static int bd71837_set_voltage_sel_restricted(struct regulator_dev *rdev,
  154. unsigned int sel)
  155. {
  156. if (rdev->desc->ops->is_enabled(rdev))
  157. return -EBUSY;
  158. return regulator_set_voltage_sel_regmap(rdev, sel);
  159. }
  160. static void voltage_change_done(struct regulator_dev *rdev, unsigned int sel,
  161. unsigned int *mask)
  162. {
  163. int ret;
  164. if (*mask) {
  165. /*
  166. * Let's allow scheduling as we use I2C anyways. We just need to
  167. * guarantee minimum of 1ms sleep - it shouldn't matter if we
  168. * exceed it due to the scheduling.
  169. */
  170. msleep(1);
  171. /*
  172. * Note for next hacker. The PWRGOOD should not be masked on
  173. * BD71847 so we will just unconditionally enable detection
  174. * when voltage is set.
  175. * If someone want's to disable PWRGOOD he must implement
  176. * caching and restoring the old value here. I am not
  177. * aware of such use-cases so for the sake of the simplicity
  178. * we just always enable PWRGOOD here.
  179. */
  180. ret = regmap_update_bits(rdev->regmap, BD718XX_REG_MVRFLTMASK2,
  181. *mask, 0);
  182. if (ret)
  183. dev_err(&rdev->dev,
  184. "Failed to re-enable voltage monitoring (%d)\n",
  185. ret);
  186. }
  187. }
  188. static int voltage_change_prepare(struct regulator_dev *rdev, unsigned int sel,
  189. unsigned int *mask)
  190. {
  191. int ret;
  192. *mask = 0;
  193. if (rdev->desc->ops->is_enabled(rdev)) {
  194. int now, new;
  195. now = rdev->desc->ops->get_voltage_sel(rdev);
  196. if (now < 0)
  197. return now;
  198. now = rdev->desc->ops->list_voltage(rdev, now);
  199. if (now < 0)
  200. return now;
  201. new = rdev->desc->ops->list_voltage(rdev, sel);
  202. if (new < 0)
  203. return new;
  204. /*
  205. * If we increase LDO voltage when LDO is enabled we need to
  206. * disable the power-good detection until voltage has reached
  207. * the new level. According to HW colleagues the maximum time
  208. * it takes is 1000us. I assume that on systems with light load
  209. * this might be less - and we could probably use DT to give
  210. * system specific delay value if performance matters.
  211. *
  212. * Well, knowing we use I2C here and can add scheduling delays
  213. * I don't think it is worth the hassle and I just add fixed
  214. * 1ms sleep here (and allow scheduling). If this turns out to
  215. * be a problem we can change it to delay and make the delay
  216. * time configurable.
  217. */
  218. if (new > now) {
  219. int ldo_offset = rdev->desc->id - BD718XX_LDO1;
  220. *mask = BD718XX_LDO1_VRMON80 << ldo_offset;
  221. ret = regmap_update_bits(rdev->regmap,
  222. BD718XX_REG_MVRFLTMASK2,
  223. *mask, *mask);
  224. if (ret) {
  225. dev_err(&rdev->dev,
  226. "Failed to stop voltage monitoring\n");
  227. return ret;
  228. }
  229. }
  230. }
  231. return 0;
  232. }
  233. static int bd718xx_set_voltage_sel_restricted(struct regulator_dev *rdev,
  234. unsigned int sel)
  235. {
  236. int ret;
  237. int mask;
  238. ret = voltage_change_prepare(rdev, sel, &mask);
  239. if (ret)
  240. return ret;
  241. ret = regulator_set_voltage_sel_regmap(rdev, sel);
  242. voltage_change_done(rdev, sel, &mask);
  243. return ret;
  244. }
  245. static int bd718xx_set_voltage_sel_pickable_restricted(
  246. struct regulator_dev *rdev, unsigned int sel)
  247. {
  248. int ret;
  249. int mask;
  250. ret = voltage_change_prepare(rdev, sel, &mask);
  251. if (ret)
  252. return ret;
  253. ret = regulator_set_voltage_sel_pickable_regmap(rdev, sel);
  254. voltage_change_done(rdev, sel, &mask);
  255. return ret;
  256. }
  257. static int bd71837_set_voltage_sel_pickable_restricted(
  258. struct regulator_dev *rdev, unsigned int sel)
  259. {
  260. if (rdev->desc->ops->is_enabled(rdev))
  261. return -EBUSY;
  262. return regulator_set_voltage_sel_pickable_regmap(rdev, sel);
  263. }
  264. /*
  265. * OPS common for BD71847 and BD71850
  266. */
  267. BD718XX_OPS(bd718xx_pickable_range_ldo_ops,
  268. regulator_list_voltage_pickable_linear_range, NULL,
  269. bd718xx_set_voltage_sel_pickable_restricted,
  270. regulator_get_voltage_sel_pickable_regmap, NULL, NULL);
  271. /* BD71847 and BD71850 LDO 5 is by default OFF at RUN state */
  272. static const struct regulator_ops bd718xx_ldo5_ops_hwstate = {
  273. .is_enabled = never_enabled_by_hwstate,
  274. .list_voltage = regulator_list_voltage_pickable_linear_range,
  275. .set_voltage_sel = bd718xx_set_voltage_sel_pickable_restricted,
  276. .get_voltage_sel = regulator_get_voltage_sel_pickable_regmap,
  277. };
  278. BD718XX_OPS(bd718xx_pickable_range_buck_ops,
  279. regulator_list_voltage_pickable_linear_range, NULL,
  280. regulator_set_voltage_sel_pickable_regmap,
  281. regulator_get_voltage_sel_pickable_regmap,
  282. regulator_set_voltage_time_sel, NULL);
  283. BD718XX_OPS(bd718xx_ldo_regulator_ops, regulator_list_voltage_linear_range,
  284. NULL, bd718xx_set_voltage_sel_restricted,
  285. regulator_get_voltage_sel_regmap, NULL, NULL);
  286. BD718XX_OPS(bd718xx_ldo_regulator_nolinear_ops, regulator_list_voltage_table,
  287. NULL, bd718xx_set_voltage_sel_restricted,
  288. regulator_get_voltage_sel_regmap, NULL, NULL);
  289. BD718XX_OPS(bd718xx_buck_regulator_ops, regulator_list_voltage_linear_range,
  290. NULL, regulator_set_voltage_sel_regmap,
  291. regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
  292. NULL);
  293. BD718XX_OPS(bd718xx_buck_regulator_nolinear_ops, regulator_list_voltage_table,
  294. regulator_map_voltage_ascend, regulator_set_voltage_sel_regmap,
  295. regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
  296. NULL);
  297. /*
  298. * OPS for BD71837
  299. */
  300. BD718XX_OPS(bd71837_pickable_range_ldo_ops,
  301. regulator_list_voltage_pickable_linear_range, NULL,
  302. bd71837_set_voltage_sel_pickable_restricted,
  303. regulator_get_voltage_sel_pickable_regmap, NULL, NULL);
  304. BD718XX_OPS(bd71837_pickable_range_buck_ops,
  305. regulator_list_voltage_pickable_linear_range, NULL,
  306. bd71837_set_voltage_sel_pickable_restricted,
  307. regulator_get_voltage_sel_pickable_regmap,
  308. regulator_set_voltage_time_sel, NULL);
  309. BD718XX_OPS(bd71837_ldo_regulator_ops, regulator_list_voltage_linear_range,
  310. NULL, bd71837_set_voltage_sel_restricted,
  311. regulator_get_voltage_sel_regmap, NULL, NULL);
  312. BD718XX_OPS(bd71837_ldo_regulator_nolinear_ops, regulator_list_voltage_table,
  313. NULL, bd71837_set_voltage_sel_restricted,
  314. regulator_get_voltage_sel_regmap, NULL, NULL);
  315. BD718XX_OPS(bd71837_buck_regulator_ops, regulator_list_voltage_linear_range,
  316. NULL, bd71837_set_voltage_sel_restricted,
  317. regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
  318. NULL);
  319. BD718XX_OPS(bd71837_buck_regulator_nolinear_ops, regulator_list_voltage_table,
  320. regulator_map_voltage_ascend, bd71837_set_voltage_sel_restricted,
  321. regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
  322. NULL);
  323. /*
  324. * BD71837 bucks 3 and 4 support defining their enable/disable state also
  325. * when buck enable state is under HW state machine control. In that case the
  326. * bit [2] in CTRL register is used to indicate if regulator should be ON.
  327. */
  328. static const struct regulator_ops bd71837_buck34_ops_hwctrl = {
  329. .is_enabled = bd71837_get_buck34_enable_hwctrl,
  330. .list_voltage = regulator_list_voltage_linear_range,
  331. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  332. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  333. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  334. .set_ramp_delay = bd718xx_buck1234_set_ramp_delay,
  335. };
  336. /*
  337. * OPS for all of the ICs - BD718(37/47/50)
  338. */
  339. BD718XX_OPS(bd718xx_dvs_buck_regulator_ops, regulator_list_voltage_linear_range,
  340. NULL, regulator_set_voltage_sel_regmap,
  341. regulator_get_voltage_sel_regmap, regulator_set_voltage_time_sel,
  342. bd718xx_buck1234_set_ramp_delay);
  343. /*
  344. * BD71837 BUCK1/2/3/4
  345. * BD71847 BUCK1/2
  346. * 0.70 to 1.30V (10mV step)
  347. */
  348. static const struct linear_range bd718xx_dvs_buck_volts[] = {
  349. REGULATOR_LINEAR_RANGE(700000, 0x00, 0x3C, 10000),
  350. REGULATOR_LINEAR_RANGE(1300000, 0x3D, 0x3F, 0),
  351. };
  352. /*
  353. * BD71837 BUCK5
  354. * 0.7V to 1.35V (range 0)
  355. * and
  356. * 0.675 to 1.325 (range 1)
  357. */
  358. static const struct linear_range bd71837_buck5_volts[] = {
  359. /* Ranges when VOLT_SEL bit is 0 */
  360. REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
  361. REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
  362. REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
  363. /* Ranges when VOLT_SEL bit is 1 */
  364. REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
  365. REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
  366. REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
  367. };
  368. /*
  369. * Range selector for first 3 linear ranges is 0x0
  370. * and 0x1 for last 3 ranges.
  371. */
  372. static const unsigned int bd71837_buck5_volt_range_sel[] = {
  373. 0x0, 0x0, 0x0, 0x80, 0x80, 0x80
  374. };
  375. /*
  376. * BD71847 BUCK3
  377. */
  378. static const struct linear_range bd71847_buck3_volts[] = {
  379. /* Ranges when VOLT_SEL bits are 00 */
  380. REGULATOR_LINEAR_RANGE(700000, 0x00, 0x03, 100000),
  381. REGULATOR_LINEAR_RANGE(1050000, 0x04, 0x05, 50000),
  382. REGULATOR_LINEAR_RANGE(1200000, 0x06, 0x07, 150000),
  383. /* Ranges when VOLT_SEL bits are 01 */
  384. REGULATOR_LINEAR_RANGE(550000, 0x0, 0x7, 50000),
  385. /* Ranges when VOLT_SEL bits are 11 */
  386. REGULATOR_LINEAR_RANGE(675000, 0x0, 0x3, 100000),
  387. REGULATOR_LINEAR_RANGE(1025000, 0x4, 0x5, 50000),
  388. REGULATOR_LINEAR_RANGE(1175000, 0x6, 0x7, 150000),
  389. };
  390. static const unsigned int bd71847_buck3_volt_range_sel[] = {
  391. 0x0, 0x0, 0x0, 0x40, 0x80, 0x80, 0x80
  392. };
  393. static const struct linear_range bd71847_buck4_volts[] = {
  394. REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
  395. REGULATOR_LINEAR_RANGE(2600000, 0x00, 0x03, 100000),
  396. };
  397. static const unsigned int bd71847_buck4_volt_range_sel[] = { 0x0, 0x40 };
  398. /*
  399. * BUCK6
  400. * 3.0V to 3.3V (step 100mV)
  401. */
  402. static const struct linear_range bd71837_buck6_volts[] = {
  403. REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
  404. };
  405. /*
  406. * BD71837 BUCK7
  407. * BD71847 BUCK5
  408. * 000 = 1.605V
  409. * 001 = 1.695V
  410. * 010 = 1.755V
  411. * 011 = 1.8V (Initial)
  412. * 100 = 1.845V
  413. * 101 = 1.905V
  414. * 110 = 1.95V
  415. * 111 = 1.995V
  416. */
  417. static const unsigned int bd718xx_3rd_nodvs_buck_volts[] = {
  418. 1605000, 1695000, 1755000, 1800000, 1845000, 1905000, 1950000, 1995000
  419. };
  420. /*
  421. * BUCK8
  422. * 0.8V to 1.40V (step 10mV)
  423. */
  424. static const struct linear_range bd718xx_4th_nodvs_buck_volts[] = {
  425. REGULATOR_LINEAR_RANGE(800000, 0x00, 0x3C, 10000),
  426. };
  427. /*
  428. * LDO1
  429. * 3.0 to 3.3V (100mV step)
  430. */
  431. static const struct linear_range bd718xx_ldo1_volts[] = {
  432. REGULATOR_LINEAR_RANGE(3000000, 0x00, 0x03, 100000),
  433. REGULATOR_LINEAR_RANGE(1600000, 0x00, 0x03, 100000),
  434. };
  435. static const unsigned int bd718xx_ldo1_volt_range_sel[] = { 0x0, 0x20 };
  436. /*
  437. * LDO2
  438. * 0.8 or 0.9V
  439. */
  440. static const unsigned int ldo_2_volts[] = {
  441. 900000, 800000
  442. };
  443. /*
  444. * LDO3
  445. * 1.8 to 3.3V (100mV step)
  446. */
  447. static const struct linear_range bd718xx_ldo3_volts[] = {
  448. REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
  449. };
  450. /*
  451. * LDO4
  452. * 0.9 to 1.8V (100mV step)
  453. */
  454. static const struct linear_range bd718xx_ldo4_volts[] = {
  455. REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
  456. };
  457. /*
  458. * LDO5 for BD71837
  459. * 1.8 to 3.3V (100mV step)
  460. */
  461. static const struct linear_range bd71837_ldo5_volts[] = {
  462. REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
  463. };
  464. /*
  465. * LDO5 for BD71837
  466. * 1.8 to 3.3V (100mV step)
  467. */
  468. static const struct linear_range bd71847_ldo5_volts[] = {
  469. REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
  470. REGULATOR_LINEAR_RANGE(800000, 0x00, 0x0F, 100000),
  471. };
  472. static const unsigned int bd71847_ldo5_volt_range_sel[] = { 0x0, 0x20 };
  473. /*
  474. * LDO6
  475. * 0.9 to 1.8V (100mV step)
  476. */
  477. static const struct linear_range bd718xx_ldo6_volts[] = {
  478. REGULATOR_LINEAR_RANGE(900000, 0x00, 0x09, 100000),
  479. };
  480. /*
  481. * LDO7
  482. * 1.8 to 3.3V (100mV step)
  483. */
  484. static const struct linear_range bd71837_ldo7_volts[] = {
  485. REGULATOR_LINEAR_RANGE(1800000, 0x00, 0x0F, 100000),
  486. };
  487. struct reg_init {
  488. unsigned int reg;
  489. unsigned int mask;
  490. unsigned int val;
  491. };
  492. struct bd718xx_regulator_data {
  493. struct regulator_desc desc;
  494. const struct rohm_dvs_config dvs;
  495. const struct reg_init init;
  496. const struct reg_init *additional_inits;
  497. int additional_init_amnt;
  498. };
  499. /*
  500. * There is a HW quirk in BD71837. The shutdown sequence timings for
  501. * bucks/LDOs which are controlled via register interface are changed.
  502. * At PMIC poweroff the voltage for BUCK6/7 is cut immediately at the
  503. * beginning of shut-down sequence. As bucks 6 and 7 are parent
  504. * supplies for LDO5 and LDO6 - this causes LDO5/6 voltage
  505. * monitoring to errorneously detect under voltage and force PMIC to
  506. * emergency state instead of poweroff. In order to avoid this we
  507. * disable voltage monitoring for LDO5 and LDO6
  508. */
  509. static const struct reg_init bd71837_ldo5_inits[] = {
  510. {
  511. .reg = BD718XX_REG_MVRFLTMASK2,
  512. .mask = BD718XX_LDO5_VRMON80,
  513. .val = BD718XX_LDO5_VRMON80,
  514. },
  515. };
  516. static const struct reg_init bd71837_ldo6_inits[] = {
  517. {
  518. .reg = BD718XX_REG_MVRFLTMASK2,
  519. .mask = BD718XX_LDO6_VRMON80,
  520. .val = BD718XX_LDO6_VRMON80,
  521. },
  522. };
  523. static int buck_set_hw_dvs_levels(struct device_node *np,
  524. const struct regulator_desc *desc,
  525. struct regulator_config *cfg)
  526. {
  527. struct bd718xx_regulator_data *data;
  528. data = container_of(desc, struct bd718xx_regulator_data, desc);
  529. return rohm_regulator_set_dvs_levels(&data->dvs, np, desc, cfg->regmap);
  530. }
  531. static const struct regulator_ops *bd71847_swcontrol_ops[] = {
  532. &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
  533. &bd718xx_pickable_range_buck_ops, &bd718xx_pickable_range_buck_ops,
  534. &bd718xx_buck_regulator_nolinear_ops, &bd718xx_buck_regulator_ops,
  535. &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_nolinear_ops,
  536. &bd718xx_ldo_regulator_ops, &bd718xx_ldo_regulator_ops,
  537. &bd718xx_pickable_range_ldo_ops, &bd718xx_ldo_regulator_ops,
  538. };
  539. static const struct regulator_ops *bd71847_hwcontrol_ops[] = {
  540. &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
  541. &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
  542. &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops),
  543. &BD718XX_HWOPNAME(bd718xx_pickable_range_buck_ops),
  544. &BD718XX_HWOPNAME(bd718xx_buck_regulator_nolinear_ops),
  545. &BD718XX_HWOPNAME(bd718xx_buck_regulator_ops),
  546. &BD718XX_HWOPNAME(bd718xx_pickable_range_ldo_ops),
  547. &BD718XX_HWOPNAME(bd718xx_ldo_regulator_nolinear_ops),
  548. &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
  549. &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
  550. &bd718xx_ldo5_ops_hwstate,
  551. &BD718XX_HWOPNAME(bd718xx_ldo_regulator_ops),
  552. };
  553. static struct bd718xx_regulator_data bd71847_regulators[] = {
  554. {
  555. .desc = {
  556. .name = "buck1",
  557. .of_match = of_match_ptr("BUCK1"),
  558. .regulators_node = of_match_ptr("regulators"),
  559. .id = BD718XX_BUCK1,
  560. .type = REGULATOR_VOLTAGE,
  561. .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
  562. .linear_ranges = bd718xx_dvs_buck_volts,
  563. .n_linear_ranges =
  564. ARRAY_SIZE(bd718xx_dvs_buck_volts),
  565. .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
  566. .vsel_mask = DVS_BUCK_RUN_MASK,
  567. .enable_reg = BD718XX_REG_BUCK1_CTRL,
  568. .enable_mask = BD718XX_BUCK_EN,
  569. .enable_time = BD71847_BUCK1_STARTUP_TIME,
  570. .owner = THIS_MODULE,
  571. .of_parse_cb = buck_set_hw_dvs_levels,
  572. },
  573. .dvs = {
  574. .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
  575. ROHM_DVS_LEVEL_SUSPEND,
  576. .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
  577. .run_mask = DVS_BUCK_RUN_MASK,
  578. .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
  579. .idle_mask = DVS_BUCK_RUN_MASK,
  580. .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
  581. .suspend_mask = DVS_BUCK_RUN_MASK,
  582. },
  583. .init = {
  584. .reg = BD718XX_REG_BUCK1_CTRL,
  585. .mask = BD718XX_BUCK_SEL,
  586. .val = BD718XX_BUCK_SEL,
  587. },
  588. },
  589. {
  590. .desc = {
  591. .name = "buck2",
  592. .of_match = of_match_ptr("BUCK2"),
  593. .regulators_node = of_match_ptr("regulators"),
  594. .id = BD718XX_BUCK2,
  595. .type = REGULATOR_VOLTAGE,
  596. .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
  597. .linear_ranges = bd718xx_dvs_buck_volts,
  598. .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
  599. .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
  600. .vsel_mask = DVS_BUCK_RUN_MASK,
  601. .enable_reg = BD718XX_REG_BUCK2_CTRL,
  602. .enable_mask = BD718XX_BUCK_EN,
  603. .enable_time = BD71847_BUCK2_STARTUP_TIME,
  604. .owner = THIS_MODULE,
  605. .of_parse_cb = buck_set_hw_dvs_levels,
  606. },
  607. .dvs = {
  608. .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
  609. .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
  610. .run_mask = DVS_BUCK_RUN_MASK,
  611. .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
  612. .idle_mask = DVS_BUCK_RUN_MASK,
  613. },
  614. .init = {
  615. .reg = BD718XX_REG_BUCK2_CTRL,
  616. .mask = BD718XX_BUCK_SEL,
  617. .val = BD718XX_BUCK_SEL,
  618. },
  619. },
  620. {
  621. .desc = {
  622. .name = "buck3",
  623. .of_match = of_match_ptr("BUCK3"),
  624. .regulators_node = of_match_ptr("regulators"),
  625. .id = BD718XX_BUCK3,
  626. .type = REGULATOR_VOLTAGE,
  627. .n_voltages = BD71847_BUCK3_VOLTAGE_NUM,
  628. .linear_ranges = bd71847_buck3_volts,
  629. .n_linear_ranges =
  630. ARRAY_SIZE(bd71847_buck3_volts),
  631. .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
  632. .vsel_mask = BD718XX_1ST_NODVS_BUCK_MASK,
  633. .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
  634. .vsel_range_mask = BD71847_BUCK3_RANGE_MASK,
  635. .linear_range_selectors = bd71847_buck3_volt_range_sel,
  636. .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
  637. .enable_mask = BD718XX_BUCK_EN,
  638. .enable_time = BD71847_BUCK3_STARTUP_TIME,
  639. .owner = THIS_MODULE,
  640. },
  641. .init = {
  642. .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
  643. .mask = BD718XX_BUCK_SEL,
  644. .val = BD718XX_BUCK_SEL,
  645. },
  646. },
  647. {
  648. .desc = {
  649. .name = "buck4",
  650. .of_match = of_match_ptr("BUCK4"),
  651. .regulators_node = of_match_ptr("regulators"),
  652. .id = BD718XX_BUCK4,
  653. .type = REGULATOR_VOLTAGE,
  654. .n_voltages = BD71847_BUCK4_VOLTAGE_NUM,
  655. .linear_ranges = bd71847_buck4_volts,
  656. .n_linear_ranges =
  657. ARRAY_SIZE(bd71847_buck4_volts),
  658. .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
  659. .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
  660. .vsel_mask = BD71847_BUCK4_MASK,
  661. .vsel_range_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
  662. .vsel_range_mask = BD71847_BUCK4_RANGE_MASK,
  663. .linear_range_selectors = bd71847_buck4_volt_range_sel,
  664. .enable_mask = BD718XX_BUCK_EN,
  665. .enable_time = BD71847_BUCK4_STARTUP_TIME,
  666. .owner = THIS_MODULE,
  667. },
  668. .init = {
  669. .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
  670. .mask = BD718XX_BUCK_SEL,
  671. .val = BD718XX_BUCK_SEL,
  672. },
  673. },
  674. {
  675. .desc = {
  676. .name = "buck5",
  677. .of_match = of_match_ptr("BUCK5"),
  678. .regulators_node = of_match_ptr("regulators"),
  679. .id = BD718XX_BUCK5,
  680. .type = REGULATOR_VOLTAGE,
  681. .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
  682. .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
  683. .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
  684. .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
  685. .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
  686. .enable_mask = BD718XX_BUCK_EN,
  687. .enable_time = BD71847_BUCK5_STARTUP_TIME,
  688. .owner = THIS_MODULE,
  689. },
  690. .init = {
  691. .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
  692. .mask = BD718XX_BUCK_SEL,
  693. .val = BD718XX_BUCK_SEL,
  694. },
  695. },
  696. {
  697. .desc = {
  698. .name = "buck6",
  699. .of_match = of_match_ptr("BUCK6"),
  700. .regulators_node = of_match_ptr("regulators"),
  701. .id = BD718XX_BUCK6,
  702. .type = REGULATOR_VOLTAGE,
  703. .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
  704. .linear_ranges = bd718xx_4th_nodvs_buck_volts,
  705. .n_linear_ranges =
  706. ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
  707. .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
  708. .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
  709. .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
  710. .enable_mask = BD718XX_BUCK_EN,
  711. .enable_time = BD71847_BUCK6_STARTUP_TIME,
  712. .owner = THIS_MODULE,
  713. },
  714. .init = {
  715. .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
  716. .mask = BD718XX_BUCK_SEL,
  717. .val = BD718XX_BUCK_SEL,
  718. },
  719. },
  720. {
  721. .desc = {
  722. .name = "ldo1",
  723. .of_match = of_match_ptr("LDO1"),
  724. .regulators_node = of_match_ptr("regulators"),
  725. .id = BD718XX_LDO1,
  726. .type = REGULATOR_VOLTAGE,
  727. .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
  728. .linear_ranges = bd718xx_ldo1_volts,
  729. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
  730. .vsel_reg = BD718XX_REG_LDO1_VOLT,
  731. .vsel_mask = BD718XX_LDO1_MASK,
  732. .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
  733. .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
  734. .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
  735. .enable_reg = BD718XX_REG_LDO1_VOLT,
  736. .enable_mask = BD718XX_LDO_EN,
  737. .enable_time = BD71847_LDO1_STARTUP_TIME,
  738. .owner = THIS_MODULE,
  739. },
  740. .init = {
  741. .reg = BD718XX_REG_LDO1_VOLT,
  742. .mask = BD718XX_LDO_SEL,
  743. .val = BD718XX_LDO_SEL,
  744. },
  745. },
  746. {
  747. .desc = {
  748. .name = "ldo2",
  749. .of_match = of_match_ptr("LDO2"),
  750. .regulators_node = of_match_ptr("regulators"),
  751. .id = BD718XX_LDO2,
  752. .type = REGULATOR_VOLTAGE,
  753. .volt_table = &ldo_2_volts[0],
  754. .vsel_reg = BD718XX_REG_LDO2_VOLT,
  755. .vsel_mask = BD718XX_LDO2_MASK,
  756. .n_voltages = ARRAY_SIZE(ldo_2_volts),
  757. .enable_reg = BD718XX_REG_LDO2_VOLT,
  758. .enable_mask = BD718XX_LDO_EN,
  759. .enable_time = BD71847_LDO2_STARTUP_TIME,
  760. .owner = THIS_MODULE,
  761. },
  762. .init = {
  763. .reg = BD718XX_REG_LDO2_VOLT,
  764. .mask = BD718XX_LDO_SEL,
  765. .val = BD718XX_LDO_SEL,
  766. },
  767. },
  768. {
  769. .desc = {
  770. .name = "ldo3",
  771. .of_match = of_match_ptr("LDO3"),
  772. .regulators_node = of_match_ptr("regulators"),
  773. .id = BD718XX_LDO3,
  774. .type = REGULATOR_VOLTAGE,
  775. .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
  776. .linear_ranges = bd718xx_ldo3_volts,
  777. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
  778. .vsel_reg = BD718XX_REG_LDO3_VOLT,
  779. .vsel_mask = BD718XX_LDO3_MASK,
  780. .enable_reg = BD718XX_REG_LDO3_VOLT,
  781. .enable_mask = BD718XX_LDO_EN,
  782. .enable_time = BD71847_LDO3_STARTUP_TIME,
  783. .owner = THIS_MODULE,
  784. },
  785. .init = {
  786. .reg = BD718XX_REG_LDO3_VOLT,
  787. .mask = BD718XX_LDO_SEL,
  788. .val = BD718XX_LDO_SEL,
  789. },
  790. },
  791. {
  792. .desc = {
  793. .name = "ldo4",
  794. .of_match = of_match_ptr("LDO4"),
  795. .regulators_node = of_match_ptr("regulators"),
  796. .id = BD718XX_LDO4,
  797. .type = REGULATOR_VOLTAGE,
  798. .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
  799. .linear_ranges = bd718xx_ldo4_volts,
  800. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
  801. .vsel_reg = BD718XX_REG_LDO4_VOLT,
  802. .vsel_mask = BD718XX_LDO4_MASK,
  803. .enable_reg = BD718XX_REG_LDO4_VOLT,
  804. .enable_mask = BD718XX_LDO_EN,
  805. .enable_time = BD71847_LDO4_STARTUP_TIME,
  806. .owner = THIS_MODULE,
  807. },
  808. .init = {
  809. .reg = BD718XX_REG_LDO4_VOLT,
  810. .mask = BD718XX_LDO_SEL,
  811. .val = BD718XX_LDO_SEL,
  812. },
  813. },
  814. {
  815. .desc = {
  816. .name = "ldo5",
  817. .of_match = of_match_ptr("LDO5"),
  818. .regulators_node = of_match_ptr("regulators"),
  819. .id = BD718XX_LDO5,
  820. .type = REGULATOR_VOLTAGE,
  821. .n_voltages = BD71847_LDO5_VOLTAGE_NUM,
  822. .linear_ranges = bd71847_ldo5_volts,
  823. .n_linear_ranges = ARRAY_SIZE(bd71847_ldo5_volts),
  824. .vsel_reg = BD718XX_REG_LDO5_VOLT,
  825. .vsel_mask = BD71847_LDO5_MASK,
  826. .vsel_range_reg = BD718XX_REG_LDO5_VOLT,
  827. .vsel_range_mask = BD71847_LDO5_RANGE_MASK,
  828. .linear_range_selectors = bd71847_ldo5_volt_range_sel,
  829. .enable_reg = BD718XX_REG_LDO5_VOLT,
  830. .enable_mask = BD718XX_LDO_EN,
  831. .enable_time = BD71847_LDO5_STARTUP_TIME,
  832. .owner = THIS_MODULE,
  833. },
  834. .init = {
  835. .reg = BD718XX_REG_LDO5_VOLT,
  836. .mask = BD718XX_LDO_SEL,
  837. .val = BD718XX_LDO_SEL,
  838. },
  839. },
  840. {
  841. .desc = {
  842. .name = "ldo6",
  843. .of_match = of_match_ptr("LDO6"),
  844. .regulators_node = of_match_ptr("regulators"),
  845. .id = BD718XX_LDO6,
  846. .type = REGULATOR_VOLTAGE,
  847. .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
  848. .linear_ranges = bd718xx_ldo6_volts,
  849. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
  850. /* LDO6 is supplied by buck5 */
  851. .supply_name = "buck5",
  852. .vsel_reg = BD718XX_REG_LDO6_VOLT,
  853. .vsel_mask = BD718XX_LDO6_MASK,
  854. .enable_reg = BD718XX_REG_LDO6_VOLT,
  855. .enable_mask = BD718XX_LDO_EN,
  856. .enable_time = BD71847_LDO6_STARTUP_TIME,
  857. .owner = THIS_MODULE,
  858. },
  859. .init = {
  860. .reg = BD718XX_REG_LDO6_VOLT,
  861. .mask = BD718XX_LDO_SEL,
  862. .val = BD718XX_LDO_SEL,
  863. },
  864. },
  865. };
  866. static const struct regulator_ops *bd71837_swcontrol_ops[] = {
  867. &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
  868. &bd718xx_dvs_buck_regulator_ops, &bd718xx_dvs_buck_regulator_ops,
  869. &bd71837_pickable_range_buck_ops, &bd71837_buck_regulator_ops,
  870. &bd71837_buck_regulator_nolinear_ops, &bd71837_buck_regulator_ops,
  871. &bd71837_pickable_range_ldo_ops, &bd71837_ldo_regulator_nolinear_ops,
  872. &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops,
  873. &bd71837_ldo_regulator_ops, &bd71837_ldo_regulator_ops,
  874. &bd71837_ldo_regulator_ops,
  875. };
  876. static const struct regulator_ops *bd71837_hwcontrol_ops[] = {
  877. &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
  878. &BD718XX_HWOPNAME(bd718xx_dvs_buck_regulator_ops),
  879. &bd71837_buck34_ops_hwctrl, &bd71837_buck34_ops_hwctrl,
  880. &BD718XX_HWOPNAME(bd71837_pickable_range_buck_ops),
  881. &BD718XX_HWOPNAME(bd71837_buck_regulator_ops),
  882. &BD718XX_HWOPNAME(bd71837_buck_regulator_nolinear_ops),
  883. &BD718XX_HWOPNAME(bd71837_buck_regulator_ops),
  884. &BD718XX_HWOPNAME(bd71837_pickable_range_ldo_ops),
  885. &BD718XX_HWOPNAME(bd71837_ldo_regulator_nolinear_ops),
  886. &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
  887. &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
  888. &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
  889. &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
  890. &BD718XX_HWOPNAME(bd71837_ldo_regulator_ops),
  891. };
  892. static struct bd718xx_regulator_data bd71837_regulators[] = {
  893. {
  894. .desc = {
  895. .name = "buck1",
  896. .of_match = of_match_ptr("BUCK1"),
  897. .regulators_node = of_match_ptr("regulators"),
  898. .id = BD718XX_BUCK1,
  899. .type = REGULATOR_VOLTAGE,
  900. .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
  901. .linear_ranges = bd718xx_dvs_buck_volts,
  902. .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
  903. .vsel_reg = BD718XX_REG_BUCK1_VOLT_RUN,
  904. .vsel_mask = DVS_BUCK_RUN_MASK,
  905. .enable_reg = BD718XX_REG_BUCK1_CTRL,
  906. .enable_mask = BD718XX_BUCK_EN,
  907. .enable_time = BD71837_BUCK1_STARTUP_TIME,
  908. .owner = THIS_MODULE,
  909. .of_parse_cb = buck_set_hw_dvs_levels,
  910. },
  911. .dvs = {
  912. .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE |
  913. ROHM_DVS_LEVEL_SUSPEND,
  914. .run_reg = BD718XX_REG_BUCK1_VOLT_RUN,
  915. .run_mask = DVS_BUCK_RUN_MASK,
  916. .idle_reg = BD718XX_REG_BUCK1_VOLT_IDLE,
  917. .idle_mask = DVS_BUCK_RUN_MASK,
  918. .suspend_reg = BD718XX_REG_BUCK1_VOLT_SUSP,
  919. .suspend_mask = DVS_BUCK_RUN_MASK,
  920. },
  921. .init = {
  922. .reg = BD718XX_REG_BUCK1_CTRL,
  923. .mask = BD718XX_BUCK_SEL,
  924. .val = BD718XX_BUCK_SEL,
  925. },
  926. },
  927. {
  928. .desc = {
  929. .name = "buck2",
  930. .of_match = of_match_ptr("BUCK2"),
  931. .regulators_node = of_match_ptr("regulators"),
  932. .id = BD718XX_BUCK2,
  933. .type = REGULATOR_VOLTAGE,
  934. .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
  935. .linear_ranges = bd718xx_dvs_buck_volts,
  936. .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
  937. .vsel_reg = BD718XX_REG_BUCK2_VOLT_RUN,
  938. .vsel_mask = DVS_BUCK_RUN_MASK,
  939. .enable_reg = BD718XX_REG_BUCK2_CTRL,
  940. .enable_mask = BD718XX_BUCK_EN,
  941. .enable_time = BD71837_BUCK2_STARTUP_TIME,
  942. .owner = THIS_MODULE,
  943. .of_parse_cb = buck_set_hw_dvs_levels,
  944. },
  945. .dvs = {
  946. .level_map = ROHM_DVS_LEVEL_RUN | ROHM_DVS_LEVEL_IDLE,
  947. .run_reg = BD718XX_REG_BUCK2_VOLT_RUN,
  948. .run_mask = DVS_BUCK_RUN_MASK,
  949. .idle_reg = BD718XX_REG_BUCK2_VOLT_IDLE,
  950. .idle_mask = DVS_BUCK_RUN_MASK,
  951. },
  952. .init = {
  953. .reg = BD718XX_REG_BUCK2_CTRL,
  954. .mask = BD718XX_BUCK_SEL,
  955. .val = BD718XX_BUCK_SEL,
  956. },
  957. },
  958. {
  959. .desc = {
  960. .name = "buck3",
  961. .of_match = of_match_ptr("BUCK3"),
  962. .regulators_node = of_match_ptr("regulators"),
  963. .id = BD718XX_BUCK3,
  964. .type = REGULATOR_VOLTAGE,
  965. .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
  966. .linear_ranges = bd718xx_dvs_buck_volts,
  967. .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
  968. .vsel_reg = BD71837_REG_BUCK3_VOLT_RUN,
  969. .vsel_mask = DVS_BUCK_RUN_MASK,
  970. .enable_reg = BD71837_REG_BUCK3_CTRL,
  971. .enable_mask = BD718XX_BUCK_EN,
  972. .enable_time = BD71837_BUCK3_STARTUP_TIME,
  973. .owner = THIS_MODULE,
  974. .of_parse_cb = buck_set_hw_dvs_levels,
  975. },
  976. .dvs = {
  977. .level_map = ROHM_DVS_LEVEL_RUN,
  978. .run_reg = BD71837_REG_BUCK3_VOLT_RUN,
  979. .run_mask = DVS_BUCK_RUN_MASK,
  980. },
  981. .init = {
  982. .reg = BD71837_REG_BUCK3_CTRL,
  983. .mask = BD718XX_BUCK_SEL,
  984. .val = BD718XX_BUCK_SEL,
  985. },
  986. },
  987. {
  988. .desc = {
  989. .name = "buck4",
  990. .of_match = of_match_ptr("BUCK4"),
  991. .regulators_node = of_match_ptr("regulators"),
  992. .id = BD718XX_BUCK4,
  993. .type = REGULATOR_VOLTAGE,
  994. .n_voltages = BD718XX_DVS_BUCK_VOLTAGE_NUM,
  995. .linear_ranges = bd718xx_dvs_buck_volts,
  996. .n_linear_ranges = ARRAY_SIZE(bd718xx_dvs_buck_volts),
  997. .vsel_reg = BD71837_REG_BUCK4_VOLT_RUN,
  998. .vsel_mask = DVS_BUCK_RUN_MASK,
  999. .enable_reg = BD71837_REG_BUCK4_CTRL,
  1000. .enable_mask = BD718XX_BUCK_EN,
  1001. .enable_time = BD71837_BUCK4_STARTUP_TIME,
  1002. .owner = THIS_MODULE,
  1003. .of_parse_cb = buck_set_hw_dvs_levels,
  1004. },
  1005. .dvs = {
  1006. .level_map = ROHM_DVS_LEVEL_RUN,
  1007. .run_reg = BD71837_REG_BUCK4_VOLT_RUN,
  1008. .run_mask = DVS_BUCK_RUN_MASK,
  1009. },
  1010. .init = {
  1011. .reg = BD71837_REG_BUCK4_CTRL,
  1012. .mask = BD718XX_BUCK_SEL,
  1013. .val = BD718XX_BUCK_SEL,
  1014. },
  1015. },
  1016. {
  1017. .desc = {
  1018. .name = "buck5",
  1019. .of_match = of_match_ptr("BUCK5"),
  1020. .regulators_node = of_match_ptr("regulators"),
  1021. .id = BD718XX_BUCK5,
  1022. .type = REGULATOR_VOLTAGE,
  1023. .n_voltages = BD71837_BUCK5_VOLTAGE_NUM,
  1024. .linear_ranges = bd71837_buck5_volts,
  1025. .n_linear_ranges =
  1026. ARRAY_SIZE(bd71837_buck5_volts),
  1027. .vsel_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
  1028. .vsel_mask = BD71837_BUCK5_MASK,
  1029. .vsel_range_reg = BD718XX_REG_1ST_NODVS_BUCK_VOLT,
  1030. .vsel_range_mask = BD71837_BUCK5_RANGE_MASK,
  1031. .linear_range_selectors = bd71837_buck5_volt_range_sel,
  1032. .enable_reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
  1033. .enable_mask = BD718XX_BUCK_EN,
  1034. .enable_time = BD71837_BUCK5_STARTUP_TIME,
  1035. .owner = THIS_MODULE,
  1036. },
  1037. .init = {
  1038. .reg = BD718XX_REG_1ST_NODVS_BUCK_CTRL,
  1039. .mask = BD718XX_BUCK_SEL,
  1040. .val = BD718XX_BUCK_SEL,
  1041. },
  1042. },
  1043. {
  1044. .desc = {
  1045. .name = "buck6",
  1046. .of_match = of_match_ptr("BUCK6"),
  1047. .regulators_node = of_match_ptr("regulators"),
  1048. .id = BD718XX_BUCK6,
  1049. .type = REGULATOR_VOLTAGE,
  1050. .n_voltages = BD71837_BUCK6_VOLTAGE_NUM,
  1051. .linear_ranges = bd71837_buck6_volts,
  1052. .n_linear_ranges =
  1053. ARRAY_SIZE(bd71837_buck6_volts),
  1054. .vsel_reg = BD718XX_REG_2ND_NODVS_BUCK_VOLT,
  1055. .vsel_mask = BD71837_BUCK6_MASK,
  1056. .enable_reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
  1057. .enable_mask = BD718XX_BUCK_EN,
  1058. .enable_time = BD71837_BUCK6_STARTUP_TIME,
  1059. .owner = THIS_MODULE,
  1060. },
  1061. .init = {
  1062. .reg = BD718XX_REG_2ND_NODVS_BUCK_CTRL,
  1063. .mask = BD718XX_BUCK_SEL,
  1064. .val = BD718XX_BUCK_SEL,
  1065. },
  1066. },
  1067. {
  1068. .desc = {
  1069. .name = "buck7",
  1070. .of_match = of_match_ptr("BUCK7"),
  1071. .regulators_node = of_match_ptr("regulators"),
  1072. .id = BD718XX_BUCK7,
  1073. .type = REGULATOR_VOLTAGE,
  1074. .volt_table = &bd718xx_3rd_nodvs_buck_volts[0],
  1075. .n_voltages = ARRAY_SIZE(bd718xx_3rd_nodvs_buck_volts),
  1076. .vsel_reg = BD718XX_REG_3RD_NODVS_BUCK_VOLT,
  1077. .vsel_mask = BD718XX_3RD_NODVS_BUCK_MASK,
  1078. .enable_reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
  1079. .enable_mask = BD718XX_BUCK_EN,
  1080. .enable_time = BD71837_BUCK7_STARTUP_TIME,
  1081. .owner = THIS_MODULE,
  1082. },
  1083. .init = {
  1084. .reg = BD718XX_REG_3RD_NODVS_BUCK_CTRL,
  1085. .mask = BD718XX_BUCK_SEL,
  1086. .val = BD718XX_BUCK_SEL,
  1087. },
  1088. },
  1089. {
  1090. .desc = {
  1091. .name = "buck8",
  1092. .of_match = of_match_ptr("BUCK8"),
  1093. .regulators_node = of_match_ptr("regulators"),
  1094. .id = BD718XX_BUCK8,
  1095. .type = REGULATOR_VOLTAGE,
  1096. .n_voltages = BD718XX_4TH_NODVS_BUCK_VOLTAGE_NUM,
  1097. .linear_ranges = bd718xx_4th_nodvs_buck_volts,
  1098. .n_linear_ranges =
  1099. ARRAY_SIZE(bd718xx_4th_nodvs_buck_volts),
  1100. .vsel_reg = BD718XX_REG_4TH_NODVS_BUCK_VOLT,
  1101. .vsel_mask = BD718XX_4TH_NODVS_BUCK_MASK,
  1102. .enable_reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
  1103. .enable_mask = BD718XX_BUCK_EN,
  1104. .enable_time = BD71837_BUCK8_STARTUP_TIME,
  1105. .owner = THIS_MODULE,
  1106. },
  1107. .init = {
  1108. .reg = BD718XX_REG_4TH_NODVS_BUCK_CTRL,
  1109. .mask = BD718XX_BUCK_SEL,
  1110. .val = BD718XX_BUCK_SEL,
  1111. },
  1112. },
  1113. {
  1114. .desc = {
  1115. .name = "ldo1",
  1116. .of_match = of_match_ptr("LDO1"),
  1117. .regulators_node = of_match_ptr("regulators"),
  1118. .id = BD718XX_LDO1,
  1119. .type = REGULATOR_VOLTAGE,
  1120. .n_voltages = BD718XX_LDO1_VOLTAGE_NUM,
  1121. .linear_ranges = bd718xx_ldo1_volts,
  1122. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo1_volts),
  1123. .vsel_reg = BD718XX_REG_LDO1_VOLT,
  1124. .vsel_mask = BD718XX_LDO1_MASK,
  1125. .vsel_range_reg = BD718XX_REG_LDO1_VOLT,
  1126. .vsel_range_mask = BD718XX_LDO1_RANGE_MASK,
  1127. .linear_range_selectors = bd718xx_ldo1_volt_range_sel,
  1128. .enable_reg = BD718XX_REG_LDO1_VOLT,
  1129. .enable_mask = BD718XX_LDO_EN,
  1130. .enable_time = BD71837_LDO1_STARTUP_TIME,
  1131. .owner = THIS_MODULE,
  1132. },
  1133. .init = {
  1134. .reg = BD718XX_REG_LDO1_VOLT,
  1135. .mask = BD718XX_LDO_SEL,
  1136. .val = BD718XX_LDO_SEL,
  1137. },
  1138. },
  1139. {
  1140. .desc = {
  1141. .name = "ldo2",
  1142. .of_match = of_match_ptr("LDO2"),
  1143. .regulators_node = of_match_ptr("regulators"),
  1144. .id = BD718XX_LDO2,
  1145. .type = REGULATOR_VOLTAGE,
  1146. .volt_table = &ldo_2_volts[0],
  1147. .vsel_reg = BD718XX_REG_LDO2_VOLT,
  1148. .vsel_mask = BD718XX_LDO2_MASK,
  1149. .n_voltages = ARRAY_SIZE(ldo_2_volts),
  1150. .enable_reg = BD718XX_REG_LDO2_VOLT,
  1151. .enable_mask = BD718XX_LDO_EN,
  1152. .enable_time = BD71837_LDO2_STARTUP_TIME,
  1153. .owner = THIS_MODULE,
  1154. },
  1155. .init = {
  1156. .reg = BD718XX_REG_LDO2_VOLT,
  1157. .mask = BD718XX_LDO_SEL,
  1158. .val = BD718XX_LDO_SEL,
  1159. },
  1160. },
  1161. {
  1162. .desc = {
  1163. .name = "ldo3",
  1164. .of_match = of_match_ptr("LDO3"),
  1165. .regulators_node = of_match_ptr("regulators"),
  1166. .id = BD718XX_LDO3,
  1167. .type = REGULATOR_VOLTAGE,
  1168. .n_voltages = BD718XX_LDO3_VOLTAGE_NUM,
  1169. .linear_ranges = bd718xx_ldo3_volts,
  1170. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo3_volts),
  1171. .vsel_reg = BD718XX_REG_LDO3_VOLT,
  1172. .vsel_mask = BD718XX_LDO3_MASK,
  1173. .enable_reg = BD718XX_REG_LDO3_VOLT,
  1174. .enable_mask = BD718XX_LDO_EN,
  1175. .enable_time = BD71837_LDO3_STARTUP_TIME,
  1176. .owner = THIS_MODULE,
  1177. },
  1178. .init = {
  1179. .reg = BD718XX_REG_LDO3_VOLT,
  1180. .mask = BD718XX_LDO_SEL,
  1181. .val = BD718XX_LDO_SEL,
  1182. },
  1183. },
  1184. {
  1185. .desc = {
  1186. .name = "ldo4",
  1187. .of_match = of_match_ptr("LDO4"),
  1188. .regulators_node = of_match_ptr("regulators"),
  1189. .id = BD718XX_LDO4,
  1190. .type = REGULATOR_VOLTAGE,
  1191. .n_voltages = BD718XX_LDO4_VOLTAGE_NUM,
  1192. .linear_ranges = bd718xx_ldo4_volts,
  1193. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo4_volts),
  1194. .vsel_reg = BD718XX_REG_LDO4_VOLT,
  1195. .vsel_mask = BD718XX_LDO4_MASK,
  1196. .enable_reg = BD718XX_REG_LDO4_VOLT,
  1197. .enable_mask = BD718XX_LDO_EN,
  1198. .enable_time = BD71837_LDO4_STARTUP_TIME,
  1199. .owner = THIS_MODULE,
  1200. },
  1201. .init = {
  1202. .reg = BD718XX_REG_LDO4_VOLT,
  1203. .mask = BD718XX_LDO_SEL,
  1204. .val = BD718XX_LDO_SEL,
  1205. },
  1206. },
  1207. {
  1208. .desc = {
  1209. .name = "ldo5",
  1210. .of_match = of_match_ptr("LDO5"),
  1211. .regulators_node = of_match_ptr("regulators"),
  1212. .id = BD718XX_LDO5,
  1213. .type = REGULATOR_VOLTAGE,
  1214. .n_voltages = BD71837_LDO5_VOLTAGE_NUM,
  1215. .linear_ranges = bd71837_ldo5_volts,
  1216. .n_linear_ranges = ARRAY_SIZE(bd71837_ldo5_volts),
  1217. /* LDO5 is supplied by buck6 */
  1218. .supply_name = "buck6",
  1219. .vsel_reg = BD718XX_REG_LDO5_VOLT,
  1220. .vsel_mask = BD71837_LDO5_MASK,
  1221. .enable_reg = BD718XX_REG_LDO5_VOLT,
  1222. .enable_mask = BD718XX_LDO_EN,
  1223. .enable_time = BD71837_LDO5_STARTUP_TIME,
  1224. .owner = THIS_MODULE,
  1225. },
  1226. .init = {
  1227. .reg = BD718XX_REG_LDO5_VOLT,
  1228. .mask = BD718XX_LDO_SEL,
  1229. .val = BD718XX_LDO_SEL,
  1230. },
  1231. .additional_inits = bd71837_ldo5_inits,
  1232. .additional_init_amnt = ARRAY_SIZE(bd71837_ldo5_inits),
  1233. },
  1234. {
  1235. .desc = {
  1236. .name = "ldo6",
  1237. .of_match = of_match_ptr("LDO6"),
  1238. .regulators_node = of_match_ptr("regulators"),
  1239. .id = BD718XX_LDO6,
  1240. .type = REGULATOR_VOLTAGE,
  1241. .n_voltages = BD718XX_LDO6_VOLTAGE_NUM,
  1242. .linear_ranges = bd718xx_ldo6_volts,
  1243. .n_linear_ranges = ARRAY_SIZE(bd718xx_ldo6_volts),
  1244. /* LDO6 is supplied by buck7 */
  1245. .supply_name = "buck7",
  1246. .vsel_reg = BD718XX_REG_LDO6_VOLT,
  1247. .vsel_mask = BD718XX_LDO6_MASK,
  1248. .enable_reg = BD718XX_REG_LDO6_VOLT,
  1249. .enable_mask = BD718XX_LDO_EN,
  1250. .enable_time = BD71837_LDO6_STARTUP_TIME,
  1251. .owner = THIS_MODULE,
  1252. },
  1253. .init = {
  1254. .reg = BD718XX_REG_LDO6_VOLT,
  1255. .mask = BD718XX_LDO_SEL,
  1256. .val = BD718XX_LDO_SEL,
  1257. },
  1258. .additional_inits = bd71837_ldo6_inits,
  1259. .additional_init_amnt = ARRAY_SIZE(bd71837_ldo6_inits),
  1260. },
  1261. {
  1262. .desc = {
  1263. .name = "ldo7",
  1264. .of_match = of_match_ptr("LDO7"),
  1265. .regulators_node = of_match_ptr("regulators"),
  1266. .id = BD718XX_LDO7,
  1267. .type = REGULATOR_VOLTAGE,
  1268. .n_voltages = BD71837_LDO7_VOLTAGE_NUM,
  1269. .linear_ranges = bd71837_ldo7_volts,
  1270. .n_linear_ranges = ARRAY_SIZE(bd71837_ldo7_volts),
  1271. .vsel_reg = BD71837_REG_LDO7_VOLT,
  1272. .vsel_mask = BD71837_LDO7_MASK,
  1273. .enable_reg = BD71837_REG_LDO7_VOLT,
  1274. .enable_mask = BD718XX_LDO_EN,
  1275. .enable_time = BD71837_LDO7_STARTUP_TIME,
  1276. .owner = THIS_MODULE,
  1277. },
  1278. .init = {
  1279. .reg = BD71837_REG_LDO7_VOLT,
  1280. .mask = BD718XX_LDO_SEL,
  1281. .val = BD718XX_LDO_SEL,
  1282. },
  1283. },
  1284. };
  1285. static void mark_hw_controlled(struct device *dev, struct device_node *np,
  1286. struct bd718xx_regulator_data *reg_data,
  1287. unsigned int num_reg_data, int *info)
  1288. {
  1289. int i;
  1290. for (i = 1; i <= num_reg_data; i++) {
  1291. if (!of_node_name_eq(np, reg_data[i-1].desc.of_match))
  1292. continue;
  1293. *info |= 1 << (i - 1);
  1294. dev_dbg(dev, "regulator %d runlevel controlled\n", i);
  1295. return;
  1296. }
  1297. dev_warn(dev, "Bad regulator node\n");
  1298. }
  1299. static int get_hw_controlled_regulators(struct device *dev,
  1300. struct bd718xx_regulator_data *reg_data,
  1301. unsigned int num_reg_data, int *info)
  1302. {
  1303. struct device_node *np;
  1304. struct device_node *nproot = dev->of_node;
  1305. const char *prop = "rohm,no-regulator-enable-control";
  1306. *info = 0;
  1307. nproot = of_get_child_by_name(nproot, "regulators");
  1308. if (!nproot) {
  1309. dev_err(dev, "failed to find regulators node\n");
  1310. return -ENODEV;
  1311. }
  1312. for_each_child_of_node(nproot, np)
  1313. if (of_property_read_bool(np, prop))
  1314. mark_hw_controlled(dev, np, reg_data, num_reg_data,
  1315. info);
  1316. of_node_put(nproot);
  1317. return 0;
  1318. }
  1319. static int bd718xx_probe(struct platform_device *pdev)
  1320. {
  1321. struct bd718xx *mfd;
  1322. struct regulator_config config = { 0 };
  1323. int i, j, err, omit_enable;
  1324. bool use_snvs;
  1325. struct bd718xx_regulator_data *reg_data;
  1326. unsigned int num_reg_data;
  1327. enum rohm_chip_type chip = platform_get_device_id(pdev)->driver_data;
  1328. const struct regulator_ops **swops, **hwops;
  1329. mfd = dev_get_drvdata(pdev->dev.parent);
  1330. if (!mfd) {
  1331. dev_err(&pdev->dev, "No MFD driver data\n");
  1332. err = -EINVAL;
  1333. goto err;
  1334. }
  1335. switch (chip) {
  1336. case ROHM_CHIP_TYPE_BD71837:
  1337. reg_data = bd71837_regulators;
  1338. num_reg_data = ARRAY_SIZE(bd71837_regulators);
  1339. swops = &bd71837_swcontrol_ops[0];
  1340. hwops = &bd71837_hwcontrol_ops[0];
  1341. break;
  1342. case ROHM_CHIP_TYPE_BD71847:
  1343. reg_data = bd71847_regulators;
  1344. num_reg_data = ARRAY_SIZE(bd71847_regulators);
  1345. swops = &bd71847_swcontrol_ops[0];
  1346. hwops = &bd71847_hwcontrol_ops[0];
  1347. break;
  1348. default:
  1349. dev_err(&pdev->dev, "Unsupported chip type\n");
  1350. err = -EINVAL;
  1351. goto err;
  1352. }
  1353. /* Register LOCK release */
  1354. err = regmap_update_bits(mfd->chip.regmap, BD718XX_REG_REGLOCK,
  1355. (REGLOCK_PWRSEQ | REGLOCK_VREG), 0);
  1356. if (err) {
  1357. dev_err(&pdev->dev, "Failed to unlock PMIC (%d)\n", err);
  1358. goto err;
  1359. } else {
  1360. dev_dbg(&pdev->dev, "Unlocked lock register 0x%x\n",
  1361. BD718XX_REG_REGLOCK);
  1362. }
  1363. use_snvs = of_property_read_bool(pdev->dev.parent->of_node,
  1364. "rohm,reset-snvs-powered");
  1365. /*
  1366. * Change the next stage from poweroff to be READY instead of SNVS
  1367. * for all reset types because OTP loading at READY will clear SEL
  1368. * bit allowing HW defaults for power rails to be used
  1369. */
  1370. if (!use_snvs) {
  1371. err = regmap_update_bits(mfd->chip.regmap,
  1372. BD718XX_REG_TRANS_COND1,
  1373. BD718XX_ON_REQ_POWEROFF_MASK |
  1374. BD718XX_SWRESET_POWEROFF_MASK |
  1375. BD718XX_WDOG_POWEROFF_MASK |
  1376. BD718XX_KEY_L_POWEROFF_MASK,
  1377. BD718XX_POWOFF_TO_RDY);
  1378. if (err) {
  1379. dev_err(&pdev->dev, "Failed to change reset target\n");
  1380. goto err;
  1381. } else {
  1382. dev_dbg(&pdev->dev,
  1383. "Changed all resets from SVNS to READY\n");
  1384. }
  1385. }
  1386. config.dev = pdev->dev.parent;
  1387. config.regmap = mfd->chip.regmap;
  1388. /*
  1389. * There are cases when we want to leave the enable-control for
  1390. * the HW state machine and use this driver only for voltage control.
  1391. * One special case is when we use PMIC_STBY_REQ line from SoC to PMIC
  1392. * in order to set the system to SUSPEND state.
  1393. *
  1394. * If regulator is taken under SW control the regulator state will not
  1395. * be affected by PMIC state machine - Eg. regulator is likely to stay
  1396. * on even in SUSPEND
  1397. */
  1398. get_hw_controlled_regulators(pdev->dev.parent, reg_data, num_reg_data,
  1399. &omit_enable);
  1400. for (i = 0; i < num_reg_data; i++) {
  1401. struct regulator_desc *desc;
  1402. struct regulator_dev *rdev;
  1403. struct bd718xx_regulator_data *r;
  1404. int no_enable_control = omit_enable & (1 << i);
  1405. r = &reg_data[i];
  1406. desc = &r->desc;
  1407. if (no_enable_control)
  1408. desc->ops = hwops[i];
  1409. else
  1410. desc->ops = swops[i];
  1411. rdev = devm_regulator_register(&pdev->dev, desc, &config);
  1412. if (IS_ERR(rdev)) {
  1413. dev_err(&pdev->dev,
  1414. "failed to register %s regulator\n",
  1415. desc->name);
  1416. err = PTR_ERR(rdev);
  1417. goto err;
  1418. }
  1419. /*
  1420. * Regulator register gets the regulator constraints and
  1421. * applies them (set_machine_constraints). This should have
  1422. * turned the control register(s) to correct values and we
  1423. * can now switch the control from PMIC state machine to the
  1424. * register interface
  1425. *
  1426. * At poweroff transition PMIC HW disables EN bit for
  1427. * regulators but leaves SEL bit untouched. So if state
  1428. * transition from POWEROFF is done to SNVS - then all power
  1429. * rails controlled by SW (having SEL bit set) stay disabled
  1430. * as EN is cleared. This will result boot failure if any
  1431. * crucial systems are powered by these rails. We don't
  1432. * enable SW control for crucial regulators if snvs state is
  1433. * used
  1434. */
  1435. if (!no_enable_control && (!use_snvs ||
  1436. !rdev->constraints->always_on ||
  1437. !rdev->constraints->boot_on)) {
  1438. err = regmap_update_bits(mfd->chip.regmap, r->init.reg,
  1439. r->init.mask, r->init.val);
  1440. if (err) {
  1441. dev_err(&pdev->dev,
  1442. "Failed to take control for (%s)\n",
  1443. desc->name);
  1444. goto err;
  1445. }
  1446. }
  1447. for (j = 0; j < r->additional_init_amnt; j++) {
  1448. err = regmap_update_bits(mfd->chip.regmap,
  1449. r->additional_inits[j].reg,
  1450. r->additional_inits[j].mask,
  1451. r->additional_inits[j].val);
  1452. if (err) {
  1453. dev_err(&pdev->dev,
  1454. "Buck (%s) initialization failed\n",
  1455. desc->name);
  1456. goto err;
  1457. }
  1458. }
  1459. }
  1460. err:
  1461. return err;
  1462. }
  1463. static const struct platform_device_id bd718x7_pmic_id[] = {
  1464. { "bd71837-pmic", ROHM_CHIP_TYPE_BD71837 },
  1465. { "bd71847-pmic", ROHM_CHIP_TYPE_BD71847 },
  1466. { },
  1467. };
  1468. MODULE_DEVICE_TABLE(platform, bd718x7_pmic_id);
  1469. static struct platform_driver bd718xx_regulator = {
  1470. .driver = {
  1471. .name = "bd718xx-pmic",
  1472. },
  1473. .probe = bd718xx_probe,
  1474. .id_table = bd718x7_pmic_id,
  1475. };
  1476. module_platform_driver(bd718xx_regulator);
  1477. MODULE_AUTHOR("Matti Vaittinen <matti.vaittinen@fi.rohmeurope.com>");
  1478. MODULE_DESCRIPTION("BD71837/BD71847 voltage regulator driver");
  1479. MODULE_LICENSE("GPL");
  1480. MODULE_ALIAS("platform:bd718xx-pmic");