da9211-regulator.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564
  1. // SPDX-License-Identifier: GPL-2.0+
  2. //
  3. // da9211-regulator.c - Regulator device driver for DA9211/DA9212
  4. // /DA9213/DA9223/DA9214/DA9224/DA9215/DA9225
  5. // Copyright (C) 2015 Dialog Semiconductor Ltd.
  6. #include <linux/err.h>
  7. #include <linux/i2c.h>
  8. #include <linux/module.h>
  9. #include <linux/init.h>
  10. #include <linux/slab.h>
  11. #include <linux/regulator/driver.h>
  12. #include <linux/regulator/machine.h>
  13. #include <linux/regmap.h>
  14. #include <linux/irq.h>
  15. #include <linux/interrupt.h>
  16. #include <linux/gpio/consumer.h>
  17. #include <linux/regulator/of_regulator.h>
  18. #include <linux/regulator/da9211.h>
  19. #include <dt-bindings/regulator/dlg,da9211-regulator.h>
  20. #include "da9211-regulator.h"
  21. /* DEVICE IDs */
  22. #define DA9211_DEVICE_ID 0x22
  23. #define DA9213_DEVICE_ID 0x23
  24. #define DA9215_DEVICE_ID 0x24
  25. /* DA9211 REGULATOR IDs */
  26. #define DA9211_ID_BUCKA 0
  27. #define DA9211_ID_BUCKB 1
  28. struct da9211 {
  29. struct device *dev;
  30. struct regmap *regmap;
  31. struct da9211_pdata *pdata;
  32. struct regulator_dev *rdev[DA9211_MAX_REGULATORS];
  33. int num_regulator;
  34. int chip_irq;
  35. int chip_id;
  36. };
  37. static const struct regmap_range_cfg da9211_regmap_range[] = {
  38. {
  39. .selector_reg = DA9211_REG_PAGE_CON,
  40. .selector_mask = DA9211_REG_PAGE_MASK,
  41. .selector_shift = DA9211_REG_PAGE_SHIFT,
  42. .window_start = 0,
  43. .window_len = 256,
  44. .range_min = 0,
  45. .range_max = 5*128,
  46. },
  47. };
  48. static bool da9211_volatile_reg(struct device *dev, unsigned int reg)
  49. {
  50. switch (reg) {
  51. case DA9211_REG_STATUS_A:
  52. case DA9211_REG_STATUS_B:
  53. case DA9211_REG_EVENT_A:
  54. case DA9211_REG_EVENT_B:
  55. return true;
  56. }
  57. return false;
  58. }
  59. static const struct regmap_config da9211_regmap_config = {
  60. .reg_bits = 8,
  61. .val_bits = 8,
  62. .max_register = 5 * 128,
  63. .volatile_reg = da9211_volatile_reg,
  64. .cache_type = REGCACHE_RBTREE,
  65. .ranges = da9211_regmap_range,
  66. .num_ranges = ARRAY_SIZE(da9211_regmap_range),
  67. };
  68. /* Default limits measured in millivolts and milliamps */
  69. #define DA9211_MIN_MV 300
  70. #define DA9211_MAX_MV 1570
  71. #define DA9211_STEP_MV 10
  72. /* Current limits for DA9211 buck (uA) indices
  73. * corresponds with register values
  74. */
  75. static const int da9211_current_limits[] = {
  76. 2000000, 2200000, 2400000, 2600000, 2800000, 3000000, 3200000, 3400000,
  77. 3600000, 3800000, 4000000, 4200000, 4400000, 4600000, 4800000, 5000000
  78. };
  79. /* Current limits for DA9213 buck (uA) indices
  80. * corresponds with register values
  81. */
  82. static const int da9213_current_limits[] = {
  83. 3000000, 3200000, 3400000, 3600000, 3800000, 4000000, 4200000, 4400000,
  84. 4600000, 4800000, 5000000, 5200000, 5400000, 5600000, 5800000, 6000000
  85. };
  86. /* Current limits for DA9215 buck (uA) indices
  87. * corresponds with register values
  88. */
  89. static const int da9215_current_limits[] = {
  90. 4000000, 4200000, 4400000, 4600000, 4800000, 5000000, 5200000, 5400000,
  91. 5600000, 5800000, 6000000, 6200000, 6400000, 6600000, 6800000, 7000000
  92. };
  93. static unsigned int da9211_map_buck_mode(unsigned int mode)
  94. {
  95. switch (mode) {
  96. case DA9211_BUCK_MODE_SLEEP:
  97. return REGULATOR_MODE_STANDBY;
  98. case DA9211_BUCK_MODE_SYNC:
  99. return REGULATOR_MODE_FAST;
  100. case DA9211_BUCK_MODE_AUTO:
  101. return REGULATOR_MODE_NORMAL;
  102. default:
  103. return REGULATOR_MODE_INVALID;
  104. }
  105. }
  106. static unsigned int da9211_buck_get_mode(struct regulator_dev *rdev)
  107. {
  108. int id = rdev_get_id(rdev);
  109. struct da9211 *chip = rdev_get_drvdata(rdev);
  110. unsigned int data;
  111. int ret, mode = 0;
  112. ret = regmap_read(chip->regmap, DA9211_REG_BUCKA_CONF+id, &data);
  113. if (ret < 0)
  114. return ret;
  115. switch (data & 0x03) {
  116. case DA9211_BUCK_MODE_SYNC:
  117. mode = REGULATOR_MODE_FAST;
  118. break;
  119. case DA9211_BUCK_MODE_AUTO:
  120. mode = REGULATOR_MODE_NORMAL;
  121. break;
  122. case DA9211_BUCK_MODE_SLEEP:
  123. mode = REGULATOR_MODE_STANDBY;
  124. break;
  125. }
  126. return mode;
  127. }
  128. static int da9211_buck_set_mode(struct regulator_dev *rdev,
  129. unsigned int mode)
  130. {
  131. int id = rdev_get_id(rdev);
  132. struct da9211 *chip = rdev_get_drvdata(rdev);
  133. int val = 0;
  134. switch (mode) {
  135. case REGULATOR_MODE_FAST:
  136. val = DA9211_BUCK_MODE_SYNC;
  137. break;
  138. case REGULATOR_MODE_NORMAL:
  139. val = DA9211_BUCK_MODE_AUTO;
  140. break;
  141. case REGULATOR_MODE_STANDBY:
  142. val = DA9211_BUCK_MODE_SLEEP;
  143. break;
  144. }
  145. return regmap_update_bits(chip->regmap, DA9211_REG_BUCKA_CONF+id,
  146. 0x03, val);
  147. }
  148. static int da9211_set_current_limit(struct regulator_dev *rdev, int min,
  149. int max)
  150. {
  151. int id = rdev_get_id(rdev);
  152. struct da9211 *chip = rdev_get_drvdata(rdev);
  153. int i, max_size;
  154. const int *current_limits;
  155. switch (chip->chip_id) {
  156. case DA9211:
  157. current_limits = da9211_current_limits;
  158. max_size = ARRAY_SIZE(da9211_current_limits)-1;
  159. break;
  160. case DA9213:
  161. current_limits = da9213_current_limits;
  162. max_size = ARRAY_SIZE(da9213_current_limits)-1;
  163. break;
  164. case DA9215:
  165. current_limits = da9215_current_limits;
  166. max_size = ARRAY_SIZE(da9215_current_limits)-1;
  167. break;
  168. default:
  169. return -EINVAL;
  170. }
  171. /* search for closest to maximum */
  172. for (i = max_size; i >= 0; i--) {
  173. if (min <= current_limits[i] &&
  174. max >= current_limits[i]) {
  175. return regmap_update_bits(chip->regmap,
  176. DA9211_REG_BUCK_ILIM,
  177. (0x0F << id*4), (i << id*4));
  178. }
  179. }
  180. return -EINVAL;
  181. }
  182. static int da9211_get_current_limit(struct regulator_dev *rdev)
  183. {
  184. int id = rdev_get_id(rdev);
  185. struct da9211 *chip = rdev_get_drvdata(rdev);
  186. unsigned int data;
  187. int ret;
  188. const int *current_limits;
  189. switch (chip->chip_id) {
  190. case DA9211:
  191. current_limits = da9211_current_limits;
  192. break;
  193. case DA9213:
  194. current_limits = da9213_current_limits;
  195. break;
  196. case DA9215:
  197. current_limits = da9215_current_limits;
  198. break;
  199. default:
  200. return -EINVAL;
  201. }
  202. ret = regmap_read(chip->regmap, DA9211_REG_BUCK_ILIM, &data);
  203. if (ret < 0)
  204. return ret;
  205. /* select one of 16 values: 0000 (2000mA or 3000mA)
  206. * to 1111 (5000mA or 6000mA).
  207. */
  208. data = (data >> id*4) & 0x0F;
  209. return current_limits[data];
  210. }
  211. static const struct regulator_ops da9211_buck_ops = {
  212. .get_mode = da9211_buck_get_mode,
  213. .set_mode = da9211_buck_set_mode,
  214. .enable = regulator_enable_regmap,
  215. .disable = regulator_disable_regmap,
  216. .is_enabled = regulator_is_enabled_regmap,
  217. .set_voltage_sel = regulator_set_voltage_sel_regmap,
  218. .get_voltage_sel = regulator_get_voltage_sel_regmap,
  219. .list_voltage = regulator_list_voltage_linear,
  220. .set_current_limit = da9211_set_current_limit,
  221. .get_current_limit = da9211_get_current_limit,
  222. };
  223. #define DA9211_BUCK(_id) \
  224. {\
  225. .name = #_id,\
  226. .ops = &da9211_buck_ops,\
  227. .type = REGULATOR_VOLTAGE,\
  228. .id = DA9211_ID_##_id,\
  229. .n_voltages = (DA9211_MAX_MV - DA9211_MIN_MV) / DA9211_STEP_MV + 1,\
  230. .min_uV = (DA9211_MIN_MV * 1000),\
  231. .uV_step = (DA9211_STEP_MV * 1000),\
  232. .enable_reg = DA9211_REG_BUCKA_CONT + DA9211_ID_##_id,\
  233. .enable_mask = DA9211_BUCKA_EN,\
  234. .vsel_reg = DA9211_REG_VBUCKA_A + DA9211_ID_##_id * 2,\
  235. .vsel_mask = DA9211_VBUCK_MASK,\
  236. .owner = THIS_MODULE,\
  237. .of_map_mode = da9211_map_buck_mode,\
  238. }
  239. static struct regulator_desc da9211_regulators[] = {
  240. DA9211_BUCK(BUCKA),
  241. DA9211_BUCK(BUCKB),
  242. };
  243. #ifdef CONFIG_OF
  244. static struct of_regulator_match da9211_matches[] = {
  245. [DA9211_ID_BUCKA] = {
  246. .name = "BUCKA",
  247. .desc = &da9211_regulators[DA9211_ID_BUCKA],
  248. },
  249. [DA9211_ID_BUCKB] = {
  250. .name = "BUCKB",
  251. .desc = &da9211_regulators[DA9211_ID_BUCKB],
  252. },
  253. };
  254. static struct da9211_pdata *da9211_parse_regulators_dt(
  255. struct device *dev)
  256. {
  257. struct da9211_pdata *pdata;
  258. struct device_node *node;
  259. int i, num, n;
  260. node = of_get_child_by_name(dev->of_node, "regulators");
  261. if (!node) {
  262. dev_err(dev, "regulators node not found\n");
  263. return ERR_PTR(-ENODEV);
  264. }
  265. num = of_regulator_match(dev, node, da9211_matches,
  266. ARRAY_SIZE(da9211_matches));
  267. of_node_put(node);
  268. if (num < 0) {
  269. dev_err(dev, "Failed to match regulators\n");
  270. return ERR_PTR(-EINVAL);
  271. }
  272. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  273. if (!pdata)
  274. return ERR_PTR(-ENOMEM);
  275. pdata->num_buck = num;
  276. n = 0;
  277. for (i = 0; i < ARRAY_SIZE(da9211_matches); i++) {
  278. if (!da9211_matches[i].init_data)
  279. continue;
  280. pdata->init_data[n] = da9211_matches[i].init_data;
  281. pdata->reg_node[n] = da9211_matches[i].of_node;
  282. pdata->gpiod_ren[n] = devm_fwnode_gpiod_get(dev,
  283. of_fwnode_handle(pdata->reg_node[n]),
  284. "enable",
  285. GPIOD_OUT_HIGH |
  286. GPIOD_FLAGS_BIT_NONEXCLUSIVE,
  287. "da9211-enable");
  288. if (IS_ERR(pdata->gpiod_ren[n]))
  289. pdata->gpiod_ren[n] = NULL;
  290. n++;
  291. }
  292. return pdata;
  293. }
  294. #else
  295. static struct da9211_pdata *da9211_parse_regulators_dt(
  296. struct device *dev)
  297. {
  298. return ERR_PTR(-ENODEV);
  299. }
  300. #endif
  301. static irqreturn_t da9211_irq_handler(int irq, void *data)
  302. {
  303. struct da9211 *chip = data;
  304. int reg_val, err, ret = IRQ_NONE;
  305. err = regmap_read(chip->regmap, DA9211_REG_EVENT_B, &reg_val);
  306. if (err < 0)
  307. goto error_i2c;
  308. if (reg_val & DA9211_E_OV_CURR_A) {
  309. regulator_notifier_call_chain(chip->rdev[0],
  310. REGULATOR_EVENT_OVER_CURRENT, NULL);
  311. err = regmap_write(chip->regmap, DA9211_REG_EVENT_B,
  312. DA9211_E_OV_CURR_A);
  313. if (err < 0)
  314. goto error_i2c;
  315. ret = IRQ_HANDLED;
  316. }
  317. if (reg_val & DA9211_E_OV_CURR_B) {
  318. regulator_notifier_call_chain(chip->rdev[1],
  319. REGULATOR_EVENT_OVER_CURRENT, NULL);
  320. err = regmap_write(chip->regmap, DA9211_REG_EVENT_B,
  321. DA9211_E_OV_CURR_B);
  322. if (err < 0)
  323. goto error_i2c;
  324. ret = IRQ_HANDLED;
  325. }
  326. return ret;
  327. error_i2c:
  328. dev_err(chip->dev, "I2C error : %d\n", err);
  329. return IRQ_NONE;
  330. }
  331. static int da9211_regulator_init(struct da9211 *chip)
  332. {
  333. struct regulator_config config = { };
  334. int i, ret;
  335. unsigned int data;
  336. ret = regmap_read(chip->regmap, DA9211_REG_CONFIG_E, &data);
  337. if (ret < 0) {
  338. dev_err(chip->dev, "Failed to read CONFIG_E reg: %d\n", ret);
  339. return ret;
  340. }
  341. data &= DA9211_SLAVE_SEL;
  342. /* If configuration for 1/2 bucks is different between platform data
  343. * and the register, driver should exit.
  344. */
  345. if (chip->pdata->num_buck == 1 && data == 0x00)
  346. chip->num_regulator = 1;
  347. else if (chip->pdata->num_buck == 2 && data != 0x00)
  348. chip->num_regulator = 2;
  349. else {
  350. dev_err(chip->dev, "Configuration is mismatched\n");
  351. return -EINVAL;
  352. }
  353. for (i = 0; i < chip->num_regulator; i++) {
  354. config.init_data = chip->pdata->init_data[i];
  355. config.dev = chip->dev;
  356. config.driver_data = chip;
  357. config.regmap = chip->regmap;
  358. config.of_node = chip->pdata->reg_node[i];
  359. if (chip->pdata->gpiod_ren[i])
  360. config.ena_gpiod = chip->pdata->gpiod_ren[i];
  361. else
  362. config.ena_gpiod = NULL;
  363. /*
  364. * Hand the GPIO descriptor management over to the regulator
  365. * core, remove it from GPIO devres management.
  366. */
  367. if (config.ena_gpiod)
  368. devm_gpiod_unhinge(chip->dev, config.ena_gpiod);
  369. chip->rdev[i] = devm_regulator_register(chip->dev,
  370. &da9211_regulators[i], &config);
  371. if (IS_ERR(chip->rdev[i])) {
  372. dev_err(chip->dev,
  373. "Failed to register DA9211 regulator\n");
  374. return PTR_ERR(chip->rdev[i]);
  375. }
  376. if (chip->chip_irq != 0) {
  377. ret = regmap_update_bits(chip->regmap,
  378. DA9211_REG_MASK_B, DA9211_M_OV_CURR_A << i, 0);
  379. if (ret < 0) {
  380. dev_err(chip->dev,
  381. "Failed to update mask reg: %d\n", ret);
  382. return ret;
  383. }
  384. }
  385. }
  386. return 0;
  387. }
  388. /*
  389. * I2C driver interface functions
  390. */
  391. static int da9211_i2c_probe(struct i2c_client *i2c)
  392. {
  393. struct da9211 *chip;
  394. int error, ret;
  395. unsigned int data;
  396. chip = devm_kzalloc(&i2c->dev, sizeof(struct da9211), GFP_KERNEL);
  397. if (!chip)
  398. return -ENOMEM;
  399. chip->dev = &i2c->dev;
  400. chip->regmap = devm_regmap_init_i2c(i2c, &da9211_regmap_config);
  401. if (IS_ERR(chip->regmap)) {
  402. error = PTR_ERR(chip->regmap);
  403. dev_err(chip->dev, "Failed to allocate register map: %d\n",
  404. error);
  405. return error;
  406. }
  407. i2c_set_clientdata(i2c, chip);
  408. chip->pdata = i2c->dev.platform_data;
  409. ret = regmap_read(chip->regmap, DA9211_REG_DEVICE_ID, &data);
  410. if (ret < 0) {
  411. dev_err(chip->dev, "Failed to read DEVICE_ID reg: %d\n", ret);
  412. return ret;
  413. }
  414. switch (data) {
  415. case DA9211_DEVICE_ID:
  416. chip->chip_id = DA9211;
  417. break;
  418. case DA9213_DEVICE_ID:
  419. chip->chip_id = DA9213;
  420. break;
  421. case DA9215_DEVICE_ID:
  422. chip->chip_id = DA9215;
  423. break;
  424. default:
  425. dev_err(chip->dev, "Unsupported device id = 0x%x.\n", data);
  426. return -ENODEV;
  427. }
  428. if (!chip->pdata)
  429. chip->pdata = da9211_parse_regulators_dt(chip->dev);
  430. if (IS_ERR(chip->pdata)) {
  431. dev_err(chip->dev, "No regulators defined for the platform\n");
  432. return PTR_ERR(chip->pdata);
  433. }
  434. chip->chip_irq = i2c->irq;
  435. if (chip->chip_irq != 0) {
  436. ret = devm_request_threaded_irq(chip->dev, chip->chip_irq, NULL,
  437. da9211_irq_handler,
  438. IRQF_TRIGGER_LOW|IRQF_ONESHOT,
  439. "da9211", chip);
  440. if (ret != 0) {
  441. dev_err(chip->dev, "Failed to request IRQ: %d\n",
  442. chip->chip_irq);
  443. return ret;
  444. }
  445. } else {
  446. dev_warn(chip->dev, "No IRQ configured\n");
  447. }
  448. ret = da9211_regulator_init(chip);
  449. if (ret < 0)
  450. dev_err(chip->dev, "Failed to initialize regulator: %d\n", ret);
  451. return ret;
  452. }
  453. static const struct i2c_device_id da9211_i2c_id[] = {
  454. {"da9211", DA9211},
  455. {"da9212", DA9212},
  456. {"da9213", DA9213},
  457. {"da9223", DA9223},
  458. {"da9214", DA9214},
  459. {"da9224", DA9224},
  460. {"da9215", DA9215},
  461. {"da9225", DA9225},
  462. {},
  463. };
  464. MODULE_DEVICE_TABLE(i2c, da9211_i2c_id);
  465. #ifdef CONFIG_OF
  466. static const struct of_device_id da9211_dt_ids[] = {
  467. { .compatible = "dlg,da9211", .data = &da9211_i2c_id[0] },
  468. { .compatible = "dlg,da9212", .data = &da9211_i2c_id[1] },
  469. { .compatible = "dlg,da9213", .data = &da9211_i2c_id[2] },
  470. { .compatible = "dlg,da9223", .data = &da9211_i2c_id[3] },
  471. { .compatible = "dlg,da9214", .data = &da9211_i2c_id[4] },
  472. { .compatible = "dlg,da9224", .data = &da9211_i2c_id[5] },
  473. { .compatible = "dlg,da9215", .data = &da9211_i2c_id[6] },
  474. { .compatible = "dlg,da9225", .data = &da9211_i2c_id[7] },
  475. {},
  476. };
  477. MODULE_DEVICE_TABLE(of, da9211_dt_ids);
  478. #endif
  479. static struct i2c_driver da9211_regulator_driver = {
  480. .driver = {
  481. .name = "da9211",
  482. .of_match_table = of_match_ptr(da9211_dt_ids),
  483. },
  484. .probe_new = da9211_i2c_probe,
  485. .id_table = da9211_i2c_id,
  486. };
  487. module_i2c_driver(da9211_regulator_driver);
  488. MODULE_AUTHOR("James Ban <James.Ban.opensource@diasemi.com>");
  489. MODULE_DESCRIPTION("DA9211/DA9212/DA9213/DA9223/DA9214/DA9224/DA9215/DA9225 regulator driver");
  490. MODULE_LICENSE("GPL");