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