?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
tmpfs mempolicy: fix /proc/mounts corrupting memory
[linux-2.6/linux-acpi-2.6/ibm-acpi-2.6.git] / drivers / power / ab8500_charger.c
blob3be9c0ee3fc58a2c016cb9509ceb316c54312b5f
1 /*
2 * Copyright (C) ST-Ericsson SA 2012
3 *
4 * Charger driver for AB8500
5 *
6 * License Terms: GNU General Public License v2
7 * Author:
8 * Johan Palsson <johan.palsson@stericsson.com>
9 * Karl Komierowski <karl.komierowski@stericsson.com>
10 * Arun R Murthy <arun.murthy@stericsson.com>
11 */
12
13 #include <linux/init.h>
14 #include <linux/module.h>
15 #include <linux/device.h>
16 #include <linux/interrupt.h>
17 #include <linux/delay.h>
18 #include <linux/slab.h>
19 #include <linux/platform_device.h>
20 #include <linux/power_supply.h>
21 #include <linux/completion.h>
22 #include <linux/regulator/consumer.h>
23 #include <linux/err.h>
24 #include <linux/workqueue.h>
25 #include <linux/kobject.h>
26 #include <linux/of.h>
27 #include <linux/mfd/core.h>
28 #include <linux/mfd/abx500/ab8500.h>
29 #include <linux/mfd/abx500.h>
30 #include <linux/mfd/abx500/ab8500-bm.h>
31 #include <linux/mfd/abx500/ab8500-gpadc.h>
32 #include <linux/mfd/abx500/ux500_chargalg.h>
33 #include <linux/usb/otg.h>
34
35 /* Charger constants */
36 #define NO_PW_CONN 0
37 #define AC_PW_CONN 1
38 #define USB_PW_CONN 2
39
40 #define MAIN_WDOG_ENA 0x01
41 #define MAIN_WDOG_KICK 0x02
42 #define MAIN_WDOG_DIS 0x00
43 #define CHARG_WD_KICK 0x01
44 #define MAIN_CH_ENA 0x01
45 #define MAIN_CH_NO_OVERSHOOT_ENA_N 0x02
46 #define USB_CH_ENA 0x01
47 #define USB_CHG_NO_OVERSHOOT_ENA_N 0x02
48 #define MAIN_CH_DET 0x01
49 #define MAIN_CH_CV_ON 0x04
50 #define USB_CH_CV_ON 0x08
51 #define VBUS_DET_DBNC100 0x02
52 #define VBUS_DET_DBNC1 0x01
53 #define OTP_ENABLE_WD 0x01
54
55 #define MAIN_CH_INPUT_CURR_SHIFT 4
56 #define VBUS_IN_CURR_LIM_SHIFT 4
57
58 #define LED_INDICATOR_PWM_ENA 0x01
59 #define LED_INDICATOR_PWM_DIS 0x00
60 #define LED_IND_CUR_5MA 0x04
61 #define LED_INDICATOR_PWM_DUTY_252_256 0xBF
62
63 /* HW failure constants */
64 #define MAIN_CH_TH_PROT 0x02
65 #define VBUS_CH_NOK 0x08
66 #define USB_CH_TH_PROT 0x02
67 #define VBUS_OVV_TH 0x01
68 #define MAIN_CH_NOK 0x01
69 #define VBUS_DET 0x80
70
71 /* UsbLineStatus register bit masks */
72 #define AB8500_USB_LINK_STATUS 0x78
73 #define AB8500_STD_HOST_SUSP 0x18
74
75 /* Watchdog timeout constant */
76 #define WD_TIMER 0x30 /* 4min */
77 #define WD_KICK_INTERVAL (60 * HZ)
78
79 /* Lowest charger voltage is 3.39V -> 0x4E */
80 #define LOW_VOLT_REG 0x4E
81
82 /* UsbLineStatus register - usb types */
83 enum ab8500_charger_link_status {
84 USB_STAT_NOT_CONFIGURED,
85 USB_STAT_STD_HOST_NC,
86 USB_STAT_STD_HOST_C_NS,
87 USB_STAT_STD_HOST_C_S,
88 USB_STAT_HOST_CHG_NM,
89 USB_STAT_HOST_CHG_HS,
90 USB_STAT_HOST_CHG_HS_CHIRP,
91 USB_STAT_DEDICATED_CHG,
92 USB_STAT_ACA_RID_A,
93 USB_STAT_ACA_RID_B,
94 USB_STAT_ACA_RID_C_NM,
95 USB_STAT_ACA_RID_C_HS,
96 USB_STAT_ACA_RID_C_HS_CHIRP,
97 USB_STAT_HM_IDGND,
98 USB_STAT_RESERVED,
99 USB_STAT_NOT_VALID_LINK,
100 };
101
102 enum ab8500_usb_state {
103 AB8500_BM_USB_STATE_RESET_HS, /* HighSpeed Reset */
104 AB8500_BM_USB_STATE_RESET_FS, /* FullSpeed/LowSpeed Reset */
105 AB8500_BM_USB_STATE_CONFIGURED,
106 AB8500_BM_USB_STATE_SUSPEND,
107 AB8500_BM_USB_STATE_RESUME,
108 AB8500_BM_USB_STATE_MAX,
109 };
110
111 /* VBUS input current limits supported in AB8500 in mA */
112 #define USB_CH_IP_CUR_LVL_0P05 50
113 #define USB_CH_IP_CUR_LVL_0P09 98
114 #define USB_CH_IP_CUR_LVL_0P19 193
115 #define USB_CH_IP_CUR_LVL_0P29 290
116 #define USB_CH_IP_CUR_LVL_0P38 380
117 #define USB_CH_IP_CUR_LVL_0P45 450
118 #define USB_CH_IP_CUR_LVL_0P5 500
119 #define USB_CH_IP_CUR_LVL_0P6 600
120 #define USB_CH_IP_CUR_LVL_0P7 700
121 #define USB_CH_IP_CUR_LVL_0P8 800
122 #define USB_CH_IP_CUR_LVL_0P9 900
123 #define USB_CH_IP_CUR_LVL_1P0 1000
124 #define USB_CH_IP_CUR_LVL_1P1 1100
125 #define USB_CH_IP_CUR_LVL_1P3 1300
126 #define USB_CH_IP_CUR_LVL_1P4 1400
127 #define USB_CH_IP_CUR_LVL_1P5 1500
128
129 #define VBAT_TRESH_IP_CUR_RED 3800
130
131 #define to_ab8500_charger_usb_device_info(x) container_of((x), \
132 struct ab8500_charger, usb_chg)
133 #define to_ab8500_charger_ac_device_info(x) container_of((x), \
134 struct ab8500_charger, ac_chg)
135
136 /**
137 * struct ab8500_charger_interrupts - ab8500 interupts
138 * @name: name of the interrupt
139 * @isr function pointer to the isr
140 */
141 struct ab8500_charger_interrupts {
142 char *name;
143 irqreturn_t (*isr)(int irq, void *data);
144 };
145
146 struct ab8500_charger_info {
147 int charger_connected;
148 int charger_online;
149 int charger_voltage;
150 int cv_active;
151 bool wd_expired;
152 };
153
154 struct ab8500_charger_event_flags {
155 bool mainextchnotok;
156 bool main_thermal_prot;
157 bool usb_thermal_prot;
158 bool vbus_ovv;
159 bool usbchargernotok;
160 bool chgwdexp;
161 bool vbus_collapse;
162 };
163
164 struct ab8500_charger_usb_state {
165 bool usb_changed;
166 int usb_current;
167 enum ab8500_usb_state state;
168 spinlock_t usb_lock;
169 };
170
171 /**
172 * struct ab8500_charger - ab8500 Charger device information
173 * @dev: Pointer to the structure device
174 * @max_usb_in_curr: Max USB charger input current
175 * @vbus_detected: VBUS detected
176 * @vbus_detected_start:
177 * VBUS detected during startup
178 * @ac_conn: This will be true when the AC charger has been plugged
179 * @vddadc_en_ac: Indicate if VDD ADC supply is enabled because AC
180 * charger is enabled
181 * @vddadc_en_usb: Indicate if VDD ADC supply is enabled because USB
182 * charger is enabled
183 * @vbat Battery voltage
184 * @old_vbat Previously measured battery voltage
185 * @autopower Indicate if we should have automatic pwron after pwrloss
186 * @autopower_cfg platform specific power config support for "pwron after pwrloss"
187 * @parent: Pointer to the struct ab8500
188 * @gpadc: Pointer to the struct gpadc
189 * @bat: Pointer to the abx500_bm platform data
190 * @flags: Structure for information about events triggered
191 * @usb_state: Structure for usb stack information
192 * @ac_chg: AC charger power supply
193 * @usb_chg: USB charger power supply
194 * @ac: Structure that holds the AC charger properties
195 * @usb: Structure that holds the USB charger properties
196 * @regu: Pointer to the struct regulator
197 * @charger_wq: Work queue for the IRQs and checking HW state
198 * @check_vbat_work Work for checking vbat threshold to adjust vbus current
199 * @check_hw_failure_work: Work for checking HW state
200 * @check_usbchgnotok_work: Work for checking USB charger not ok status
201 * @kick_wd_work: Work for kicking the charger watchdog in case
202 * of ABB rev 1.* due to the watchog logic bug
203 * @ac_work: Work for checking AC charger connection
204 * @detect_usb_type_work: Work for detecting the USB type connected
205 * @usb_link_status_work: Work for checking the new USB link status
206 * @usb_state_changed_work: Work for checking USB state
207 * @check_main_thermal_prot_work:
208 * Work for checking Main thermal status
209 * @check_usb_thermal_prot_work:
210 * Work for checking USB thermal status
211 */
212 struct ab8500_charger {
213 struct device *dev;
214 int max_usb_in_curr;
215 bool vbus_detected;
216 bool vbus_detected_start;
217 bool ac_conn;
218 bool vddadc_en_ac;
219 bool vddadc_en_usb;
220 int vbat;
221 int old_vbat;
222 bool autopower;
223 bool autopower_cfg;
224 struct ab8500 *parent;
225 struct ab8500_gpadc *gpadc;
226 struct abx500_bm_data *bat;
227 struct ab8500_charger_event_flags flags;
228 struct ab8500_charger_usb_state usb_state;
229 struct ux500_charger ac_chg;
230 struct ux500_charger usb_chg;
231 struct ab8500_charger_info ac;
232 struct ab8500_charger_info usb;
233 struct regulator *regu;
234 struct workqueue_struct *charger_wq;
235 struct delayed_work check_vbat_work;
236 struct delayed_work check_hw_failure_work;
237 struct delayed_work check_usbchgnotok_work;
238 struct delayed_work kick_wd_work;
239 struct work_struct ac_work;
240 struct work_struct detect_usb_type_work;
241 struct work_struct usb_link_status_work;
242 struct work_struct usb_state_changed_work;
243 struct work_struct check_main_thermal_prot_work;
244 struct work_struct check_usb_thermal_prot_work;
245 struct usb_phy *usb_phy;
246 struct notifier_block nb;
247 };
248
249 /* AC properties */
250 static enum power_supply_property ab8500_charger_ac_props[] = {
251 POWER_SUPPLY_PROP_HEALTH,
252 POWER_SUPPLY_PROP_PRESENT,
253 POWER_SUPPLY_PROP_ONLINE,
254 POWER_SUPPLY_PROP_VOLTAGE_NOW,
255 POWER_SUPPLY_PROP_VOLTAGE_AVG,
256 POWER_SUPPLY_PROP_CURRENT_NOW,
257 };
258
259 /* USB properties */
260 static enum power_supply_property ab8500_charger_usb_props[] = {
261 POWER_SUPPLY_PROP_HEALTH,
262 POWER_SUPPLY_PROP_CURRENT_AVG,
263 POWER_SUPPLY_PROP_PRESENT,
264 POWER_SUPPLY_PROP_ONLINE,
265 POWER_SUPPLY_PROP_VOLTAGE_NOW,
266 POWER_SUPPLY_PROP_VOLTAGE_AVG,
267 POWER_SUPPLY_PROP_CURRENT_NOW,
268 };
269
270 /**
271 * ab8500_power_loss_handling - set how we handle powerloss.
272 * @di: pointer to the ab8500_charger structure
273 *
274 * Magic nummbers are from STE HW department.
275 */
276 static void ab8500_power_loss_handling(struct ab8500_charger *di)
277 {
278 u8 reg;
279 int ret;
280
281 dev_dbg(di->dev, "Autopower : %d\n", di->autopower);
282
283 /* read the autopower register */
284 ret = abx500_get_register_interruptible(di->dev, 0x15, 0x00, &reg);
285 if (ret) {
286 dev_err(di->dev, "%d write failed\n", __LINE__);
287 return;
288 }
289
290 /* enable the OPT emulation registers */
291 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
292 if (ret) {
293 dev_err(di->dev, "%d write failed\n", __LINE__);
294 return;
295 }
296
297 if (di->autopower)
298 reg |= 0x8;
299 else
300 reg &= ~0x8;
301
302 /* write back the changed value to autopower reg */
303 ret = abx500_set_register_interruptible(di->dev, 0x15, 0x00, reg);
304 if (ret) {
305 dev_err(di->dev, "%d write failed\n", __LINE__);
306 return;
307 }
308
309 /* disable the set OTP registers again */
310 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
311 if (ret) {
312 dev_err(di->dev, "%d write failed\n", __LINE__);
313 return;
314 }
315 }
316
317 /**
318 * ab8500_power_supply_changed - a wrapper with local extentions for
319 * power_supply_changed
320 * @di: pointer to the ab8500_charger structure
321 * @psy: pointer to power_supply_that have changed.
322 *
323 */
324 static void ab8500_power_supply_changed(struct ab8500_charger *di,
325 struct power_supply *psy)
326 {
327 if (di->autopower_cfg) {
328 if (!di->usb.charger_connected &&
329 !di->ac.charger_connected &&
330 di->autopower) {
331 di->autopower = false;
332 ab8500_power_loss_handling(di);
333 } else if (!di->autopower &&
334 (di->ac.charger_connected ||
335 di->usb.charger_connected)) {
336 di->autopower = true;
337 ab8500_power_loss_handling(di);
338 }
339 }
340 power_supply_changed(psy);
341 }
342
343 static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
344 bool connected)
345 {
346 if (connected != di->usb.charger_connected) {
347 dev_dbg(di->dev, "USB connected:%i\n", connected);
348 di->usb.charger_connected = connected;
349 sysfs_notify(&di->usb_chg.psy.dev->kobj, NULL, "present");
350 }
351 }
352
353 /**
354 * ab8500_charger_get_ac_voltage() - get ac charger voltage
355 * @di: pointer to the ab8500_charger structure
356 *
357 * Returns ac charger voltage (on success)
358 */
359 static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
360 {
361 int vch;
362
363 /* Only measure voltage if the charger is connected */
364 if (di->ac.charger_connected) {
365 vch = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_V);
366 if (vch < 0)
367 dev_err(di->dev, "%s gpadc conv failed,\n", __func__);
368 } else {
369 vch = 0;
370 }
371 return vch;
372 }
373
374 /**
375 * ab8500_charger_ac_cv() - check if the main charger is in CV mode
376 * @di: pointer to the ab8500_charger structure
377 *
378 * Returns ac charger CV mode (on success) else error code
379 */
380 static int ab8500_charger_ac_cv(struct ab8500_charger *di)
381 {
382 u8 val;
383 int ret = 0;
384
385 /* Only check CV mode if the charger is online */
386 if (di->ac.charger_online) {
387 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
388 AB8500_CH_STATUS1_REG, &val);
389 if (ret < 0) {
390 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
391 return 0;
392 }
393
394 if (val & MAIN_CH_CV_ON)
395 ret = 1;
396 else
397 ret = 0;
398 }
399
400 return ret;
401 }
402
403 /**
404 * ab8500_charger_get_vbus_voltage() - get vbus voltage
405 * @di: pointer to the ab8500_charger structure
406 *
407 * This function returns the vbus voltage.
408 * Returns vbus voltage (on success)
409 */
410 static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
411 {
412 int vch;
413
414 /* Only measure voltage if the charger is connected */
415 if (di->usb.charger_connected) {
416 vch = ab8500_gpadc_convert(di->gpadc, VBUS_V);
417 if (vch < 0)
418 dev_err(di->dev, "%s gpadc conv failed\n", __func__);
419 } else {
420 vch = 0;
421 }
422 return vch;
423 }
424
425 /**
426 * ab8500_charger_get_usb_current() - get usb charger current
427 * @di: pointer to the ab8500_charger structure
428 *
429 * This function returns the usb charger current.
430 * Returns usb current (on success) and error code on failure
431 */
432 static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
433 {
434 int ich;
435
436 /* Only measure current if the charger is online */
437 if (di->usb.charger_online) {
438 ich = ab8500_gpadc_convert(di->gpadc, USB_CHARGER_C);
439 if (ich < 0)
440 dev_err(di->dev, "%s gpadc conv failed\n", __func__);
441 } else {
442 ich = 0;
443 }
444 return ich;
445 }
446
447 /**
448 * ab8500_charger_get_ac_current() - get ac charger current
449 * @di: pointer to the ab8500_charger structure
450 *
451 * This function returns the ac charger current.
452 * Returns ac current (on success) and error code on failure.
453 */
454 static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
455 {
456 int ich;
457
458 /* Only measure current if the charger is online */
459 if (di->ac.charger_online) {
460 ich = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_C);
461 if (ich < 0)
462 dev_err(di->dev, "%s gpadc conv failed\n", __func__);
463 } else {
464 ich = 0;
465 }
466 return ich;
467 }
468
469 /**
470 * ab8500_charger_usb_cv() - check if the usb charger is in CV mode
471 * @di: pointer to the ab8500_charger structure
472 *
473 * Returns ac charger CV mode (on success) else error code
474 */
475 static int ab8500_charger_usb_cv(struct ab8500_charger *di)
476 {
477 int ret;
478 u8 val;
479
480 /* Only check CV mode if the charger is online */
481 if (di->usb.charger_online) {
482 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
483 AB8500_CH_USBCH_STAT1_REG, &val);
484 if (ret < 0) {
485 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
486 return 0;
487 }
488
489 if (val & USB_CH_CV_ON)
490 ret = 1;
491 else
492 ret = 0;
493 } else {
494 ret = 0;
495 }
496
497 return ret;
498 }
499
500 /**
501 * ab8500_charger_detect_chargers() - Detect the connected chargers
502 * @di: pointer to the ab8500_charger structure
503 *
504 * Returns the type of charger connected.
505 * For USB it will not mean we can actually charge from it
506 * but that there is a USB cable connected that we have to
507 * identify. This is used during startup when we don't get
508 * interrupts of the charger detection
509 *
510 * Returns an integer value, that means,
511 * NO_PW_CONN no power supply is connected
512 * AC_PW_CONN if the AC power supply is connected
513 * USB_PW_CONN if the USB power supply is connected
514 * AC_PW_CONN + USB_PW_CONN if USB and AC power supplies are both connected
515 */
516 static int ab8500_charger_detect_chargers(struct ab8500_charger *di)
517 {
518 int result = NO_PW_CONN;
519 int ret;
520 u8 val;
521
522 /* Check for AC charger */
523 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
524 AB8500_CH_STATUS1_REG, &val);
525 if (ret < 0) {
526 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
527 return ret;
528 }
529
530 if (val & MAIN_CH_DET)
531 result = AC_PW_CONN;
532
533 /* Check for USB charger */
534 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
535 AB8500_CH_USBCH_STAT1_REG, &val);
536 if (ret < 0) {
537 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
538 return ret;
539 }
540
541 if ((val & VBUS_DET_DBNC1) && (val & VBUS_DET_DBNC100))
542 result |= USB_PW_CONN;
543
544 return result;
545 }
546
547 /**
548 * ab8500_charger_max_usb_curr() - get the max curr for the USB type
549 * @di: pointer to the ab8500_charger structure
550 * @link_status: the identified USB type
551 *
552 * Get the maximum current that is allowed to be drawn from the host
553 * based on the USB type.
554 * Returns error code in case of failure else 0 on success
555 */
556 static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
557 enum ab8500_charger_link_status link_status)
558 {
559 int ret = 0;
560
561 switch (link_status) {
562 case USB_STAT_STD_HOST_NC:
563 case USB_STAT_STD_HOST_C_NS:
564 case USB_STAT_STD_HOST_C_S:
565 dev_dbg(di->dev, "USB Type - Standard host is "
566 "detected through USB driver\n");
567 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P09;
568 break;
569 case USB_STAT_HOST_CHG_HS_CHIRP:
570 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P5;
571 break;
572 case USB_STAT_HOST_CHG_HS:
573 case USB_STAT_ACA_RID_C_HS:
574 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P9;
575 break;
576 case USB_STAT_ACA_RID_A:
577 /*
578 * Dedicated charger level minus maximum current accessory
579 * can consume (300mA). Closest level is 1100mA
580 */
581 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_1P1;
582 break;
583 case USB_STAT_ACA_RID_B:
584 /*
585 * Dedicated charger level minus 120mA (20mA for ACA and
586 * 100mA for potential accessory). Closest level is 1300mA
587 */
588 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_1P3;
589 break;
590 case USB_STAT_DEDICATED_CHG:
591 case USB_STAT_HOST_CHG_NM:
592 case USB_STAT_ACA_RID_C_HS_CHIRP:
593 case USB_STAT_ACA_RID_C_NM:
594 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_1P5;
595 break;
596 case USB_STAT_RESERVED:
597 /*
598 * This state is used to indicate that VBUS has dropped below
599 * the detection level 4 times in a row. This is due to the
600 * charger output current is set to high making the charger
601 * voltage collapse. This have to be propagated through to
602 * chargalg. This is done using the property
603 * POWER_SUPPLY_PROP_CURRENT_AVG = 1
604 */
605 di->flags.vbus_collapse = true;
606 dev_dbg(di->dev, "USB Type - USB_STAT_RESERVED "
607 "VBUS has collapsed\n");
608 ret = -1;
609 break;
610 case USB_STAT_HM_IDGND:
611 case USB_STAT_NOT_CONFIGURED:
612 case USB_STAT_NOT_VALID_LINK:
613 dev_err(di->dev, "USB Type - Charging not allowed\n");
614 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P05;
615 ret = -ENXIO;
616 break;
617 default:
618 dev_err(di->dev, "USB Type - Unknown\n");
619 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P05;
620 ret = -ENXIO;
621 break;
622 };
623
624 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
625 link_status, di->max_usb_in_curr);
626
627 return ret;
628 }
629
630 /**
631 * ab8500_charger_read_usb_type() - read the type of usb connected
632 * @di: pointer to the ab8500_charger structure
633 *
634 * Detect the type of the plugged USB
635 * Returns error code in case of failure else 0 on success
636 */
637 static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
638 {
639 int ret;
640 u8 val;
641
642 ret = abx500_get_register_interruptible(di->dev,
643 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, &val);
644 if (ret < 0) {
645 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
646 return ret;
647 }
648 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
649 AB8500_USB_LINE_STAT_REG, &val);
650 if (ret < 0) {
651 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
652 return ret;
653 }
654
655 /* get the USB type */
656 val = (val & AB8500_USB_LINK_STATUS) >> 3;
657 ret = ab8500_charger_max_usb_curr(di,
658 (enum ab8500_charger_link_status) val);
659
660 return ret;
661 }
662
663 /**
664 * ab8500_charger_detect_usb_type() - get the type of usb connected
665 * @di: pointer to the ab8500_charger structure
666 *
667 * Detect the type of the plugged USB
668 * Returns error code in case of failure else 0 on success
669 */
670 static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
671 {
672 int i, ret;
673 u8 val;
674
675 /*
676 * On getting the VBUS rising edge detect interrupt there
677 * is a 250ms delay after which the register UsbLineStatus
678 * is filled with valid data.
679 */
680 for (i = 0; i < 10; i++) {
681 msleep(250);
682 ret = abx500_get_register_interruptible(di->dev,
683 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG,
684 &val);
685 if (ret < 0) {
686 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
687 return ret;
688 }
689 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
690 AB8500_USB_LINE_STAT_REG, &val);
691 if (ret < 0) {
692 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
693 return ret;
694 }
695 /*
696 * Until the IT source register is read the UsbLineStatus
697 * register is not updated, hence doing the same
698 * Revisit this:
699 */
700
701 /* get the USB type */
702 val = (val & AB8500_USB_LINK_STATUS) >> 3;
703 if (val)
704 break;
705 }
706 ret = ab8500_charger_max_usb_curr(di,
707 (enum ab8500_charger_link_status) val);
708
709 return ret;
710 }
711
712 /*
713 * This array maps the raw hex value to charger voltage used by the AB8500
714 * Values taken from the UM0836
715 */
716 static int ab8500_charger_voltage_map[] = {
717 3500 ,
718 3525 ,
719 3550 ,
720 3575 ,
721 3600 ,
722 3625 ,
723 3650 ,
724 3675 ,
725 3700 ,
726 3725 ,
727 3750 ,
728 3775 ,
729 3800 ,
730 3825 ,
731 3850 ,
732 3875 ,
733 3900 ,
734 3925 ,
735 3950 ,
736 3975 ,
737 4000 ,
738 4025 ,
739 4050 ,
740 4060 ,
741 4070 ,
742 4080 ,
743 4090 ,
744 4100 ,
745 4110 ,
746 4120 ,
747 4130 ,
748 4140 ,
749 4150 ,
750 4160 ,
751 4170 ,
752 4180 ,
753 4190 ,
754 4200 ,
755 4210 ,
756 4220 ,
757 4230 ,
758 4240 ,
759 4250 ,
760 4260 ,
761 4270 ,
762 4280 ,
763 4290 ,
764 4300 ,
765 4310 ,
766 4320 ,
767 4330 ,
768 4340 ,
769 4350 ,
770 4360 ,
771 4370 ,
772 4380 ,
773 4390 ,
774 4400 ,
775 4410 ,
776 4420 ,
777 4430 ,
778 4440 ,
779 4450 ,
780 4460 ,
781 4470 ,
782 4480 ,
783 4490 ,
784 4500 ,
785 4510 ,
786 4520 ,
787 4530 ,
788 4540 ,
789 4550 ,
790 4560 ,
791 4570 ,
792 4580 ,
793 4590 ,
794 4600 ,
795 };
796
797 /*
798 * This array maps the raw hex value to charger current used by the AB8500
799 * Values taken from the UM0836
800 */
801 static int ab8500_charger_current_map[] = {
802 100 ,
803 200 ,
804 300 ,
805 400 ,
806 500 ,
807 600 ,
808 700 ,
809 800 ,
810 900 ,
811 1000 ,
812 1100 ,
813 1200 ,
814 1300 ,
815 1400 ,
816 1500 ,
817 };
818
819 /*
820 * This array maps the raw hex value to VBUS input current used by the AB8500
821 * Values taken from the UM0836
822 */
823 static int ab8500_charger_vbus_in_curr_map[] = {
824 USB_CH_IP_CUR_LVL_0P05,
825 USB_CH_IP_CUR_LVL_0P09,
826 USB_CH_IP_CUR_LVL_0P19,
827 USB_CH_IP_CUR_LVL_0P29,
828 USB_CH_IP_CUR_LVL_0P38,
829 USB_CH_IP_CUR_LVL_0P45,
830 USB_CH_IP_CUR_LVL_0P5,
831 USB_CH_IP_CUR_LVL_0P6,
832 USB_CH_IP_CUR_LVL_0P7,
833 USB_CH_IP_CUR_LVL_0P8,
834 USB_CH_IP_CUR_LVL_0P9,
835 USB_CH_IP_CUR_LVL_1P0,
836 USB_CH_IP_CUR_LVL_1P1,
837 USB_CH_IP_CUR_LVL_1P3,
838 USB_CH_IP_CUR_LVL_1P4,
839 USB_CH_IP_CUR_LVL_1P5,
840 };
841
842 static int ab8500_voltage_to_regval(int voltage)
843 {
844 int i;
845
846 /* Special case for voltage below 3.5V */
847 if (voltage < ab8500_charger_voltage_map[0])
848 return LOW_VOLT_REG;
849
850 for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) {
851 if (voltage < ab8500_charger_voltage_map[i])
852 return i - 1;
853 }
854
855 /* If not last element, return error */
856 i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1;
857 if (voltage == ab8500_charger_voltage_map[i])
858 return i;
859 else
860 return -1;
861 }
862
863 static int ab8500_current_to_regval(int curr)
864 {
865 int i;
866
867 if (curr < ab8500_charger_current_map[0])
868 return 0;
869
870 for (i = 0; i < ARRAY_SIZE(ab8500_charger_current_map); i++) {
871 if (curr < ab8500_charger_current_map[i])
872 return i - 1;
873 }
874
875 /* If not last element, return error */
876 i = ARRAY_SIZE(ab8500_charger_current_map) - 1;
877 if (curr == ab8500_charger_current_map[i])
878 return i;
879 else
880 return -1;
881 }
882
883 static int ab8500_vbus_in_curr_to_regval(int curr)
884 {
885 int i;
886
887 if (curr < ab8500_charger_vbus_in_curr_map[0])
888 return 0;
889
890 for (i = 0; i < ARRAY_SIZE(ab8500_charger_vbus_in_curr_map); i++) {
891 if (curr < ab8500_charger_vbus_in_curr_map[i])
892 return i - 1;
893 }
894
895 /* If not last element, return error */
896 i = ARRAY_SIZE(ab8500_charger_vbus_in_curr_map) - 1;
897 if (curr == ab8500_charger_vbus_in_curr_map[i])
898 return i;
899 else
900 return -1;
901 }
902
903 /**
904 * ab8500_charger_get_usb_cur() - get usb current
905 * @di: pointer to the ab8500_charger structre
906 *
907 * The usb stack provides the maximum current that can be drawn from
908 * the standard usb host. This will be in mA.
909 * This function converts current in mA to a value that can be written
910 * to the register. Returns -1 if charging is not allowed
911 */
912 static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
913 {
914 switch (di->usb_state.usb_current) {
915 case 100:
916 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P09;
917 break;
918 case 200:
919 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P19;
920 break;
921 case 300:
922 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P29;
923 break;
924 case 400:
925 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P38;
926 break;
927 case 500:
928 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P5;
929 break;
930 default:
931 di->max_usb_in_curr = USB_CH_IP_CUR_LVL_0P05;
932 return -1;
933 break;
934 };
935 return 0;
936 }
937
938 /**
939 * ab8500_charger_set_vbus_in_curr() - set VBUS input current limit
940 * @di: pointer to the ab8500_charger structure
941 * @ich_in: charger input current limit
942 *
943 * Sets the current that can be drawn from the USB host
944 * Returns error code in case of failure else 0(on success)
945 */
946 static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
947 int ich_in)
948 {
949 int ret;
950 int input_curr_index;
951 int min_value;
952
953 /* We should always use to lowest current limit */
954 min_value = min(di->bat->chg_params->usb_curr_max, ich_in);
955
956 switch (min_value) {
957 case 100:
958 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
959 min_value = USB_CH_IP_CUR_LVL_0P05;
960 break;
961 case 500:
962 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
963 min_value = USB_CH_IP_CUR_LVL_0P45;
964 break;
965 default:
966 break;
967 }
968
969 input_curr_index = ab8500_vbus_in_curr_to_regval(min_value);
970 if (input_curr_index < 0) {
971 dev_err(di->dev, "VBUS input current limit too high\n");
972 return -ENXIO;
973 }
974
975 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
976 AB8500_USBCH_IPT_CRNTLVL_REG,
977 input_curr_index << VBUS_IN_CURR_LIM_SHIFT);
978 if (ret)
979 dev_err(di->dev, "%s write failed\n", __func__);
980
981 return ret;
982 }
983
984 /**
985 * ab8500_charger_led_en() - turn on/off chargign led
986 * @di: pointer to the ab8500_charger structure
987 * @on: flag to turn on/off the chargign led
988 *
989 * Power ON/OFF charging LED indication
990 * Returns error code in case of failure else 0(on success)
991 */
992 static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
993 {
994 int ret;
995
996 if (on) {
997 /* Power ON charging LED indicator, set LED current to 5mA */
998 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
999 AB8500_LED_INDICATOR_PWM_CTRL,
1000 (LED_IND_CUR_5MA | LED_INDICATOR_PWM_ENA));
1001 if (ret) {
1002 dev_err(di->dev, "Power ON LED failed\n");
1003 return ret;
1004 }
1005 /* LED indicator PWM duty cycle 252/256 */
1006 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1007 AB8500_LED_INDICATOR_PWM_DUTY,
1008 LED_INDICATOR_PWM_DUTY_252_256);
1009 if (ret) {
1010 dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1011 return ret;
1012 }
1013 } else {
1014 /* Power off charging LED indicator */
1015 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1016 AB8500_LED_INDICATOR_PWM_CTRL,
1017 LED_INDICATOR_PWM_DIS);
1018 if (ret) {
1019 dev_err(di->dev, "Power-off LED failed\n");
1020 return ret;
1021 }
1022 }
1023
1024 return ret;
1025 }
1026
1027 /**
1028 * ab8500_charger_ac_en() - enable or disable ac charging
1029 * @di: pointer to the ab8500_charger structure
1030 * @enable: enable/disable flag
1031 * @vset: charging voltage
1032 * @iset: charging current
1033 *
1034 * Enable/Disable AC/Mains charging and turns on/off the charging led
1035 * respectively.
1036 **/
1037 static int ab8500_charger_ac_en(struct ux500_charger *charger,
1038 int enable, int vset, int iset)
1039 {
1040 int ret;
1041 int volt_index;
1042 int curr_index;
1043 int input_curr_index;
1044 u8 overshoot = 0;
1045
1046 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1047
1048 if (enable) {
1049 /* Check if AC is connected */
1050 if (!di->ac.charger_connected) {
1051 dev_err(di->dev, "AC charger not connected\n");
1052 return -ENXIO;
1053 }
1054
1055 /* Enable AC charging */
1056 dev_dbg(di->dev, "Enable AC: %dmV %dmA\n", vset, iset);
1057
1058 /*
1059 * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1060 * will be triggered everytime we enable the VDD ADC supply.
1061 * This will turn off charging for a short while.
1062 * It can be avoided by having the supply on when
1063 * there is a charger enabled. Normally the VDD ADC supply
1064 * is enabled everytime a GPADC conversion is triggered. We will
1065 * force it to be enabled from this driver to have
1066 * the GPADC module independant of the AB8500 chargers
1067 */
1068 if (!di->vddadc_en_ac) {
1069 regulator_enable(di->regu);
1070 di->vddadc_en_ac = true;
1071 }
1072
1073 /* Check if the requested voltage or current is valid */
1074 volt_index = ab8500_voltage_to_regval(vset);
1075 curr_index = ab8500_current_to_regval(iset);
1076 input_curr_index = ab8500_current_to_regval(
1077 di->bat->chg_params->ac_curr_max);
1078 if (volt_index < 0 || curr_index < 0 || input_curr_index < 0) {
1079 dev_err(di->dev,
1080 "Charger voltage or current too high, "
1081 "charging not started\n");
1082 return -ENXIO;
1083 }
1084
1085 /* ChVoltLevel: maximum battery charging voltage */
1086 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1087 AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1088 if (ret) {
1089 dev_err(di->dev, "%s write failed\n", __func__);
1090 return ret;
1091 }
1092 /* MainChInputCurr: current that can be drawn from the charger*/
1093 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1094 AB8500_MCH_IPT_CURLVL_REG,
1095 input_curr_index << MAIN_CH_INPUT_CURR_SHIFT);
1096 if (ret) {
1097 dev_err(di->dev, "%s write failed\n", __func__);
1098 return ret;
1099 }
1100 /* ChOutputCurentLevel: protected output current */
1101 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1102 AB8500_CH_OPT_CRNTLVL_REG, (u8) curr_index);
1103 if (ret) {
1104 dev_err(di->dev, "%s write failed\n", __func__);
1105 return ret;
1106 }
1107
1108 /* Check if VBAT overshoot control should be enabled */
1109 if (!di->bat->enable_overshoot)
1110 overshoot = MAIN_CH_NO_OVERSHOOT_ENA_N;
1111
1112 /* Enable Main Charger */
1113 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1114 AB8500_MCH_CTRL1, MAIN_CH_ENA | overshoot);
1115 if (ret) {
1116 dev_err(di->dev, "%s write failed\n", __func__);
1117 return ret;
1118 }
1119
1120 /* Power on charging LED indication */
1121 ret = ab8500_charger_led_en(di, true);
1122 if (ret < 0)
1123 dev_err(di->dev, "failed to enable LED\n");
1124
1125 di->ac.charger_online = 1;
1126 } else {
1127 /* Disable AC charging */
1128 if (is_ab8500_1p1_or_earlier(di->parent)) {
1129 /*
1130 * For ABB revision 1.0 and 1.1 there is a bug in the
1131 * watchdog logic. That means we have to continously
1132 * kick the charger watchdog even when no charger is
1133 * connected. This is only valid once the AC charger
1134 * has been enabled. This is a bug that is not handled
1135 * by the algorithm and the watchdog have to be kicked
1136 * by the charger driver when the AC charger
1137 * is disabled
1138 */
1139 if (di->ac_conn) {
1140 queue_delayed_work(di->charger_wq,
1141 &di->kick_wd_work,
1142 round_jiffies(WD_KICK_INTERVAL));
1143 }
1144
1145 /*
1146 * We can't turn off charging completely
1147 * due to a bug in AB8500 cut1.
1148 * If we do, charging will not start again.
1149 * That is why we set the lowest voltage
1150 * and current possible
1151 */
1152 ret = abx500_set_register_interruptible(di->dev,
1153 AB8500_CHARGER,
1154 AB8500_CH_VOLT_LVL_REG, CH_VOL_LVL_3P5);
1155 if (ret) {
1156 dev_err(di->dev,
1157 "%s write failed\n", __func__);
1158 return ret;
1159 }
1160
1161 ret = abx500_set_register_interruptible(di->dev,
1162 AB8500_CHARGER,
1163 AB8500_CH_OPT_CRNTLVL_REG, CH_OP_CUR_LVL_0P1);
1164 if (ret) {
1165 dev_err(di->dev,
1166 "%s write failed\n", __func__);
1167 return ret;
1168 }
1169 } else {
1170 ret = abx500_set_register_interruptible(di->dev,
1171 AB8500_CHARGER,
1172 AB8500_MCH_CTRL1, 0);
1173 if (ret) {
1174 dev_err(di->dev,
1175 "%s write failed\n", __func__);
1176 return ret;
1177 }
1178 }
1179
1180 ret = ab8500_charger_led_en(di, false);
1181 if (ret < 0)
1182 dev_err(di->dev, "failed to disable LED\n");
1183
1184 di->ac.charger_online = 0;
1185 di->ac.wd_expired = false;
1186
1187 /* Disable regulator if enabled */
1188 if (di->vddadc_en_ac) {
1189 regulator_disable(di->regu);
1190 di->vddadc_en_ac = false;
1191 }
1192
1193 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1194 }
1195 ab8500_power_supply_changed(di, &di->ac_chg.psy);
1196
1197 return ret;
1198 }
1199
1200 /**
1201 * ab8500_charger_usb_en() - enable usb charging
1202 * @di: pointer to the ab8500_charger structure
1203 * @enable: enable/disable flag
1204 * @vset: charging voltage
1205 * @ich_out: charger output current
1206 *
1207 * Enable/Disable USB charging and turns on/off the charging led respectively.
1208 * Returns error code in case of failure else 0(on success)
1209 */
1210 static int ab8500_charger_usb_en(struct ux500_charger *charger,
1211 int enable, int vset, int ich_out)
1212 {
1213 int ret;
1214 int volt_index;
1215 int curr_index;
1216 u8 overshoot = 0;
1217
1218 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1219
1220 if (enable) {
1221 /* Check if USB is connected */
1222 if (!di->usb.charger_connected) {
1223 dev_err(di->dev, "USB charger not connected\n");
1224 return -ENXIO;
1225 }
1226
1227 /*
1228 * Due to a bug in AB8500, BTEMP_HIGH/LOW interrupts
1229 * will be triggered everytime we enable the VDD ADC supply.
1230 * This will turn off charging for a short while.
1231 * It can be avoided by having the supply on when
1232 * there is a charger enabled. Normally the VDD ADC supply
1233 * is enabled everytime a GPADC conversion is triggered. We will
1234 * force it to be enabled from this driver to have
1235 * the GPADC module independant of the AB8500 chargers
1236 */
1237 if (!di->vddadc_en_usb) {
1238 regulator_enable(di->regu);
1239 di->vddadc_en_usb = true;
1240 }
1241
1242 /* Enable USB charging */
1243 dev_dbg(di->dev, "Enable USB: %dmV %dmA\n", vset, ich_out);
1244
1245 /* Check if the requested voltage or current is valid */
1246 volt_index = ab8500_voltage_to_regval(vset);
1247 curr_index = ab8500_current_to_regval(ich_out);
1248 if (volt_index < 0 || curr_index < 0) {
1249 dev_err(di->dev,
1250 "Charger voltage or current too high, "
1251 "charging not started\n");
1252 return -ENXIO;
1253 }
1254
1255 /* ChVoltLevel: max voltage upto which battery can be charged */
1256 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1257 AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1258 if (ret) {
1259 dev_err(di->dev, "%s write failed\n", __func__);
1260 return ret;
1261 }
1262 /* USBChInputCurr: current that can be drawn from the usb */
1263 ret = ab8500_charger_set_vbus_in_curr(di, di->max_usb_in_curr);
1264 if (ret) {
1265 dev_err(di->dev, "setting USBChInputCurr failed\n");
1266 return ret;
1267 }
1268 /* ChOutputCurentLevel: protected output current */
1269 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1270 AB8500_CH_OPT_CRNTLVL_REG, (u8) curr_index);
1271 if (ret) {
1272 dev_err(di->dev, "%s write failed\n", __func__);
1273 return ret;
1274 }
1275 /* Check if VBAT overshoot control should be enabled */
1276 if (!di->bat->enable_overshoot)
1277 overshoot = USB_CHG_NO_OVERSHOOT_ENA_N;
1278
1279 /* Enable USB Charger */
1280 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1281 AB8500_USBCH_CTRL1_REG, USB_CH_ENA | overshoot);
1282 if (ret) {
1283 dev_err(di->dev, "%s write failed\n", __func__);
1284 return ret;
1285 }
1286
1287 /* If success power on charging LED indication */
1288 ret = ab8500_charger_led_en(di, true);
1289 if (ret < 0)
1290 dev_err(di->dev, "failed to enable LED\n");
1291
1292 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1293
1294 di->usb.charger_online = 1;
1295 } else {
1296 /* Disable USB charging */
1297 ret = abx500_set_register_interruptible(di->dev,
1298 AB8500_CHARGER,
1299 AB8500_USBCH_CTRL1_REG, 0);
1300 if (ret) {
1301 dev_err(di->dev,
1302 "%s write failed\n", __func__);
1303 return ret;
1304 }
1305
1306 ret = ab8500_charger_led_en(di, false);
1307 if (ret < 0)
1308 dev_err(di->dev, "failed to disable LED\n");
1309
1310 di->usb.charger_online = 0;
1311 di->usb.wd_expired = false;
1312
1313 /* Disable regulator if enabled */
1314 if (di->vddadc_en_usb) {
1315 regulator_disable(di->regu);
1316 di->vddadc_en_usb = false;
1317 }
1318
1319 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1320
1321 /* Cancel any pending Vbat check work */
1322 if (delayed_work_pending(&di->check_vbat_work))
1323 cancel_delayed_work(&di->check_vbat_work);
1324
1325 }
1326 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1327
1328 return ret;
1329 }
1330
1331 /**
1332 * ab8500_charger_watchdog_kick() - kick charger watchdog
1333 * @di: pointer to the ab8500_charger structure
1334 *
1335 * Kick charger watchdog
1336 * Returns error code in case of failure else 0(on success)
1337 */
1338 static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1339 {
1340 int ret;
1341 struct ab8500_charger *di;
1342
1343 if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
1344 di = to_ab8500_charger_ac_device_info(charger);
1345 else if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1346 di = to_ab8500_charger_usb_device_info(charger);
1347 else
1348 return -ENXIO;
1349
1350 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1351 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1352 if (ret)
1353 dev_err(di->dev, "Failed to kick WD!\n");
1354
1355 return ret;
1356 }
1357
1358 /**
1359 * ab8500_charger_update_charger_current() - update charger current
1360 * @di: pointer to the ab8500_charger structure
1361 *
1362 * Update the charger output current for the specified charger
1363 * Returns error code in case of failure else 0(on success)
1364 */
1365 static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1366 int ich_out)
1367 {
1368 int ret;
1369 int curr_index;
1370 struct ab8500_charger *di;
1371
1372 if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
1373 di = to_ab8500_charger_ac_device_info(charger);
1374 else if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1375 di = to_ab8500_charger_usb_device_info(charger);
1376 else
1377 return -ENXIO;
1378
1379 curr_index = ab8500_current_to_regval(ich_out);
1380 if (curr_index < 0) {
1381 dev_err(di->dev,
1382 "Charger current too high, "
1383 "charging not started\n");
1384 return -ENXIO;
1385 }
1386
1387 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1388 AB8500_CH_OPT_CRNTLVL_REG, (u8) curr_index);
1389 if (ret) {
1390 dev_err(di->dev, "%s write failed\n", __func__);
1391 return ret;
1392 }
1393
1394 /* Reset the main and usb drop input current measurement counter */
1395 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1396 AB8500_CHARGER_CTRL,
1397 0x1);
1398 if (ret) {
1399 dev_err(di->dev, "%s write failed\n", __func__);
1400 return ret;
1401 }
1402
1403 return ret;
1404 }
1405
1406 static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1407 {
1408 struct power_supply *psy;
1409 struct power_supply *ext;
1410 struct ab8500_charger *di;
1411 union power_supply_propval ret;
1412 int i, j;
1413 bool psy_found = false;
1414 struct ux500_charger *usb_chg;
1415
1416 usb_chg = (struct ux500_charger *)data;
1417 psy = &usb_chg->psy;
1418
1419 di = to_ab8500_charger_usb_device_info(usb_chg);
1420
1421 ext = dev_get_drvdata(dev);
1422
1423 /* For all psy where the driver name appears in any supplied_to */
1424 for (i = 0; i < ext->num_supplicants; i++) {
1425 if (!strcmp(ext->supplied_to[i], psy->name))
1426 psy_found = true;
1427 }
1428
1429 if (!psy_found)
1430 return 0;
1431
1432 /* Go through all properties for the psy */
1433 for (j = 0; j < ext->num_properties; j++) {
1434 enum power_supply_property prop;
1435 prop = ext->properties[j];
1436
1437 if (ext->get_property(ext, prop, &ret))
1438 continue;
1439
1440 switch (prop) {
1441 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1442 switch (ext->type) {
1443 case POWER_SUPPLY_TYPE_BATTERY:
1444 di->vbat = ret.intval / 1000;
1445 break;
1446 default:
1447 break;
1448 }
1449 break;
1450 default:
1451 break;
1452 }
1453 }
1454 return 0;
1455 }
1456
1457 /**
1458 * ab8500_charger_check_vbat_work() - keep vbus current within spec
1459 * @work pointer to the work_struct structure
1460 *
1461 * Due to a asic bug it is necessary to lower the input current to the vbus
1462 * charger when charging with at some specific levels. This issue is only valid
1463 * for below a certain battery voltage. This function makes sure that the
1464 * the allowed current limit isn't exceeded.
1465 */
1466 static void ab8500_charger_check_vbat_work(struct work_struct *work)
1467 {
1468 int t = 10;
1469 struct ab8500_charger *di = container_of(work,
1470 struct ab8500_charger, check_vbat_work.work);
1471
1472 class_for_each_device(power_supply_class, NULL,
1473 &di->usb_chg.psy, ab8500_charger_get_ext_psy_data);
1474
1475 /* First run old_vbat is 0. */
1476 if (di->old_vbat == 0)
1477 di->old_vbat = di->vbat;
1478
1479 if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1480 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1481 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1482 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1483
1484 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
1485 " old: %d\n", di->max_usb_in_curr, di->vbat,
1486 di->old_vbat);
1487 ab8500_charger_set_vbus_in_curr(di, di->max_usb_in_curr);
1488 power_supply_changed(&di->usb_chg.psy);
1489 }
1490
1491 di->old_vbat = di->vbat;
1492
1493 /*
1494 * No need to check the battery voltage every second when not close to
1495 * the threshold.
1496 */
1497 if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) &&
1498 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100)))
1499 t = 1;
1500
1501 queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
1502 }
1503
1504 /**
1505 * ab8500_charger_check_hw_failure_work() - check main charger failure
1506 * @work: pointer to the work_struct structure
1507 *
1508 * Work queue function for checking the main charger status
1509 */
1510 static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
1511 {
1512 int ret;
1513 u8 reg_value;
1514
1515 struct ab8500_charger *di = container_of(work,
1516 struct ab8500_charger, check_hw_failure_work.work);
1517
1518 /* Check if the status bits for HW failure is still active */
1519 if (di->flags.mainextchnotok) {
1520 ret = abx500_get_register_interruptible(di->dev,
1521 AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
1522 if (ret < 0) {
1523 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1524 return;
1525 }
1526 if (!(reg_value & MAIN_CH_NOK)) {
1527 di->flags.mainextchnotok = false;
1528 ab8500_power_supply_changed(di, &di->ac_chg.psy);
1529 }
1530 }
1531 if (di->flags.vbus_ovv) {
1532 ret = abx500_get_register_interruptible(di->dev,
1533 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
1534 &reg_value);
1535 if (ret < 0) {
1536 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1537 return;
1538 }
1539 if (!(reg_value & VBUS_OVV_TH)) {
1540 di->flags.vbus_ovv = false;
1541 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1542 }
1543 }
1544 /* If we still have a failure, schedule a new check */
1545 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
1546 queue_delayed_work(di->charger_wq,
1547 &di->check_hw_failure_work, round_jiffies(HZ));
1548 }
1549 }
1550
1551 /**
1552 * ab8500_charger_kick_watchdog_work() - kick the watchdog
1553 * @work: pointer to the work_struct structure
1554 *
1555 * Work queue function for kicking the charger watchdog.
1556 *
1557 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
1558 * logic. That means we have to continously kick the charger
1559 * watchdog even when no charger is connected. This is only
1560 * valid once the AC charger has been enabled. This is
1561 * a bug that is not handled by the algorithm and the
1562 * watchdog have to be kicked by the charger driver
1563 * when the AC charger is disabled
1564 */
1565 static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
1566 {
1567 int ret;
1568
1569 struct ab8500_charger *di = container_of(work,
1570 struct ab8500_charger, kick_wd_work.work);
1571
1572 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1573 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1574 if (ret)
1575 dev_err(di->dev, "Failed to kick WD!\n");
1576
1577 /* Schedule a new watchdog kick */
1578 queue_delayed_work(di->charger_wq,
1579 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
1580 }
1581
1582 /**
1583 * ab8500_charger_ac_work() - work to get and set main charger status
1584 * @work: pointer to the work_struct structure
1585 *
1586 * Work queue function for checking the main charger status
1587 */
1588 static void ab8500_charger_ac_work(struct work_struct *work)
1589 {
1590 int ret;
1591
1592 struct ab8500_charger *di = container_of(work,
1593 struct ab8500_charger, ac_work);
1594
1595 /*
1596 * Since we can't be sure that the events are received
1597 * synchronously, we have the check if the main charger is
1598 * connected by reading the status register
1599 */
1600 ret = ab8500_charger_detect_chargers(di);
1601 if (ret < 0)
1602 return;
1603
1604 if (ret & AC_PW_CONN) {
1605 di->ac.charger_connected = 1;
1606 di->ac_conn = true;
1607 } else {
1608 di->ac.charger_connected = 0;
1609 }
1610
1611 ab8500_power_supply_changed(di, &di->ac_chg.psy);
1612 sysfs_notify(&di->ac_chg.psy.dev->kobj, NULL, "present");
1613 }
1614
1615 /**
1616 * ab8500_charger_detect_usb_type_work() - work to detect USB type
1617 * @work: Pointer to the work_struct structure
1618 *
1619 * Detect the type of USB plugged
1620 */
1621 static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
1622 {
1623 int ret;
1624
1625 struct ab8500_charger *di = container_of(work,
1626 struct ab8500_charger, detect_usb_type_work);
1627
1628 /*
1629 * Since we can't be sure that the events are received
1630 * synchronously, we have the check if is
1631 * connected by reading the status register
1632 */
1633 ret = ab8500_charger_detect_chargers(di);
1634 if (ret < 0)
1635 return;
1636
1637 if (!(ret & USB_PW_CONN)) {
1638 di->vbus_detected = 0;
1639 ab8500_charger_set_usb_connected(di, false);
1640 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1641 } else {
1642 di->vbus_detected = 1;
1643
1644 if (is_ab8500_1p1_or_earlier(di->parent)) {
1645 ret = ab8500_charger_detect_usb_type(di);
1646 if (!ret) {
1647 ab8500_charger_set_usb_connected(di, true);
1648 ab8500_power_supply_changed(di,
1649 &di->usb_chg.psy);
1650 }
1651 } else {
1652 /* For ABB cut2.0 and onwards we have an IRQ,
1653 * USB_LINK_STATUS that will be triggered when the USB
1654 * link status changes. The exception is USB connected
1655 * during startup. Then we don't get a
1656 * USB_LINK_STATUS IRQ
1657 */
1658 if (di->vbus_detected_start) {
1659 di->vbus_detected_start = false;
1660 ret = ab8500_charger_detect_usb_type(di);
1661 if (!ret) {
1662 ab8500_charger_set_usb_connected(di,
1663 true);
1664 ab8500_power_supply_changed(di,
1665 &di->usb_chg.psy);
1666 }
1667 }
1668 }
1669 }
1670 }
1671
1672 /**
1673 * ab8500_charger_usb_link_status_work() - work to detect USB type
1674 * @work: pointer to the work_struct structure
1675 *
1676 * Detect the type of USB plugged
1677 */
1678 static void ab8500_charger_usb_link_status_work(struct work_struct *work)
1679 {
1680 int ret;
1681
1682 struct ab8500_charger *di = container_of(work,
1683 struct ab8500_charger, usb_link_status_work);
1684
1685 /*
1686 * Since we can't be sure that the events are received
1687 * synchronously, we have the check if is
1688 * connected by reading the status register
1689 */
1690 ret = ab8500_charger_detect_chargers(di);
1691 if (ret < 0)
1692 return;
1693
1694 if (!(ret & USB_PW_CONN)) {
1695 di->vbus_detected = 0;
1696 ab8500_charger_set_usb_connected(di, false);
1697 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1698 } else {
1699 di->vbus_detected = 1;
1700 ret = ab8500_charger_read_usb_type(di);
1701 if (!ret) {
1702 /* Update maximum input current */
1703 ret = ab8500_charger_set_vbus_in_curr(di,
1704 di->max_usb_in_curr);
1705 if (ret)
1706 return;
1707
1708 ab8500_charger_set_usb_connected(di, true);
1709 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1710 } else if (ret == -ENXIO) {
1711 /* No valid charger type detected */
1712 ab8500_charger_set_usb_connected(di, false);
1713 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1714 }
1715 }
1716 }
1717
1718 static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
1719 {
1720 int ret;
1721 unsigned long flags;
1722
1723 struct ab8500_charger *di = container_of(work,
1724 struct ab8500_charger, usb_state_changed_work);
1725
1726 if (!di->vbus_detected)
1727 return;
1728
1729 spin_lock_irqsave(&di->usb_state.usb_lock, flags);
1730 di->usb_state.usb_changed = false;
1731 spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
1732
1733 /*
1734 * wait for some time until you get updates from the usb stack
1735 * and negotiations are completed
1736 */
1737 msleep(250);
1738
1739 if (di->usb_state.usb_changed)
1740 return;
1741
1742 dev_dbg(di->dev, "%s USB state: 0x%02x mA: %d\n",
1743 __func__, di->usb_state.state, di->usb_state.usb_current);
1744
1745 switch (di->usb_state.state) {
1746 case AB8500_BM_USB_STATE_RESET_HS:
1747 case AB8500_BM_USB_STATE_RESET_FS:
1748 case AB8500_BM_USB_STATE_SUSPEND:
1749 case AB8500_BM_USB_STATE_MAX:
1750 ab8500_charger_set_usb_connected(di, false);
1751 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1752 break;
1753
1754 case AB8500_BM_USB_STATE_RESUME:
1755 /*
1756 * when suspend->resume there should be delay
1757 * of 1sec for enabling charging
1758 */
1759 msleep(1000);
1760 /* Intentional fall through */
1761 case AB8500_BM_USB_STATE_CONFIGURED:
1762 /*
1763 * USB is configured, enable charging with the charging
1764 * input current obtained from USB driver
1765 */
1766 if (!ab8500_charger_get_usb_cur(di)) {
1767 /* Update maximum input current */
1768 ret = ab8500_charger_set_vbus_in_curr(di,
1769 di->max_usb_in_curr);
1770 if (ret)
1771 return;
1772
1773 ab8500_charger_set_usb_connected(di, true);
1774 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1775 }
1776 break;
1777
1778 default:
1779 break;
1780 };
1781 }
1782
1783 /**
1784 * ab8500_charger_check_usbchargernotok_work() - check USB chg not ok status
1785 * @work: pointer to the work_struct structure
1786 *
1787 * Work queue function for checking the USB charger Not OK status
1788 */
1789 static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
1790 {
1791 int ret;
1792 u8 reg_value;
1793 bool prev_status;
1794
1795 struct ab8500_charger *di = container_of(work,
1796 struct ab8500_charger, check_usbchgnotok_work.work);
1797
1798 /* Check if the status bit for usbchargernotok is still active */
1799 ret = abx500_get_register_interruptible(di->dev,
1800 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
1801 if (ret < 0) {
1802 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1803 return;
1804 }
1805 prev_status = di->flags.usbchargernotok;
1806
1807 if (reg_value & VBUS_CH_NOK) {
1808 di->flags.usbchargernotok = true;
1809 /* Check again in 1sec */
1810 queue_delayed_work(di->charger_wq,
1811 &di->check_usbchgnotok_work, HZ);
1812 } else {
1813 di->flags.usbchargernotok = false;
1814 di->flags.vbus_collapse = false;
1815 }
1816
1817 if (prev_status != di->flags.usbchargernotok)
1818 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1819 }
1820
1821 /**
1822 * ab8500_charger_check_main_thermal_prot_work() - check main thermal status
1823 * @work: pointer to the work_struct structure
1824 *
1825 * Work queue function for checking the Main thermal prot status
1826 */
1827 static void ab8500_charger_check_main_thermal_prot_work(
1828 struct work_struct *work)
1829 {
1830 int ret;
1831 u8 reg_value;
1832
1833 struct ab8500_charger *di = container_of(work,
1834 struct ab8500_charger, check_main_thermal_prot_work);
1835
1836 /* Check if the status bit for main_thermal_prot is still active */
1837 ret = abx500_get_register_interruptible(di->dev,
1838 AB8500_CHARGER, AB8500_CH_STATUS2_REG, &reg_value);
1839 if (ret < 0) {
1840 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1841 return;
1842 }
1843 if (reg_value & MAIN_CH_TH_PROT)
1844 di->flags.main_thermal_prot = true;
1845 else
1846 di->flags.main_thermal_prot = false;
1847
1848 ab8500_power_supply_changed(di, &di->ac_chg.psy);
1849 }
1850
1851 /**
1852 * ab8500_charger_check_usb_thermal_prot_work() - check usb thermal status
1853 * @work: pointer to the work_struct structure
1854 *
1855 * Work queue function for checking the USB thermal prot status
1856 */
1857 static void ab8500_charger_check_usb_thermal_prot_work(
1858 struct work_struct *work)
1859 {
1860 int ret;
1861 u8 reg_value;
1862
1863 struct ab8500_charger *di = container_of(work,
1864 struct ab8500_charger, check_usb_thermal_prot_work);
1865
1866 /* Check if the status bit for usb_thermal_prot is still active */
1867 ret = abx500_get_register_interruptible(di->dev,
1868 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, &reg_value);
1869 if (ret < 0) {
1870 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
1871 return;
1872 }
1873 if (reg_value & USB_CH_TH_PROT)
1874 di->flags.usb_thermal_prot = true;
1875 else
1876 di->flags.usb_thermal_prot = false;
1877
1878 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1879 }
1880
1881 /**
1882 * ab8500_charger_mainchunplugdet_handler() - main charger unplugged
1883 * @irq: interrupt number
1884 * @_di: pointer to the ab8500_charger structure
1885 *
1886 * Returns IRQ status(IRQ_HANDLED)
1887 */
1888 static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
1889 {
1890 struct ab8500_charger *di = _di;
1891
1892 dev_dbg(di->dev, "Main charger unplugged\n");
1893 queue_work(di->charger_wq, &di->ac_work);
1894
1895 return IRQ_HANDLED;
1896 }
1897
1898 /**
1899 * ab8500_charger_mainchplugdet_handler() - main charger plugged
1900 * @irq: interrupt number
1901 * @_di: pointer to the ab8500_charger structure
1902 *
1903 * Returns IRQ status(IRQ_HANDLED)
1904 */
1905 static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
1906 {
1907 struct ab8500_charger *di = _di;
1908
1909 dev_dbg(di->dev, "Main charger plugged\n");
1910 queue_work(di->charger_wq, &di->ac_work);
1911
1912 return IRQ_HANDLED;
1913 }
1914
1915 /**
1916 * ab8500_charger_mainextchnotok_handler() - main charger not ok
1917 * @irq: interrupt number
1918 * @_di: pointer to the ab8500_charger structure
1919 *
1920 * Returns IRQ status(IRQ_HANDLED)
1921 */
1922 static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
1923 {
1924 struct ab8500_charger *di = _di;
1925
1926 dev_dbg(di->dev, "Main charger not ok\n");
1927 di->flags.mainextchnotok = true;
1928 ab8500_power_supply_changed(di, &di->ac_chg.psy);
1929
1930 /* Schedule a new HW failure check */
1931 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
1932
1933 return IRQ_HANDLED;
1934 }
1935
1936 /**
1937 * ab8500_charger_mainchthprotr_handler() - Die temp is above main charger
1938 * thermal protection threshold
1939 * @irq: interrupt number
1940 * @_di: pointer to the ab8500_charger structure
1941 *
1942 * Returns IRQ status(IRQ_HANDLED)
1943 */
1944 static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
1945 {
1946 struct ab8500_charger *di = _di;
1947
1948 dev_dbg(di->dev,
1949 "Die temp above Main charger thermal protection threshold\n");
1950 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
1951
1952 return IRQ_HANDLED;
1953 }
1954
1955 /**
1956 * ab8500_charger_mainchthprotf_handler() - Die temp is below main charger
1957 * thermal protection threshold
1958 * @irq: interrupt number
1959 * @_di: pointer to the ab8500_charger structure
1960 *
1961 * Returns IRQ status(IRQ_HANDLED)
1962 */
1963 static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
1964 {
1965 struct ab8500_charger *di = _di;
1966
1967 dev_dbg(di->dev,
1968 "Die temp ok for Main charger thermal protection threshold\n");
1969 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
1970
1971 return IRQ_HANDLED;
1972 }
1973
1974 /**
1975 * ab8500_charger_vbusdetf_handler() - VBUS falling detected
1976 * @irq: interrupt number
1977 * @_di: pointer to the ab8500_charger structure
1978 *
1979 * Returns IRQ status(IRQ_HANDLED)
1980 */
1981 static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
1982 {
1983 struct ab8500_charger *di = _di;
1984
1985 dev_dbg(di->dev, "VBUS falling detected\n");
1986 queue_work(di->charger_wq, &di->detect_usb_type_work);
1987
1988 return IRQ_HANDLED;
1989 }
1990
1991 /**
1992 * ab8500_charger_vbusdetr_handler() - VBUS rising detected
1993 * @irq: interrupt number
1994 * @_di: pointer to the ab8500_charger structure
1995 *
1996 * Returns IRQ status(IRQ_HANDLED)
1997 */
1998 static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
1999 {
2000 struct ab8500_charger *di = _di;
2001
2002 di->vbus_detected = true;
2003 dev_dbg(di->dev, "VBUS rising detected\n");
2004 queue_work(di->charger_wq, &di->detect_usb_type_work);
2005
2006 return IRQ_HANDLED;
2007 }
2008
2009 /**
2010 * ab8500_charger_usblinkstatus_handler() - USB link status has changed
2011 * @irq: interrupt number
2012 * @_di: pointer to the ab8500_charger structure
2013 *
2014 * Returns IRQ status(IRQ_HANDLED)
2015 */
2016 static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2017 {
2018 struct ab8500_charger *di = _di;
2019
2020 dev_dbg(di->dev, "USB link status changed\n");
2021
2022 queue_work(di->charger_wq, &di->usb_link_status_work);
2023
2024 return IRQ_HANDLED;
2025 }
2026
2027 /**
2028 * ab8500_charger_usbchthprotr_handler() - Die temp is above usb charger
2029 * thermal protection threshold
2030 * @irq: interrupt number
2031 * @_di: pointer to the ab8500_charger structure
2032 *
2033 * Returns IRQ status(IRQ_HANDLED)
2034 */
2035 static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2036 {
2037 struct ab8500_charger *di = _di;
2038
2039 dev_dbg(di->dev,
2040 "Die temp above USB charger thermal protection threshold\n");
2041 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2042
2043 return IRQ_HANDLED;
2044 }
2045
2046 /**
2047 * ab8500_charger_usbchthprotf_handler() - Die temp is below usb charger
2048 * thermal protection threshold
2049 * @irq: interrupt number
2050 * @_di: pointer to the ab8500_charger structure
2051 *
2052 * Returns IRQ status(IRQ_HANDLED)
2053 */
2054 static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2055 {
2056 struct ab8500_charger *di = _di;
2057
2058 dev_dbg(di->dev,
2059 "Die temp ok for USB charger thermal protection threshold\n");
2060 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2061
2062 return IRQ_HANDLED;
2063 }
2064
2065 /**
2066 * ab8500_charger_usbchargernotokr_handler() - USB charger not ok detected
2067 * @irq: interrupt number
2068 * @_di: pointer to the ab8500_charger structure
2069 *
2070 * Returns IRQ status(IRQ_HANDLED)
2071 */
2072 static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2073 {
2074 struct ab8500_charger *di = _di;
2075
2076 dev_dbg(di->dev, "Not allowed USB charger detected\n");
2077 queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2078
2079 return IRQ_HANDLED;
2080 }
2081
2082 /**
2083 * ab8500_charger_chwdexp_handler() - Charger watchdog expired
2084 * @irq: interrupt number
2085 * @_di: pointer to the ab8500_charger structure
2086 *
2087 * Returns IRQ status(IRQ_HANDLED)
2088 */
2089 static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2090 {
2091 struct ab8500_charger *di = _di;
2092
2093 dev_dbg(di->dev, "Charger watchdog expired\n");
2094
2095 /*
2096 * The charger that was online when the watchdog expired
2097 * needs to be restarted for charging to start again
2098 */
2099 if (di->ac.charger_online) {
2100 di->ac.wd_expired = true;
2101 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2102 }
2103 if (di->usb.charger_online) {
2104 di->usb.wd_expired = true;
2105 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2106 }
2107
2108 return IRQ_HANDLED;
2109 }
2110
2111 /**
2112 * ab8500_charger_vbusovv_handler() - VBUS overvoltage detected
2113 * @irq: interrupt number
2114 * @_di: pointer to the ab8500_charger structure
2115 *
2116 * Returns IRQ status(IRQ_HANDLED)
2117 */
2118 static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2119 {
2120 struct ab8500_charger *di = _di;
2121
2122 dev_dbg(di->dev, "VBUS overvoltage detected\n");
2123 di->flags.vbus_ovv = true;
2124 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2125
2126 /* Schedule a new HW failure check */
2127 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2128
2129 return IRQ_HANDLED;
2130 }
2131
2132 /**
2133 * ab8500_charger_ac_get_property() - get the ac/mains properties
2134 * @psy: pointer to the power_supply structure
2135 * @psp: pointer to the power_supply_property structure
2136 * @val: pointer to the power_supply_propval union
2137 *
2138 * This function gets called when an application tries to get the ac/mains
2139 * properties by reading the sysfs files.
2140 * AC/Mains properties are online, present and voltage.
2141 * online: ac/mains charging is in progress or not
2142 * present: presence of the ac/mains
2143 * voltage: AC/Mains voltage
2144 * Returns error code in case of failure else 0(on success)
2145 */
2146 static int ab8500_charger_ac_get_property(struct power_supply *psy,
2147 enum power_supply_property psp,
2148 union power_supply_propval *val)
2149 {
2150 struct ab8500_charger *di;
2151
2152 di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2153
2154 switch (psp) {
2155 case POWER_SUPPLY_PROP_HEALTH:
2156 if (di->flags.mainextchnotok)
2157 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2158 else if (di->ac.wd_expired || di->usb.wd_expired)
2159 val->intval = POWER_SUPPLY_HEALTH_DEAD;
2160 else if (di->flags.main_thermal_prot)
2161 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2162 else
2163 val->intval = POWER_SUPPLY_HEALTH_GOOD;
2164 break;
2165 case POWER_SUPPLY_PROP_ONLINE:
2166 val->intval = di->ac.charger_online;
2167 break;
2168 case POWER_SUPPLY_PROP_PRESENT:
2169 val->intval = di->ac.charger_connected;
2170 break;
2171 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2172 di->ac.charger_voltage = ab8500_charger_get_ac_voltage(di);
2173 val->intval = di->ac.charger_voltage * 1000;
2174 break;
2175 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2176 /*
2177 * This property is used to indicate when CV mode is entered
2178 * for the AC charger
2179 */
2180 di->ac.cv_active = ab8500_charger_ac_cv(di);
2181 val->intval = di->ac.cv_active;
2182 break;
2183 case POWER_SUPPLY_PROP_CURRENT_NOW:
2184 val->intval = ab8500_charger_get_ac_current(di) * 1000;
2185 break;
2186 default:
2187 return -EINVAL;
2188 }
2189 return 0;
2190 }
2191
2192 /**
2193 * ab8500_charger_usb_get_property() - get the usb properties
2194 * @psy: pointer to the power_supply structure
2195 * @psp: pointer to the power_supply_property structure
2196 * @val: pointer to the power_supply_propval union
2197 *
2198 * This function gets called when an application tries to get the usb
2199 * properties by reading the sysfs files.
2200 * USB properties are online, present and voltage.
2201 * online: usb charging is in progress or not
2202 * present: presence of the usb
2203 * voltage: vbus voltage
2204 * Returns error code in case of failure else 0(on success)
2205 */
2206 static int ab8500_charger_usb_get_property(struct power_supply *psy,
2207 enum power_supply_property psp,
2208 union power_supply_propval *val)
2209 {
2210 struct ab8500_charger *di;
2211
2212 di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
2213
2214 switch (psp) {
2215 case POWER_SUPPLY_PROP_HEALTH:
2216 if (di->flags.usbchargernotok)
2217 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2218 else if (di->ac.wd_expired || di->usb.wd_expired)
2219 val->intval = POWER_SUPPLY_HEALTH_DEAD;
2220 else if (di->flags.usb_thermal_prot)
2221 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2222 else if (di->flags.vbus_ovv)
2223 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
2224 else
2225 val->intval = POWER_SUPPLY_HEALTH_GOOD;
2226 break;
2227 case POWER_SUPPLY_PROP_ONLINE:
2228 val->intval = di->usb.charger_online;
2229 break;
2230 case POWER_SUPPLY_PROP_PRESENT:
2231 val->intval = di->usb.charger_connected;
2232 break;
2233 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2234 di->usb.charger_voltage = ab8500_charger_get_vbus_voltage(di);
2235 val->intval = di->usb.charger_voltage * 1000;
2236 break;
2237 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2238 /*
2239 * This property is used to indicate when CV mode is entered
2240 * for the USB charger
2241 */
2242 di->usb.cv_active = ab8500_charger_usb_cv(di);
2243 val->intval = di->usb.cv_active;
2244 break;
2245 case POWER_SUPPLY_PROP_CURRENT_NOW:
2246 val->intval = ab8500_charger_get_usb_current(di) * 1000;
2247 break;
2248 case POWER_SUPPLY_PROP_CURRENT_AVG:
2249 /*
2250 * This property is used to indicate when VBUS has collapsed
2251 * due to too high output current from the USB charger
2252 */
2253 if (di->flags.vbus_collapse)
2254 val->intval = 1;
2255 else
2256 val->intval = 0;
2257 break;
2258 default:
2259 return -EINVAL;
2260 }
2261 return 0;
2262 }
2263
2264 /**
2265 * ab8500_charger_init_hw_registers() - Set up charger related registers
2266 * @di: pointer to the ab8500_charger structure
2267 *
2268 * Set up charger OVV, watchdog and maximum voltage registers as well as
2269 * charging of the backup battery
2270 */
2271 static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
2272 {
2273 int ret = 0;
2274
2275 /* Setup maximum charger current and voltage for ABB cut2.0 */
2276 if (!is_ab8500_1p1_or_earlier(di->parent)) {
2277 ret = abx500_set_register_interruptible(di->dev,
2278 AB8500_CHARGER,
2279 AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
2280 if (ret) {
2281 dev_err(di->dev,
2282 "failed to set CH_VOLT_LVL_MAX_REG\n");
2283 goto out;
2284 }
2285
2286 ret = abx500_set_register_interruptible(di->dev,
2287 AB8500_CHARGER,
2288 AB8500_CH_OPT_CRNTLVL_MAX_REG, CH_OP_CUR_LVL_1P6);
2289 if (ret) {
2290 dev_err(di->dev,
2291 "failed to set CH_OPT_CRNTLVL_MAX_REG\n");
2292 goto out;
2293 }
2294 }
2295
2296 /* VBUS OVV set to 6.3V and enable automatic current limitiation */
2297 ret = abx500_set_register_interruptible(di->dev,
2298 AB8500_CHARGER,
2299 AB8500_USBCH_CTRL2_REG,
2300 VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
2301 if (ret) {
2302 dev_err(di->dev, "failed to set VBUS OVV\n");
2303 goto out;
2304 }
2305
2306 /* Enable main watchdog in OTP */
2307 ret = abx500_set_register_interruptible(di->dev,
2308 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
2309 if (ret) {
2310 dev_err(di->dev, "failed to enable main WD in OTP\n");
2311 goto out;
2312 }
2313
2314 /* Enable main watchdog */
2315 ret = abx500_set_register_interruptible(di->dev,
2316 AB8500_SYS_CTRL2_BLOCK,
2317 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
2318 if (ret) {
2319 dev_err(di->dev, "faile to enable main watchdog\n");
2320 goto out;
2321 }
2322
2323 /*
2324 * Due to internal synchronisation, Enable and Kick watchdog bits
2325 * cannot be enabled in a single write.
2326 * A minimum delay of 2*32 kHz period (62.5µs) must be inserted
2327 * between writing Enable then Kick bits.
2328 */
2329 udelay(63);
2330
2331 /* Kick main watchdog */
2332 ret = abx500_set_register_interruptible(di->dev,
2333 AB8500_SYS_CTRL2_BLOCK,
2334 AB8500_MAIN_WDOG_CTRL_REG,
2335 (MAIN_WDOG_ENA | MAIN_WDOG_KICK));
2336 if (ret) {
2337 dev_err(di->dev, "failed to kick main watchdog\n");
2338 goto out;
2339 }
2340
2341 /* Disable main watchdog */
2342 ret = abx500_set_register_interruptible(di->dev,
2343 AB8500_SYS_CTRL2_BLOCK,
2344 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
2345 if (ret) {
2346 dev_err(di->dev, "failed to disable main watchdog\n");
2347 goto out;
2348 }
2349
2350 /* Set watchdog timeout */
2351 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2352 AB8500_CH_WD_TIMER_REG, WD_TIMER);
2353 if (ret) {
2354 dev_err(di->dev, "failed to set charger watchdog timeout\n");
2355 goto out;
2356 }
2357
2358 /* Backup battery voltage and current */
2359 ret = abx500_set_register_interruptible(di->dev,
2360 AB8500_RTC,
2361 AB8500_RTC_BACKUP_CHG_REG,
2362 di->bat->bkup_bat_v |
2363 di->bat->bkup_bat_i);
2364 if (ret) {
2365 dev_err(di->dev, "failed to setup backup battery charging\n");
2366 goto out;
2367 }
2368
2369 /* Enable backup battery charging */
2370 abx500_mask_and_set_register_interruptible(di->dev,
2371 AB8500_RTC, AB8500_RTC_CTRL_REG,
2372 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
2373 if (ret < 0)
2374 dev_err(di->dev, "%s mask and set failed\n", __func__);
2375
2376 out:
2377 return ret;
2378 }
2379
2380 /*
2381 * ab8500 charger driver interrupts and their respective isr
2382 */
2383 static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
2384 {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
2385 {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
2386 {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
2387 {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
2388 {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
2389 {"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
2390 {"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
2391 {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
2392 {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
2393 {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
2394 {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
2395 {"VBUS_OVV", ab8500_charger_vbusovv_handler},
2396 {"CH_WD_EXP", ab8500_charger_chwdexp_handler},
2397 };
2398
2399 static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
2400 unsigned long event, void *power)
2401 {
2402 struct ab8500_charger *di =
2403 container_of(nb, struct ab8500_charger, nb);
2404 enum ab8500_usb_state bm_usb_state;
2405 unsigned mA = *((unsigned *)power);
2406
2407 if (event != USB_EVENT_VBUS) {
2408 dev_dbg(di->dev, "not a standard host, returning\n");
2409 return NOTIFY_DONE;
2410 }
2411
2412 /* TODO: State is fabricate here. See if charger really needs USB
2413 * state or if mA is enough
2414 */
2415 if ((di->usb_state.usb_current == 2) && (mA > 2))
2416 bm_usb_state = AB8500_BM_USB_STATE_RESUME;
2417 else if (mA == 0)
2418 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
2419 else if (mA == 2)
2420 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
2421 else if (mA >= 8) /* 8, 100, 500 */
2422 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
2423 else /* Should never occur */
2424 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
2425
2426 dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
2427 __func__, bm_usb_state, mA);
2428
2429 spin_lock(&di->usb_state.usb_lock);
2430 di->usb_state.usb_changed = true;
2431 spin_unlock(&di->usb_state.usb_lock);
2432
2433 di->usb_state.state = bm_usb_state;
2434 di->usb_state.usb_current = mA;
2435
2436 queue_work(di->charger_wq, &di->usb_state_changed_work);
2437
2438 return NOTIFY_OK;
2439 }
2440
2441 #if defined(CONFIG_PM)
2442 static int ab8500_charger_resume(struct platform_device *pdev)
2443 {
2444 int ret;
2445 struct ab8500_charger *di = platform_get_drvdata(pdev);
2446
2447 /*
2448 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2449 * logic. That means we have to continously kick the charger
2450 * watchdog even when no charger is connected. This is only
2451 * valid once the AC charger has been enabled. This is
2452 * a bug that is not handled by the algorithm and the
2453 * watchdog have to be kicked by the charger driver
2454 * when the AC charger is disabled
2455 */
2456 if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
2457 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2458 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2459 if (ret)
2460 dev_err(di->dev, "Failed to kick WD!\n");
2461
2462 /* If not already pending start a new timer */
2463 if (!delayed_work_pending(
2464 &di->kick_wd_work)) {
2465 queue_delayed_work(di->charger_wq, &di->kick_wd_work,
2466 round_jiffies(WD_KICK_INTERVAL));
2467 }
2468 }
2469
2470 /* If we still have a HW failure, schedule a new check */
2471 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2472 queue_delayed_work(di->charger_wq,
2473 &di->check_hw_failure_work, 0);
2474 }
2475
2476 return 0;
2477 }
2478
2479 static int ab8500_charger_suspend(struct platform_device *pdev,
2480 pm_message_t state)
2481 {
2482 struct ab8500_charger *di = platform_get_drvdata(pdev);
2483
2484 /* Cancel any pending HW failure check */
2485 if (delayed_work_pending(&di->check_hw_failure_work))
2486 cancel_delayed_work(&di->check_hw_failure_work);
2487
2488 return 0;
2489 }
2490 #else
2491 #define ab8500_charger_suspend NULL
2492 #define ab8500_charger_resume NULL
2493 #endif
2494
2495 static int ab8500_charger_remove(struct platform_device *pdev)
2496 {
2497 struct ab8500_charger *di = platform_get_drvdata(pdev);
2498 int i, irq, ret;
2499
2500 /* Disable AC charging */
2501 ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
2502
2503 /* Disable USB charging */
2504 ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
2505
2506 /* Disable interrupts */
2507 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
2508 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
2509 free_irq(irq, di);
2510 }
2511
2512 /* disable the regulator */
2513 regulator_put(di->regu);
2514
2515 /* Backup battery voltage and current disable */
2516 ret = abx500_mask_and_set_register_interruptible(di->dev,
2517 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
2518 if (ret < 0)
2519 dev_err(di->dev, "%s mask and set failed\n", __func__);
2520
2521 usb_unregister_notifier(di->usb_phy, &di->nb);
2522 usb_put_phy(di->usb_phy);
2523
2524 /* Delete the work queue */
2525 destroy_workqueue(di->charger_wq);
2526
2527 flush_scheduled_work();
2528 power_supply_unregister(&di->usb_chg.psy);
2529 power_supply_unregister(&di->ac_chg.psy);
2530 platform_set_drvdata(pdev, NULL);
2531
2532 return 0;
2533 }
2534
2535 static char *supply_interface[] = {
2536 "ab8500_chargalg",
2537 "ab8500_fg",
2538 "ab8500_btemp",
2539 };
2540
2541 static int ab8500_charger_probe(struct platform_device *pdev)
2542 {
2543 struct device_node *np = pdev->dev.of_node;
2544 struct ab8500_charger *di;
2545 int irq, i, charger_status, ret = 0;
2546
2547 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
2548 if (!di) {
2549 dev_err(&pdev->dev, "%s no mem for ab8500_charger\n", __func__);
2550 return -ENOMEM;
2551 }
2552 di->bat = pdev->mfd_cell->platform_data;
2553 if (!di->bat) {
2554 if (np) {
2555 ret = bmdevs_of_probe(&pdev->dev, np, &di->bat);
2556 if (ret) {
2557 dev_err(&pdev->dev,
2558 "failed to get battery information\n");
2559 return ret;
2560 }
2561 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
2562 } else {
2563 dev_err(&pdev->dev, "missing dt node for ab8500_charger\n");
2564 return -EINVAL;
2565 }
2566 } else {
2567 dev_info(&pdev->dev, "falling back to legacy platform data\n");
2568 di->autopower_cfg = false;
2569 }
2570
2571 /* get parent data */
2572 di->dev = &pdev->dev;
2573 di->parent = dev_get_drvdata(pdev->dev.parent);
2574 di->gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
2575
2576 /* initialize lock */
2577 spin_lock_init(&di->usb_state.usb_lock);
2578
2579 di->autopower = false;
2580
2581 /* AC supply */
2582 /* power_supply base class */
2583 di->ac_chg.psy.name = "ab8500_ac";
2584 di->ac_chg.psy.type = POWER_SUPPLY_TYPE_MAINS;
2585 di->ac_chg.psy.properties = ab8500_charger_ac_props;
2586 di->ac_chg.psy.num_properties = ARRAY_SIZE(ab8500_charger_ac_props);
2587 di->ac_chg.psy.get_property = ab8500_charger_ac_get_property;
2588 di->ac_chg.psy.supplied_to = supply_interface;
2589 di->ac_chg.psy.num_supplicants = ARRAY_SIZE(supply_interface),
2590 /* ux500_charger sub-class */
2591 di->ac_chg.ops.enable = &ab8500_charger_ac_en;
2592 di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
2593 di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
2594 di->ac_chg.max_out_volt = ab8500_charger_voltage_map[
2595 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
2596 di->ac_chg.max_out_curr = ab8500_charger_current_map[
2597 ARRAY_SIZE(ab8500_charger_current_map) - 1];
2598
2599 /* USB supply */
2600 /* power_supply base class */
2601 di->usb_chg.psy.name = "ab8500_usb";
2602 di->usb_chg.psy.type = POWER_SUPPLY_TYPE_USB;
2603 di->usb_chg.psy.properties = ab8500_charger_usb_props;
2604 di->usb_chg.psy.num_properties = ARRAY_SIZE(ab8500_charger_usb_props);
2605 di->usb_chg.psy.get_property = ab8500_charger_usb_get_property;
2606 di->usb_chg.psy.supplied_to = supply_interface;
2607 di->usb_chg.psy.num_supplicants = ARRAY_SIZE(supply_interface),
2608 /* ux500_charger sub-class */
2609 di->usb_chg.ops.enable = &ab8500_charger_usb_en;
2610 di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
2611 di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
2612 di->usb_chg.max_out_volt = ab8500_charger_voltage_map[
2613 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
2614 di->usb_chg.max_out_curr = ab8500_charger_current_map[
2615 ARRAY_SIZE(ab8500_charger_current_map) - 1];
2616
2617
2618 /* Create a work queue for the charger */
2619 di->charger_wq =
2620 create_singlethread_workqueue("ab8500_charger_wq");
2621 if (di->charger_wq == NULL) {
2622 dev_err(di->dev, "failed to create work queue\n");
2623 return -ENOMEM;
2624 }
2625
2626 /* Init work for HW failure check */
2627 INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
2628 ab8500_charger_check_hw_failure_work);
2629 INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
2630 ab8500_charger_check_usbchargernotok_work);
2631
2632 /*
2633 * For ABB revision 1.0 and 1.1 there is a bug in the watchdog
2634 * logic. That means we have to continously kick the charger
2635 * watchdog even when no charger is connected. This is only
2636 * valid once the AC charger has been enabled. This is
2637 * a bug that is not handled by the algorithm and the
2638 * watchdog have to be kicked by the charger driver
2639 * when the AC charger is disabled
2640 */
2641 INIT_DEFERRABLE_WORK(&di->kick_wd_work,
2642 ab8500_charger_kick_watchdog_work);
2643
2644 INIT_DEFERRABLE_WORK(&di->check_vbat_work,
2645 ab8500_charger_check_vbat_work);
2646
2647 /* Init work for charger detection */
2648 INIT_WORK(&di->usb_link_status_work,
2649 ab8500_charger_usb_link_status_work);
2650 INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
2651 INIT_WORK(&di->detect_usb_type_work,
2652 ab8500_charger_detect_usb_type_work);
2653
2654 INIT_WORK(&di->usb_state_changed_work,
2655 ab8500_charger_usb_state_changed_work);
2656
2657 /* Init work for checking HW status */
2658 INIT_WORK(&di->check_main_thermal_prot_work,
2659 ab8500_charger_check_main_thermal_prot_work);
2660 INIT_WORK(&di->check_usb_thermal_prot_work,
2661 ab8500_charger_check_usb_thermal_prot_work);
2662
2663 /*
2664 * VDD ADC supply needs to be enabled from this driver when there
2665 * is a charger connected to avoid erroneous BTEMP_HIGH/LOW
2666 * interrupts during charging
2667 */
2668 di->regu = regulator_get(di->dev, "vddadc");
2669 if (IS_ERR(di->regu)) {
2670 ret = PTR_ERR(di->regu);
2671 dev_err(di->dev, "failed to get vddadc regulator\n");
2672 goto free_charger_wq;
2673 }
2674
2675
2676 /* Initialize OVV, and other registers */
2677 ret = ab8500_charger_init_hw_registers(di);
2678 if (ret) {
2679 dev_err(di->dev, "failed to initialize ABB registers\n");
2680 goto free_regulator;
2681 }
2682
2683 /* Register AC charger class */
2684 ret = power_supply_register(di->dev, &di->ac_chg.psy);
2685 if (ret) {
2686 dev_err(di->dev, "failed to register AC charger\n");
2687 goto free_regulator;
2688 }
2689
2690 /* Register USB charger class */
2691 ret = power_supply_register(di->dev, &di->usb_chg.psy);
2692 if (ret) {
2693 dev_err(di->dev, "failed to register USB charger\n");
2694 goto free_ac;
2695 }
2696
2697 di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
2698 if (IS_ERR_OR_NULL(di->usb_phy)) {
2699 dev_err(di->dev, "failed to get usb transceiver\n");
2700 ret = -EINVAL;
2701 goto free_usb;
2702 }
2703 di->nb.notifier_call = ab8500_charger_usb_notifier_call;
2704 ret = usb_register_notifier(di->usb_phy, &di->nb);
2705 if (ret) {
2706 dev_err(di->dev, "failed to register usb notifier\n");
2707 goto put_usb_phy;
2708 }
2709
2710 /* Identify the connected charger types during startup */
2711 charger_status = ab8500_charger_detect_chargers(di);
2712 if (charger_status & AC_PW_CONN) {
2713 di->ac.charger_connected = 1;
2714 di->ac_conn = true;
2715 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2716 sysfs_notify(&di->ac_chg.psy.dev->kobj, NULL, "present");
2717 }
2718
2719 if (charger_status & USB_PW_CONN) {
2720 dev_dbg(di->dev, "VBUS Detect during startup\n");
2721 di->vbus_detected = true;
2722 di->vbus_detected_start = true;
2723 queue_work(di->charger_wq,
2724 &di->detect_usb_type_work);
2725 }
2726
2727 /* Register interrupts */
2728 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
2729 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
2730 ret = request_threaded_irq(irq, NULL, ab8500_charger_irq[i].isr,
2731 IRQF_SHARED | IRQF_NO_SUSPEND,
2732 ab8500_charger_irq[i].name, di);
2733
2734 if (ret != 0) {
2735 dev_err(di->dev, "failed to request %s IRQ %d: %d\n"
2736 , ab8500_charger_irq[i].name, irq, ret);
2737 goto free_irq;
2738 }
2739 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
2740 ab8500_charger_irq[i].name, irq, ret);
2741 }
2742
2743 platform_set_drvdata(pdev, di);
2744
2745 return ret;
2746
2747 free_irq:
2748 usb_unregister_notifier(di->usb_phy, &di->nb);
2749
2750 /* We also have to free all successfully registered irqs */
2751 for (i = i - 1; i >= 0; i--) {
2752 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
2753 free_irq(irq, di);
2754 }
2755 put_usb_phy:
2756 usb_put_phy(di->usb_phy);
2757 free_usb:
2758 power_supply_unregister(&di->usb_chg.psy);
2759 free_ac:
2760 power_supply_unregister(&di->ac_chg.psy);
2761 free_regulator:
2762 regulator_put(di->regu);
2763 free_charger_wq:
2764 destroy_workqueue(di->charger_wq);
2765 return ret;
2766 }
2767
2768 static const struct of_device_id ab8500_charger_match[] = {
2769 { .compatible = "stericsson,ab8500-charger", },
2770 { },
2771 };
2772
2773 static struct platform_driver ab8500_charger_driver = {
2774 .probe = ab8500_charger_probe,
2775 .remove = ab8500_charger_remove,
2776 .suspend = ab8500_charger_suspend,
2777 .resume = ab8500_charger_resume,
2778 .driver = {
2779 .name = "ab8500-charger",
2780 .owner = THIS_MODULE,
2781 .of_match_table = ab8500_charger_match,
2782 },
2783 };
2784
2785 static int __init ab8500_charger_init(void)
2786 {
2787 return platform_driver_register(&ab8500_charger_driver);
2788 }
2789
2790 static void __exit ab8500_charger_exit(void)
2791 {
2792 platform_driver_unregister(&ab8500_charger_driver);
2793 }
2794
2795 subsys_initcall_sync(ab8500_charger_init);
2796 module_exit(ab8500_charger_exit);
2797
2798 MODULE_LICENSE("GPL v2");
2799 MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
2800 MODULE_ALIAS("platform:ab8500-charger");
2801 MODULE_DESCRIPTION("AB8500 charger management driver");
Linux 2.6 ibm-acpi/thinkpad-acpi driver git tree