da9030_battery.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Battery charger driver for Dialog Semiconductor DA9030
  4. *
  5. * Copyright (C) 2008 Compulab, Ltd.
  6. * Mike Rapoport <mike@compulab.co.il>
  7. */
  8. #include <linux/kernel.h>
  9. #include <linux/slab.h>
  10. #include <linux/init.h>
  11. #include <linux/types.h>
  12. #include <linux/device.h>
  13. #include <linux/workqueue.h>
  14. #include <linux/module.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/power_supply.h>
  17. #include <linux/mfd/da903x.h>
  18. #include <linux/debugfs.h>
  19. #include <linux/seq_file.h>
  20. #include <linux/notifier.h>
  21. #define DA9030_FAULT_LOG 0x0a
  22. #define DA9030_FAULT_LOG_OVER_TEMP (1 << 7)
  23. #define DA9030_FAULT_LOG_VBAT_OVER (1 << 4)
  24. #define DA9030_CHARGE_CONTROL 0x28
  25. #define DA9030_CHRG_CHARGER_ENABLE (1 << 7)
  26. #define DA9030_ADC_MAN_CONTROL 0x30
  27. #define DA9030_ADC_TBATREF_ENABLE (1 << 5)
  28. #define DA9030_ADC_LDO_INT_ENABLE (1 << 4)
  29. #define DA9030_ADC_AUTO_CONTROL 0x31
  30. #define DA9030_ADC_TBAT_ENABLE (1 << 5)
  31. #define DA9030_ADC_VBAT_IN_TXON (1 << 4)
  32. #define DA9030_ADC_VCH_ENABLE (1 << 3)
  33. #define DA9030_ADC_ICH_ENABLE (1 << 2)
  34. #define DA9030_ADC_VBAT_ENABLE (1 << 1)
  35. #define DA9030_ADC_AUTO_SLEEP_ENABLE (1 << 0)
  36. #define DA9030_VBATMON 0x32
  37. #define DA9030_VBATMONTXON 0x33
  38. #define DA9030_TBATHIGHP 0x34
  39. #define DA9030_TBATHIGHN 0x35
  40. #define DA9030_TBATLOW 0x36
  41. #define DA9030_VBAT_RES 0x41
  42. #define DA9030_VBATMIN_RES 0x42
  43. #define DA9030_VBATMINTXON_RES 0x43
  44. #define DA9030_ICHMAX_RES 0x44
  45. #define DA9030_ICHMIN_RES 0x45
  46. #define DA9030_ICHAVERAGE_RES 0x46
  47. #define DA9030_VCHMAX_RES 0x47
  48. #define DA9030_VCHMIN_RES 0x48
  49. #define DA9030_TBAT_RES 0x49
  50. struct da9030_adc_res {
  51. uint8_t vbat_res;
  52. uint8_t vbatmin_res;
  53. uint8_t vbatmintxon;
  54. uint8_t ichmax_res;
  55. uint8_t ichmin_res;
  56. uint8_t ichaverage_res;
  57. uint8_t vchmax_res;
  58. uint8_t vchmin_res;
  59. uint8_t tbat_res;
  60. uint8_t adc_in4_res;
  61. uint8_t adc_in5_res;
  62. };
  63. struct da9030_battery_thresholds {
  64. int tbat_low;
  65. int tbat_high;
  66. int tbat_restart;
  67. int vbat_low;
  68. int vbat_crit;
  69. int vbat_charge_start;
  70. int vbat_charge_stop;
  71. int vbat_charge_restart;
  72. int vcharge_min;
  73. int vcharge_max;
  74. };
  75. struct da9030_charger {
  76. struct power_supply *psy;
  77. struct power_supply_desc psy_desc;
  78. struct device *master;
  79. struct da9030_adc_res adc;
  80. struct delayed_work work;
  81. unsigned int interval;
  82. struct power_supply_info *battery_info;
  83. struct da9030_battery_thresholds thresholds;
  84. unsigned int charge_milliamp;
  85. unsigned int charge_millivolt;
  86. /* charger status */
  87. bool chdet;
  88. uint8_t fault;
  89. int mA;
  90. int mV;
  91. bool is_on;
  92. struct notifier_block nb;
  93. /* platform callbacks for battery low and critical events */
  94. void (*battery_low)(void);
  95. void (*battery_critical)(void);
  96. struct dentry *debug_file;
  97. };
  98. static inline int da9030_reg_to_mV(int reg)
  99. {
  100. return ((reg * 2650) >> 8) + 2650;
  101. }
  102. static inline int da9030_millivolt_to_reg(int mV)
  103. {
  104. return ((mV - 2650) << 8) / 2650;
  105. }
  106. static inline int da9030_reg_to_mA(int reg)
  107. {
  108. return ((reg * 24000) >> 8) / 15;
  109. }
  110. #ifdef CONFIG_DEBUG_FS
  111. static int bat_debug_show(struct seq_file *s, void *data)
  112. {
  113. struct da9030_charger *charger = s->private;
  114. seq_printf(s, "charger is %s\n", charger->is_on ? "on" : "off");
  115. if (charger->chdet) {
  116. seq_printf(s, "iset = %dmA, vset = %dmV\n",
  117. charger->mA, charger->mV);
  118. }
  119. seq_printf(s, "vbat_res = %d (%dmV)\n",
  120. charger->adc.vbat_res,
  121. da9030_reg_to_mV(charger->adc.vbat_res));
  122. seq_printf(s, "vbatmin_res = %d (%dmV)\n",
  123. charger->adc.vbatmin_res,
  124. da9030_reg_to_mV(charger->adc.vbatmin_res));
  125. seq_printf(s, "vbatmintxon = %d (%dmV)\n",
  126. charger->adc.vbatmintxon,
  127. da9030_reg_to_mV(charger->adc.vbatmintxon));
  128. seq_printf(s, "ichmax_res = %d (%dmA)\n",
  129. charger->adc.ichmax_res,
  130. da9030_reg_to_mV(charger->adc.ichmax_res));
  131. seq_printf(s, "ichmin_res = %d (%dmA)\n",
  132. charger->adc.ichmin_res,
  133. da9030_reg_to_mA(charger->adc.ichmin_res));
  134. seq_printf(s, "ichaverage_res = %d (%dmA)\n",
  135. charger->adc.ichaverage_res,
  136. da9030_reg_to_mA(charger->adc.ichaverage_res));
  137. seq_printf(s, "vchmax_res = %d (%dmV)\n",
  138. charger->adc.vchmax_res,
  139. da9030_reg_to_mA(charger->adc.vchmax_res));
  140. seq_printf(s, "vchmin_res = %d (%dmV)\n",
  141. charger->adc.vchmin_res,
  142. da9030_reg_to_mV(charger->adc.vchmin_res));
  143. return 0;
  144. }
  145. DEFINE_SHOW_ATTRIBUTE(bat_debug);
  146. static struct dentry *da9030_bat_create_debugfs(struct da9030_charger *charger)
  147. {
  148. charger->debug_file = debugfs_create_file("charger", 0666, NULL,
  149. charger, &bat_debug_fops);
  150. return charger->debug_file;
  151. }
  152. static void da9030_bat_remove_debugfs(struct da9030_charger *charger)
  153. {
  154. debugfs_remove(charger->debug_file);
  155. }
  156. #else
  157. static inline struct dentry *da9030_bat_create_debugfs(struct da9030_charger *charger)
  158. {
  159. return NULL;
  160. }
  161. static inline void da9030_bat_remove_debugfs(struct da9030_charger *charger)
  162. {
  163. }
  164. #endif
  165. static inline void da9030_read_adc(struct da9030_charger *charger,
  166. struct da9030_adc_res *adc)
  167. {
  168. da903x_reads(charger->master, DA9030_VBAT_RES,
  169. sizeof(*adc), (uint8_t *)adc);
  170. }
  171. static void da9030_charger_update_state(struct da9030_charger *charger)
  172. {
  173. uint8_t val;
  174. da903x_read(charger->master, DA9030_CHARGE_CONTROL, &val);
  175. charger->is_on = (val & DA9030_CHRG_CHARGER_ENABLE) ? 1 : 0;
  176. charger->mA = ((val >> 3) & 0xf) * 100;
  177. charger->mV = (val & 0x7) * 50 + 4000;
  178. da9030_read_adc(charger, &charger->adc);
  179. da903x_read(charger->master, DA9030_FAULT_LOG, &charger->fault);
  180. charger->chdet = da903x_query_status(charger->master,
  181. DA9030_STATUS_CHDET);
  182. }
  183. static void da9030_set_charge(struct da9030_charger *charger, int on)
  184. {
  185. uint8_t val;
  186. if (on) {
  187. val = DA9030_CHRG_CHARGER_ENABLE;
  188. val |= (charger->charge_milliamp / 100) << 3;
  189. val |= (charger->charge_millivolt - 4000) / 50;
  190. charger->is_on = 1;
  191. } else {
  192. val = 0;
  193. charger->is_on = 0;
  194. }
  195. da903x_write(charger->master, DA9030_CHARGE_CONTROL, val);
  196. power_supply_changed(charger->psy);
  197. }
  198. static void da9030_charger_check_state(struct da9030_charger *charger)
  199. {
  200. da9030_charger_update_state(charger);
  201. /* we wake or boot with external power on */
  202. if (!charger->is_on) {
  203. if ((charger->chdet) &&
  204. (charger->adc.vbat_res <
  205. charger->thresholds.vbat_charge_start)) {
  206. da9030_set_charge(charger, 1);
  207. }
  208. } else {
  209. /* Charger has been pulled out */
  210. if (!charger->chdet) {
  211. da9030_set_charge(charger, 0);
  212. return;
  213. }
  214. if (charger->adc.vbat_res >=
  215. charger->thresholds.vbat_charge_stop) {
  216. da9030_set_charge(charger, 0);
  217. da903x_write(charger->master, DA9030_VBATMON,
  218. charger->thresholds.vbat_charge_restart);
  219. } else if (charger->adc.vbat_res >
  220. charger->thresholds.vbat_low) {
  221. /* we are charging and passed LOW_THRESH,
  222. so upate DA9030 VBAT threshold
  223. */
  224. da903x_write(charger->master, DA9030_VBATMON,
  225. charger->thresholds.vbat_low);
  226. }
  227. if (charger->adc.vchmax_res > charger->thresholds.vcharge_max ||
  228. charger->adc.vchmin_res < charger->thresholds.vcharge_min ||
  229. /* Tempreture readings are negative */
  230. charger->adc.tbat_res < charger->thresholds.tbat_high ||
  231. charger->adc.tbat_res > charger->thresholds.tbat_low) {
  232. /* disable charger */
  233. da9030_set_charge(charger, 0);
  234. }
  235. }
  236. }
  237. static void da9030_charging_monitor(struct work_struct *work)
  238. {
  239. struct da9030_charger *charger;
  240. charger = container_of(work, struct da9030_charger, work.work);
  241. da9030_charger_check_state(charger);
  242. /* reschedule for the next time */
  243. schedule_delayed_work(&charger->work, charger->interval);
  244. }
  245. static enum power_supply_property da9030_battery_props[] = {
  246. POWER_SUPPLY_PROP_MODEL_NAME,
  247. POWER_SUPPLY_PROP_STATUS,
  248. POWER_SUPPLY_PROP_HEALTH,
  249. POWER_SUPPLY_PROP_TECHNOLOGY,
  250. POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
  251. POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
  252. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  253. POWER_SUPPLY_PROP_CURRENT_AVG,
  254. };
  255. static void da9030_battery_check_status(struct da9030_charger *charger,
  256. union power_supply_propval *val)
  257. {
  258. if (charger->chdet) {
  259. if (charger->is_on)
  260. val->intval = POWER_SUPPLY_STATUS_CHARGING;
  261. else
  262. val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  263. } else {
  264. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  265. }
  266. }
  267. static void da9030_battery_check_health(struct da9030_charger *charger,
  268. union power_supply_propval *val)
  269. {
  270. if (charger->fault & DA9030_FAULT_LOG_OVER_TEMP)
  271. val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
  272. else if (charger->fault & DA9030_FAULT_LOG_VBAT_OVER)
  273. val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  274. else
  275. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  276. }
  277. static int da9030_battery_get_property(struct power_supply *psy,
  278. enum power_supply_property psp,
  279. union power_supply_propval *val)
  280. {
  281. struct da9030_charger *charger = power_supply_get_drvdata(psy);
  282. switch (psp) {
  283. case POWER_SUPPLY_PROP_STATUS:
  284. da9030_battery_check_status(charger, val);
  285. break;
  286. case POWER_SUPPLY_PROP_HEALTH:
  287. da9030_battery_check_health(charger, val);
  288. break;
  289. case POWER_SUPPLY_PROP_TECHNOLOGY:
  290. val->intval = charger->battery_info->technology;
  291. break;
  292. case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
  293. val->intval = charger->battery_info->voltage_max_design;
  294. break;
  295. case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
  296. val->intval = charger->battery_info->voltage_min_design;
  297. break;
  298. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  299. val->intval = da9030_reg_to_mV(charger->adc.vbat_res) * 1000;
  300. break;
  301. case POWER_SUPPLY_PROP_CURRENT_AVG:
  302. val->intval =
  303. da9030_reg_to_mA(charger->adc.ichaverage_res) * 1000;
  304. break;
  305. case POWER_SUPPLY_PROP_MODEL_NAME:
  306. val->strval = charger->battery_info->name;
  307. break;
  308. default:
  309. break;
  310. }
  311. return 0;
  312. }
  313. static void da9030_battery_vbat_event(struct da9030_charger *charger)
  314. {
  315. da9030_read_adc(charger, &charger->adc);
  316. if (charger->is_on)
  317. return;
  318. if (charger->adc.vbat_res < charger->thresholds.vbat_low) {
  319. /* set VBAT threshold for critical */
  320. da903x_write(charger->master, DA9030_VBATMON,
  321. charger->thresholds.vbat_crit);
  322. if (charger->battery_low)
  323. charger->battery_low();
  324. } else if (charger->adc.vbat_res <
  325. charger->thresholds.vbat_crit) {
  326. /* notify the system of battery critical */
  327. if (charger->battery_critical)
  328. charger->battery_critical();
  329. }
  330. }
  331. static int da9030_battery_event(struct notifier_block *nb, unsigned long event,
  332. void *data)
  333. {
  334. struct da9030_charger *charger =
  335. container_of(nb, struct da9030_charger, nb);
  336. switch (event) {
  337. case DA9030_EVENT_CHDET:
  338. cancel_delayed_work_sync(&charger->work);
  339. schedule_work(&charger->work.work);
  340. break;
  341. case DA9030_EVENT_VBATMON:
  342. da9030_battery_vbat_event(charger);
  343. break;
  344. case DA9030_EVENT_CHIOVER:
  345. case DA9030_EVENT_TBAT:
  346. da9030_set_charge(charger, 0);
  347. break;
  348. }
  349. return 0;
  350. }
  351. static void da9030_battery_convert_thresholds(struct da9030_charger *charger,
  352. struct da9030_battery_info *pdata)
  353. {
  354. charger->thresholds.tbat_low = pdata->tbat_low;
  355. charger->thresholds.tbat_high = pdata->tbat_high;
  356. charger->thresholds.tbat_restart = pdata->tbat_restart;
  357. charger->thresholds.vbat_low =
  358. da9030_millivolt_to_reg(pdata->vbat_low);
  359. charger->thresholds.vbat_crit =
  360. da9030_millivolt_to_reg(pdata->vbat_crit);
  361. charger->thresholds.vbat_charge_start =
  362. da9030_millivolt_to_reg(pdata->vbat_charge_start);
  363. charger->thresholds.vbat_charge_stop =
  364. da9030_millivolt_to_reg(pdata->vbat_charge_stop);
  365. charger->thresholds.vbat_charge_restart =
  366. da9030_millivolt_to_reg(pdata->vbat_charge_restart);
  367. charger->thresholds.vcharge_min =
  368. da9030_millivolt_to_reg(pdata->vcharge_min);
  369. charger->thresholds.vcharge_max =
  370. da9030_millivolt_to_reg(pdata->vcharge_max);
  371. }
  372. static void da9030_battery_setup_psy(struct da9030_charger *charger)
  373. {
  374. struct power_supply_desc *psy_desc = &charger->psy_desc;
  375. struct power_supply_info *info = charger->battery_info;
  376. psy_desc->name = info->name;
  377. psy_desc->use_for_apm = info->use_for_apm;
  378. psy_desc->type = POWER_SUPPLY_TYPE_BATTERY;
  379. psy_desc->get_property = da9030_battery_get_property;
  380. psy_desc->properties = da9030_battery_props;
  381. psy_desc->num_properties = ARRAY_SIZE(da9030_battery_props);
  382. };
  383. static int da9030_battery_charger_init(struct da9030_charger *charger)
  384. {
  385. char v[5];
  386. int ret;
  387. v[0] = v[1] = charger->thresholds.vbat_low;
  388. v[2] = charger->thresholds.tbat_high;
  389. v[3] = charger->thresholds.tbat_restart;
  390. v[4] = charger->thresholds.tbat_low;
  391. ret = da903x_writes(charger->master, DA9030_VBATMON, 5, v);
  392. if (ret)
  393. return ret;
  394. /*
  395. * Enable reference voltage supply for ADC from the LDO_INTERNAL
  396. * regulator. Must be set before ADC measurements can be made.
  397. */
  398. ret = da903x_write(charger->master, DA9030_ADC_MAN_CONTROL,
  399. DA9030_ADC_LDO_INT_ENABLE |
  400. DA9030_ADC_TBATREF_ENABLE);
  401. if (ret)
  402. return ret;
  403. /* enable auto ADC measuremnts */
  404. return da903x_write(charger->master, DA9030_ADC_AUTO_CONTROL,
  405. DA9030_ADC_TBAT_ENABLE | DA9030_ADC_VBAT_IN_TXON |
  406. DA9030_ADC_VCH_ENABLE | DA9030_ADC_ICH_ENABLE |
  407. DA9030_ADC_VBAT_ENABLE |
  408. DA9030_ADC_AUTO_SLEEP_ENABLE);
  409. }
  410. static int da9030_battery_probe(struct platform_device *pdev)
  411. {
  412. struct da9030_charger *charger;
  413. struct power_supply_config psy_cfg = {};
  414. struct da9030_battery_info *pdata = pdev->dev.platform_data;
  415. int ret;
  416. if (pdata == NULL)
  417. return -EINVAL;
  418. if (pdata->charge_milliamp >= 1500 ||
  419. pdata->charge_millivolt < 4000 ||
  420. pdata->charge_millivolt > 4350)
  421. return -EINVAL;
  422. charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL);
  423. if (charger == NULL)
  424. return -ENOMEM;
  425. charger->master = pdev->dev.parent;
  426. /* 10 seconds between monitor runs unless platform defines other
  427. interval */
  428. charger->interval = msecs_to_jiffies(
  429. (pdata->batmon_interval ? : 10) * 1000);
  430. charger->charge_milliamp = pdata->charge_milliamp;
  431. charger->charge_millivolt = pdata->charge_millivolt;
  432. charger->battery_info = pdata->battery_info;
  433. charger->battery_low = pdata->battery_low;
  434. charger->battery_critical = pdata->battery_critical;
  435. da9030_battery_convert_thresholds(charger, pdata);
  436. ret = da9030_battery_charger_init(charger);
  437. if (ret)
  438. goto err_charger_init;
  439. INIT_DELAYED_WORK(&charger->work, da9030_charging_monitor);
  440. schedule_delayed_work(&charger->work, charger->interval);
  441. charger->nb.notifier_call = da9030_battery_event;
  442. ret = da903x_register_notifier(charger->master, &charger->nb,
  443. DA9030_EVENT_CHDET |
  444. DA9030_EVENT_VBATMON |
  445. DA9030_EVENT_CHIOVER |
  446. DA9030_EVENT_TBAT);
  447. if (ret)
  448. goto err_notifier;
  449. da9030_battery_setup_psy(charger);
  450. psy_cfg.drv_data = charger;
  451. charger->psy = power_supply_register(&pdev->dev, &charger->psy_desc,
  452. &psy_cfg);
  453. if (IS_ERR(charger->psy)) {
  454. ret = PTR_ERR(charger->psy);
  455. goto err_ps_register;
  456. }
  457. charger->debug_file = da9030_bat_create_debugfs(charger);
  458. platform_set_drvdata(pdev, charger);
  459. return 0;
  460. err_ps_register:
  461. da903x_unregister_notifier(charger->master, &charger->nb,
  462. DA9030_EVENT_CHDET | DA9030_EVENT_VBATMON |
  463. DA9030_EVENT_CHIOVER | DA9030_EVENT_TBAT);
  464. err_notifier:
  465. cancel_delayed_work(&charger->work);
  466. err_charger_init:
  467. return ret;
  468. }
  469. static int da9030_battery_remove(struct platform_device *dev)
  470. {
  471. struct da9030_charger *charger = platform_get_drvdata(dev);
  472. da9030_bat_remove_debugfs(charger);
  473. da903x_unregister_notifier(charger->master, &charger->nb,
  474. DA9030_EVENT_CHDET | DA9030_EVENT_VBATMON |
  475. DA9030_EVENT_CHIOVER | DA9030_EVENT_TBAT);
  476. cancel_delayed_work_sync(&charger->work);
  477. da9030_set_charge(charger, 0);
  478. power_supply_unregister(charger->psy);
  479. return 0;
  480. }
  481. static struct platform_driver da903x_battery_driver = {
  482. .driver = {
  483. .name = "da903x-battery",
  484. },
  485. .probe = da9030_battery_probe,
  486. .remove = da9030_battery_remove,
  487. };
  488. module_platform_driver(da903x_battery_driver);
  489. MODULE_DESCRIPTION("DA9030 battery charger driver");
  490. MODULE_AUTHOR("Mike Rapoport, CompuLab");
  491. MODULE_LICENSE("GPL");