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