ltc3589.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483
  1. // SPDX-License-Identifier: GPL-2.0
  2. //
  3. // Linear Technology LTC3589,LTC3589-1 regulator support
  4. //
  5. // Copyright (c) 2014 Philipp Zabel <p.zabel@pengutronix.de>, Pengutronix
  6. #include <linux/i2c.h>
  7. #include <linux/init.h>
  8. #include <linux/interrupt.h>
  9. #include <linux/module.h>
  10. #include <linux/kernel.h>
  11. #include <linux/of.h>
  12. #include <linux/of_device.h>
  13. #include <linux/regmap.h>
  14. #include <linux/regulator/driver.h>
  15. #include <linux/regulator/of_regulator.h>
  16. #define DRIVER_NAME "ltc3589"
  17. #define LTC3589_IRQSTAT 0x02
  18. #define LTC3589_SCR1 0x07
  19. #define LTC3589_OVEN 0x10
  20. #define LTC3589_SCR2 0x12
  21. #define LTC3589_PGSTAT 0x13
  22. #define LTC3589_VCCR 0x20
  23. #define LTC3589_CLIRQ 0x21
  24. #define LTC3589_B1DTV1 0x23
  25. #define LTC3589_B1DTV2 0x24
  26. #define LTC3589_VRRCR 0x25
  27. #define LTC3589_B2DTV1 0x26
  28. #define LTC3589_B2DTV2 0x27
  29. #define LTC3589_B3DTV1 0x29
  30. #define LTC3589_B3DTV2 0x2a
  31. #define LTC3589_L2DTV1 0x32
  32. #define LTC3589_L2DTV2 0x33
  33. #define LTC3589_IRQSTAT_PGOOD_TIMEOUT BIT(3)
  34. #define LTC3589_IRQSTAT_UNDERVOLT_WARN BIT(4)
  35. #define LTC3589_IRQSTAT_UNDERVOLT_FAULT BIT(5)
  36. #define LTC3589_IRQSTAT_THERMAL_WARN BIT(6)
  37. #define LTC3589_IRQSTAT_THERMAL_FAULT BIT(7)
  38. #define LTC3589_OVEN_SW1 BIT(0)
  39. #define LTC3589_OVEN_SW2 BIT(1)
  40. #define LTC3589_OVEN_SW3 BIT(2)
  41. #define LTC3589_OVEN_BB_OUT BIT(3)
  42. #define LTC3589_OVEN_LDO2 BIT(4)
  43. #define LTC3589_OVEN_LDO3 BIT(5)
  44. #define LTC3589_OVEN_LDO4 BIT(6)
  45. #define LTC3589_OVEN_SW_CTRL BIT(7)
  46. #define LTC3589_VCCR_SW1_GO BIT(0)
  47. #define LTC3589_VCCR_SW2_GO BIT(2)
  48. #define LTC3589_VCCR_SW3_GO BIT(4)
  49. #define LTC3589_VCCR_LDO2_GO BIT(6)
  50. enum ltc3589_variant {
  51. LTC3589,
  52. LTC3589_1,
  53. LTC3589_2,
  54. };
  55. enum ltc3589_reg {
  56. LTC3589_SW1,
  57. LTC3589_SW2,
  58. LTC3589_SW3,
  59. LTC3589_BB_OUT,
  60. LTC3589_LDO1,
  61. LTC3589_LDO2,
  62. LTC3589_LDO3,
  63. LTC3589_LDO4,
  64. LTC3589_NUM_REGULATORS,
  65. };
  66. struct ltc3589 {
  67. struct regmap *regmap;
  68. struct device *dev;
  69. enum ltc3589_variant variant;
  70. struct regulator_desc regulator_descs[LTC3589_NUM_REGULATORS];
  71. struct regulator_dev *regulators[LTC3589_NUM_REGULATORS];
  72. };
  73. static const int ltc3589_ldo4[] = {
  74. 2800000, 2500000, 1800000, 3300000,
  75. };
  76. static const int ltc3589_12_ldo4[] = {
  77. 1200000, 1800000, 2500000, 3200000,
  78. };
  79. static int ltc3589_set_ramp_delay(struct regulator_dev *rdev, int ramp_delay)
  80. {
  81. struct ltc3589 *ltc3589 = rdev_get_drvdata(rdev);
  82. int sel, shift;
  83. if (unlikely(ramp_delay <= 0))
  84. return -EINVAL;
  85. /* VRRCR slew rate offsets are the same as VCCR go bit offsets */
  86. shift = ffs(rdev->desc->apply_bit) - 1;
  87. /* The slew rate can be set to 0.88, 1.75, 3.5, or 7 mV/uS */
  88. for (sel = 0; sel < 4; sel++) {
  89. if ((880 << sel) >= ramp_delay) {
  90. return regmap_update_bits(ltc3589->regmap,
  91. LTC3589_VRRCR,
  92. 0x3 << shift, sel << shift);
  93. }
  94. }
  95. return -EINVAL;
  96. }
  97. static int ltc3589_set_suspend_voltage(struct regulator_dev *rdev, int uV)
  98. {
  99. struct ltc3589 *ltc3589 = rdev_get_drvdata(rdev);
  100. int sel;
  101. sel = regulator_map_voltage_linear(rdev, uV, uV);
  102. if (sel < 0)
  103. return sel;
  104. /* DTV2 register follows right after the corresponding DTV1 register */
  105. return regmap_update_bits(ltc3589->regmap, rdev->desc->vsel_reg + 1,
  106. rdev->desc->vsel_mask, sel);
  107. }
  108. static int ltc3589_set_suspend_mode(struct regulator_dev *rdev,
  109. unsigned int mode)
  110. {
  111. struct ltc3589 *ltc3589 = rdev_get_drvdata(rdev);
  112. int mask, bit = 0;
  113. /* VCCR reference selects are right next to the VCCR go bits */
  114. mask = rdev->desc->apply_bit << 1;
  115. if (mode == REGULATOR_MODE_STANDBY)
  116. bit = mask; /* Select DTV2 */
  117. mask |= rdev->desc->apply_bit;
  118. bit |= rdev->desc->apply_bit;
  119. return regmap_update_bits(ltc3589->regmap, LTC3589_VCCR, mask, bit);
  120. }
  121. /* SW1, SW2, SW3, LDO2 */
  122. static const struct regulator_ops ltc3589_linear_regulator_ops = {
  123. .enable = regulator_enable_regmap,
  124. .disable = regulator_disable_regmap,
  125. .is_enabled = regulator_is_enabled_regmap,
  126. .list_voltage = regulator_list_voltage_linear,
  127. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  128. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  129. .set_ramp_delay = ltc3589_set_ramp_delay,
  130. .set_voltage_time_sel = regulator_set_voltage_time_sel,
  131. .set_suspend_voltage = ltc3589_set_suspend_voltage,
  132. .set_suspend_mode = ltc3589_set_suspend_mode,
  133. };
  134. /* BB_OUT, LDO3 */
  135. static const struct regulator_ops ltc3589_fixed_regulator_ops = {
  136. .enable = regulator_enable_regmap,
  137. .disable = regulator_disable_regmap,
  138. .is_enabled = regulator_is_enabled_regmap,
  139. };
  140. /* LDO1 */
  141. static const struct regulator_ops ltc3589_fixed_standby_regulator_ops = {
  142. };
  143. /* LDO4 */
  144. static const struct regulator_ops ltc3589_table_regulator_ops = {
  145. .enable = regulator_enable_regmap,
  146. .disable = regulator_disable_regmap,
  147. .is_enabled = regulator_is_enabled_regmap,
  148. .list_voltage = regulator_list_voltage_table,
  149. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  150. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  151. };
  152. static inline unsigned int ltc3589_scale(unsigned int uV, u32 r1, u32 r2)
  153. {
  154. uint64_t tmp;
  155. if (uV == 0)
  156. return 0;
  157. tmp = (uint64_t)uV * r1;
  158. do_div(tmp, r2);
  159. return uV + (unsigned int)tmp;
  160. }
  161. static int ltc3589_of_parse_cb(struct device_node *np,
  162. const struct regulator_desc *desc,
  163. struct regulator_config *config)
  164. {
  165. struct ltc3589 *ltc3589 = config->driver_data;
  166. struct regulator_desc *rdesc = &ltc3589->regulator_descs[desc->id];
  167. u32 r[2];
  168. int ret;
  169. /* Parse feedback voltage dividers. LDO3 and LDO4 don't have them */
  170. if (desc->id >= LTC3589_LDO3)
  171. return 0;
  172. ret = of_property_read_u32_array(np, "lltc,fb-voltage-divider", r, 2);
  173. if (ret) {
  174. dev_err(ltc3589->dev, "Failed to parse voltage divider: %d\n",
  175. ret);
  176. return ret;
  177. }
  178. if (!r[0] || !r[1])
  179. return 0;
  180. rdesc->min_uV = ltc3589_scale(desc->min_uV, r[0], r[1]);
  181. rdesc->uV_step = ltc3589_scale(desc->uV_step, r[0], r[1]);
  182. rdesc->fixed_uV = ltc3589_scale(desc->fixed_uV, r[0], r[1]);
  183. return 0;
  184. }
  185. #define LTC3589_REG(_name, _of_name, _ops, en_bit, dtv1_reg, dtv_mask, go_bit)\
  186. [LTC3589_ ## _name] = { \
  187. .name = #_name, \
  188. .of_match = of_match_ptr(#_of_name), \
  189. .regulators_node = of_match_ptr("regulators"), \
  190. .of_parse_cb = ltc3589_of_parse_cb, \
  191. .n_voltages = (dtv_mask) + 1, \
  192. .min_uV = (go_bit) ? 362500 : 0, \
  193. .uV_step = (go_bit) ? 12500 : 0, \
  194. .ramp_delay = (go_bit) ? 1750 : 0, \
  195. .fixed_uV = (dtv_mask) ? 0 : 800000, \
  196. .ops = &ltc3589_ ## _ops ## _regulator_ops, \
  197. .type = REGULATOR_VOLTAGE, \
  198. .id = LTC3589_ ## _name, \
  199. .owner = THIS_MODULE, \
  200. .vsel_reg = (dtv1_reg), \
  201. .vsel_mask = (dtv_mask), \
  202. .apply_reg = (go_bit) ? LTC3589_VCCR : 0, \
  203. .apply_bit = (go_bit), \
  204. .enable_reg = (en_bit) ? LTC3589_OVEN : 0, \
  205. .enable_mask = (en_bit), \
  206. }
  207. #define LTC3589_LINEAR_REG(_name, _of_name, _dtv1) \
  208. LTC3589_REG(_name, _of_name, linear, LTC3589_OVEN_ ## _name, \
  209. LTC3589_ ## _dtv1, 0x1f, \
  210. LTC3589_VCCR_ ## _name ## _GO)
  211. #define LTC3589_FIXED_REG(_name, _of_name) \
  212. LTC3589_REG(_name, _of_name, fixed, LTC3589_OVEN_ ## _name, 0, 0, 0)
  213. static const struct regulator_desc ltc3589_regulators[] = {
  214. LTC3589_LINEAR_REG(SW1, sw1, B1DTV1),
  215. LTC3589_LINEAR_REG(SW2, sw2, B2DTV1),
  216. LTC3589_LINEAR_REG(SW3, sw3, B3DTV1),
  217. LTC3589_FIXED_REG(BB_OUT, bb-out),
  218. LTC3589_REG(LDO1, ldo1, fixed_standby, 0, 0, 0, 0),
  219. LTC3589_LINEAR_REG(LDO2, ldo2, L2DTV1),
  220. LTC3589_FIXED_REG(LDO3, ldo3),
  221. LTC3589_REG(LDO4, ldo4, table, LTC3589_OVEN_LDO4, LTC3589_L2DTV2,
  222. 0x60, 0),
  223. };
  224. static bool ltc3589_writeable_reg(struct device *dev, unsigned int reg)
  225. {
  226. switch (reg) {
  227. case LTC3589_IRQSTAT:
  228. case LTC3589_SCR1:
  229. case LTC3589_OVEN:
  230. case LTC3589_SCR2:
  231. case LTC3589_VCCR:
  232. case LTC3589_CLIRQ:
  233. case LTC3589_B1DTV1:
  234. case LTC3589_B1DTV2:
  235. case LTC3589_VRRCR:
  236. case LTC3589_B2DTV1:
  237. case LTC3589_B2DTV2:
  238. case LTC3589_B3DTV1:
  239. case LTC3589_B3DTV2:
  240. case LTC3589_L2DTV1:
  241. case LTC3589_L2DTV2:
  242. return true;
  243. }
  244. return false;
  245. }
  246. static bool ltc3589_readable_reg(struct device *dev, unsigned int reg)
  247. {
  248. switch (reg) {
  249. case LTC3589_IRQSTAT:
  250. case LTC3589_SCR1:
  251. case LTC3589_OVEN:
  252. case LTC3589_SCR2:
  253. case LTC3589_PGSTAT:
  254. case LTC3589_VCCR:
  255. case LTC3589_B1DTV1:
  256. case LTC3589_B1DTV2:
  257. case LTC3589_VRRCR:
  258. case LTC3589_B2DTV1:
  259. case LTC3589_B2DTV2:
  260. case LTC3589_B3DTV1:
  261. case LTC3589_B3DTV2:
  262. case LTC3589_L2DTV1:
  263. case LTC3589_L2DTV2:
  264. return true;
  265. }
  266. return false;
  267. }
  268. static bool ltc3589_volatile_reg(struct device *dev, unsigned int reg)
  269. {
  270. switch (reg) {
  271. case LTC3589_IRQSTAT:
  272. case LTC3589_PGSTAT:
  273. case LTC3589_VCCR:
  274. return true;
  275. }
  276. return false;
  277. }
  278. static const struct reg_default ltc3589_reg_defaults[] = {
  279. { LTC3589_SCR1, 0x00 },
  280. { LTC3589_OVEN, 0x00 },
  281. { LTC3589_SCR2, 0x00 },
  282. { LTC3589_VCCR, 0x00 },
  283. { LTC3589_B1DTV1, 0x19 },
  284. { LTC3589_B1DTV2, 0x19 },
  285. { LTC3589_VRRCR, 0xff },
  286. { LTC3589_B2DTV1, 0x19 },
  287. { LTC3589_B2DTV2, 0x19 },
  288. { LTC3589_B3DTV1, 0x19 },
  289. { LTC3589_B3DTV2, 0x19 },
  290. { LTC3589_L2DTV1, 0x19 },
  291. { LTC3589_L2DTV2, 0x19 },
  292. };
  293. static const struct regmap_config ltc3589_regmap_config = {
  294. .reg_bits = 8,
  295. .val_bits = 8,
  296. .writeable_reg = ltc3589_writeable_reg,
  297. .readable_reg = ltc3589_readable_reg,
  298. .volatile_reg = ltc3589_volatile_reg,
  299. .max_register = LTC3589_L2DTV2,
  300. .reg_defaults = ltc3589_reg_defaults,
  301. .num_reg_defaults = ARRAY_SIZE(ltc3589_reg_defaults),
  302. .use_single_read = true,
  303. .use_single_write = true,
  304. .cache_type = REGCACHE_RBTREE,
  305. };
  306. static irqreturn_t ltc3589_isr(int irq, void *dev_id)
  307. {
  308. struct ltc3589 *ltc3589 = dev_id;
  309. unsigned int i, irqstat, event;
  310. regmap_read(ltc3589->regmap, LTC3589_IRQSTAT, &irqstat);
  311. if (irqstat & LTC3589_IRQSTAT_THERMAL_WARN) {
  312. event = REGULATOR_EVENT_OVER_TEMP;
  313. for (i = 0; i < LTC3589_NUM_REGULATORS; i++)
  314. regulator_notifier_call_chain(ltc3589->regulators[i],
  315. event, NULL);
  316. }
  317. if (irqstat & LTC3589_IRQSTAT_UNDERVOLT_WARN) {
  318. event = REGULATOR_EVENT_UNDER_VOLTAGE;
  319. for (i = 0; i < LTC3589_NUM_REGULATORS; i++)
  320. regulator_notifier_call_chain(ltc3589->regulators[i],
  321. event, NULL);
  322. }
  323. /* Clear warning condition */
  324. regmap_write(ltc3589->regmap, LTC3589_CLIRQ, 0);
  325. return IRQ_HANDLED;
  326. }
  327. static int ltc3589_probe(struct i2c_client *client,
  328. const struct i2c_device_id *id)
  329. {
  330. struct device *dev = &client->dev;
  331. struct regulator_desc *descs;
  332. struct ltc3589 *ltc3589;
  333. int i, ret;
  334. ltc3589 = devm_kzalloc(dev, sizeof(*ltc3589), GFP_KERNEL);
  335. if (!ltc3589)
  336. return -ENOMEM;
  337. i2c_set_clientdata(client, ltc3589);
  338. if (client->dev.of_node)
  339. ltc3589->variant = (enum ltc3589_variant)
  340. of_device_get_match_data(&client->dev);
  341. else
  342. ltc3589->variant = id->driver_data;
  343. ltc3589->dev = dev;
  344. descs = ltc3589->regulator_descs;
  345. memcpy(descs, ltc3589_regulators, sizeof(ltc3589_regulators));
  346. if (ltc3589->variant == LTC3589) {
  347. descs[LTC3589_LDO3].fixed_uV = 1800000;
  348. descs[LTC3589_LDO4].volt_table = ltc3589_ldo4;
  349. } else {
  350. descs[LTC3589_LDO3].fixed_uV = 2800000;
  351. descs[LTC3589_LDO4].volt_table = ltc3589_12_ldo4;
  352. }
  353. ltc3589->regmap = devm_regmap_init_i2c(client, &ltc3589_regmap_config);
  354. if (IS_ERR(ltc3589->regmap)) {
  355. ret = PTR_ERR(ltc3589->regmap);
  356. dev_err(dev, "failed to initialize regmap: %d\n", ret);
  357. return ret;
  358. }
  359. for (i = 0; i < LTC3589_NUM_REGULATORS; i++) {
  360. struct regulator_desc *desc = &ltc3589->regulator_descs[i];
  361. struct regulator_config config = { };
  362. config.dev = dev;
  363. config.driver_data = ltc3589;
  364. ltc3589->regulators[i] = devm_regulator_register(dev, desc,
  365. &config);
  366. if (IS_ERR(ltc3589->regulators[i])) {
  367. ret = PTR_ERR(ltc3589->regulators[i]);
  368. dev_err(dev, "failed to register regulator %s: %d\n",
  369. desc->name, ret);
  370. return ret;
  371. }
  372. }
  373. if (client->irq) {
  374. ret = devm_request_threaded_irq(dev, client->irq, NULL,
  375. ltc3589_isr,
  376. IRQF_TRIGGER_LOW | IRQF_ONESHOT,
  377. client->name, ltc3589);
  378. if (ret) {
  379. dev_err(dev, "Failed to request IRQ: %d\n", ret);
  380. return ret;
  381. }
  382. }
  383. return 0;
  384. }
  385. static const struct i2c_device_id ltc3589_i2c_id[] = {
  386. { "ltc3589", LTC3589 },
  387. { "ltc3589-1", LTC3589_1 },
  388. { "ltc3589-2", LTC3589_2 },
  389. { }
  390. };
  391. MODULE_DEVICE_TABLE(i2c, ltc3589_i2c_id);
  392. static const struct of_device_id __maybe_unused ltc3589_of_match[] = {
  393. {
  394. .compatible = "lltc,ltc3589",
  395. .data = (void *)LTC3589,
  396. },
  397. {
  398. .compatible = "lltc,ltc3589-1",
  399. .data = (void *)LTC3589_1,
  400. },
  401. {
  402. .compatible = "lltc,ltc3589-2",
  403. .data = (void *)LTC3589_2,
  404. },
  405. { },
  406. };
  407. MODULE_DEVICE_TABLE(of, ltc3589_of_match);
  408. static struct i2c_driver ltc3589_driver = {
  409. .driver = {
  410. .name = DRIVER_NAME,
  411. .of_match_table = of_match_ptr(ltc3589_of_match),
  412. },
  413. .probe = ltc3589_probe,
  414. .id_table = ltc3589_i2c_id,
  415. };
  416. module_i2c_driver(ltc3589_driver);
  417. MODULE_AUTHOR("Philipp Zabel <p.zabel@pengutronix.de>");
  418. MODULE_DESCRIPTION("Regulator driver for Linear Technology LTC3589(-1,2)");
  419. MODULE_LICENSE("GPL v2");