lp8788-charger.c 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * TI LP8788 MFD - battery charger driver
  4. *
  5. * Copyright 2012 Texas Instruments
  6. *
  7. * Author: Milo(Woogyom) Kim <milo.kim@ti.com>
  8. */
  9. #include <linux/err.h>
  10. #include <linux/iio/consumer.h>
  11. #include <linux/interrupt.h>
  12. #include <linux/irqdomain.h>
  13. #include <linux/mfd/lp8788.h>
  14. #include <linux/module.h>
  15. #include <linux/platform_device.h>
  16. #include <linux/power_supply.h>
  17. #include <linux/slab.h>
  18. #include <linux/workqueue.h>
  19. /* register address */
  20. #define LP8788_CHG_STATUS 0x07
  21. #define LP8788_CHG_IDCIN 0x13
  22. #define LP8788_CHG_IBATT 0x14
  23. #define LP8788_CHG_VTERM 0x15
  24. #define LP8788_CHG_EOC 0x16
  25. /* mask/shift bits */
  26. #define LP8788_CHG_INPUT_STATE_M 0x03 /* Addr 07h */
  27. #define LP8788_CHG_STATE_M 0x3C
  28. #define LP8788_CHG_STATE_S 2
  29. #define LP8788_NO_BATT_M BIT(6)
  30. #define LP8788_BAD_BATT_M BIT(7)
  31. #define LP8788_CHG_IBATT_M 0x1F /* Addr 14h */
  32. #define LP8788_CHG_VTERM_M 0x0F /* Addr 15h */
  33. #define LP8788_CHG_EOC_LEVEL_M 0x30 /* Addr 16h */
  34. #define LP8788_CHG_EOC_LEVEL_S 4
  35. #define LP8788_CHG_EOC_TIME_M 0x0E
  36. #define LP8788_CHG_EOC_TIME_S 1
  37. #define LP8788_CHG_EOC_MODE_M BIT(0)
  38. #define LP8788_CHARGER_NAME "charger"
  39. #define LP8788_BATTERY_NAME "main_batt"
  40. #define LP8788_CHG_START 0x11
  41. #define LP8788_CHG_END 0x1C
  42. #define LP8788_ISEL_MAX 23
  43. #define LP8788_ISEL_STEP 50
  44. #define LP8788_VTERM_MIN 4100
  45. #define LP8788_VTERM_STEP 25
  46. #define LP8788_MAX_BATT_CAPACITY 100
  47. #define LP8788_MAX_CHG_IRQS 11
  48. enum lp8788_charging_state {
  49. LP8788_OFF,
  50. LP8788_WARM_UP,
  51. LP8788_LOW_INPUT = 0x3,
  52. LP8788_PRECHARGE,
  53. LP8788_CC,
  54. LP8788_CV,
  55. LP8788_MAINTENANCE,
  56. LP8788_BATTERY_FAULT,
  57. LP8788_SYSTEM_SUPPORT = 0xC,
  58. LP8788_HIGH_CURRENT = 0xF,
  59. LP8788_MAX_CHG_STATE,
  60. };
  61. enum lp8788_charger_adc_sel {
  62. LP8788_VBATT,
  63. LP8788_BATT_TEMP,
  64. LP8788_NUM_CHG_ADC,
  65. };
  66. enum lp8788_charger_input_state {
  67. LP8788_SYSTEM_SUPPLY = 1,
  68. LP8788_FULL_FUNCTION,
  69. };
  70. /*
  71. * struct lp8788_chg_irq
  72. * @which : lp8788 interrupt id
  73. * @virq : Linux IRQ number from irq_domain
  74. */
  75. struct lp8788_chg_irq {
  76. enum lp8788_int_id which;
  77. int virq;
  78. };
  79. /*
  80. * struct lp8788_charger
  81. * @lp : used for accessing the registers of mfd lp8788 device
  82. * @charger : power supply driver for the battery charger
  83. * @battery : power supply driver for the battery
  84. * @charger_work : work queue for charger input interrupts
  85. * @chan : iio channels for getting adc values
  86. * eg) battery voltage, capacity and temperature
  87. * @irqs : charger dedicated interrupts
  88. * @num_irqs : total numbers of charger interrupts
  89. * @pdata : charger platform specific data
  90. */
  91. struct lp8788_charger {
  92. struct lp8788 *lp;
  93. struct power_supply *charger;
  94. struct power_supply *battery;
  95. struct work_struct charger_work;
  96. struct iio_channel *chan[LP8788_NUM_CHG_ADC];
  97. struct lp8788_chg_irq irqs[LP8788_MAX_CHG_IRQS];
  98. int num_irqs;
  99. struct lp8788_charger_platform_data *pdata;
  100. };
  101. static char *battery_supplied_to[] = {
  102. LP8788_BATTERY_NAME,
  103. };
  104. static enum power_supply_property lp8788_charger_prop[] = {
  105. POWER_SUPPLY_PROP_ONLINE,
  106. POWER_SUPPLY_PROP_CURRENT_MAX,
  107. };
  108. static enum power_supply_property lp8788_battery_prop[] = {
  109. POWER_SUPPLY_PROP_STATUS,
  110. POWER_SUPPLY_PROP_HEALTH,
  111. POWER_SUPPLY_PROP_PRESENT,
  112. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  113. POWER_SUPPLY_PROP_CAPACITY,
  114. POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
  115. POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
  116. POWER_SUPPLY_PROP_TEMP,
  117. };
  118. static bool lp8788_is_charger_detected(struct lp8788_charger *pchg)
  119. {
  120. u8 data;
  121. lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
  122. data &= LP8788_CHG_INPUT_STATE_M;
  123. return data == LP8788_SYSTEM_SUPPLY || data == LP8788_FULL_FUNCTION;
  124. }
  125. static int lp8788_charger_get_property(struct power_supply *psy,
  126. enum power_supply_property psp,
  127. union power_supply_propval *val)
  128. {
  129. struct lp8788_charger *pchg = dev_get_drvdata(psy->dev.parent);
  130. u8 read;
  131. switch (psp) {
  132. case POWER_SUPPLY_PROP_ONLINE:
  133. val->intval = lp8788_is_charger_detected(pchg);
  134. break;
  135. case POWER_SUPPLY_PROP_CURRENT_MAX:
  136. lp8788_read_byte(pchg->lp, LP8788_CHG_IDCIN, &read);
  137. val->intval = LP8788_ISEL_STEP *
  138. (min_t(int, read, LP8788_ISEL_MAX) + 1);
  139. break;
  140. default:
  141. return -EINVAL;
  142. }
  143. return 0;
  144. }
  145. static int lp8788_get_battery_status(struct lp8788_charger *pchg,
  146. union power_supply_propval *val)
  147. {
  148. enum lp8788_charging_state state;
  149. u8 data;
  150. int ret;
  151. ret = lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
  152. if (ret)
  153. return ret;
  154. state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
  155. switch (state) {
  156. case LP8788_OFF:
  157. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  158. break;
  159. case LP8788_PRECHARGE:
  160. case LP8788_CC:
  161. case LP8788_CV:
  162. case LP8788_HIGH_CURRENT:
  163. val->intval = POWER_SUPPLY_STATUS_CHARGING;
  164. break;
  165. case LP8788_MAINTENANCE:
  166. val->intval = POWER_SUPPLY_STATUS_FULL;
  167. break;
  168. default:
  169. val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  170. break;
  171. }
  172. return 0;
  173. }
  174. static int lp8788_get_battery_health(struct lp8788_charger *pchg,
  175. union power_supply_propval *val)
  176. {
  177. u8 data;
  178. int ret;
  179. ret = lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
  180. if (ret)
  181. return ret;
  182. if (data & LP8788_NO_BATT_M)
  183. val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  184. else if (data & LP8788_BAD_BATT_M)
  185. val->intval = POWER_SUPPLY_HEALTH_DEAD;
  186. else
  187. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  188. return 0;
  189. }
  190. static int lp8788_get_battery_present(struct lp8788_charger *pchg,
  191. union power_supply_propval *val)
  192. {
  193. u8 data;
  194. int ret;
  195. ret = lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
  196. if (ret)
  197. return ret;
  198. val->intval = !(data & LP8788_NO_BATT_M);
  199. return 0;
  200. }
  201. static int lp8788_get_vbatt_adc(struct lp8788_charger *pchg, int *result)
  202. {
  203. struct iio_channel *channel = pchg->chan[LP8788_VBATT];
  204. if (!channel)
  205. return -EINVAL;
  206. return iio_read_channel_processed(channel, result);
  207. }
  208. static int lp8788_get_battery_voltage(struct lp8788_charger *pchg,
  209. union power_supply_propval *val)
  210. {
  211. return lp8788_get_vbatt_adc(pchg, &val->intval);
  212. }
  213. static int lp8788_get_battery_capacity(struct lp8788_charger *pchg,
  214. union power_supply_propval *val)
  215. {
  216. struct lp8788 *lp = pchg->lp;
  217. struct lp8788_charger_platform_data *pdata = pchg->pdata;
  218. unsigned int max_vbatt;
  219. int vbatt;
  220. enum lp8788_charging_state state;
  221. u8 data;
  222. int ret;
  223. if (!pdata)
  224. return -EINVAL;
  225. max_vbatt = pdata->max_vbatt_mv;
  226. if (max_vbatt == 0)
  227. return -EINVAL;
  228. ret = lp8788_read_byte(lp, LP8788_CHG_STATUS, &data);
  229. if (ret)
  230. return ret;
  231. state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
  232. if (state == LP8788_MAINTENANCE) {
  233. val->intval = LP8788_MAX_BATT_CAPACITY;
  234. } else {
  235. ret = lp8788_get_vbatt_adc(pchg, &vbatt);
  236. if (ret)
  237. return ret;
  238. val->intval = (vbatt * LP8788_MAX_BATT_CAPACITY) / max_vbatt;
  239. val->intval = min(val->intval, LP8788_MAX_BATT_CAPACITY);
  240. }
  241. return 0;
  242. }
  243. static int lp8788_get_battery_temperature(struct lp8788_charger *pchg,
  244. union power_supply_propval *val)
  245. {
  246. struct iio_channel *channel = pchg->chan[LP8788_BATT_TEMP];
  247. int result;
  248. int ret;
  249. if (!channel)
  250. return -EINVAL;
  251. ret = iio_read_channel_processed(channel, &result);
  252. if (ret < 0)
  253. return -EINVAL;
  254. /* unit: 0.1 'C */
  255. val->intval = result * 10;
  256. return 0;
  257. }
  258. static int lp8788_get_battery_charging_current(struct lp8788_charger *pchg,
  259. union power_supply_propval *val)
  260. {
  261. u8 read;
  262. lp8788_read_byte(pchg->lp, LP8788_CHG_IBATT, &read);
  263. read &= LP8788_CHG_IBATT_M;
  264. val->intval = LP8788_ISEL_STEP *
  265. (min_t(int, read, LP8788_ISEL_MAX) + 1);
  266. return 0;
  267. }
  268. static int lp8788_get_charging_termination_voltage(struct lp8788_charger *pchg,
  269. union power_supply_propval *val)
  270. {
  271. u8 read;
  272. lp8788_read_byte(pchg->lp, LP8788_CHG_VTERM, &read);
  273. read &= LP8788_CHG_VTERM_M;
  274. val->intval = LP8788_VTERM_MIN + LP8788_VTERM_STEP * read;
  275. return 0;
  276. }
  277. static int lp8788_battery_get_property(struct power_supply *psy,
  278. enum power_supply_property psp,
  279. union power_supply_propval *val)
  280. {
  281. struct lp8788_charger *pchg = dev_get_drvdata(psy->dev.parent);
  282. switch (psp) {
  283. case POWER_SUPPLY_PROP_STATUS:
  284. return lp8788_get_battery_status(pchg, val);
  285. case POWER_SUPPLY_PROP_HEALTH:
  286. return lp8788_get_battery_health(pchg, val);
  287. case POWER_SUPPLY_PROP_PRESENT:
  288. return lp8788_get_battery_present(pchg, val);
  289. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  290. return lp8788_get_battery_voltage(pchg, val);
  291. case POWER_SUPPLY_PROP_CAPACITY:
  292. return lp8788_get_battery_capacity(pchg, val);
  293. case POWER_SUPPLY_PROP_TEMP:
  294. return lp8788_get_battery_temperature(pchg, val);
  295. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
  296. return lp8788_get_battery_charging_current(pchg, val);
  297. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
  298. return lp8788_get_charging_termination_voltage(pchg, val);
  299. default:
  300. return -EINVAL;
  301. }
  302. }
  303. static inline bool lp8788_is_valid_charger_register(u8 addr)
  304. {
  305. return addr >= LP8788_CHG_START && addr <= LP8788_CHG_END;
  306. }
  307. static int lp8788_update_charger_params(struct platform_device *pdev,
  308. struct lp8788_charger *pchg)
  309. {
  310. struct lp8788 *lp = pchg->lp;
  311. struct lp8788_charger_platform_data *pdata = pchg->pdata;
  312. struct lp8788_chg_param *param;
  313. int i;
  314. int ret;
  315. if (!pdata || !pdata->chg_params) {
  316. dev_info(&pdev->dev, "skip updating charger parameters\n");
  317. return 0;
  318. }
  319. /* settting charging parameters */
  320. for (i = 0; i < pdata->num_chg_params; i++) {
  321. param = pdata->chg_params + i;
  322. if (lp8788_is_valid_charger_register(param->addr)) {
  323. ret = lp8788_write_byte(lp, param->addr, param->val);
  324. if (ret)
  325. return ret;
  326. }
  327. }
  328. return 0;
  329. }
  330. static const struct power_supply_desc lp8788_psy_charger_desc = {
  331. .name = LP8788_CHARGER_NAME,
  332. .type = POWER_SUPPLY_TYPE_MAINS,
  333. .properties = lp8788_charger_prop,
  334. .num_properties = ARRAY_SIZE(lp8788_charger_prop),
  335. .get_property = lp8788_charger_get_property,
  336. };
  337. static const struct power_supply_desc lp8788_psy_battery_desc = {
  338. .name = LP8788_BATTERY_NAME,
  339. .type = POWER_SUPPLY_TYPE_BATTERY,
  340. .properties = lp8788_battery_prop,
  341. .num_properties = ARRAY_SIZE(lp8788_battery_prop),
  342. .get_property = lp8788_battery_get_property,
  343. };
  344. static void lp8788_psy_unregister(struct lp8788_charger *pchg)
  345. {
  346. power_supply_unregister(pchg->battery);
  347. power_supply_unregister(pchg->charger);
  348. }
  349. static void lp8788_charger_event(struct work_struct *work)
  350. {
  351. struct lp8788_charger *pchg =
  352. container_of(work, struct lp8788_charger, charger_work);
  353. struct lp8788_charger_platform_data *pdata = pchg->pdata;
  354. enum lp8788_charger_event event = lp8788_is_charger_detected(pchg);
  355. pdata->charger_event(pchg->lp, event);
  356. }
  357. static bool lp8788_find_irq_id(struct lp8788_charger *pchg, int virq, int *id)
  358. {
  359. bool found = false;
  360. int i;
  361. for (i = 0; i < pchg->num_irqs; i++) {
  362. if (pchg->irqs[i].virq == virq) {
  363. *id = pchg->irqs[i].which;
  364. found = true;
  365. break;
  366. }
  367. }
  368. return found;
  369. }
  370. static irqreturn_t lp8788_charger_irq_thread(int virq, void *ptr)
  371. {
  372. struct lp8788_charger *pchg = ptr;
  373. struct lp8788_charger_platform_data *pdata = pchg->pdata;
  374. int id = -1;
  375. if (!lp8788_find_irq_id(pchg, virq, &id))
  376. return IRQ_NONE;
  377. switch (id) {
  378. case LP8788_INT_CHG_INPUT_STATE:
  379. case LP8788_INT_CHG_STATE:
  380. case LP8788_INT_EOC:
  381. case LP8788_INT_BATT_LOW:
  382. case LP8788_INT_NO_BATT:
  383. power_supply_changed(pchg->charger);
  384. power_supply_changed(pchg->battery);
  385. break;
  386. default:
  387. break;
  388. }
  389. /* report charger dectection event if used */
  390. if (!pdata)
  391. goto irq_handled;
  392. if (pdata->charger_event && id == LP8788_INT_CHG_INPUT_STATE)
  393. schedule_work(&pchg->charger_work);
  394. irq_handled:
  395. return IRQ_HANDLED;
  396. }
  397. static int lp8788_set_irqs(struct platform_device *pdev,
  398. struct lp8788_charger *pchg, const char *name)
  399. {
  400. struct resource *r;
  401. struct irq_domain *irqdm = pchg->lp->irqdm;
  402. int irq_start;
  403. int irq_end;
  404. int virq;
  405. int nr_irq;
  406. int i;
  407. int ret;
  408. /* no error even if no irq resource */
  409. r = platform_get_resource_byname(pdev, IORESOURCE_IRQ, name);
  410. if (!r)
  411. return 0;
  412. irq_start = r->start;
  413. irq_end = r->end;
  414. for (i = irq_start; i <= irq_end; i++) {
  415. nr_irq = pchg->num_irqs;
  416. virq = irq_create_mapping(irqdm, i);
  417. pchg->irqs[nr_irq].virq = virq;
  418. pchg->irqs[nr_irq].which = i;
  419. pchg->num_irqs++;
  420. ret = request_threaded_irq(virq, NULL,
  421. lp8788_charger_irq_thread,
  422. IRQF_ONESHOT, name, pchg);
  423. if (ret)
  424. break;
  425. }
  426. if (i <= irq_end)
  427. goto err_free_irq;
  428. return 0;
  429. err_free_irq:
  430. for (i = 0; i < pchg->num_irqs; i++)
  431. free_irq(pchg->irqs[i].virq, pchg);
  432. return ret;
  433. }
  434. static int lp8788_irq_register(struct platform_device *pdev,
  435. struct lp8788_charger *pchg)
  436. {
  437. const char *name[] = {
  438. LP8788_CHG_IRQ, LP8788_PRSW_IRQ, LP8788_BATT_IRQ
  439. };
  440. int i;
  441. int ret;
  442. INIT_WORK(&pchg->charger_work, lp8788_charger_event);
  443. pchg->num_irqs = 0;
  444. for (i = 0; i < ARRAY_SIZE(name); i++) {
  445. ret = lp8788_set_irqs(pdev, pchg, name[i]);
  446. if (ret) {
  447. dev_warn(&pdev->dev, "irq setup failed: %s\n", name[i]);
  448. return ret;
  449. }
  450. }
  451. if (pchg->num_irqs > LP8788_MAX_CHG_IRQS) {
  452. dev_err(&pdev->dev, "invalid total number of irqs: %d\n",
  453. pchg->num_irqs);
  454. return -EINVAL;
  455. }
  456. return 0;
  457. }
  458. static void lp8788_irq_unregister(struct platform_device *pdev,
  459. struct lp8788_charger *pchg)
  460. {
  461. int i;
  462. int irq;
  463. for (i = 0; i < pchg->num_irqs; i++) {
  464. irq = pchg->irqs[i].virq;
  465. if (!irq)
  466. continue;
  467. free_irq(irq, pchg);
  468. }
  469. }
  470. static void lp8788_setup_adc_channel(struct device *dev,
  471. struct lp8788_charger *pchg)
  472. {
  473. struct lp8788_charger_platform_data *pdata = pchg->pdata;
  474. struct iio_channel *chan;
  475. if (!pdata)
  476. return;
  477. /* ADC channel for battery voltage */
  478. chan = devm_iio_channel_get(dev, pdata->adc_vbatt);
  479. pchg->chan[LP8788_VBATT] = IS_ERR(chan) ? NULL : chan;
  480. /* ADC channel for battery temperature */
  481. chan = devm_iio_channel_get(dev, pdata->adc_batt_temp);
  482. pchg->chan[LP8788_BATT_TEMP] = IS_ERR(chan) ? NULL : chan;
  483. }
  484. static ssize_t lp8788_show_charger_status(struct device *dev,
  485. struct device_attribute *attr, char *buf)
  486. {
  487. struct lp8788_charger *pchg = dev_get_drvdata(dev);
  488. enum lp8788_charging_state state;
  489. static const char * const desc[LP8788_MAX_CHG_STATE] = {
  490. [LP8788_OFF] = "CHARGER OFF",
  491. [LP8788_WARM_UP] = "WARM UP",
  492. [LP8788_LOW_INPUT] = "LOW INPUT STATE",
  493. [LP8788_PRECHARGE] = "CHARGING - PRECHARGE",
  494. [LP8788_CC] = "CHARGING - CC",
  495. [LP8788_CV] = "CHARGING - CV",
  496. [LP8788_MAINTENANCE] = "NO CHARGING - MAINTENANCE",
  497. [LP8788_BATTERY_FAULT] = "BATTERY FAULT",
  498. [LP8788_SYSTEM_SUPPORT] = "SYSTEM SUPPORT",
  499. [LP8788_HIGH_CURRENT] = "HIGH CURRENT",
  500. };
  501. u8 data;
  502. lp8788_read_byte(pchg->lp, LP8788_CHG_STATUS, &data);
  503. state = (data & LP8788_CHG_STATE_M) >> LP8788_CHG_STATE_S;
  504. return scnprintf(buf, PAGE_SIZE, "%s\n", desc[state]);
  505. }
  506. static ssize_t lp8788_show_eoc_time(struct device *dev,
  507. struct device_attribute *attr, char *buf)
  508. {
  509. struct lp8788_charger *pchg = dev_get_drvdata(dev);
  510. static const char * const stime[] = {
  511. "400ms", "5min", "10min", "15min",
  512. "20min", "25min", "30min", "No timeout"
  513. };
  514. u8 val;
  515. lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val);
  516. val = (val & LP8788_CHG_EOC_TIME_M) >> LP8788_CHG_EOC_TIME_S;
  517. return scnprintf(buf, PAGE_SIZE, "End Of Charge Time: %s\n",
  518. stime[val]);
  519. }
  520. static ssize_t lp8788_show_eoc_level(struct device *dev,
  521. struct device_attribute *attr, char *buf)
  522. {
  523. struct lp8788_charger *pchg = dev_get_drvdata(dev);
  524. static const char * const abs_level[] = {
  525. "25mA", "49mA", "75mA", "98mA"
  526. };
  527. static const char * const relative_level[] = {
  528. "5%", "10%", "15%", "20%"
  529. };
  530. const char *level;
  531. u8 val;
  532. u8 mode;
  533. lp8788_read_byte(pchg->lp, LP8788_CHG_EOC, &val);
  534. mode = val & LP8788_CHG_EOC_MODE_M;
  535. val = (val & LP8788_CHG_EOC_LEVEL_M) >> LP8788_CHG_EOC_LEVEL_S;
  536. level = mode ? abs_level[val] : relative_level[val];
  537. return scnprintf(buf, PAGE_SIZE, "End Of Charge Level: %s\n", level);
  538. }
  539. static DEVICE_ATTR(charger_status, S_IRUSR, lp8788_show_charger_status, NULL);
  540. static DEVICE_ATTR(eoc_time, S_IRUSR, lp8788_show_eoc_time, NULL);
  541. static DEVICE_ATTR(eoc_level, S_IRUSR, lp8788_show_eoc_level, NULL);
  542. static struct attribute *lp8788_charger_sysfs_attrs[] = {
  543. &dev_attr_charger_status.attr,
  544. &dev_attr_eoc_time.attr,
  545. &dev_attr_eoc_level.attr,
  546. NULL,
  547. };
  548. ATTRIBUTE_GROUPS(lp8788_charger_sysfs);
  549. static int lp8788_psy_register(struct platform_device *pdev,
  550. struct lp8788_charger *pchg)
  551. {
  552. struct power_supply_config charger_cfg = {};
  553. charger_cfg.attr_grp = lp8788_charger_sysfs_groups;
  554. charger_cfg.supplied_to = battery_supplied_to;
  555. charger_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to);
  556. pchg->charger = power_supply_register(&pdev->dev,
  557. &lp8788_psy_charger_desc,
  558. &charger_cfg);
  559. if (IS_ERR(pchg->charger))
  560. return -EPERM;
  561. pchg->battery = power_supply_register(&pdev->dev,
  562. &lp8788_psy_battery_desc, NULL);
  563. if (IS_ERR(pchg->battery)) {
  564. power_supply_unregister(pchg->charger);
  565. return -EPERM;
  566. }
  567. return 0;
  568. }
  569. static int lp8788_charger_probe(struct platform_device *pdev)
  570. {
  571. struct lp8788 *lp = dev_get_drvdata(pdev->dev.parent);
  572. struct lp8788_charger *pchg;
  573. struct device *dev = &pdev->dev;
  574. int ret;
  575. pchg = devm_kzalloc(dev, sizeof(struct lp8788_charger), GFP_KERNEL);
  576. if (!pchg)
  577. return -ENOMEM;
  578. pchg->lp = lp;
  579. pchg->pdata = lp->pdata ? lp->pdata->chg_pdata : NULL;
  580. platform_set_drvdata(pdev, pchg);
  581. ret = lp8788_update_charger_params(pdev, pchg);
  582. if (ret)
  583. return ret;
  584. lp8788_setup_adc_channel(&pdev->dev, pchg);
  585. ret = lp8788_psy_register(pdev, pchg);
  586. if (ret)
  587. return ret;
  588. ret = lp8788_irq_register(pdev, pchg);
  589. if (ret)
  590. dev_warn(dev, "failed to register charger irq: %d\n", ret);
  591. return 0;
  592. }
  593. static int lp8788_charger_remove(struct platform_device *pdev)
  594. {
  595. struct lp8788_charger *pchg = platform_get_drvdata(pdev);
  596. flush_work(&pchg->charger_work);
  597. lp8788_irq_unregister(pdev, pchg);
  598. lp8788_psy_unregister(pchg);
  599. return 0;
  600. }
  601. static struct platform_driver lp8788_charger_driver = {
  602. .probe = lp8788_charger_probe,
  603. .remove = lp8788_charger_remove,
  604. .driver = {
  605. .name = LP8788_DEV_CHARGER,
  606. },
  607. };
  608. module_platform_driver(lp8788_charger_driver);
  609. MODULE_DESCRIPTION("TI LP8788 Charger Driver");
  610. MODULE_AUTHOR("Milo Kim");
  611. MODULE_LICENSE("GPL");
  612. MODULE_ALIAS("platform:lp8788-charger");