1
2
3
4
5
6
7
8
9
10
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/notifier.h>
19#include <linux/slab.h>
20#include <linux/platform_device.h>
21#include <linux/power_supply.h>
22#include <linux/completion.h>
23#include <linux/regulator/consumer.h>
24#include <linux/err.h>
25#include <linux/workqueue.h>
26#include <linux/kobject.h>
27#include <linux/of.h>
28#include <linux/mfd/core.h>
29#include <linux/mfd/abx500/ab8500.h>
30#include <linux/mfd/abx500.h>
31#include <linux/mfd/abx500/ab8500-bm.h>
32#include <linux/mfd/abx500/ab8500-gpadc.h>
33#include <linux/mfd/abx500/ux500_chargalg.h>
34#include <linux/usb/otg.h>
35#include <linux/mutex.h>
36
37
38#define NO_PW_CONN 0
39#define AC_PW_CONN 1
40#define USB_PW_CONN 2
41
42#define MAIN_WDOG_ENA 0x01
43#define MAIN_WDOG_KICK 0x02
44#define MAIN_WDOG_DIS 0x00
45#define CHARG_WD_KICK 0x01
46#define MAIN_CH_ENA 0x01
47#define MAIN_CH_NO_OVERSHOOT_ENA_N 0x02
48#define USB_CH_ENA 0x01
49#define USB_CHG_NO_OVERSHOOT_ENA_N 0x02
50#define MAIN_CH_DET 0x01
51#define MAIN_CH_CV_ON 0x04
52#define USB_CH_CV_ON 0x08
53#define VBUS_DET_DBNC100 0x02
54#define VBUS_DET_DBNC1 0x01
55#define OTP_ENABLE_WD 0x01
56#define DROP_COUNT_RESET 0x01
57#define USB_CH_DET 0x01
58
59#define MAIN_CH_INPUT_CURR_SHIFT 4
60#define VBUS_IN_CURR_LIM_SHIFT 4
61#define AB8540_VBUS_IN_CURR_LIM_SHIFT 2
62#define AUTO_VBUS_IN_CURR_LIM_SHIFT 4
63#define AB8540_AUTO_VBUS_IN_CURR_MASK 0x3F
64#define VBUS_IN_CURR_LIM_RETRY_SET_TIME 30
65
66#define LED_INDICATOR_PWM_ENA 0x01
67#define LED_INDICATOR_PWM_DIS 0x00
68#define LED_IND_CUR_5MA 0x04
69#define LED_INDICATOR_PWM_DUTY_252_256 0xBF
70
71
72#define MAIN_CH_TH_PROT 0x02
73#define VBUS_CH_NOK 0x08
74#define USB_CH_TH_PROT 0x02
75#define VBUS_OVV_TH 0x01
76#define MAIN_CH_NOK 0x01
77#define VBUS_DET 0x80
78
79#define MAIN_CH_STATUS2_MAINCHGDROP 0x80
80#define MAIN_CH_STATUS2_MAINCHARGERDETDBNC 0x40
81#define USB_CH_VBUSDROP 0x40
82#define USB_CH_VBUSDETDBNC 0x01
83
84
85#define AB8500_USB_LINK_STATUS 0x78
86#define AB8505_USB_LINK_STATUS 0xF8
87#define AB8500_STD_HOST_SUSP 0x18
88#define USB_LINK_STATUS_SHIFT 3
89
90
91#define WD_TIMER 0x30
92#define WD_KICK_INTERVAL (60 * HZ)
93
94
95#define LOW_VOLT_REG 0x4E
96
97
98#define STEP_UDELAY 1000
99
100#define CHARGER_STATUS_POLL 10
101
102#define CHG_WD_INTERVAL (60 * HZ)
103
104#define AB8500_SW_CONTROL_FALLBACK 0x03
105
106#define WAIT_ACA_RID_ENUMERATION (5 * 1000)
107
108#define AB8500_SYS_CHARGER_CONTROL_REG 0x52
109#define EXTERNAL_CHARGER_DISABLE_REG_VAL 0x03
110#define EXTERNAL_CHARGER_ENABLE_REG_VAL 0x07
111
112
113enum ab8500_charger_link_status {
114 USB_STAT_NOT_CONFIGURED,
115 USB_STAT_STD_HOST_NC,
116 USB_STAT_STD_HOST_C_NS,
117 USB_STAT_STD_HOST_C_S,
118 USB_STAT_HOST_CHG_NM,
119 USB_STAT_HOST_CHG_HS,
120 USB_STAT_HOST_CHG_HS_CHIRP,
121 USB_STAT_DEDICATED_CHG,
122 USB_STAT_ACA_RID_A,
123 USB_STAT_ACA_RID_B,
124 USB_STAT_ACA_RID_C_NM,
125 USB_STAT_ACA_RID_C_HS,
126 USB_STAT_ACA_RID_C_HS_CHIRP,
127 USB_STAT_HM_IDGND,
128 USB_STAT_RESERVED,
129 USB_STAT_NOT_VALID_LINK,
130 USB_STAT_PHY_EN,
131 USB_STAT_SUP_NO_IDGND_VBUS,
132 USB_STAT_SUP_IDGND_VBUS,
133 USB_STAT_CHARGER_LINE_1,
134 USB_STAT_CARKIT_1,
135 USB_STAT_CARKIT_2,
136 USB_STAT_ACA_DOCK_CHARGER,
137};
138
139enum ab8500_usb_state {
140 AB8500_BM_USB_STATE_RESET_HS,
141 AB8500_BM_USB_STATE_RESET_FS,
142 AB8500_BM_USB_STATE_CONFIGURED,
143 AB8500_BM_USB_STATE_SUSPEND,
144 AB8500_BM_USB_STATE_RESUME,
145 AB8500_BM_USB_STATE_MAX,
146};
147
148
149#define USB_CH_IP_CUR_LVL_0P05 50
150#define USB_CH_IP_CUR_LVL_0P09 98
151#define USB_CH_IP_CUR_LVL_0P19 193
152#define USB_CH_IP_CUR_LVL_0P29 290
153#define USB_CH_IP_CUR_LVL_0P38 380
154#define USB_CH_IP_CUR_LVL_0P45 450
155#define USB_CH_IP_CUR_LVL_0P5 500
156#define USB_CH_IP_CUR_LVL_0P6 600
157#define USB_CH_IP_CUR_LVL_0P7 700
158#define USB_CH_IP_CUR_LVL_0P8 800
159#define USB_CH_IP_CUR_LVL_0P9 900
160#define USB_CH_IP_CUR_LVL_1P0 1000
161#define USB_CH_IP_CUR_LVL_1P1 1100
162#define USB_CH_IP_CUR_LVL_1P3 1300
163#define USB_CH_IP_CUR_LVL_1P4 1400
164#define USB_CH_IP_CUR_LVL_1P5 1500
165
166#define VBAT_TRESH_IP_CUR_RED 3800
167
168#define to_ab8500_charger_usb_device_info(x) container_of((x), \
169 struct ab8500_charger, usb_chg)
170#define to_ab8500_charger_ac_device_info(x) container_of((x), \
171 struct ab8500_charger, ac_chg)
172
173
174
175
176
177
178struct ab8500_charger_interrupts {
179 char *name;
180 irqreturn_t (*isr)(int irq, void *data);
181};
182
183struct ab8500_charger_info {
184 int charger_connected;
185 int charger_online;
186 int charger_voltage;
187 int cv_active;
188 bool wd_expired;
189 int charger_current;
190};
191
192struct ab8500_charger_event_flags {
193 bool mainextchnotok;
194 bool main_thermal_prot;
195 bool usb_thermal_prot;
196 bool vbus_ovv;
197 bool usbchargernotok;
198 bool chgwdexp;
199 bool vbus_collapse;
200 bool vbus_drop_end;
201};
202
203struct ab8500_charger_usb_state {
204 int usb_current;
205 int usb_current_tmp;
206 enum ab8500_usb_state state;
207 enum ab8500_usb_state state_tmp;
208 spinlock_t usb_lock;
209};
210
211struct ab8500_charger_max_usb_in_curr {
212 int usb_type_max;
213 int set_max;
214 int calculated_max;
215};
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272struct ab8500_charger {
273 struct device *dev;
274 bool vbus_detected;
275 bool vbus_detected_start;
276 bool ac_conn;
277 bool vddadc_en_ac;
278 bool vddadc_en_usb;
279 int vbat;
280 int old_vbat;
281 bool usb_device_is_unrecognised;
282 bool autopower;
283 bool autopower_cfg;
284 int invalid_charger_detect_state;
285 int is_aca_rid;
286 atomic_t current_stepping_sessions;
287 struct ab8500 *parent;
288 struct ab8500_gpadc *gpadc;
289 struct abx500_bm_data *bm;
290 struct ab8500_charger_event_flags flags;
291 struct ab8500_charger_usb_state usb_state;
292 struct ab8500_charger_max_usb_in_curr max_usb_in_curr;
293 struct ux500_charger ac_chg;
294 struct ux500_charger usb_chg;
295 struct ab8500_charger_info ac;
296 struct ab8500_charger_info usb;
297 struct regulator *regu;
298 struct workqueue_struct *charger_wq;
299 struct mutex usb_ipt_crnt_lock;
300 struct delayed_work check_vbat_work;
301 struct delayed_work check_hw_failure_work;
302 struct delayed_work check_usbchgnotok_work;
303 struct delayed_work kick_wd_work;
304 struct delayed_work usb_state_changed_work;
305 struct delayed_work attach_work;
306 struct delayed_work ac_charger_attached_work;
307 struct delayed_work usb_charger_attached_work;
308 struct delayed_work vbus_drop_end_work;
309 struct work_struct ac_work;
310 struct work_struct detect_usb_type_work;
311 struct work_struct usb_link_status_work;
312 struct work_struct check_main_thermal_prot_work;
313 struct work_struct check_usb_thermal_prot_work;
314 struct usb_phy *usb_phy;
315 struct notifier_block nb;
316 struct mutex charger_attached_mutex;
317};
318
319
320static enum power_supply_property ab8500_charger_ac_props[] = {
321 POWER_SUPPLY_PROP_HEALTH,
322 POWER_SUPPLY_PROP_PRESENT,
323 POWER_SUPPLY_PROP_ONLINE,
324 POWER_SUPPLY_PROP_VOLTAGE_NOW,
325 POWER_SUPPLY_PROP_VOLTAGE_AVG,
326 POWER_SUPPLY_PROP_CURRENT_NOW,
327};
328
329
330static enum power_supply_property ab8500_charger_usb_props[] = {
331 POWER_SUPPLY_PROP_HEALTH,
332 POWER_SUPPLY_PROP_CURRENT_AVG,
333 POWER_SUPPLY_PROP_PRESENT,
334 POWER_SUPPLY_PROP_ONLINE,
335 POWER_SUPPLY_PROP_VOLTAGE_NOW,
336 POWER_SUPPLY_PROP_VOLTAGE_AVG,
337 POWER_SUPPLY_PROP_CURRENT_NOW,
338};
339
340
341
342
343
344static void ab8500_enable_disable_sw_fallback(struct ab8500_charger *di,
345 bool fallback)
346{
347 u8 val;
348 u8 reg;
349 u8 bank;
350 u8 bit;
351 int ret;
352
353 dev_dbg(di->dev, "SW Fallback: %d\n", fallback);
354
355 if (is_ab8500(di->parent)) {
356 bank = 0x15;
357 reg = 0x0;
358 bit = 3;
359 } else {
360 bank = AB8500_SYS_CTRL1_BLOCK;
361 reg = AB8500_SW_CONTROL_FALLBACK;
362 bit = 0;
363 }
364
365
366 ret = abx500_get_register_interruptible(di->dev, bank, reg, &val);
367 if (ret < 0) {
368 dev_err(di->dev, "%d read failed\n", __LINE__);
369 return;
370 }
371
372 if (is_ab8500(di->parent)) {
373
374 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x2);
375 if (ret) {
376 dev_err(di->dev, "%d write failed\n", __LINE__);
377 goto disable_otp;
378 }
379 }
380
381 if (fallback)
382 val |= (1 << bit);
383 else
384 val &= ~(1 << bit);
385
386
387 ret = abx500_set_register_interruptible(di->dev, bank, reg, val);
388 if (ret) {
389 dev_err(di->dev, "%d write failed\n", __LINE__);
390 }
391
392disable_otp:
393 if (is_ab8500(di->parent)) {
394
395 ret = abx500_set_register_interruptible(di->dev, 0x11, 0x00, 0x0);
396 if (ret) {
397 dev_err(di->dev, "%d write failed\n", __LINE__);
398 }
399 }
400}
401
402
403
404
405
406
407
408
409static void ab8500_power_supply_changed(struct ab8500_charger *di,
410 struct power_supply *psy)
411{
412 if (di->autopower_cfg) {
413 if (!di->usb.charger_connected &&
414 !di->ac.charger_connected &&
415 di->autopower) {
416 di->autopower = false;
417 ab8500_enable_disable_sw_fallback(di, false);
418 } else if (!di->autopower &&
419 (di->ac.charger_connected ||
420 di->usb.charger_connected)) {
421 di->autopower = true;
422 ab8500_enable_disable_sw_fallback(di, true);
423 }
424 }
425 power_supply_changed(psy);
426}
427
428static void ab8500_charger_set_usb_connected(struct ab8500_charger *di,
429 bool connected)
430{
431 if (connected != di->usb.charger_connected) {
432 dev_dbg(di->dev, "USB connected:%i\n", connected);
433 di->usb.charger_connected = connected;
434
435 if (!connected)
436 di->flags.vbus_drop_end = false;
437
438 sysfs_notify(&di->usb_chg.psy.dev->kobj, NULL, "present");
439
440 if (connected) {
441 mutex_lock(&di->charger_attached_mutex);
442 mutex_unlock(&di->charger_attached_mutex);
443
444 if (is_ab8500(di->parent))
445 queue_delayed_work(di->charger_wq,
446 &di->usb_charger_attached_work,
447 HZ);
448 } else {
449 cancel_delayed_work_sync(&di->usb_charger_attached_work);
450 mutex_lock(&di->charger_attached_mutex);
451 mutex_unlock(&di->charger_attached_mutex);
452 }
453 }
454}
455
456
457
458
459
460
461
462static int ab8500_charger_get_ac_voltage(struct ab8500_charger *di)
463{
464 int vch;
465
466
467 if (di->ac.charger_connected) {
468 vch = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_V);
469 if (vch < 0)
470 dev_err(di->dev, "%s gpadc conv failed,\n", __func__);
471 } else {
472 vch = 0;
473 }
474 return vch;
475}
476
477
478
479
480
481
482
483static int ab8500_charger_ac_cv(struct ab8500_charger *di)
484{
485 u8 val;
486 int ret = 0;
487
488
489 if (di->ac.charger_online) {
490 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
491 AB8500_CH_STATUS1_REG, &val);
492 if (ret < 0) {
493 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
494 return 0;
495 }
496
497 if (val & MAIN_CH_CV_ON)
498 ret = 1;
499 else
500 ret = 0;
501 }
502
503 return ret;
504}
505
506
507
508
509
510
511
512
513static int ab8500_charger_get_vbus_voltage(struct ab8500_charger *di)
514{
515 int vch;
516
517
518 if (di->usb.charger_connected) {
519 vch = ab8500_gpadc_convert(di->gpadc, VBUS_V);
520 if (vch < 0)
521 dev_err(di->dev, "%s gpadc conv failed\n", __func__);
522 } else {
523 vch = 0;
524 }
525 return vch;
526}
527
528
529
530
531
532
533
534
535static int ab8500_charger_get_usb_current(struct ab8500_charger *di)
536{
537 int ich;
538
539
540 if (di->usb.charger_online) {
541 ich = ab8500_gpadc_convert(di->gpadc, USB_CHARGER_C);
542 if (ich < 0)
543 dev_err(di->dev, "%s gpadc conv failed\n", __func__);
544 } else {
545 ich = 0;
546 }
547 return ich;
548}
549
550
551
552
553
554
555
556
557static int ab8500_charger_get_ac_current(struct ab8500_charger *di)
558{
559 int ich;
560
561
562 if (di->ac.charger_online) {
563 ich = ab8500_gpadc_convert(di->gpadc, MAIN_CHARGER_C);
564 if (ich < 0)
565 dev_err(di->dev, "%s gpadc conv failed\n", __func__);
566 } else {
567 ich = 0;
568 }
569 return ich;
570}
571
572
573
574
575
576
577
578static int ab8500_charger_usb_cv(struct ab8500_charger *di)
579{
580 int ret;
581 u8 val;
582
583
584 if (di->usb.charger_online) {
585 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
586 AB8500_CH_USBCH_STAT1_REG, &val);
587 if (ret < 0) {
588 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
589 return 0;
590 }
591
592 if (val & USB_CH_CV_ON)
593 ret = 1;
594 else
595 ret = 0;
596 } else {
597 ret = 0;
598 }
599
600 return ret;
601}
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620static int ab8500_charger_detect_chargers(struct ab8500_charger *di, bool probe)
621{
622 int result = NO_PW_CONN;
623 int ret;
624 u8 val;
625
626
627 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
628 AB8500_CH_STATUS1_REG, &val);
629 if (ret < 0) {
630 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
631 return ret;
632 }
633
634 if (val & MAIN_CH_DET)
635 result = AC_PW_CONN;
636
637
638
639 if (!probe) {
640
641
642
643
644
645
646 msleep(110);
647 }
648 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
649 AB8500_CH_USBCH_STAT1_REG, &val);
650 if (ret < 0) {
651 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
652 return ret;
653 }
654 dev_dbg(di->dev,
655 "%s AB8500_CH_USBCH_STAT1_REG %x\n", __func__,
656 val);
657 if ((val & VBUS_DET_DBNC1) && (val & VBUS_DET_DBNC100))
658 result |= USB_PW_CONN;
659
660 return result;
661}
662
663
664
665
666
667
668
669
670
671
672static int ab8500_charger_max_usb_curr(struct ab8500_charger *di,
673 enum ab8500_charger_link_status link_status)
674{
675 int ret = 0;
676
677 di->usb_device_is_unrecognised = false;
678
679
680
681
682
683
684
685
686 switch (link_status) {
687 case USB_STAT_STD_HOST_NC:
688 case USB_STAT_STD_HOST_C_NS:
689 case USB_STAT_STD_HOST_C_S:
690 dev_dbg(di->dev, "USB Type - Standard host is "
691 "detected through USB driver\n");
692 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
693 di->is_aca_rid = 0;
694 break;
695 case USB_STAT_HOST_CHG_HS_CHIRP:
696 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
697 di->is_aca_rid = 0;
698 break;
699 case USB_STAT_HOST_CHG_HS:
700 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
701 di->is_aca_rid = 0;
702 break;
703 case USB_STAT_ACA_RID_C_HS:
704 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P9;
705 di->is_aca_rid = 0;
706 break;
707 case USB_STAT_ACA_RID_A:
708
709
710
711
712 dev_dbg(di->dev, "USB_STAT_ACA_RID_A detected\n");
713 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
714 di->is_aca_rid = 1;
715 break;
716 case USB_STAT_ACA_RID_B:
717
718
719
720
721 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P3;
722 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
723 di->max_usb_in_curr.usb_type_max);
724 di->is_aca_rid = 1;
725 break;
726 case USB_STAT_HOST_CHG_NM:
727 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
728 di->is_aca_rid = 0;
729 break;
730 case USB_STAT_DEDICATED_CHG:
731 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P5;
732 di->is_aca_rid = 0;
733 break;
734 case USB_STAT_ACA_RID_C_HS_CHIRP:
735 case USB_STAT_ACA_RID_C_NM:
736 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_1P5;
737 di->is_aca_rid = 1;
738 break;
739 case USB_STAT_NOT_CONFIGURED:
740 if (di->vbus_detected) {
741 di->usb_device_is_unrecognised = true;
742 dev_dbg(di->dev, "USB Type - Legacy charger.\n");
743 di->max_usb_in_curr.usb_type_max =
744 USB_CH_IP_CUR_LVL_1P5;
745 break;
746 }
747 case USB_STAT_HM_IDGND:
748 dev_err(di->dev, "USB Type - Charging not allowed\n");
749 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05;
750 ret = -ENXIO;
751 break;
752 case USB_STAT_RESERVED:
753 if (is_ab8500(di->parent)) {
754 di->flags.vbus_collapse = true;
755 dev_err(di->dev, "USB Type - USB_STAT_RESERVED "
756 "VBUS has collapsed\n");
757 ret = -ENXIO;
758 break;
759 } else {
760 dev_dbg(di->dev, "USB Type - Charging not allowed\n");
761 di->max_usb_in_curr.usb_type_max =
762 USB_CH_IP_CUR_LVL_0P05;
763 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
764 link_status,
765 di->max_usb_in_curr.usb_type_max);
766 ret = -ENXIO;
767 break;
768 }
769 break;
770 case USB_STAT_CARKIT_1:
771 case USB_STAT_CARKIT_2:
772 case USB_STAT_ACA_DOCK_CHARGER:
773 case USB_STAT_CHARGER_LINE_1:
774 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
775 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d", link_status,
776 di->max_usb_in_curr.usb_type_max);
777 case USB_STAT_NOT_VALID_LINK:
778 dev_err(di->dev, "USB Type invalid - try charging anyway\n");
779 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
780 break;
781
782 default:
783 dev_err(di->dev, "USB Type - Unknown\n");
784 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05;
785 ret = -ENXIO;
786 break;
787 };
788
789 di->max_usb_in_curr.set_max = di->max_usb_in_curr.usb_type_max;
790 dev_dbg(di->dev, "USB Type - 0x%02x MaxCurr: %d",
791 link_status, di->max_usb_in_curr.set_max);
792
793 return ret;
794}
795
796
797
798
799
800
801
802
803static int ab8500_charger_read_usb_type(struct ab8500_charger *di)
804{
805 int ret;
806 u8 val;
807
808 ret = abx500_get_register_interruptible(di->dev,
809 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG, &val);
810 if (ret < 0) {
811 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
812 return ret;
813 }
814 if (is_ab8500(di->parent))
815 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
816 AB8500_USB_LINE_STAT_REG, &val);
817 else
818 ret = abx500_get_register_interruptible(di->dev,
819 AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val);
820 if (ret < 0) {
821 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
822 return ret;
823 }
824
825
826 if (is_ab8500(di->parent))
827 val = (val & AB8500_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT;
828 else
829 val = (val & AB8505_USB_LINK_STATUS) >> USB_LINK_STATUS_SHIFT;
830 ret = ab8500_charger_max_usb_curr(di,
831 (enum ab8500_charger_link_status) val);
832
833 return ret;
834}
835
836
837
838
839
840
841
842
843static int ab8500_charger_detect_usb_type(struct ab8500_charger *di)
844{
845 int i, ret;
846 u8 val;
847
848
849
850
851
852
853 for (i = 0; i < 10; i++) {
854 msleep(250);
855 ret = abx500_get_register_interruptible(di->dev,
856 AB8500_INTERRUPT, AB8500_IT_SOURCE21_REG,
857 &val);
858 dev_dbg(di->dev, "%s AB8500_IT_SOURCE21_REG %x\n",
859 __func__, val);
860 if (ret < 0) {
861 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
862 return ret;
863 }
864
865 if (is_ab8500(di->parent))
866 ret = abx500_get_register_interruptible(di->dev,
867 AB8500_USB, AB8500_USB_LINE_STAT_REG, &val);
868 else
869 ret = abx500_get_register_interruptible(di->dev,
870 AB8500_USB, AB8500_USB_LINK1_STAT_REG, &val);
871 if (ret < 0) {
872 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
873 return ret;
874 }
875 dev_dbg(di->dev, "%s AB8500_USB_LINE_STAT_REG %x\n", __func__,
876 val);
877
878
879
880
881
882
883
884 if (is_ab8500(di->parent))
885 val = (val & AB8500_USB_LINK_STATUS) >>
886 USB_LINK_STATUS_SHIFT;
887 else
888 val = (val & AB8505_USB_LINK_STATUS) >>
889 USB_LINK_STATUS_SHIFT;
890 if (val)
891 break;
892 }
893 ret = ab8500_charger_max_usb_curr(di,
894 (enum ab8500_charger_link_status) val);
895
896 return ret;
897}
898
899
900
901
902
903static int ab8500_charger_voltage_map[] = {
904 3500 ,
905 3525 ,
906 3550 ,
907 3575 ,
908 3600 ,
909 3625 ,
910 3650 ,
911 3675 ,
912 3700 ,
913 3725 ,
914 3750 ,
915 3775 ,
916 3800 ,
917 3825 ,
918 3850 ,
919 3875 ,
920 3900 ,
921 3925 ,
922 3950 ,
923 3975 ,
924 4000 ,
925 4025 ,
926 4050 ,
927 4060 ,
928 4070 ,
929 4080 ,
930 4090 ,
931 4100 ,
932 4110 ,
933 4120 ,
934 4130 ,
935 4140 ,
936 4150 ,
937 4160 ,
938 4170 ,
939 4180 ,
940 4190 ,
941 4200 ,
942 4210 ,
943 4220 ,
944 4230 ,
945 4240 ,
946 4250 ,
947 4260 ,
948 4270 ,
949 4280 ,
950 4290 ,
951 4300 ,
952 4310 ,
953 4320 ,
954 4330 ,
955 4340 ,
956 4350 ,
957 4360 ,
958 4370 ,
959 4380 ,
960 4390 ,
961 4400 ,
962 4410 ,
963 4420 ,
964 4430 ,
965 4440 ,
966 4450 ,
967 4460 ,
968 4470 ,
969 4480 ,
970 4490 ,
971 4500 ,
972 4510 ,
973 4520 ,
974 4530 ,
975 4540 ,
976 4550 ,
977 4560 ,
978 4570 ,
979 4580 ,
980 4590 ,
981 4600 ,
982};
983
984static int ab8500_voltage_to_regval(int voltage)
985{
986 int i;
987
988
989 if (voltage < ab8500_charger_voltage_map[0])
990 return LOW_VOLT_REG;
991
992 for (i = 1; i < ARRAY_SIZE(ab8500_charger_voltage_map); i++) {
993 if (voltage < ab8500_charger_voltage_map[i])
994 return i - 1;
995 }
996
997
998 i = ARRAY_SIZE(ab8500_charger_voltage_map) - 1;
999 if (voltage == ab8500_charger_voltage_map[i])
1000 return i;
1001 else
1002 return -1;
1003}
1004
1005static int ab8500_current_to_regval(struct ab8500_charger *di, int curr)
1006{
1007 int i;
1008
1009 if (curr < di->bm->chg_output_curr[0])
1010 return 0;
1011
1012 for (i = 0; i < di->bm->n_chg_out_curr; i++) {
1013 if (curr < di->bm->chg_output_curr[i])
1014 return i - 1;
1015 }
1016
1017
1018 i = di->bm->n_chg_out_curr - 1;
1019 if (curr == di->bm->chg_output_curr[i])
1020 return i;
1021 else
1022 return -1;
1023}
1024
1025static int ab8500_vbus_in_curr_to_regval(struct ab8500_charger *di, int curr)
1026{
1027 int i;
1028
1029 if (curr < di->bm->chg_input_curr[0])
1030 return 0;
1031
1032 for (i = 0; i < di->bm->n_chg_in_curr; i++) {
1033 if (curr < di->bm->chg_input_curr[i])
1034 return i - 1;
1035 }
1036
1037
1038 i = di->bm->n_chg_in_curr - 1;
1039 if (curr == di->bm->chg_input_curr[i])
1040 return i;
1041 else
1042 return -1;
1043}
1044
1045
1046
1047
1048
1049
1050
1051
1052
1053
1054static int ab8500_charger_get_usb_cur(struct ab8500_charger *di)
1055{
1056 int ret = 0;
1057 switch (di->usb_state.usb_current) {
1058 case 100:
1059 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P09;
1060 break;
1061 case 200:
1062 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P19;
1063 break;
1064 case 300:
1065 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P29;
1066 break;
1067 case 400:
1068 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P38;
1069 break;
1070 case 500:
1071 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P5;
1072 break;
1073 default:
1074 di->max_usb_in_curr.usb_type_max = USB_CH_IP_CUR_LVL_0P05;
1075 ret = -EPERM;
1076 break;
1077 };
1078 di->max_usb_in_curr.set_max = di->max_usb_in_curr.usb_type_max;
1079 return ret;
1080}
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091static bool ab8500_charger_check_continue_stepping(struct ab8500_charger *di,
1092 int reg)
1093{
1094 if (reg == AB8500_USBCH_IPT_CRNTLVL_REG)
1095 return !di->flags.vbus_drop_end;
1096 else
1097 return true;
1098}
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113static int ab8500_charger_set_current(struct ab8500_charger *di,
1114 int ich, int reg)
1115{
1116 int ret = 0;
1117 int curr_index, prev_curr_index, shift_value, i;
1118 u8 reg_value;
1119 u32 step_udelay;
1120 bool no_stepping = false;
1121
1122 atomic_inc(&di->current_stepping_sessions);
1123
1124 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1125 reg, ®_value);
1126 if (ret < 0) {
1127 dev_err(di->dev, "%s read failed\n", __func__);
1128 goto exit_set_current;
1129 }
1130
1131 switch (reg) {
1132 case AB8500_MCH_IPT_CURLVL_REG:
1133 shift_value = MAIN_CH_INPUT_CURR_SHIFT;
1134 prev_curr_index = (reg_value >> shift_value);
1135 curr_index = ab8500_current_to_regval(di, ich);
1136 step_udelay = STEP_UDELAY;
1137 if (!di->ac.charger_connected)
1138 no_stepping = true;
1139 break;
1140 case AB8500_USBCH_IPT_CRNTLVL_REG:
1141 if (is_ab8540(di->parent))
1142 shift_value = AB8540_VBUS_IN_CURR_LIM_SHIFT;
1143 else
1144 shift_value = VBUS_IN_CURR_LIM_SHIFT;
1145 prev_curr_index = (reg_value >> shift_value);
1146 curr_index = ab8500_vbus_in_curr_to_regval(di, ich);
1147 step_udelay = STEP_UDELAY * 100;
1148
1149 if (!di->usb.charger_connected)
1150 no_stepping = true;
1151 break;
1152 case AB8500_CH_OPT_CRNTLVL_REG:
1153 shift_value = 0;
1154 prev_curr_index = (reg_value >> shift_value);
1155 curr_index = ab8500_current_to_regval(di, ich);
1156 step_udelay = STEP_UDELAY;
1157 if (curr_index && (curr_index - prev_curr_index) > 1)
1158 step_udelay *= 100;
1159
1160 if (!di->usb.charger_connected && !di->ac.charger_connected)
1161 no_stepping = true;
1162
1163 break;
1164 default:
1165 dev_err(di->dev, "%s current register not valid\n", __func__);
1166 ret = -ENXIO;
1167 goto exit_set_current;
1168 }
1169
1170 if (curr_index < 0) {
1171 dev_err(di->dev, "requested current limit out-of-range\n");
1172 ret = -ENXIO;
1173 goto exit_set_current;
1174 }
1175
1176
1177 if (prev_curr_index == curr_index) {
1178 dev_dbg(di->dev, "%s current not changed for reg: 0x%02x\n",
1179 __func__, reg);
1180 ret = 0;
1181 goto exit_set_current;
1182 }
1183
1184 dev_dbg(di->dev, "%s set charger current: %d mA for reg: 0x%02x\n",
1185 __func__, ich, reg);
1186
1187 if (no_stepping) {
1188 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1189 reg, (u8)curr_index << shift_value);
1190 if (ret)
1191 dev_err(di->dev, "%s write failed\n", __func__);
1192 } else if (prev_curr_index > curr_index) {
1193 for (i = prev_curr_index - 1; i >= curr_index; i--) {
1194 dev_dbg(di->dev, "curr change_1 to: %x for 0x%02x\n",
1195 (u8) i << shift_value, reg);
1196 ret = abx500_set_register_interruptible(di->dev,
1197 AB8500_CHARGER, reg, (u8)i << shift_value);
1198 if (ret) {
1199 dev_err(di->dev, "%s write failed\n", __func__);
1200 goto exit_set_current;
1201 }
1202 if (i != curr_index)
1203 usleep_range(step_udelay, step_udelay * 2);
1204 }
1205 } else {
1206 bool allow = true;
1207 for (i = prev_curr_index + 1; i <= curr_index && allow; i++) {
1208 dev_dbg(di->dev, "curr change_2 to: %x for 0x%02x\n",
1209 (u8)i << shift_value, reg);
1210 ret = abx500_set_register_interruptible(di->dev,
1211 AB8500_CHARGER, reg, (u8)i << shift_value);
1212 if (ret) {
1213 dev_err(di->dev, "%s write failed\n", __func__);
1214 goto exit_set_current;
1215 }
1216 if (i != curr_index)
1217 usleep_range(step_udelay, step_udelay * 2);
1218
1219 allow = ab8500_charger_check_continue_stepping(di, reg);
1220 }
1221 }
1222
1223exit_set_current:
1224 atomic_dec(&di->current_stepping_sessions);
1225
1226 return ret;
1227}
1228
1229
1230
1231
1232
1233
1234
1235
1236
1237static int ab8500_charger_set_vbus_in_curr(struct ab8500_charger *di,
1238 int ich_in)
1239{
1240 int min_value;
1241 int ret;
1242
1243
1244 min_value = min(di->bm->chg_params->usb_curr_max, ich_in);
1245 if (di->max_usb_in_curr.set_max > 0)
1246 min_value = min(di->max_usb_in_curr.set_max, min_value);
1247
1248 if (di->usb_state.usb_current >= 0)
1249 min_value = min(di->usb_state.usb_current, min_value);
1250
1251 switch (min_value) {
1252 case 100:
1253 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1254 min_value = USB_CH_IP_CUR_LVL_0P05;
1255 break;
1256 case 500:
1257 if (di->vbat < VBAT_TRESH_IP_CUR_RED)
1258 min_value = USB_CH_IP_CUR_LVL_0P45;
1259 break;
1260 default:
1261 break;
1262 }
1263
1264 dev_info(di->dev, "VBUS input current limit set to %d mA\n", min_value);
1265
1266 mutex_lock(&di->usb_ipt_crnt_lock);
1267 ret = ab8500_charger_set_current(di, min_value,
1268 AB8500_USBCH_IPT_CRNTLVL_REG);
1269 mutex_unlock(&di->usb_ipt_crnt_lock);
1270
1271 return ret;
1272}
1273
1274
1275
1276
1277
1278
1279
1280
1281
1282static int ab8500_charger_set_main_in_curr(struct ab8500_charger *di,
1283 int ich_in)
1284{
1285 return ab8500_charger_set_current(di, ich_in,
1286 AB8500_MCH_IPT_CURLVL_REG);
1287}
1288
1289
1290
1291
1292
1293
1294
1295
1296
1297static int ab8500_charger_set_output_curr(struct ab8500_charger *di,
1298 int ich_out)
1299{
1300 return ab8500_charger_set_current(di, ich_out,
1301 AB8500_CH_OPT_CRNTLVL_REG);
1302}
1303
1304
1305
1306
1307
1308
1309
1310
1311
1312static int ab8500_charger_led_en(struct ab8500_charger *di, int on)
1313{
1314 int ret;
1315
1316 if (on) {
1317
1318 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1319 AB8500_LED_INDICATOR_PWM_CTRL,
1320 (LED_IND_CUR_5MA | LED_INDICATOR_PWM_ENA));
1321 if (ret) {
1322 dev_err(di->dev, "Power ON LED failed\n");
1323 return ret;
1324 }
1325
1326 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1327 AB8500_LED_INDICATOR_PWM_DUTY,
1328 LED_INDICATOR_PWM_DUTY_252_256);
1329 if (ret) {
1330 dev_err(di->dev, "Set LED PWM duty cycle failed\n");
1331 return ret;
1332 }
1333 } else {
1334
1335 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1336 AB8500_LED_INDICATOR_PWM_CTRL,
1337 LED_INDICATOR_PWM_DIS);
1338 if (ret) {
1339 dev_err(di->dev, "Power-off LED failed\n");
1340 return ret;
1341 }
1342 }
1343
1344 return ret;
1345}
1346
1347
1348
1349
1350
1351
1352
1353
1354
1355
1356
1357static int ab8500_charger_ac_en(struct ux500_charger *charger,
1358 int enable, int vset, int iset)
1359{
1360 int ret;
1361 int volt_index;
1362 int curr_index;
1363 int input_curr_index;
1364 u8 overshoot = 0;
1365
1366 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1367
1368 if (enable) {
1369
1370 if (!di->ac.charger_connected) {
1371 dev_err(di->dev, "AC charger not connected\n");
1372 return -ENXIO;
1373 }
1374
1375
1376 dev_dbg(di->dev, "Enable AC: %dmV %dmA\n", vset, iset);
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388 if (!di->vddadc_en_ac) {
1389 regulator_enable(di->regu);
1390 di->vddadc_en_ac = true;
1391 }
1392
1393
1394 volt_index = ab8500_voltage_to_regval(vset);
1395 curr_index = ab8500_current_to_regval(di, iset);
1396 input_curr_index = ab8500_current_to_regval(di,
1397 di->bm->chg_params->ac_curr_max);
1398 if (volt_index < 0 || curr_index < 0 || input_curr_index < 0) {
1399 dev_err(di->dev,
1400 "Charger voltage or current too high, "
1401 "charging not started\n");
1402 return -ENXIO;
1403 }
1404
1405
1406 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1407 AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1408 if (ret) {
1409 dev_err(di->dev, "%s write failed\n", __func__);
1410 return ret;
1411 }
1412
1413 ret = ab8500_charger_set_main_in_curr(di,
1414 di->bm->chg_params->ac_curr_max);
1415 if (ret) {
1416 dev_err(di->dev, "%s Failed to set MainChInputCurr\n",
1417 __func__);
1418 return ret;
1419 }
1420
1421 ret = ab8500_charger_set_output_curr(di, iset);
1422 if (ret) {
1423 dev_err(di->dev, "%s "
1424 "Failed to set ChOutputCurentLevel\n",
1425 __func__);
1426 return ret;
1427 }
1428
1429
1430 if (!di->bm->enable_overshoot)
1431 overshoot = MAIN_CH_NO_OVERSHOOT_ENA_N;
1432
1433
1434 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1435 AB8500_MCH_CTRL1, MAIN_CH_ENA | overshoot);
1436 if (ret) {
1437 dev_err(di->dev, "%s write failed\n", __func__);
1438 return ret;
1439 }
1440
1441
1442 ret = ab8500_charger_led_en(di, true);
1443 if (ret < 0)
1444 dev_err(di->dev, "failed to enable LED\n");
1445
1446 di->ac.charger_online = 1;
1447 } else {
1448
1449 if (is_ab8500_1p1_or_earlier(di->parent)) {
1450
1451
1452
1453
1454
1455
1456
1457
1458
1459
1460 if (di->ac_conn) {
1461 queue_delayed_work(di->charger_wq,
1462 &di->kick_wd_work,
1463 round_jiffies(WD_KICK_INTERVAL));
1464 }
1465
1466
1467
1468
1469
1470
1471
1472
1473 ret = abx500_set_register_interruptible(di->dev,
1474 AB8500_CHARGER,
1475 AB8500_CH_VOLT_LVL_REG, CH_VOL_LVL_3P5);
1476 if (ret) {
1477 dev_err(di->dev,
1478 "%s write failed\n", __func__);
1479 return ret;
1480 }
1481
1482 ret = ab8500_charger_set_output_curr(di, 0);
1483 if (ret) {
1484 dev_err(di->dev, "%s "
1485 "Failed to set ChOutputCurentLevel\n",
1486 __func__);
1487 return ret;
1488 }
1489 } else {
1490 ret = abx500_set_register_interruptible(di->dev,
1491 AB8500_CHARGER,
1492 AB8500_MCH_CTRL1, 0);
1493 if (ret) {
1494 dev_err(di->dev,
1495 "%s write failed\n", __func__);
1496 return ret;
1497 }
1498 }
1499
1500 ret = ab8500_charger_led_en(di, false);
1501 if (ret < 0)
1502 dev_err(di->dev, "failed to disable LED\n");
1503
1504 di->ac.charger_online = 0;
1505 di->ac.wd_expired = false;
1506
1507
1508 if (di->vddadc_en_ac) {
1509 regulator_disable(di->regu);
1510 di->vddadc_en_ac = false;
1511 }
1512
1513 dev_dbg(di->dev, "%s Disabled AC charging\n", __func__);
1514 }
1515 ab8500_power_supply_changed(di, &di->ac_chg.psy);
1516
1517 return ret;
1518}
1519
1520
1521
1522
1523
1524
1525
1526
1527
1528
1529
1530static int ab8500_charger_usb_en(struct ux500_charger *charger,
1531 int enable, int vset, int ich_out)
1532{
1533 int ret;
1534 int volt_index;
1535 int curr_index;
1536 u8 overshoot = 0;
1537
1538 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1539
1540 if (enable) {
1541
1542 if (!di->usb.charger_connected) {
1543 dev_err(di->dev, "USB charger not connected\n");
1544 return -ENXIO;
1545 }
1546
1547
1548
1549
1550
1551
1552
1553
1554
1555
1556
1557 if (!di->vddadc_en_usb) {
1558 regulator_enable(di->regu);
1559 di->vddadc_en_usb = true;
1560 }
1561
1562
1563 dev_dbg(di->dev, "Enable USB: %dmV %dmA\n", vset, ich_out);
1564
1565
1566 volt_index = ab8500_voltage_to_regval(vset);
1567 curr_index = ab8500_current_to_regval(di, ich_out);
1568 if (volt_index < 0 || curr_index < 0) {
1569 dev_err(di->dev,
1570 "Charger voltage or current too high, "
1571 "charging not started\n");
1572 return -ENXIO;
1573 }
1574
1575
1576 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1577 AB8500_CH_VOLT_LVL_REG, (u8) volt_index);
1578 if (ret) {
1579 dev_err(di->dev, "%s write failed\n", __func__);
1580 return ret;
1581 }
1582
1583 if (!di->bm->enable_overshoot)
1584 overshoot = USB_CHG_NO_OVERSHOOT_ENA_N;
1585
1586
1587 dev_dbg(di->dev,
1588 "Enabling USB with write to AB8500_USBCH_CTRL1_REG\n");
1589 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1590 AB8500_USBCH_CTRL1_REG, USB_CH_ENA | overshoot);
1591 if (ret) {
1592 dev_err(di->dev, "%s write failed\n", __func__);
1593 return ret;
1594 }
1595
1596
1597 ret = ab8500_charger_led_en(di, true);
1598 if (ret < 0)
1599 dev_err(di->dev, "failed to enable LED\n");
1600
1601 di->usb.charger_online = 1;
1602
1603
1604 ret = ab8500_charger_set_vbus_in_curr(di,
1605 di->max_usb_in_curr.usb_type_max);
1606 if (ret) {
1607 dev_err(di->dev, "setting USBChInputCurr failed\n");
1608 return ret;
1609 }
1610
1611
1612 ret = ab8500_charger_set_output_curr(di, ich_out);
1613 if (ret) {
1614 dev_err(di->dev, "%s "
1615 "Failed to set ChOutputCurentLevel\n",
1616 __func__);
1617 return ret;
1618 }
1619
1620 queue_delayed_work(di->charger_wq, &di->check_vbat_work, HZ);
1621
1622 } else {
1623
1624 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1625 ret = abx500_set_register_interruptible(di->dev,
1626 AB8500_CHARGER,
1627 AB8500_USBCH_CTRL1_REG, 0);
1628 if (ret) {
1629 dev_err(di->dev,
1630 "%s write failed\n", __func__);
1631 return ret;
1632 }
1633
1634 ret = ab8500_charger_led_en(di, false);
1635 if (ret < 0)
1636 dev_err(di->dev, "failed to disable LED\n");
1637
1638 ret = ab8500_charger_set_vbus_in_curr(di, 0);
1639 if (ret) {
1640 dev_err(di->dev, "setting USBChInputCurr failed\n");
1641 return ret;
1642 }
1643
1644
1645 ret = ab8500_charger_set_output_curr(di, 0);
1646 if (ret) {
1647 dev_err(di->dev, "%s "
1648 "Failed to reset ChOutputCurentLevel\n",
1649 __func__);
1650 return ret;
1651 }
1652 di->usb.charger_online = 0;
1653 di->usb.wd_expired = false;
1654
1655
1656 if (di->vddadc_en_usb) {
1657 regulator_disable(di->regu);
1658 di->vddadc_en_usb = false;
1659 }
1660
1661 dev_dbg(di->dev, "%s Disabled USB charging\n", __func__);
1662
1663
1664 cancel_delayed_work(&di->check_vbat_work);
1665
1666 }
1667 ab8500_power_supply_changed(di, &di->usb_chg.psy);
1668
1669 return ret;
1670}
1671
1672static int ab8500_external_charger_prepare(struct notifier_block *charger_nb,
1673 unsigned long event, void *data)
1674{
1675 int ret;
1676 struct device *dev = data;
1677
1678 ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK,
1679 AB8500_SYS_CHARGER_CONTROL_REG,
1680 EXTERNAL_CHARGER_DISABLE_REG_VAL);
1681 if (ret < 0) {
1682 dev_err(dev, "write reg failed %d\n", ret);
1683 goto out;
1684 }
1685 ret = abx500_set_register_interruptible(dev, AB8500_SYS_CTRL1_BLOCK,
1686 AB8500_SYS_CHARGER_CONTROL_REG,
1687 EXTERNAL_CHARGER_ENABLE_REG_VAL);
1688 if (ret < 0)
1689 dev_err(dev, "Write reg failed %d\n", ret);
1690
1691out:
1692 return ret;
1693}
1694
1695
1696
1697
1698
1699
1700
1701
1702
1703
1704static int ab8500_charger_usb_check_enable(struct ux500_charger *charger,
1705 int vset, int iset)
1706{
1707 u8 usbch_ctrl1 = 0;
1708 int ret = 0;
1709
1710 struct ab8500_charger *di = to_ab8500_charger_usb_device_info(charger);
1711
1712 if (!di->usb.charger_connected)
1713 return ret;
1714
1715 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1716 AB8500_USBCH_CTRL1_REG, &usbch_ctrl1);
1717 if (ret < 0) {
1718 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1719 return ret;
1720 }
1721 dev_dbg(di->dev, "USB charger ctrl: 0x%02x\n", usbch_ctrl1);
1722
1723 if (!(usbch_ctrl1 & USB_CH_ENA)) {
1724 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1725
1726 ret = abx500_mask_and_set_register_interruptible(di->dev,
1727 AB8500_CHARGER, AB8500_CHARGER_CTRL,
1728 DROP_COUNT_RESET, DROP_COUNT_RESET);
1729 if (ret < 0) {
1730 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1731 return ret;
1732 }
1733
1734 ret = ab8500_charger_usb_en(&di->usb_chg, true, vset, iset);
1735 if (ret < 0) {
1736 dev_err(di->dev, "Failed to enable VBUS charger %d\n",
1737 __LINE__);
1738 return ret;
1739 }
1740 }
1741 return ret;
1742}
1743
1744
1745
1746
1747
1748
1749
1750
1751
1752
1753static int ab8500_charger_ac_check_enable(struct ux500_charger *charger,
1754 int vset, int iset)
1755{
1756 u8 mainch_ctrl1 = 0;
1757 int ret = 0;
1758
1759 struct ab8500_charger *di = to_ab8500_charger_ac_device_info(charger);
1760
1761 if (!di->ac.charger_connected)
1762 return ret;
1763
1764 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
1765 AB8500_MCH_CTRL1, &mainch_ctrl1);
1766 if (ret < 0) {
1767 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
1768 return ret;
1769 }
1770 dev_dbg(di->dev, "AC charger ctrl: 0x%02x\n", mainch_ctrl1);
1771
1772 if (!(mainch_ctrl1 & MAIN_CH_ENA)) {
1773 dev_info(di->dev, "Charging has been disabled abnormally and will be re-enabled\n");
1774
1775 ret = abx500_mask_and_set_register_interruptible(di->dev,
1776 AB8500_CHARGER, AB8500_CHARGER_CTRL,
1777 DROP_COUNT_RESET, DROP_COUNT_RESET);
1778
1779 if (ret < 0) {
1780 dev_err(di->dev, "ab8500 write failed %d\n", __LINE__);
1781 return ret;
1782 }
1783
1784 ret = ab8500_charger_ac_en(&di->usb_chg, true, vset, iset);
1785 if (ret < 0) {
1786 dev_err(di->dev, "failed to enable AC charger %d\n",
1787 __LINE__);
1788 return ret;
1789 }
1790 }
1791 return ret;
1792}
1793
1794
1795
1796
1797
1798
1799
1800
1801static int ab8500_charger_watchdog_kick(struct ux500_charger *charger)
1802{
1803 int ret;
1804 struct ab8500_charger *di;
1805
1806 if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
1807 di = to_ab8500_charger_ac_device_info(charger);
1808 else if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1809 di = to_ab8500_charger_usb_device_info(charger);
1810 else
1811 return -ENXIO;
1812
1813 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1814 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
1815 if (ret)
1816 dev_err(di->dev, "Failed to kick WD!\n");
1817
1818 return ret;
1819}
1820
1821
1822
1823
1824
1825
1826
1827
1828static int ab8500_charger_update_charger_current(struct ux500_charger *charger,
1829 int ich_out)
1830{
1831 int ret;
1832 struct ab8500_charger *di;
1833
1834 if (charger->psy.type == POWER_SUPPLY_TYPE_MAINS)
1835 di = to_ab8500_charger_ac_device_info(charger);
1836 else if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1837 di = to_ab8500_charger_usb_device_info(charger);
1838 else
1839 return -ENXIO;
1840
1841 ret = ab8500_charger_set_output_curr(di, ich_out);
1842 if (ret) {
1843 dev_err(di->dev, "%s "
1844 "Failed to set ChOutputCurentLevel\n",
1845 __func__);
1846 return ret;
1847 }
1848
1849
1850 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
1851 AB8500_CHARGER_CTRL, DROP_COUNT_RESET);
1852 if (ret) {
1853 dev_err(di->dev, "%s write failed\n", __func__);
1854 return ret;
1855 }
1856
1857 return ret;
1858}
1859
1860
1861
1862
1863
1864
1865
1866
1867
1868static int ab8540_charger_power_path_enable(struct ux500_charger *charger,
1869 bool enable)
1870{
1871 int ret;
1872 struct ab8500_charger *di;
1873
1874 if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1875 di = to_ab8500_charger_usb_device_info(charger);
1876 else
1877 return -ENXIO;
1878
1879 ret = abx500_mask_and_set_register_interruptible(di->dev,
1880 AB8500_CHARGER, AB8540_USB_PP_MODE_REG,
1881 BUS_POWER_PATH_MODE_ENA, enable);
1882 if (ret) {
1883 dev_err(di->dev, "%s write failed\n", __func__);
1884 return ret;
1885 }
1886
1887 return ret;
1888}
1889
1890
1891
1892
1893
1894
1895
1896
1897
1898
1899static int ab8540_charger_usb_pre_chg_enable(struct ux500_charger *charger,
1900 bool enable)
1901{
1902 int ret;
1903 struct ab8500_charger *di;
1904
1905 if (charger->psy.type == POWER_SUPPLY_TYPE_USB)
1906 di = to_ab8500_charger_usb_device_info(charger);
1907 else
1908 return -ENXIO;
1909
1910 ret = abx500_mask_and_set_register_interruptible(di->dev,
1911 AB8500_CHARGER, AB8540_USB_PP_CHR_REG,
1912 BUS_POWER_PATH_PRECHG_ENA, enable);
1913 if (ret) {
1914 dev_err(di->dev, "%s write failed\n", __func__);
1915 return ret;
1916 }
1917
1918 return ret;
1919}
1920
1921static int ab8500_charger_get_ext_psy_data(struct device *dev, void *data)
1922{
1923 struct power_supply *psy;
1924 struct power_supply *ext;
1925 struct ab8500_charger *di;
1926 union power_supply_propval ret;
1927 int i, j;
1928 bool psy_found = false;
1929 struct ux500_charger *usb_chg;
1930
1931 usb_chg = (struct ux500_charger *)data;
1932 psy = &usb_chg->psy;
1933
1934 di = to_ab8500_charger_usb_device_info(usb_chg);
1935
1936 ext = dev_get_drvdata(dev);
1937
1938
1939 for (i = 0; i < ext->num_supplicants; i++) {
1940 if (!strcmp(ext->supplied_to[i], psy->name))
1941 psy_found = true;
1942 }
1943
1944 if (!psy_found)
1945 return 0;
1946
1947
1948 for (j = 0; j < ext->num_properties; j++) {
1949 enum power_supply_property prop;
1950 prop = ext->properties[j];
1951
1952 if (ext->get_property(ext, prop, &ret))
1953 continue;
1954
1955 switch (prop) {
1956 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
1957 switch (ext->type) {
1958 case POWER_SUPPLY_TYPE_BATTERY:
1959 di->vbat = ret.intval / 1000;
1960 break;
1961 default:
1962 break;
1963 }
1964 break;
1965 default:
1966 break;
1967 }
1968 }
1969 return 0;
1970}
1971
1972
1973
1974
1975
1976
1977
1978
1979
1980
1981static void ab8500_charger_check_vbat_work(struct work_struct *work)
1982{
1983 int t = 10;
1984 struct ab8500_charger *di = container_of(work,
1985 struct ab8500_charger, check_vbat_work.work);
1986
1987 class_for_each_device(power_supply_class, NULL,
1988 &di->usb_chg.psy, ab8500_charger_get_ext_psy_data);
1989
1990
1991 if (di->old_vbat == 0)
1992 di->old_vbat = di->vbat;
1993
1994 if (!((di->old_vbat <= VBAT_TRESH_IP_CUR_RED &&
1995 di->vbat <= VBAT_TRESH_IP_CUR_RED) ||
1996 (di->old_vbat > VBAT_TRESH_IP_CUR_RED &&
1997 di->vbat > VBAT_TRESH_IP_CUR_RED))) {
1998
1999 dev_dbg(di->dev, "Vbat did cross threshold, curr: %d, new: %d,"
2000 " old: %d\n", di->max_usb_in_curr.usb_type_max,
2001 di->vbat, di->old_vbat);
2002 ab8500_charger_set_vbus_in_curr(di,
2003 di->max_usb_in_curr.usb_type_max);
2004 power_supply_changed(&di->usb_chg.psy);
2005 }
2006
2007 di->old_vbat = di->vbat;
2008
2009
2010
2011
2012
2013 if (di->vbat < (VBAT_TRESH_IP_CUR_RED + 100) &&
2014 (di->vbat > (VBAT_TRESH_IP_CUR_RED - 100)))
2015 t = 1;
2016
2017 queue_delayed_work(di->charger_wq, &di->check_vbat_work, t * HZ);
2018}
2019
2020
2021
2022
2023
2024
2025
2026static void ab8500_charger_check_hw_failure_work(struct work_struct *work)
2027{
2028 int ret;
2029 u8 reg_value;
2030
2031 struct ab8500_charger *di = container_of(work,
2032 struct ab8500_charger, check_hw_failure_work.work);
2033
2034
2035 if (di->flags.mainextchnotok) {
2036 ret = abx500_get_register_interruptible(di->dev,
2037 AB8500_CHARGER, AB8500_CH_STATUS2_REG, ®_value);
2038 if (ret < 0) {
2039 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2040 return;
2041 }
2042 if (!(reg_value & MAIN_CH_NOK)) {
2043 di->flags.mainextchnotok = false;
2044 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2045 }
2046 }
2047 if (di->flags.vbus_ovv) {
2048 ret = abx500_get_register_interruptible(di->dev,
2049 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG,
2050 ®_value);
2051 if (ret < 0) {
2052 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2053 return;
2054 }
2055 if (!(reg_value & VBUS_OVV_TH)) {
2056 di->flags.vbus_ovv = false;
2057 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2058 }
2059 }
2060
2061 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
2062 queue_delayed_work(di->charger_wq,
2063 &di->check_hw_failure_work, round_jiffies(HZ));
2064 }
2065}
2066
2067
2068
2069
2070
2071
2072
2073
2074
2075
2076
2077
2078
2079
2080
2081static void ab8500_charger_kick_watchdog_work(struct work_struct *work)
2082{
2083 int ret;
2084
2085 struct ab8500_charger *di = container_of(work,
2086 struct ab8500_charger, kick_wd_work.work);
2087
2088 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
2089 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
2090 if (ret)
2091 dev_err(di->dev, "Failed to kick WD!\n");
2092
2093
2094 queue_delayed_work(di->charger_wq,
2095 &di->kick_wd_work, round_jiffies(WD_KICK_INTERVAL));
2096}
2097
2098
2099
2100
2101
2102
2103
2104static void ab8500_charger_ac_work(struct work_struct *work)
2105{
2106 int ret;
2107
2108 struct ab8500_charger *di = container_of(work,
2109 struct ab8500_charger, ac_work);
2110
2111
2112
2113
2114
2115
2116 ret = ab8500_charger_detect_chargers(di, false);
2117 if (ret < 0)
2118 return;
2119
2120 if (ret & AC_PW_CONN) {
2121 di->ac.charger_connected = 1;
2122 di->ac_conn = true;
2123 } else {
2124 di->ac.charger_connected = 0;
2125 }
2126
2127 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2128 sysfs_notify(&di->ac_chg.psy.dev->kobj, NULL, "present");
2129}
2130
2131static void ab8500_charger_usb_attached_work(struct work_struct *work)
2132{
2133 struct ab8500_charger *di = container_of(work,
2134 struct ab8500_charger,
2135 usb_charger_attached_work.work);
2136 int usbch = (USB_CH_VBUSDROP | USB_CH_VBUSDETDBNC);
2137 int ret, i;
2138 u8 statval;
2139
2140 for (i = 0; i < 10; i++) {
2141 ret = abx500_get_register_interruptible(di->dev,
2142 AB8500_CHARGER,
2143 AB8500_CH_USBCH_STAT1_REG,
2144 &statval);
2145 if (ret < 0) {
2146 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2147 goto reschedule;
2148 }
2149 if ((statval & usbch) != usbch)
2150 goto reschedule;
2151
2152 msleep(CHARGER_STATUS_POLL);
2153 }
2154
2155 ab8500_charger_usb_en(&di->usb_chg, 0, 0, 0);
2156
2157 mutex_lock(&di->charger_attached_mutex);
2158 mutex_unlock(&di->charger_attached_mutex);
2159
2160 return;
2161
2162reschedule:
2163 queue_delayed_work(di->charger_wq,
2164 &di->usb_charger_attached_work,
2165 HZ);
2166}
2167
2168static void ab8500_charger_ac_attached_work(struct work_struct *work)
2169{
2170
2171 struct ab8500_charger *di = container_of(work,
2172 struct ab8500_charger,
2173 ac_charger_attached_work.work);
2174 int mainch = (MAIN_CH_STATUS2_MAINCHGDROP |
2175 MAIN_CH_STATUS2_MAINCHARGERDETDBNC);
2176 int ret, i;
2177 u8 statval;
2178
2179 for (i = 0; i < 10; i++) {
2180 ret = abx500_get_register_interruptible(di->dev,
2181 AB8500_CHARGER,
2182 AB8500_CH_STATUS2_REG,
2183 &statval);
2184 if (ret < 0) {
2185 dev_err(di->dev, "ab8500 read failed %d\n", __LINE__);
2186 goto reschedule;
2187 }
2188
2189 if ((statval & mainch) != mainch)
2190 goto reschedule;
2191
2192 msleep(CHARGER_STATUS_POLL);
2193 }
2194
2195 ab8500_charger_ac_en(&di->ac_chg, 0, 0, 0);
2196 queue_work(di->charger_wq, &di->ac_work);
2197
2198 mutex_lock(&di->charger_attached_mutex);
2199 mutex_unlock(&di->charger_attached_mutex);
2200
2201 return;
2202
2203reschedule:
2204 queue_delayed_work(di->charger_wq,
2205 &di->ac_charger_attached_work,
2206 HZ);
2207}
2208
2209
2210
2211
2212
2213
2214
2215static void ab8500_charger_detect_usb_type_work(struct work_struct *work)
2216{
2217 int ret;
2218
2219 struct ab8500_charger *di = container_of(work,
2220 struct ab8500_charger, detect_usb_type_work);
2221
2222
2223
2224
2225
2226
2227 ret = ab8500_charger_detect_chargers(di, false);
2228 if (ret < 0)
2229 return;
2230
2231 if (!(ret & USB_PW_CONN)) {
2232 dev_dbg(di->dev, "%s di->vbus_detected = false\n", __func__);
2233 di->vbus_detected = false;
2234 ab8500_charger_set_usb_connected(di, false);
2235 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2236 } else {
2237 dev_dbg(di->dev, "%s di->vbus_detected = true\n", __func__);
2238 di->vbus_detected = true;
2239
2240 if (is_ab8500_1p1_or_earlier(di->parent)) {
2241 ret = ab8500_charger_detect_usb_type(di);
2242 if (!ret) {
2243 ab8500_charger_set_usb_connected(di, true);
2244 ab8500_power_supply_changed(di,
2245 &di->usb_chg.psy);
2246 }
2247 } else {
2248
2249
2250
2251
2252
2253
2254
2255 if (di->vbus_detected_start) {
2256 di->vbus_detected_start = false;
2257 ret = ab8500_charger_detect_usb_type(di);
2258 if (!ret) {
2259 ab8500_charger_set_usb_connected(di,
2260 true);
2261 ab8500_power_supply_changed(di,
2262 &di->usb_chg.psy);
2263 }
2264 }
2265 }
2266 }
2267}
2268
2269
2270
2271
2272
2273
2274
2275static void ab8500_charger_usb_link_attach_work(struct work_struct *work)
2276{
2277 struct ab8500_charger *di =
2278 container_of(work, struct ab8500_charger, attach_work.work);
2279 int ret;
2280
2281
2282 if (!di->usb.charger_online) {
2283 ret = ab8500_charger_set_vbus_in_curr(di,
2284 di->max_usb_in_curr.usb_type_max);
2285 if (ret)
2286 return;
2287 }
2288
2289 ab8500_charger_set_usb_connected(di, true);
2290 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2291}
2292
2293
2294
2295
2296
2297
2298
2299static void ab8500_charger_usb_link_status_work(struct work_struct *work)
2300{
2301 int detected_chargers;
2302 int ret;
2303 u8 val;
2304 u8 link_status;
2305
2306 struct ab8500_charger *di = container_of(work,
2307 struct ab8500_charger, usb_link_status_work);
2308
2309
2310
2311
2312
2313
2314 detected_chargers = ab8500_charger_detect_chargers(di, false);
2315 if (detected_chargers < 0)
2316 return;
2317
2318
2319
2320
2321
2322
2323
2324 if (is_ab8500(di->parent))
2325 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2326 AB8500_USB_LINE_STAT_REG, &val);
2327 else
2328 ret = abx500_get_register_interruptible(di->dev, AB8500_USB,
2329 AB8500_USB_LINK1_STAT_REG, &val);
2330
2331 if (ret >= 0)
2332 dev_dbg(di->dev, "UsbLineStatus register = 0x%02x\n", val);
2333 else
2334 dev_dbg(di->dev, "Error reading USB link status\n");
2335
2336 if (is_ab8500(di->parent))
2337 link_status = AB8500_USB_LINK_STATUS;
2338 else
2339 link_status = AB8505_USB_LINK_STATUS;
2340
2341 if (detected_chargers & USB_PW_CONN) {
2342 if (((val & link_status) >> USB_LINK_STATUS_SHIFT) ==
2343 USB_STAT_NOT_VALID_LINK &&
2344 di->invalid_charger_detect_state == 0) {
2345 dev_dbg(di->dev,
2346 "Invalid charger detected, state= 0\n");
2347
2348 abx500_mask_and_set_register_interruptible(di->dev,
2349 AB8500_CHARGER, AB8500_USBCH_CTRL1_REG,
2350 USB_CH_ENA, USB_CH_ENA);
2351
2352 abx500_mask_and_set_register_interruptible(di->dev,
2353 AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2354 USB_CH_DET, USB_CH_DET);
2355 di->invalid_charger_detect_state = 1;
2356
2357 return;
2358
2359 }
2360 if (di->invalid_charger_detect_state == 1) {
2361 dev_dbg(di->dev,
2362 "Invalid charger detected, state= 1\n");
2363
2364 abx500_mask_and_set_register_interruptible(di->dev,
2365 AB8500_USB, AB8500_USB_LINE_CTRL2_REG,
2366 USB_CH_DET, 0x00);
2367
2368 if (is_ab8500(di->parent))
2369 ret = abx500_get_register_interruptible(di->dev,
2370 AB8500_USB, AB8500_USB_LINE_STAT_REG,
2371 &val);
2372 else
2373 ret = abx500_get_register_interruptible(di->dev,
2374 AB8500_USB, AB8500_USB_LINK1_STAT_REG,
2375 &val);
2376
2377 dev_dbg(di->dev, "USB link status= 0x%02x\n",
2378 (val & link_status) >> USB_LINK_STATUS_SHIFT);
2379 di->invalid_charger_detect_state = 2;
2380 }
2381 } else {
2382 di->invalid_charger_detect_state = 0;
2383 }
2384
2385 if (!(detected_chargers & USB_PW_CONN)) {
2386 di->vbus_detected = false;
2387 ab8500_charger_set_usb_connected(di, false);
2388 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2389 return;
2390 }
2391
2392 dev_dbg(di->dev,"%s di->vbus_detected = true\n",__func__);
2393 di->vbus_detected = true;
2394 ret = ab8500_charger_read_usb_type(di);
2395 if (ret) {
2396 if (ret == -ENXIO) {
2397
2398 ab8500_charger_set_usb_connected(di, false);
2399 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2400 }
2401 return;
2402 }
2403
2404 if (di->usb_device_is_unrecognised) {
2405 dev_dbg(di->dev,
2406 "Potential Legacy Charger device. "
2407 "Delay work for %d msec for USB enum "
2408 "to finish",
2409 WAIT_ACA_RID_ENUMERATION);
2410 queue_delayed_work(di->charger_wq,
2411 &di->attach_work,
2412 msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2413 } else if (di->is_aca_rid == 1) {
2414
2415 di->is_aca_rid++;
2416 dev_dbg(di->dev,
2417 "%s Wait %d msec for USB enum to finish",
2418 __func__, WAIT_ACA_RID_ENUMERATION);
2419 queue_delayed_work(di->charger_wq,
2420 &di->attach_work,
2421 msecs_to_jiffies(WAIT_ACA_RID_ENUMERATION));
2422 } else {
2423 queue_delayed_work(di->charger_wq,
2424 &di->attach_work,
2425 0);
2426 }
2427}
2428
2429static void ab8500_charger_usb_state_changed_work(struct work_struct *work)
2430{
2431 int ret;
2432 unsigned long flags;
2433
2434 struct ab8500_charger *di = container_of(work,
2435 struct ab8500_charger, usb_state_changed_work.work);
2436
2437 if (!di->vbus_detected) {
2438 dev_dbg(di->dev,
2439 "%s !di->vbus_detected\n",
2440 __func__);
2441 return;
2442 }
2443
2444 spin_lock_irqsave(&di->usb_state.usb_lock, flags);
2445 di->usb_state.state = di->usb_state.state_tmp;
2446 di->usb_state.usb_current = di->usb_state.usb_current_tmp;
2447 spin_unlock_irqrestore(&di->usb_state.usb_lock, flags);
2448
2449 dev_dbg(di->dev, "%s USB state: 0x%02x mA: %d\n",
2450 __func__, di->usb_state.state, di->usb_state.usb_current);
2451
2452 switch (di->usb_state.state) {
2453 case AB8500_BM_USB_STATE_RESET_HS:
2454 case AB8500_BM_USB_STATE_RESET_FS:
2455 case AB8500_BM_USB_STATE_SUSPEND:
2456 case AB8500_BM_USB_STATE_MAX:
2457 ab8500_charger_set_usb_connected(di, false);
2458 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2459 break;
2460
2461 case AB8500_BM_USB_STATE_RESUME:
2462
2463
2464
2465
2466 msleep(1000);
2467
2468 case AB8500_BM_USB_STATE_CONFIGURED:
2469
2470
2471
2472
2473 if (!ab8500_charger_get_usb_cur(di)) {
2474
2475 ret = ab8500_charger_set_vbus_in_curr(di,
2476 di->max_usb_in_curr.usb_type_max);
2477 if (ret)
2478 return;
2479
2480 ab8500_charger_set_usb_connected(di, true);
2481 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2482 }
2483 break;
2484
2485 default:
2486 break;
2487 };
2488}
2489
2490
2491
2492
2493
2494
2495
2496static void ab8500_charger_check_usbchargernotok_work(struct work_struct *work)
2497{
2498 int ret;
2499 u8 reg_value;
2500 bool prev_status;
2501
2502 struct ab8500_charger *di = container_of(work,
2503 struct ab8500_charger, check_usbchgnotok_work.work);
2504
2505
2506 ret = abx500_get_register_interruptible(di->dev,
2507 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, ®_value);
2508 if (ret < 0) {
2509 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2510 return;
2511 }
2512 prev_status = di->flags.usbchargernotok;
2513
2514 if (reg_value & VBUS_CH_NOK) {
2515 di->flags.usbchargernotok = true;
2516
2517 queue_delayed_work(di->charger_wq,
2518 &di->check_usbchgnotok_work, HZ);
2519 } else {
2520 di->flags.usbchargernotok = false;
2521 di->flags.vbus_collapse = false;
2522 }
2523
2524 if (prev_status != di->flags.usbchargernotok)
2525 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2526}
2527
2528
2529
2530
2531
2532
2533
2534static void ab8500_charger_check_main_thermal_prot_work(
2535 struct work_struct *work)
2536{
2537 int ret;
2538 u8 reg_value;
2539
2540 struct ab8500_charger *di = container_of(work,
2541 struct ab8500_charger, check_main_thermal_prot_work);
2542
2543
2544 ret = abx500_get_register_interruptible(di->dev,
2545 AB8500_CHARGER, AB8500_CH_STATUS2_REG, ®_value);
2546 if (ret < 0) {
2547 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2548 return;
2549 }
2550 if (reg_value & MAIN_CH_TH_PROT)
2551 di->flags.main_thermal_prot = true;
2552 else
2553 di->flags.main_thermal_prot = false;
2554
2555 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2556}
2557
2558
2559
2560
2561
2562
2563
2564static void ab8500_charger_check_usb_thermal_prot_work(
2565 struct work_struct *work)
2566{
2567 int ret;
2568 u8 reg_value;
2569
2570 struct ab8500_charger *di = container_of(work,
2571 struct ab8500_charger, check_usb_thermal_prot_work);
2572
2573
2574 ret = abx500_get_register_interruptible(di->dev,
2575 AB8500_CHARGER, AB8500_CH_USBCH_STAT2_REG, ®_value);
2576 if (ret < 0) {
2577 dev_err(di->dev, "%s ab8500 read failed\n", __func__);
2578 return;
2579 }
2580 if (reg_value & USB_CH_TH_PROT)
2581 di->flags.usb_thermal_prot = true;
2582 else
2583 di->flags.usb_thermal_prot = false;
2584
2585 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2586}
2587
2588
2589
2590
2591
2592
2593
2594
2595static irqreturn_t ab8500_charger_mainchunplugdet_handler(int irq, void *_di)
2596{
2597 struct ab8500_charger *di = _di;
2598
2599 dev_dbg(di->dev, "Main charger unplugged\n");
2600 queue_work(di->charger_wq, &di->ac_work);
2601
2602 cancel_delayed_work_sync(&di->ac_charger_attached_work);
2603 mutex_lock(&di->charger_attached_mutex);
2604 mutex_unlock(&di->charger_attached_mutex);
2605
2606 return IRQ_HANDLED;
2607}
2608
2609
2610
2611
2612
2613
2614
2615
2616static irqreturn_t ab8500_charger_mainchplugdet_handler(int irq, void *_di)
2617{
2618 struct ab8500_charger *di = _di;
2619
2620 dev_dbg(di->dev, "Main charger plugged\n");
2621 queue_work(di->charger_wq, &di->ac_work);
2622
2623 mutex_lock(&di->charger_attached_mutex);
2624 mutex_unlock(&di->charger_attached_mutex);
2625
2626 if (is_ab8500(di->parent))
2627 queue_delayed_work(di->charger_wq,
2628 &di->ac_charger_attached_work,
2629 HZ);
2630 return IRQ_HANDLED;
2631}
2632
2633
2634
2635
2636
2637
2638
2639
2640static irqreturn_t ab8500_charger_mainextchnotok_handler(int irq, void *_di)
2641{
2642 struct ab8500_charger *di = _di;
2643
2644 dev_dbg(di->dev, "Main charger not ok\n");
2645 di->flags.mainextchnotok = true;
2646 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2647
2648
2649 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2650
2651 return IRQ_HANDLED;
2652}
2653
2654
2655
2656
2657
2658
2659
2660
2661
2662static irqreturn_t ab8500_charger_mainchthprotr_handler(int irq, void *_di)
2663{
2664 struct ab8500_charger *di = _di;
2665
2666 dev_dbg(di->dev,
2667 "Die temp above Main charger thermal protection threshold\n");
2668 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2669
2670 return IRQ_HANDLED;
2671}
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681static irqreturn_t ab8500_charger_mainchthprotf_handler(int irq, void *_di)
2682{
2683 struct ab8500_charger *di = _di;
2684
2685 dev_dbg(di->dev,
2686 "Die temp ok for Main charger thermal protection threshold\n");
2687 queue_work(di->charger_wq, &di->check_main_thermal_prot_work);
2688
2689 return IRQ_HANDLED;
2690}
2691
2692static void ab8500_charger_vbus_drop_end_work(struct work_struct *work)
2693{
2694 struct ab8500_charger *di = container_of(work,
2695 struct ab8500_charger, vbus_drop_end_work.work);
2696 int ret, curr;
2697 u8 reg_value;
2698
2699 di->flags.vbus_drop_end = false;
2700
2701
2702 abx500_set_register_interruptible(di->dev,
2703 AB8500_CHARGER, AB8500_CHARGER_CTRL, 0x01);
2704
2705 if (is_ab8540(di->parent))
2706 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2707 AB8540_CH_USBCH_STAT3_REG, ®_value);
2708 else
2709 ret = abx500_get_register_interruptible(di->dev, AB8500_CHARGER,
2710 AB8500_CH_USBCH_STAT2_REG, ®_value);
2711 if (ret < 0) {
2712 dev_err(di->dev, "%s read failed\n", __func__);
2713 return;
2714 }
2715
2716 if (is_ab8540(di->parent))
2717 curr = di->bm->chg_input_curr[
2718 reg_value & AB8540_AUTO_VBUS_IN_CURR_MASK];
2719 else
2720 curr = di->bm->chg_input_curr[
2721 reg_value >> AUTO_VBUS_IN_CURR_LIM_SHIFT];
2722
2723 if (di->max_usb_in_curr.calculated_max != curr) {
2724
2725 di->max_usb_in_curr.calculated_max = curr;
2726 dev_dbg(di->dev,
2727 "VBUS input current limiting to %d mA\n",
2728 di->max_usb_in_curr.calculated_max);
2729 } else {
2730
2731
2732
2733
2734 di->max_usb_in_curr.set_max =
2735 di->max_usb_in_curr.calculated_max;
2736 dev_dbg(di->dev,
2737 "VBUS input current limited to %d mA\n",
2738 di->max_usb_in_curr.set_max);
2739 }
2740
2741 if (di->usb.charger_connected)
2742 ab8500_charger_set_vbus_in_curr(di,
2743 di->max_usb_in_curr.usb_type_max);
2744}
2745
2746
2747
2748
2749
2750
2751
2752
2753static irqreturn_t ab8500_charger_vbusdetf_handler(int irq, void *_di)
2754{
2755 struct ab8500_charger *di = _di;
2756
2757 di->vbus_detected = false;
2758 dev_dbg(di->dev, "VBUS falling detected\n");
2759 queue_work(di->charger_wq, &di->detect_usb_type_work);
2760
2761 return IRQ_HANDLED;
2762}
2763
2764
2765
2766
2767
2768
2769
2770
2771static irqreturn_t ab8500_charger_vbusdetr_handler(int irq, void *_di)
2772{
2773 struct ab8500_charger *di = _di;
2774
2775 di->vbus_detected = true;
2776 dev_dbg(di->dev, "VBUS rising detected\n");
2777
2778 queue_work(di->charger_wq, &di->detect_usb_type_work);
2779
2780 return IRQ_HANDLED;
2781}
2782
2783
2784
2785
2786
2787
2788
2789
2790static irqreturn_t ab8500_charger_usblinkstatus_handler(int irq, void *_di)
2791{
2792 struct ab8500_charger *di = _di;
2793
2794 dev_dbg(di->dev, "USB link status changed\n");
2795
2796 queue_work(di->charger_wq, &di->usb_link_status_work);
2797
2798 return IRQ_HANDLED;
2799}
2800
2801
2802
2803
2804
2805
2806
2807
2808
2809static irqreturn_t ab8500_charger_usbchthprotr_handler(int irq, void *_di)
2810{
2811 struct ab8500_charger *di = _di;
2812
2813 dev_dbg(di->dev,
2814 "Die temp above USB charger thermal protection threshold\n");
2815 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2816
2817 return IRQ_HANDLED;
2818}
2819
2820
2821
2822
2823
2824
2825
2826
2827
2828static irqreturn_t ab8500_charger_usbchthprotf_handler(int irq, void *_di)
2829{
2830 struct ab8500_charger *di = _di;
2831
2832 dev_dbg(di->dev,
2833 "Die temp ok for USB charger thermal protection threshold\n");
2834 queue_work(di->charger_wq, &di->check_usb_thermal_prot_work);
2835
2836 return IRQ_HANDLED;
2837}
2838
2839
2840
2841
2842
2843
2844
2845
2846static irqreturn_t ab8500_charger_usbchargernotokr_handler(int irq, void *_di)
2847{
2848 struct ab8500_charger *di = _di;
2849
2850 dev_dbg(di->dev, "Not allowed USB charger detected\n");
2851 queue_delayed_work(di->charger_wq, &di->check_usbchgnotok_work, 0);
2852
2853 return IRQ_HANDLED;
2854}
2855
2856
2857
2858
2859
2860
2861
2862
2863static irqreturn_t ab8500_charger_chwdexp_handler(int irq, void *_di)
2864{
2865 struct ab8500_charger *di = _di;
2866
2867 dev_dbg(di->dev, "Charger watchdog expired\n");
2868
2869
2870
2871
2872
2873 if (di->ac.charger_online) {
2874 di->ac.wd_expired = true;
2875 ab8500_power_supply_changed(di, &di->ac_chg.psy);
2876 }
2877 if (di->usb.charger_online) {
2878 di->usb.wd_expired = true;
2879 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2880 }
2881
2882 return IRQ_HANDLED;
2883}
2884
2885
2886
2887
2888
2889
2890
2891
2892static irqreturn_t ab8500_charger_vbuschdropend_handler(int irq, void *_di)
2893{
2894 struct ab8500_charger *di = _di;
2895
2896 dev_dbg(di->dev, "VBUS charger drop ended\n");
2897 di->flags.vbus_drop_end = true;
2898
2899
2900
2901
2902
2903 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work,
2904 round_jiffies(VBUS_IN_CURR_LIM_RETRY_SET_TIME * HZ));
2905
2906 return IRQ_HANDLED;
2907}
2908
2909
2910
2911
2912
2913
2914
2915
2916static irqreturn_t ab8500_charger_vbusovv_handler(int irq, void *_di)
2917{
2918 struct ab8500_charger *di = _di;
2919
2920 dev_dbg(di->dev, "VBUS overvoltage detected\n");
2921 di->flags.vbus_ovv = true;
2922 ab8500_power_supply_changed(di, &di->usb_chg.psy);
2923
2924
2925 queue_delayed_work(di->charger_wq, &di->check_hw_failure_work, 0);
2926
2927 return IRQ_HANDLED;
2928}
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944static int ab8500_charger_ac_get_property(struct power_supply *psy,
2945 enum power_supply_property psp,
2946 union power_supply_propval *val)
2947{
2948 struct ab8500_charger *di;
2949 int ret;
2950
2951 di = to_ab8500_charger_ac_device_info(psy_to_ux500_charger(psy));
2952
2953 switch (psp) {
2954 case POWER_SUPPLY_PROP_HEALTH:
2955 if (di->flags.mainextchnotok)
2956 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
2957 else if (di->ac.wd_expired || di->usb.wd_expired)
2958 val->intval = POWER_SUPPLY_HEALTH_DEAD;
2959 else if (di->flags.main_thermal_prot)
2960 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
2961 else
2962 val->intval = POWER_SUPPLY_HEALTH_GOOD;
2963 break;
2964 case POWER_SUPPLY_PROP_ONLINE:
2965 val->intval = di->ac.charger_online;
2966 break;
2967 case POWER_SUPPLY_PROP_PRESENT:
2968 val->intval = di->ac.charger_connected;
2969 break;
2970 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
2971 ret = ab8500_charger_get_ac_voltage(di);
2972 if (ret >= 0)
2973 di->ac.charger_voltage = ret;
2974
2975 val->intval = di->ac.charger_voltage * 1000;
2976 break;
2977 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
2978
2979
2980
2981
2982 di->ac.cv_active = ab8500_charger_ac_cv(di);
2983 val->intval = di->ac.cv_active;
2984 break;
2985 case POWER_SUPPLY_PROP_CURRENT_NOW:
2986 ret = ab8500_charger_get_ac_current(di);
2987 if (ret >= 0)
2988 di->ac.charger_current = ret;
2989 val->intval = di->ac.charger_current * 1000;
2990 break;
2991 default:
2992 return -EINVAL;
2993 }
2994 return 0;
2995}
2996
2997
2998
2999
3000
3001
3002
3003
3004
3005
3006
3007
3008
3009
3010
3011static int ab8500_charger_usb_get_property(struct power_supply *psy,
3012 enum power_supply_property psp,
3013 union power_supply_propval *val)
3014{
3015 struct ab8500_charger *di;
3016 int ret;
3017
3018 di = to_ab8500_charger_usb_device_info(psy_to_ux500_charger(psy));
3019
3020 switch (psp) {
3021 case POWER_SUPPLY_PROP_HEALTH:
3022 if (di->flags.usbchargernotok)
3023 val->intval = POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
3024 else if (di->ac.wd_expired || di->usb.wd_expired)
3025 val->intval = POWER_SUPPLY_HEALTH_DEAD;
3026 else if (di->flags.usb_thermal_prot)
3027 val->intval = POWER_SUPPLY_HEALTH_OVERHEAT;
3028 else if (di->flags.vbus_ovv)
3029 val->intval = POWER_SUPPLY_HEALTH_OVERVOLTAGE;
3030 else
3031 val->intval = POWER_SUPPLY_HEALTH_GOOD;
3032 break;
3033 case POWER_SUPPLY_PROP_ONLINE:
3034 val->intval = di->usb.charger_online;
3035 break;
3036 case POWER_SUPPLY_PROP_PRESENT:
3037 val->intval = di->usb.charger_connected;
3038 break;
3039 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
3040 ret = ab8500_charger_get_vbus_voltage(di);
3041 if (ret >= 0)
3042 di->usb.charger_voltage = ret;
3043 val->intval = di->usb.charger_voltage * 1000;
3044 break;
3045 case POWER_SUPPLY_PROP_VOLTAGE_AVG:
3046
3047
3048
3049
3050 di->usb.cv_active = ab8500_charger_usb_cv(di);
3051 val->intval = di->usb.cv_active;
3052 break;
3053 case POWER_SUPPLY_PROP_CURRENT_NOW:
3054 ret = ab8500_charger_get_usb_current(di);
3055 if (ret >= 0)
3056 di->usb.charger_current = ret;
3057 val->intval = di->usb.charger_current * 1000;
3058 break;
3059 case POWER_SUPPLY_PROP_CURRENT_AVG:
3060
3061
3062
3063
3064 if (di->flags.vbus_collapse)
3065 val->intval = 1;
3066 else
3067 val->intval = 0;
3068 break;
3069 default:
3070 return -EINVAL;
3071 }
3072 return 0;
3073}
3074
3075
3076
3077
3078
3079
3080
3081
3082static int ab8500_charger_init_hw_registers(struct ab8500_charger *di)
3083{
3084 int ret = 0;
3085 u8 bup_vch_range = 0, vbup33_vrtcn = 0;
3086
3087
3088 if (!is_ab8500_1p1_or_earlier(di->parent)) {
3089 ret = abx500_set_register_interruptible(di->dev,
3090 AB8500_CHARGER,
3091 AB8500_CH_VOLT_LVL_MAX_REG, CH_VOL_LVL_4P6);
3092 if (ret) {
3093 dev_err(di->dev,
3094 "failed to set CH_VOLT_LVL_MAX_REG\n");
3095 goto out;
3096 }
3097
3098 if (is_ab8540(di->parent))
3099 ret = abx500_set_register_interruptible(di->dev,
3100 AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3101 CH_OP_CUR_LVL_2P);
3102 else
3103 ret = abx500_set_register_interruptible(di->dev,
3104 AB8500_CHARGER, AB8500_CH_OPT_CRNTLVL_MAX_REG,
3105 CH_OP_CUR_LVL_1P6);
3106 if (ret) {
3107 dev_err(di->dev,
3108 "failed to set CH_OPT_CRNTLVL_MAX_REG\n");
3109 goto out;
3110 }
3111 }
3112
3113 if (is_ab9540_2p0(di->parent) || is_ab9540_3p0(di->parent)
3114 || is_ab8505_2p0(di->parent) || is_ab8540(di->parent))
3115 ret = abx500_mask_and_set_register_interruptible(di->dev,
3116 AB8500_CHARGER,
3117 AB8500_USBCH_CTRL2_REG,
3118 VBUS_AUTO_IN_CURR_LIM_ENA,
3119 VBUS_AUTO_IN_CURR_LIM_ENA);
3120 else
3121
3122
3123
3124 ret = abx500_set_register_interruptible(di->dev,
3125 AB8500_CHARGER,
3126 AB8500_USBCH_CTRL2_REG,
3127 VBUS_OVV_SELECT_6P3V | VBUS_AUTO_IN_CURR_LIM_ENA);
3128 if (ret) {
3129 dev_err(di->dev,
3130 "failed to set automatic current limitation\n");
3131 goto out;
3132 }
3133
3134
3135 ret = abx500_set_register_interruptible(di->dev,
3136 AB8500_OTP_EMUL, AB8500_OTP_CONF_15, OTP_ENABLE_WD);
3137 if (ret) {
3138 dev_err(di->dev, "failed to enable main WD in OTP\n");
3139 goto out;
3140 }
3141
3142
3143 ret = abx500_set_register_interruptible(di->dev,
3144 AB8500_SYS_CTRL2_BLOCK,
3145 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_ENA);
3146 if (ret) {
3147 dev_err(di->dev, "faile to enable main watchdog\n");
3148 goto out;
3149 }
3150
3151
3152
3153
3154
3155
3156
3157 udelay(63);
3158
3159
3160 ret = abx500_set_register_interruptible(di->dev,
3161 AB8500_SYS_CTRL2_BLOCK,
3162 AB8500_MAIN_WDOG_CTRL_REG,
3163 (MAIN_WDOG_ENA | MAIN_WDOG_KICK));
3164 if (ret) {
3165 dev_err(di->dev, "failed to kick main watchdog\n");
3166 goto out;
3167 }
3168
3169
3170 ret = abx500_set_register_interruptible(di->dev,
3171 AB8500_SYS_CTRL2_BLOCK,
3172 AB8500_MAIN_WDOG_CTRL_REG, MAIN_WDOG_DIS);
3173 if (ret) {
3174 dev_err(di->dev, "failed to disable main watchdog\n");
3175 goto out;
3176 }
3177
3178
3179 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3180 AB8500_CH_WD_TIMER_REG, WD_TIMER);
3181 if (ret) {
3182 dev_err(di->dev, "failed to set charger watchdog timeout\n");
3183 goto out;
3184 }
3185
3186 ret = ab8500_charger_led_en(di, false);
3187 if (ret < 0) {
3188 dev_err(di->dev, "failed to disable LED\n");
3189 goto out;
3190 }
3191
3192
3193 if (di->bm->bkup_bat_v > BUP_VCH_SEL_3P1V)
3194 bup_vch_range = BUP_VCH_RANGE;
3195 if (di->bm->bkup_bat_v == BUP_VCH_SEL_3P3V)
3196 vbup33_vrtcn = VBUP33_VRTCN;
3197
3198 ret = abx500_set_register_interruptible(di->dev,
3199 AB8500_RTC,
3200 AB8500_RTC_BACKUP_CHG_REG,
3201 (di->bm->bkup_bat_v & 0x3) | di->bm->bkup_bat_i);
3202 if (ret) {
3203 dev_err(di->dev, "failed to setup backup battery charging\n");
3204 goto out;
3205 }
3206 if (is_ab8540(di->parent)) {
3207 ret = abx500_set_register_interruptible(di->dev,
3208 AB8500_RTC,
3209 AB8500_RTC_CTRL1_REG,
3210 bup_vch_range | vbup33_vrtcn);
3211 if (ret) {
3212 dev_err(di->dev,
3213 "failed to setup backup battery charging\n");
3214 goto out;
3215 }
3216 }
3217
3218
3219 abx500_mask_and_set_register_interruptible(di->dev,
3220 AB8500_RTC, AB8500_RTC_CTRL_REG,
3221 RTC_BUP_CH_ENA, RTC_BUP_CH_ENA);
3222 if (ret < 0)
3223 dev_err(di->dev, "%s mask and set failed\n", __func__);
3224
3225 if (is_ab8540(di->parent)) {
3226 ret = abx500_mask_and_set_register_interruptible(di->dev,
3227 AB8500_CHARGER, AB8540_USB_PP_MODE_REG,
3228 BUS_VSYS_VOL_SELECT_MASK, BUS_VSYS_VOL_SELECT_3P6V);
3229 if (ret) {
3230 dev_err(di->dev,
3231 "failed to setup usb power path vsys voltage\n");
3232 goto out;
3233 }
3234 ret = abx500_mask_and_set_register_interruptible(di->dev,
3235 AB8500_CHARGER, AB8540_USB_PP_CHR_REG,
3236 BUS_PP_PRECHG_CURRENT_MASK, 0);
3237 if (ret) {
3238 dev_err(di->dev,
3239 "failed to setup usb power path prechage current\n");
3240 goto out;
3241 }
3242 }
3243
3244out:
3245 return ret;
3246}
3247
3248
3249
3250
3251static struct ab8500_charger_interrupts ab8500_charger_irq[] = {
3252 {"MAIN_CH_UNPLUG_DET", ab8500_charger_mainchunplugdet_handler},
3253 {"MAIN_CHARGE_PLUG_DET", ab8500_charger_mainchplugdet_handler},
3254 {"MAIN_EXT_CH_NOT_OK", ab8500_charger_mainextchnotok_handler},
3255 {"MAIN_CH_TH_PROT_R", ab8500_charger_mainchthprotr_handler},
3256 {"MAIN_CH_TH_PROT_F", ab8500_charger_mainchthprotf_handler},
3257 {"VBUS_DET_F", ab8500_charger_vbusdetf_handler},
3258 {"VBUS_DET_R", ab8500_charger_vbusdetr_handler},
3259 {"USB_LINK_STATUS", ab8500_charger_usblinkstatus_handler},
3260 {"USB_CH_TH_PROT_R", ab8500_charger_usbchthprotr_handler},
3261 {"USB_CH_TH_PROT_F", ab8500_charger_usbchthprotf_handler},
3262 {"USB_CHARGER_NOT_OKR", ab8500_charger_usbchargernotokr_handler},
3263 {"VBUS_OVV", ab8500_charger_vbusovv_handler},
3264 {"CH_WD_EXP", ab8500_charger_chwdexp_handler},
3265 {"VBUS_CH_DROP_END", ab8500_charger_vbuschdropend_handler},
3266};
3267
3268static int ab8500_charger_usb_notifier_call(struct notifier_block *nb,
3269 unsigned long event, void *power)
3270{
3271 struct ab8500_charger *di =
3272 container_of(nb, struct ab8500_charger, nb);
3273 enum ab8500_usb_state bm_usb_state;
3274 unsigned mA = *((unsigned *)power);
3275
3276 if (!di)
3277 return NOTIFY_DONE;
3278
3279 if (event != USB_EVENT_VBUS) {
3280 dev_dbg(di->dev, "not a standard host, returning\n");
3281 return NOTIFY_DONE;
3282 }
3283
3284
3285
3286
3287 if ((di->usb_state.usb_current == 2) && (mA > 2))
3288 bm_usb_state = AB8500_BM_USB_STATE_RESUME;
3289 else if (mA == 0)
3290 bm_usb_state = AB8500_BM_USB_STATE_RESET_HS;
3291 else if (mA == 2)
3292 bm_usb_state = AB8500_BM_USB_STATE_SUSPEND;
3293 else if (mA >= 8)
3294 bm_usb_state = AB8500_BM_USB_STATE_CONFIGURED;
3295 else
3296 bm_usb_state = AB8500_BM_USB_STATE_RESET_FS;
3297
3298 dev_dbg(di->dev, "%s usb_state: 0x%02x mA: %d\n",
3299 __func__, bm_usb_state, mA);
3300
3301 spin_lock(&di->usb_state.usb_lock);
3302 di->usb_state.state_tmp = bm_usb_state;
3303 di->usb_state.usb_current_tmp = mA;
3304 spin_unlock(&di->usb_state.usb_lock);
3305
3306
3307
3308
3309
3310 queue_delayed_work(di->charger_wq, &di->usb_state_changed_work, HZ/2);
3311
3312 return NOTIFY_OK;
3313}
3314
3315#if defined(CONFIG_PM)
3316static int ab8500_charger_resume(struct platform_device *pdev)
3317{
3318 int ret;
3319 struct ab8500_charger *di = platform_get_drvdata(pdev);
3320
3321
3322
3323
3324
3325
3326
3327
3328
3329
3330 if (di->ac_conn && is_ab8500_1p1_or_earlier(di->parent)) {
3331 ret = abx500_set_register_interruptible(di->dev, AB8500_CHARGER,
3332 AB8500_CHARG_WD_CTRL, CHARG_WD_KICK);
3333 if (ret)
3334 dev_err(di->dev, "Failed to kick WD!\n");
3335
3336
3337 queue_delayed_work(di->charger_wq, &di->kick_wd_work,
3338 round_jiffies(WD_KICK_INTERVAL));
3339 }
3340
3341
3342 if (di->flags.mainextchnotok || di->flags.vbus_ovv) {
3343 queue_delayed_work(di->charger_wq,
3344 &di->check_hw_failure_work, 0);
3345 }
3346
3347 if (di->flags.vbus_drop_end)
3348 queue_delayed_work(di->charger_wq, &di->vbus_drop_end_work, 0);
3349
3350 return 0;
3351}
3352
3353static int ab8500_charger_suspend(struct platform_device *pdev,
3354 pm_message_t state)
3355{
3356 struct ab8500_charger *di = platform_get_drvdata(pdev);
3357
3358
3359 cancel_delayed_work(&di->check_hw_failure_work);
3360 cancel_delayed_work(&di->vbus_drop_end_work);
3361
3362 flush_delayed_work(&di->attach_work);
3363 flush_delayed_work(&di->usb_charger_attached_work);
3364 flush_delayed_work(&di->ac_charger_attached_work);
3365 flush_delayed_work(&di->check_usbchgnotok_work);
3366 flush_delayed_work(&di->check_vbat_work);
3367 flush_delayed_work(&di->kick_wd_work);
3368
3369 flush_work(&di->usb_link_status_work);
3370 flush_work(&di->ac_work);
3371 flush_work(&di->detect_usb_type_work);
3372
3373 if (atomic_read(&di->current_stepping_sessions))
3374 return -EAGAIN;
3375
3376 return 0;
3377}
3378#else
3379#define ab8500_charger_suspend NULL
3380#define ab8500_charger_resume NULL
3381#endif
3382
3383static struct notifier_block charger_nb = {
3384 .notifier_call = ab8500_external_charger_prepare,
3385};
3386
3387static int ab8500_charger_remove(struct platform_device *pdev)
3388{
3389 struct ab8500_charger *di = platform_get_drvdata(pdev);
3390 int i, irq, ret;
3391
3392
3393 ab8500_charger_ac_en(&di->ac_chg, false, 0, 0);
3394
3395
3396 ab8500_charger_usb_en(&di->usb_chg, false, 0, 0);
3397
3398
3399 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3400 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3401 free_irq(irq, di);
3402 }
3403
3404
3405 ret = abx500_mask_and_set_register_interruptible(di->dev,
3406 AB8500_RTC, AB8500_RTC_CTRL_REG, RTC_BUP_CH_ENA, 0);
3407 if (ret < 0)
3408 dev_err(di->dev, "%s mask and set failed\n", __func__);
3409
3410 usb_unregister_notifier(di->usb_phy, &di->nb);
3411 usb_put_phy(di->usb_phy);
3412
3413
3414 destroy_workqueue(di->charger_wq);
3415
3416
3417 if (!di->ac_chg.enabled)
3418 blocking_notifier_chain_unregister(
3419 &charger_notifier_list, &charger_nb);
3420
3421 flush_scheduled_work();
3422 if (di->usb_chg.enabled)
3423 power_supply_unregister(&di->usb_chg.psy);
3424
3425 if (di->ac_chg.enabled && !di->ac_chg.external)
3426 power_supply_unregister(&di->ac_chg.psy);
3427
3428 return 0;
3429}
3430
3431static char *supply_interface[] = {
3432 "ab8500_chargalg",
3433 "ab8500_fg",
3434 "ab8500_btemp",
3435};
3436
3437static int ab8500_charger_probe(struct platform_device *pdev)
3438{
3439 struct device_node *np = pdev->dev.of_node;
3440 struct abx500_bm_data *plat = pdev->dev.platform_data;
3441 struct ab8500_charger *di;
3442 int irq, i, charger_status, ret = 0, ch_stat;
3443
3444 di = devm_kzalloc(&pdev->dev, sizeof(*di), GFP_KERNEL);
3445 if (!di) {
3446 dev_err(&pdev->dev, "%s no mem for ab8500_charger\n", __func__);
3447 return -ENOMEM;
3448 }
3449
3450 if (!plat) {
3451 dev_err(&pdev->dev, "no battery management data supplied\n");
3452 return -EINVAL;
3453 }
3454 di->bm = plat;
3455
3456 if (np) {
3457 ret = ab8500_bm_of_probe(&pdev->dev, np, di->bm);
3458 if (ret) {
3459 dev_err(&pdev->dev, "failed to get battery information\n");
3460 return ret;
3461 }
3462 di->autopower_cfg = of_property_read_bool(np, "autopower_cfg");
3463 } else
3464 di->autopower_cfg = false;
3465
3466
3467 di->dev = &pdev->dev;
3468 di->parent = dev_get_drvdata(pdev->dev.parent);
3469 di->gpadc = ab8500_gpadc_get("ab8500-gpadc.0");
3470
3471
3472 spin_lock_init(&di->usb_state.usb_lock);
3473 mutex_init(&di->usb_ipt_crnt_lock);
3474
3475 di->autopower = false;
3476 di->invalid_charger_detect_state = 0;
3477
3478
3479
3480 di->ac_chg.psy.name = "ab8500_ac";
3481 di->ac_chg.psy.type = POWER_SUPPLY_TYPE_MAINS;
3482 di->ac_chg.psy.properties = ab8500_charger_ac_props;
3483 di->ac_chg.psy.num_properties = ARRAY_SIZE(ab8500_charger_ac_props);
3484 di->ac_chg.psy.get_property = ab8500_charger_ac_get_property;
3485 di->ac_chg.psy.supplied_to = supply_interface;
3486 di->ac_chg.psy.num_supplicants = ARRAY_SIZE(supply_interface),
3487
3488 di->ac_chg.ops.enable = &ab8500_charger_ac_en;
3489 di->ac_chg.ops.check_enable = &ab8500_charger_ac_check_enable;
3490 di->ac_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3491 di->ac_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3492 di->ac_chg.max_out_volt = ab8500_charger_voltage_map[
3493 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3494 di->ac_chg.max_out_curr =
3495 di->bm->chg_output_curr[di->bm->n_chg_out_curr - 1];
3496 di->ac_chg.wdt_refresh = CHG_WD_INTERVAL;
3497 di->ac_chg.enabled = di->bm->ac_enabled;
3498 di->ac_chg.external = false;
3499
3500
3501 if (!di->ac_chg.enabled)
3502 blocking_notifier_chain_register(
3503 &charger_notifier_list, &charger_nb);
3504
3505
3506
3507 di->usb_chg.psy.name = "ab8500_usb";
3508 di->usb_chg.psy.type = POWER_SUPPLY_TYPE_USB;
3509 di->usb_chg.psy.properties = ab8500_charger_usb_props;
3510 di->usb_chg.psy.num_properties = ARRAY_SIZE(ab8500_charger_usb_props);
3511 di->usb_chg.psy.get_property = ab8500_charger_usb_get_property;
3512 di->usb_chg.psy.supplied_to = supply_interface;
3513 di->usb_chg.psy.num_supplicants = ARRAY_SIZE(supply_interface),
3514
3515 di->usb_chg.ops.enable = &ab8500_charger_usb_en;
3516 di->usb_chg.ops.check_enable = &ab8500_charger_usb_check_enable;
3517 di->usb_chg.ops.kick_wd = &ab8500_charger_watchdog_kick;
3518 di->usb_chg.ops.update_curr = &ab8500_charger_update_charger_current;
3519 di->usb_chg.ops.pp_enable = &ab8540_charger_power_path_enable;
3520 di->usb_chg.ops.pre_chg_enable = &ab8540_charger_usb_pre_chg_enable;
3521 di->usb_chg.max_out_volt = ab8500_charger_voltage_map[
3522 ARRAY_SIZE(ab8500_charger_voltage_map) - 1];
3523 di->usb_chg.max_out_curr =
3524 di->bm->chg_output_curr[di->bm->n_chg_out_curr - 1];
3525 di->usb_chg.wdt_refresh = CHG_WD_INTERVAL;
3526 di->usb_chg.enabled = di->bm->usb_enabled;
3527 di->usb_chg.external = false;
3528 di->usb_chg.power_path = di->bm->usb_power_path;
3529 di->usb_state.usb_current = -1;
3530
3531
3532 di->charger_wq =
3533 create_singlethread_workqueue("ab8500_charger_wq");
3534 if (di->charger_wq == NULL) {
3535 dev_err(di->dev, "failed to create work queue\n");
3536 return -ENOMEM;
3537 }
3538
3539 mutex_init(&di->charger_attached_mutex);
3540
3541
3542 INIT_DEFERRABLE_WORK(&di->check_hw_failure_work,
3543 ab8500_charger_check_hw_failure_work);
3544 INIT_DEFERRABLE_WORK(&di->check_usbchgnotok_work,
3545 ab8500_charger_check_usbchargernotok_work);
3546
3547 INIT_DELAYED_WORK(&di->ac_charger_attached_work,
3548 ab8500_charger_ac_attached_work);
3549 INIT_DELAYED_WORK(&di->usb_charger_attached_work,
3550 ab8500_charger_usb_attached_work);
3551
3552
3553
3554
3555
3556
3557
3558
3559
3560
3561 INIT_DEFERRABLE_WORK(&di->kick_wd_work,
3562 ab8500_charger_kick_watchdog_work);
3563
3564 INIT_DEFERRABLE_WORK(&di->check_vbat_work,
3565 ab8500_charger_check_vbat_work);
3566
3567 INIT_DELAYED_WORK(&di->attach_work,
3568 ab8500_charger_usb_link_attach_work);
3569
3570 INIT_DELAYED_WORK(&di->usb_state_changed_work,
3571 ab8500_charger_usb_state_changed_work);
3572
3573 INIT_DELAYED_WORK(&di->vbus_drop_end_work,
3574 ab8500_charger_vbus_drop_end_work);
3575
3576
3577 INIT_WORK(&di->usb_link_status_work,
3578 ab8500_charger_usb_link_status_work);
3579 INIT_WORK(&di->ac_work, ab8500_charger_ac_work);
3580 INIT_WORK(&di->detect_usb_type_work,
3581 ab8500_charger_detect_usb_type_work);
3582
3583
3584 INIT_WORK(&di->check_main_thermal_prot_work,
3585 ab8500_charger_check_main_thermal_prot_work);
3586 INIT_WORK(&di->check_usb_thermal_prot_work,
3587 ab8500_charger_check_usb_thermal_prot_work);
3588
3589
3590
3591
3592
3593
3594 di->regu = devm_regulator_get(di->dev, "vddadc");
3595 if (IS_ERR(di->regu)) {
3596 ret = PTR_ERR(di->regu);
3597 dev_err(di->dev, "failed to get vddadc regulator\n");
3598 goto free_charger_wq;
3599 }
3600
3601
3602
3603 ret = ab8500_charger_init_hw_registers(di);
3604 if (ret) {
3605 dev_err(di->dev, "failed to initialize ABB registers\n");
3606 goto free_charger_wq;
3607 }
3608
3609
3610 if (di->ac_chg.enabled) {
3611 ret = power_supply_register(di->dev, &di->ac_chg.psy);
3612 if (ret) {
3613 dev_err(di->dev, "failed to register AC charger\n");
3614 goto free_charger_wq;
3615 }
3616 }
3617
3618
3619 if (di->usb_chg.enabled) {
3620 ret = power_supply_register(di->dev, &di->usb_chg.psy);
3621 if (ret) {
3622 dev_err(di->dev, "failed to register USB charger\n");
3623 goto free_ac;
3624 }
3625 }
3626
3627 di->usb_phy = usb_get_phy(USB_PHY_TYPE_USB2);
3628 if (IS_ERR_OR_NULL(di->usb_phy)) {
3629 dev_err(di->dev, "failed to get usb transceiver\n");
3630 ret = -EINVAL;
3631 goto free_usb;
3632 }
3633 di->nb.notifier_call = ab8500_charger_usb_notifier_call;
3634 ret = usb_register_notifier(di->usb_phy, &di->nb);
3635 if (ret) {
3636 dev_err(di->dev, "failed to register usb notifier\n");
3637 goto put_usb_phy;
3638 }
3639
3640
3641 charger_status = ab8500_charger_detect_chargers(di, true);
3642 if (charger_status & AC_PW_CONN) {
3643 di->ac.charger_connected = 1;
3644 di->ac_conn = true;
3645 ab8500_power_supply_changed(di, &di->ac_chg.psy);
3646 sysfs_notify(&di->ac_chg.psy.dev->kobj, NULL, "present");
3647 }
3648
3649 if (charger_status & USB_PW_CONN) {
3650 di->vbus_detected = true;
3651 di->vbus_detected_start = true;
3652 queue_work(di->charger_wq,
3653 &di->detect_usb_type_work);
3654 }
3655
3656
3657 for (i = 0; i < ARRAY_SIZE(ab8500_charger_irq); i++) {
3658 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3659 ret = request_threaded_irq(irq, NULL, ab8500_charger_irq[i].isr,
3660 IRQF_SHARED | IRQF_NO_SUSPEND,
3661 ab8500_charger_irq[i].name, di);
3662
3663 if (ret != 0) {
3664 dev_err(di->dev, "failed to request %s IRQ %d: %d\n"
3665 , ab8500_charger_irq[i].name, irq, ret);
3666 goto free_irq;
3667 }
3668 dev_dbg(di->dev, "Requested %s IRQ %d: %d\n",
3669 ab8500_charger_irq[i].name, irq, ret);
3670 }
3671
3672 platform_set_drvdata(pdev, di);
3673
3674 mutex_lock(&di->charger_attached_mutex);
3675
3676 ch_stat = ab8500_charger_detect_chargers(di, false);
3677
3678 if ((ch_stat & AC_PW_CONN) == AC_PW_CONN) {
3679 if (is_ab8500(di->parent))
3680 queue_delayed_work(di->charger_wq,
3681 &di->ac_charger_attached_work,
3682 HZ);
3683 }
3684 if ((ch_stat & USB_PW_CONN) == USB_PW_CONN) {
3685 if (is_ab8500(di->parent))
3686 queue_delayed_work(di->charger_wq,
3687 &di->usb_charger_attached_work,
3688 HZ);
3689 }
3690
3691 mutex_unlock(&di->charger_attached_mutex);
3692
3693 return ret;
3694
3695free_irq:
3696 usb_unregister_notifier(di->usb_phy, &di->nb);
3697
3698
3699 for (i = i - 1; i >= 0; i--) {
3700 irq = platform_get_irq_byname(pdev, ab8500_charger_irq[i].name);
3701 free_irq(irq, di);
3702 }
3703put_usb_phy:
3704 usb_put_phy(di->usb_phy);
3705free_usb:
3706 if (di->usb_chg.enabled)
3707 power_supply_unregister(&di->usb_chg.psy);
3708free_ac:
3709 if (di->ac_chg.enabled)
3710 power_supply_unregister(&di->ac_chg.psy);
3711free_charger_wq:
3712 destroy_workqueue(di->charger_wq);
3713 return ret;
3714}
3715
3716static const struct of_device_id ab8500_charger_match[] = {
3717 { .compatible = "stericsson,ab8500-charger", },
3718 { },
3719};
3720
3721static struct platform_driver ab8500_charger_driver = {
3722 .probe = ab8500_charger_probe,
3723 .remove = ab8500_charger_remove,
3724 .suspend = ab8500_charger_suspend,
3725 .resume = ab8500_charger_resume,
3726 .driver = {
3727 .name = "ab8500-charger",
3728 .owner = THIS_MODULE,
3729 .of_match_table = ab8500_charger_match,
3730 },
3731};
3732
3733static int __init ab8500_charger_init(void)
3734{
3735 return platform_driver_register(&ab8500_charger_driver);
3736}
3737
3738static void __exit ab8500_charger_exit(void)
3739{
3740 platform_driver_unregister(&ab8500_charger_driver);
3741}
3742
3743subsys_initcall_sync(ab8500_charger_init);
3744module_exit(ab8500_charger_exit);
3745
3746MODULE_LICENSE("GPL v2");
3747MODULE_AUTHOR("Johan Palsson, Karl Komierowski, Arun R Murthy");
3748MODULE_ALIAS("platform:ab8500-charger");
3749MODULE_DESCRIPTION("AB8500 charger management driver");
3750