lp8727_charger.c 14 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Driver for LP8727 Micro/Mini USB IC with integrated charger
  4. *
  5. * Copyright (C) 2011 Texas Instruments
  6. * Copyright (C) 2011 National Semiconductor
  7. */
  8. #include <linux/module.h>
  9. #include <linux/slab.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/i2c.h>
  12. #include <linux/power_supply.h>
  13. #include <linux/platform_data/lp8727.h>
  14. #include <linux/of.h>
  15. #define LP8788_NUM_INTREGS 2
  16. #define DEFAULT_DEBOUNCE_MSEC 270
  17. /* Registers */
  18. #define LP8727_CTRL1 0x1
  19. #define LP8727_CTRL2 0x2
  20. #define LP8727_SWCTRL 0x3
  21. #define LP8727_INT1 0x4
  22. #define LP8727_INT2 0x5
  23. #define LP8727_STATUS1 0x6
  24. #define LP8727_STATUS2 0x7
  25. #define LP8727_CHGCTRL2 0x9
  26. /* CTRL1 register */
  27. #define LP8727_CP_EN BIT(0)
  28. #define LP8727_ADC_EN BIT(1)
  29. #define LP8727_ID200_EN BIT(4)
  30. /* CTRL2 register */
  31. #define LP8727_CHGDET_EN BIT(1)
  32. #define LP8727_INT_EN BIT(6)
  33. /* SWCTRL register */
  34. #define LP8727_SW_DM1_DM (0x0 << 0)
  35. #define LP8727_SW_DM1_HiZ (0x7 << 0)
  36. #define LP8727_SW_DP2_DP (0x0 << 3)
  37. #define LP8727_SW_DP2_HiZ (0x7 << 3)
  38. /* INT1 register */
  39. #define LP8727_IDNO (0xF << 0)
  40. #define LP8727_VBUS BIT(4)
  41. /* STATUS1 register */
  42. #define LP8727_CHGSTAT (3 << 4)
  43. #define LP8727_CHPORT BIT(6)
  44. #define LP8727_DCPORT BIT(7)
  45. #define LP8727_STAT_EOC 0x30
  46. /* STATUS2 register */
  47. #define LP8727_TEMP_STAT (3 << 5)
  48. #define LP8727_TEMP_SHIFT 5
  49. /* CHGCTRL2 register */
  50. #define LP8727_ICHG_SHIFT 4
  51. enum lp8727_dev_id {
  52. LP8727_ID_NONE,
  53. LP8727_ID_TA,
  54. LP8727_ID_DEDICATED_CHG,
  55. LP8727_ID_USB_CHG,
  56. LP8727_ID_USB_DS,
  57. LP8727_ID_MAX,
  58. };
  59. enum lp8727_die_temp {
  60. LP8788_TEMP_75C,
  61. LP8788_TEMP_95C,
  62. LP8788_TEMP_115C,
  63. LP8788_TEMP_135C,
  64. };
  65. struct lp8727_psy {
  66. struct power_supply *ac;
  67. struct power_supply *usb;
  68. struct power_supply *batt;
  69. };
  70. struct lp8727_chg {
  71. struct device *dev;
  72. struct i2c_client *client;
  73. struct mutex xfer_lock;
  74. struct lp8727_psy *psy;
  75. struct lp8727_platform_data *pdata;
  76. /* Charger Data */
  77. enum lp8727_dev_id devid;
  78. struct lp8727_chg_param *chg_param;
  79. /* Interrupt Handling */
  80. int irq;
  81. struct delayed_work work;
  82. unsigned long debounce_jiffies;
  83. };
  84. static int lp8727_read_bytes(struct lp8727_chg *pchg, u8 reg, u8 *data, u8 len)
  85. {
  86. s32 ret;
  87. mutex_lock(&pchg->xfer_lock);
  88. ret = i2c_smbus_read_i2c_block_data(pchg->client, reg, len, data);
  89. mutex_unlock(&pchg->xfer_lock);
  90. return (ret != len) ? -EIO : 0;
  91. }
  92. static inline int lp8727_read_byte(struct lp8727_chg *pchg, u8 reg, u8 *data)
  93. {
  94. return lp8727_read_bytes(pchg, reg, data, 1);
  95. }
  96. static int lp8727_write_byte(struct lp8727_chg *pchg, u8 reg, u8 data)
  97. {
  98. int ret;
  99. mutex_lock(&pchg->xfer_lock);
  100. ret = i2c_smbus_write_byte_data(pchg->client, reg, data);
  101. mutex_unlock(&pchg->xfer_lock);
  102. return ret;
  103. }
  104. static bool lp8727_is_charger_attached(const char *name, int id)
  105. {
  106. if (!strcmp(name, "ac"))
  107. return id == LP8727_ID_TA || id == LP8727_ID_DEDICATED_CHG;
  108. else if (!strcmp(name, "usb"))
  109. return id == LP8727_ID_USB_CHG;
  110. return id >= LP8727_ID_TA && id <= LP8727_ID_USB_CHG;
  111. }
  112. static int lp8727_init_device(struct lp8727_chg *pchg)
  113. {
  114. u8 val;
  115. int ret;
  116. u8 intstat[LP8788_NUM_INTREGS];
  117. /* clear interrupts */
  118. ret = lp8727_read_bytes(pchg, LP8727_INT1, intstat, LP8788_NUM_INTREGS);
  119. if (ret)
  120. return ret;
  121. val = LP8727_ID200_EN | LP8727_ADC_EN | LP8727_CP_EN;
  122. ret = lp8727_write_byte(pchg, LP8727_CTRL1, val);
  123. if (ret)
  124. return ret;
  125. val = LP8727_INT_EN | LP8727_CHGDET_EN;
  126. return lp8727_write_byte(pchg, LP8727_CTRL2, val);
  127. }
  128. static int lp8727_is_dedicated_charger(struct lp8727_chg *pchg)
  129. {
  130. u8 val;
  131. lp8727_read_byte(pchg, LP8727_STATUS1, &val);
  132. return val & LP8727_DCPORT;
  133. }
  134. static int lp8727_is_usb_charger(struct lp8727_chg *pchg)
  135. {
  136. u8 val;
  137. lp8727_read_byte(pchg, LP8727_STATUS1, &val);
  138. return val & LP8727_CHPORT;
  139. }
  140. static inline void lp8727_ctrl_switch(struct lp8727_chg *pchg, u8 sw)
  141. {
  142. lp8727_write_byte(pchg, LP8727_SWCTRL, sw);
  143. }
  144. static void lp8727_id_detection(struct lp8727_chg *pchg, u8 id, int vbusin)
  145. {
  146. struct lp8727_platform_data *pdata = pchg->pdata;
  147. u8 devid = LP8727_ID_NONE;
  148. u8 swctrl = LP8727_SW_DM1_HiZ | LP8727_SW_DP2_HiZ;
  149. switch (id) {
  150. case 0x5:
  151. devid = LP8727_ID_TA;
  152. pchg->chg_param = pdata ? pdata->ac : NULL;
  153. break;
  154. case 0xB:
  155. if (lp8727_is_dedicated_charger(pchg)) {
  156. pchg->chg_param = pdata ? pdata->ac : NULL;
  157. devid = LP8727_ID_DEDICATED_CHG;
  158. } else if (lp8727_is_usb_charger(pchg)) {
  159. pchg->chg_param = pdata ? pdata->usb : NULL;
  160. devid = LP8727_ID_USB_CHG;
  161. swctrl = LP8727_SW_DM1_DM | LP8727_SW_DP2_DP;
  162. } else if (vbusin) {
  163. devid = LP8727_ID_USB_DS;
  164. swctrl = LP8727_SW_DM1_DM | LP8727_SW_DP2_DP;
  165. }
  166. break;
  167. default:
  168. devid = LP8727_ID_NONE;
  169. pchg->chg_param = NULL;
  170. break;
  171. }
  172. pchg->devid = devid;
  173. lp8727_ctrl_switch(pchg, swctrl);
  174. }
  175. static void lp8727_enable_chgdet(struct lp8727_chg *pchg)
  176. {
  177. u8 val;
  178. lp8727_read_byte(pchg, LP8727_CTRL2, &val);
  179. val |= LP8727_CHGDET_EN;
  180. lp8727_write_byte(pchg, LP8727_CTRL2, val);
  181. }
  182. static void lp8727_delayed_func(struct work_struct *_work)
  183. {
  184. struct lp8727_chg *pchg = container_of(_work, struct lp8727_chg,
  185. work.work);
  186. u8 intstat[LP8788_NUM_INTREGS];
  187. u8 idno;
  188. u8 vbus;
  189. if (lp8727_read_bytes(pchg, LP8727_INT1, intstat, LP8788_NUM_INTREGS)) {
  190. dev_err(pchg->dev, "can not read INT registers\n");
  191. return;
  192. }
  193. idno = intstat[0] & LP8727_IDNO;
  194. vbus = intstat[0] & LP8727_VBUS;
  195. lp8727_id_detection(pchg, idno, vbus);
  196. lp8727_enable_chgdet(pchg);
  197. power_supply_changed(pchg->psy->ac);
  198. power_supply_changed(pchg->psy->usb);
  199. power_supply_changed(pchg->psy->batt);
  200. }
  201. static irqreturn_t lp8727_isr_func(int irq, void *ptr)
  202. {
  203. struct lp8727_chg *pchg = ptr;
  204. schedule_delayed_work(&pchg->work, pchg->debounce_jiffies);
  205. return IRQ_HANDLED;
  206. }
  207. static int lp8727_setup_irq(struct lp8727_chg *pchg)
  208. {
  209. int ret;
  210. int irq = pchg->client->irq;
  211. unsigned delay_msec = pchg->pdata ? pchg->pdata->debounce_msec :
  212. DEFAULT_DEBOUNCE_MSEC;
  213. INIT_DELAYED_WORK(&pchg->work, lp8727_delayed_func);
  214. if (irq <= 0) {
  215. dev_warn(pchg->dev, "invalid irq number: %d\n", irq);
  216. return 0;
  217. }
  218. ret = request_threaded_irq(irq, NULL, lp8727_isr_func,
  219. IRQF_TRIGGER_FALLING | IRQF_ONESHOT,
  220. "lp8727_irq", pchg);
  221. if (ret)
  222. return ret;
  223. pchg->irq = irq;
  224. pchg->debounce_jiffies = msecs_to_jiffies(delay_msec);
  225. return 0;
  226. }
  227. static void lp8727_release_irq(struct lp8727_chg *pchg)
  228. {
  229. cancel_delayed_work_sync(&pchg->work);
  230. if (pchg->irq)
  231. free_irq(pchg->irq, pchg);
  232. }
  233. static enum power_supply_property lp8727_charger_prop[] = {
  234. POWER_SUPPLY_PROP_ONLINE,
  235. };
  236. static enum power_supply_property lp8727_battery_prop[] = {
  237. POWER_SUPPLY_PROP_STATUS,
  238. POWER_SUPPLY_PROP_HEALTH,
  239. POWER_SUPPLY_PROP_PRESENT,
  240. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  241. POWER_SUPPLY_PROP_CAPACITY,
  242. POWER_SUPPLY_PROP_TEMP,
  243. };
  244. static char *battery_supplied_to[] = {
  245. "main_batt",
  246. };
  247. static int lp8727_charger_get_property(struct power_supply *psy,
  248. enum power_supply_property psp,
  249. union power_supply_propval *val)
  250. {
  251. struct lp8727_chg *pchg = dev_get_drvdata(psy->dev.parent);
  252. if (psp != POWER_SUPPLY_PROP_ONLINE)
  253. return -EINVAL;
  254. val->intval = lp8727_is_charger_attached(psy->desc->name, pchg->devid);
  255. return 0;
  256. }
  257. static bool lp8727_is_high_temperature(enum lp8727_die_temp temp)
  258. {
  259. switch (temp) {
  260. case LP8788_TEMP_95C:
  261. case LP8788_TEMP_115C:
  262. case LP8788_TEMP_135C:
  263. return true;
  264. default:
  265. return false;
  266. }
  267. }
  268. static int lp8727_battery_get_property(struct power_supply *psy,
  269. enum power_supply_property psp,
  270. union power_supply_propval *val)
  271. {
  272. struct lp8727_chg *pchg = dev_get_drvdata(psy->dev.parent);
  273. struct lp8727_platform_data *pdata = pchg->pdata;
  274. enum lp8727_die_temp temp;
  275. u8 read;
  276. switch (psp) {
  277. case POWER_SUPPLY_PROP_STATUS:
  278. if (!lp8727_is_charger_attached(psy->desc->name, pchg->devid)) {
  279. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  280. return 0;
  281. }
  282. lp8727_read_byte(pchg, LP8727_STATUS1, &read);
  283. val->intval = (read & LP8727_CHGSTAT) == LP8727_STAT_EOC ?
  284. POWER_SUPPLY_STATUS_FULL :
  285. POWER_SUPPLY_STATUS_CHARGING;
  286. break;
  287. case POWER_SUPPLY_PROP_HEALTH:
  288. lp8727_read_byte(pchg, LP8727_STATUS2, &read);
  289. temp = (read & LP8727_TEMP_STAT) >> LP8727_TEMP_SHIFT;
  290. val->intval = lp8727_is_high_temperature(temp) ?
  291. POWER_SUPPLY_HEALTH_OVERHEAT :
  292. POWER_SUPPLY_HEALTH_GOOD;
  293. break;
  294. case POWER_SUPPLY_PROP_PRESENT:
  295. if (!pdata)
  296. return -EINVAL;
  297. if (pdata->get_batt_present)
  298. val->intval = pdata->get_batt_present();
  299. break;
  300. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  301. if (!pdata)
  302. return -EINVAL;
  303. if (pdata->get_batt_level)
  304. val->intval = pdata->get_batt_level();
  305. break;
  306. case POWER_SUPPLY_PROP_CAPACITY:
  307. if (!pdata)
  308. return -EINVAL;
  309. if (pdata->get_batt_capacity)
  310. val->intval = pdata->get_batt_capacity();
  311. break;
  312. case POWER_SUPPLY_PROP_TEMP:
  313. if (!pdata)
  314. return -EINVAL;
  315. if (pdata->get_batt_temp)
  316. val->intval = pdata->get_batt_temp();
  317. break;
  318. default:
  319. break;
  320. }
  321. return 0;
  322. }
  323. static void lp8727_charger_changed(struct power_supply *psy)
  324. {
  325. struct lp8727_chg *pchg = dev_get_drvdata(psy->dev.parent);
  326. u8 eoc_level;
  327. u8 ichg;
  328. u8 val;
  329. /* skip if no charger exists */
  330. if (!lp8727_is_charger_attached(psy->desc->name, pchg->devid))
  331. return;
  332. /* update charging parameters */
  333. if (pchg->chg_param) {
  334. eoc_level = pchg->chg_param->eoc_level;
  335. ichg = pchg->chg_param->ichg;
  336. val = (ichg << LP8727_ICHG_SHIFT) | eoc_level;
  337. lp8727_write_byte(pchg, LP8727_CHGCTRL2, val);
  338. }
  339. }
  340. static const struct power_supply_desc lp8727_ac_desc = {
  341. .name = "ac",
  342. .type = POWER_SUPPLY_TYPE_MAINS,
  343. .properties = lp8727_charger_prop,
  344. .num_properties = ARRAY_SIZE(lp8727_charger_prop),
  345. .get_property = lp8727_charger_get_property,
  346. };
  347. static const struct power_supply_desc lp8727_usb_desc = {
  348. .name = "usb",
  349. .type = POWER_SUPPLY_TYPE_USB,
  350. .properties = lp8727_charger_prop,
  351. .num_properties = ARRAY_SIZE(lp8727_charger_prop),
  352. .get_property = lp8727_charger_get_property,
  353. };
  354. static const struct power_supply_desc lp8727_batt_desc = {
  355. .name = "main_batt",
  356. .type = POWER_SUPPLY_TYPE_BATTERY,
  357. .properties = lp8727_battery_prop,
  358. .num_properties = ARRAY_SIZE(lp8727_battery_prop),
  359. .get_property = lp8727_battery_get_property,
  360. .external_power_changed = lp8727_charger_changed,
  361. };
  362. static int lp8727_register_psy(struct lp8727_chg *pchg)
  363. {
  364. struct power_supply_config psy_cfg = {}; /* Only for ac and usb */
  365. struct lp8727_psy *psy;
  366. psy = devm_kzalloc(pchg->dev, sizeof(*psy), GFP_KERNEL);
  367. if (!psy)
  368. return -ENOMEM;
  369. pchg->psy = psy;
  370. psy_cfg.supplied_to = battery_supplied_to;
  371. psy_cfg.num_supplicants = ARRAY_SIZE(battery_supplied_to);
  372. psy->ac = power_supply_register(pchg->dev, &lp8727_ac_desc, &psy_cfg);
  373. if (IS_ERR(psy->ac))
  374. goto err_psy_ac;
  375. psy->usb = power_supply_register(pchg->dev, &lp8727_usb_desc,
  376. &psy_cfg);
  377. if (IS_ERR(psy->usb))
  378. goto err_psy_usb;
  379. psy->batt = power_supply_register(pchg->dev, &lp8727_batt_desc, NULL);
  380. if (IS_ERR(psy->batt))
  381. goto err_psy_batt;
  382. return 0;
  383. err_psy_batt:
  384. power_supply_unregister(psy->usb);
  385. err_psy_usb:
  386. power_supply_unregister(psy->ac);
  387. err_psy_ac:
  388. return -EPERM;
  389. }
  390. static void lp8727_unregister_psy(struct lp8727_chg *pchg)
  391. {
  392. struct lp8727_psy *psy = pchg->psy;
  393. if (!psy)
  394. return;
  395. power_supply_unregister(psy->ac);
  396. power_supply_unregister(psy->usb);
  397. power_supply_unregister(psy->batt);
  398. }
  399. #ifdef CONFIG_OF
  400. static struct lp8727_chg_param
  401. *lp8727_parse_charge_pdata(struct device *dev, struct device_node *np)
  402. {
  403. struct lp8727_chg_param *param;
  404. param = devm_kzalloc(dev, sizeof(*param), GFP_KERNEL);
  405. if (!param)
  406. goto out;
  407. of_property_read_u8(np, "eoc-level", (u8 *)&param->eoc_level);
  408. of_property_read_u8(np, "charging-current", (u8 *)&param->ichg);
  409. out:
  410. return param;
  411. }
  412. static struct lp8727_platform_data *lp8727_parse_dt(struct device *dev)
  413. {
  414. struct device_node *np = dev->of_node;
  415. struct device_node *child;
  416. struct lp8727_platform_data *pdata;
  417. const char *type;
  418. pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
  419. if (!pdata)
  420. return ERR_PTR(-ENOMEM);
  421. of_property_read_u32(np, "debounce-ms", &pdata->debounce_msec);
  422. /* If charging parameter is not defined, just skip parsing the dt */
  423. if (of_get_child_count(np) == 0)
  424. return pdata;
  425. for_each_child_of_node(np, child) {
  426. of_property_read_string(child, "charger-type", &type);
  427. if (!strcmp(type, "ac"))
  428. pdata->ac = lp8727_parse_charge_pdata(dev, child);
  429. if (!strcmp(type, "usb"))
  430. pdata->usb = lp8727_parse_charge_pdata(dev, child);
  431. }
  432. return pdata;
  433. }
  434. #else
  435. static struct lp8727_platform_data *lp8727_parse_dt(struct device *dev)
  436. {
  437. return NULL;
  438. }
  439. #endif
  440. static int lp8727_probe(struct i2c_client *cl, const struct i2c_device_id *id)
  441. {
  442. struct lp8727_chg *pchg;
  443. struct lp8727_platform_data *pdata;
  444. int ret;
  445. if (!i2c_check_functionality(cl->adapter, I2C_FUNC_SMBUS_I2C_BLOCK))
  446. return -EIO;
  447. if (cl->dev.of_node) {
  448. pdata = lp8727_parse_dt(&cl->dev);
  449. if (IS_ERR(pdata))
  450. return PTR_ERR(pdata);
  451. } else {
  452. pdata = dev_get_platdata(&cl->dev);
  453. }
  454. pchg = devm_kzalloc(&cl->dev, sizeof(*pchg), GFP_KERNEL);
  455. if (!pchg)
  456. return -ENOMEM;
  457. pchg->client = cl;
  458. pchg->dev = &cl->dev;
  459. pchg->pdata = pdata;
  460. i2c_set_clientdata(cl, pchg);
  461. mutex_init(&pchg->xfer_lock);
  462. ret = lp8727_init_device(pchg);
  463. if (ret) {
  464. dev_err(pchg->dev, "i2c communication err: %d", ret);
  465. return ret;
  466. }
  467. ret = lp8727_register_psy(pchg);
  468. if (ret) {
  469. dev_err(pchg->dev, "power supplies register err: %d", ret);
  470. return ret;
  471. }
  472. ret = lp8727_setup_irq(pchg);
  473. if (ret) {
  474. dev_err(pchg->dev, "irq handler err: %d", ret);
  475. lp8727_unregister_psy(pchg);
  476. return ret;
  477. }
  478. return 0;
  479. }
  480. static int lp8727_remove(struct i2c_client *cl)
  481. {
  482. struct lp8727_chg *pchg = i2c_get_clientdata(cl);
  483. lp8727_release_irq(pchg);
  484. lp8727_unregister_psy(pchg);
  485. return 0;
  486. }
  487. static const struct of_device_id lp8727_dt_ids[] = {
  488. { .compatible = "ti,lp8727", },
  489. { }
  490. };
  491. MODULE_DEVICE_TABLE(of, lp8727_dt_ids);
  492. static const struct i2c_device_id lp8727_ids[] = {
  493. {"lp8727", 0},
  494. { }
  495. };
  496. MODULE_DEVICE_TABLE(i2c, lp8727_ids);
  497. static struct i2c_driver lp8727_driver = {
  498. .driver = {
  499. .name = "lp8727",
  500. .of_match_table = of_match_ptr(lp8727_dt_ids),
  501. },
  502. .probe = lp8727_probe,
  503. .remove = lp8727_remove,
  504. .id_table = lp8727_ids,
  505. };
  506. module_i2c_driver(lp8727_driver);
  507. MODULE_DESCRIPTION("TI/National Semiconductor LP8727 charger driver");
  508. MODULE_AUTHOR("Milo Kim <milo.kim@ti.com>, Daniel Jeong <daniel.jeong@ti.com>");
  509. MODULE_LICENSE("GPL");