tps65912-regulator.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561
  1. /*
  2. * tps65912.c -- TI tps65912
  3. *
  4. * Copyright 2011 Texas Instruments Inc.
  5. *
  6. * Author: Margarita Olaya Cabrera <magi@slimlogic.co.uk>
  7. *
  8. * This program is free software; you can redistribute it and/or modify it
  9. * under the terms of the GNU General Public License as published by the
  10. * Free Software Foundation; either version 2 of the License, or (at your
  11. * option) any later version.
  12. *
  13. * This driver is based on wm8350 implementation.
  14. */
  15. #include <linux/kernel.h>
  16. #include <linux/module.h>
  17. #include <linux/init.h>
  18. #include <linux/err.h>
  19. #include <linux/platform_device.h>
  20. #include <linux/regulator/driver.h>
  21. #include <linux/regulator/machine.h>
  22. #include <linux/slab.h>
  23. #include <linux/gpio.h>
  24. #include <linux/mfd/tps65912.h>
  25. /* DCDC's */
  26. #define TPS65912_REG_DCDC1 0
  27. #define TPS65912_REG_DCDC2 1
  28. #define TPS65912_REG_DCDC3 2
  29. #define TPS65912_REG_DCDC4 3
  30. /* LDOs */
  31. #define TPS65912_REG_LDO1 4
  32. #define TPS65912_REG_LDO2 5
  33. #define TPS65912_REG_LDO3 6
  34. #define TPS65912_REG_LDO4 7
  35. #define TPS65912_REG_LDO5 8
  36. #define TPS65912_REG_LDO6 9
  37. #define TPS65912_REG_LDO7 10
  38. #define TPS65912_REG_LDO8 11
  39. #define TPS65912_REG_LDO9 12
  40. #define TPS65912_REG_LDO10 13
  41. /* Number of step-down converters available */
  42. #define TPS65912_NUM_DCDC 4
  43. /* Number of LDO voltage regulators available */
  44. #define TPS65912_NUM_LDO 10
  45. /* Number of total regulators available */
  46. #define TPS65912_NUM_REGULATOR (TPS65912_NUM_DCDC + TPS65912_NUM_LDO)
  47. #define TPS65912_REG_ENABLED 0x80
  48. #define OP_SELREG_MASK 0x40
  49. #define OP_SELREG_SHIFT 6
  50. struct tps_info {
  51. const char *name;
  52. };
  53. static struct tps_info tps65912_regs[] = {
  54. {
  55. .name = "DCDC1",
  56. },
  57. {
  58. .name = "DCDC2",
  59. },
  60. {
  61. .name = "DCDC3",
  62. },
  63. {
  64. .name = "DCDC4",
  65. },
  66. {
  67. .name = "LDO1",
  68. },
  69. {
  70. .name = "LDO2",
  71. },
  72. {
  73. .name = "LDO3",
  74. },
  75. {
  76. .name = "LDO4",
  77. },
  78. {
  79. .name = "LDO5",
  80. },
  81. {
  82. .name = "LDO6",
  83. },
  84. {
  85. .name = "LDO7",
  86. },
  87. {
  88. .name = "LDO8",
  89. },
  90. {
  91. .name = "LDO9",
  92. },
  93. {
  94. .name = "LDO10",
  95. },
  96. };
  97. struct tps65912_reg {
  98. struct regulator_desc desc[TPS65912_NUM_REGULATOR];
  99. struct tps65912 *mfd;
  100. struct regulator_dev *rdev[TPS65912_NUM_REGULATOR];
  101. struct tps_info *info[TPS65912_NUM_REGULATOR];
  102. /* for read/write access */
  103. struct mutex io_lock;
  104. int mode;
  105. int (*get_ctrl_reg)(int);
  106. int dcdc_range[TPS65912_NUM_DCDC];
  107. int pwm_mode_reg;
  108. int eco_reg;
  109. };
  110. static const struct regulator_linear_range tps65912_ldo_ranges[] = {
  111. { .min_uV = 800000, .max_uV = 1600000, .min_sel = 0, .max_sel = 32,
  112. .uV_step = 25000 },
  113. { .min_uV = 1650000, .max_uV = 3000000, .min_sel = 33, .max_sel = 60,
  114. .uV_step = 50000 },
  115. { .min_uV = 3100000, .max_uV = 3300000, .min_sel = 61, .max_sel = 63,
  116. .uV_step = 100000 },
  117. };
  118. static int tps65912_get_range(struct tps65912_reg *pmic, int id)
  119. {
  120. struct tps65912 *mfd = pmic->mfd;
  121. int range;
  122. switch (id) {
  123. case TPS65912_REG_DCDC1:
  124. range = tps65912_reg_read(mfd, TPS65912_DCDC1_LIMIT);
  125. break;
  126. case TPS65912_REG_DCDC2:
  127. range = tps65912_reg_read(mfd, TPS65912_DCDC2_LIMIT);
  128. break;
  129. case TPS65912_REG_DCDC3:
  130. range = tps65912_reg_read(mfd, TPS65912_DCDC3_LIMIT);
  131. break;
  132. case TPS65912_REG_DCDC4:
  133. range = tps65912_reg_read(mfd, TPS65912_DCDC4_LIMIT);
  134. break;
  135. default:
  136. return 0;
  137. }
  138. if (range >= 0)
  139. range = (range & DCDC_LIMIT_RANGE_MASK)
  140. >> DCDC_LIMIT_RANGE_SHIFT;
  141. pmic->dcdc_range[id] = range;
  142. return range;
  143. }
  144. static unsigned long tps65912_vsel_to_uv_range0(u8 vsel)
  145. {
  146. unsigned long uv;
  147. uv = ((vsel * 12500) + 500000);
  148. return uv;
  149. }
  150. static unsigned long tps65912_vsel_to_uv_range1(u8 vsel)
  151. {
  152. unsigned long uv;
  153. uv = ((vsel * 12500) + 700000);
  154. return uv;
  155. }
  156. static unsigned long tps65912_vsel_to_uv_range2(u8 vsel)
  157. {
  158. unsigned long uv;
  159. uv = ((vsel * 25000) + 500000);
  160. return uv;
  161. }
  162. static unsigned long tps65912_vsel_to_uv_range3(u8 vsel)
  163. {
  164. unsigned long uv;
  165. if (vsel == 0x3f)
  166. uv = 3800000;
  167. else
  168. uv = ((vsel * 50000) + 500000);
  169. return uv;
  170. }
  171. static int tps65912_get_ctrl_register(int id)
  172. {
  173. if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4)
  174. return id * 3 + TPS65912_DCDC1_AVS;
  175. else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10)
  176. return id - TPS65912_REG_LDO5 + TPS65912_LDO5;
  177. else
  178. return -EINVAL;
  179. }
  180. static int tps65912_get_sel_register(struct tps65912_reg *pmic, int id)
  181. {
  182. struct tps65912 *mfd = pmic->mfd;
  183. int opvsel;
  184. u8 reg = 0;
  185. if (id >= TPS65912_REG_DCDC1 && id <= TPS65912_REG_LDO4) {
  186. opvsel = tps65912_reg_read(mfd, id * 3 + TPS65912_DCDC1_OP);
  187. if (opvsel & OP_SELREG_MASK)
  188. reg = id * 3 + TPS65912_DCDC1_AVS;
  189. else
  190. reg = id * 3 + TPS65912_DCDC1_OP;
  191. } else if (id >= TPS65912_REG_LDO5 && id <= TPS65912_REG_LDO10) {
  192. reg = id - TPS65912_REG_LDO5 + TPS65912_LDO5;
  193. } else {
  194. return -EINVAL;
  195. }
  196. return reg;
  197. }
  198. static int tps65912_get_mode_regiters(struct tps65912_reg *pmic, int id)
  199. {
  200. switch (id) {
  201. case TPS65912_REG_DCDC1:
  202. pmic->pwm_mode_reg = TPS65912_DCDC1_CTRL;
  203. pmic->eco_reg = TPS65912_DCDC1_AVS;
  204. break;
  205. case TPS65912_REG_DCDC2:
  206. pmic->pwm_mode_reg = TPS65912_DCDC2_CTRL;
  207. pmic->eco_reg = TPS65912_DCDC2_AVS;
  208. break;
  209. case TPS65912_REG_DCDC3:
  210. pmic->pwm_mode_reg = TPS65912_DCDC3_CTRL;
  211. pmic->eco_reg = TPS65912_DCDC3_AVS;
  212. break;
  213. case TPS65912_REG_DCDC4:
  214. pmic->pwm_mode_reg = TPS65912_DCDC4_CTRL;
  215. pmic->eco_reg = TPS65912_DCDC4_AVS;
  216. break;
  217. default:
  218. return -EINVAL;
  219. }
  220. return 0;
  221. }
  222. static int tps65912_reg_is_enabled(struct regulator_dev *dev)
  223. {
  224. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  225. struct tps65912 *mfd = pmic->mfd;
  226. int reg, value, id = rdev_get_id(dev);
  227. if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
  228. return -EINVAL;
  229. reg = pmic->get_ctrl_reg(id);
  230. if (reg < 0)
  231. return reg;
  232. value = tps65912_reg_read(mfd, reg);
  233. if (value < 0)
  234. return value;
  235. return value & TPS65912_REG_ENABLED;
  236. }
  237. static int tps65912_reg_enable(struct regulator_dev *dev)
  238. {
  239. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  240. struct tps65912 *mfd = pmic->mfd;
  241. int id = rdev_get_id(dev);
  242. int reg;
  243. if (id < TPS65912_REG_DCDC1 || id > TPS65912_REG_LDO10)
  244. return -EINVAL;
  245. reg = pmic->get_ctrl_reg(id);
  246. if (reg < 0)
  247. return reg;
  248. return tps65912_set_bits(mfd, reg, TPS65912_REG_ENABLED);
  249. }
  250. static int tps65912_reg_disable(struct regulator_dev *dev)
  251. {
  252. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  253. struct tps65912 *mfd = pmic->mfd;
  254. int id = rdev_get_id(dev), reg;
  255. reg = pmic->get_ctrl_reg(id);
  256. if (reg < 0)
  257. return reg;
  258. return tps65912_clear_bits(mfd, reg, TPS65912_REG_ENABLED);
  259. }
  260. static int tps65912_set_mode(struct regulator_dev *dev, unsigned int mode)
  261. {
  262. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  263. struct tps65912 *mfd = pmic->mfd;
  264. int pwm_mode, eco, id = rdev_get_id(dev);
  265. tps65912_get_mode_regiters(pmic, id);
  266. pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
  267. eco = tps65912_reg_read(mfd, pmic->eco_reg);
  268. pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
  269. eco &= DCDC_AVS_ECO_MASK;
  270. switch (mode) {
  271. case REGULATOR_MODE_FAST:
  272. /* Verify if mode alredy set */
  273. if (pwm_mode && !eco)
  274. break;
  275. tps65912_set_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
  276. tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
  277. break;
  278. case REGULATOR_MODE_NORMAL:
  279. case REGULATOR_MODE_IDLE:
  280. if (!pwm_mode && !eco)
  281. break;
  282. tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
  283. tps65912_clear_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
  284. break;
  285. case REGULATOR_MODE_STANDBY:
  286. if (!pwm_mode && eco)
  287. break;
  288. tps65912_clear_bits(mfd, pmic->pwm_mode_reg, DCDCCTRL_DCDC_MODE_MASK);
  289. tps65912_set_bits(mfd, pmic->eco_reg, DCDC_AVS_ECO_MASK);
  290. break;
  291. default:
  292. return -EINVAL;
  293. }
  294. return 0;
  295. }
  296. static unsigned int tps65912_get_mode(struct regulator_dev *dev)
  297. {
  298. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  299. struct tps65912 *mfd = pmic->mfd;
  300. int pwm_mode, eco, mode = 0, id = rdev_get_id(dev);
  301. tps65912_get_mode_regiters(pmic, id);
  302. pwm_mode = tps65912_reg_read(mfd, pmic->pwm_mode_reg);
  303. eco = tps65912_reg_read(mfd, pmic->eco_reg);
  304. pwm_mode &= DCDCCTRL_DCDC_MODE_MASK;
  305. eco &= DCDC_AVS_ECO_MASK;
  306. if (pwm_mode && !eco)
  307. mode = REGULATOR_MODE_FAST;
  308. else if (!pwm_mode && !eco)
  309. mode = REGULATOR_MODE_NORMAL;
  310. else if (!pwm_mode && eco)
  311. mode = REGULATOR_MODE_STANDBY;
  312. return mode;
  313. }
  314. static int tps65912_list_voltage(struct regulator_dev *dev, unsigned selector)
  315. {
  316. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  317. int range, voltage = 0, id = rdev_get_id(dev);
  318. if (id > TPS65912_REG_DCDC4)
  319. return -EINVAL;
  320. range = pmic->dcdc_range[id];
  321. switch (range) {
  322. case 0:
  323. /* 0.5 - 1.2875V in 12.5mV steps */
  324. voltage = tps65912_vsel_to_uv_range0(selector);
  325. break;
  326. case 1:
  327. /* 0.7 - 1.4875V in 12.5mV steps */
  328. voltage = tps65912_vsel_to_uv_range1(selector);
  329. break;
  330. case 2:
  331. /* 0.5 - 2.075V in 25mV steps */
  332. voltage = tps65912_vsel_to_uv_range2(selector);
  333. break;
  334. case 3:
  335. /* 0.5 - 3.8V in 50mV steps */
  336. voltage = tps65912_vsel_to_uv_range3(selector);
  337. break;
  338. }
  339. return voltage;
  340. }
  341. static int tps65912_get_voltage_sel(struct regulator_dev *dev)
  342. {
  343. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  344. struct tps65912 *mfd = pmic->mfd;
  345. int id = rdev_get_id(dev);
  346. int reg, vsel;
  347. reg = tps65912_get_sel_register(pmic, id);
  348. if (reg < 0)
  349. return reg;
  350. vsel = tps65912_reg_read(mfd, reg);
  351. vsel &= 0x3F;
  352. return vsel;
  353. }
  354. static int tps65912_set_voltage_sel(struct regulator_dev *dev,
  355. unsigned selector)
  356. {
  357. struct tps65912_reg *pmic = rdev_get_drvdata(dev);
  358. struct tps65912 *mfd = pmic->mfd;
  359. int id = rdev_get_id(dev);
  360. int value;
  361. u8 reg;
  362. reg = tps65912_get_sel_register(pmic, id);
  363. value = tps65912_reg_read(mfd, reg);
  364. value &= 0xC0;
  365. return tps65912_reg_write(mfd, reg, selector | value);
  366. }
  367. /* Operations permitted on DCDCx */
  368. static struct regulator_ops tps65912_ops_dcdc = {
  369. .is_enabled = tps65912_reg_is_enabled,
  370. .enable = tps65912_reg_enable,
  371. .disable = tps65912_reg_disable,
  372. .set_mode = tps65912_set_mode,
  373. .get_mode = tps65912_get_mode,
  374. .get_voltage_sel = tps65912_get_voltage_sel,
  375. .set_voltage_sel = tps65912_set_voltage_sel,
  376. .list_voltage = tps65912_list_voltage,
  377. };
  378. /* Operations permitted on LDOx */
  379. static struct regulator_ops tps65912_ops_ldo = {
  380. .is_enabled = tps65912_reg_is_enabled,
  381. .enable = tps65912_reg_enable,
  382. .disable = tps65912_reg_disable,
  383. .get_voltage_sel = tps65912_get_voltage_sel,
  384. .set_voltage_sel = tps65912_set_voltage_sel,
  385. .list_voltage = regulator_list_voltage_linear_range,
  386. .map_voltage = regulator_map_voltage_linear_range,
  387. };
  388. static int tps65912_probe(struct platform_device *pdev)
  389. {
  390. struct tps65912 *tps65912 = dev_get_drvdata(pdev->dev.parent);
  391. struct regulator_config config = { };
  392. struct tps_info *info;
  393. struct regulator_init_data *reg_data;
  394. struct regulator_dev *rdev;
  395. struct tps65912_reg *pmic;
  396. struct tps65912_board *pmic_plat_data;
  397. int i, err;
  398. pmic_plat_data = dev_get_platdata(tps65912->dev);
  399. if (!pmic_plat_data)
  400. return -EINVAL;
  401. reg_data = pmic_plat_data->tps65912_pmic_init_data;
  402. pmic = devm_kzalloc(&pdev->dev, sizeof(*pmic), GFP_KERNEL);
  403. if (!pmic)
  404. return -ENOMEM;
  405. mutex_init(&pmic->io_lock);
  406. pmic->mfd = tps65912;
  407. platform_set_drvdata(pdev, pmic);
  408. pmic->get_ctrl_reg = &tps65912_get_ctrl_register;
  409. info = tps65912_regs;
  410. for (i = 0; i < TPS65912_NUM_REGULATOR; i++, info++, reg_data++) {
  411. int range = 0;
  412. /* Register the regulators */
  413. pmic->info[i] = info;
  414. pmic->desc[i].name = info->name;
  415. pmic->desc[i].id = i;
  416. pmic->desc[i].n_voltages = 64;
  417. if (i > TPS65912_REG_DCDC4) {
  418. pmic->desc[i].ops = &tps65912_ops_ldo;
  419. pmic->desc[i].linear_ranges = tps65912_ldo_ranges;
  420. pmic->desc[i].n_linear_ranges =
  421. ARRAY_SIZE(tps65912_ldo_ranges);
  422. } else {
  423. pmic->desc[i].ops = &tps65912_ops_dcdc;
  424. }
  425. pmic->desc[i].type = REGULATOR_VOLTAGE;
  426. pmic->desc[i].owner = THIS_MODULE;
  427. range = tps65912_get_range(pmic, i);
  428. config.dev = tps65912->dev;
  429. config.init_data = reg_data;
  430. config.driver_data = pmic;
  431. rdev = regulator_register(&pmic->desc[i], &config);
  432. if (IS_ERR(rdev)) {
  433. dev_err(tps65912->dev,
  434. "failed to register %s regulator\n",
  435. pdev->name);
  436. err = PTR_ERR(rdev);
  437. goto err;
  438. }
  439. /* Save regulator for cleanup */
  440. pmic->rdev[i] = rdev;
  441. }
  442. return 0;
  443. err:
  444. while (--i >= 0)
  445. regulator_unregister(pmic->rdev[i]);
  446. return err;
  447. }
  448. static int tps65912_remove(struct platform_device *pdev)
  449. {
  450. struct tps65912_reg *tps65912_reg = platform_get_drvdata(pdev);
  451. int i;
  452. for (i = 0; i < TPS65912_NUM_REGULATOR; i++)
  453. regulator_unregister(tps65912_reg->rdev[i]);
  454. return 0;
  455. }
  456. static struct platform_driver tps65912_driver = {
  457. .driver = {
  458. .name = "tps65912-pmic",
  459. .owner = THIS_MODULE,
  460. },
  461. .probe = tps65912_probe,
  462. .remove = tps65912_remove,
  463. };
  464. static int __init tps65912_init(void)
  465. {
  466. return platform_driver_register(&tps65912_driver);
  467. }
  468. subsys_initcall(tps65912_init);
  469. static void __exit tps65912_cleanup(void)
  470. {
  471. platform_driver_unregister(&tps65912_driver);
  472. }
  473. module_exit(tps65912_cleanup);
  474. MODULE_AUTHOR("Margarita Olaya Cabrera <magi@slimlogic.co.uk>");
  475. MODULE_DESCRIPTION("TPS65912 voltage regulator driver");
  476. MODULE_LICENSE("GPL v2");
  477. MODULE_ALIAS("platform:tps65912-pmic");