rk808-regulator.c 43 KB

1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351135213531354135513561357135813591360136113621363136413651366136713681369137013711372137313741375137613771378137913801381
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Regulator driver for Rockchip RK805/RK808/RK818
  4. *
  5. * Copyright (c) 2014, Fuzhou Rockchip Electronics Co., Ltd
  6. *
  7. * Author: Chris Zhong <zyw@rock-chips.com>
  8. * Author: Zhang Qing <zhangqing@rock-chips.com>
  9. *
  10. * Copyright (C) 2016 PHYTEC Messtechnik GmbH
  11. *
  12. * Author: Wadim Egorov <w.egorov@phytec.de>
  13. */
  14. #include <linux/delay.h>
  15. #include <linux/gpio.h>
  16. #include <linux/i2c.h>
  17. #include <linux/module.h>
  18. #include <linux/of_device.h>
  19. #include <linux/of_gpio.h>
  20. #include <linux/mfd/rk808.h>
  21. #include <linux/regulator/driver.h>
  22. #include <linux/regulator/of_regulator.h>
  23. #include <linux/gpio/consumer.h>
  24. /* Field Definitions */
  25. #define RK808_BUCK_VSEL_MASK 0x3f
  26. #define RK808_BUCK4_VSEL_MASK 0xf
  27. #define RK808_LDO_VSEL_MASK 0x1f
  28. #define RK809_BUCK5_VSEL_MASK 0x7
  29. #define RK817_LDO_VSEL_MASK 0x7f
  30. #define RK817_BOOST_VSEL_MASK 0x7
  31. #define RK817_BUCK_VSEL_MASK 0x7f
  32. #define RK818_BUCK_VSEL_MASK 0x3f
  33. #define RK818_BUCK4_VSEL_MASK 0x1f
  34. #define RK818_LDO_VSEL_MASK 0x1f
  35. #define RK818_LDO3_ON_VSEL_MASK 0xf
  36. #define RK818_BOOST_ON_VSEL_MASK 0xe0
  37. /* Ramp rate definitions for buck1 / buck2 only */
  38. #define RK808_RAMP_RATE_OFFSET 3
  39. #define RK808_RAMP_RATE_MASK (3 << RK808_RAMP_RATE_OFFSET)
  40. #define RK808_RAMP_RATE_2MV_PER_US (0 << RK808_RAMP_RATE_OFFSET)
  41. #define RK808_RAMP_RATE_4MV_PER_US (1 << RK808_RAMP_RATE_OFFSET)
  42. #define RK808_RAMP_RATE_6MV_PER_US (2 << RK808_RAMP_RATE_OFFSET)
  43. #define RK808_RAMP_RATE_10MV_PER_US (3 << RK808_RAMP_RATE_OFFSET)
  44. #define RK808_DVS2_POL BIT(2)
  45. #define RK808_DVS1_POL BIT(1)
  46. /* Offset from XXX_ON_VSEL to XXX_SLP_VSEL */
  47. #define RK808_SLP_REG_OFFSET 1
  48. /* Offset from XXX_ON_VSEL to XXX_DVS_VSEL */
  49. #define RK808_DVS_REG_OFFSET 2
  50. /* Offset from XXX_EN_REG to SLEEP_SET_OFF_XXX */
  51. #define RK808_SLP_SET_OFF_REG_OFFSET 2
  52. /* max steps for increase voltage of Buck1/2, equal 100mv*/
  53. #define MAX_STEPS_ONE_TIME 8
  54. #define ENABLE_MASK(id) (BIT(id) | BIT(4 + (id)))
  55. #define DISABLE_VAL(id) (BIT(4 + (id)))
  56. #define RK817_BOOST_DESC(_id, _match, _supply, _min, _max, _step, _vreg,\
  57. _vmask, _ereg, _emask, _enval, _disval, _etime, m_drop) \
  58. { \
  59. .name = (_match), \
  60. .supply_name = (_supply), \
  61. .of_match = of_match_ptr(_match), \
  62. .regulators_node = of_match_ptr("regulators"), \
  63. .type = REGULATOR_VOLTAGE, \
  64. .id = (_id), \
  65. .n_voltages = (((_max) - (_min)) / (_step) + 1), \
  66. .owner = THIS_MODULE, \
  67. .min_uV = (_min) * 1000, \
  68. .uV_step = (_step) * 1000, \
  69. .vsel_reg = (_vreg), \
  70. .vsel_mask = (_vmask), \
  71. .enable_reg = (_ereg), \
  72. .enable_mask = (_emask), \
  73. .enable_val = (_enval), \
  74. .disable_val = (_disval), \
  75. .enable_time = (_etime), \
  76. .min_dropout_uV = (m_drop) * 1000, \
  77. .ops = &rk817_boost_ops, \
  78. }
  79. #define RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
  80. _vmask, _ereg, _emask, _enval, _disval, _etime, _ops) \
  81. { \
  82. .name = (_match), \
  83. .supply_name = (_supply), \
  84. .of_match = of_match_ptr(_match), \
  85. .regulators_node = of_match_ptr("regulators"), \
  86. .type = REGULATOR_VOLTAGE, \
  87. .id = (_id), \
  88. .n_voltages = (((_max) - (_min)) / (_step) + 1), \
  89. .owner = THIS_MODULE, \
  90. .min_uV = (_min) * 1000, \
  91. .uV_step = (_step) * 1000, \
  92. .vsel_reg = (_vreg), \
  93. .vsel_mask = (_vmask), \
  94. .enable_reg = (_ereg), \
  95. .enable_mask = (_emask), \
  96. .enable_val = (_enval), \
  97. .disable_val = (_disval), \
  98. .enable_time = (_etime), \
  99. .ops = _ops, \
  100. }
  101. #define RK805_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
  102. _vmask, _ereg, _emask, _etime) \
  103. RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
  104. _vmask, _ereg, _emask, 0, 0, _etime, &rk805_reg_ops)
  105. #define RK8XX_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
  106. _vmask, _ereg, _emask, _etime) \
  107. RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
  108. _vmask, _ereg, _emask, 0, 0, _etime, &rk808_reg_ops)
  109. #define RK817_DESC(_id, _match, _supply, _min, _max, _step, _vreg, \
  110. _vmask, _ereg, _emask, _disval, _etime) \
  111. RK8XX_DESC_COM(_id, _match, _supply, _min, _max, _step, _vreg, \
  112. _vmask, _ereg, _emask, _emask, _disval, _etime, &rk817_reg_ops)
  113. #define RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
  114. _enval, _disval, _ops) \
  115. { \
  116. .name = (_match), \
  117. .supply_name = (_supply), \
  118. .of_match = of_match_ptr(_match), \
  119. .regulators_node = of_match_ptr("regulators"), \
  120. .type = REGULATOR_VOLTAGE, \
  121. .id = (_id), \
  122. .enable_reg = (_ereg), \
  123. .enable_mask = (_emask), \
  124. .enable_val = (_enval), \
  125. .disable_val = (_disval), \
  126. .owner = THIS_MODULE, \
  127. .ops = _ops \
  128. }
  129. #define RK817_DESC_SWITCH(_id, _match, _supply, _ereg, _emask, \
  130. _disval) \
  131. RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
  132. _emask, _disval, &rk817_switch_ops)
  133. #define RK8XX_DESC_SWITCH(_id, _match, _supply, _ereg, _emask) \
  134. RKXX_DESC_SWITCH_COM(_id, _match, _supply, _ereg, _emask, \
  135. 0, 0, &rk808_switch_ops)
  136. struct rk808_regulator_data {
  137. struct gpio_desc *dvs_gpio[2];
  138. };
  139. static const int rk808_buck_config_regs[] = {
  140. RK808_BUCK1_CONFIG_REG,
  141. RK808_BUCK2_CONFIG_REG,
  142. RK808_BUCK3_CONFIG_REG,
  143. RK808_BUCK4_CONFIG_REG,
  144. };
  145. static const struct linear_range rk808_ldo3_voltage_ranges[] = {
  146. REGULATOR_LINEAR_RANGE(800000, 0, 13, 100000),
  147. REGULATOR_LINEAR_RANGE(2500000, 15, 15, 0),
  148. };
  149. #define RK809_BUCK5_SEL_CNT (8)
  150. static const struct linear_range rk809_buck5_voltage_ranges[] = {
  151. REGULATOR_LINEAR_RANGE(1500000, 0, 0, 0),
  152. REGULATOR_LINEAR_RANGE(1800000, 1, 3, 200000),
  153. REGULATOR_LINEAR_RANGE(2800000, 4, 5, 200000),
  154. REGULATOR_LINEAR_RANGE(3300000, 6, 7, 300000),
  155. };
  156. #define RK817_BUCK1_MIN0 500000
  157. #define RK817_BUCK1_MAX0 1500000
  158. #define RK817_BUCK1_MIN1 1600000
  159. #define RK817_BUCK1_MAX1 2400000
  160. #define RK817_BUCK3_MAX1 3400000
  161. #define RK817_BUCK1_STP0 12500
  162. #define RK817_BUCK1_STP1 100000
  163. #define RK817_BUCK1_SEL0 ((RK817_BUCK1_MAX0 - RK817_BUCK1_MIN0) /\
  164. RK817_BUCK1_STP0)
  165. #define RK817_BUCK1_SEL1 ((RK817_BUCK1_MAX1 - RK817_BUCK1_MIN1) /\
  166. RK817_BUCK1_STP1)
  167. #define RK817_BUCK3_SEL1 ((RK817_BUCK3_MAX1 - RK817_BUCK1_MIN1) /\
  168. RK817_BUCK1_STP1)
  169. #define RK817_BUCK1_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK1_SEL1 + 1)
  170. #define RK817_BUCK3_SEL_CNT (RK817_BUCK1_SEL0 + RK817_BUCK3_SEL1 + 1)
  171. static const struct linear_range rk817_buck1_voltage_ranges[] = {
  172. REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0,
  173. RK817_BUCK1_SEL0, RK817_BUCK1_STP0),
  174. REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1,
  175. RK817_BUCK1_SEL_CNT, RK817_BUCK1_STP1),
  176. };
  177. static const struct linear_range rk817_buck3_voltage_ranges[] = {
  178. REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN0, 0,
  179. RK817_BUCK1_SEL0, RK817_BUCK1_STP0),
  180. REGULATOR_LINEAR_RANGE(RK817_BUCK1_MIN1, RK817_BUCK1_SEL0 + 1,
  181. RK817_BUCK3_SEL_CNT, RK817_BUCK1_STP1),
  182. };
  183. static int rk808_buck1_2_get_voltage_sel_regmap(struct regulator_dev *rdev)
  184. {
  185. struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
  186. int id = rdev_get_id(rdev);
  187. struct gpio_desc *gpio = pdata->dvs_gpio[id];
  188. unsigned int val;
  189. int ret;
  190. if (!gpio || gpiod_get_value(gpio) == 0)
  191. return regulator_get_voltage_sel_regmap(rdev);
  192. ret = regmap_read(rdev->regmap,
  193. rdev->desc->vsel_reg + RK808_DVS_REG_OFFSET,
  194. &val);
  195. if (ret != 0)
  196. return ret;
  197. val &= rdev->desc->vsel_mask;
  198. val >>= ffs(rdev->desc->vsel_mask) - 1;
  199. return val;
  200. }
  201. static int rk808_buck1_2_i2c_set_voltage_sel(struct regulator_dev *rdev,
  202. unsigned sel)
  203. {
  204. int ret, delta_sel;
  205. unsigned int old_sel, tmp, val, mask = rdev->desc->vsel_mask;
  206. ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
  207. if (ret != 0)
  208. return ret;
  209. tmp = val & ~mask;
  210. old_sel = val & mask;
  211. old_sel >>= ffs(mask) - 1;
  212. delta_sel = sel - old_sel;
  213. /*
  214. * If directly modify the register to change the voltage, we will face
  215. * the risk of overshoot. Put it into a multi-step, can effectively
  216. * avoid this problem, a step is 100mv here.
  217. */
  218. while (delta_sel > MAX_STEPS_ONE_TIME) {
  219. old_sel += MAX_STEPS_ONE_TIME;
  220. val = old_sel << (ffs(mask) - 1);
  221. val |= tmp;
  222. /*
  223. * i2c is 400kHz (2.5us per bit) and we must transmit _at least_
  224. * 3 bytes (24 bits) plus start and stop so 26 bits. So we've
  225. * got more than 65 us between each voltage change and thus
  226. * won't ramp faster than ~1500 uV / us.
  227. */
  228. ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val);
  229. delta_sel = sel - old_sel;
  230. }
  231. sel <<= ffs(mask) - 1;
  232. val = tmp | sel;
  233. ret = regmap_write(rdev->regmap, rdev->desc->vsel_reg, val);
  234. /*
  235. * When we change the voltage register directly, the ramp rate is about
  236. * 100000uv/us, wait 1us to make sure the target voltage to be stable,
  237. * so we needn't wait extra time after that.
  238. */
  239. udelay(1);
  240. return ret;
  241. }
  242. static int rk808_buck1_2_set_voltage_sel(struct regulator_dev *rdev,
  243. unsigned sel)
  244. {
  245. struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
  246. int id = rdev_get_id(rdev);
  247. struct gpio_desc *gpio = pdata->dvs_gpio[id];
  248. unsigned int reg = rdev->desc->vsel_reg;
  249. unsigned old_sel;
  250. int ret, gpio_level;
  251. if (!gpio)
  252. return rk808_buck1_2_i2c_set_voltage_sel(rdev, sel);
  253. gpio_level = gpiod_get_value(gpio);
  254. if (gpio_level == 0) {
  255. reg += RK808_DVS_REG_OFFSET;
  256. ret = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &old_sel);
  257. } else {
  258. ret = regmap_read(rdev->regmap,
  259. reg + RK808_DVS_REG_OFFSET,
  260. &old_sel);
  261. }
  262. if (ret != 0)
  263. return ret;
  264. sel <<= ffs(rdev->desc->vsel_mask) - 1;
  265. sel |= old_sel & ~rdev->desc->vsel_mask;
  266. ret = regmap_write(rdev->regmap, reg, sel);
  267. if (ret)
  268. return ret;
  269. gpiod_set_value(gpio, !gpio_level);
  270. return ret;
  271. }
  272. static int rk808_buck1_2_set_voltage_time_sel(struct regulator_dev *rdev,
  273. unsigned int old_selector,
  274. unsigned int new_selector)
  275. {
  276. struct rk808_regulator_data *pdata = rdev_get_drvdata(rdev);
  277. int id = rdev_get_id(rdev);
  278. struct gpio_desc *gpio = pdata->dvs_gpio[id];
  279. /* if there is no dvs1/2 pin, we don't need wait extra time here. */
  280. if (!gpio)
  281. return 0;
  282. return regulator_set_voltage_time_sel(rdev, old_selector, new_selector);
  283. }
  284. static int rk808_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
  285. {
  286. unsigned int ramp_value = RK808_RAMP_RATE_10MV_PER_US;
  287. unsigned int reg = rk808_buck_config_regs[rdev_get_id(rdev)];
  288. switch (ramp_delay) {
  289. case 1 ... 2000:
  290. ramp_value = RK808_RAMP_RATE_2MV_PER_US;
  291. break;
  292. case 2001 ... 4000:
  293. ramp_value = RK808_RAMP_RATE_4MV_PER_US;
  294. break;
  295. case 4001 ... 6000:
  296. ramp_value = RK808_RAMP_RATE_6MV_PER_US;
  297. break;
  298. case 6001 ... 10000:
  299. break;
  300. default:
  301. pr_warn("%s ramp_delay: %d not supported, setting 10000\n",
  302. rdev->desc->name, ramp_delay);
  303. }
  304. return regmap_update_bits(rdev->regmap, reg,
  305. RK808_RAMP_RATE_MASK, ramp_value);
  306. }
  307. /*
  308. * RK817 RK809
  309. */
  310. static int rk817_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
  311. {
  312. unsigned int ramp_value = RK817_RAMP_RATE_25MV_PER_US;
  313. unsigned int reg = RK817_BUCK_CONFIG_REG(rdev_get_id(rdev));
  314. switch (ramp_delay) {
  315. case 0 ... 3000:
  316. ramp_value = RK817_RAMP_RATE_3MV_PER_US;
  317. break;
  318. case 3001 ... 6300:
  319. ramp_value = RK817_RAMP_RATE_6_3MV_PER_US;
  320. break;
  321. case 6301 ... 12500:
  322. ramp_value = RK817_RAMP_RATE_12_5MV_PER_US;
  323. break;
  324. case 12501 ... 25000:
  325. break;
  326. default:
  327. dev_warn(&rdev->dev,
  328. "%s ramp_delay: %d not supported, setting 25000\n",
  329. rdev->desc->name, ramp_delay);
  330. }
  331. return regmap_update_bits(rdev->regmap, reg,
  332. RK817_RAMP_RATE_MASK, ramp_value);
  333. }
  334. static int rk808_set_suspend_voltage(struct regulator_dev *rdev, int uv)
  335. {
  336. unsigned int reg;
  337. int sel = regulator_map_voltage_linear(rdev, uv, uv);
  338. if (sel < 0)
  339. return -EINVAL;
  340. reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
  341. return regmap_update_bits(rdev->regmap, reg,
  342. rdev->desc->vsel_mask,
  343. sel);
  344. }
  345. static int rk808_set_suspend_voltage_range(struct regulator_dev *rdev, int uv)
  346. {
  347. unsigned int reg;
  348. int sel = regulator_map_voltage_linear_range(rdev, uv, uv);
  349. if (sel < 0)
  350. return -EINVAL;
  351. reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
  352. return regmap_update_bits(rdev->regmap, reg,
  353. rdev->desc->vsel_mask,
  354. sel);
  355. }
  356. static int rk805_set_suspend_enable(struct regulator_dev *rdev)
  357. {
  358. unsigned int reg;
  359. reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
  360. return regmap_update_bits(rdev->regmap, reg,
  361. rdev->desc->enable_mask,
  362. rdev->desc->enable_mask);
  363. }
  364. static int rk805_set_suspend_disable(struct regulator_dev *rdev)
  365. {
  366. unsigned int reg;
  367. reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
  368. return regmap_update_bits(rdev->regmap, reg,
  369. rdev->desc->enable_mask,
  370. 0);
  371. }
  372. static int rk808_set_suspend_enable(struct regulator_dev *rdev)
  373. {
  374. unsigned int reg;
  375. reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
  376. return regmap_update_bits(rdev->regmap, reg,
  377. rdev->desc->enable_mask,
  378. 0);
  379. }
  380. static int rk808_set_suspend_disable(struct regulator_dev *rdev)
  381. {
  382. unsigned int reg;
  383. reg = rdev->desc->enable_reg + RK808_SLP_SET_OFF_REG_OFFSET;
  384. return regmap_update_bits(rdev->regmap, reg,
  385. rdev->desc->enable_mask,
  386. rdev->desc->enable_mask);
  387. }
  388. static int rk817_set_suspend_enable_ctrl(struct regulator_dev *rdev,
  389. unsigned int en)
  390. {
  391. unsigned int reg;
  392. int id = rdev_get_id(rdev);
  393. unsigned int id_slp, msk, val;
  394. if (id >= RK817_ID_DCDC1 && id <= RK817_ID_DCDC4)
  395. id_slp = id;
  396. else if (id >= RK817_ID_LDO1 && id <= RK817_ID_LDO8)
  397. id_slp = 8 + (id - RK817_ID_LDO1);
  398. else if (id >= RK817_ID_LDO9 && id <= RK809_ID_SW2)
  399. id_slp = 4 + (id - RK817_ID_LDO9);
  400. else
  401. return -EINVAL;
  402. reg = RK817_POWER_SLP_EN_REG(id_slp / 8);
  403. msk = BIT(id_slp % 8);
  404. if (en)
  405. val = msk;
  406. else
  407. val = 0;
  408. return regmap_update_bits(rdev->regmap, reg, msk, val);
  409. }
  410. static int rk817_set_suspend_enable(struct regulator_dev *rdev)
  411. {
  412. return rk817_set_suspend_enable_ctrl(rdev, 1);
  413. }
  414. static int rk817_set_suspend_disable(struct regulator_dev *rdev)
  415. {
  416. return rk817_set_suspend_enable_ctrl(rdev, 0);
  417. }
  418. static int rk8xx_set_suspend_mode(struct regulator_dev *rdev, unsigned int mode)
  419. {
  420. unsigned int reg;
  421. reg = rdev->desc->vsel_reg + RK808_SLP_REG_OFFSET;
  422. switch (mode) {
  423. case REGULATOR_MODE_FAST:
  424. return regmap_update_bits(rdev->regmap, reg,
  425. PWM_MODE_MSK, FPWM_MODE);
  426. case REGULATOR_MODE_NORMAL:
  427. return regmap_update_bits(rdev->regmap, reg,
  428. PWM_MODE_MSK, AUTO_PWM_MODE);
  429. default:
  430. dev_err(&rdev->dev, "do not support this mode\n");
  431. return -EINVAL;
  432. }
  433. return 0;
  434. }
  435. static int rk8xx_set_mode(struct regulator_dev *rdev, unsigned int mode)
  436. {
  437. switch (mode) {
  438. case REGULATOR_MODE_FAST:
  439. return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
  440. PWM_MODE_MSK, FPWM_MODE);
  441. case REGULATOR_MODE_NORMAL:
  442. return regmap_update_bits(rdev->regmap, rdev->desc->vsel_reg,
  443. PWM_MODE_MSK, AUTO_PWM_MODE);
  444. default:
  445. dev_err(&rdev->dev, "do not support this mode\n");
  446. return -EINVAL;
  447. }
  448. return 0;
  449. }
  450. static unsigned int rk8xx_get_mode(struct regulator_dev *rdev)
  451. {
  452. unsigned int val;
  453. int err;
  454. err = regmap_read(rdev->regmap, rdev->desc->vsel_reg, &val);
  455. if (err)
  456. return err;
  457. if (val & FPWM_MODE)
  458. return REGULATOR_MODE_FAST;
  459. else
  460. return REGULATOR_MODE_NORMAL;
  461. }
  462. static int rk8xx_is_enabled_wmsk_regmap(struct regulator_dev *rdev)
  463. {
  464. unsigned int val;
  465. int ret;
  466. ret = regmap_read(rdev->regmap, rdev->desc->enable_reg, &val);
  467. if (ret != 0)
  468. return ret;
  469. /* add write mask bit */
  470. val |= (rdev->desc->enable_mask & 0xf0);
  471. val &= rdev->desc->enable_mask;
  472. if (rdev->desc->enable_is_inverted) {
  473. if (rdev->desc->enable_val)
  474. return val != rdev->desc->enable_val;
  475. return (val == 0);
  476. }
  477. if (rdev->desc->enable_val)
  478. return val == rdev->desc->enable_val;
  479. return val != 0;
  480. }
  481. static unsigned int rk8xx_regulator_of_map_mode(unsigned int mode)
  482. {
  483. switch (mode) {
  484. case 1:
  485. return REGULATOR_MODE_FAST;
  486. case 2:
  487. return REGULATOR_MODE_NORMAL;
  488. default:
  489. return REGULATOR_MODE_INVALID;
  490. }
  491. }
  492. static const struct regulator_ops rk805_reg_ops = {
  493. .list_voltage = regulator_list_voltage_linear,
  494. .map_voltage = regulator_map_voltage_linear,
  495. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  496. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  497. .enable = regulator_enable_regmap,
  498. .disable = regulator_disable_regmap,
  499. .is_enabled = regulator_is_enabled_regmap,
  500. .set_suspend_voltage = rk808_set_suspend_voltage,
  501. .set_suspend_enable = rk805_set_suspend_enable,
  502. .set_suspend_disable = rk805_set_suspend_disable,
  503. };
  504. static const struct regulator_ops rk805_switch_ops = {
  505. .enable = regulator_enable_regmap,
  506. .disable = regulator_disable_regmap,
  507. .is_enabled = regulator_is_enabled_regmap,
  508. .set_suspend_enable = rk805_set_suspend_enable,
  509. .set_suspend_disable = rk805_set_suspend_disable,
  510. };
  511. static const struct regulator_ops rk808_buck1_2_ops = {
  512. .list_voltage = regulator_list_voltage_linear,
  513. .map_voltage = regulator_map_voltage_linear,
  514. .get_voltage_sel = rk808_buck1_2_get_voltage_sel_regmap,
  515. .set_voltage_sel = rk808_buck1_2_set_voltage_sel,
  516. .set_voltage_time_sel = rk808_buck1_2_set_voltage_time_sel,
  517. .enable = regulator_enable_regmap,
  518. .disable = regulator_disable_regmap,
  519. .is_enabled = regulator_is_enabled_regmap,
  520. .set_ramp_delay = rk808_set_ramp_delay,
  521. .set_suspend_voltage = rk808_set_suspend_voltage,
  522. .set_suspend_enable = rk808_set_suspend_enable,
  523. .set_suspend_disable = rk808_set_suspend_disable,
  524. };
  525. static const struct regulator_ops rk808_reg_ops = {
  526. .list_voltage = regulator_list_voltage_linear,
  527. .map_voltage = regulator_map_voltage_linear,
  528. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  529. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  530. .enable = regulator_enable_regmap,
  531. .disable = regulator_disable_regmap,
  532. .is_enabled = regulator_is_enabled_regmap,
  533. .set_suspend_voltage = rk808_set_suspend_voltage,
  534. .set_suspend_enable = rk808_set_suspend_enable,
  535. .set_suspend_disable = rk808_set_suspend_disable,
  536. };
  537. static const struct regulator_ops rk808_reg_ops_ranges = {
  538. .list_voltage = regulator_list_voltage_linear_range,
  539. .map_voltage = regulator_map_voltage_linear_range,
  540. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  541. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  542. .enable = regulator_enable_regmap,
  543. .disable = regulator_disable_regmap,
  544. .is_enabled = regulator_is_enabled_regmap,
  545. .set_suspend_voltage = rk808_set_suspend_voltage_range,
  546. .set_suspend_enable = rk808_set_suspend_enable,
  547. .set_suspend_disable = rk808_set_suspend_disable,
  548. };
  549. static const struct regulator_ops rk808_switch_ops = {
  550. .enable = regulator_enable_regmap,
  551. .disable = regulator_disable_regmap,
  552. .is_enabled = regulator_is_enabled_regmap,
  553. .set_suspend_enable = rk808_set_suspend_enable,
  554. .set_suspend_disable = rk808_set_suspend_disable,
  555. };
  556. static const struct linear_range rk805_buck_1_2_voltage_ranges[] = {
  557. REGULATOR_LINEAR_RANGE(712500, 0, 59, 12500),
  558. REGULATOR_LINEAR_RANGE(1800000, 60, 62, 200000),
  559. REGULATOR_LINEAR_RANGE(2300000, 63, 63, 0),
  560. };
  561. static const struct regulator_ops rk809_buck5_ops_range = {
  562. .list_voltage = regulator_list_voltage_linear_range,
  563. .map_voltage = regulator_map_voltage_linear_range,
  564. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  565. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  566. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  567. .enable = regulator_enable_regmap,
  568. .disable = regulator_disable_regmap,
  569. .is_enabled = rk8xx_is_enabled_wmsk_regmap,
  570. .set_suspend_voltage = rk808_set_suspend_voltage_range,
  571. .set_suspend_enable = rk817_set_suspend_enable,
  572. .set_suspend_disable = rk817_set_suspend_disable,
  573. };
  574. static const struct regulator_ops rk817_reg_ops = {
  575. .list_voltage = regulator_list_voltage_linear,
  576. .map_voltage = regulator_map_voltage_linear,
  577. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  578. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  579. .enable = regulator_enable_regmap,
  580. .disable = regulator_disable_regmap,
  581. .is_enabled = rk8xx_is_enabled_wmsk_regmap,
  582. .set_suspend_voltage = rk808_set_suspend_voltage,
  583. .set_suspend_enable = rk817_set_suspend_enable,
  584. .set_suspend_disable = rk817_set_suspend_disable,
  585. };
  586. static const struct regulator_ops rk817_boost_ops = {
  587. .list_voltage = regulator_list_voltage_linear,
  588. .map_voltage = regulator_map_voltage_linear,
  589. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  590. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  591. .enable = regulator_enable_regmap,
  592. .disable = regulator_disable_regmap,
  593. .is_enabled = rk8xx_is_enabled_wmsk_regmap,
  594. .set_suspend_enable = rk817_set_suspend_enable,
  595. .set_suspend_disable = rk817_set_suspend_disable,
  596. };
  597. static const struct regulator_ops rk817_buck_ops_range = {
  598. .list_voltage = regulator_list_voltage_linear_range,
  599. .map_voltage = regulator_map_voltage_linear_range,
  600. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  601. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  602. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  603. .enable = regulator_enable_regmap,
  604. .disable = regulator_disable_regmap,
  605. .is_enabled = rk8xx_is_enabled_wmsk_regmap,
  606. .set_mode = rk8xx_set_mode,
  607. .get_mode = rk8xx_get_mode,
  608. .set_suspend_mode = rk8xx_set_suspend_mode,
  609. .set_ramp_delay = rk817_set_ramp_delay,
  610. .set_suspend_voltage = rk808_set_suspend_voltage_range,
  611. .set_suspend_enable = rk817_set_suspend_enable,
  612. .set_suspend_disable = rk817_set_suspend_disable,
  613. };
  614. static const struct regulator_ops rk817_switch_ops = {
  615. .enable = regulator_enable_regmap,
  616. .disable = regulator_disable_regmap,
  617. .is_enabled = rk8xx_is_enabled_wmsk_regmap,
  618. .set_suspend_enable = rk817_set_suspend_enable,
  619. .set_suspend_disable = rk817_set_suspend_disable,
  620. };
  621. static const struct regulator_desc rk805_reg[] = {
  622. {
  623. .name = "DCDC_REG1",
  624. .supply_name = "vcc1",
  625. .of_match = of_match_ptr("DCDC_REG1"),
  626. .regulators_node = of_match_ptr("regulators"),
  627. .id = RK805_ID_DCDC1,
  628. .ops = &rk808_reg_ops_ranges,
  629. .type = REGULATOR_VOLTAGE,
  630. .n_voltages = 64,
  631. .linear_ranges = rk805_buck_1_2_voltage_ranges,
  632. .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
  633. .vsel_reg = RK805_BUCK1_ON_VSEL_REG,
  634. .vsel_mask = RK818_BUCK_VSEL_MASK,
  635. .enable_reg = RK805_DCDC_EN_REG,
  636. .enable_mask = BIT(0),
  637. .owner = THIS_MODULE,
  638. }, {
  639. .name = "DCDC_REG2",
  640. .supply_name = "vcc2",
  641. .of_match = of_match_ptr("DCDC_REG2"),
  642. .regulators_node = of_match_ptr("regulators"),
  643. .id = RK805_ID_DCDC2,
  644. .ops = &rk808_reg_ops_ranges,
  645. .type = REGULATOR_VOLTAGE,
  646. .n_voltages = 64,
  647. .linear_ranges = rk805_buck_1_2_voltage_ranges,
  648. .n_linear_ranges = ARRAY_SIZE(rk805_buck_1_2_voltage_ranges),
  649. .vsel_reg = RK805_BUCK2_ON_VSEL_REG,
  650. .vsel_mask = RK818_BUCK_VSEL_MASK,
  651. .enable_reg = RK805_DCDC_EN_REG,
  652. .enable_mask = BIT(1),
  653. .owner = THIS_MODULE,
  654. }, {
  655. .name = "DCDC_REG3",
  656. .supply_name = "vcc3",
  657. .of_match = of_match_ptr("DCDC_REG3"),
  658. .regulators_node = of_match_ptr("regulators"),
  659. .id = RK805_ID_DCDC3,
  660. .ops = &rk805_switch_ops,
  661. .type = REGULATOR_VOLTAGE,
  662. .n_voltages = 1,
  663. .enable_reg = RK805_DCDC_EN_REG,
  664. .enable_mask = BIT(2),
  665. .owner = THIS_MODULE,
  666. },
  667. RK805_DESC(RK805_ID_DCDC4, "DCDC_REG4", "vcc4", 800, 3400, 100,
  668. RK805_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
  669. RK805_DCDC_EN_REG, BIT(3), 0),
  670. RK805_DESC(RK805_ID_LDO1, "LDO_REG1", "vcc5", 800, 3400, 100,
  671. RK805_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
  672. BIT(0), 400),
  673. RK805_DESC(RK805_ID_LDO2, "LDO_REG2", "vcc5", 800, 3400, 100,
  674. RK805_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
  675. BIT(1), 400),
  676. RK805_DESC(RK805_ID_LDO3, "LDO_REG3", "vcc6", 800, 3400, 100,
  677. RK805_LDO3_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK805_LDO_EN_REG,
  678. BIT(2), 400),
  679. };
  680. static const struct regulator_desc rk808_reg[] = {
  681. {
  682. .name = "DCDC_REG1",
  683. .supply_name = "vcc1",
  684. .of_match = of_match_ptr("DCDC_REG1"),
  685. .regulators_node = of_match_ptr("regulators"),
  686. .id = RK808_ID_DCDC1,
  687. .ops = &rk808_buck1_2_ops,
  688. .type = REGULATOR_VOLTAGE,
  689. .min_uV = 712500,
  690. .uV_step = 12500,
  691. .n_voltages = 64,
  692. .vsel_reg = RK808_BUCK1_ON_VSEL_REG,
  693. .vsel_mask = RK808_BUCK_VSEL_MASK,
  694. .enable_reg = RK808_DCDC_EN_REG,
  695. .enable_mask = BIT(0),
  696. .owner = THIS_MODULE,
  697. }, {
  698. .name = "DCDC_REG2",
  699. .supply_name = "vcc2",
  700. .of_match = of_match_ptr("DCDC_REG2"),
  701. .regulators_node = of_match_ptr("regulators"),
  702. .id = RK808_ID_DCDC2,
  703. .ops = &rk808_buck1_2_ops,
  704. .type = REGULATOR_VOLTAGE,
  705. .min_uV = 712500,
  706. .uV_step = 12500,
  707. .n_voltages = 64,
  708. .vsel_reg = RK808_BUCK2_ON_VSEL_REG,
  709. .vsel_mask = RK808_BUCK_VSEL_MASK,
  710. .enable_reg = RK808_DCDC_EN_REG,
  711. .enable_mask = BIT(1),
  712. .owner = THIS_MODULE,
  713. }, {
  714. .name = "DCDC_REG3",
  715. .supply_name = "vcc3",
  716. .of_match = of_match_ptr("DCDC_REG3"),
  717. .regulators_node = of_match_ptr("regulators"),
  718. .id = RK808_ID_DCDC3,
  719. .ops = &rk808_switch_ops,
  720. .type = REGULATOR_VOLTAGE,
  721. .n_voltages = 1,
  722. .enable_reg = RK808_DCDC_EN_REG,
  723. .enable_mask = BIT(2),
  724. .owner = THIS_MODULE,
  725. },
  726. RK8XX_DESC(RK808_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3300, 100,
  727. RK808_BUCK4_ON_VSEL_REG, RK808_BUCK4_VSEL_MASK,
  728. RK808_DCDC_EN_REG, BIT(3), 0),
  729. RK8XX_DESC(RK808_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
  730. RK808_LDO1_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  731. BIT(0), 400),
  732. RK8XX_DESC(RK808_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
  733. RK808_LDO2_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  734. BIT(1), 400),
  735. {
  736. .name = "LDO_REG3",
  737. .supply_name = "vcc7",
  738. .of_match = of_match_ptr("LDO_REG3"),
  739. .regulators_node = of_match_ptr("regulators"),
  740. .id = RK808_ID_LDO3,
  741. .ops = &rk808_reg_ops_ranges,
  742. .type = REGULATOR_VOLTAGE,
  743. .n_voltages = 16,
  744. .linear_ranges = rk808_ldo3_voltage_ranges,
  745. .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
  746. .vsel_reg = RK808_LDO3_ON_VSEL_REG,
  747. .vsel_mask = RK808_BUCK4_VSEL_MASK,
  748. .enable_reg = RK808_LDO_EN_REG,
  749. .enable_mask = BIT(2),
  750. .enable_time = 400,
  751. .owner = THIS_MODULE,
  752. },
  753. RK8XX_DESC(RK808_ID_LDO4, "LDO_REG4", "vcc9", 1800, 3400, 100,
  754. RK808_LDO4_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  755. BIT(3), 400),
  756. RK8XX_DESC(RK808_ID_LDO5, "LDO_REG5", "vcc9", 1800, 3400, 100,
  757. RK808_LDO5_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  758. BIT(4), 400),
  759. RK8XX_DESC(RK808_ID_LDO6, "LDO_REG6", "vcc10", 800, 2500, 100,
  760. RK808_LDO6_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  761. BIT(5), 400),
  762. RK8XX_DESC(RK808_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
  763. RK808_LDO7_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  764. BIT(6), 400),
  765. RK8XX_DESC(RK808_ID_LDO8, "LDO_REG8", "vcc11", 1800, 3400, 100,
  766. RK808_LDO8_ON_VSEL_REG, RK808_LDO_VSEL_MASK, RK808_LDO_EN_REG,
  767. BIT(7), 400),
  768. RK8XX_DESC_SWITCH(RK808_ID_SWITCH1, "SWITCH_REG1", "vcc8",
  769. RK808_DCDC_EN_REG, BIT(5)),
  770. RK8XX_DESC_SWITCH(RK808_ID_SWITCH2, "SWITCH_REG2", "vcc12",
  771. RK808_DCDC_EN_REG, BIT(6)),
  772. };
  773. static const struct regulator_desc rk809_reg[] = {
  774. {
  775. .name = "DCDC_REG1",
  776. .supply_name = "vcc1",
  777. .of_match = of_match_ptr("DCDC_REG1"),
  778. .regulators_node = of_match_ptr("regulators"),
  779. .id = RK817_ID_DCDC1,
  780. .ops = &rk817_buck_ops_range,
  781. .type = REGULATOR_VOLTAGE,
  782. .n_voltages = RK817_BUCK1_SEL_CNT + 1,
  783. .linear_ranges = rk817_buck1_voltage_ranges,
  784. .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
  785. .vsel_reg = RK817_BUCK1_ON_VSEL_REG,
  786. .vsel_mask = RK817_BUCK_VSEL_MASK,
  787. .enable_reg = RK817_POWER_EN_REG(0),
  788. .enable_mask = ENABLE_MASK(RK817_ID_DCDC1),
  789. .enable_val = ENABLE_MASK(RK817_ID_DCDC1),
  790. .disable_val = DISABLE_VAL(RK817_ID_DCDC1),
  791. .of_map_mode = rk8xx_regulator_of_map_mode,
  792. .owner = THIS_MODULE,
  793. }, {
  794. .name = "DCDC_REG2",
  795. .supply_name = "vcc2",
  796. .of_match = of_match_ptr("DCDC_REG2"),
  797. .regulators_node = of_match_ptr("regulators"),
  798. .id = RK817_ID_DCDC2,
  799. .ops = &rk817_buck_ops_range,
  800. .type = REGULATOR_VOLTAGE,
  801. .n_voltages = RK817_BUCK1_SEL_CNT + 1,
  802. .linear_ranges = rk817_buck1_voltage_ranges,
  803. .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
  804. .vsel_reg = RK817_BUCK2_ON_VSEL_REG,
  805. .vsel_mask = RK817_BUCK_VSEL_MASK,
  806. .enable_reg = RK817_POWER_EN_REG(0),
  807. .enable_mask = ENABLE_MASK(RK817_ID_DCDC2),
  808. .enable_val = ENABLE_MASK(RK817_ID_DCDC2),
  809. .disable_val = DISABLE_VAL(RK817_ID_DCDC2),
  810. .of_map_mode = rk8xx_regulator_of_map_mode,
  811. .owner = THIS_MODULE,
  812. }, {
  813. .name = "DCDC_REG3",
  814. .supply_name = "vcc3",
  815. .of_match = of_match_ptr("DCDC_REG3"),
  816. .regulators_node = of_match_ptr("regulators"),
  817. .id = RK817_ID_DCDC3,
  818. .ops = &rk817_buck_ops_range,
  819. .type = REGULATOR_VOLTAGE,
  820. .n_voltages = RK817_BUCK1_SEL_CNT + 1,
  821. .linear_ranges = rk817_buck1_voltage_ranges,
  822. .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
  823. .vsel_reg = RK817_BUCK3_ON_VSEL_REG,
  824. .vsel_mask = RK817_BUCK_VSEL_MASK,
  825. .enable_reg = RK817_POWER_EN_REG(0),
  826. .enable_mask = ENABLE_MASK(RK817_ID_DCDC3),
  827. .enable_val = ENABLE_MASK(RK817_ID_DCDC3),
  828. .disable_val = DISABLE_VAL(RK817_ID_DCDC3),
  829. .of_map_mode = rk8xx_regulator_of_map_mode,
  830. .owner = THIS_MODULE,
  831. }, {
  832. .name = "DCDC_REG4",
  833. .supply_name = "vcc4",
  834. .of_match = of_match_ptr("DCDC_REG4"),
  835. .regulators_node = of_match_ptr("regulators"),
  836. .id = RK817_ID_DCDC4,
  837. .ops = &rk817_buck_ops_range,
  838. .type = REGULATOR_VOLTAGE,
  839. .n_voltages = RK817_BUCK3_SEL_CNT + 1,
  840. .linear_ranges = rk817_buck3_voltage_ranges,
  841. .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges),
  842. .vsel_reg = RK817_BUCK4_ON_VSEL_REG,
  843. .vsel_mask = RK817_BUCK_VSEL_MASK,
  844. .enable_reg = RK817_POWER_EN_REG(0),
  845. .enable_mask = ENABLE_MASK(RK817_ID_DCDC4),
  846. .enable_val = ENABLE_MASK(RK817_ID_DCDC4),
  847. .disable_val = DISABLE_VAL(RK817_ID_DCDC4),
  848. .of_map_mode = rk8xx_regulator_of_map_mode,
  849. .owner = THIS_MODULE,
  850. },
  851. {
  852. .name = "DCDC_REG5",
  853. .supply_name = "vcc9",
  854. .of_match = of_match_ptr("DCDC_REG5"),
  855. .regulators_node = of_match_ptr("regulators"),
  856. .id = RK809_ID_DCDC5,
  857. .ops = &rk809_buck5_ops_range,
  858. .type = REGULATOR_VOLTAGE,
  859. .n_voltages = RK809_BUCK5_SEL_CNT,
  860. .linear_ranges = rk809_buck5_voltage_ranges,
  861. .n_linear_ranges = ARRAY_SIZE(rk809_buck5_voltage_ranges),
  862. .vsel_reg = RK809_BUCK5_CONFIG(0),
  863. .vsel_mask = RK809_BUCK5_VSEL_MASK,
  864. .enable_reg = RK817_POWER_EN_REG(3),
  865. .enable_mask = ENABLE_MASK(1),
  866. .enable_val = ENABLE_MASK(1),
  867. .disable_val = DISABLE_VAL(1),
  868. .of_map_mode = rk8xx_regulator_of_map_mode,
  869. .owner = THIS_MODULE,
  870. },
  871. RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25,
  872. RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK,
  873. RK817_POWER_EN_REG(1), ENABLE_MASK(0),
  874. DISABLE_VAL(0), 400),
  875. RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25,
  876. RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK,
  877. RK817_POWER_EN_REG(1), ENABLE_MASK(1),
  878. DISABLE_VAL(1), 400),
  879. RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25,
  880. RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK,
  881. RK817_POWER_EN_REG(1), ENABLE_MASK(2),
  882. DISABLE_VAL(2), 400),
  883. RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25,
  884. RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK,
  885. RK817_POWER_EN_REG(1), ENABLE_MASK(3),
  886. DISABLE_VAL(3), 400),
  887. RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25,
  888. RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK,
  889. RK817_POWER_EN_REG(2), ENABLE_MASK(0),
  890. DISABLE_VAL(0), 400),
  891. RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25,
  892. RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK,
  893. RK817_POWER_EN_REG(2), ENABLE_MASK(1),
  894. DISABLE_VAL(1), 400),
  895. RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25,
  896. RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK,
  897. RK817_POWER_EN_REG(2), ENABLE_MASK(2),
  898. DISABLE_VAL(2), 400),
  899. RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25,
  900. RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK,
  901. RK817_POWER_EN_REG(2), ENABLE_MASK(3),
  902. DISABLE_VAL(3), 400),
  903. RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25,
  904. RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK,
  905. RK817_POWER_EN_REG(3), ENABLE_MASK(0),
  906. DISABLE_VAL(0), 400),
  907. RK817_DESC_SWITCH(RK809_ID_SW1, "SWITCH_REG1", "vcc9",
  908. RK817_POWER_EN_REG(3), ENABLE_MASK(2),
  909. DISABLE_VAL(2)),
  910. RK817_DESC_SWITCH(RK809_ID_SW2, "SWITCH_REG2", "vcc8",
  911. RK817_POWER_EN_REG(3), ENABLE_MASK(3),
  912. DISABLE_VAL(3)),
  913. };
  914. static const struct regulator_desc rk817_reg[] = {
  915. {
  916. .name = "DCDC_REG1",
  917. .supply_name = "vcc1",
  918. .of_match = of_match_ptr("DCDC_REG1"),
  919. .regulators_node = of_match_ptr("regulators"),
  920. .id = RK817_ID_DCDC1,
  921. .ops = &rk817_buck_ops_range,
  922. .type = REGULATOR_VOLTAGE,
  923. .n_voltages = RK817_BUCK1_SEL_CNT + 1,
  924. .linear_ranges = rk817_buck1_voltage_ranges,
  925. .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
  926. .vsel_reg = RK817_BUCK1_ON_VSEL_REG,
  927. .vsel_mask = RK817_BUCK_VSEL_MASK,
  928. .enable_reg = RK817_POWER_EN_REG(0),
  929. .enable_mask = ENABLE_MASK(RK817_ID_DCDC1),
  930. .enable_val = ENABLE_MASK(RK817_ID_DCDC1),
  931. .disable_val = DISABLE_VAL(RK817_ID_DCDC1),
  932. .of_map_mode = rk8xx_regulator_of_map_mode,
  933. .owner = THIS_MODULE,
  934. }, {
  935. .name = "DCDC_REG2",
  936. .supply_name = "vcc2",
  937. .of_match = of_match_ptr("DCDC_REG2"),
  938. .regulators_node = of_match_ptr("regulators"),
  939. .id = RK817_ID_DCDC2,
  940. .ops = &rk817_buck_ops_range,
  941. .type = REGULATOR_VOLTAGE,
  942. .n_voltages = RK817_BUCK1_SEL_CNT + 1,
  943. .linear_ranges = rk817_buck1_voltage_ranges,
  944. .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
  945. .vsel_reg = RK817_BUCK2_ON_VSEL_REG,
  946. .vsel_mask = RK817_BUCK_VSEL_MASK,
  947. .enable_reg = RK817_POWER_EN_REG(0),
  948. .enable_mask = ENABLE_MASK(RK817_ID_DCDC2),
  949. .enable_val = ENABLE_MASK(RK817_ID_DCDC2),
  950. .disable_val = DISABLE_VAL(RK817_ID_DCDC2),
  951. .of_map_mode = rk8xx_regulator_of_map_mode,
  952. .owner = THIS_MODULE,
  953. }, {
  954. .name = "DCDC_REG3",
  955. .supply_name = "vcc3",
  956. .of_match = of_match_ptr("DCDC_REG3"),
  957. .regulators_node = of_match_ptr("regulators"),
  958. .id = RK817_ID_DCDC3,
  959. .ops = &rk817_buck_ops_range,
  960. .type = REGULATOR_VOLTAGE,
  961. .n_voltages = RK817_BUCK1_SEL_CNT + 1,
  962. .linear_ranges = rk817_buck1_voltage_ranges,
  963. .n_linear_ranges = ARRAY_SIZE(rk817_buck1_voltage_ranges),
  964. .vsel_reg = RK817_BUCK3_ON_VSEL_REG,
  965. .vsel_mask = RK817_BUCK_VSEL_MASK,
  966. .enable_reg = RK817_POWER_EN_REG(0),
  967. .enable_mask = ENABLE_MASK(RK817_ID_DCDC3),
  968. .enable_val = ENABLE_MASK(RK817_ID_DCDC3),
  969. .disable_val = DISABLE_VAL(RK817_ID_DCDC3),
  970. .of_map_mode = rk8xx_regulator_of_map_mode,
  971. .owner = THIS_MODULE,
  972. }, {
  973. .name = "DCDC_REG4",
  974. .supply_name = "vcc4",
  975. .of_match = of_match_ptr("DCDC_REG4"),
  976. .regulators_node = of_match_ptr("regulators"),
  977. .id = RK817_ID_DCDC4,
  978. .ops = &rk817_buck_ops_range,
  979. .type = REGULATOR_VOLTAGE,
  980. .n_voltages = RK817_BUCK3_SEL_CNT + 1,
  981. .linear_ranges = rk817_buck3_voltage_ranges,
  982. .n_linear_ranges = ARRAY_SIZE(rk817_buck3_voltage_ranges),
  983. .vsel_reg = RK817_BUCK4_ON_VSEL_REG,
  984. .vsel_mask = RK817_BUCK_VSEL_MASK,
  985. .enable_reg = RK817_POWER_EN_REG(0),
  986. .enable_mask = ENABLE_MASK(RK817_ID_DCDC4),
  987. .enable_val = ENABLE_MASK(RK817_ID_DCDC4),
  988. .disable_val = DISABLE_VAL(RK817_ID_DCDC4),
  989. .of_map_mode = rk8xx_regulator_of_map_mode,
  990. .owner = THIS_MODULE,
  991. },
  992. RK817_DESC(RK817_ID_LDO1, "LDO_REG1", "vcc5", 600, 3400, 25,
  993. RK817_LDO_ON_VSEL_REG(0), RK817_LDO_VSEL_MASK,
  994. RK817_POWER_EN_REG(1), ENABLE_MASK(0),
  995. DISABLE_VAL(0), 400),
  996. RK817_DESC(RK817_ID_LDO2, "LDO_REG2", "vcc5", 600, 3400, 25,
  997. RK817_LDO_ON_VSEL_REG(1), RK817_LDO_VSEL_MASK,
  998. RK817_POWER_EN_REG(1), ENABLE_MASK(1),
  999. DISABLE_VAL(1), 400),
  1000. RK817_DESC(RK817_ID_LDO3, "LDO_REG3", "vcc5", 600, 3400, 25,
  1001. RK817_LDO_ON_VSEL_REG(2), RK817_LDO_VSEL_MASK,
  1002. RK817_POWER_EN_REG(1), ENABLE_MASK(2),
  1003. DISABLE_VAL(2), 400),
  1004. RK817_DESC(RK817_ID_LDO4, "LDO_REG4", "vcc6", 600, 3400, 25,
  1005. RK817_LDO_ON_VSEL_REG(3), RK817_LDO_VSEL_MASK,
  1006. RK817_POWER_EN_REG(1), ENABLE_MASK(3),
  1007. DISABLE_VAL(3), 400),
  1008. RK817_DESC(RK817_ID_LDO5, "LDO_REG5", "vcc6", 600, 3400, 25,
  1009. RK817_LDO_ON_VSEL_REG(4), RK817_LDO_VSEL_MASK,
  1010. RK817_POWER_EN_REG(2), ENABLE_MASK(0),
  1011. DISABLE_VAL(0), 400),
  1012. RK817_DESC(RK817_ID_LDO6, "LDO_REG6", "vcc6", 600, 3400, 25,
  1013. RK817_LDO_ON_VSEL_REG(5), RK817_LDO_VSEL_MASK,
  1014. RK817_POWER_EN_REG(2), ENABLE_MASK(1),
  1015. DISABLE_VAL(1), 400),
  1016. RK817_DESC(RK817_ID_LDO7, "LDO_REG7", "vcc7", 600, 3400, 25,
  1017. RK817_LDO_ON_VSEL_REG(6), RK817_LDO_VSEL_MASK,
  1018. RK817_POWER_EN_REG(2), ENABLE_MASK(2),
  1019. DISABLE_VAL(2), 400),
  1020. RK817_DESC(RK817_ID_LDO8, "LDO_REG8", "vcc7", 600, 3400, 25,
  1021. RK817_LDO_ON_VSEL_REG(7), RK817_LDO_VSEL_MASK,
  1022. RK817_POWER_EN_REG(2), ENABLE_MASK(3),
  1023. DISABLE_VAL(3), 400),
  1024. RK817_DESC(RK817_ID_LDO9, "LDO_REG9", "vcc7", 600, 3400, 25,
  1025. RK817_LDO_ON_VSEL_REG(8), RK817_LDO_VSEL_MASK,
  1026. RK817_POWER_EN_REG(3), ENABLE_MASK(0),
  1027. DISABLE_VAL(0), 400),
  1028. RK817_BOOST_DESC(RK817_ID_BOOST, "BOOST", "vcc8", 4700, 5400, 100,
  1029. RK817_BOOST_OTG_CFG, RK817_BOOST_VSEL_MASK,
  1030. RK817_POWER_EN_REG(3), ENABLE_MASK(1), ENABLE_MASK(1),
  1031. DISABLE_VAL(1), 400, 3500 - 5400),
  1032. RK817_DESC_SWITCH(RK817_ID_BOOST_OTG_SW, "OTG_SWITCH", "vcc9",
  1033. RK817_POWER_EN_REG(3), ENABLE_MASK(2),
  1034. DISABLE_VAL(2)),
  1035. };
  1036. static const struct regulator_desc rk818_reg[] = {
  1037. {
  1038. .name = "DCDC_REG1",
  1039. .supply_name = "vcc1",
  1040. .of_match = of_match_ptr("DCDC_REG1"),
  1041. .regulators_node = of_match_ptr("regulators"),
  1042. .id = RK818_ID_DCDC1,
  1043. .ops = &rk808_reg_ops,
  1044. .type = REGULATOR_VOLTAGE,
  1045. .min_uV = 712500,
  1046. .uV_step = 12500,
  1047. .n_voltages = 64,
  1048. .vsel_reg = RK818_BUCK1_ON_VSEL_REG,
  1049. .vsel_mask = RK818_BUCK_VSEL_MASK,
  1050. .enable_reg = RK818_DCDC_EN_REG,
  1051. .enable_mask = BIT(0),
  1052. .owner = THIS_MODULE,
  1053. }, {
  1054. .name = "DCDC_REG2",
  1055. .supply_name = "vcc2",
  1056. .of_match = of_match_ptr("DCDC_REG2"),
  1057. .regulators_node = of_match_ptr("regulators"),
  1058. .id = RK818_ID_DCDC2,
  1059. .ops = &rk808_reg_ops,
  1060. .type = REGULATOR_VOLTAGE,
  1061. .min_uV = 712500,
  1062. .uV_step = 12500,
  1063. .n_voltages = 64,
  1064. .vsel_reg = RK818_BUCK2_ON_VSEL_REG,
  1065. .vsel_mask = RK818_BUCK_VSEL_MASK,
  1066. .enable_reg = RK818_DCDC_EN_REG,
  1067. .enable_mask = BIT(1),
  1068. .owner = THIS_MODULE,
  1069. }, {
  1070. .name = "DCDC_REG3",
  1071. .supply_name = "vcc3",
  1072. .of_match = of_match_ptr("DCDC_REG3"),
  1073. .regulators_node = of_match_ptr("regulators"),
  1074. .id = RK818_ID_DCDC3,
  1075. .ops = &rk808_switch_ops,
  1076. .type = REGULATOR_VOLTAGE,
  1077. .n_voltages = 1,
  1078. .enable_reg = RK818_DCDC_EN_REG,
  1079. .enable_mask = BIT(2),
  1080. .owner = THIS_MODULE,
  1081. },
  1082. RK8XX_DESC(RK818_ID_DCDC4, "DCDC_REG4", "vcc4", 1800, 3600, 100,
  1083. RK818_BUCK4_ON_VSEL_REG, RK818_BUCK4_VSEL_MASK,
  1084. RK818_DCDC_EN_REG, BIT(3), 0),
  1085. RK8XX_DESC(RK818_ID_BOOST, "DCDC_BOOST", "boost", 4700, 5400, 100,
  1086. RK818_BOOST_LDO9_ON_VSEL_REG, RK818_BOOST_ON_VSEL_MASK,
  1087. RK818_DCDC_EN_REG, BIT(4), 0),
  1088. RK8XX_DESC(RK818_ID_LDO1, "LDO_REG1", "vcc6", 1800, 3400, 100,
  1089. RK818_LDO1_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1090. BIT(0), 400),
  1091. RK8XX_DESC(RK818_ID_LDO2, "LDO_REG2", "vcc6", 1800, 3400, 100,
  1092. RK818_LDO2_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1093. BIT(1), 400),
  1094. {
  1095. .name = "LDO_REG3",
  1096. .supply_name = "vcc7",
  1097. .of_match = of_match_ptr("LDO_REG3"),
  1098. .regulators_node = of_match_ptr("regulators"),
  1099. .id = RK818_ID_LDO3,
  1100. .ops = &rk808_reg_ops_ranges,
  1101. .type = REGULATOR_VOLTAGE,
  1102. .n_voltages = 16,
  1103. .linear_ranges = rk808_ldo3_voltage_ranges,
  1104. .n_linear_ranges = ARRAY_SIZE(rk808_ldo3_voltage_ranges),
  1105. .vsel_reg = RK818_LDO3_ON_VSEL_REG,
  1106. .vsel_mask = RK818_LDO3_ON_VSEL_MASK,
  1107. .enable_reg = RK818_LDO_EN_REG,
  1108. .enable_mask = BIT(2),
  1109. .enable_time = 400,
  1110. .owner = THIS_MODULE,
  1111. },
  1112. RK8XX_DESC(RK818_ID_LDO4, "LDO_REG4", "vcc8", 1800, 3400, 100,
  1113. RK818_LDO4_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1114. BIT(3), 400),
  1115. RK8XX_DESC(RK818_ID_LDO5, "LDO_REG5", "vcc7", 1800, 3400, 100,
  1116. RK818_LDO5_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1117. BIT(4), 400),
  1118. RK8XX_DESC(RK818_ID_LDO6, "LDO_REG6", "vcc8", 800, 2500, 100,
  1119. RK818_LDO6_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1120. BIT(5), 400),
  1121. RK8XX_DESC(RK818_ID_LDO7, "LDO_REG7", "vcc7", 800, 2500, 100,
  1122. RK818_LDO7_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1123. BIT(6), 400),
  1124. RK8XX_DESC(RK818_ID_LDO8, "LDO_REG8", "vcc8", 1800, 3400, 100,
  1125. RK818_LDO8_ON_VSEL_REG, RK818_LDO_VSEL_MASK, RK818_LDO_EN_REG,
  1126. BIT(7), 400),
  1127. RK8XX_DESC(RK818_ID_LDO9, "LDO_REG9", "vcc9", 1800, 3400, 100,
  1128. RK818_BOOST_LDO9_ON_VSEL_REG, RK818_LDO_VSEL_MASK,
  1129. RK818_DCDC_EN_REG, BIT(5), 400),
  1130. RK8XX_DESC_SWITCH(RK818_ID_SWITCH, "SWITCH_REG", "vcc9",
  1131. RK818_DCDC_EN_REG, BIT(6)),
  1132. RK8XX_DESC_SWITCH(RK818_ID_HDMI_SWITCH, "HDMI_SWITCH", "h_5v",
  1133. RK818_H5V_EN_REG, BIT(0)),
  1134. RK8XX_DESC_SWITCH(RK818_ID_OTG_SWITCH, "OTG_SWITCH", "usb",
  1135. RK818_DCDC_EN_REG, BIT(7)),
  1136. };
  1137. static int rk808_regulator_dt_parse_pdata(struct device *dev,
  1138. struct device *client_dev,
  1139. struct regmap *map,
  1140. struct rk808_regulator_data *pdata)
  1141. {
  1142. struct device_node *np;
  1143. int tmp, ret = 0, i;
  1144. np = of_get_child_by_name(client_dev->of_node, "regulators");
  1145. if (!np)
  1146. return -ENXIO;
  1147. for (i = 0; i < ARRAY_SIZE(pdata->dvs_gpio); i++) {
  1148. pdata->dvs_gpio[i] =
  1149. devm_gpiod_get_index_optional(client_dev, "dvs", i,
  1150. GPIOD_OUT_LOW);
  1151. if (IS_ERR(pdata->dvs_gpio[i])) {
  1152. ret = PTR_ERR(pdata->dvs_gpio[i]);
  1153. dev_err(dev, "failed to get dvs%d gpio (%d)\n", i, ret);
  1154. goto dt_parse_end;
  1155. }
  1156. if (!pdata->dvs_gpio[i]) {
  1157. dev_info(dev, "there is no dvs%d gpio\n", i);
  1158. continue;
  1159. }
  1160. tmp = i ? RK808_DVS2_POL : RK808_DVS1_POL;
  1161. ret = regmap_update_bits(map, RK808_IO_POL_REG, tmp,
  1162. gpiod_is_active_low(pdata->dvs_gpio[i]) ?
  1163. 0 : tmp);
  1164. }
  1165. dt_parse_end:
  1166. of_node_put(np);
  1167. return ret;
  1168. }
  1169. static int rk808_regulator_probe(struct platform_device *pdev)
  1170. {
  1171. struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent);
  1172. struct i2c_client *client = rk808->i2c;
  1173. struct regulator_config config = {};
  1174. struct regulator_dev *rk808_rdev;
  1175. struct rk808_regulator_data *pdata;
  1176. const struct regulator_desc *regulators;
  1177. int ret, i, nregulators;
  1178. pdata = devm_kzalloc(&pdev->dev, sizeof(*pdata), GFP_KERNEL);
  1179. if (!pdata)
  1180. return -ENOMEM;
  1181. ret = rk808_regulator_dt_parse_pdata(&pdev->dev, &client->dev,
  1182. rk808->regmap, pdata);
  1183. if (ret < 0)
  1184. return ret;
  1185. platform_set_drvdata(pdev, pdata);
  1186. switch (rk808->variant) {
  1187. case RK805_ID:
  1188. regulators = rk805_reg;
  1189. nregulators = RK805_NUM_REGULATORS;
  1190. break;
  1191. case RK808_ID:
  1192. regulators = rk808_reg;
  1193. nregulators = RK808_NUM_REGULATORS;
  1194. break;
  1195. case RK809_ID:
  1196. regulators = rk809_reg;
  1197. nregulators = RK809_NUM_REGULATORS;
  1198. break;
  1199. case RK817_ID:
  1200. regulators = rk817_reg;
  1201. nregulators = RK817_NUM_REGULATORS;
  1202. break;
  1203. case RK818_ID:
  1204. regulators = rk818_reg;
  1205. nregulators = RK818_NUM_REGULATORS;
  1206. break;
  1207. default:
  1208. dev_err(&client->dev, "unsupported RK8XX ID %lu\n",
  1209. rk808->variant);
  1210. return -EINVAL;
  1211. }
  1212. config.dev = &client->dev;
  1213. config.driver_data = pdata;
  1214. config.regmap = rk808->regmap;
  1215. /* Instantiate the regulators */
  1216. for (i = 0; i < nregulators; i++) {
  1217. rk808_rdev = devm_regulator_register(&pdev->dev,
  1218. &regulators[i], &config);
  1219. if (IS_ERR(rk808_rdev)) {
  1220. dev_err(&client->dev,
  1221. "failed to register %d regulator\n", i);
  1222. return PTR_ERR(rk808_rdev);
  1223. }
  1224. }
  1225. return 0;
  1226. }
  1227. static struct platform_driver rk808_regulator_driver = {
  1228. .probe = rk808_regulator_probe,
  1229. .driver = {
  1230. .name = "rk808-regulator"
  1231. },
  1232. };
  1233. module_platform_driver(rk808_regulator_driver);
  1234. MODULE_DESCRIPTION("regulator driver for the RK805/RK808/RK818 series PMICs");
  1235. MODULE_AUTHOR("Tony xie <tony.xie@rock-chips.com>");
  1236. MODULE_AUTHOR("Chris Zhong <zyw@rock-chips.com>");
  1237. MODULE_AUTHOR("Zhang Qing <zhangqing@rock-chips.com>");
  1238. MODULE_AUTHOR("Wadim Egorov <w.egorov@phytec.de>");
  1239. MODULE_LICENSE("GPL");
  1240. MODULE_ALIAS("platform:rk808-regulator");