sc2731_charger.c 13 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541
  1. // SPDX-License-Identifier: GPL-2.0
  2. // Copyright (C) 2018 Spreadtrum Communications Inc.
  3. #include <linux/module.h>
  4. #include <linux/platform_device.h>
  5. #include <linux/power_supply.h>
  6. #include <linux/usb/phy.h>
  7. #include <linux/regmap.h>
  8. #include <linux/notifier.h>
  9. #include <linux/of.h>
  10. /* PMIC global registers definition */
  11. #define SC2731_CHARGE_STATUS 0xedc
  12. #define SC2731_CHARGE_FULL BIT(4)
  13. #define SC2731_MODULE_EN1 0xc0c
  14. #define SC2731_CHARGE_EN BIT(5)
  15. /* SC2731 switch charger registers definition */
  16. #define SC2731_CHG_CFG0 0x0
  17. #define SC2731_CHG_CFG1 0x4
  18. #define SC2731_CHG_CFG2 0x8
  19. #define SC2731_CHG_CFG3 0xc
  20. #define SC2731_CHG_CFG4 0x10
  21. #define SC2731_CHG_CFG5 0x28
  22. /* SC2731_CHG_CFG0 register definition */
  23. #define SC2731_PRECHG_RNG_SHIFT 11
  24. #define SC2731_PRECHG_RNG_MASK GENMASK(12, 11)
  25. #define SC2731_TERMINATION_VOL_MASK GENMASK(2, 1)
  26. #define SC2731_TERMINATION_VOL_SHIFT 1
  27. #define SC2731_TERMINATION_VOL_CAL_MASK GENMASK(8, 3)
  28. #define SC2731_TERMINATION_VOL_CAL_SHIFT 3
  29. #define SC2731_TERMINATION_CUR_MASK GENMASK(2, 0)
  30. #define SC2731_CC_EN BIT(13)
  31. #define SC2731_CHARGER_PD BIT(0)
  32. /* SC2731_CHG_CFG1 register definition */
  33. #define SC2731_CUR_MASK GENMASK(5, 0)
  34. /* SC2731_CHG_CFG5 register definition */
  35. #define SC2731_CUR_LIMIT_SHIFT 8
  36. #define SC2731_CUR_LIMIT_MASK GENMASK(9, 8)
  37. /* Default current definition (unit is mA) */
  38. #define SC2731_CURRENT_LIMIT_100 100
  39. #define SC2731_CURRENT_LIMIT_500 500
  40. #define SC2731_CURRENT_LIMIT_900 900
  41. #define SC2731_CURRENT_LIMIT_2000 2000
  42. #define SC2731_CURRENT_PRECHG 450
  43. #define SC2731_CURRENT_STEP 50
  44. struct sc2731_charger_info {
  45. struct device *dev;
  46. struct regmap *regmap;
  47. struct usb_phy *usb_phy;
  48. struct notifier_block usb_notify;
  49. struct power_supply *psy_usb;
  50. struct work_struct work;
  51. struct mutex lock;
  52. bool charging;
  53. u32 base;
  54. u32 limit;
  55. };
  56. static void sc2731_charger_stop_charge(struct sc2731_charger_info *info)
  57. {
  58. regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  59. SC2731_CC_EN, 0);
  60. regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  61. SC2731_CHARGER_PD, SC2731_CHARGER_PD);
  62. }
  63. static int sc2731_charger_start_charge(struct sc2731_charger_info *info)
  64. {
  65. int ret;
  66. /* Enable charger constant current mode */
  67. ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  68. SC2731_CC_EN, SC2731_CC_EN);
  69. if (ret)
  70. return ret;
  71. /* Start charging */
  72. return regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  73. SC2731_CHARGER_PD, 0);
  74. }
  75. static int sc2731_charger_set_current_limit(struct sc2731_charger_info *info,
  76. u32 limit)
  77. {
  78. u32 val;
  79. if (limit <= SC2731_CURRENT_LIMIT_100)
  80. val = 0;
  81. else if (limit <= SC2731_CURRENT_LIMIT_500)
  82. val = 3;
  83. else if (limit <= SC2731_CURRENT_LIMIT_900)
  84. val = 2;
  85. else
  86. val = 1;
  87. return regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG5,
  88. SC2731_CUR_LIMIT_MASK,
  89. val << SC2731_CUR_LIMIT_SHIFT);
  90. }
  91. static int sc2731_charger_set_current(struct sc2731_charger_info *info, u32 cur)
  92. {
  93. u32 val;
  94. int ret;
  95. if (cur > SC2731_CURRENT_LIMIT_2000)
  96. cur = SC2731_CURRENT_LIMIT_2000;
  97. else if (cur < SC2731_CURRENT_PRECHG)
  98. cur = SC2731_CURRENT_PRECHG;
  99. /* Calculate the step value, each step is 50 mA */
  100. val = (cur - SC2731_CURRENT_PRECHG) / SC2731_CURRENT_STEP;
  101. /* Set pre-charge current as 450 mA */
  102. ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  103. SC2731_PRECHG_RNG_MASK,
  104. 0x3 << SC2731_PRECHG_RNG_SHIFT);
  105. if (ret)
  106. return ret;
  107. return regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG1,
  108. SC2731_CUR_MASK, val);
  109. }
  110. static int sc2731_charger_get_status(struct sc2731_charger_info *info)
  111. {
  112. u32 val;
  113. int ret;
  114. ret = regmap_read(info->regmap, SC2731_CHARGE_STATUS, &val);
  115. if (ret)
  116. return ret;
  117. if (val & SC2731_CHARGE_FULL)
  118. return POWER_SUPPLY_STATUS_FULL;
  119. return POWER_SUPPLY_STATUS_CHARGING;
  120. }
  121. static int sc2731_charger_get_current(struct sc2731_charger_info *info,
  122. u32 *cur)
  123. {
  124. int ret;
  125. u32 val;
  126. ret = regmap_read(info->regmap, info->base + SC2731_CHG_CFG1, &val);
  127. if (ret)
  128. return ret;
  129. val &= SC2731_CUR_MASK;
  130. *cur = val * SC2731_CURRENT_STEP + SC2731_CURRENT_PRECHG;
  131. return 0;
  132. }
  133. static int sc2731_charger_get_current_limit(struct sc2731_charger_info *info,
  134. u32 *cur)
  135. {
  136. int ret;
  137. u32 val;
  138. ret = regmap_read(info->regmap, info->base + SC2731_CHG_CFG5, &val);
  139. if (ret)
  140. return ret;
  141. val = (val & SC2731_CUR_LIMIT_MASK) >> SC2731_CUR_LIMIT_SHIFT;
  142. switch (val) {
  143. case 0:
  144. *cur = SC2731_CURRENT_LIMIT_100;
  145. break;
  146. case 1:
  147. *cur = SC2731_CURRENT_LIMIT_2000;
  148. break;
  149. case 2:
  150. *cur = SC2731_CURRENT_LIMIT_900;
  151. break;
  152. case 3:
  153. *cur = SC2731_CURRENT_LIMIT_500;
  154. break;
  155. default:
  156. return -EINVAL;
  157. }
  158. return 0;
  159. }
  160. static int
  161. sc2731_charger_usb_set_property(struct power_supply *psy,
  162. enum power_supply_property psp,
  163. const union power_supply_propval *val)
  164. {
  165. struct sc2731_charger_info *info = power_supply_get_drvdata(psy);
  166. int ret;
  167. mutex_lock(&info->lock);
  168. if (!info->charging) {
  169. mutex_unlock(&info->lock);
  170. return -ENODEV;
  171. }
  172. switch (psp) {
  173. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  174. ret = sc2731_charger_set_current(info, val->intval / 1000);
  175. if (ret < 0)
  176. dev_err(info->dev, "set charge current failed\n");
  177. break;
  178. case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  179. ret = sc2731_charger_set_current_limit(info,
  180. val->intval / 1000);
  181. if (ret < 0)
  182. dev_err(info->dev, "set input current limit failed\n");
  183. break;
  184. default:
  185. ret = -EINVAL;
  186. }
  187. mutex_unlock(&info->lock);
  188. return ret;
  189. }
  190. static int sc2731_charger_usb_get_property(struct power_supply *psy,
  191. enum power_supply_property psp,
  192. union power_supply_propval *val)
  193. {
  194. struct sc2731_charger_info *info = power_supply_get_drvdata(psy);
  195. int ret = 0;
  196. u32 cur;
  197. mutex_lock(&info->lock);
  198. switch (psp) {
  199. case POWER_SUPPLY_PROP_STATUS:
  200. if (info->charging)
  201. val->intval = sc2731_charger_get_status(info);
  202. else
  203. val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  204. break;
  205. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  206. if (!info->charging) {
  207. val->intval = 0;
  208. } else {
  209. ret = sc2731_charger_get_current(info, &cur);
  210. if (ret)
  211. goto out;
  212. val->intval = cur * 1000;
  213. }
  214. break;
  215. case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  216. if (!info->charging) {
  217. val->intval = 0;
  218. } else {
  219. ret = sc2731_charger_get_current_limit(info, &cur);
  220. if (ret)
  221. goto out;
  222. val->intval = cur * 1000;
  223. }
  224. break;
  225. default:
  226. ret = -EINVAL;
  227. }
  228. out:
  229. mutex_unlock(&info->lock);
  230. return ret;
  231. }
  232. static int sc2731_charger_property_is_writeable(struct power_supply *psy,
  233. enum power_supply_property psp)
  234. {
  235. int ret;
  236. switch (psp) {
  237. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  238. case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT:
  239. ret = 1;
  240. break;
  241. default:
  242. ret = 0;
  243. }
  244. return ret;
  245. }
  246. static enum power_supply_property sc2731_usb_props[] = {
  247. POWER_SUPPLY_PROP_STATUS,
  248. POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
  249. POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT,
  250. };
  251. static const struct power_supply_desc sc2731_charger_desc = {
  252. .name = "sc2731_charger",
  253. .type = POWER_SUPPLY_TYPE_USB,
  254. .properties = sc2731_usb_props,
  255. .num_properties = ARRAY_SIZE(sc2731_usb_props),
  256. .get_property = sc2731_charger_usb_get_property,
  257. .set_property = sc2731_charger_usb_set_property,
  258. .property_is_writeable = sc2731_charger_property_is_writeable,
  259. };
  260. static void sc2731_charger_work(struct work_struct *data)
  261. {
  262. struct sc2731_charger_info *info =
  263. container_of(data, struct sc2731_charger_info, work);
  264. int ret;
  265. mutex_lock(&info->lock);
  266. if (info->limit > 0 && !info->charging) {
  267. /* set current limitation and start to charge */
  268. ret = sc2731_charger_set_current_limit(info, info->limit);
  269. if (ret)
  270. goto out;
  271. ret = sc2731_charger_set_current(info, info->limit);
  272. if (ret)
  273. goto out;
  274. ret = sc2731_charger_start_charge(info);
  275. if (ret)
  276. goto out;
  277. info->charging = true;
  278. } else if (!info->limit && info->charging) {
  279. /* Stop charging */
  280. info->charging = false;
  281. sc2731_charger_stop_charge(info);
  282. }
  283. out:
  284. mutex_unlock(&info->lock);
  285. }
  286. static int sc2731_charger_usb_change(struct notifier_block *nb,
  287. unsigned long limit, void *data)
  288. {
  289. struct sc2731_charger_info *info =
  290. container_of(nb, struct sc2731_charger_info, usb_notify);
  291. info->limit = limit;
  292. schedule_work(&info->work);
  293. return NOTIFY_OK;
  294. }
  295. static int sc2731_charger_hw_init(struct sc2731_charger_info *info)
  296. {
  297. struct power_supply_battery_info bat_info = { };
  298. u32 term_currrent, term_voltage, cur_val, vol_val;
  299. int ret;
  300. /* Enable charger module */
  301. ret = regmap_update_bits(info->regmap, SC2731_MODULE_EN1,
  302. SC2731_CHARGE_EN, SC2731_CHARGE_EN);
  303. if (ret)
  304. return ret;
  305. ret = power_supply_get_battery_info(info->psy_usb, &bat_info);
  306. if (ret) {
  307. dev_warn(info->dev, "no battery information is supplied\n");
  308. /*
  309. * If no battery information is supplied, we should set
  310. * default charge termination current to 120 mA, and default
  311. * charge termination voltage to 4.35V.
  312. */
  313. cur_val = 0x2;
  314. vol_val = 0x1;
  315. } else {
  316. term_currrent = bat_info.charge_term_current_ua / 1000;
  317. if (term_currrent <= 90)
  318. cur_val = 0;
  319. else if (term_currrent >= 265)
  320. cur_val = 0x7;
  321. else
  322. cur_val = ((term_currrent - 90) / 25) + 1;
  323. term_voltage = bat_info.constant_charge_voltage_max_uv / 1000;
  324. if (term_voltage > 4500)
  325. term_voltage = 4500;
  326. if (term_voltage > 4200)
  327. vol_val = (term_voltage - 4200) / 100;
  328. else
  329. vol_val = 0;
  330. power_supply_put_battery_info(info->psy_usb, &bat_info);
  331. }
  332. /* Set charge termination current */
  333. ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG2,
  334. SC2731_TERMINATION_CUR_MASK, cur_val);
  335. if (ret)
  336. goto error;
  337. /* Set charge termination voltage */
  338. ret = regmap_update_bits(info->regmap, info->base + SC2731_CHG_CFG0,
  339. SC2731_TERMINATION_VOL_MASK |
  340. SC2731_TERMINATION_VOL_CAL_MASK,
  341. (vol_val << SC2731_TERMINATION_VOL_SHIFT) |
  342. (0x6 << SC2731_TERMINATION_VOL_CAL_SHIFT));
  343. if (ret)
  344. goto error;
  345. return 0;
  346. error:
  347. regmap_update_bits(info->regmap, SC2731_MODULE_EN1, SC2731_CHARGE_EN, 0);
  348. return ret;
  349. }
  350. static void sc2731_charger_detect_status(struct sc2731_charger_info *info)
  351. {
  352. unsigned int min, max;
  353. /*
  354. * If the USB charger status has been USB_CHARGER_PRESENT before
  355. * registering the notifier, we should start to charge with getting
  356. * the charge current.
  357. */
  358. if (info->usb_phy->chg_state != USB_CHARGER_PRESENT)
  359. return;
  360. usb_phy_get_charger_current(info->usb_phy, &min, &max);
  361. info->limit = min;
  362. schedule_work(&info->work);
  363. }
  364. static int sc2731_charger_probe(struct platform_device *pdev)
  365. {
  366. struct device_node *np = pdev->dev.of_node;
  367. struct sc2731_charger_info *info;
  368. struct power_supply_config charger_cfg = { };
  369. int ret;
  370. info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
  371. if (!info)
  372. return -ENOMEM;
  373. mutex_init(&info->lock);
  374. info->dev = &pdev->dev;
  375. INIT_WORK(&info->work, sc2731_charger_work);
  376. info->regmap = dev_get_regmap(pdev->dev.parent, NULL);
  377. if (!info->regmap) {
  378. dev_err(&pdev->dev, "failed to get charger regmap\n");
  379. return -ENODEV;
  380. }
  381. ret = of_property_read_u32(np, "reg", &info->base);
  382. if (ret) {
  383. dev_err(&pdev->dev, "failed to get register address\n");
  384. return -ENODEV;
  385. }
  386. charger_cfg.drv_data = info;
  387. charger_cfg.of_node = np;
  388. info->psy_usb = devm_power_supply_register(&pdev->dev,
  389. &sc2731_charger_desc,
  390. &charger_cfg);
  391. if (IS_ERR(info->psy_usb)) {
  392. dev_err(&pdev->dev, "failed to register power supply\n");
  393. return PTR_ERR(info->psy_usb);
  394. }
  395. ret = sc2731_charger_hw_init(info);
  396. if (ret)
  397. return ret;
  398. info->usb_phy = devm_usb_get_phy_by_phandle(&pdev->dev, "phys", 0);
  399. if (IS_ERR(info->usb_phy)) {
  400. dev_err(&pdev->dev, "failed to find USB phy\n");
  401. return PTR_ERR(info->usb_phy);
  402. }
  403. info->usb_notify.notifier_call = sc2731_charger_usb_change;
  404. ret = usb_register_notifier(info->usb_phy, &info->usb_notify);
  405. if (ret) {
  406. dev_err(&pdev->dev, "failed to register notifier: %d\n", ret);
  407. return ret;
  408. }
  409. sc2731_charger_detect_status(info);
  410. return 0;
  411. }
  412. static int sc2731_charger_remove(struct platform_device *pdev)
  413. {
  414. struct sc2731_charger_info *info = platform_get_drvdata(pdev);
  415. usb_unregister_notifier(info->usb_phy, &info->usb_notify);
  416. return 0;
  417. }
  418. static const struct of_device_id sc2731_charger_of_match[] = {
  419. { .compatible = "sprd,sc2731-charger", },
  420. { }
  421. };
  422. MODULE_DEVICE_TABLE(of, sc2731_charger_of_match);
  423. static struct platform_driver sc2731_charger_driver = {
  424. .driver = {
  425. .name = "sc2731-charger",
  426. .of_match_table = sc2731_charger_of_match,
  427. },
  428. .probe = sc2731_charger_probe,
  429. .remove = sc2731_charger_remove,
  430. };
  431. module_platform_driver(sc2731_charger_driver);
  432. MODULE_DESCRIPTION("Spreadtrum SC2731 Charger Driver");
  433. MODULE_LICENSE("GPL v2");