pm2301_charger.c 30 KB

12345678910111213141516171819202122232425262728293031323334353637383940414243444546474849505152535455565758596061626364656667686970717273747576777879808182838485868788899091929394959697989910010110210310410510610710810911011111211311411511611711811912012112212312412512612712812913013113213313413513613713813914014114214314414514614714814915015115215315415515615715815916016116216316416516616716816917017117217317417517617717817918018118218318418518618718818919019119219319419519619719819920020120220320420520620720820921021121221321421521621721821922022122222322422522622722822923023123223323423523623723823924024124224324424524624724824925025125225325425525625725825926026126226326426526626726826927027127227327427527627727827928028128228328428528628728828929029129229329429529629729829930030130230330430530630730830931031131231331431531631731831932032132232332432532632732832933033133233333433533633733833934034134234334434534634734834935035135235335435535635735835936036136236336436536636736836937037137237337437537637737837938038138238338438538638738838939039139239339439539639739839940040140240340440540640740840941041141241341441541641741841942042142242342442542642742842943043143243343443543643743843944044144244344444544644744844945045145245345445545645745845946046146246346446546646746846947047147247347447547647747847948048148248348448548648748848949049149249349449549649749849950050150250350450550650750850951051151251351451551651751851952052152252352452552652752852953053153253353453553653753853954054154254354454554654754854955055155255355455555655755855956056156256356456556656756856957057157257357457557657757857958058158258358458558658758858959059159259359459559659759859960060160260360460560660760860961061161261361461561661761861962062162262362462562662762862963063163263363463563663763863964064164264364464564664764864965065165265365465565665765865966066166266366466566666766866967067167267367467567667767867968068168268368468568668768868969069169269369469569669769869970070170270370470570670770870971071171271371471571671771871972072172272372472572672772872973073173273373473573673773873974074174274374474574674774874975075175275375475575675775875976076176276376476576676776876977077177277377477577677777877978078178278378478578678778878979079179279379479579679779879980080180280380480580680780880981081181281381481581681781881982082182282382482582682782882983083183283383483583683783883984084184284384484584684784884985085185285385485585685785885986086186286386486586686786886987087187287387487587687787887988088188288388488588688788888989089189289389489589689789889990090190290390490590690790890991091191291391491591691791891992092192292392492592692792892993093193293393493593693793893994094194294394494594694794894995095195295395495595695795895996096196296396496596696796896997097197297397497597697797897998098198298398498598698798898999099199299399499599699799899910001001100210031004100510061007100810091010101110121013101410151016101710181019102010211022102310241025102610271028102910301031103210331034103510361037103810391040104110421043104410451046104710481049105010511052105310541055105610571058105910601061106210631064106510661067106810691070107110721073107410751076107710781079108010811082108310841085108610871088108910901091109210931094109510961097109810991100110111021103110411051106110711081109111011111112111311141115111611171118111911201121112211231124112511261127112811291130113111321133113411351136113711381139114011411142114311441145114611471148114911501151115211531154115511561157115811591160116111621163116411651166116711681169117011711172117311741175117611771178117911801181118211831184118511861187118811891190119111921193119411951196119711981199120012011202120312041205120612071208120912101211121212131214121512161217121812191220122112221223122412251226122712281229123012311232123312341235123612371238123912401241124212431244124512461247124812491250
  1. // SPDX-License-Identifier: GPL-2.0-only
  2. /*
  3. * Copyright 2012 ST Ericsson.
  4. *
  5. * Power supply driver for ST Ericsson pm2xxx_charger charger
  6. */
  7. #include <linux/init.h>
  8. #include <linux/module.h>
  9. #include <linux/device.h>
  10. #include <linux/interrupt.h>
  11. #include <linux/delay.h>
  12. #include <linux/slab.h>
  13. #include <linux/platform_device.h>
  14. #include <linux/power_supply.h>
  15. #include <linux/regulator/consumer.h>
  16. #include <linux/err.h>
  17. #include <linux/i2c.h>
  18. #include <linux/workqueue.h>
  19. #include <linux/mfd/abx500/ab8500.h>
  20. #include <linux/mfd/abx500/ab8500-bm.h>
  21. #include <linux/mfd/abx500/ux500_chargalg.h>
  22. #include <linux/pm2301_charger.h>
  23. #include <linux/gpio.h>
  24. #include <linux/pm_runtime.h>
  25. #include <linux/pm.h>
  26. #include "pm2301_charger.h"
  27. #define to_pm2xxx_charger_ac_device_info(x) container_of((x), \
  28. struct pm2xxx_charger, ac_chg)
  29. #define SLEEP_MIN 50
  30. #define SLEEP_MAX 100
  31. #define PM2XXX_AUTOSUSPEND_DELAY 500
  32. static int pm2xxx_interrupt_registers[] = {
  33. PM2XXX_REG_INT1,
  34. PM2XXX_REG_INT2,
  35. PM2XXX_REG_INT3,
  36. PM2XXX_REG_INT4,
  37. PM2XXX_REG_INT5,
  38. PM2XXX_REG_INT6,
  39. };
  40. static enum power_supply_property pm2xxx_charger_ac_props[] = {
  41. POWER_SUPPLY_PROP_HEALTH,
  42. POWER_SUPPLY_PROP_PRESENT,
  43. POWER_SUPPLY_PROP_ONLINE,
  44. POWER_SUPPLY_PROP_VOLTAGE_AVG,
  45. };
  46. static int pm2xxx_charger_voltage_map[] = {
  47. 3500,
  48. 3525,
  49. 3550,
  50. 3575,
  51. 3600,
  52. 3625,
  53. 3650,
  54. 3675,
  55. 3700,
  56. 3725,
  57. 3750,
  58. 3775,
  59. 3800,
  60. 3825,
  61. 3850,
  62. 3875,
  63. 3900,
  64. 3925,
  65. 3950,
  66. 3975,
  67. 4000,
  68. 4025,
  69. 4050,
  70. 4075,
  71. 4100,
  72. 4125,
  73. 4150,
  74. 4175,
  75. 4200,
  76. 4225,
  77. 4250,
  78. 4275,
  79. 4300,
  80. };
  81. static int pm2xxx_charger_current_map[] = {
  82. 200,
  83. 200,
  84. 400,
  85. 600,
  86. 800,
  87. 1000,
  88. 1200,
  89. 1400,
  90. 1600,
  91. 1800,
  92. 2000,
  93. 2200,
  94. 2400,
  95. 2600,
  96. 2800,
  97. 3000,
  98. };
  99. static void set_lpn_pin(struct pm2xxx_charger *pm2)
  100. {
  101. if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin)) {
  102. gpio_set_value(pm2->lpn_pin, 1);
  103. usleep_range(SLEEP_MIN, SLEEP_MAX);
  104. }
  105. }
  106. static void clear_lpn_pin(struct pm2xxx_charger *pm2)
  107. {
  108. if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin))
  109. gpio_set_value(pm2->lpn_pin, 0);
  110. }
  111. static int pm2xxx_reg_read(struct pm2xxx_charger *pm2, int reg, u8 *val)
  112. {
  113. int ret;
  114. /* wake up the device */
  115. pm_runtime_get_sync(pm2->dev);
  116. ret = i2c_smbus_read_i2c_block_data(pm2->config.pm2xxx_i2c, reg,
  117. 1, val);
  118. if (ret < 0)
  119. dev_err(pm2->dev, "Error reading register at 0x%x\n", reg);
  120. else
  121. ret = 0;
  122. pm_runtime_put_sync(pm2->dev);
  123. return ret;
  124. }
  125. static int pm2xxx_reg_write(struct pm2xxx_charger *pm2, int reg, u8 val)
  126. {
  127. int ret;
  128. /* wake up the device */
  129. pm_runtime_get_sync(pm2->dev);
  130. ret = i2c_smbus_write_i2c_block_data(pm2->config.pm2xxx_i2c, reg,
  131. 1, &val);
  132. if (ret < 0)
  133. dev_err(pm2->dev, "Error writing register at 0x%x\n", reg);
  134. else
  135. ret = 0;
  136. pm_runtime_put_sync(pm2->dev);
  137. return ret;
  138. }
  139. static int pm2xxx_charging_enable_mngt(struct pm2xxx_charger *pm2)
  140. {
  141. int ret;
  142. /* Enable charging */
  143. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2,
  144. (PM2XXX_CH_AUTO_RESUME_EN | PM2XXX_CHARGER_ENA));
  145. return ret;
  146. }
  147. static int pm2xxx_charging_disable_mngt(struct pm2xxx_charger *pm2)
  148. {
  149. int ret;
  150. /* Disable SW EOC ctrl */
  151. ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG, PM2XXX_SWCTRL_HW);
  152. if (ret < 0) {
  153. dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
  154. return ret;
  155. }
  156. /* Disable charging */
  157. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2,
  158. (PM2XXX_CH_AUTO_RESUME_DIS | PM2XXX_CHARGER_DIS));
  159. if (ret < 0) {
  160. dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
  161. return ret;
  162. }
  163. return 0;
  164. }
  165. static int pm2xxx_charger_batt_therm_mngt(struct pm2xxx_charger *pm2, int val)
  166. {
  167. queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work);
  168. return 0;
  169. }
  170. static int pm2xxx_charger_die_therm_mngt(struct pm2xxx_charger *pm2, int val)
  171. {
  172. queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work);
  173. return 0;
  174. }
  175. static int pm2xxx_charger_ovv_mngt(struct pm2xxx_charger *pm2, int val)
  176. {
  177. dev_err(pm2->dev, "Overvoltage detected\n");
  178. pm2->flags.ovv = true;
  179. power_supply_changed(pm2->ac_chg.psy);
  180. /* Schedule a new HW failure check */
  181. queue_delayed_work(pm2->charger_wq, &pm2->check_hw_failure_work, 0);
  182. return 0;
  183. }
  184. static int pm2xxx_charger_wd_exp_mngt(struct pm2xxx_charger *pm2, int val)
  185. {
  186. dev_dbg(pm2->dev , "20 minutes watchdog expired\n");
  187. pm2->ac.wd_expired = true;
  188. power_supply_changed(pm2->ac_chg.psy);
  189. return 0;
  190. }
  191. static int pm2xxx_charger_vbat_lsig_mngt(struct pm2xxx_charger *pm2, int val)
  192. {
  193. int ret;
  194. switch (val) {
  195. case PM2XXX_INT1_ITVBATLOWR:
  196. dev_dbg(pm2->dev, "VBAT grows above VBAT_LOW level\n");
  197. /* Enable SW EOC ctrl */
  198. ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG,
  199. PM2XXX_SWCTRL_SW);
  200. if (ret < 0) {
  201. dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
  202. return ret;
  203. }
  204. break;
  205. case PM2XXX_INT1_ITVBATLOWF:
  206. dev_dbg(pm2->dev, "VBAT drops below VBAT_LOW level\n");
  207. /* Disable SW EOC ctrl */
  208. ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG,
  209. PM2XXX_SWCTRL_HW);
  210. if (ret < 0) {
  211. dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
  212. return ret;
  213. }
  214. break;
  215. default:
  216. dev_err(pm2->dev, "Unknown VBAT level\n");
  217. }
  218. return 0;
  219. }
  220. static int pm2xxx_charger_bat_disc_mngt(struct pm2xxx_charger *pm2, int val)
  221. {
  222. dev_dbg(pm2->dev, "battery disconnected\n");
  223. return 0;
  224. }
  225. static int pm2xxx_charger_detection(struct pm2xxx_charger *pm2, u8 *val)
  226. {
  227. int ret;
  228. ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT2, val);
  229. if (ret < 0) {
  230. dev_err(pm2->dev, "Charger detection failed\n");
  231. goto out;
  232. }
  233. *val &= (PM2XXX_INT2_S_ITVPWR1PLUG | PM2XXX_INT2_S_ITVPWR2PLUG);
  234. out:
  235. return ret;
  236. }
  237. static int pm2xxx_charger_itv_pwr_plug_mngt(struct pm2xxx_charger *pm2, int val)
  238. {
  239. int ret;
  240. u8 read_val;
  241. /*
  242. * Since we can't be sure that the events are received
  243. * synchronously, we have the check if the main charger is
  244. * connected by reading the interrupt source register.
  245. */
  246. ret = pm2xxx_charger_detection(pm2, &read_val);
  247. if ((ret == 0) && read_val) {
  248. pm2->ac.charger_connected = 1;
  249. pm2->ac_conn = true;
  250. queue_work(pm2->charger_wq, &pm2->ac_work);
  251. }
  252. return ret;
  253. }
  254. static int pm2xxx_charger_itv_pwr_unplug_mngt(struct pm2xxx_charger *pm2,
  255. int val)
  256. {
  257. pm2->ac.charger_connected = 0;
  258. queue_work(pm2->charger_wq, &pm2->ac_work);
  259. return 0;
  260. }
  261. static int pm2_int_reg0(void *pm2_data, int val)
  262. {
  263. struct pm2xxx_charger *pm2 = pm2_data;
  264. int ret = 0;
  265. if (val & PM2XXX_INT1_ITVBATLOWR) {
  266. ret = pm2xxx_charger_vbat_lsig_mngt(pm2,
  267. PM2XXX_INT1_ITVBATLOWR);
  268. if (ret < 0)
  269. goto out;
  270. }
  271. if (val & PM2XXX_INT1_ITVBATLOWF) {
  272. ret = pm2xxx_charger_vbat_lsig_mngt(pm2,
  273. PM2XXX_INT1_ITVBATLOWF);
  274. if (ret < 0)
  275. goto out;
  276. }
  277. if (val & PM2XXX_INT1_ITVBATDISCONNECT) {
  278. ret = pm2xxx_charger_bat_disc_mngt(pm2,
  279. PM2XXX_INT1_ITVBATDISCONNECT);
  280. if (ret < 0)
  281. goto out;
  282. }
  283. out:
  284. return ret;
  285. }
  286. static int pm2_int_reg1(void *pm2_data, int val)
  287. {
  288. struct pm2xxx_charger *pm2 = pm2_data;
  289. int ret = 0;
  290. if (val & (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG)) {
  291. dev_dbg(pm2->dev , "Main charger plugged\n");
  292. ret = pm2xxx_charger_itv_pwr_plug_mngt(pm2, val &
  293. (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG));
  294. }
  295. if (val &
  296. (PM2XXX_INT2_ITVPWR1UNPLUG | PM2XXX_INT2_ITVPWR2UNPLUG)) {
  297. dev_dbg(pm2->dev , "Main charger unplugged\n");
  298. ret = pm2xxx_charger_itv_pwr_unplug_mngt(pm2, val &
  299. (PM2XXX_INT2_ITVPWR1UNPLUG |
  300. PM2XXX_INT2_ITVPWR2UNPLUG));
  301. }
  302. return ret;
  303. }
  304. static int pm2_int_reg2(void *pm2_data, int val)
  305. {
  306. struct pm2xxx_charger *pm2 = pm2_data;
  307. int ret = 0;
  308. if (val & PM2XXX_INT3_ITAUTOTIMEOUTWD)
  309. ret = pm2xxx_charger_wd_exp_mngt(pm2, val);
  310. if (val & (PM2XXX_INT3_ITCHPRECHARGEWD |
  311. PM2XXX_INT3_ITCHCCWD | PM2XXX_INT3_ITCHCVWD)) {
  312. dev_dbg(pm2->dev,
  313. "Watchdog occurred for precharge, CC and CV charge\n");
  314. }
  315. return ret;
  316. }
  317. static int pm2_int_reg3(void *pm2_data, int val)
  318. {
  319. struct pm2xxx_charger *pm2 = pm2_data;
  320. int ret = 0;
  321. if (val & (PM2XXX_INT4_ITCHARGINGON)) {
  322. dev_dbg(pm2->dev ,
  323. "charging operation has started\n");
  324. }
  325. if (val & (PM2XXX_INT4_ITVRESUME)) {
  326. dev_dbg(pm2->dev,
  327. "battery discharged down to VResume threshold\n");
  328. }
  329. if (val & (PM2XXX_INT4_ITBATTFULL)) {
  330. dev_dbg(pm2->dev , "battery fully detected\n");
  331. }
  332. if (val & (PM2XXX_INT4_ITCVPHASE)) {
  333. dev_dbg(pm2->dev, "CV phase enter with 0.5C charging\n");
  334. }
  335. if (val & (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV)) {
  336. pm2->failure_case = VPWR_OVV;
  337. ret = pm2xxx_charger_ovv_mngt(pm2, val &
  338. (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV));
  339. dev_dbg(pm2->dev, "VPWR/VSYSTEM overvoltage detected\n");
  340. }
  341. if (val & (PM2XXX_INT4_S_ITBATTEMPCOLD |
  342. PM2XXX_INT4_S_ITBATTEMPHOT)) {
  343. ret = pm2xxx_charger_batt_therm_mngt(pm2, val &
  344. (PM2XXX_INT4_S_ITBATTEMPCOLD |
  345. PM2XXX_INT4_S_ITBATTEMPHOT));
  346. dev_dbg(pm2->dev, "BTEMP is too Low/High\n");
  347. }
  348. return ret;
  349. }
  350. static int pm2_int_reg4(void *pm2_data, int val)
  351. {
  352. struct pm2xxx_charger *pm2 = pm2_data;
  353. int ret = 0;
  354. if (val & PM2XXX_INT5_ITVSYSTEMOVV) {
  355. pm2->failure_case = VSYSTEM_OVV;
  356. ret = pm2xxx_charger_ovv_mngt(pm2, val &
  357. PM2XXX_INT5_ITVSYSTEMOVV);
  358. dev_dbg(pm2->dev, "VSYSTEM overvoltage detected\n");
  359. }
  360. if (val & (PM2XXX_INT5_ITTHERMALWARNINGFALL |
  361. PM2XXX_INT5_ITTHERMALWARNINGRISE |
  362. PM2XXX_INT5_ITTHERMALSHUTDOWNFALL |
  363. PM2XXX_INT5_ITTHERMALSHUTDOWNRISE)) {
  364. dev_dbg(pm2->dev, "BTEMP die temperature is too Low/High\n");
  365. ret = pm2xxx_charger_die_therm_mngt(pm2, val &
  366. (PM2XXX_INT5_ITTHERMALWARNINGFALL |
  367. PM2XXX_INT5_ITTHERMALWARNINGRISE |
  368. PM2XXX_INT5_ITTHERMALSHUTDOWNFALL |
  369. PM2XXX_INT5_ITTHERMALSHUTDOWNRISE));
  370. }
  371. return ret;
  372. }
  373. static int pm2_int_reg5(void *pm2_data, int val)
  374. {
  375. struct pm2xxx_charger *pm2 = pm2_data;
  376. int ret = 0;
  377. if (val & (PM2XXX_INT6_ITVPWR2DROP | PM2XXX_INT6_ITVPWR1DROP)) {
  378. dev_dbg(pm2->dev, "VMPWR drop to VBAT level\n");
  379. }
  380. if (val & (PM2XXX_INT6_ITVPWR2VALIDRISE |
  381. PM2XXX_INT6_ITVPWR1VALIDRISE |
  382. PM2XXX_INT6_ITVPWR2VALIDFALL |
  383. PM2XXX_INT6_ITVPWR1VALIDFALL)) {
  384. dev_dbg(pm2->dev, "Falling/Rising edge on WPWR1/2\n");
  385. }
  386. return ret;
  387. }
  388. static irqreturn_t pm2xxx_irq_int(int irq, void *data)
  389. {
  390. struct pm2xxx_charger *pm2 = data;
  391. struct pm2xxx_interrupts *interrupt = pm2->pm2_int;
  392. int i;
  393. /* wake up the device */
  394. pm_runtime_get_sync(pm2->dev);
  395. do {
  396. for (i = 0; i < PM2XXX_NUM_INT_REG; i++) {
  397. pm2xxx_reg_read(pm2,
  398. pm2xxx_interrupt_registers[i],
  399. &(interrupt->reg[i]));
  400. if (interrupt->reg[i] > 0)
  401. interrupt->handler[i](pm2, interrupt->reg[i]);
  402. }
  403. } while (gpio_get_value(pm2->pdata->gpio_irq_number) == 0);
  404. pm_runtime_mark_last_busy(pm2->dev);
  405. pm_runtime_put_autosuspend(pm2->dev);
  406. return IRQ_HANDLED;
  407. }
  408. static int pm2xxx_charger_get_ac_cv(struct pm2xxx_charger *pm2)
  409. {
  410. int ret = 0;
  411. u8 val;
  412. if (pm2->ac.charger_connected && pm2->ac.charger_online) {
  413. ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &val);
  414. if (ret < 0) {
  415. dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
  416. goto out;
  417. }
  418. if (val & PM2XXX_INT4_S_ITCVPHASE)
  419. ret = PM2XXX_CONST_VOLT;
  420. else
  421. ret = PM2XXX_CONST_CURR;
  422. }
  423. out:
  424. return ret;
  425. }
  426. static int pm2xxx_current_to_regval(int curr)
  427. {
  428. int i;
  429. if (curr < pm2xxx_charger_current_map[0])
  430. return 0;
  431. for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_current_map); i++) {
  432. if (curr < pm2xxx_charger_current_map[i])
  433. return (i - 1);
  434. }
  435. i = ARRAY_SIZE(pm2xxx_charger_current_map) - 1;
  436. if (curr == pm2xxx_charger_current_map[i])
  437. return i;
  438. else
  439. return -EINVAL;
  440. }
  441. static int pm2xxx_voltage_to_regval(int curr)
  442. {
  443. int i;
  444. if (curr < pm2xxx_charger_voltage_map[0])
  445. return 0;
  446. for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_voltage_map); i++) {
  447. if (curr < pm2xxx_charger_voltage_map[i])
  448. return i - 1;
  449. }
  450. i = ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1;
  451. if (curr == pm2xxx_charger_voltage_map[i])
  452. return i;
  453. else
  454. return -EINVAL;
  455. }
  456. static int pm2xxx_charger_update_charger_current(struct ux500_charger *charger,
  457. int ich_out)
  458. {
  459. int ret;
  460. int curr_index;
  461. struct pm2xxx_charger *pm2;
  462. u8 val;
  463. if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
  464. pm2 = to_pm2xxx_charger_ac_device_info(charger);
  465. else
  466. return -ENXIO;
  467. curr_index = pm2xxx_current_to_regval(ich_out);
  468. if (curr_index < 0) {
  469. dev_err(pm2->dev,
  470. "Charger current too high, charging not started\n");
  471. return -ENXIO;
  472. }
  473. ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val);
  474. if (ret >= 0) {
  475. val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK;
  476. val |= curr_index;
  477. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val);
  478. if (ret < 0) {
  479. dev_err(pm2->dev,
  480. "%s write failed\n", __func__);
  481. }
  482. }
  483. else
  484. dev_err(pm2->dev, "%s read failed\n", __func__);
  485. return ret;
  486. }
  487. static int pm2xxx_charger_ac_get_property(struct power_supply *psy,
  488. enum power_supply_property psp,
  489. union power_supply_propval *val)
  490. {
  491. struct pm2xxx_charger *pm2;
  492. pm2 = to_pm2xxx_charger_ac_device_info(psy_to_ux500_charger(psy));
  493. switch (psp) {
  494. case POWER_SUPPLY_PROP_HEALTH:
  495. if (pm2->flags.mainextchnotok)
  496. val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
  497. else if (pm2->ac.wd_expired)
  498. val->intval = POWER_SUPPLY_HEALTH_DEAD;
  499. else if (pm2->flags.main_thermal_prot)
  500. val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
  501. else if (pm2->flags.ovv)
  502. val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
  503. else
  504. val->intval = POWER_SUPPLY_HEALTH_GOOD;
  505. break;
  506. case POWER_SUPPLY_PROP_ONLINE:
  507. val->intval = pm2->ac.charger_online;
  508. break;
  509. case POWER_SUPPLY_PROP_PRESENT:
  510. val->intval = pm2->ac.charger_connected;
  511. break;
  512. case POWER_SUPPLY_PROP_VOLTAGE_AVG:
  513. pm2->ac.cv_active = pm2xxx_charger_get_ac_cv(pm2);
  514. val->intval = pm2->ac.cv_active;
  515. break;
  516. default:
  517. return -EINVAL;
  518. }
  519. return 0;
  520. }
  521. static int pm2xxx_charging_init(struct pm2xxx_charger *pm2)
  522. {
  523. int ret = 0;
  524. /* enable CC and CV watchdog */
  525. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG3,
  526. (PM2XXX_CH_WD_CV_PHASE_60MIN | PM2XXX_CH_WD_CC_PHASE_60MIN));
  527. if( ret < 0)
  528. return ret;
  529. /* enable precharge watchdog */
  530. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG4,
  531. PM2XXX_CH_WD_PRECH_PHASE_60MIN);
  532. /* Disable auto timeout */
  533. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG5,
  534. PM2XXX_CH_WD_AUTO_TIMEOUT_20MIN);
  535. /*
  536. * EOC current level = 100mA
  537. * Precharge current level = 100mA
  538. * CC current level = 1000mA
  539. */
  540. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6,
  541. (PM2XXX_DIR_CH_CC_CURRENT_1000MA |
  542. PM2XXX_CH_PRECH_CURRENT_100MA |
  543. PM2XXX_CH_EOC_CURRENT_100MA));
  544. /*
  545. * recharge threshold = 3.8V
  546. * Precharge to CC threshold = 2.9V
  547. */
  548. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG7,
  549. (PM2XXX_CH_PRECH_VOL_2_9 | PM2XXX_CH_VRESUME_VOL_3_8));
  550. /* float voltage charger level = 4.2V */
  551. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8,
  552. PM2XXX_CH_VOLT_4_2);
  553. /* Voltage drop between VBAT and VSYS in HW charging = 300mV */
  554. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG9,
  555. (PM2XXX_CH_150MV_DROP_300MV | PM2XXX_CHARCHING_INFO_DIS |
  556. PM2XXX_CH_CC_REDUCED_CURRENT_IDENT |
  557. PM2XXX_CH_CC_MODEDROP_DIS));
  558. /* Input charger level of over voltage = 10V */
  559. ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR2,
  560. PM2XXX_VPWR2_OVV_10);
  561. ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR1,
  562. PM2XXX_VPWR1_OVV_10);
  563. /* Input charger drop */
  564. ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR2,
  565. (PM2XXX_VPWR2_HW_OPT_DIS | PM2XXX_VPWR2_VALID_DIS |
  566. PM2XXX_VPWR2_DROP_DIS));
  567. ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR1,
  568. (PM2XXX_VPWR1_HW_OPT_DIS | PM2XXX_VPWR1_VALID_DIS |
  569. PM2XXX_VPWR1_DROP_DIS));
  570. /* Disable battery low monitoring */
  571. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_LOW_LEV_COMP_REG,
  572. PM2XXX_VBAT_LOW_MONITORING_ENA);
  573. return ret;
  574. }
  575. static int pm2xxx_charger_ac_en(struct ux500_charger *charger,
  576. int enable, int vset, int iset)
  577. {
  578. int ret;
  579. int volt_index;
  580. int curr_index;
  581. u8 val;
  582. struct pm2xxx_charger *pm2 = to_pm2xxx_charger_ac_device_info(charger);
  583. if (enable) {
  584. if (!pm2->ac.charger_connected) {
  585. dev_dbg(pm2->dev, "AC charger not connected\n");
  586. return -ENXIO;
  587. }
  588. dev_dbg(pm2->dev, "Enable AC: %dmV %dmA\n", vset, iset);
  589. if (!pm2->vddadc_en_ac) {
  590. ret = regulator_enable(pm2->regu);
  591. if (ret)
  592. dev_warn(pm2->dev,
  593. "Failed to enable vddadc regulator\n");
  594. else
  595. pm2->vddadc_en_ac = true;
  596. }
  597. ret = pm2xxx_charging_init(pm2);
  598. if (ret < 0) {
  599. dev_err(pm2->dev, "%s charging init failed\n",
  600. __func__);
  601. goto error_occured;
  602. }
  603. volt_index = pm2xxx_voltage_to_regval(vset);
  604. curr_index = pm2xxx_current_to_regval(iset);
  605. if (volt_index < 0 || curr_index < 0) {
  606. dev_err(pm2->dev,
  607. "Charger voltage or current too high, "
  608. "charging not started\n");
  609. return -ENXIO;
  610. }
  611. ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG8, &val);
  612. if (ret < 0) {
  613. dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
  614. goto error_occured;
  615. }
  616. val &= ~PM2XXX_CH_VOLT_MASK;
  617. val |= volt_index;
  618. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8, val);
  619. if (ret < 0) {
  620. dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
  621. goto error_occured;
  622. }
  623. ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val);
  624. if (ret < 0) {
  625. dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
  626. goto error_occured;
  627. }
  628. val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK;
  629. val |= curr_index;
  630. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val);
  631. if (ret < 0) {
  632. dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
  633. goto error_occured;
  634. }
  635. if (!pm2->bat->enable_overshoot) {
  636. ret = pm2xxx_reg_read(pm2, PM2XXX_LED_CTRL_REG, &val);
  637. if (ret < 0) {
  638. dev_err(pm2->dev, "%s pm2xxx read failed\n",
  639. __func__);
  640. goto error_occured;
  641. }
  642. val |= PM2XXX_ANTI_OVERSHOOT_EN;
  643. ret = pm2xxx_reg_write(pm2, PM2XXX_LED_CTRL_REG, val);
  644. if (ret < 0) {
  645. dev_err(pm2->dev, "%s pm2xxx write failed\n",
  646. __func__);
  647. goto error_occured;
  648. }
  649. }
  650. ret = pm2xxx_charging_enable_mngt(pm2);
  651. if (ret < 0) {
  652. dev_err(pm2->dev, "Failed to enable"
  653. "pm2xxx ac charger\n");
  654. goto error_occured;
  655. }
  656. pm2->ac.charger_online = 1;
  657. } else {
  658. pm2->ac.charger_online = 0;
  659. pm2->ac.wd_expired = false;
  660. /* Disable regulator if enabled */
  661. if (pm2->vddadc_en_ac) {
  662. regulator_disable(pm2->regu);
  663. pm2->vddadc_en_ac = false;
  664. }
  665. ret = pm2xxx_charging_disable_mngt(pm2);
  666. if (ret < 0) {
  667. dev_err(pm2->dev, "failed to disable"
  668. "pm2xxx ac charger\n");
  669. goto error_occured;
  670. }
  671. dev_dbg(pm2->dev, "PM2301: " "Disabled AC charging\n");
  672. }
  673. power_supply_changed(pm2->ac_chg.psy);
  674. error_occured:
  675. return ret;
  676. }
  677. static int pm2xxx_charger_watchdog_kick(struct ux500_charger *charger)
  678. {
  679. int ret;
  680. struct pm2xxx_charger *pm2;
  681. if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
  682. pm2 = to_pm2xxx_charger_ac_device_info(charger);
  683. else
  684. return -ENXIO;
  685. ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_WD_KICK, WD_TIMER);
  686. if (ret)
  687. dev_err(pm2->dev, "Failed to kick WD!\n");
  688. return ret;
  689. }
  690. static void pm2xxx_charger_ac_work(struct work_struct *work)
  691. {
  692. struct pm2xxx_charger *pm2 = container_of(work,
  693. struct pm2xxx_charger, ac_work);
  694. power_supply_changed(pm2->ac_chg.psy);
  695. sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present");
  696. };
  697. static void pm2xxx_charger_check_hw_failure_work(struct work_struct *work)
  698. {
  699. u8 reg_value;
  700. struct pm2xxx_charger *pm2 = container_of(work,
  701. struct pm2xxx_charger, check_hw_failure_work.work);
  702. if (pm2->flags.ovv) {
  703. pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &reg_value);
  704. if (!(reg_value & (PM2XXX_INT4_S_ITVPWR1OVV |
  705. PM2XXX_INT4_S_ITVPWR2OVV))) {
  706. pm2->flags.ovv = false;
  707. power_supply_changed(pm2->ac_chg.psy);
  708. }
  709. }
  710. /* If we still have a failure, schedule a new check */
  711. if (pm2->flags.ovv) {
  712. queue_delayed_work(pm2->charger_wq,
  713. &pm2->check_hw_failure_work, round_jiffies(HZ));
  714. }
  715. }
  716. static void pm2xxx_charger_check_main_thermal_prot_work(
  717. struct work_struct *work)
  718. {
  719. int ret;
  720. u8 val;
  721. struct pm2xxx_charger *pm2 = container_of(work, struct pm2xxx_charger,
  722. check_main_thermal_prot_work);
  723. /* Check if die temp warning is still active */
  724. ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT5, &val);
  725. if (ret < 0) {
  726. dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
  727. return;
  728. }
  729. if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGRISE
  730. | PM2XXX_INT5_S_ITTHERMALSHUTDOWNRISE))
  731. pm2->flags.main_thermal_prot = true;
  732. else if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGFALL
  733. | PM2XXX_INT5_S_ITTHERMALSHUTDOWNFALL))
  734. pm2->flags.main_thermal_prot = false;
  735. power_supply_changed(pm2->ac_chg.psy);
  736. }
  737. static struct pm2xxx_interrupts pm2xxx_int = {
  738. .handler[0] = pm2_int_reg0,
  739. .handler[1] = pm2_int_reg1,
  740. .handler[2] = pm2_int_reg2,
  741. .handler[3] = pm2_int_reg3,
  742. .handler[4] = pm2_int_reg4,
  743. .handler[5] = pm2_int_reg5,
  744. };
  745. static struct pm2xxx_irq pm2xxx_charger_irq[] = {
  746. {"PM2XXX_IRQ_INT", pm2xxx_irq_int},
  747. };
  748. static int __maybe_unused pm2xxx_wall_charger_resume(struct device *dev)
  749. {
  750. struct i2c_client *i2c_client = to_i2c_client(dev);
  751. struct pm2xxx_charger *pm2;
  752. pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client);
  753. set_lpn_pin(pm2);
  754. /* If we still have a HW failure, schedule a new check */
  755. if (pm2->flags.ovv)
  756. queue_delayed_work(pm2->charger_wq,
  757. &pm2->check_hw_failure_work, 0);
  758. return 0;
  759. }
  760. static int __maybe_unused pm2xxx_wall_charger_suspend(struct device *dev)
  761. {
  762. struct i2c_client *i2c_client = to_i2c_client(dev);
  763. struct pm2xxx_charger *pm2;
  764. pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client);
  765. clear_lpn_pin(pm2);
  766. /* Cancel any pending HW failure check */
  767. if (delayed_work_pending(&pm2->check_hw_failure_work))
  768. cancel_delayed_work(&pm2->check_hw_failure_work);
  769. flush_work(&pm2->ac_work);
  770. flush_work(&pm2->check_main_thermal_prot_work);
  771. return 0;
  772. }
  773. static int __maybe_unused pm2xxx_runtime_suspend(struct device *dev)
  774. {
  775. struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev);
  776. struct pm2xxx_charger *pm2;
  777. pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client);
  778. clear_lpn_pin(pm2);
  779. return 0;
  780. }
  781. static int __maybe_unused pm2xxx_runtime_resume(struct device *dev)
  782. {
  783. struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev);
  784. struct pm2xxx_charger *pm2;
  785. pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client);
  786. if (gpio_is_valid(pm2->lpn_pin) && gpio_get_value(pm2->lpn_pin) == 0)
  787. set_lpn_pin(pm2);
  788. return 0;
  789. }
  790. static const struct dev_pm_ops pm2xxx_pm_ops __maybe_unused = {
  791. SET_SYSTEM_SLEEP_PM_OPS(pm2xxx_wall_charger_suspend,
  792. pm2xxx_wall_charger_resume)
  793. SET_RUNTIME_PM_OPS(pm2xxx_runtime_suspend, pm2xxx_runtime_resume, NULL)
  794. };
  795. static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client,
  796. const struct i2c_device_id *id)
  797. {
  798. struct pm2xxx_platform_data *pl_data = i2c_client->dev.platform_data;
  799. struct power_supply_config psy_cfg = {};
  800. struct pm2xxx_charger *pm2;
  801. int ret = 0;
  802. u8 val;
  803. int i;
  804. if (!pl_data) {
  805. dev_err(&i2c_client->dev, "No platform data supplied\n");
  806. return -EINVAL;
  807. }
  808. pm2 = kzalloc(sizeof(struct pm2xxx_charger), GFP_KERNEL);
  809. if (!pm2) {
  810. dev_err(&i2c_client->dev, "pm2xxx_charger allocation failed\n");
  811. return -ENOMEM;
  812. }
  813. /* get parent data */
  814. pm2->dev = &i2c_client->dev;
  815. pm2->pm2_int = &pm2xxx_int;
  816. /* get charger spcific platform data */
  817. if (!pl_data->wall_charger) {
  818. dev_err(pm2->dev, "no charger platform data supplied\n");
  819. ret = -EINVAL;
  820. goto free_device_info;
  821. }
  822. pm2->pdata = pl_data->wall_charger;
  823. /* get battery specific platform data */
  824. if (!pl_data->battery) {
  825. dev_err(pm2->dev, "no battery platform data supplied\n");
  826. ret = -EINVAL;
  827. goto free_device_info;
  828. }
  829. pm2->bat = pl_data->battery;
  830. if (!i2c_check_functionality(i2c_client->adapter,
  831. I2C_FUNC_SMBUS_BYTE_DATA |
  832. I2C_FUNC_SMBUS_READ_WORD_DATA)) {
  833. ret = -ENODEV;
  834. dev_info(pm2->dev, "pm2301 i2c_check_functionality failed\n");
  835. goto free_device_info;
  836. }
  837. pm2->config.pm2xxx_i2c = i2c_client;
  838. pm2->config.pm2xxx_id = (struct i2c_device_id *) id;
  839. i2c_set_clientdata(i2c_client, pm2);
  840. /* AC supply */
  841. /* power_supply base class */
  842. pm2->ac_chg_desc.name = pm2->pdata->label;
  843. pm2->ac_chg_desc.type = POWER_SUPPLY_TYPE_MAINS;
  844. pm2->ac_chg_desc.properties = pm2xxx_charger_ac_props;
  845. pm2->ac_chg_desc.num_properties = ARRAY_SIZE(pm2xxx_charger_ac_props);
  846. pm2->ac_chg_desc.get_property = pm2xxx_charger_ac_get_property;
  847. psy_cfg.supplied_to = pm2->pdata->supplied_to;
  848. psy_cfg.num_supplicants = pm2->pdata->num_supplicants;
  849. /* pm2xxx_charger sub-class */
  850. pm2->ac_chg.ops.enable = &pm2xxx_charger_ac_en;
  851. pm2->ac_chg.ops.kick_wd = &pm2xxx_charger_watchdog_kick;
  852. pm2->ac_chg.ops.update_curr = &pm2xxx_charger_update_charger_current;
  853. pm2->ac_chg.max_out_volt = pm2xxx_charger_voltage_map[
  854. ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1];
  855. pm2->ac_chg.max_out_curr = pm2xxx_charger_current_map[
  856. ARRAY_SIZE(pm2xxx_charger_current_map) - 1];
  857. pm2->ac_chg.wdt_refresh = WD_KICK_INTERVAL;
  858. pm2->ac_chg.enabled = true;
  859. pm2->ac_chg.external = true;
  860. /* Create a work queue for the charger */
  861. pm2->charger_wq = alloc_ordered_workqueue("pm2xxx_charger_wq",
  862. WQ_MEM_RECLAIM);
  863. if (pm2->charger_wq == NULL) {
  864. ret = -ENOMEM;
  865. dev_err(pm2->dev, "failed to create work queue\n");
  866. goto free_device_info;
  867. }
  868. /* Init work for charger detection */
  869. INIT_WORK(&pm2->ac_work, pm2xxx_charger_ac_work);
  870. /* Init work for checking HW status */
  871. INIT_WORK(&pm2->check_main_thermal_prot_work,
  872. pm2xxx_charger_check_main_thermal_prot_work);
  873. /* Init work for HW failure check */
  874. INIT_DEFERRABLE_WORK(&pm2->check_hw_failure_work,
  875. pm2xxx_charger_check_hw_failure_work);
  876. /*
  877. * VDD ADC supply needs to be enabled from this driver when there
  878. * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
  879. * interrupts during charging
  880. */
  881. pm2->regu = regulator_get(pm2->dev, "vddadc");
  882. if (IS_ERR(pm2->regu)) {
  883. ret = PTR_ERR(pm2->regu);
  884. dev_err(pm2->dev, "failed to get vddadc regulator\n");
  885. goto free_charger_wq;
  886. }
  887. /* Register AC charger class */
  888. pm2->ac_chg.psy = power_supply_register(pm2->dev, &pm2->ac_chg_desc,
  889. &psy_cfg);
  890. if (IS_ERR(pm2->ac_chg.psy)) {
  891. dev_err(pm2->dev, "failed to register AC charger\n");
  892. ret = PTR_ERR(pm2->ac_chg.psy);
  893. goto free_regulator;
  894. }
  895. /* Register interrupts */
  896. ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number),
  897. NULL,
  898. pm2xxx_charger_irq[0].isr,
  899. pm2->pdata->irq_type | IRQF_ONESHOT,
  900. pm2xxx_charger_irq[0].name, pm2);
  901. if (ret != 0) {
  902. dev_err(pm2->dev, "failed to request %s IRQ %d: %d\n",
  903. pm2xxx_charger_irq[0].name,
  904. gpio_to_irq(pm2->pdata->gpio_irq_number), ret);
  905. goto unregister_pm2xxx_charger;
  906. }
  907. ret = pm_runtime_set_active(pm2->dev);
  908. if (ret)
  909. dev_err(pm2->dev, "set active Error\n");
  910. pm_runtime_enable(pm2->dev);
  911. pm_runtime_set_autosuspend_delay(pm2->dev, PM2XXX_AUTOSUSPEND_DELAY);
  912. pm_runtime_use_autosuspend(pm2->dev);
  913. pm_runtime_resume(pm2->dev);
  914. /* pm interrupt can wake up system */
  915. ret = enable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
  916. if (ret) {
  917. dev_err(pm2->dev, "failed to set irq wake\n");
  918. goto unregister_pm2xxx_interrupt;
  919. }
  920. mutex_init(&pm2->lock);
  921. if (gpio_is_valid(pm2->pdata->lpn_gpio)) {
  922. /* get lpn GPIO from platform data */
  923. pm2->lpn_pin = pm2->pdata->lpn_gpio;
  924. /*
  925. * Charger detection mechanism requires pulling up the LPN pin
  926. * while i2c communication if Charger is not connected
  927. * LPN pin of PM2301 is GPIO60 of AB9540
  928. */
  929. ret = gpio_request(pm2->lpn_pin, "pm2301_lpm_gpio");
  930. if (ret < 0) {
  931. dev_err(pm2->dev, "pm2301_lpm_gpio request failed\n");
  932. goto disable_pm2_irq_wake;
  933. }
  934. ret = gpio_direction_output(pm2->lpn_pin, 0);
  935. if (ret < 0) {
  936. dev_err(pm2->dev, "pm2301_lpm_gpio direction failed\n");
  937. goto free_gpio;
  938. }
  939. set_lpn_pin(pm2);
  940. }
  941. /* read interrupt registers */
  942. for (i = 0; i < PM2XXX_NUM_INT_REG; i++)
  943. pm2xxx_reg_read(pm2,
  944. pm2xxx_interrupt_registers[i],
  945. &val);
  946. ret = pm2xxx_charger_detection(pm2, &val);
  947. if ((ret == 0) && val) {
  948. pm2->ac.charger_connected = 1;
  949. ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON,
  950. AB8500_MAIN_CH_DET);
  951. pm2->ac_conn = true;
  952. power_supply_changed(pm2->ac_chg.psy);
  953. sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present");
  954. }
  955. return 0;
  956. free_gpio:
  957. if (gpio_is_valid(pm2->lpn_pin))
  958. gpio_free(pm2->lpn_pin);
  959. disable_pm2_irq_wake:
  960. disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
  961. unregister_pm2xxx_interrupt:
  962. /* disable interrupt */
  963. free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
  964. unregister_pm2xxx_charger:
  965. /* unregister power supply */
  966. power_supply_unregister(pm2->ac_chg.psy);
  967. free_regulator:
  968. /* disable the regulator */
  969. regulator_put(pm2->regu);
  970. free_charger_wq:
  971. destroy_workqueue(pm2->charger_wq);
  972. free_device_info:
  973. kfree(pm2);
  974. return ret;
  975. }
  976. static int pm2xxx_wall_charger_remove(struct i2c_client *i2c_client)
  977. {
  978. struct pm2xxx_charger *pm2 = i2c_get_clientdata(i2c_client);
  979. /* Disable pm_runtime */
  980. pm_runtime_disable(pm2->dev);
  981. /* Disable AC charging */
  982. pm2xxx_charger_ac_en(&pm2->ac_chg, false, 0, 0);
  983. /* Disable wake by pm interrupt */
  984. disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
  985. /* Disable interrupts */
  986. free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
  987. /* Delete the work queue */
  988. destroy_workqueue(pm2->charger_wq);
  989. flush_scheduled_work();
  990. /* disable the regulator */
  991. regulator_put(pm2->regu);
  992. power_supply_unregister(pm2->ac_chg.psy);
  993. if (gpio_is_valid(pm2->lpn_pin))
  994. gpio_free(pm2->lpn_pin);
  995. kfree(pm2);
  996. return 0;
  997. }
  998. static const struct i2c_device_id pm2xxx_id[] = {
  999. { "pm2301", 0 },
  1000. { }
  1001. };
  1002. MODULE_DEVICE_TABLE(i2c, pm2xxx_id);
  1003. static struct i2c_driver pm2xxx_charger_driver = {
  1004. .probe = pm2xxx_wall_charger_probe,
  1005. .remove = pm2xxx_wall_charger_remove,
  1006. .driver = {
  1007. .name = "pm2xxx-wall_charger",
  1008. .pm = IS_ENABLED(CONFIG_PM) ? &pm2xxx_pm_ops : NULL,
  1009. },
  1010. .id_table = pm2xxx_id,
  1011. };
  1012. static int __init pm2xxx_charger_init(void)
  1013. {
  1014. return i2c_add_driver(&pm2xxx_charger_driver);
  1015. }
  1016. static void __exit pm2xxx_charger_exit(void)
  1017. {
  1018. i2c_del_driver(&pm2xxx_charger_driver);
  1019. }
  1020. device_initcall_sync(pm2xxx_charger_init);
  1021. module_exit(pm2xxx_charger_exit);
  1022. MODULE_LICENSE("GPL v2");
  1023. MODULE_AUTHOR("Rajkumar kasirajan, Olivier Launay");
  1024. MODULE_DESCRIPTION("PM2xxx charger management driver");