lp872x.c 25 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright 2012 Texas Instruments
  4. *
  5. * Author: Milo(Woogyom) Kim <[email protected]>
  6. */
  7. #include <linux/module.h>
  8. #include <linux/slab.h>
  9. #include <linux/i2c.h>
  10. #include <linux/regmap.h>
  11. #include <linux/err.h>
  12. #include <linux/gpio/consumer.h>
  13. #include <linux/delay.h>
  14. #include <linux/regulator/lp872x.h>
  15. #include <linux/regulator/driver.h>
  16. #include <linux/platform_device.h>
  17. #include <linux/of.h>
  18. #include <linux/regulator/of_regulator.h>
  19. /* Registers : LP8720/8725 shared */
  20. #define LP872X_GENERAL_CFG 0x00
  21. #define LP872X_LDO1_VOUT 0x01
  22. #define LP872X_LDO2_VOUT 0x02
  23. #define LP872X_LDO3_VOUT 0x03
  24. #define LP872X_LDO4_VOUT 0x04
  25. #define LP872X_LDO5_VOUT 0x05
  26. /* Registers : LP8720 */
  27. #define LP8720_BUCK_VOUT1 0x06
  28. #define LP8720_BUCK_VOUT2 0x07
  29. #define LP8720_ENABLE 0x08
  30. /* Registers : LP8725 */
  31. #define LP8725_LILO1_VOUT 0x06
  32. #define LP8725_LILO2_VOUT 0x07
  33. #define LP8725_BUCK1_VOUT1 0x08
  34. #define LP8725_BUCK1_VOUT2 0x09
  35. #define LP8725_BUCK2_VOUT1 0x0A
  36. #define LP8725_BUCK2_VOUT2 0x0B
  37. #define LP8725_BUCK_CTRL 0x0C
  38. #define LP8725_LDO_CTRL 0x0D
  39. /* Mask/shift : LP8720/LP8725 shared */
  40. #define LP872X_VOUT_M 0x1F
  41. #define LP872X_START_DELAY_M 0xE0
  42. #define LP872X_START_DELAY_S 5
  43. #define LP872X_EN_LDO1_M BIT(0)
  44. #define LP872X_EN_LDO2_M BIT(1)
  45. #define LP872X_EN_LDO3_M BIT(2)
  46. #define LP872X_EN_LDO4_M BIT(3)
  47. #define LP872X_EN_LDO5_M BIT(4)
  48. /* Mask/shift : LP8720 */
  49. #define LP8720_TIMESTEP_S 0 /* Addr 00h */
  50. #define LP8720_TIMESTEP_M BIT(0)
  51. #define LP8720_EXT_DVS_M BIT(2)
  52. #define LP8720_BUCK_FPWM_S 5 /* Addr 07h */
  53. #define LP8720_BUCK_FPWM_M BIT(5)
  54. #define LP8720_EN_BUCK_M BIT(5) /* Addr 08h */
  55. #define LP8720_DVS_SEL_M BIT(7)
  56. /* Mask/shift : LP8725 */
  57. #define LP8725_TIMESTEP_M 0xC0 /* Addr 00h */
  58. #define LP8725_TIMESTEP_S 6
  59. #define LP8725_BUCK1_EN_M BIT(0)
  60. #define LP8725_DVS1_M BIT(2)
  61. #define LP8725_DVS2_M BIT(3)
  62. #define LP8725_BUCK2_EN_M BIT(4)
  63. #define LP8725_BUCK_CL_M 0xC0 /* Addr 09h, 0Bh */
  64. #define LP8725_BUCK_CL_S 6
  65. #define LP8725_BUCK1_FPWM_S 1 /* Addr 0Ch */
  66. #define LP8725_BUCK1_FPWM_M BIT(1)
  67. #define LP8725_BUCK2_FPWM_S 5
  68. #define LP8725_BUCK2_FPWM_M BIT(5)
  69. #define LP8725_EN_LILO1_M BIT(5) /* Addr 0Dh */
  70. #define LP8725_EN_LILO2_M BIT(6)
  71. /* PWM mode */
  72. #define LP872X_FORCE_PWM 1
  73. #define LP872X_AUTO_PWM 0
  74. #define LP8720_NUM_REGULATORS 6
  75. #define LP8725_NUM_REGULATORS 9
  76. #define EXTERN_DVS_USED 0
  77. #define MAX_DELAY 6
  78. /* Default DVS Mode */
  79. #define LP8720_DEFAULT_DVS 0
  80. #define LP8725_DEFAULT_DVS BIT(2)
  81. /* dump registers in regmap-debugfs */
  82. #define MAX_REGISTERS 0x0F
  83. enum lp872x_id {
  84. LP8720,
  85. LP8725,
  86. };
  87. struct lp872x {
  88. struct regmap *regmap;
  89. struct device *dev;
  90. enum lp872x_id chipid;
  91. struct lp872x_platform_data *pdata;
  92. int num_regulators;
  93. enum gpiod_flags dvs_pin;
  94. };
  95. /* LP8720/LP8725 shared voltage table for LDOs */
  96. static const unsigned int lp872x_ldo_vtbl[] = {
  97. 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000, 1550000,
  98. 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000, 2000000,
  99. 2100000, 2200000, 2300000, 2400000, 2500000, 2600000, 2650000, 2700000,
  100. 2750000, 2800000, 2850000, 2900000, 2950000, 3000000, 3100000, 3300000,
  101. };
  102. /* LP8720 LDO4 voltage table */
  103. static const unsigned int lp8720_ldo4_vtbl[] = {
  104. 800000, 850000, 900000, 1000000, 1100000, 1200000, 1250000, 1300000,
  105. 1350000, 1400000, 1450000, 1500000, 1550000, 1600000, 1650000, 1700000,
  106. 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
  107. 2400000, 2500000, 2600000, 2650000, 2700000, 2750000, 2800000, 2850000,
  108. };
  109. /* LP8725 LILO(Low Input Low Output) voltage table */
  110. static const unsigned int lp8725_lilo_vtbl[] = {
  111. 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
  112. 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
  113. 1800000, 1900000, 2000000, 2100000, 2200000, 2300000, 2400000, 2500000,
  114. 2600000, 2700000, 2800000, 2850000, 2900000, 3000000, 3100000, 3300000,
  115. };
  116. /* LP8720 BUCK voltage table */
  117. #define EXT_R 0 /* external resistor divider */
  118. static const unsigned int lp8720_buck_vtbl[] = {
  119. EXT_R, 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000,
  120. 1150000, 1200000, 1250000, 1300000, 1350000, 1400000, 1450000, 1500000,
  121. 1550000, 1600000, 1650000, 1700000, 1750000, 1800000, 1850000, 1900000,
  122. 1950000, 2000000, 2050000, 2100000, 2150000, 2200000, 2250000, 2300000,
  123. };
  124. /* LP8725 BUCK voltage table */
  125. static const unsigned int lp8725_buck_vtbl[] = {
  126. 800000, 850000, 900000, 950000, 1000000, 1050000, 1100000, 1150000,
  127. 1200000, 1250000, 1300000, 1350000, 1400000, 1500000, 1600000, 1700000,
  128. 1750000, 1800000, 1850000, 1900000, 2000000, 2100000, 2200000, 2300000,
  129. 2400000, 2500000, 2600000, 2700000, 2800000, 2850000, 2900000, 3000000,
  130. };
  131. /* LP8725 BUCK current limit */
  132. static const unsigned int lp8725_buck_uA[] = {
  133. 460000, 780000, 1050000, 1370000,
  134. };
  135. static int lp872x_read_byte(struct lp872x *lp, u8 addr, u8 *data)
  136. {
  137. int ret;
  138. unsigned int val;
  139. ret = regmap_read(lp->regmap, addr, &val);
  140. if (ret < 0) {
  141. dev_err(lp->dev, "failed to read 0x%.2x\n", addr);
  142. return ret;
  143. }
  144. *data = (u8)val;
  145. return 0;
  146. }
  147. static inline int lp872x_write_byte(struct lp872x *lp, u8 addr, u8 data)
  148. {
  149. return regmap_write(lp->regmap, addr, data);
  150. }
  151. static inline int lp872x_update_bits(struct lp872x *lp, u8 addr,
  152. unsigned int mask, u8 data)
  153. {
  154. return regmap_update_bits(lp->regmap, addr, mask, data);
  155. }
  156. static int lp872x_get_timestep_usec(struct lp872x *lp)
  157. {
  158. enum lp872x_id chip = lp->chipid;
  159. u8 val, mask, shift;
  160. int *time_usec, size, ret;
  161. int lp8720_time_usec[] = { 25, 50 };
  162. int lp8725_time_usec[] = { 32, 64, 128, 256 };
  163. switch (chip) {
  164. case LP8720:
  165. mask = LP8720_TIMESTEP_M;
  166. shift = LP8720_TIMESTEP_S;
  167. time_usec = &lp8720_time_usec[0];
  168. size = ARRAY_SIZE(lp8720_time_usec);
  169. break;
  170. case LP8725:
  171. mask = LP8725_TIMESTEP_M;
  172. shift = LP8725_TIMESTEP_S;
  173. time_usec = &lp8725_time_usec[0];
  174. size = ARRAY_SIZE(lp8725_time_usec);
  175. break;
  176. default:
  177. return -EINVAL;
  178. }
  179. ret = lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val);
  180. if (ret)
  181. return ret;
  182. val = (val & mask) >> shift;
  183. if (val >= size)
  184. return -EINVAL;
  185. return *(time_usec + val);
  186. }
  187. static int lp872x_regulator_enable_time(struct regulator_dev *rdev)
  188. {
  189. struct lp872x *lp = rdev_get_drvdata(rdev);
  190. enum lp872x_regulator_id rid = rdev_get_id(rdev);
  191. int time_step_us = lp872x_get_timestep_usec(lp);
  192. int ret;
  193. u8 addr, val;
  194. if (time_step_us < 0)
  195. return time_step_us;
  196. switch (rid) {
  197. case LP8720_ID_LDO1 ... LP8720_ID_BUCK:
  198. addr = LP872X_LDO1_VOUT + rid;
  199. break;
  200. case LP8725_ID_LDO1 ... LP8725_ID_BUCK1:
  201. addr = LP872X_LDO1_VOUT + rid - LP8725_ID_BASE;
  202. break;
  203. case LP8725_ID_BUCK2:
  204. addr = LP8725_BUCK2_VOUT1;
  205. break;
  206. default:
  207. return -EINVAL;
  208. }
  209. ret = lp872x_read_byte(lp, addr, &val);
  210. if (ret)
  211. return ret;
  212. val = (val & LP872X_START_DELAY_M) >> LP872X_START_DELAY_S;
  213. return val > MAX_DELAY ? 0 : val * time_step_us;
  214. }
  215. static void lp872x_set_dvs(struct lp872x *lp, enum lp872x_dvs_sel dvs_sel,
  216. struct gpio_desc *gpio)
  217. {
  218. enum gpiod_flags state;
  219. state = dvs_sel == SEL_V1 ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
  220. gpiod_set_value(gpio, state);
  221. lp->dvs_pin = state;
  222. }
  223. static u8 lp872x_select_buck_vout_addr(struct lp872x *lp,
  224. enum lp872x_regulator_id buck)
  225. {
  226. u8 val, addr;
  227. if (lp872x_read_byte(lp, LP872X_GENERAL_CFG, &val))
  228. return 0;
  229. switch (buck) {
  230. case LP8720_ID_BUCK:
  231. if (val & LP8720_EXT_DVS_M) {
  232. addr = (lp->dvs_pin == GPIOD_OUT_HIGH) ?
  233. LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
  234. } else {
  235. if (lp872x_read_byte(lp, LP8720_ENABLE, &val))
  236. return 0;
  237. addr = val & LP8720_DVS_SEL_M ?
  238. LP8720_BUCK_VOUT1 : LP8720_BUCK_VOUT2;
  239. }
  240. break;
  241. case LP8725_ID_BUCK1:
  242. if (val & LP8725_DVS1_M)
  243. addr = LP8725_BUCK1_VOUT1;
  244. else
  245. addr = (lp->dvs_pin == GPIOD_OUT_HIGH) ?
  246. LP8725_BUCK1_VOUT1 : LP8725_BUCK1_VOUT2;
  247. break;
  248. case LP8725_ID_BUCK2:
  249. addr = val & LP8725_DVS2_M ?
  250. LP8725_BUCK2_VOUT1 : LP8725_BUCK2_VOUT2;
  251. break;
  252. default:
  253. return 0;
  254. }
  255. return addr;
  256. }
  257. static bool lp872x_is_valid_buck_addr(u8 addr)
  258. {
  259. switch (addr) {
  260. case LP8720_BUCK_VOUT1:
  261. case LP8720_BUCK_VOUT2:
  262. case LP8725_BUCK1_VOUT1:
  263. case LP8725_BUCK1_VOUT2:
  264. case LP8725_BUCK2_VOUT1:
  265. case LP8725_BUCK2_VOUT2:
  266. return true;
  267. default:
  268. return false;
  269. }
  270. }
  271. static int lp872x_buck_set_voltage_sel(struct regulator_dev *rdev,
  272. unsigned selector)
  273. {
  274. struct lp872x *lp = rdev_get_drvdata(rdev);
  275. enum lp872x_regulator_id buck = rdev_get_id(rdev);
  276. u8 addr, mask = LP872X_VOUT_M;
  277. struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
  278. if (dvs && dvs->gpio)
  279. lp872x_set_dvs(lp, dvs->vsel, dvs->gpio);
  280. addr = lp872x_select_buck_vout_addr(lp, buck);
  281. if (!lp872x_is_valid_buck_addr(addr))
  282. return -EINVAL;
  283. return lp872x_update_bits(lp, addr, mask, selector);
  284. }
  285. static int lp872x_buck_get_voltage_sel(struct regulator_dev *rdev)
  286. {
  287. struct lp872x *lp = rdev_get_drvdata(rdev);
  288. enum lp872x_regulator_id buck = rdev_get_id(rdev);
  289. u8 addr, val;
  290. int ret;
  291. addr = lp872x_select_buck_vout_addr(lp, buck);
  292. if (!lp872x_is_valid_buck_addr(addr))
  293. return -EINVAL;
  294. ret = lp872x_read_byte(lp, addr, &val);
  295. if (ret)
  296. return ret;
  297. return val & LP872X_VOUT_M;
  298. }
  299. static int lp872x_buck_set_mode(struct regulator_dev *rdev, unsigned int mode)
  300. {
  301. struct lp872x *lp = rdev_get_drvdata(rdev);
  302. enum lp872x_regulator_id buck = rdev_get_id(rdev);
  303. u8 addr, mask, shift, val;
  304. switch (buck) {
  305. case LP8720_ID_BUCK:
  306. addr = LP8720_BUCK_VOUT2;
  307. mask = LP8720_BUCK_FPWM_M;
  308. shift = LP8720_BUCK_FPWM_S;
  309. break;
  310. case LP8725_ID_BUCK1:
  311. addr = LP8725_BUCK_CTRL;
  312. mask = LP8725_BUCK1_FPWM_M;
  313. shift = LP8725_BUCK1_FPWM_S;
  314. break;
  315. case LP8725_ID_BUCK2:
  316. addr = LP8725_BUCK_CTRL;
  317. mask = LP8725_BUCK2_FPWM_M;
  318. shift = LP8725_BUCK2_FPWM_S;
  319. break;
  320. default:
  321. return -EINVAL;
  322. }
  323. if (mode == REGULATOR_MODE_FAST)
  324. val = LP872X_FORCE_PWM << shift;
  325. else if (mode == REGULATOR_MODE_NORMAL)
  326. val = LP872X_AUTO_PWM << shift;
  327. else
  328. return -EINVAL;
  329. return lp872x_update_bits(lp, addr, mask, val);
  330. }
  331. static unsigned int lp872x_buck_get_mode(struct regulator_dev *rdev)
  332. {
  333. struct lp872x *lp = rdev_get_drvdata(rdev);
  334. enum lp872x_regulator_id buck = rdev_get_id(rdev);
  335. u8 addr, mask, val;
  336. int ret;
  337. switch (buck) {
  338. case LP8720_ID_BUCK:
  339. addr = LP8720_BUCK_VOUT2;
  340. mask = LP8720_BUCK_FPWM_M;
  341. break;
  342. case LP8725_ID_BUCK1:
  343. addr = LP8725_BUCK_CTRL;
  344. mask = LP8725_BUCK1_FPWM_M;
  345. break;
  346. case LP8725_ID_BUCK2:
  347. addr = LP8725_BUCK_CTRL;
  348. mask = LP8725_BUCK2_FPWM_M;
  349. break;
  350. default:
  351. return -EINVAL;
  352. }
  353. ret = lp872x_read_byte(lp, addr, &val);
  354. if (ret)
  355. return ret;
  356. return val & mask ? REGULATOR_MODE_FAST : REGULATOR_MODE_NORMAL;
  357. }
  358. static const struct regulator_ops lp872x_ldo_ops = {
  359. .list_voltage = regulator_list_voltage_table,
  360. .map_voltage = regulator_map_voltage_ascend,
  361. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  362. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  363. .enable = regulator_enable_regmap,
  364. .disable = regulator_disable_regmap,
  365. .is_enabled = regulator_is_enabled_regmap,
  366. .enable_time = lp872x_regulator_enable_time,
  367. };
  368. static const struct regulator_ops lp8720_buck_ops = {
  369. .list_voltage = regulator_list_voltage_table,
  370. .map_voltage = regulator_map_voltage_ascend,
  371. .set_voltage_sel = lp872x_buck_set_voltage_sel,
  372. .get_voltage_sel = lp872x_buck_get_voltage_sel,
  373. .enable = regulator_enable_regmap,
  374. .disable = regulator_disable_regmap,
  375. .is_enabled = regulator_is_enabled_regmap,
  376. .enable_time = lp872x_regulator_enable_time,
  377. .set_mode = lp872x_buck_set_mode,
  378. .get_mode = lp872x_buck_get_mode,
  379. };
  380. static const struct regulator_ops lp8725_buck_ops = {
  381. .list_voltage = regulator_list_voltage_table,
  382. .map_voltage = regulator_map_voltage_ascend,
  383. .set_voltage_sel = lp872x_buck_set_voltage_sel,
  384. .get_voltage_sel = lp872x_buck_get_voltage_sel,
  385. .enable = regulator_enable_regmap,
  386. .disable = regulator_disable_regmap,
  387. .is_enabled = regulator_is_enabled_regmap,
  388. .enable_time = lp872x_regulator_enable_time,
  389. .set_mode = lp872x_buck_set_mode,
  390. .get_mode = lp872x_buck_get_mode,
  391. .set_current_limit = regulator_set_current_limit_regmap,
  392. .get_current_limit = regulator_get_current_limit_regmap,
  393. };
  394. static const struct regulator_desc lp8720_regulator_desc[] = {
  395. {
  396. .name = "ldo1",
  397. .of_match = of_match_ptr("ldo1"),
  398. .id = LP8720_ID_LDO1,
  399. .ops = &lp872x_ldo_ops,
  400. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  401. .volt_table = lp872x_ldo_vtbl,
  402. .type = REGULATOR_VOLTAGE,
  403. .owner = THIS_MODULE,
  404. .vsel_reg = LP872X_LDO1_VOUT,
  405. .vsel_mask = LP872X_VOUT_M,
  406. .enable_reg = LP8720_ENABLE,
  407. .enable_mask = LP872X_EN_LDO1_M,
  408. },
  409. {
  410. .name = "ldo2",
  411. .of_match = of_match_ptr("ldo2"),
  412. .id = LP8720_ID_LDO2,
  413. .ops = &lp872x_ldo_ops,
  414. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  415. .volt_table = lp872x_ldo_vtbl,
  416. .type = REGULATOR_VOLTAGE,
  417. .owner = THIS_MODULE,
  418. .vsel_reg = LP872X_LDO2_VOUT,
  419. .vsel_mask = LP872X_VOUT_M,
  420. .enable_reg = LP8720_ENABLE,
  421. .enable_mask = LP872X_EN_LDO2_M,
  422. },
  423. {
  424. .name = "ldo3",
  425. .of_match = of_match_ptr("ldo3"),
  426. .id = LP8720_ID_LDO3,
  427. .ops = &lp872x_ldo_ops,
  428. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  429. .volt_table = lp872x_ldo_vtbl,
  430. .type = REGULATOR_VOLTAGE,
  431. .owner = THIS_MODULE,
  432. .vsel_reg = LP872X_LDO3_VOUT,
  433. .vsel_mask = LP872X_VOUT_M,
  434. .enable_reg = LP8720_ENABLE,
  435. .enable_mask = LP872X_EN_LDO3_M,
  436. },
  437. {
  438. .name = "ldo4",
  439. .of_match = of_match_ptr("ldo4"),
  440. .id = LP8720_ID_LDO4,
  441. .ops = &lp872x_ldo_ops,
  442. .n_voltages = ARRAY_SIZE(lp8720_ldo4_vtbl),
  443. .volt_table = lp8720_ldo4_vtbl,
  444. .type = REGULATOR_VOLTAGE,
  445. .owner = THIS_MODULE,
  446. .vsel_reg = LP872X_LDO4_VOUT,
  447. .vsel_mask = LP872X_VOUT_M,
  448. .enable_reg = LP8720_ENABLE,
  449. .enable_mask = LP872X_EN_LDO4_M,
  450. },
  451. {
  452. .name = "ldo5",
  453. .of_match = of_match_ptr("ldo5"),
  454. .id = LP8720_ID_LDO5,
  455. .ops = &lp872x_ldo_ops,
  456. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  457. .volt_table = lp872x_ldo_vtbl,
  458. .type = REGULATOR_VOLTAGE,
  459. .owner = THIS_MODULE,
  460. .vsel_reg = LP872X_LDO5_VOUT,
  461. .vsel_mask = LP872X_VOUT_M,
  462. .enable_reg = LP8720_ENABLE,
  463. .enable_mask = LP872X_EN_LDO5_M,
  464. },
  465. {
  466. .name = "buck",
  467. .of_match = of_match_ptr("buck"),
  468. .id = LP8720_ID_BUCK,
  469. .ops = &lp8720_buck_ops,
  470. .n_voltages = ARRAY_SIZE(lp8720_buck_vtbl),
  471. .volt_table = lp8720_buck_vtbl,
  472. .type = REGULATOR_VOLTAGE,
  473. .owner = THIS_MODULE,
  474. .enable_reg = LP8720_ENABLE,
  475. .enable_mask = LP8720_EN_BUCK_M,
  476. },
  477. };
  478. static const struct regulator_desc lp8725_regulator_desc[] = {
  479. {
  480. .name = "ldo1",
  481. .of_match = of_match_ptr("ldo1"),
  482. .id = LP8725_ID_LDO1,
  483. .ops = &lp872x_ldo_ops,
  484. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  485. .volt_table = lp872x_ldo_vtbl,
  486. .type = REGULATOR_VOLTAGE,
  487. .owner = THIS_MODULE,
  488. .vsel_reg = LP872X_LDO1_VOUT,
  489. .vsel_mask = LP872X_VOUT_M,
  490. .enable_reg = LP8725_LDO_CTRL,
  491. .enable_mask = LP872X_EN_LDO1_M,
  492. },
  493. {
  494. .name = "ldo2",
  495. .of_match = of_match_ptr("ldo2"),
  496. .id = LP8725_ID_LDO2,
  497. .ops = &lp872x_ldo_ops,
  498. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  499. .volt_table = lp872x_ldo_vtbl,
  500. .type = REGULATOR_VOLTAGE,
  501. .owner = THIS_MODULE,
  502. .vsel_reg = LP872X_LDO2_VOUT,
  503. .vsel_mask = LP872X_VOUT_M,
  504. .enable_reg = LP8725_LDO_CTRL,
  505. .enable_mask = LP872X_EN_LDO2_M,
  506. },
  507. {
  508. .name = "ldo3",
  509. .of_match = of_match_ptr("ldo3"),
  510. .id = LP8725_ID_LDO3,
  511. .ops = &lp872x_ldo_ops,
  512. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  513. .volt_table = lp872x_ldo_vtbl,
  514. .type = REGULATOR_VOLTAGE,
  515. .owner = THIS_MODULE,
  516. .vsel_reg = LP872X_LDO3_VOUT,
  517. .vsel_mask = LP872X_VOUT_M,
  518. .enable_reg = LP8725_LDO_CTRL,
  519. .enable_mask = LP872X_EN_LDO3_M,
  520. },
  521. {
  522. .name = "ldo4",
  523. .of_match = of_match_ptr("ldo4"),
  524. .id = LP8725_ID_LDO4,
  525. .ops = &lp872x_ldo_ops,
  526. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  527. .volt_table = lp872x_ldo_vtbl,
  528. .type = REGULATOR_VOLTAGE,
  529. .owner = THIS_MODULE,
  530. .vsel_reg = LP872X_LDO4_VOUT,
  531. .vsel_mask = LP872X_VOUT_M,
  532. .enable_reg = LP8725_LDO_CTRL,
  533. .enable_mask = LP872X_EN_LDO4_M,
  534. },
  535. {
  536. .name = "ldo5",
  537. .of_match = of_match_ptr("ldo5"),
  538. .id = LP8725_ID_LDO5,
  539. .ops = &lp872x_ldo_ops,
  540. .n_voltages = ARRAY_SIZE(lp872x_ldo_vtbl),
  541. .volt_table = lp872x_ldo_vtbl,
  542. .type = REGULATOR_VOLTAGE,
  543. .owner = THIS_MODULE,
  544. .vsel_reg = LP872X_LDO5_VOUT,
  545. .vsel_mask = LP872X_VOUT_M,
  546. .enable_reg = LP8725_LDO_CTRL,
  547. .enable_mask = LP872X_EN_LDO5_M,
  548. },
  549. {
  550. .name = "lilo1",
  551. .of_match = of_match_ptr("lilo1"),
  552. .id = LP8725_ID_LILO1,
  553. .ops = &lp872x_ldo_ops,
  554. .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
  555. .volt_table = lp8725_lilo_vtbl,
  556. .type = REGULATOR_VOLTAGE,
  557. .owner = THIS_MODULE,
  558. .vsel_reg = LP8725_LILO1_VOUT,
  559. .vsel_mask = LP872X_VOUT_M,
  560. .enable_reg = LP8725_LDO_CTRL,
  561. .enable_mask = LP8725_EN_LILO1_M,
  562. },
  563. {
  564. .name = "lilo2",
  565. .of_match = of_match_ptr("lilo2"),
  566. .id = LP8725_ID_LILO2,
  567. .ops = &lp872x_ldo_ops,
  568. .n_voltages = ARRAY_SIZE(lp8725_lilo_vtbl),
  569. .volt_table = lp8725_lilo_vtbl,
  570. .type = REGULATOR_VOLTAGE,
  571. .owner = THIS_MODULE,
  572. .vsel_reg = LP8725_LILO2_VOUT,
  573. .vsel_mask = LP872X_VOUT_M,
  574. .enable_reg = LP8725_LDO_CTRL,
  575. .enable_mask = LP8725_EN_LILO2_M,
  576. },
  577. {
  578. .name = "buck1",
  579. .of_match = of_match_ptr("buck1"),
  580. .id = LP8725_ID_BUCK1,
  581. .ops = &lp8725_buck_ops,
  582. .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
  583. .volt_table = lp8725_buck_vtbl,
  584. .type = REGULATOR_VOLTAGE,
  585. .owner = THIS_MODULE,
  586. .enable_reg = LP872X_GENERAL_CFG,
  587. .enable_mask = LP8725_BUCK1_EN_M,
  588. .curr_table = lp8725_buck_uA,
  589. .n_current_limits = ARRAY_SIZE(lp8725_buck_uA),
  590. .csel_reg = LP8725_BUCK1_VOUT2,
  591. .csel_mask = LP8725_BUCK_CL_M,
  592. },
  593. {
  594. .name = "buck2",
  595. .of_match = of_match_ptr("buck2"),
  596. .id = LP8725_ID_BUCK2,
  597. .ops = &lp8725_buck_ops,
  598. .n_voltages = ARRAY_SIZE(lp8725_buck_vtbl),
  599. .volt_table = lp8725_buck_vtbl,
  600. .type = REGULATOR_VOLTAGE,
  601. .owner = THIS_MODULE,
  602. .enable_reg = LP872X_GENERAL_CFG,
  603. .enable_mask = LP8725_BUCK2_EN_M,
  604. .curr_table = lp8725_buck_uA,
  605. .n_current_limits = ARRAY_SIZE(lp8725_buck_uA),
  606. .csel_reg = LP8725_BUCK2_VOUT2,
  607. .csel_mask = LP8725_BUCK_CL_M,
  608. },
  609. };
  610. static int lp872x_init_dvs(struct lp872x *lp)
  611. {
  612. struct lp872x_dvs *dvs = lp->pdata ? lp->pdata->dvs : NULL;
  613. enum gpiod_flags pinstate;
  614. u8 mask[] = { LP8720_EXT_DVS_M, LP8725_DVS1_M | LP8725_DVS2_M };
  615. u8 default_dvs_mode[] = { LP8720_DEFAULT_DVS, LP8725_DEFAULT_DVS };
  616. if (!dvs)
  617. goto set_default_dvs_mode;
  618. if (!dvs->gpio)
  619. goto set_default_dvs_mode;
  620. pinstate = dvs->init_state;
  621. dvs->gpio = devm_gpiod_get_optional(lp->dev, "ti,dvs", pinstate);
  622. if (IS_ERR(dvs->gpio)) {
  623. dev_err(lp->dev, "gpio request err: %ld\n", PTR_ERR(dvs->gpio));
  624. return PTR_ERR(dvs->gpio);
  625. }
  626. lp->dvs_pin = pinstate;
  627. return 0;
  628. set_default_dvs_mode:
  629. return lp872x_update_bits(lp, LP872X_GENERAL_CFG, mask[lp->chipid],
  630. default_dvs_mode[lp->chipid]);
  631. }
  632. static int lp872x_hw_enable(struct lp872x *lp)
  633. {
  634. if (!lp->pdata)
  635. return -EINVAL;
  636. if (!lp->pdata->enable_gpio)
  637. return 0;
  638. /* Always set enable GPIO high. */
  639. lp->pdata->enable_gpio = devm_gpiod_get_optional(lp->dev, "enable", GPIOD_OUT_HIGH);
  640. if (IS_ERR(lp->pdata->enable_gpio)) {
  641. dev_err(lp->dev, "gpio request err: %ld\n", PTR_ERR(lp->pdata->enable_gpio));
  642. return PTR_ERR(lp->pdata->enable_gpio);
  643. }
  644. /* Each chip has a different enable delay. */
  645. if (lp->chipid == LP8720)
  646. usleep_range(LP8720_ENABLE_DELAY, 1.5 * LP8720_ENABLE_DELAY);
  647. else
  648. usleep_range(LP8725_ENABLE_DELAY, 1.5 * LP8725_ENABLE_DELAY);
  649. return 0;
  650. }
  651. static int lp872x_config(struct lp872x *lp)
  652. {
  653. struct lp872x_platform_data *pdata = lp->pdata;
  654. int ret;
  655. if (!pdata || !pdata->update_config)
  656. goto init_dvs;
  657. ret = lp872x_write_byte(lp, LP872X_GENERAL_CFG, pdata->general_config);
  658. if (ret)
  659. return ret;
  660. init_dvs:
  661. return lp872x_init_dvs(lp);
  662. }
  663. static struct regulator_init_data
  664. *lp872x_find_regulator_init_data(int id, struct lp872x *lp)
  665. {
  666. struct lp872x_platform_data *pdata = lp->pdata;
  667. int i;
  668. if (!pdata)
  669. return NULL;
  670. for (i = 0; i < lp->num_regulators; i++) {
  671. if (pdata->regulator_data[i].id == id)
  672. return pdata->regulator_data[i].init_data;
  673. }
  674. return NULL;
  675. }
  676. static int lp872x_regulator_register(struct lp872x *lp)
  677. {
  678. const struct regulator_desc *desc;
  679. struct regulator_config cfg = { };
  680. struct regulator_dev *rdev;
  681. int i;
  682. for (i = 0; i < lp->num_regulators; i++) {
  683. desc = (lp->chipid == LP8720) ? &lp8720_regulator_desc[i] :
  684. &lp8725_regulator_desc[i];
  685. cfg.dev = lp->dev;
  686. cfg.init_data = lp872x_find_regulator_init_data(desc->id, lp);
  687. cfg.driver_data = lp;
  688. cfg.regmap = lp->regmap;
  689. rdev = devm_regulator_register(lp->dev, desc, &cfg);
  690. if (IS_ERR(rdev)) {
  691. dev_err(lp->dev, "regulator register err");
  692. return PTR_ERR(rdev);
  693. }
  694. }
  695. return 0;
  696. }
  697. static const struct regmap_config lp872x_regmap_config = {
  698. .reg_bits = 8,
  699. .val_bits = 8,
  700. .max_register = MAX_REGISTERS,
  701. };
  702. #ifdef CONFIG_OF
  703. #define LP872X_VALID_OPMODE (REGULATOR_MODE_FAST | REGULATOR_MODE_NORMAL)
  704. static struct of_regulator_match lp8720_matches[] = {
  705. { .name = "ldo1", .driver_data = (void *)LP8720_ID_LDO1, },
  706. { .name = "ldo2", .driver_data = (void *)LP8720_ID_LDO2, },
  707. { .name = "ldo3", .driver_data = (void *)LP8720_ID_LDO3, },
  708. { .name = "ldo4", .driver_data = (void *)LP8720_ID_LDO4, },
  709. { .name = "ldo5", .driver_data = (void *)LP8720_ID_LDO5, },
  710. { .name = "buck", .driver_data = (void *)LP8720_ID_BUCK, },
  711. };
  712. static struct of_regulator_match lp8725_matches[] = {
  713. { .name = "ldo1", .driver_data = (void *)LP8725_ID_LDO1, },
  714. { .name = "ldo2", .driver_data = (void *)LP8725_ID_LDO2, },
  715. { .name = "ldo3", .driver_data = (void *)LP8725_ID_LDO3, },
  716. { .name = "ldo4", .driver_data = (void *)LP8725_ID_LDO4, },
  717. { .name = "ldo5", .driver_data = (void *)LP8725_ID_LDO5, },
  718. { .name = "lilo1", .driver_data = (void *)LP8725_ID_LILO1, },
  719. { .name = "lilo2", .driver_data = (void *)LP8725_ID_LILO2, },
  720. { .name = "buck1", .driver_data = (void *)LP8725_ID_BUCK1, },
  721. { .name = "buck2", .driver_data = (void *)LP8725_ID_BUCK2, },
  722. };
  723. static struct lp872x_platform_data
  724. *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
  725. {
  726. struct device_node *np = dev->of_node;
  727. struct lp872x_platform_data *pdata;
  728. struct of_regulator_match *match;
  729. int num_matches;
  730. int count;
  731. int i;
  732. u8 dvs_state;
  733. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  734. if (!pdata)
  735. return ERR_PTR(-ENOMEM);
  736. of_property_read_u8(np, "ti,general-config", &pdata->general_config);
  737. if (of_find_property(np, "ti,update-config", NULL))
  738. pdata->update_config = true;
  739. pdata->dvs = devm_kzalloc(dev, sizeof(struct lp872x_dvs), GFP_KERNEL);
  740. if (!pdata->dvs)
  741. return ERR_PTR(-ENOMEM);
  742. of_property_read_u8(np, "ti,dvs-vsel", (u8 *)&pdata->dvs->vsel);
  743. of_property_read_u8(np, "ti,dvs-state", &dvs_state);
  744. pdata->dvs->init_state = dvs_state ? GPIOD_OUT_HIGH : GPIOD_OUT_LOW;
  745. if (of_get_child_count(np) == 0)
  746. goto out;
  747. switch (which) {
  748. case LP8720:
  749. match = lp8720_matches;
  750. num_matches = ARRAY_SIZE(lp8720_matches);
  751. break;
  752. case LP8725:
  753. match = lp8725_matches;
  754. num_matches = ARRAY_SIZE(lp8725_matches);
  755. break;
  756. default:
  757. goto out;
  758. }
  759. count = of_regulator_match(dev, np, match, num_matches);
  760. if (count <= 0)
  761. goto out;
  762. for (i = 0; i < num_matches; i++) {
  763. pdata->regulator_data[i].id =
  764. (enum lp872x_regulator_id)match[i].driver_data;
  765. pdata->regulator_data[i].init_data = match[i].init_data;
  766. }
  767. out:
  768. return pdata;
  769. }
  770. #else
  771. static struct lp872x_platform_data
  772. *lp872x_populate_pdata_from_dt(struct device *dev, enum lp872x_id which)
  773. {
  774. return NULL;
  775. }
  776. #endif
  777. static int lp872x_probe(struct i2c_client *cl, const struct i2c_device_id *id)
  778. {
  779. struct lp872x *lp;
  780. struct lp872x_platform_data *pdata;
  781. int ret;
  782. static const int lp872x_num_regulators[] = {
  783. [LP8720] = LP8720_NUM_REGULATORS,
  784. [LP8725] = LP8725_NUM_REGULATORS,
  785. };
  786. if (cl->dev.of_node) {
  787. pdata = lp872x_populate_pdata_from_dt(&cl->dev,
  788. (enum lp872x_id)id->driver_data);
  789. if (IS_ERR(pdata))
  790. return PTR_ERR(pdata);
  791. } else {
  792. pdata = dev_get_platdata(&cl->dev);
  793. }
  794. lp = devm_kzalloc(&cl->dev, sizeof(struct lp872x), GFP_KERNEL);
  795. if (!lp)
  796. return -ENOMEM;
  797. lp->num_regulators = lp872x_num_regulators[id->driver_data];
  798. lp->regmap = devm_regmap_init_i2c(cl, &lp872x_regmap_config);
  799. if (IS_ERR(lp->regmap)) {
  800. ret = PTR_ERR(lp->regmap);
  801. dev_err(&cl->dev, "regmap init i2c err: %d\n", ret);
  802. return ret;
  803. }
  804. lp->dev = &cl->dev;
  805. lp->pdata = pdata;
  806. lp->chipid = id->driver_data;
  807. i2c_set_clientdata(cl, lp);
  808. ret = lp872x_hw_enable(lp);
  809. if (ret)
  810. return ret;
  811. ret = lp872x_config(lp);
  812. if (ret)
  813. return ret;
  814. return lp872x_regulator_register(lp);
  815. }
  816. static const struct of_device_id lp872x_dt_ids[] = {
  817. { .compatible = "ti,lp8720", },
  818. { .compatible = "ti,lp8725", },
  819. { }
  820. };
  821. MODULE_DEVICE_TABLE(of, lp872x_dt_ids);
  822. static const struct i2c_device_id lp872x_ids[] = {
  823. {"lp8720", LP8720},
  824. {"lp8725", LP8725},
  825. { }
  826. };
  827. MODULE_DEVICE_TABLE(i2c, lp872x_ids);
  828. static struct i2c_driver lp872x_driver = {
  829. .driver = {
  830. .name = "lp872x",
  831. .of_match_table = of_match_ptr(lp872x_dt_ids),
  832. },
  833. .probe = lp872x_probe,
  834. .id_table = lp872x_ids,
  835. };
  836. module_i2c_driver(lp872x_driver);
  837. MODULE_DESCRIPTION("TI/National Semiconductor LP872x PMU Regulator Driver");
  838. MODULE_AUTHOR("Milo Kim");
  839. MODULE_LICENSE("GPL");