da9150-charger.c 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690
  1. // SPDX-License-Identifier: GPL-2.0-or-later
  2. /*
  3. * DA9150 Charger Driver
  4. *
  5. * Copyright (c) 2014 Dialog Semiconductor
  6. *
  7. * Author: Adam Thomson <Adam.Thomson.Opensource@diasemi.com>
  8. */
  9. #include <linux/kernel.h>
  10. #include <linux/slab.h>
  11. #include <linux/module.h>
  12. #include <linux/platform_device.h>
  13. #include <linux/of.h>
  14. #include <linux/of_platform.h>
  15. #include <linux/interrupt.h>
  16. #include <linux/power_supply.h>
  17. #include <linux/notifier.h>
  18. #include <linux/usb/phy.h>
  19. #include <linux/iio/consumer.h>
  20. #include <linux/mfd/da9150/core.h>
  21. #include <linux/mfd/da9150/registers.h>
  22. /* Private data */
  23. struct da9150_charger {
  24. struct da9150 *da9150;
  25. struct device *dev;
  26. struct power_supply *usb;
  27. struct power_supply *battery;
  28. struct power_supply *supply_online;
  29. struct usb_phy *usb_phy;
  30. struct notifier_block otg_nb;
  31. struct work_struct otg_work;
  32. unsigned long usb_event;
  33. struct iio_channel *ibus_chan;
  34. struct iio_channel *vbus_chan;
  35. struct iio_channel *tjunc_chan;
  36. struct iio_channel *vbat_chan;
  37. };
  38. static inline int da9150_charger_supply_online(struct da9150_charger *charger,
  39. struct power_supply *psy,
  40. union power_supply_propval *val)
  41. {
  42. val->intval = (psy == charger->supply_online) ? 1 : 0;
  43. return 0;
  44. }
  45. /* Charger Properties */
  46. static int da9150_charger_vbus_voltage_now(struct da9150_charger *charger,
  47. union power_supply_propval *val)
  48. {
  49. int v_val, ret;
  50. /* Read processed value - mV units */
  51. ret = iio_read_channel_processed(charger->vbus_chan, &v_val);
  52. if (ret < 0)
  53. return ret;
  54. /* Convert voltage to expected uV units */
  55. val->intval = v_val * 1000;
  56. return 0;
  57. }
  58. static int da9150_charger_ibus_current_avg(struct da9150_charger *charger,
  59. union power_supply_propval *val)
  60. {
  61. int i_val, ret;
  62. /* Read processed value - mA units */
  63. ret = iio_read_channel_processed(charger->ibus_chan, &i_val);
  64. if (ret < 0)
  65. return ret;
  66. /* Convert current to expected uA units */
  67. val->intval = i_val * 1000;
  68. return 0;
  69. }
  70. static int da9150_charger_tjunc_temp(struct da9150_charger *charger,
  71. union power_supply_propval *val)
  72. {
  73. int t_val, ret;
  74. /* Read processed value - 0.001 degrees C units */
  75. ret = iio_read_channel_processed(charger->tjunc_chan, &t_val);
  76. if (ret < 0)
  77. return ret;
  78. /* Convert temp to expect 0.1 degrees C units */
  79. val->intval = t_val / 100;
  80. return 0;
  81. }
  82. static enum power_supply_property da9150_charger_props[] = {
  83. POWER_SUPPLY_PROP_ONLINE,
  84. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  85. POWER_SUPPLY_PROP_CURRENT_AVG,
  86. POWER_SUPPLY_PROP_TEMP,
  87. };
  88. static int da9150_charger_get_prop(struct power_supply *psy,
  89. enum power_supply_property psp,
  90. union power_supply_propval *val)
  91. {
  92. struct da9150_charger *charger = dev_get_drvdata(psy->dev.parent);
  93. int ret;
  94. switch (psp) {
  95. case POWER_SUPPLY_PROP_ONLINE:
  96. ret = da9150_charger_supply_online(charger, psy, val);
  97. break;
  98. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  99. ret = da9150_charger_vbus_voltage_now(charger, val);
  100. break;
  101. case POWER_SUPPLY_PROP_CURRENT_AVG:
  102. ret = da9150_charger_ibus_current_avg(charger, val);
  103. break;
  104. case POWER_SUPPLY_PROP_TEMP:
  105. ret = da9150_charger_tjunc_temp(charger, val);
  106. break;
  107. default:
  108. ret = -EINVAL;
  109. break;
  110. }
  111. return ret;
  112. }
  113. /* Battery Properties */
  114. static int da9150_charger_battery_status(struct da9150_charger *charger,
  115. union power_supply_propval *val)
  116. {
  117. u8 reg;
  118. /* Check to see if battery is discharging */
  119. reg = da9150_reg_read(charger->da9150, DA9150_STATUS_H);
  120. if (((reg & DA9150_VBUS_STAT_MASK) == DA9150_VBUS_STAT_OFF) ||
  121. ((reg & DA9150_VBUS_STAT_MASK) == DA9150_VBUS_STAT_WAIT)) {
  122. val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
  123. return 0;
  124. }
  125. reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
  126. /* Now check for other states */
  127. switch (reg & DA9150_CHG_STAT_MASK) {
  128. case DA9150_CHG_STAT_ACT:
  129. case DA9150_CHG_STAT_PRE:
  130. case DA9150_CHG_STAT_CC:
  131. case DA9150_CHG_STAT_CV:
  132. val->intval = POWER_SUPPLY_STATUS_CHARGING;
  133. break;
  134. case DA9150_CHG_STAT_OFF:
  135. case DA9150_CHG_STAT_SUSP:
  136. case DA9150_CHG_STAT_TEMP:
  137. case DA9150_CHG_STAT_TIME:
  138. case DA9150_CHG_STAT_BAT:
  139. val->intval = POWER_SUPPLY_STATUS_NOT_CHARGING;
  140. break;
  141. case DA9150_CHG_STAT_FULL:
  142. val->intval = POWER_SUPPLY_STATUS_FULL;
  143. break;
  144. default:
  145. val->intval = POWER_SUPPLY_STATUS_UNKNOWN;
  146. break;
  147. }
  148. return 0;
  149. }
  150. static int da9150_charger_battery_health(struct da9150_charger *charger,
  151. union power_supply_propval *val)
  152. {
  153. u8 reg;
  154. reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
  155. /* Check if temperature limit reached */
  156. switch (reg & DA9150_CHG_TEMP_MASK) {
  157. case DA9150_CHG_TEMP_UNDER:
  158. val->intval = POWER_SUPPLY_HEALTH_COLD;
  159. return 0;
  160. case DA9150_CHG_TEMP_OVER:
  161. val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
  162. return 0;
  163. default:
  164. break;
  165. }
  166. /* Check for other health states */
  167. switch (reg & DA9150_CHG_STAT_MASK) {
  168. case DA9150_CHG_STAT_ACT:
  169. case DA9150_CHG_STAT_PRE:
  170. val->intval = POWER_SUPPLY_HEALTH_DEAD;
  171. break;
  172. case DA9150_CHG_STAT_TIME:
  173. val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  174. break;
  175. default:
  176. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  177. break;
  178. }
  179. return 0;
  180. }
  181. static int da9150_charger_battery_present(struct da9150_charger *charger,
  182. union power_supply_propval *val)
  183. {
  184. u8 reg;
  185. /* Check if battery present or removed */
  186. reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
  187. if ((reg & DA9150_CHG_STAT_MASK) == DA9150_CHG_STAT_BAT)
  188. val->intval = 0;
  189. else
  190. val->intval = 1;
  191. return 0;
  192. }
  193. static int da9150_charger_battery_charge_type(struct da9150_charger *charger,
  194. union power_supply_propval *val)
  195. {
  196. u8 reg;
  197. reg = da9150_reg_read(charger->da9150, DA9150_STATUS_J);
  198. switch (reg & DA9150_CHG_STAT_MASK) {
  199. case DA9150_CHG_STAT_CC:
  200. val->intval = POWER_SUPPLY_CHARGE_TYPE_FAST;
  201. break;
  202. case DA9150_CHG_STAT_ACT:
  203. case DA9150_CHG_STAT_PRE:
  204. case DA9150_CHG_STAT_CV:
  205. val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE;
  206. break;
  207. default:
  208. val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE;
  209. break;
  210. }
  211. return 0;
  212. }
  213. static int da9150_charger_battery_voltage_min(struct da9150_charger *charger,
  214. union power_supply_propval *val)
  215. {
  216. u8 reg;
  217. reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_C);
  218. /* Value starts at 2500 mV, 50 mV increments, presented in uV */
  219. val->intval = ((reg & DA9150_CHG_VFAULT_MASK) * 50000) + 2500000;
  220. return 0;
  221. }
  222. static int da9150_charger_battery_voltage_now(struct da9150_charger *charger,
  223. union power_supply_propval *val)
  224. {
  225. int v_val, ret;
  226. /* Read processed value - mV units */
  227. ret = iio_read_channel_processed(charger->vbat_chan, &v_val);
  228. if (ret < 0)
  229. return ret;
  230. val->intval = v_val * 1000;
  231. return 0;
  232. }
  233. static int da9150_charger_battery_current_max(struct da9150_charger *charger,
  234. union power_supply_propval *val)
  235. {
  236. int reg;
  237. reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_D);
  238. /* 25mA increments */
  239. val->intval = reg * 25000;
  240. return 0;
  241. }
  242. static int da9150_charger_battery_voltage_max(struct da9150_charger *charger,
  243. union power_supply_propval *val)
  244. {
  245. u8 reg;
  246. reg = da9150_reg_read(charger->da9150, DA9150_PPR_CHGCTRL_B);
  247. /* Value starts at 3650 mV, 25 mV increments, presented in uV */
  248. val->intval = ((reg & DA9150_CHG_VBAT_MASK) * 25000) + 3650000;
  249. return 0;
  250. }
  251. static enum power_supply_property da9150_charger_bat_props[] = {
  252. POWER_SUPPLY_PROP_STATUS,
  253. POWER_SUPPLY_PROP_ONLINE,
  254. POWER_SUPPLY_PROP_HEALTH,
  255. POWER_SUPPLY_PROP_PRESENT,
  256. POWER_SUPPLY_PROP_CHARGE_TYPE,
  257. POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
  258. POWER_SUPPLY_PROP_VOLTAGE_NOW,
  259. POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
  260. POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
  261. };
  262. static int da9150_charger_battery_get_prop(struct power_supply *psy,
  263. enum power_supply_property psp,
  264. union power_supply_propval *val)
  265. {
  266. struct da9150_charger *charger = dev_get_drvdata(psy->dev.parent);
  267. int ret;
  268. switch (psp) {
  269. case POWER_SUPPLY_PROP_STATUS:
  270. ret = da9150_charger_battery_status(charger, val);
  271. break;
  272. case POWER_SUPPLY_PROP_ONLINE:
  273. ret = da9150_charger_supply_online(charger, psy, val);
  274. break;
  275. case POWER_SUPPLY_PROP_HEALTH:
  276. ret = da9150_charger_battery_health(charger, val);
  277. break;
  278. case POWER_SUPPLY_PROP_PRESENT:
  279. ret = da9150_charger_battery_present(charger, val);
  280. break;
  281. case POWER_SUPPLY_PROP_CHARGE_TYPE:
  282. ret = da9150_charger_battery_charge_type(charger, val);
  283. break;
  284. case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
  285. ret = da9150_charger_battery_voltage_min(charger, val);
  286. break;
  287. case POWER_SUPPLY_PROP_VOLTAGE_NOW:
  288. ret = da9150_charger_battery_voltage_now(charger, val);
  289. break;
  290. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
  291. ret = da9150_charger_battery_current_max(charger, val);
  292. break;
  293. case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
  294. ret = da9150_charger_battery_voltage_max(charger, val);
  295. break;
  296. default:
  297. ret = -EINVAL;
  298. break;
  299. }
  300. return ret;
  301. }
  302. static irqreturn_t da9150_charger_chg_irq(int irq, void *data)
  303. {
  304. struct da9150_charger *charger = data;
  305. power_supply_changed(charger->battery);
  306. return IRQ_HANDLED;
  307. }
  308. static irqreturn_t da9150_charger_tjunc_irq(int irq, void *data)
  309. {
  310. struct da9150_charger *charger = data;
  311. /* Nothing we can really do except report this. */
  312. dev_crit(charger->dev, "TJunc over temperature!!!\n");
  313. power_supply_changed(charger->usb);
  314. return IRQ_HANDLED;
  315. }
  316. static irqreturn_t da9150_charger_vfault_irq(int irq, void *data)
  317. {
  318. struct da9150_charger *charger = data;
  319. /* Nothing we can really do except report this. */
  320. dev_crit(charger->dev, "VSYS under voltage!!!\n");
  321. power_supply_changed(charger->usb);
  322. power_supply_changed(charger->battery);
  323. return IRQ_HANDLED;
  324. }
  325. static irqreturn_t da9150_charger_vbus_irq(int irq, void *data)
  326. {
  327. struct da9150_charger *charger = data;
  328. u8 reg;
  329. reg = da9150_reg_read(charger->da9150, DA9150_STATUS_H);
  330. /* Charger plugged in or battery only */
  331. switch (reg & DA9150_VBUS_STAT_MASK) {
  332. case DA9150_VBUS_STAT_OFF:
  333. case DA9150_VBUS_STAT_WAIT:
  334. charger->supply_online = charger->battery;
  335. break;
  336. case DA9150_VBUS_STAT_CHG:
  337. charger->supply_online = charger->usb;
  338. break;
  339. default:
  340. dev_warn(charger->dev, "Unknown VBUS state - reg = 0x%x\n",
  341. reg);
  342. charger->supply_online = NULL;
  343. break;
  344. }
  345. power_supply_changed(charger->usb);
  346. power_supply_changed(charger->battery);
  347. return IRQ_HANDLED;
  348. }
  349. static void da9150_charger_otg_work(struct work_struct *data)
  350. {
  351. struct da9150_charger *charger =
  352. container_of(data, struct da9150_charger, otg_work);
  353. switch (charger->usb_event) {
  354. case USB_EVENT_ID:
  355. /* Enable OTG Boost */
  356. da9150_set_bits(charger->da9150, DA9150_PPR_BKCTRL_A,
  357. DA9150_VBUS_MODE_MASK, DA9150_VBUS_MODE_OTG);
  358. break;
  359. case USB_EVENT_NONE:
  360. /* Revert to charge mode */
  361. power_supply_changed(charger->usb);
  362. power_supply_changed(charger->battery);
  363. da9150_set_bits(charger->da9150, DA9150_PPR_BKCTRL_A,
  364. DA9150_VBUS_MODE_MASK, DA9150_VBUS_MODE_CHG);
  365. break;
  366. }
  367. }
  368. static int da9150_charger_otg_ncb(struct notifier_block *nb, unsigned long val,
  369. void *priv)
  370. {
  371. struct da9150_charger *charger =
  372. container_of(nb, struct da9150_charger, otg_nb);
  373. dev_dbg(charger->dev, "DA9150 OTG notify %lu\n", val);
  374. charger->usb_event = val;
  375. schedule_work(&charger->otg_work);
  376. return NOTIFY_OK;
  377. }
  378. static int da9150_charger_register_irq(struct platform_device *pdev,
  379. irq_handler_t handler,
  380. const char *irq_name)
  381. {
  382. struct device *dev = &pdev->dev;
  383. struct da9150_charger *charger = platform_get_drvdata(pdev);
  384. int irq, ret;
  385. irq = platform_get_irq_byname(pdev, irq_name);
  386. if (irq < 0) {
  387. dev_err(dev, "Failed to get IRQ CHG_STATUS: %d\n", irq);
  388. return irq;
  389. }
  390. ret = request_threaded_irq(irq, NULL, handler, IRQF_ONESHOT, irq_name,
  391. charger);
  392. if (ret)
  393. dev_err(dev, "Failed to request IRQ %d: %d\n", irq, ret);
  394. return ret;
  395. }
  396. static void da9150_charger_unregister_irq(struct platform_device *pdev,
  397. const char *irq_name)
  398. {
  399. struct device *dev = &pdev->dev;
  400. struct da9150_charger *charger = platform_get_drvdata(pdev);
  401. int irq;
  402. irq = platform_get_irq_byname(pdev, irq_name);
  403. if (irq < 0) {
  404. dev_err(dev, "Failed to get IRQ CHG_STATUS: %d\n", irq);
  405. return;
  406. }
  407. free_irq(irq, charger);
  408. }
  409. static const struct power_supply_desc usb_desc = {
  410. .name = "da9150-usb",
  411. .type = POWER_SUPPLY_TYPE_USB,
  412. .properties = da9150_charger_props,
  413. .num_properties = ARRAY_SIZE(da9150_charger_props),
  414. .get_property = da9150_charger_get_prop,
  415. };
  416. static const struct power_supply_desc battery_desc = {
  417. .name = "da9150-battery",
  418. .type = POWER_SUPPLY_TYPE_BATTERY,
  419. .properties = da9150_charger_bat_props,
  420. .num_properties = ARRAY_SIZE(da9150_charger_bat_props),
  421. .get_property = da9150_charger_battery_get_prop,
  422. };
  423. static int da9150_charger_probe(struct platform_device *pdev)
  424. {
  425. struct device *dev = &pdev->dev;
  426. struct da9150 *da9150 = dev_get_drvdata(dev->parent);
  427. struct da9150_charger *charger;
  428. u8 reg;
  429. int ret;
  430. charger = devm_kzalloc(dev, sizeof(struct da9150_charger), GFP_KERNEL);
  431. if (!charger)
  432. return -ENOMEM;
  433. platform_set_drvdata(pdev, charger);
  434. charger->da9150 = da9150;
  435. charger->dev = dev;
  436. /* Acquire ADC channels */
  437. charger->ibus_chan = iio_channel_get(dev, "CHAN_IBUS");
  438. if (IS_ERR(charger->ibus_chan)) {
  439. ret = PTR_ERR(charger->ibus_chan);
  440. goto ibus_chan_fail;
  441. }
  442. charger->vbus_chan = iio_channel_get(dev, "CHAN_VBUS");
  443. if (IS_ERR(charger->vbus_chan)) {
  444. ret = PTR_ERR(charger->vbus_chan);
  445. goto vbus_chan_fail;
  446. }
  447. charger->tjunc_chan = iio_channel_get(dev, "CHAN_TJUNC");
  448. if (IS_ERR(charger->tjunc_chan)) {
  449. ret = PTR_ERR(charger->tjunc_chan);
  450. goto tjunc_chan_fail;
  451. }
  452. charger->vbat_chan = iio_channel_get(dev, "CHAN_VBAT");
  453. if (IS_ERR(charger->vbat_chan)) {
  454. ret = PTR_ERR(charger->vbat_chan);
  455. goto vbat_chan_fail;
  456. }
  457. /* Register power supplies */
  458. charger->usb = power_supply_register(dev, &usb_desc, NULL);
  459. if (IS_ERR(charger->usb)) {
  460. ret = PTR_ERR(charger->usb);
  461. goto usb_fail;
  462. }
  463. charger->battery = power_supply_register(dev, &battery_desc, NULL);
  464. if (IS_ERR(charger->battery)) {
  465. ret = PTR_ERR(charger->battery);
  466. goto battery_fail;
  467. }
  468. /* Get initial online supply */
  469. reg = da9150_reg_read(da9150, DA9150_STATUS_H);
  470. switch (reg & DA9150_VBUS_STAT_MASK) {
  471. case DA9150_VBUS_STAT_OFF:
  472. case DA9150_VBUS_STAT_WAIT:
  473. charger->supply_online = charger->battery;
  474. break;
  475. case DA9150_VBUS_STAT_CHG:
  476. charger->supply_online = charger->usb;
  477. break;
  478. default:
  479. dev_warn(dev, "Unknown VBUS state - reg = 0x%x\n", reg);
  480. charger->supply_online = NULL;
  481. break;
  482. }
  483. /* Setup OTG reporting & configuration */
  484. charger->usb_phy = devm_usb_get_phy(dev, USB_PHY_TYPE_USB2);
  485. if (!IS_ERR_OR_NULL(charger->usb_phy)) {
  486. INIT_WORK(&charger->otg_work, da9150_charger_otg_work);
  487. charger->otg_nb.notifier_call = da9150_charger_otg_ncb;
  488. usb_register_notifier(charger->usb_phy, &charger->otg_nb);
  489. }
  490. /* Register IRQs */
  491. ret = da9150_charger_register_irq(pdev, da9150_charger_chg_irq,
  492. "CHG_STATUS");
  493. if (ret < 0)
  494. goto chg_irq_fail;
  495. ret = da9150_charger_register_irq(pdev, da9150_charger_tjunc_irq,
  496. "CHG_TJUNC");
  497. if (ret < 0)
  498. goto tjunc_irq_fail;
  499. ret = da9150_charger_register_irq(pdev, da9150_charger_vfault_irq,
  500. "CHG_VFAULT");
  501. if (ret < 0)
  502. goto vfault_irq_fail;
  503. ret = da9150_charger_register_irq(pdev, da9150_charger_vbus_irq,
  504. "CHG_VBUS");
  505. if (ret < 0)
  506. goto vbus_irq_fail;
  507. return 0;
  508. vbus_irq_fail:
  509. da9150_charger_unregister_irq(pdev, "CHG_VFAULT");
  510. vfault_irq_fail:
  511. da9150_charger_unregister_irq(pdev, "CHG_TJUNC");
  512. tjunc_irq_fail:
  513. da9150_charger_unregister_irq(pdev, "CHG_STATUS");
  514. chg_irq_fail:
  515. if (!IS_ERR_OR_NULL(charger->usb_phy))
  516. usb_unregister_notifier(charger->usb_phy, &charger->otg_nb);
  517. battery_fail:
  518. power_supply_unregister(charger->usb);
  519. usb_fail:
  520. iio_channel_release(charger->vbat_chan);
  521. vbat_chan_fail:
  522. iio_channel_release(charger->tjunc_chan);
  523. tjunc_chan_fail:
  524. iio_channel_release(charger->vbus_chan);
  525. vbus_chan_fail:
  526. iio_channel_release(charger->ibus_chan);
  527. ibus_chan_fail:
  528. return ret;
  529. }
  530. static int da9150_charger_remove(struct platform_device *pdev)
  531. {
  532. struct da9150_charger *charger = platform_get_drvdata(pdev);
  533. int irq;
  534. /* Make sure IRQs are released before unregistering power supplies */
  535. irq = platform_get_irq_byname(pdev, "CHG_VBUS");
  536. free_irq(irq, charger);
  537. irq = platform_get_irq_byname(pdev, "CHG_VFAULT");
  538. free_irq(irq, charger);
  539. irq = platform_get_irq_byname(pdev, "CHG_TJUNC");
  540. free_irq(irq, charger);
  541. irq = platform_get_irq_byname(pdev, "CHG_STATUS");
  542. free_irq(irq, charger);
  543. if (!IS_ERR_OR_NULL(charger->usb_phy))
  544. usb_unregister_notifier(charger->usb_phy, &charger->otg_nb);
  545. power_supply_unregister(charger->battery);
  546. power_supply_unregister(charger->usb);
  547. /* Release ADC channels */
  548. iio_channel_release(charger->ibus_chan);
  549. iio_channel_release(charger->vbus_chan);
  550. iio_channel_release(charger->tjunc_chan);
  551. iio_channel_release(charger->vbat_chan);
  552. return 0;
  553. }
  554. static struct platform_driver da9150_charger_driver = {
  555. .driver = {
  556. .name = "da9150-charger",
  557. },
  558. .probe = da9150_charger_probe,
  559. .remove = da9150_charger_remove,
  560. };
  561. module_platform_driver(da9150_charger_driver);
  562. MODULE_DESCRIPTION("Charger Driver for DA9150");
  563. MODULE_AUTHOR("Adam Thomson <Adam.Thomson.Opensource@diasemi.com>");
  564. MODULE_LICENSE("GPL");