2 * drivers/power/rt5025-charger.c
3 * Driver for Richtek RT5025 PMIC Charger driver
5 * Copyright (C) 2014 Richtek Technology Corp.
6 * cy_huang <cy_huang@richtek.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation; either version 2
11 * of the License, or (at your option) any later version.
14 #include <linux/module.h>
15 #include <linux/kernel.h>
16 #include <linux/init.h>
17 #include <linux/version.h>
18 #include <linux/err.h>
19 #include <linux/platform_device.h>
20 #include <linux/i2c.h>
22 #include <linux/power_supply.h>
23 #include <linux/workqueue.h>
24 #include <linux/delay.h>
25 #ifdef CONFIG_HAS_EARLYSUSPEND
26 #include <linux/earlysuspend.h>
27 #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
29 #include <linux/mfd/rt5025.h>
30 #include <linux/power/rt5025-charger.h>
31 #ifdef CONFIG_RT_POWER
32 #include <linux/power/rt-power.h>
33 #endif /* #ifdef CONFIG_RT_POWER */
35 static unsigned char chg_init_regval[] = {
47 static char *rtdef_chg_name = "rt-charger";
49 static char *rt_charger_supply_list[] = {
53 static enum power_supply_property rt_charger_props[] = {
54 POWER_SUPPLY_PROP_STATUS,
55 POWER_SUPPLY_PROP_ONLINE,
56 POWER_SUPPLY_PROP_PRESENT,
57 POWER_SUPPLY_PROP_TEMP,
58 POWER_SUPPLY_PROP_CHARGE_NOW,
59 POWER_SUPPLY_PROP_CURRENT_MAX,
60 POWER_SUPPLY_PROP_CURRENT_AVG,
61 POWER_SUPPLY_PROP_CURRENT_NOW,
62 POWER_SUPPLY_PROP_VOLTAGE_NOW,
63 POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN,
64 POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN,
67 static void rt_charger_set_batt_status(struct rt5025_charger_info *ci);
69 static int rt_charger_get_property(struct power_supply *psy, enum power_supply_property psp, \
70 union power_supply_propval *val)
72 struct rt5025_charger_info *ci = dev_get_drvdata(psy->dev->parent);
75 #ifdef CONFIG_BATTERY_RT5025
76 struct power_supply *bat_psy = power_supply_get_by_name(RT_BATT_NAME);
77 union power_supply_propval pval;
81 case POWER_SUPPLY_PROP_ONLINE:
82 val->intval = ci->online;
84 case POWER_SUPPLY_PROP_STATUS:
85 val->intval = ci->chg_status;
87 case POWER_SUPPLY_PROP_PRESENT:
88 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL7);
92 if (regval & RT5025_CHGCEN_MASK)
98 case POWER_SUPPLY_PROP_TEMP:
100 #ifdef CONFIG_BATTERY_RT5025
102 ret = bat_psy->get_property(bat_psy, POWER_SUPPLY_PROP_TEMP_AMBIENT,\
105 dev_err(ci->dev, "get ic temp fail\n");
107 val->intval = pval.intval;
109 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
111 case POWER_SUPPLY_PROP_CHARGE_NOW:
112 val->intval = ci->charger_cable;
114 case POWER_SUPPLY_PROP_CURRENT_MAX:
117 case POWER_SUPPLY_PROP_CURRENT_AVG:
118 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL4);
122 regval &= RT5025_CHGAICR_MASK;
123 regval >>= RT5025_CHGAICR_SHFT;
143 case POWER_SUPPLY_PROP_CURRENT_NOW:
144 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL4);
148 regval &= RT5025_CHGICC_MASK;
149 regval >>= RT5025_CHGICC_SHFT;
150 val->intval = 500 + regval * 100;
153 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
154 regval = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL3);
158 regval &= RT5025_CHGCV_MASK;
159 regval >>= RT5025_CHGCV_SHFT;
160 val->intval = regval * 20 + 3500;
163 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
166 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
175 static int rt_charger_set_property(struct power_supply *psy, enum power_supply_property psp, \
176 const union power_supply_propval *val)
178 struct rt5025_charger_info *ci = dev_get_drvdata(psy->dev->parent);
181 RTINFO("prop = %d, val->intval = %d\n", psp, val->intval);
183 case POWER_SUPPLY_PROP_ONLINE:
184 ci->online = val->intval;
187 ret = rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGTEEN_MASK);
188 /*charger workaround*/
190 /*turn on recharge irq enable*/
191 chg_init_regval[8] |= RT5025_CHRCHGI_MASK;
192 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN3, chg_init_regval[8]);
193 /*turn on chterm irq enable*/
194 chg_init_regval[7] |= RT5025_CHTERMI_MASK;
195 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN2, chg_init_regval[7]);
197 ci->chg_status = POWER_SUPPLY_STATUS_CHARGING;
198 rt_charger_set_batt_status(ci);
201 ret = rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGTEEN_MASK);
202 /*charger workaround*/
203 /*turn off chterm irq enable*/
204 chg_init_regval[7] &= ~RT5025_CHTERMI_MASK;
205 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN2, chg_init_regval[7]);
206 /*turn off recharge irq enable*/
207 chg_init_regval[8] &= ~RT5025_CHRCHGI_MASK;
208 rt5025_reg_write(ci->i2c, RT5025_REG_IRQEN3, chg_init_regval[8]);
210 ci->chg_status = POWER_SUPPLY_STATUS_DISCHARGING;
211 rt_charger_set_batt_status(ci);
214 case POWER_SUPPLY_PROP_PRESENT:
215 if (ci->online && val->intval) {
219 union power_supply_propval pval;
221 if (ci->charger_cable == POWER_SUPPLY_TYPE_MAINS)
222 battemp_icc = inttemp_icc = (ci->screen_on ?\
223 ci->screenon_icc:ci->acchg_icc);
224 else if (ci->charger_cable == POWER_SUPPLY_TYPE_USB_DCP)
225 battemp_icc = inttemp_icc = (ci->screen_on ?\
226 ci->screenon_icc:ci->usbtachg_icc);
228 battemp_icc = inttemp_icc = (ci->screen_on ?\
229 ci->screenon_icc:ci->usbchg_icc);
230 if (ci->battemp_region == RT5025_BATTEMP_COLD ||\
231 ci->battemp_region == RT5025_BATTEMP_HOT)
233 else if (ci->battemp_region == RT5025_BATTEMP_COOL ||\
234 ci->battemp_region == RT5025_BATTEMP_WARM)
237 if (ci->inttemp_region == RT5025_INTTEMP_WARM)
239 else if (ci->inttemp_region == RT5025_INTTEMP_HOT)
245 icc = min(battemp_icc, inttemp_icc);
247 ret = psy->set_property(psy, POWER_SUPPLY_PROP_CURRENT_NOW, &pval);
249 dev_err(ci->dev, "set final icc fail\n");
252 case POWER_SUPPLY_PROP_CHARGE_NOW:
253 ci->charger_cable = val->intval;
255 case POWER_SUPPLY_PROP_CURRENT_AVG:
256 if (0 < val->intval && val->intval <= 100)
258 else if (val->intval <= 500)
260 else if (val->intval <= 1000)
265 ret = rt5025_assign_bits(ci->i2c, RT5025_REG_CHGCTL4, \
266 RT5025_CHGAICR_MASK, regval << RT5025_CHGAICR_SHFT);
268 case POWER_SUPPLY_PROP_CURRENT_NOW:
269 if (val->intval < 0) {
272 #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN
273 ret = rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_VBUSHZ_MASK);
275 dev_err(ci->dev, "set vbus hz fail\n");
277 ret = rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGBCEN_MASK);
279 dev_err(ci->dev, "shutdown chg buck fail\n");
280 #endif /* #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
281 } else if (val->intval == 0) {
284 #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN
285 ret = rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_VBUSHZ_MASK);
287 dev_err(ci->dev, "clear vbus hz fail\n");
289 ret = rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL2, RT5025_CHGBCEN_MASK);
291 dev_err(ci->dev, "turnon chg buck fail\n");
292 #endif /* #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
293 } else if (val->intval > 0 && val->intval < 500) {
295 } else if (val->intval > 2000) {
298 regval = (val->intval - 500) / 100;
302 ret = rt5025_assign_bits(ci->i2c, RT5025_REG_CHGCTL4, RT5025_CHGICC_MASK, \
303 regval<<RT5025_CHGICC_SHFT);
305 if (val->intval > 0 && val->intval < 500)
306 rt5025_clr_bits(ci->i2c, RT5025_REG_CHGCTL7, RT5025_CHGCEN_MASK);
308 rt5025_set_bits(ci->i2c, RT5025_REG_CHGCTL7, RT5025_CHGCEN_MASK);
310 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
311 if (val->intval < 3500)
313 else if (val->intval > 4440)
316 regval = (val->intval - 3500) / 20;
317 ret = rt5025_assign_bits(ci->i2c, RT5025_REG_CHGCTL3, RT5025_CHGCV_MASK, \
318 regval << RT5025_CHGCV_SHFT);
320 case POWER_SUPPLY_PROP_TEMP:
321 case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN:
322 case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN:
323 case POWER_SUPPLY_PROP_CURRENT_MAX:
324 case POWER_SUPPLY_PROP_STATUS:
331 #ifdef CONFIG_BATTERY_RT5025
332 static int rt5025_set_tempalrt(struct rt5025_charger_info *ci)
336 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
337 RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0x00);
338 if (ci->battemp_region == RT5025_BATTEMP_HOT) {
339 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[6]);
340 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
341 RT5025_TALRTMX_MASK, 0xFF);
342 } else if (ci->battemp_region == RT5025_BATTEMP_WARM) {
343 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[4]);
344 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[7]);
345 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
346 RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0xFF);
347 } else if (ci->battemp_region == RT5025_BATTEMP_NORMAL) {
348 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[2]);
349 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[5]);
350 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
351 RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0xFF);
352 } else if (ci->battemp_region == RT5025_BATTEMP_COOL) {
353 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMAX, ci->temp_scalar[0]);
354 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[3]);
355 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
356 RT5025_TALRTMX_MASK|RT5025_TALRTMN_MASK, 0xFF);
358 rt5025_reg_write(ci->i2c, RT5025_REG_TALRTMIN, ci->temp_scalar[1]);
359 rt5025_assign_bits(ci->i2c, RT5025_REG_IRQCTL,\
360 RT5025_TALRTMN_MASK, 0xFF);
364 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
366 static void rt_charger_set_batt_status(struct rt5025_charger_info *ci)
368 #ifdef CONFIG_BATTERY_RT5025
369 struct power_supply *psy = power_supply_get_by_name(RT_BATT_NAME);
370 union power_supply_propval pval;
374 dev_err(ci->dev, "can't get battery supply\n");
377 pval.intval = ci->chg_status;
378 rc = psy->set_property(psy, POWER_SUPPLY_PROP_STATUS, &pval);
380 dev_err(ci->dev, "set battery status fail\n");
381 power_supply_changed(psy);
382 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
385 static int rt_charger_check_battery_present(struct rt5025_charger_info *ci)
388 #ifdef CONFIG_BATTERY_RT5025
389 struct power_supply *psy = power_supply_get_by_name(RT_BATT_NAME);
390 union power_supply_propval pval;
393 dev_err(ci->dev, "can't get battery supply\n");
396 rc = psy->get_property(psy, POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval);
398 dev_err(ci->dev, "get battery voltage fail\n");
400 if (pval.intval < (ci->chg_volt - 200) * 1000)
405 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
409 static void rt5025_batabs_irq_handler(void *info, int eventno)
411 struct rt5025_charger_info *ci = info;
412 struct power_supply *psy = &ci->psy;
413 union power_supply_propval pval;
416 #ifdef CONFIG_BATTERY_RT5025
417 struct power_supply *bat_psy = power_supply_get_by_name(RT_BATT_NAME);
421 dev_err(ci->dev, "get rt-battery supply fail\n");
423 rc = bat_psy->set_property(bat_psy,
424 POWER_SUPPLY_PROP_PRESENT, &pval);
426 dev_err(ci->dev, "set battery not present fail\n");
427 power_supply_changed(bat_psy);
429 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
430 /*set aicr to disable*/
432 rc = psy->set_property(psy, POWER_SUPPLY_PROP_CURRENT_AVG, &pval);
434 dev_err(ci->dev, "set aicr to disable fail\n");
437 rc = psy->set_property(psy, POWER_SUPPLY_PROP_CURRENT_NOW, &pval);
439 dev_err(ci->dev, "set icc to 2000 fail\n");
440 /*set online = 0, due to bat absense*/
442 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
444 dev_err(ci->dev, "set charger offline fail\n");
449 static void rt5025_acin_irq_handler(void *info, int eventno)
451 #ifdef CONFIG_RT_POWER
452 struct rt5025_charger_info *ci = info;
453 #ifndef CONFIG_RT_SUPPORT_ACUSB_DUALIN
454 struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
456 struct power_supply *psy = power_supply_get_by_name(RT_AC_NAME);
457 #endif /* #ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
458 union power_supply_propval pval;
462 dev_err(ci->dev, "could not get psy supply\n");
466 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
468 dev_err(ci->dev, "set ac online fail\n");
469 power_supply_changed(psy);
470 dev_info(ci->dev, "%s\n", __func__);
471 #endif /* #ifdef CONFIG_RT_POWER */
474 static void rt5025_acout_irq_handler(void *info, int eventno)
476 #ifdef CONFIG_RT_POWER
477 struct rt5025_charger_info *ci = info;
478 #ifndef CONFIG_RT_SUPPORT_ACUSB_DUALIN
479 struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
481 struct power_supply *psy = power_supply_get_by_name(RT_AC_NAME);
482 #endif /* ifdef CONFIG_RT_SUPPORT_ACUSB_DUALIN */
483 union power_supply_propval pval;
487 dev_err(ci->dev, "could not get rt-usb supply\n");
491 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
493 dev_err(ci->dev, "set ac offline fail\n");
494 power_supply_changed(psy);
495 dev_info(ci->dev, "%s\n", __func__);
496 #endif /* #ifdef CONFIG_RT_POWER */
499 static void rt5025_usbin_irq_handler(void *info, int eventno)
501 #ifdef CONFIG_RT_POWER
502 struct rt5025_charger_info *ci = info;
503 struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
504 union power_supply_propval pval;
508 dev_err(ci->dev, "could not get rt-usb supply\n");
513 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
515 dev_err(ci->dev, "set ac online fail\n");
516 power_supply_changed(psy);
518 dev_info(ci->dev, "%s\n", __func__);
519 #endif /* #ifdef CONFIG_RT_POWER */
522 static void rt5025_usbout_irq_handler(void *info, int eventno)
524 #ifdef CONFIG_RT_POWER
525 struct rt5025_charger_info *ci = info;
526 struct power_supply *psy = power_supply_get_by_name(RT_USB_NAME);
527 union power_supply_propval pval;
531 dev_err(ci->dev, "could not get rt-usb supply\n");
536 rc = psy->set_property(psy, POWER_SUPPLY_PROP_ONLINE, &pval);
538 dev_err(ci->dev, "set ac offline fail\n");
539 power_supply_changed(psy);
541 dev_info(ci->dev, "%s\n", __func__);
542 #endif /* #ifdef CONFIG_RT_POWER */
545 static void rt5025_talrtmax_irq_handler(void *info, int eventno)
547 #ifdef CONFIG_BATTERY_RT5025
548 struct rt5025_charger_info *ci = info;
549 union power_supply_propval pval;
552 switch (ci->battemp_region) {
553 case RT5025_BATTEMP_COLD:
554 dev_warn(ci->dev, "cold than cold???\n");
556 case RT5025_BATTEMP_COOL:
557 dev_info(ci->dev, "cool-> cold\n");
558 ci->battemp_region = RT5025_BATTEMP_COLD;
559 rt5025_set_tempalrt(ci);
561 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
564 dev_err(ci->dev, "set present fail\n");
566 case RT5025_BATTEMP_NORMAL:
567 dev_info(ci->dev, "normal-> cool\n");
568 ci->battemp_region = RT5025_BATTEMP_COOL;
569 rt5025_set_tempalrt(ci);
571 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
574 dev_err(ci->dev, "set present fail\n");
576 case RT5025_BATTEMP_WARM:
577 dev_info(ci->dev, "warm-> normal\n");
578 ci->battemp_region = RT5025_BATTEMP_NORMAL;
579 rt5025_set_tempalrt(ci);
581 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
584 dev_err(ci->dev, "set present fail\n");
586 case RT5025_BATTEMP_HOT:
587 dev_info(ci->dev, "hot-> warm\n");
588 ci->battemp_region = RT5025_BATTEMP_WARM;
589 rt5025_set_tempalrt(ci);
591 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
594 dev_err(ci->dev, "set present fail\n");
599 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
602 static void rt5025_talrtmin_irq_handler(void *info, int eventno)
604 #ifdef CONFIG_BATTERY_RT5025
605 struct rt5025_charger_info *ci = info;
606 union power_supply_propval pval;
609 switch (ci->battemp_region) {
610 case RT5025_BATTEMP_COLD:
611 dev_info(ci->dev, "cold-> cool\n");
612 ci->battemp_region = RT5025_BATTEMP_COOL;
613 rt5025_set_tempalrt(ci);
615 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
618 dev_err(ci->dev, "set present fail\n");
620 case RT5025_BATTEMP_COOL:
621 dev_info(ci->dev, "cool-> normal\n");
622 ci->battemp_region = RT5025_BATTEMP_NORMAL;
623 rt5025_set_tempalrt(ci);
625 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
628 dev_err(ci->dev, "set present fail\n");
630 case RT5025_BATTEMP_NORMAL:
631 dev_info(ci->dev, "normal-> warm\n");
632 ci->battemp_region = RT5025_BATTEMP_WARM;
633 rt5025_set_tempalrt(ci);
635 rc = ci->psy.set_property(&ci->psy,
636 POWER_SUPPLY_PROP_PRESENT,\
639 dev_err(ci->dev, "set present fail\n");
641 case RT5025_BATTEMP_WARM:
642 dev_info(ci->dev, "warm-> hot\n");
643 ci->battemp_region = RT5025_BATTEMP_HOT;
644 rt5025_set_tempalrt(ci);
646 rc = ci->psy.set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT,\
649 dev_err(ci->dev, "set present fail\n");
651 case RT5025_BATTEMP_HOT:
652 dev_warn(ci->dev, "hot than hot???\n");
657 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
660 static void rt5025_general_irq_handler(void *info, int eventno)
662 struct rt5025_charger_info *ci = info;
664 RTINFO("eventno=%02d\n", eventno);
666 case CHGEVENT_CHRCHGI:
668 dev_warn(ci->dev, "recharge false alarm\n");
670 union power_supply_propval pval;
672 dev_info(ci->dev, "recharge occur\n");
673 ci->chg_status = POWER_SUPPLY_STATUS_CHARGING;
674 pval.intval = ci->chg_volt;
675 rt_charger_set_batt_status(ci);
676 ci->psy.set_property(&ci->psy,
677 POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval);
680 case CHGEVENT_CHTERMI:
682 dev_warn(ci->dev, "eoc false alarm\n");
684 if (rt_charger_check_battery_present(ci)) {
685 union power_supply_propval pval;
687 if (ci->chg_status == POWER_SUPPLY_STATUS_FULL)
689 dev_info(ci->dev, "eoc really occur\n");
690 ci->chg_status = POWER_SUPPLY_STATUS_FULL;
691 rt_charger_set_batt_status(ci);
692 pval.intval = ci->chg_volt-50;
693 ci->psy.set_property(&ci->psy,
694 POWER_SUPPLY_PROP_VOLTAGE_NOW, &pval);
696 dev_info(ci->dev, "no battery condition\n");
697 rt5025_batabs_irq_handler(ci, eventno);
701 case CHGEVENT_TALRTMAX:
702 #ifdef CONFIG_BATTERY_RT5025
703 rt5025_set_tempalrt(ci);
704 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
706 case CHGEVENT_TALRTMIN:
707 #ifdef CONFIG_BATTERY_RT5025
708 rt5025_set_tempalrt(ci);
709 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
716 static rt_irq_handler rt_chgirq_handler[CHGEVENT_MAX] = {
717 [CHGEVENT_TIMEOUT_CC] = rt5025_general_irq_handler,
718 [CHGEVENT_TIMEOUT_PC] = rt5025_general_irq_handler,
719 [CHGEVENT_CHVSREGI] = rt5025_general_irq_handler,
720 [CHGEVENT_CHTREGI] = rt5025_general_irq_handler,
721 [CHGEVENT_CHRCHGI] = rt5025_general_irq_handler,
722 [CHGEVENT_CHTERMI] = rt5025_general_irq_handler,
723 [CHGEVENT_CHBATOVI] = rt5025_general_irq_handler,
724 [CHGEVENT_CHGOODI_INUSB] = rt5025_general_irq_handler,
725 [CHGEVENT_CHBADI_INUSB] = rt5025_general_irq_handler,
726 [CHGEVENT_CHSLPI_INUSB] = rt5025_usbout_irq_handler,
727 [CHGEVENT_CHGOODI_INAC] = rt5025_general_irq_handler,
728 [CHGEVENT_CHBADI_INAC] = rt5025_general_irq_handler,
729 [CHGEVENT_CHSLPI_INAC] = rt5025_acout_irq_handler,
730 [CHGEVENT_BATABS] = rt5025_batabs_irq_handler,
731 [CHGEVENT_INUSB_PLUGIN] = rt5025_usbin_irq_handler,
732 [CHGEVENT_INUSBOVP] = rt5025_general_irq_handler,
733 [CHGEVENT_INAC_PLUGIN] = rt5025_acin_irq_handler,
734 [CHGEVENT_INACOVP] = rt5025_general_irq_handler,
735 [CHGEVENT_TALRTMIN] = rt5025_talrtmin_irq_handler,
736 [CHGEVENT_TALRTMAX] = rt5025_talrtmax_irq_handler,
739 void rt5025_charger_irq_handler(struct rt5025_charger_info *ci, unsigned int irqevent)
742 #ifdef CONFIG_BATTERY_RT5025
743 unsigned int enable_irq_event = (RT5025_TALRTMX_MASK | RT5025_TALRTMN_MASK)<<24 | \
744 (chg_init_regval[6] << 16) | (chg_init_regval[7] << 8) | chg_init_regval[8];
746 unsigned int enable_irq_event = (chg_init_regval[6] << 16)
747 | (chg_init_regval[7] << 8)| \
749 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
750 unsigned int final_irq_event = irqevent&enable_irq_event;
752 /*charger workaround (TE+RECHARGE)*/
753 if (final_irq_event & (1 << CHGEVENT_CHTERMI) && \
754 final_irq_event & (1 << CHGEVENT_CHRCHGI))
755 final_irq_event &= ~((1 << CHGEVENT_CHTERMI) | (1 << CHGEVENT_CHRCHGI));
756 i = rt5025_reg_read(ci->i2c, RT5025_REG_CHGCTL1);
758 dev_err(ci->dev, "read CHGCTL1 fail\n");
762 if (final_irq_event & (1 << CHGEVENT_INAC_PLUGIN) && \
763 final_irq_event & (1 << CHGEVENT_CHSLPI_INAC)) {
764 if (i & RT5025_ACUSABLE_MASK)
765 final_irq_event &= ~(1<<CHGEVENT_CHSLPI_INAC);
767 final_irq_event &= ~(1<<CHGEVENT_INAC_PLUGIN);
770 if (final_irq_event & (1 << CHGEVENT_INUSB_PLUGIN) && \
771 final_irq_event & (1 << CHGEVENT_CHSLPI_INUSB)) {
772 if (i & RT5025_USBUSABLE_MASK)
773 final_irq_event &= ~(1 << CHGEVENT_CHSLPI_INUSB);
775 final_irq_event &= ~(1 << CHGEVENT_INUSB_PLUGIN);
777 for (i = 0; i < CHGEVENT_MAX; i++) {
778 if ((final_irq_event & (1 << i)) && rt_chgirq_handler[i])
779 rt_chgirq_handler[i](ci, i);
782 EXPORT_SYMBOL(rt5025_charger_irq_handler);
784 static void rt5025_tempmon_work(struct work_struct *work)
786 struct rt5025_charger_info *ci = container_of(work, \
787 struct rt5025_charger_info, tempmon_work.work);
788 #ifdef CONFIG_BATTERY_RT5025
789 struct power_supply *psy = power_supply_get_by_name(RT_BATT_NAME);
790 union power_supply_propval pval;
795 #ifdef CONFIG_BATTERY_RT5025
797 dev_err(ci->dev, "could not get rt-battery psy\n");
800 if (!ci->init_once) {
804 pval.intval = 23; /* magic code*/
805 psy->get_property(psy, POWER_SUPPLY_PROP_TEMP, &pval);
806 for (i = 3; i >= 0; i--)
807 if (pval.intval > ci->temp[i])
810 ci->battemp_region = RT5025_BATTEMP_HOT;
812 ci->battemp_region = RT5025_BATTEMP_WARM;
814 ci->battemp_region = RT5025_BATTEMP_NORMAL;
816 ci->battemp_region = RT5025_BATTEMP_COOL;
818 ci->battemp_region = RT5025_BATTEMP_COLD;
819 rt5025_set_tempalrt(ci);
823 psy->get_property(psy, POWER_SUPPLY_PROP_TEMP_AMBIENT, &pval);
824 if (pval.intval > 1000)
825 inttemp_region = RT5025_INTTEMP_HOT;
826 else if (pval.intval > 750)
827 inttemp_region = RT5025_INTTEMP_WARM;
829 inttemp_region = RT5025_INTTEMP_NORMAL;
831 if (inttemp_region != ci->inttemp_region) {
832 ci->inttemp_region = inttemp_region;
834 rt_charger_set_property(&ci->psy,
835 POWER_SUPPLY_PROP_PRESENT, &pval);
837 #endif /* #ifdef CONFIG_BATTERY_RT5025 */
839 schedule_delayed_work(&ci->tempmon_work, 5*HZ);
842 static int rt5025_charger_reginit(struct i2c_client *client)
844 rt5025_reg_block_write(client, RT5025_REG_CHGCTL2, 6, chg_init_regval);
845 /*set all to be masked*/
846 rt5025_reg_write(client, RT5025_REG_IRQEN1, 0x00);
847 rt5025_reg_write(client, RT5025_REG_IRQEN2, 0x00);
848 rt5025_reg_write(client, RT5025_REG_IRQEN3, 0x00);
849 /*just clear the old irq event*/
850 rt5025_reg_read(client, RT5025_REG_IRQSTAT1);
851 rt5025_reg_read(client, RT5025_REG_IRQSTAT2);
852 rt5025_reg_read(client, RT5025_REG_IRQSTAT3);
853 /*set enable irqs as we want*/
854 rt5025_reg_write(client, RT5025_REG_IRQEN1, chg_init_regval[6]);
855 rt5025_reg_write(client, RT5025_REG_IRQEN2, chg_init_regval[7]);
856 rt5025_reg_write(client, RT5025_REG_IRQEN3, chg_init_regval[8]);
861 static int rt_parse_dt(struct rt5025_charger_info *ci, struct device *dev)
864 struct device_node *np = dev->of_node;
867 if (of_property_read_bool(np, "rt,te_en"))
870 if (of_property_read_u32(np, "rt,iprec", &val)) {
871 dev_info(dev, "no iprec property, use default value\n");
873 if (val > RT5025_IPREC_MAX)
874 val = RT5025_IPREC_MAX;
875 chg_init_regval[4] &= (~RT5025_CHGIPREC_MASK);
876 chg_init_regval[4] |= (val << RT5025_CHGIPREC_SHFT);
879 if (of_property_read_u32(np, "rt,ieoc", &val)) {
880 dev_info(dev, "no ieoc property, use the default value\n");
882 if (val > RT5025_IEOC_MAX)
883 val = RT5025_IEOC_MAX;
884 chg_init_regval[4] &= (~RT5025_CHGIEOC_MASK);
885 chg_init_regval[4] |= (val << RT5025_CHGIEOC_SHFT);
888 if (of_property_read_u32(np, "rt,vprec", &val)) {
889 dev_info(dev, "no vprec property, use the default value\n");
891 if (val > RT5025_VPREC_MAX)
892 val = RT5025_VPREC_MAX;
893 chg_init_regval[4] &= (~RT5025_CHGVPREC_MASK);
894 chg_init_regval[4] |= (val << RT5025_CHGVPREC_SHFT);
897 if (of_property_read_u32(np, "rt,vdpm", &val)) {
898 dev_info(dev, "no vdpm property, use the default value\n");
900 if (val > RT5025_VDPM_MAX)
901 val = RT5025_VDPM_MAX;
902 chg_init_regval[3] &= (~RT5025_CHGVDPM_MASK);
903 chg_init_regval[3] |= (val << RT5025_CHGVDPM_SHFT);
906 if (of_property_read_u32(np, "rt,chg_volt", &val)) {
907 dev_info(dev, "no chg_volt property, use 4200 as the default value\n");
913 if (of_property_read_u32(np, "rt,acchg_icc", &val)) {
914 dev_info(dev, "no acchg_icc property, use 2000 as the default value\n");
915 ci->acchg_icc = 2000;
920 if (of_property_read_u32(np, "rt,usbtachg_icc", &val)) {
921 dev_info(dev, "no usbtachg_icc property, use 2000 as the default value\n");
922 ci->usbtachg_icc = 2000;
924 ci->usbtachg_icc = val;
927 if (of_property_read_u32(np, "rt,usbchg_icc", &val)) {
928 dev_info(dev, "no usbchg_icc property, use 500 as the default value\n");
929 ci->usbchg_icc = 500;
931 ci->usbchg_icc = val;
934 if (of_property_read_u32(np, "rt,screenon_icc", &val)) {
935 dev_info(dev, "no screenon_icc property, use 500 as the default value\n");
936 ci->screenon_icc = 500;
938 ci->screenon_icc = val;
941 if (of_property_read_bool(np, "rt,screenon_adjust")) {
942 ci->screenon_adjust = 1;
946 if (of_property_read_u32_array(np, "rt,temp",
948 dev_info(dev, "no temperature property, use default value\n");
955 if (of_property_read_u32_array(np, "rt,temp_scalar",
956 ci->temp_scalar, 8)) {
957 dev_info(dev, "no temp_scalar property, use default value\n");
958 ci->temp_scalar[0] = 0x30;
959 ci->temp_scalar[1] = 0x2B;
960 ci->temp_scalar[2] = 0x28;
961 ci->temp_scalar[3] = 0x22;
962 ci->temp_scalar[4] = 0x15;
963 ci->temp_scalar[5] = 0x10;
964 ci->temp_scalar[6] = 0x10;
965 ci->temp_scalar[7] = 0x0D;
967 #endif /* #ifdef CONFIG_OF */
968 rt5025_charger_reginit(ci->i2c);
973 static int rt_parse_pdata(struct rt5025_charger_info *ci, struct device *dev)
975 struct rt5025_charger_data *pdata = dev->platform_data;
981 chg_init_regval[4] &= (~RT5025_CHGIPREC_MASK);
982 chg_init_regval[4] |= (pdata->iprec << RT5025_CHGIPREC_SHFT);
984 chg_init_regval[4] &= (~RT5025_CHGIEOC_MASK);
985 chg_init_regval[4] |= (pdata->ieoc << RT5025_CHGIEOC_SHFT);
987 chg_init_regval[4] &= (~RT5025_CHGVPREC_MASK);
988 chg_init_regval[4] |= (pdata->vprec << RT5025_CHGVPREC_SHFT);
990 chg_init_regval[3] &= (~RT5025_CHGVDPM_MASK);
991 chg_init_regval[3] |= (pdata->vdpm << RT5025_CHGVDPM_SHFT);
993 ci->chg_volt = pdata->chg_volt;
994 ci->acchg_icc = pdata->acchg_icc;
995 ci->usbtachg_icc = pdata->usbtachg_icc;
996 ci->usbchg_icc = pdata->usbchg_icc;
997 ci->screenon_icc = pdata->screenon_icc;
998 if (pdata->screenon_adjust) {
999 ci->screenon_adjust = 1;
1000 /*default probe screen will on*/
1003 for (i = 0; i < 4; i++)
1004 ci->temp[i] = pdata->temp[i];
1005 for (i = 0; i < 8; i++)
1006 ci->temp_scalar[i] = pdata->temp_scalar[i];
1007 rt5025_charger_reginit(ci->i2c);
1012 #ifdef CONFIG_RT_POWER
1013 static struct platform_device rt_power_dev = {
1017 #endif /* #ifdef CONFIG_RT_POWER */
1019 #ifdef CONFIG_HAS_EARLYSUSPEND
1020 static void rt5025_charger_earlysuspend(struct early_suspend *handler)
1022 struct rt5025_charger_info *ci = container_of(handler, \
1023 struct rt5025_charger_info, early_suspend);
1024 union power_supply_propval pval;
1027 if (ci->screenon_adjust) {
1030 rc = ci->psy.set_property(&ci->psy,
1031 POWER_SUPPLY_PROP_PRESENT, &pval);
1033 dev_err(ci->dev, "set charger present property fail\n");
1037 static void rt5025_charger_earlyresume(struct early_suspend *handler)
1039 struct rt5025_charger_info *ci = container_of(handler, \
1040 struct rt5025_charger_info, early_suspend);
1041 union power_supply_propval pval;
1044 if (ci->screenon_adjust) {
1047 rc = ci->psy.set_property(&ci->psy,
1048 POWER_SUPPLY_PROP_PRESENT, &pval);
1050 dev_err(ci->dev, "set charger present property fail\n");
1053 #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
1055 static int rt5025_charger_probe(struct platform_device *pdev)
1057 struct rt5025_chip *chip = dev_get_drvdata(pdev->dev.parent);
1058 struct rt5025_platform_data *pdata =
1059 (pdev->dev.parent)->platform_data;
1060 #ifdef CONFIG_RT_POWER
1061 struct rt_power_data *rt_power_pdata;
1062 #endif /* #ifdef CONFIG_RT_POWER */
1063 struct rt5025_charger_info *ci;
1064 bool use_dt = pdev->dev.of_node;
1067 ci = devm_kzalloc(chip->dev, sizeof(struct rt5025_charger_info), GFP_KERNEL);
1071 ci->i2c = chip->i2c;
1072 ci->dev = &pdev->dev;
1073 ci->chg_status = POWER_SUPPLY_STATUS_DISCHARGING;
1074 ci->battemp_region = RT5025_BATTEMP_NORMAL;
1075 ci->inttemp_region = RT5025_INTTEMP_NORMAL;
1076 #ifdef CONFIG_RT_JEITA_REMOVE
1078 #endif /* #ifdef RT_JEITA_REMOVE */
1081 rt_parse_dt(ci, &pdev->dev);
1087 pdev->dev.platform_data = pdata->chg_pdata;
1088 rt_parse_pdata(ci, &pdev->dev);
1090 INIT_DELAYED_WORK(&ci->tempmon_work, rt5025_tempmon_work);
1092 platform_set_drvdata(pdev, ci);
1093 /*power supply register*/
1094 ci->psy.name = rtdef_chg_name;
1095 #if (LINUX_VERSION_CODE >= KERNEL_VERSION(3, 3, 0))
1096 ci->psy.type = POWER_SUPPLY_TYPE_UNKNOWN;
1099 #endif /* #ifdef (LINUX_VERSION_CODE */
1100 ci->psy.supplied_to = rt_charger_supply_list;
1101 ci->psy.properties = rt_charger_props;
1102 ci->psy.num_properties = ARRAY_SIZE(rt_charger_props);
1103 ci->psy.get_property = rt_charger_get_property;
1104 ci->psy.set_property = rt_charger_set_property;
1105 ret = power_supply_register(&pdev->dev, &ci->psy);
1107 dev_err(&pdev->dev, "couldn't create power supply for rt-charger\n");
1111 #ifdef CONFIG_HAS_EARLYSUSPEND
1112 ci->early_suspend.level = EARLY_SUSPEND_LEVEL_DISABLE_FB + 1;
1113 ci->early_suspend.suspend = rt5025_charger_earlysuspend;
1114 ci->early_suspend.resume = rt5025_charger_earlyresume;
1115 register_early_suspend(&ci->early_suspend);
1116 #endif /* CONFIG_HAS_EARLYSUSPEND */
1118 #ifdef CONFIG_RT_POWER
1119 rt_power_pdata = devm_kzalloc(&pdev->dev,
1120 sizeof(*rt_power_pdata), GFP_KERNEL);
1121 if (!rt_power_pdata) {
1125 rt_power_pdata->chg_volt = ci->chg_volt;
1126 rt_power_pdata->acchg_icc = ci->acchg_icc;
1127 rt_power_pdata->usbtachg_icc = ci->usbtachg_icc;
1128 rt_power_pdata->usbchg_icc = ci->usbchg_icc;
1130 rt_power_dev.dev.platform_data = rt_power_pdata;
1131 rt_power_dev.dev.parent = &pdev->dev;
1132 ret = platform_device_register(&rt_power_dev);
1135 #endif /* #ifdef CONFIG_RT_POWER */
1137 chip->charger_info = ci;
1138 schedule_delayed_work(&ci->tempmon_work, 1*HZ);
1139 dev_info(&pdev->dev, "driver successfully loaded\n");
1141 #ifdef CONFIG_RT_POWER
1143 #endif /* #ifdef CONFIG_RT_POWER */
1144 #ifdef CONFIG_HAS_EARLYSUSPEND
1145 unregister_early_suspend(&ci->early_suspend);
1146 #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
1147 power_supply_unregister(&ci->psy);
1152 static int rt5025_charger_remove(struct platform_device *pdev)
1154 struct rt5025_charger_info *ci = platform_get_drvdata(pdev);
1156 power_supply_unregister(&ci->psy);
1157 #ifdef CONFIG_HAS_EARLYSUSPEND
1158 unregister_early_suspend(&ci->early_suspend);
1159 #endif /* #ifdef CONFIG_HAS_EARLYSUSPEND */
1160 #ifdef CONFIG_RT_POWER
1161 platform_device_unregister(&rt_power_dev);
1162 #endif /* #ifdef CONFIG_RT_POWER */
1166 static int rt5025_charger_suspend(struct platform_device *pdev,
1169 struct rt5025_charger_info *ci = platform_get_drvdata(pdev);
1170 union power_supply_propval pval;
1173 cancel_delayed_work_sync(&ci->tempmon_work);
1174 /*force inttemp to normal temp*/
1175 ci->inttemp_region = RT5025_INTTEMP_NORMAL;
1177 rt_charger_set_property(&ci->psy, POWER_SUPPLY_PROP_PRESENT, &pval);
1181 static int rt5025_charger_resume(struct platform_device *pdev)
1183 struct rt5025_charger_info *ci = platform_get_drvdata(pdev);
1186 schedule_delayed_work(&ci->tempmon_work, msecs_to_jiffies(50));
1190 static const struct of_device_id rt_match_table[] = {
1191 { .compatible = "rt,rt5025-charger",},
1195 static struct platform_driver rt5025_charger_driver = {
1197 .name = RT5025_DEV_NAME "-charger",
1198 .owner = THIS_MODULE,
1199 .of_match_table = rt_match_table,
1201 .probe = rt5025_charger_probe,
1202 .remove = rt5025_charger_remove,
1203 .suspend = rt5025_charger_suspend,
1204 .resume = rt5025_charger_resume,
1207 static int rt5025_charger_init(void)
1209 return platform_driver_register(&rt5025_charger_driver);
1211 fs_initcall_sync(rt5025_charger_init);
1213 static void rt5025_charger_exit(void)
1215 platform_driver_unregister(&rt5025_charger_driver);
1218 module_exit(rt5025_charger_exit);
1220 MODULE_LICENSE("GPL");
1221 MODULE_AUTHOR("CY Huang <cy_huang@richtek.com>");
1222 MODULE_DESCRIPTION("Charger driver for RT5025");
1223 MODULE_ALIAS("platform:"RT5025_DEV_NAME "-charger");
1224 MODULE_VERSION(RT5025_DRV_VER);