blob: fb62ed3fc38c446041ded70e7da2c014e3f60cae [file] [log] [blame]
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001/*
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02002 * Copyright 2012 ST Ericsson.
3 *
Lee Jones2fa5b0f2013-01-23 14:33:47 +00004 * Power supply driver for ST Ericsson pm2xxx_charger charger
5 *
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02006 * 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>
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020019#include <linux/regulator/consumer.h>
20#include <linux/err.h>
21#include <linux/i2c.h>
22#include <linux/workqueue.h>
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020023#include <linux/mfd/abx500/ab8500.h>
24#include <linux/mfd/abx500/ab8500-bm.h>
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020025#include <linux/mfd/abx500/ux500_chargalg.h>
26#include <linux/pm2301_charger.h>
Lee Jones39880432013-01-23 14:38:15 +000027#include <linux/gpio.h>
Lee Jonesaee2b842013-02-25 14:28:59 +000028#include <linux/pm_runtime.h>
Lars-Peter Clausen6b170802013-04-13 13:20:07 +020029#include <linux/pm.h>
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020030
Lee Jones2fa5b0f2013-01-23 14:33:47 +000031#include "pm2301_charger.h"
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020032
33#define to_pm2xxx_charger_ac_device_info(x) container_of((x), \
34 struct pm2xxx_charger, ac_chg)
Mustapha Ben Zoubeir49fddee2012-06-27 15:40:58 +020035#define SLEEP_MIN 50
36#define SLEEP_MAX 100
Lee Jonesaee2b842013-02-25 14:28:59 +000037#define PM2XXX_AUTOSUSPEND_DELAY 500
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020038
39static int pm2xxx_interrupt_registers[] = {
40 PM2XXX_REG_INT1,
41 PM2XXX_REG_INT2,
42 PM2XXX_REG_INT3,
43 PM2XXX_REG_INT4,
44 PM2XXX_REG_INT5,
45 PM2XXX_REG_INT6,
46};
47
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020048static enum power_supply_property pm2xxx_charger_ac_props[] = {
49 POWER_SUPPLY_PROP_HEALTH,
50 POWER_SUPPLY_PROP_PRESENT,
51 POWER_SUPPLY_PROP_ONLINE,
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020052 POWER_SUPPLY_PROP_VOLTAGE_AVG,
Michel JAOUEN01ec8c52012-04-26 10:00:04 +020053};
54
55static int pm2xxx_charger_voltage_map[] = {
56 3500,
57 3525,
58 3550,
59 3575,
60 3600,
61 3625,
62 3650,
63 3675,
64 3700,
65 3725,
66 3750,
67 3775,
68 3800,
69 3825,
70 3850,
71 3875,
72 3900,
73 3925,
74 3950,
75 3975,
76 4000,
77 4025,
78 4050,
79 4075,
80 4100,
81 4125,
82 4150,
83 4175,
84 4200,
85 4225,
86 4250,
87 4275,
88 4300,
89};
90
91static int pm2xxx_charger_current_map[] = {
92 200,
93 200,
94 400,
95 600,
96 800,
97 1000,
98 1200,
99 1400,
100 1600,
101 1800,
102 2000,
103 2200,
104 2400,
105 2600,
106 2800,
107 3000,
108};
109
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200110static const struct i2c_device_id pm2xxx_ident[] = {
111 { "pm2301", 0 },
112 { }
113};
114
Lee Jones39880432013-01-23 14:38:15 +0000115static void set_lpn_pin(struct pm2xxx_charger *pm2)
116{
lme00437a21e22f2012-11-13 14:43:48 +0100117 if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin)) {
118 gpio_set_value(pm2->lpn_pin, 1);
119 usleep_range(SLEEP_MIN, SLEEP_MAX);
120 }
Lee Jones39880432013-01-23 14:38:15 +0000121}
122
123static void clear_lpn_pin(struct pm2xxx_charger *pm2)
124{
lme00437a21e22f2012-11-13 14:43:48 +0100125 if (!pm2->ac.charger_connected && gpio_is_valid(pm2->lpn_pin))
126 gpio_set_value(pm2->lpn_pin, 0);
Lee Jones39880432013-01-23 14:38:15 +0000127}
128
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200129static int pm2xxx_reg_read(struct pm2xxx_charger *pm2, int reg, u8 *val)
130{
131 int ret;
Rupesh Kumarb64f51c2012-12-05 14:14:13 +0530132
133 /* wake up the device */
134 pm_runtime_get_sync(pm2->dev);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200135
136 ret = i2c_smbus_read_i2c_block_data(pm2->config.pm2xxx_i2c, reg,
137 1, val);
138 if (ret < 0)
139 dev_err(pm2->dev, "Error reading register at 0x%x\n", reg);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530140 else
141 ret = 0;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200142
Rupesh Kumar9b7f50e2012-12-05 16:13:31 +0530143 pm_runtime_put_sync(pm2->dev);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200144
145 return ret;
146}
147
148static int pm2xxx_reg_write(struct pm2xxx_charger *pm2, int reg, u8 val)
149{
150 int ret;
Rupesh Kumarb64f51c2012-12-05 14:14:13 +0530151
152 /* wake up the device */
153 pm_runtime_get_sync(pm2->dev);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200154
155 ret = i2c_smbus_write_i2c_block_data(pm2->config.pm2xxx_i2c, reg,
156 1, &val);
157 if (ret < 0)
158 dev_err(pm2->dev, "Error writing register at 0x%x\n", reg);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530159 else
160 ret = 0;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200161
Rupesh Kumar9b7f50e2012-12-05 16:13:31 +0530162 pm_runtime_put_sync(pm2->dev);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200163
164 return ret;
165}
166
167static int pm2xxx_charging_enable_mngt(struct pm2xxx_charger *pm2)
168{
169 int ret;
170
171 /* Enable charging */
172 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2,
173 (PM2XXX_CH_AUTO_RESUME_EN | PM2XXX_CHARGER_ENA));
174
175 return ret;
176}
177
178static int pm2xxx_charging_disable_mngt(struct pm2xxx_charger *pm2)
179{
180 int ret;
181
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530182 /* Disable SW EOC ctrl */
183 ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG, PM2XXX_SWCTRL_HW);
184 if (ret < 0) {
185 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
186 return ret;
187 }
188
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200189 /* Disable charging */
190 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG2,
191 (PM2XXX_CH_AUTO_RESUME_DIS | PM2XXX_CHARGER_DIS));
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530192 if (ret < 0) {
193 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
194 return ret;
195 }
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200196
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530197 return 0;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200198}
199
200static int pm2xxx_charger_batt_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
207
Sachin Kamat83bd57a2013-09-06 13:31:12 +0530208static int pm2xxx_charger_die_therm_mngt(struct pm2xxx_charger *pm2, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200209{
210 queue_work(pm2->charger_wq, &pm2->check_main_thermal_prot_work);
211
212 return 0;
213}
214
215static int pm2xxx_charger_ovv_mngt(struct pm2xxx_charger *pm2, int val)
216{
Rupesh Kumar789ca7b2012-06-19 10:21:24 +0530217 dev_err(pm2->dev, "Overvoltage detected\n");
218 pm2->flags.ovv = true;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100219 power_supply_changed(pm2->ac_chg.psy);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200220
Rupesh Kumar789ca7b2012-06-19 10:21:24 +0530221 /* Schedule a new HW failure check */
222 queue_delayed_work(pm2->charger_wq, &pm2->check_hw_failure_work, 0);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200223
Rupesh Kumar789ca7b2012-06-19 10:21:24 +0530224 return 0;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200225}
226
227static int pm2xxx_charger_wd_exp_mngt(struct pm2xxx_charger *pm2, int val)
228{
Masanari Iida07f42252013-03-20 11:00:34 +0900229 dev_dbg(pm2->dev , "20 minutes watchdog expired\n");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200230
231 pm2->ac.wd_expired = true;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100232 power_supply_changed(pm2->ac_chg.psy);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200233
234 return 0;
235}
236
237static int pm2xxx_charger_vbat_lsig_mngt(struct pm2xxx_charger *pm2, int val)
238{
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530239 int ret;
240
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200241 switch (val) {
242 case PM2XXX_INT1_ITVBATLOWR:
243 dev_dbg(pm2->dev, "VBAT grows above VBAT_LOW level\n");
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530244 /* Enable SW EOC ctrl */
245 ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG,
246 PM2XXX_SWCTRL_SW);
247 if (ret < 0) {
248 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
249 return ret;
250 }
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200251 break;
252
253 case PM2XXX_INT1_ITVBATLOWF:
254 dev_dbg(pm2->dev, "VBAT drops below VBAT_LOW level\n");
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530255 /* Disable SW EOC ctrl */
256 ret = pm2xxx_reg_write(pm2, PM2XXX_SW_CTRL_REG,
257 PM2XXX_SWCTRL_HW);
258 if (ret < 0) {
259 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
260 return ret;
261 }
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200262 break;
263
264 default:
265 dev_err(pm2->dev, "Unknown VBAT level\n");
266 }
267
268 return 0;
269}
270
271static int pm2xxx_charger_bat_disc_mngt(struct pm2xxx_charger *pm2, int val)
272{
273 dev_dbg(pm2->dev, "battery disconnected\n");
274
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200275 return 0;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200276}
277
278static int pm2xxx_charger_detection(struct pm2xxx_charger *pm2, u8 *val)
279{
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530280 int ret;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200281
282 ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT2, val);
283
284 if (ret < 0) {
285 dev_err(pm2->dev, "Charger detection failed\n");
286 goto out;
287 }
288
289 *val &= (PM2XXX_INT2_S_ITVPWR1PLUG | PM2XXX_INT2_S_ITVPWR2PLUG);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530290
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200291out:
292 return ret;
293}
294
295static int pm2xxx_charger_itv_pwr_plug_mngt(struct pm2xxx_charger *pm2, int val)
296{
297
298 int ret;
299 u8 read_val;
300
301 /*
302 * Since we can't be sure that the events are received
303 * synchronously, we have the check if the main charger is
304 * connected by reading the interrupt source register.
305 */
306 ret = pm2xxx_charger_detection(pm2, &read_val);
307
308 if ((ret == 0) && read_val) {
309 pm2->ac.charger_connected = 1;
310 pm2->ac_conn = true;
311 queue_work(pm2->charger_wq, &pm2->ac_work);
312 }
313
314
315 return ret;
316}
317
318static int pm2xxx_charger_itv_pwr_unplug_mngt(struct pm2xxx_charger *pm2,
319 int val)
320{
321 pm2->ac.charger_connected = 0;
322 queue_work(pm2->charger_wq, &pm2->ac_work);
323
324 return 0;
325}
326
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200327static int pm2_int_reg0(void *pm2_data, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200328{
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200329 struct pm2xxx_charger *pm2 = pm2_data;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200330 int ret = 0;
331
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530332 if (val & PM2XXX_INT1_ITVBATLOWR) {
333 ret = pm2xxx_charger_vbat_lsig_mngt(pm2,
334 PM2XXX_INT1_ITVBATLOWR);
335 if (ret < 0)
336 goto out;
337 }
338
339 if (val & PM2XXX_INT1_ITVBATLOWF) {
340 ret = pm2xxx_charger_vbat_lsig_mngt(pm2,
341 PM2XXX_INT1_ITVBATLOWF);
342 if (ret < 0)
343 goto out;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200344 }
345
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200346 if (val & PM2XXX_INT1_ITVBATDISCONNECT) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200347 ret = pm2xxx_charger_bat_disc_mngt(pm2,
348 PM2XXX_INT1_ITVBATDISCONNECT);
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530349 if (ret < 0)
350 goto out;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200351 }
Rajkumar Kasirajan584f9702012-06-05 12:31:25 +0530352out:
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200353 return ret;
354}
355
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200356static int pm2_int_reg1(void *pm2_data, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200357{
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200358 struct pm2xxx_charger *pm2 = pm2_data;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200359 int ret = 0;
360
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200361 if (val & (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200362 dev_dbg(pm2->dev , "Main charger plugged\n");
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200363 ret = pm2xxx_charger_itv_pwr_plug_mngt(pm2, val &
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200364 (PM2XXX_INT2_ITVPWR1PLUG | PM2XXX_INT2_ITVPWR2PLUG));
365 }
366
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200367 if (val &
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200368 (PM2XXX_INT2_ITVPWR1UNPLUG | PM2XXX_INT2_ITVPWR2UNPLUG)) {
369 dev_dbg(pm2->dev , "Main charger unplugged\n");
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200370 ret = pm2xxx_charger_itv_pwr_unplug_mngt(pm2, val &
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200371 (PM2XXX_INT2_ITVPWR1UNPLUG |
372 PM2XXX_INT2_ITVPWR2UNPLUG));
373 }
374
375 return ret;
376}
377
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200378static int pm2_int_reg2(void *pm2_data, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200379{
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200380 struct pm2xxx_charger *pm2 = pm2_data;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200381 int ret = 0;
382
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200383 if (val & PM2XXX_INT3_ITAUTOTIMEOUTWD)
384 ret = pm2xxx_charger_wd_exp_mngt(pm2, val);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200385
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200386 if (val & (PM2XXX_INT3_ITCHPRECHARGEWD |
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200387 PM2XXX_INT3_ITCHCCWD | PM2XXX_INT3_ITCHCVWD)) {
388 dev_dbg(pm2->dev,
Masanari Iida0b1587b2013-07-17 04:37:44 +0900389 "Watchdog occurred for precharge, CC and CV charge\n");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200390 }
391
392 return ret;
393}
394
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200395static int pm2_int_reg3(void *pm2_data, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200396{
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200397 struct pm2xxx_charger *pm2 = pm2_data;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200398 int ret = 0;
399
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200400 if (val & (PM2XXX_INT4_ITCHARGINGON)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200401 dev_dbg(pm2->dev ,
402 "chargind operation has started\n");
403 }
404
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200405 if (val & (PM2XXX_INT4_ITVRESUME)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200406 dev_dbg(pm2->dev,
407 "battery discharged down to VResume threshold\n");
408 }
409
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200410 if (val & (PM2XXX_INT4_ITBATTFULL)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200411 dev_dbg(pm2->dev , "battery fully detected\n");
412 }
413
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200414 if (val & (PM2XXX_INT4_ITCVPHASE)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200415 dev_dbg(pm2->dev, "CV phase enter with 0.5C charging\n");
416 }
417
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200418 if (val & (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200419 pm2->failure_case = VPWR_OVV;
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200420 ret = pm2xxx_charger_ovv_mngt(pm2, val &
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200421 (PM2XXX_INT4_ITVPWR2OVV | PM2XXX_INT4_ITVPWR1OVV));
422 dev_dbg(pm2->dev, "VPWR/VSYSTEM overvoltage detected\n");
423 }
424
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200425 if (val & (PM2XXX_INT4_S_ITBATTEMPCOLD |
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200426 PM2XXX_INT4_S_ITBATTEMPHOT)) {
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200427 ret = pm2xxx_charger_batt_therm_mngt(pm2, val &
428 (PM2XXX_INT4_S_ITBATTEMPCOLD |
429 PM2XXX_INT4_S_ITBATTEMPHOT));
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200430 dev_dbg(pm2->dev, "BTEMP is too Low/High\n");
431 }
432
433 return ret;
434}
435
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200436static int pm2_int_reg4(void *pm2_data, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200437{
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200438 struct pm2xxx_charger *pm2 = pm2_data;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200439 int ret = 0;
440
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200441 if (val & PM2XXX_INT5_ITVSYSTEMOVV) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200442 pm2->failure_case = VSYSTEM_OVV;
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200443 ret = pm2xxx_charger_ovv_mngt(pm2, val &
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200444 PM2XXX_INT5_ITVSYSTEMOVV);
445 dev_dbg(pm2->dev, "VSYSTEM overvoltage detected\n");
446 }
447
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200448 if (val & (PM2XXX_INT5_ITTHERMALWARNINGFALL |
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200449 PM2XXX_INT5_ITTHERMALWARNINGRISE |
450 PM2XXX_INT5_ITTHERMALSHUTDOWNFALL |
451 PM2XXX_INT5_ITTHERMALSHUTDOWNRISE)) {
452 dev_dbg(pm2->dev, "BTEMP die temperature is too Low/High\n");
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200453 ret = pm2xxx_charger_die_therm_mngt(pm2, val &
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200454 (PM2XXX_INT5_ITTHERMALWARNINGFALL |
455 PM2XXX_INT5_ITTHERMALWARNINGRISE |
456 PM2XXX_INT5_ITTHERMALSHUTDOWNFALL |
457 PM2XXX_INT5_ITTHERMALSHUTDOWNRISE));
458 }
459
460 return ret;
461}
462
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200463static int pm2_int_reg5(void *pm2_data, int val)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200464{
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200465 struct pm2xxx_charger *pm2 = pm2_data;
466 int ret = 0;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200467
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200468 if (val & (PM2XXX_INT6_ITVPWR2DROP | PM2XXX_INT6_ITVPWR1DROP)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200469 dev_dbg(pm2->dev, "VMPWR drop to VBAT level\n");
470 }
471
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200472 if (val & (PM2XXX_INT6_ITVPWR2VALIDRISE |
473 PM2XXX_INT6_ITVPWR1VALIDRISE |
474 PM2XXX_INT6_ITVPWR2VALIDFALL |
475 PM2XXX_INT6_ITVPWR1VALIDFALL)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200476 dev_dbg(pm2->dev, "Falling/Rising edge on WPWR1/2\n");
477 }
478
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200479 return ret;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200480}
481
482static irqreturn_t pm2xxx_irq_int(int irq, void *data)
483{
484 struct pm2xxx_charger *pm2 = data;
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200485 struct pm2xxx_interrupts *interrupt = pm2->pm2_int;
486 int i;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200487
Lee Jonesaee2b842013-02-25 14:28:59 +0000488 /* wake up the device */
489 pm_runtime_get_sync(pm2->dev);
490
M BenZoubeirf4095a02012-09-13 10:34:18 +0200491 do {
492 for (i = 0; i < PM2XXX_NUM_INT_REG; i++) {
493 pm2xxx_reg_read(pm2,
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200494 pm2xxx_interrupt_registers[i],
495 &(interrupt->reg[i]));
496
M BenZoubeirf4095a02012-09-13 10:34:18 +0200497 if (interrupt->reg[i] > 0)
498 interrupt->handler[i](pm2, interrupt->reg[i]);
499 }
500 } while (gpio_get_value(pm2->pdata->gpio_irq_number) == 0);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200501
Lee Jonesaee2b842013-02-25 14:28:59 +0000502 pm_runtime_mark_last_busy(pm2->dev);
503 pm_runtime_put_autosuspend(pm2->dev);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200504
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200505 return IRQ_HANDLED;
506}
507
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200508static int pm2xxx_charger_get_ac_cv(struct pm2xxx_charger *pm2)
509{
510 int ret = 0;
511 u8 val;
512
513 if (pm2->ac.charger_connected && pm2->ac.charger_online) {
514
515 ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &val);
516 if (ret < 0) {
517 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
518 goto out;
519 }
520
521 if (val & PM2XXX_INT4_S_ITCVPHASE)
522 ret = PM2XXX_CONST_VOLT;
523 else
524 ret = PM2XXX_CONST_CURR;
525 }
526out:
527 return ret;
528}
529
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200530static int pm2xxx_current_to_regval(int curr)
531{
532 int i;
533
534 if (curr < pm2xxx_charger_current_map[0])
535 return 0;
536
537 for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_current_map); i++) {
538 if (curr < pm2xxx_charger_current_map[i])
539 return (i - 1);
540 }
541
542 i = ARRAY_SIZE(pm2xxx_charger_current_map) - 1;
543 if (curr == pm2xxx_charger_current_map[i])
544 return i;
545 else
546 return -EINVAL;
547}
548
549static int pm2xxx_voltage_to_regval(int curr)
550{
551 int i;
552
553 if (curr < pm2xxx_charger_voltage_map[0])
554 return 0;
555
556 for (i = 1; i < ARRAY_SIZE(pm2xxx_charger_voltage_map); i++) {
557 if (curr < pm2xxx_charger_voltage_map[i])
558 return i - 1;
559 }
560
561 i = ARRAY_SIZE(pm2xxx_charger_voltage_map) - 1;
562 if (curr == pm2xxx_charger_voltage_map[i])
563 return i;
564 else
565 return -EINVAL;
566}
567
568static int pm2xxx_charger_update_charger_current(struct ux500_charger *charger,
569 int ich_out)
570{
571 int ret;
572 int curr_index;
573 struct pm2xxx_charger *pm2;
574 u8 val;
575
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100576 if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200577 pm2 = to_pm2xxx_charger_ac_device_info(charger);
578 else
579 return -ENXIO;
580
581 curr_index = pm2xxx_current_to_regval(ich_out);
582 if (curr_index < 0) {
583 dev_err(pm2->dev,
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200584 "Charger current too high, charging not started\n");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200585 return -ENXIO;
586 }
587
588 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val);
589 if (ret >= 0) {
590 val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK;
591 val |= curr_index;
592 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val);
593 if (ret < 0) {
594 dev_err(pm2->dev,
595 "%s write failed\n", __func__);
596 }
597 }
598 else
599 dev_err(pm2->dev, "%s read failed\n", __func__);
600
601 return ret;
602}
603
604static int pm2xxx_charger_ac_get_property(struct power_supply *psy,
605 enum power_supply_property psp,
606 union power_supply_propval *val)
607{
608 struct pm2xxx_charger *pm2;
609
610 pm2 = to_pm2xxx_charger_ac_device_info(psy_to_ux500_charger(psy));
611
612 switch (psp) {
613 case POWER_SUPPLY_PROP_HEALTH:
614 if (pm2->flags.mainextchnotok)
615 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
616 else if (pm2->ac.wd_expired)
617 val->intval = POWER_SUPPLY_HEALTH_DEAD;
618 else if (pm2->flags.main_thermal_prot)
619 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
Rupesh Kumar789ca7b2012-06-19 10:21:24 +0530620 else if (pm2->flags.ovv)
621 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200622 else
623 val->intval = POWER_SUPPLY_HEALTH_GOOD;
624 break;
625 case POWER_SUPPLY_PROP_ONLINE:
626 val->intval = pm2->ac.charger_online;
627 break;
628 case POWER_SUPPLY_PROP_PRESENT:
629 val->intval = pm2->ac.charger_connected;
630 break;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200631 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
632 pm2->ac.cv_active = pm2xxx_charger_get_ac_cv(pm2);
633 val->intval = pm2->ac.cv_active;
634 break;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200635 default:
636 return -EINVAL;
637 }
638 return 0;
639}
640
641static int pm2xxx_charging_init(struct pm2xxx_charger *pm2)
642{
643 int ret = 0;
644
645 /* enable CC and CV watchdog */
646 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG3,
647 (PM2XXX_CH_WD_CV_PHASE_60MIN | PM2XXX_CH_WD_CC_PHASE_60MIN));
648 if( ret < 0)
649 return ret;
650
651 /* enable precharge watchdog */
652 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG4,
653 PM2XXX_CH_WD_PRECH_PHASE_60MIN);
654
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200655 /* Disable auto timeout */
656 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG5,
657 PM2XXX_CH_WD_AUTO_TIMEOUT_20MIN);
658
659 /*
660 * EOC current level = 100mA
661 * Precharge current level = 100mA
662 * CC current level = 1000mA
663 */
664 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6,
665 (PM2XXX_DIR_CH_CC_CURRENT_1000MA |
666 PM2XXX_CH_PRECH_CURRENT_100MA |
667 PM2XXX_CH_EOC_CURRENT_100MA));
668
669 /*
670 * recharge threshold = 3.8V
671 * Precharge to CC threshold = 2.9V
672 */
673 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG7,
674 (PM2XXX_CH_PRECH_VOL_2_9 | PM2XXX_CH_VRESUME_VOL_3_8));
675
676 /* float voltage charger level = 4.2V */
677 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8,
678 PM2XXX_CH_VOLT_4_2);
679
680 /* Voltage drop between VBAT and VSYS in HW charging = 300mV */
681 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG9,
682 (PM2XXX_CH_150MV_DROP_300MV | PM2XXX_CHARCHING_INFO_DIS |
683 PM2XXX_CH_CC_REDUCED_CURRENT_IDENT |
684 PM2XXX_CH_CC_MODEDROP_DIS));
685
686 /* Input charger level of over voltage = 10V */
687 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR2,
688 PM2XXX_VPWR2_OVV_10);
689 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_VOLT_VPWR1,
690 PM2XXX_VPWR1_OVV_10);
691
692 /* Input charger drop */
693 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR2,
694 (PM2XXX_VPWR2_HW_OPT_DIS | PM2XXX_VPWR2_VALID_DIS |
695 PM2XXX_VPWR2_DROP_DIS));
696 ret = pm2xxx_reg_write(pm2, PM2XXX_INP_DROP_VPWR1,
697 (PM2XXX_VPWR1_HW_OPT_DIS | PM2XXX_VPWR1_VALID_DIS |
698 PM2XXX_VPWR1_DROP_DIS));
699
700 /* Disable battery low monitoring */
701 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_LOW_LEV_COMP_REG,
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530702 PM2XXX_VBAT_LOW_MONITORING_ENA);
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200703
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200704 return ret;
705}
706
707static int pm2xxx_charger_ac_en(struct ux500_charger *charger,
708 int enable, int vset, int iset)
709{
710 int ret;
711 int volt_index;
712 int curr_index;
713 u8 val;
714
715 struct pm2xxx_charger *pm2 = to_pm2xxx_charger_ac_device_info(charger);
716
717 if (enable) {
718 if (!pm2->ac.charger_connected) {
719 dev_dbg(pm2->dev, "AC charger not connected\n");
720 return -ENXIO;
721 }
722
723 dev_dbg(pm2->dev, "Enable AC: %dmV %dmA\n", vset, iset);
724 if (!pm2->vddadc_en_ac) {
Sachin Kamat508b2c12013-09-06 13:31:11 +0530725 ret = regulator_enable(pm2->regu);
726 if (ret)
727 dev_warn(pm2->dev,
728 "Failed to enable vddadc regulator\n");
729 else
730 pm2->vddadc_en_ac = true;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200731 }
732
733 ret = pm2xxx_charging_init(pm2);
734 if (ret < 0) {
735 dev_err(pm2->dev, "%s charging init failed\n",
736 __func__);
737 goto error_occured;
738 }
739
740 volt_index = pm2xxx_voltage_to_regval(vset);
741 curr_index = pm2xxx_current_to_regval(iset);
742
743 if (volt_index < 0 || curr_index < 0) {
744 dev_err(pm2->dev,
745 "Charger voltage or current too high, "
746 "charging not started\n");
747 return -ENXIO;
748 }
749
750 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG8, &val);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530751 if (ret < 0) {
752 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
753 goto error_occured;
754 }
755 val &= ~PM2XXX_CH_VOLT_MASK;
756 val |= volt_index;
757 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG8, val);
758 if (ret < 0) {
759 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
760 goto error_occured;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200761 }
762
763 ret = pm2xxx_reg_read(pm2, PM2XXX_BATT_CTRL_REG6, &val);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530764 if (ret < 0) {
765 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
766 goto error_occured;
767 }
768 val &= ~PM2XXX_DIR_CH_CC_CURRENT_MASK;
769 val |= curr_index;
770 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_CTRL_REG6, val);
771 if (ret < 0) {
772 dev_err(pm2->dev, "%s pm2xxx write failed\n", __func__);
773 goto error_occured;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200774 }
775
776 if (!pm2->bat->enable_overshoot) {
777 ret = pm2xxx_reg_read(pm2, PM2XXX_LED_CTRL_REG, &val);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530778 if (ret < 0) {
779 dev_err(pm2->dev, "%s pm2xxx read failed\n",
780 __func__);
781 goto error_occured;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200782 }
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530783 val |= PM2XXX_ANTI_OVERSHOOT_EN;
784 ret = pm2xxx_reg_write(pm2, PM2XXX_LED_CTRL_REG, val);
785 if (ret < 0) {
786 dev_err(pm2->dev, "%s pm2xxx write failed\n",
787 __func__);
788 goto error_occured;
789 }
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200790 }
791
792 ret = pm2xxx_charging_enable_mngt(pm2);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530793 if (ret < 0) {
794 dev_err(pm2->dev, "Failed to enable"
795 "pm2xxx ac charger\n");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200796 goto error_occured;
797 }
798
799 pm2->ac.charger_online = 1;
800 } else {
801 pm2->ac.charger_online = 0;
802 pm2->ac.wd_expired = false;
803
804 /* Disable regulator if enabled */
805 if (pm2->vddadc_en_ac) {
806 regulator_disable(pm2->regu);
807 pm2->vddadc_en_ac = false;
808 }
809
810 ret = pm2xxx_charging_disable_mngt(pm2);
Rajkumar Kasirajane41f39e2012-05-28 15:57:33 +0530811 if (ret < 0) {
812 dev_err(pm2->dev, "failed to disable"
813 "pm2xxx ac charger\n");
814 goto error_occured;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200815 }
816
817 dev_dbg(pm2->dev, "PM2301: " "Disabled AC charging\n");
818 }
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100819 power_supply_changed(pm2->ac_chg.psy);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200820
821error_occured:
822 return ret;
823}
824
825static int pm2xxx_charger_watchdog_kick(struct ux500_charger *charger)
826{
827 int ret;
828 struct pm2xxx_charger *pm2;
829
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100830 if (charger->psy->desc->type == POWER_SUPPLY_TYPE_MAINS)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200831 pm2 = to_pm2xxx_charger_ac_device_info(charger);
832 else
833 return -ENXIO;
834
835 ret = pm2xxx_reg_write(pm2, PM2XXX_BATT_WD_KICK, WD_TIMER);
836 if (ret)
837 dev_err(pm2->dev, "Failed to kick WD!\n");
838
839 return ret;
840}
841
842static void pm2xxx_charger_ac_work(struct work_struct *work)
843{
844 struct pm2xxx_charger *pm2 = container_of(work,
845 struct pm2xxx_charger, ac_work);
846
847
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100848 power_supply_changed(pm2->ac_chg.psy);
849 sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200850};
851
Rupesh Kumar789ca7b2012-06-19 10:21:24 +0530852static void pm2xxx_charger_check_hw_failure_work(struct work_struct *work)
853{
854 u8 reg_value;
855
856 struct pm2xxx_charger *pm2 = container_of(work,
857 struct pm2xxx_charger, check_hw_failure_work.work);
858
859 if (pm2->flags.ovv) {
860 pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT4, &reg_value);
861
862 if (!(reg_value & (PM2XXX_INT4_S_ITVPWR1OVV |
863 PM2XXX_INT4_S_ITVPWR2OVV))) {
864 pm2->flags.ovv = false;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100865 power_supply_changed(pm2->ac_chg.psy);
Rupesh Kumar789ca7b2012-06-19 10:21:24 +0530866 }
867 }
868
869 /* If we still have a failure, schedule a new check */
870 if (pm2->flags.ovv) {
871 queue_delayed_work(pm2->charger_wq,
872 &pm2->check_hw_failure_work, round_jiffies(HZ));
873 }
874}
875
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200876static void pm2xxx_charger_check_main_thermal_prot_work(
877 struct work_struct *work)
878{
Rupesh Kumarda9e83d2012-07-16 12:45:19 +0530879 int ret;
880 u8 val;
881
882 struct pm2xxx_charger *pm2 = container_of(work, struct pm2xxx_charger,
883 check_main_thermal_prot_work);
884
885 /* Check if die temp warning is still active */
886 ret = pm2xxx_reg_read(pm2, PM2XXX_SRCE_REG_INT5, &val);
887 if (ret < 0) {
888 dev_err(pm2->dev, "%s pm2xxx read failed\n", __func__);
889 return;
890 }
891 if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGRISE
892 | PM2XXX_INT5_S_ITTHERMALSHUTDOWNRISE))
893 pm2->flags.main_thermal_prot = true;
894 else if (val & (PM2XXX_INT5_S_ITTHERMALWARNINGFALL
895 | PM2XXX_INT5_S_ITTHERMALSHUTDOWNFALL))
896 pm2->flags.main_thermal_prot = false;
897
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +0100898 power_supply_changed(pm2->ac_chg.psy);
Rupesh Kumarda9e83d2012-07-16 12:45:19 +0530899}
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200900
Olivier Clergeaud006f82d2012-05-14 16:50:29 +0200901static struct pm2xxx_interrupts pm2xxx_int = {
902 .handler[0] = pm2_int_reg0,
903 .handler[1] = pm2_int_reg1,
904 .handler[2] = pm2_int_reg2,
905 .handler[3] = pm2_int_reg3,
906 .handler[4] = pm2_int_reg4,
907 .handler[5] = pm2_int_reg5,
908};
909
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200910static struct pm2xxx_irq pm2xxx_charger_irq[] = {
911 {"PM2XXX_IRQ_INT", pm2xxx_irq_int},
912};
913
Arnd Bergmann0df6e322016-03-02 16:58:56 +0100914static int __maybe_unused pm2xxx_wall_charger_resume(struct device *dev)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200915{
Lars-Peter Clausen6b170802013-04-13 13:20:07 +0200916 struct i2c_client *i2c_client = to_i2c_client(dev);
Mustapha Ben Zoubeir49fddee2012-06-27 15:40:58 +0200917 struct pm2xxx_charger *pm2;
918
919 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client);
920 set_lpn_pin(pm2);
921
922 /* If we still have a HW failure, schedule a new check */
923 if (pm2->flags.ovv)
924 queue_delayed_work(pm2->charger_wq,
925 &pm2->check_hw_failure_work, 0);
926
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200927 return 0;
928}
929
Arnd Bergmann0df6e322016-03-02 16:58:56 +0100930static int __maybe_unused pm2xxx_wall_charger_suspend(struct device *dev)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200931{
Lars-Peter Clausen6b170802013-04-13 13:20:07 +0200932 struct i2c_client *i2c_client = to_i2c_client(dev);
Mustapha Ben Zoubeir49fddee2012-06-27 15:40:58 +0200933 struct pm2xxx_charger *pm2;
934
935 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(i2c_client);
936 clear_lpn_pin(pm2);
937
938 /* Cancel any pending HW failure check */
939 if (delayed_work_pending(&pm2->check_hw_failure_work))
940 cancel_delayed_work(&pm2->check_hw_failure_work);
941
942 flush_work(&pm2->ac_work);
943 flush_work(&pm2->check_main_thermal_prot_work);
944
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200945 return 0;
946}
947
Arnd Bergmann0df6e322016-03-02 16:58:56 +0100948static int __maybe_unused pm2xxx_runtime_suspend(struct device *dev)
Lee Jonesaee2b842013-02-25 14:28:59 +0000949{
950 struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev);
951 struct pm2xxx_charger *pm2;
Lee Jonesaee2b842013-02-25 14:28:59 +0000952
953 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client);
Lee Jonesaee2b842013-02-25 14:28:59 +0000954 clear_lpn_pin(pm2);
955
Dan Carpenterc8024232013-11-07 11:06:17 +0300956 return 0;
Lee Jonesaee2b842013-02-25 14:28:59 +0000957}
958
Arnd Bergmann0df6e322016-03-02 16:58:56 +0100959static int __maybe_unused pm2xxx_runtime_resume(struct device *dev)
Lee Jonesaee2b842013-02-25 14:28:59 +0000960{
961 struct i2c_client *pm2xxx_i2c_client = to_i2c_client(dev);
962 struct pm2xxx_charger *pm2;
Lee Jonesaee2b842013-02-25 14:28:59 +0000963
964 pm2 = (struct pm2xxx_charger *)i2c_get_clientdata(pm2xxx_i2c_client);
Lee Jonesaee2b842013-02-25 14:28:59 +0000965
966 if (gpio_is_valid(pm2->lpn_pin) && gpio_get_value(pm2->lpn_pin) == 0)
967 set_lpn_pin(pm2);
968
Dan Carpenterc8024232013-11-07 11:06:17 +0300969 return 0;
Lee Jonesaee2b842013-02-25 14:28:59 +0000970}
971
Arnd Bergmann0df6e322016-03-02 16:58:56 +0100972static const struct dev_pm_ops pm2xxx_pm_ops __maybe_unused = {
Lars-Peter Clausen6b170802013-04-13 13:20:07 +0200973 SET_SYSTEM_SLEEP_PM_OPS(pm2xxx_wall_charger_suspend,
974 pm2xxx_wall_charger_resume)
975 SET_RUNTIME_PM_OPS(pm2xxx_runtime_suspend, pm2xxx_runtime_resume, NULL)
Lee Jonesaee2b842013-02-25 14:28:59 +0000976};
Lee Jonesaee2b842013-02-25 14:28:59 +0000977
Lee Jones116c3262013-02-25 14:26:52 +0000978static int pm2xxx_wall_charger_probe(struct i2c_client *i2c_client,
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200979 const struct i2c_device_id *id)
980{
981 struct pm2xxx_platform_data *pl_data = i2c_client->dev.platform_data;
Krzysztof Kozlowski2dc92152015-03-12 08:44:02 +0100982 struct power_supply_config psy_cfg = {};
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200983 struct pm2xxx_charger *pm2;
984 int ret = 0;
985 u8 val;
M BenZoubeirf4095a02012-09-13 10:34:18 +0200986 int i;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200987
Axel Lindf3113332013-05-16 17:31:00 +0800988 if (!pl_data) {
989 dev_err(&i2c_client->dev, "No platform data supplied\n");
990 return -EINVAL;
991 }
992
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200993 pm2 = kzalloc(sizeof(struct pm2xxx_charger), GFP_KERNEL);
994 if (!pm2) {
Axel Lindf3113332013-05-16 17:31:00 +0800995 dev_err(&i2c_client->dev, "pm2xxx_charger allocation failed\n");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +0200996 return -ENOMEM;
997 }
998
999 /* get parent data */
1000 pm2->dev = &i2c_client->dev;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001001
Olivier Clergeaud006f82d2012-05-14 16:50:29 +02001002 pm2->pm2_int = &pm2xxx_int;
1003
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001004 /* get charger spcific platform data */
1005 if (!pl_data->wall_charger) {
1006 dev_err(pm2->dev, "no charger platform data supplied\n");
1007 ret = -EINVAL;
1008 goto free_device_info;
1009 }
1010
1011 pm2->pdata = pl_data->wall_charger;
1012
1013 /* get battery specific platform data */
1014 if (!pl_data->battery) {
1015 dev_err(pm2->dev, "no battery platform data supplied\n");
1016 ret = -EINVAL;
1017 goto free_device_info;
1018 }
1019
1020 pm2->bat = pl_data->battery;
1021
1022 if (!i2c_check_functionality(i2c_client->adapter,
1023 I2C_FUNC_SMBUS_BYTE_DATA |
1024 I2C_FUNC_SMBUS_READ_WORD_DATA)) {
1025 ret = -ENODEV;
1026 dev_info(pm2->dev, "pm2301 i2c_check_functionality failed\n");
1027 goto free_device_info;
1028 }
1029
1030 pm2->config.pm2xxx_i2c = i2c_client;
1031 pm2->config.pm2xxx_id = (struct i2c_device_id *) id;
1032 i2c_set_clientdata(i2c_client, pm2);
1033
1034 /* AC supply */
1035 /* power_supply base class */
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001036 pm2->ac_chg_desc.name = pm2->pdata->label;
1037 pm2->ac_chg_desc.type = POWER_SUPPLY_TYPE_MAINS;
1038 pm2->ac_chg_desc.properties = pm2xxx_charger_ac_props;
1039 pm2->ac_chg_desc.num_properties = ARRAY_SIZE(pm2xxx_charger_ac_props);
1040 pm2->ac_chg_desc.get_property = pm2xxx_charger_ac_get_property;
Krzysztof Kozlowski2dc92152015-03-12 08:44:02 +01001041
1042 psy_cfg.supplied_to = pm2->pdata->supplied_to;
1043 psy_cfg.num_supplicants = pm2->pdata->num_supplicants;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001044 /* 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];
Loic Pallardye07a5642012-05-10 15:33:56 +02001052 pm2->ac_chg.wdt_refresh = WD_KICK_INTERVAL;
Olivier Clergeaud006f82d2012-05-14 16:50:29 +02001053 pm2->ac_chg.enabled = true;
Loic Pallardye07a5642012-05-10 15:33:56 +02001054 pm2->ac_chg.external = true;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001055
1056 /* Create a work queue for the charger */
Axel Linc509a622013-05-16 21:17:04 +08001057 pm2->charger_wq = create_singlethread_workqueue("pm2xxx_charger_wq");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001058 if (pm2->charger_wq == NULL) {
Axel Linc509a622013-05-16 21:17:04 +08001059 ret = -ENOMEM;
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001060 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
Rupesh Kumar789ca7b2012-06-19 10:21:24 +05301071 /* Init work for HW failure check */
1072 INIT_DEFERRABLE_WORK(&pm2->check_hw_failure_work,
1073 pm2xxx_charger_check_hw_failure_work);
1074
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001075 /*
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 */
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001088 pm2->ac_chg.psy = power_supply_register(pm2->dev, &pm2->ac_chg_desc,
1089 &psy_cfg);
1090 if (IS_ERR(pm2->ac_chg.psy)) {
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001091 dev_err(pm2->dev, "failed to register AC charger\n");
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001092 ret = PTR_ERR(pm2->ac_chg.psy);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001093 goto free_regulator;
1094 }
1095
1096 /* Register interrupts */
M BenZoubeirf4095a02012-09-13 10:34:18 +02001097 ret = request_threaded_irq(gpio_to_irq(pm2->pdata->gpio_irq_number),
1098 NULL,
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001099 pm2xxx_charger_irq[0].isr,
1100 pm2->pdata->irq_type,
1101 pm2xxx_charger_irq[0].name, pm2);
1102
1103 if (ret != 0) {
1104 dev_err(pm2->dev, "failed to request %s IRQ %d: %d\n",
M BenZoubeirf4095a02012-09-13 10:34:18 +02001105 pm2xxx_charger_irq[0].name,
1106 gpio_to_irq(pm2->pdata->gpio_irq_number), ret);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001107 goto unregister_pm2xxx_charger;
1108 }
1109
Lee Jonesaee2b842013-02-25 14:28:59 +00001110 ret = pm_runtime_set_active(pm2->dev);
1111 if (ret)
1112 dev_err(pm2->dev, "set active Error\n");
1113
1114 pm_runtime_enable(pm2->dev);
1115 pm_runtime_set_autosuspend_delay(pm2->dev, PM2XXX_AUTOSUSPEND_DELAY);
1116 pm_runtime_use_autosuspend(pm2->dev);
1117 pm_runtime_resume(pm2->dev);
1118
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301119 /* pm interrupt can wake up system */
M BenZoubeirf4095a02012-09-13 10:34:18 +02001120 ret = enable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301121 if (ret) {
1122 dev_err(pm2->dev, "failed to set irq wake\n");
1123 goto unregister_pm2xxx_interrupt;
1124 }
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001125
Lee Jones39880432013-01-23 14:38:15 +00001126 mutex_init(&pm2->lock);
1127
lme00437a21e22f2012-11-13 14:43:48 +01001128 if (gpio_is_valid(pm2->pdata->lpn_gpio)) {
1129 /* get lpn GPIO from platform data */
1130 pm2->lpn_pin = pm2->pdata->lpn_gpio;
Lee Jones39880432013-01-23 14:38:15 +00001131
lme00437a21e22f2012-11-13 14:43:48 +01001132 /*
1133 * Charger detection mechanism requires pulling up the LPN pin
1134 * while i2c communication if Charger is not connected
1135 * LPN pin of PM2301 is GPIO60 of AB9540
1136 */
1137 ret = gpio_request(pm2->lpn_pin, "pm2301_lpm_gpio");
1138
1139 if (ret < 0) {
1140 dev_err(pm2->dev, "pm2301_lpm_gpio request failed\n");
1141 goto disable_pm2_irq_wake;
1142 }
1143 ret = gpio_direction_output(pm2->lpn_pin, 0);
1144 if (ret < 0) {
1145 dev_err(pm2->dev, "pm2301_lpm_gpio direction failed\n");
1146 goto free_gpio;
1147 }
1148 set_lpn_pin(pm2);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001149 }
M BenZoubeirf4095a02012-09-13 10:34:18 +02001150
1151 /* read interrupt registers */
1152 for (i = 0; i < PM2XXX_NUM_INT_REG; i++)
1153 pm2xxx_reg_read(pm2,
1154 pm2xxx_interrupt_registers[i],
1155 &val);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001156
1157 ret = pm2xxx_charger_detection(pm2, &val);
1158
1159 if ((ret == 0) && val) {
1160 pm2->ac.charger_connected = 1;
Per Forlin54fbbb62012-07-05 16:52:55 +02001161 ab8500_override_turn_on_stat(~AB8500_POW_KEY_1_ON,
1162 AB8500_MAIN_CH_DET);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001163 pm2->ac_conn = true;
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001164 power_supply_changed(pm2->ac_chg.psy);
1165 sysfs_notify(&pm2->ac_chg.psy->dev.kobj, NULL, "present");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001166 }
1167
1168 return 0;
1169
Lee Jones39880432013-01-23 14:38:15 +00001170free_gpio:
lme00437a21e22f2012-11-13 14:43:48 +01001171 if (gpio_is_valid(pm2->lpn_pin))
1172 gpio_free(pm2->lpn_pin);
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301173disable_pm2_irq_wake:
M BenZoubeirf4095a02012-09-13 10:34:18 +02001174 disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301175unregister_pm2xxx_interrupt:
1176 /* disable interrupt */
M BenZoubeirf4095a02012-09-13 10:34:18 +02001177 free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001178unregister_pm2xxx_charger:
1179 /* unregister power supply */
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001180 power_supply_unregister(pm2->ac_chg.psy);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001181free_regulator:
1182 /* disable the regulator */
1183 regulator_put(pm2->regu);
1184free_charger_wq:
1185 destroy_workqueue(pm2->charger_wq);
1186free_device_info:
1187 kfree(pm2);
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301188
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001189 return ret;
1190}
1191
Lee Jones116c3262013-02-25 14:26:52 +00001192static int pm2xxx_wall_charger_remove(struct i2c_client *i2c_client)
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001193{
1194 struct pm2xxx_charger *pm2 = i2c_get_clientdata(i2c_client);
1195
Lee Jonesaee2b842013-02-25 14:28:59 +00001196 /* Disable pm_runtime */
1197 pm_runtime_disable(pm2->dev);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001198 /* Disable AC charging */
1199 pm2xxx_charger_ac_en(&pm2->ac_chg, false, 0, 0);
1200
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301201 /* Disable wake by pm interrupt */
M BenZoubeirf4095a02012-09-13 10:34:18 +02001202 disable_irq_wake(gpio_to_irq(pm2->pdata->gpio_irq_number));
Rupesh Kumard4f510f2012-06-28 18:31:19 +05301203
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001204 /* Disable interrupts */
M BenZoubeirf4095a02012-09-13 10:34:18 +02001205 free_irq(gpio_to_irq(pm2->pdata->gpio_irq_number), pm2);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001206
1207 /* Delete the work queue */
1208 destroy_workqueue(pm2->charger_wq);
1209
1210 flush_scheduled_work();
1211
1212 /* disable the regulator */
1213 regulator_put(pm2->regu);
1214
Krzysztof Kozlowski297d7162015-03-12 08:44:11 +01001215 power_supply_unregister(pm2->ac_chg.psy);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001216
lme00437a21e22f2012-11-13 14:43:48 +01001217 if (gpio_is_valid(pm2->lpn_pin))
1218 gpio_free(pm2->lpn_pin);
Lee Jones39880432013-01-23 14:38:15 +00001219
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001220 kfree(pm2);
1221
1222 return 0;
1223}
1224
1225static const struct i2c_device_id pm2xxx_id[] = {
1226 { "pm2301", 0 },
1227 { }
1228};
1229
1230MODULE_DEVICE_TABLE(i2c, pm2xxx_id);
1231
1232static struct i2c_driver pm2xxx_charger_driver = {
1233 .probe = pm2xxx_wall_charger_probe,
Lee Jones116c3262013-02-25 14:26:52 +00001234 .remove = pm2xxx_wall_charger_remove,
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001235 .driver = {
1236 .name = "pm2xxx-wall_charger",
Arnd Bergmann0df6e322016-03-02 16:58:56 +01001237 .pm = IS_ENABLED(CONFIG_PM) ? &pm2xxx_pm_ops : NULL,
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001238 },
1239 .id_table = pm2xxx_id,
1240};
1241
1242static int __init pm2xxx_charger_init(void)
1243{
1244 return i2c_add_driver(&pm2xxx_charger_driver);
1245}
1246
1247static void __exit pm2xxx_charger_exit(void)
1248{
1249 i2c_del_driver(&pm2xxx_charger_driver);
1250}
1251
lme00437a21e22f2012-11-13 14:43:48 +01001252device_initcall_sync(pm2xxx_charger_init);
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001253module_exit(pm2xxx_charger_exit);
1254
1255MODULE_LICENSE("GPL v2");
1256MODULE_AUTHOR("Rajkumar kasirajan, Olivier Launay");
Michel JAOUEN01ec8c52012-04-26 10:00:04 +02001257MODULE_DESCRIPTION("PM2xxx charger management driver");