tps51632-regulator.c 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389
  1. /*
  2. * tps51632-regulator.c -- TI TPS51632
  3. *
  4. * Regulator driver for TPS51632 3-2-1 Phase D-Cap Step Down Driverless
  5. * Controller with serial VID control and DVFS.
  6. *
  7. * Copyright (c) 2012, NVIDIA Corporation.
  8. *
  9. * Author: Laxman Dewangan <ldewangan@nvidia.com>
  10. *
  11. * This program is free software; you can redistribute it and/or
  12. * modify it under the terms of the GNU General Public License as
  13. * published by the Free Software Foundation version 2.
  14. *
  15. * This program is distributed "as is" WITHOUT ANY WARRANTY of any kind,
  16. * whether express or implied; without even the implied warranty of
  17. * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  18. * General Public License for more details.
  19. *
  20. * You should have received a copy of the GNU General Public License
  21. * along with this program; if not, write to the Free Software
  22. * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  23. * 02111-1307, USA
  24. */
  25. #include <linux/err.h>
  26. #include <linux/i2c.h>
  27. #include <linux/init.h>
  28. #include <linux/kernel.h>
  29. #include <linux/module.h>
  30. #include <linux/of.h>
  31. #include <linux/of_device.h>
  32. #include <linux/platform_device.h>
  33. #include <linux/regmap.h>
  34. #include <linux/regulator/driver.h>
  35. #include <linux/regulator/machine.h>
  36. #include <linux/regulator/of_regulator.h>
  37. #include <linux/regulator/tps51632-regulator.h>
  38. #include <linux/slab.h>
  39. /* Register definitions */
  40. #define TPS51632_VOLTAGE_SELECT_REG 0x0
  41. #define TPS51632_VOLTAGE_BASE_REG 0x1
  42. #define TPS51632_OFFSET_REG 0x2
  43. #define TPS51632_IMON_REG 0x3
  44. #define TPS51632_VMAX_REG 0x4
  45. #define TPS51632_DVFS_CONTROL_REG 0x5
  46. #define TPS51632_POWER_STATE_REG 0x6
  47. #define TPS51632_SLEW_REGS 0x7
  48. #define TPS51632_FAULT_REG 0x14
  49. #define TPS51632_MAX_REG 0x15
  50. #define TPS51632_VOUT_MASK 0x7F
  51. #define TPS51632_VOUT_OFFSET_MASK 0x1F
  52. #define TPS51632_VMAX_MASK 0x7F
  53. #define TPS51632_VMAX_LOCK 0x80
  54. /* TPS51632_DVFS_CONTROL_REG */
  55. #define TPS51632_DVFS_PWMEN 0x1
  56. #define TPS51632_DVFS_STEP_20 0x2
  57. #define TPS51632_DVFS_VMAX_PG 0x4
  58. #define TPS51632_DVFS_PWMRST 0x8
  59. #define TPS51632_DVFS_OCA_EN 0x10
  60. #define TPS51632_DVFS_FCCM 0x20
  61. /* TPS51632_POWER_STATE_REG */
  62. #define TPS51632_POWER_STATE_MASK 0x03
  63. #define TPS51632_POWER_STATE_MULTI_PHASE_CCM 0x0
  64. #define TPS51632_POWER_STATE_SINGLE_PHASE_CCM 0x1
  65. #define TPS51632_POWER_STATE_SINGLE_PHASE_DCM 0x2
  66. #define TPS51632_MIN_VOLTAGE 500000
  67. #define TPS51632_MAX_VOLTAGE 1520000
  68. #define TPS51632_VOLTAGE_STEP_10mV 10000
  69. #define TPS51632_VOLTAGE_STEP_20mV 20000
  70. #define TPS51632_MAX_VSEL 0x7F
  71. #define TPS51632_MIN_VSEL 0x19
  72. #define TPS51632_DEFAULT_RAMP_DELAY 6000
  73. #define TPS51632_VOLT_VSEL(uV) \
  74. (DIV_ROUND_UP(uV - TPS51632_MIN_VOLTAGE, \
  75. TPS51632_VOLTAGE_STEP_10mV) + \
  76. TPS51632_MIN_VSEL)
  77. /* TPS51632 chip information */
  78. struct tps51632_chip {
  79. struct device *dev;
  80. struct regulator_desc desc;
  81. struct regulator_dev *rdev;
  82. struct regmap *regmap;
  83. };
  84. static int tps51632_dcdc_set_ramp_delay(struct regulator_dev *rdev,
  85. int ramp_delay)
  86. {
  87. struct tps51632_chip *tps = rdev_get_drvdata(rdev);
  88. int bit;
  89. int ret;
  90. if (ramp_delay == 0)
  91. bit = 0;
  92. else
  93. bit = DIV_ROUND_UP(ramp_delay, 6000) - 1;
  94. ret = regmap_write(tps->regmap, TPS51632_SLEW_REGS, BIT(bit));
  95. if (ret < 0)
  96. dev_err(tps->dev, "SLEW reg write failed, err %d\n", ret);
  97. return ret;
  98. }
  99. static struct regulator_ops tps51632_dcdc_ops = {
  100. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  101. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  102. .list_voltage = regulator_list_voltage_linear,
  103. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  104. .set_ramp_delay = tps51632_dcdc_set_ramp_delay,
  105. };
  106. static int tps51632_init_dcdc(struct tps51632_chip *tps,
  107. struct tps51632_regulator_platform_data *pdata)
  108. {
  109. int ret;
  110. uint8_t control = 0;
  111. int vsel;
  112. if (!pdata->enable_pwm_dvfs)
  113. goto skip_pwm_config;
  114. control |= TPS51632_DVFS_PWMEN;
  115. vsel = TPS51632_VOLT_VSEL(pdata->base_voltage_uV);
  116. ret = regmap_write(tps->regmap, TPS51632_VOLTAGE_BASE_REG, vsel);
  117. if (ret < 0) {
  118. dev_err(tps->dev, "BASE reg write failed, err %d\n", ret);
  119. return ret;
  120. }
  121. if (pdata->dvfs_step_20mV)
  122. control |= TPS51632_DVFS_STEP_20;
  123. if (pdata->max_voltage_uV) {
  124. unsigned int vmax;
  125. /**
  126. * TPS51632 hw behavior: VMAX register can be write only
  127. * once as it get locked after first write. The lock get
  128. * reset only when device is power-reset.
  129. * Write register only when lock bit is not enabled.
  130. */
  131. ret = regmap_read(tps->regmap, TPS51632_VMAX_REG, &vmax);
  132. if (ret < 0) {
  133. dev_err(tps->dev, "VMAX read failed, err %d\n", ret);
  134. return ret;
  135. }
  136. if (!(vmax & TPS51632_VMAX_LOCK)) {
  137. vsel = TPS51632_VOLT_VSEL(pdata->max_voltage_uV);
  138. ret = regmap_write(tps->regmap, TPS51632_VMAX_REG,
  139. vsel);
  140. if (ret < 0) {
  141. dev_err(tps->dev,
  142. "VMAX write failed, err %d\n", ret);
  143. return ret;
  144. }
  145. }
  146. }
  147. skip_pwm_config:
  148. ret = regmap_write(tps->regmap, TPS51632_DVFS_CONTROL_REG, control);
  149. if (ret < 0)
  150. dev_err(tps->dev, "DVFS reg write failed, err %d\n", ret);
  151. return ret;
  152. }
  153. static bool is_volatile_reg(struct device *dev, unsigned int reg)
  154. {
  155. switch (reg) {
  156. case TPS51632_OFFSET_REG:
  157. case TPS51632_FAULT_REG:
  158. case TPS51632_IMON_REG:
  159. return true;
  160. default:
  161. return false;
  162. }
  163. }
  164. static bool is_read_reg(struct device *dev, unsigned int reg)
  165. {
  166. switch (reg) {
  167. case 0x08 ... 0x0F:
  168. return false;
  169. default:
  170. return true;
  171. }
  172. }
  173. static bool is_write_reg(struct device *dev, unsigned int reg)
  174. {
  175. switch (reg) {
  176. case TPS51632_VOLTAGE_SELECT_REG:
  177. case TPS51632_VOLTAGE_BASE_REG:
  178. case TPS51632_VMAX_REG:
  179. case TPS51632_DVFS_CONTROL_REG:
  180. case TPS51632_POWER_STATE_REG:
  181. case TPS51632_SLEW_REGS:
  182. return true;
  183. default:
  184. return false;
  185. }
  186. }
  187. static const struct regmap_config tps51632_regmap_config = {
  188. .reg_bits = 8,
  189. .val_bits = 8,
  190. .writeable_reg = is_write_reg,
  191. .readable_reg = is_read_reg,
  192. .volatile_reg = is_volatile_reg,
  193. .max_register = TPS51632_MAX_REG - 1,
  194. .cache_type = REGCACHE_RBTREE,
  195. };
  196. #if defined(CONFIG_OF)
  197. static const struct of_device_id tps51632_of_match[] = {
  198. { .compatible = "ti,tps51632",},
  199. {},
  200. };
  201. MODULE_DEVICE_TABLE(of, tps51632_of_match);
  202. static struct tps51632_regulator_platform_data *
  203. of_get_tps51632_platform_data(struct device *dev,
  204. const struct regulator_desc *desc)
  205. {
  206. struct tps51632_regulator_platform_data *pdata;
  207. struct device_node *np = dev->of_node;
  208. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  209. if (!pdata)
  210. return NULL;
  211. pdata->reg_init_data = of_get_regulator_init_data(dev, dev->of_node,
  212. desc);
  213. if (!pdata->reg_init_data) {
  214. dev_err(dev, "Not able to get OF regulator init data\n");
  215. return NULL;
  216. }
  217. pdata->enable_pwm_dvfs =
  218. of_property_read_bool(np, "ti,enable-pwm-dvfs");
  219. pdata->dvfs_step_20mV = of_property_read_bool(np, "ti,dvfs-step-20mV");
  220. pdata->base_voltage_uV = pdata->reg_init_data->constraints.min_uV ? :
  221. TPS51632_MIN_VOLTAGE;
  222. pdata->max_voltage_uV = pdata->reg_init_data->constraints.max_uV ? :
  223. TPS51632_MAX_VOLTAGE;
  224. return pdata;
  225. }
  226. #else
  227. static struct tps51632_regulator_platform_data *
  228. of_get_tps51632_platform_data(struct device *dev,
  229. const struct regulator_desc *desc)
  230. {
  231. return NULL;
  232. }
  233. #endif
  234. static int tps51632_probe(struct i2c_client *client,
  235. const struct i2c_device_id *id)
  236. {
  237. struct tps51632_regulator_platform_data *pdata;
  238. struct regulator_dev *rdev;
  239. struct tps51632_chip *tps;
  240. int ret;
  241. struct regulator_config config = { };
  242. if (client->dev.of_node) {
  243. const struct of_device_id *match;
  244. match = of_match_device(of_match_ptr(tps51632_of_match),
  245. &client->dev);
  246. if (!match) {
  247. dev_err(&client->dev, "Error: No device match found\n");
  248. return -ENODEV;
  249. }
  250. }
  251. tps = devm_kzalloc(&client->dev, sizeof(*tps), GFP_KERNEL);
  252. if (!tps)
  253. return -ENOMEM;
  254. tps->dev = &client->dev;
  255. tps->desc.name = client->name;
  256. tps->desc.id = 0;
  257. tps->desc.ramp_delay = TPS51632_DEFAULT_RAMP_DELAY;
  258. tps->desc.min_uV = TPS51632_MIN_VOLTAGE;
  259. tps->desc.uV_step = TPS51632_VOLTAGE_STEP_10mV;
  260. tps->desc.linear_min_sel = TPS51632_MIN_VSEL;
  261. tps->desc.n_voltages = TPS51632_MAX_VSEL + 1;
  262. tps->desc.ops = &tps51632_dcdc_ops;
  263. tps->desc.type = REGULATOR_VOLTAGE;
  264. tps->desc.owner = THIS_MODULE;
  265. pdata = dev_get_platdata(&client->dev);
  266. if (!pdata && client->dev.of_node)
  267. pdata = of_get_tps51632_platform_data(&client->dev, &tps->desc);
  268. if (!pdata) {
  269. dev_err(&client->dev, "No Platform data\n");
  270. return -EINVAL;
  271. }
  272. if (pdata->enable_pwm_dvfs) {
  273. if ((pdata->base_voltage_uV < TPS51632_MIN_VOLTAGE) ||
  274. (pdata->base_voltage_uV > TPS51632_MAX_VOLTAGE)) {
  275. dev_err(&client->dev, "Invalid base_voltage_uV setting\n");
  276. return -EINVAL;
  277. }
  278. if ((pdata->max_voltage_uV) &&
  279. ((pdata->max_voltage_uV < TPS51632_MIN_VOLTAGE) ||
  280. (pdata->max_voltage_uV > TPS51632_MAX_VOLTAGE))) {
  281. dev_err(&client->dev, "Invalid max_voltage_uV setting\n");
  282. return -EINVAL;
  283. }
  284. }
  285. if (pdata->enable_pwm_dvfs)
  286. tps->desc.vsel_reg = TPS51632_VOLTAGE_BASE_REG;
  287. else
  288. tps->desc.vsel_reg = TPS51632_VOLTAGE_SELECT_REG;
  289. tps->desc.vsel_mask = TPS51632_VOUT_MASK;
  290. tps->regmap = devm_regmap_init_i2c(client, &tps51632_regmap_config);
  291. if (IS_ERR(tps->regmap)) {
  292. ret = PTR_ERR(tps->regmap);
  293. dev_err(&client->dev, "regmap init failed, err %d\n", ret);
  294. return ret;
  295. }
  296. i2c_set_clientdata(client, tps);
  297. ret = tps51632_init_dcdc(tps, pdata);
  298. if (ret < 0) {
  299. dev_err(tps->dev, "Init failed, err = %d\n", ret);
  300. return ret;
  301. }
  302. /* Register the regulators */
  303. config.dev = &client->dev;
  304. config.init_data = pdata->reg_init_data;
  305. config.driver_data = tps;
  306. config.regmap = tps->regmap;
  307. config.of_node = client->dev.of_node;
  308. rdev = devm_regulator_register(&client->dev, &tps->desc, &config);
  309. if (IS_ERR(rdev)) {
  310. dev_err(tps->dev, "regulator register failed\n");
  311. return PTR_ERR(rdev);
  312. }
  313. tps->rdev = rdev;
  314. return 0;
  315. }
  316. static const struct i2c_device_id tps51632_id[] = {
  317. {.name = "tps51632",},
  318. {},
  319. };
  320. MODULE_DEVICE_TABLE(i2c, tps51632_id);
  321. static struct i2c_driver tps51632_i2c_driver = {
  322. .driver = {
  323. .name = "tps51632",
  324. .of_match_table = of_match_ptr(tps51632_of_match),
  325. },
  326. .probe = tps51632_probe,
  327. .id_table = tps51632_id,
  328. };
  329. static int __init tps51632_init(void)
  330. {
  331. return i2c_add_driver(&tps51632_i2c_driver);
  332. }
  333. subsys_initcall(tps51632_init);
  334. static void __exit tps51632_cleanup(void)
  335. {
  336. i2c_del_driver(&tps51632_i2c_driver);
  337. }
  338. module_exit(tps51632_cleanup);
  339. MODULE_AUTHOR("Laxman Dewangan <ldewangan@nvidia.com>");
  340. MODULE_DESCRIPTION("TPS51632 voltage regulator driver");
  341. MODULE_LICENSE("GPL v2");