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