2 * RockChip ADC Battery Driver
3 * Copyright (C) 2012, RockChip
5 * Authors: xuhuicong <xhc@rock-chips.com>
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
15 #include <linux/platform_device.h>
16 #include <linux/power_supply.h>
17 #include <linux/workqueue.h>
18 #include <linux/kernel.h>
19 #include <linux/i2c.h>
20 #include <mach/gpio.h>
21 #include <linux/delay.h>
22 #include <linux/power/cw2015_battery.h>
23 #include <linux/time.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <mach/board.h>
28 #define REG_VERSION 0x0
31 #define REG_RRT_ALERT 0x6
32 #define REG_CONFIG 0x8
34 #define REG_BATINFO 0x10
36 #define MODE_SLEEP_MASK (0x3<<6)
37 #define MODE_SLEEP (0x3<<6)
38 #define MODE_NORMAL (0x0<<6)
39 #define MODE_QUICK_START (0x3<<4)
40 #define MODE_RESTART (0xf<<0)
42 #define CONFIG_UPDATE_FLG (0x1<<1)
43 #define ATHD (0x0<<3) //ATHD = 0%
45 #define CW_I2C_SPEED 100000 // default i2c speed set 100khz
46 #define BATTERY_UP_MAX_CHANGE 420 // the max time allow battery change quantity
47 #define BATTERY_DOWN_CHANGE 60 // the max time allow battery change quantity
48 #define BATTERY_DOWN_MIN_CHANGE_RUN 30 // the min time allow battery change quantity when run
49 #define BATTERY_DOWN_MIN_CHANGE_SLEEP 1800 // the min time allow battery change quantity when run 30min
51 #define BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE 3600
53 #define NO_STANDARD_AC_BIG_CHARGE_MODE 1
54 // #define SYSTEM_SHUTDOWN_VOLTAGE 3400000 //set system shutdown voltage related in battery info.
55 #define BAT_LOW_INTERRUPT 1
57 #define USB_CHARGER_MODE 1
58 #define AC_CHARGER_MODE 2
60 extern int dwc_otg_check_dpdm(void);
61 extern int get_gadget_connect_flag(void);
62 extern int dwc_vbus_status( void );
65 struct i2c_client *client;
66 struct workqueue_struct *battery_workqueue;
67 struct delayed_work battery_delay_work;
68 struct delayed_work dc_wakeup_work;
69 struct delayed_work bat_low_wakeup_work;
70 const struct cw_bat_platform_data *plat_data;
72 struct power_supply rk_bat;
73 struct power_supply rk_ac;
74 struct power_supply rk_usb;
76 long sleep_time_capacity_change; // the sleep time from capacity change to present, it will set 0 when capacity change
77 long run_time_capacity_change;
79 long sleep_time_charge_start; // the sleep time from insert ac to present, it will set 0 when insert ac
80 long run_time_charge_start;
85 int charger_init_mode;
95 static int cw_read(struct i2c_client *client, u8 reg, u8 buf[])
98 ret = i2c_master_reg8_recv(client, reg, buf, 1, CW_I2C_SPEED);
102 static int cw_write(struct i2c_client *client, u8 reg, u8 const buf[])
105 ret = i2c_master_reg8_send(client, reg, buf, 1, CW_I2C_SPEED);
109 static int cw_read_word(struct i2c_client *client, u8 reg, u8 buf[])
112 ret = i2c_master_reg8_recv(client, reg, buf, 2, CW_I2C_SPEED);
117 static int cw_write_word(struct i2c_client *client, u8 reg, u8 const buf[])
120 ret = i2c_master_reg8_send(client, reg, buf, 2, CW_I2C_SPEED);
127 static int cw_update_config_info(struct cw_battery *cw_bat)
134 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
136 /* make sure no in sleep mode */
137 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
142 if((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
143 dev_err(&cw_bat->client->dev, "Error, device in sleep mode, cannot update battery info\n");
147 /* update new battery info */
148 for (i = 0; i < SIZE_BATINFO; i++) {
149 dev_info(&cw_bat->client->dev, "cw_bat->plat_data->cw_bat_config_info[%d] = 0x%x\n", i, \
150 cw_bat->plat_data->cw_bat_config_info[i]);
151 ret = cw_write(cw_bat->client, REG_BATINFO + i, &cw_bat->plat_data->cw_bat_config_info[i]);
157 /* readback & check */
158 for (i = 0; i < SIZE_BATINFO; i++) {
159 ret = cw_read(cw_bat->client, REG_BATINFO + i, ®_val);
160 if (reg_val != cw_bat->plat_data->cw_bat_config_info[i])
164 /* set cw2015/cw2013 to use new battery info */
165 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
169 reg_val |= CONFIG_UPDATE_FLG; /* set UPDATE_FLAG */
170 reg_val &= 0x07; /* clear ATHD */
171 reg_val |= ATHD; /* set ATHD */
172 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
176 /* check 2015/cw2013 for ATHD & update_flag */
177 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
181 if (!(reg_val & CONFIG_UPDATE_FLG)) {
182 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set..\n");
185 if ((reg_val & 0xf8) != ATHD) {
186 dev_info(&cw_bat->client->dev, "the new ATHD have not set..\n");
190 reset_val &= ~(MODE_RESTART);
191 reg_val = reset_val | MODE_RESTART;
192 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
197 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
204 static int cw_init(struct cw_battery *cw_bat)
208 u8 reg_val = MODE_SLEEP;
210 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
214 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
215 reg_val = MODE_NORMAL;
216 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
221 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
225 if ((reg_val & 0xf8) != ATHD) {
226 dev_info(&cw_bat->client->dev, "the new ATHD have not set\n");
227 reg_val &= 0x07; /* clear ATHD */
228 reg_val |= ATHD; /* set ATHD */
229 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
234 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
238 if (!(reg_val & CONFIG_UPDATE_FLG)) {
239 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set\n");
240 ret = cw_update_config_info(cw_bat);
244 for(i = 0; i < SIZE_BATINFO; i++) {
245 ret = cw_read(cw_bat->client, (REG_BATINFO + i), ®_val);
249 if (cw_bat->plat_data->cw_bat_config_info[i] != reg_val)
253 if (i != SIZE_BATINFO) {
254 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set\n");
255 ret = cw_update_config_info(cw_bat);
261 for (i = 0; i < 30; i++) {
262 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
265 else if (ret != 0xff)
270 dev_err(&cw_bat->client->dev, "cw2015/cw2013 input unvalid power error\n");
277 static void cw_update_time_member_charge_start(struct cw_battery *cw_bat)
284 new_run_time = ts.tv_sec;
286 get_monotonic_boottime(&ts);
287 new_sleep_time = ts.tv_sec - new_run_time;
289 cw_bat->run_time_charge_start = new_run_time;
290 cw_bat->sleep_time_charge_start = new_sleep_time;
293 static void cw_update_time_member_capacity_change(struct cw_battery *cw_bat)
300 new_run_time = ts.tv_sec;
302 get_monotonic_boottime(&ts);
303 new_sleep_time = ts.tv_sec - new_run_time;
305 cw_bat->run_time_capacity_change = new_run_time;
306 cw_bat->sleep_time_capacity_change = new_sleep_time;
309 static int cw_quickstart(struct cw_battery *cw_bat)
312 u8 reg_val = MODE_QUICK_START;
314 ret = cw_write(cw_bat->client, REG_MODE, ®_val); //(MODE_QUICK_START | MODE_NORMAL)); // 0x30
316 dev_err(&cw_bat->client->dev, "Error quick start1\n");
320 reg_val = MODE_NORMAL;
321 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
323 dev_err(&cw_bat->client->dev, "Error quick start2\n");
329 static int cw_get_capacity(struct cw_battery *cw_bat)
338 long capacity_or_aconline_time;
341 static int if_quickstart = 0;
342 static int jump_flag =0;
346 // ret = cw_read(cw_bat->client, REG_SOC, ®_val);
347 ret = cw_read_word(cw_bat->client, REG_SOC, reg_val);
351 cw_capacity = reg_val[0];
352 if ((cw_capacity < 0) || (cw_capacity > 100)) {
353 dev_err(&cw_bat->client->dev, "get cw_capacity error; cw_capacity = %d\n", cw_capacity);
357 if (cw_capacity == 0)
358 dev_dbg(&cw_bat->client->dev, "the cw201x capacity is 0 !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
360 dev_dbg(&cw_bat->client->dev, "the cw201x capacity is %d, funciton: %s\n", cw_capacity, __func__);
362 // ret = cw_read(cw_bat->client, REG_SOC + 1, ®_val);
365 new_run_time = ts.tv_sec;
367 get_monotonic_boottime(&ts);
368 new_sleep_time = ts.tv_sec - new_run_time;
370 if ((cw_bat->charger_mode > 0) && (cw_capacity >= 95) && (cw_capacity <= cw_bat->capacity)) { // avoid no charge full
372 capacity_or_aconline_time = (cw_bat->sleep_time_capacity_change > cw_bat->sleep_time_charge_start) ? cw_bat->sleep_time_capacity_change : cw_bat->sleep_time_charge_start;
373 capacity_or_aconline_time += (cw_bat->run_time_capacity_change > cw_bat->run_time_charge_start) ? cw_bat->run_time_capacity_change : cw_bat->run_time_charge_start;
374 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
375 if (allow_change > 0) {
376 allow_capacity = cw_bat->capacity + allow_change;
377 cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
379 } else if (cw_capacity <= cw_bat->capacity) {
380 cw_capacity = cw_bat->capacity;
383 } else if (((cw_bat->charger_mode > 0) && (cw_capacity == (cw_bat->capacity - 1)))
384 || ((cw_bat->charger_mode == 0) && (cw_capacity == (cw_bat->capacity + 1)))) { // modify battery level swing
386 if (!(cw_capacity == 0 && cw_bat->capacity == 1)) {
387 cw_capacity = cw_bat->capacity;
391 } else if ((cw_capacity == 0) && (cw_bat->capacity > 1)) { // avoid battery level jump to 0% at a moment from more than 2%
392 allow_change = ((new_run_time - cw_bat->run_time_capacity_change) / BATTERY_DOWN_MIN_CHANGE_RUN);
393 allow_change += ((new_sleep_time - cw_bat->sleep_time_capacity_change) / BATTERY_DOWN_MIN_CHANGE_SLEEP);
395 allow_capacity = cw_bat->capacity - allow_change;
396 cw_capacity = (allow_capacity >= cw_capacity) ? allow_capacity: cw_capacity;
397 reg_val[0] = MODE_NORMAL;
398 ret = cw_write(cw_bat->client, REG_MODE, reg_val);
402 } else if ((cw_bat->charger_mode == 0) && (cw_capacity <= cw_bat->capacity ) && (cw_capacity >= 90) && (jump_flag == 1)) { // avoid battery level jump to CW_BAT
403 capacity_or_aconline_time = (cw_bat->sleep_time_capacity_change > cw_bat->sleep_time_charge_start) ? cw_bat->sleep_time_capacity_change : cw_bat->sleep_time_charge_start;
404 capacity_or_aconline_time += (cw_bat->run_time_capacity_change > cw_bat->run_time_charge_start) ? cw_bat->run_time_capacity_change : cw_bat->run_time_charge_start;
405 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_DOWN_CHANGE;
406 if (allow_change > 0) {
407 allow_capacity = cw_bat->capacity - allow_change;
408 if (cw_capacity >= allow_capacity){
412 cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
414 } else if (cw_capacity <= cw_bat->capacity) {
415 cw_capacity = cw_bat->capacity;
420 if((cw_bat->charger_mode > 0) &&(cw_capacity == 0))
422 charge_time = new_sleep_time + new_run_time - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
423 if ((charge_time > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE) && (if_quickstart == 0)) {
424 cw_quickstart(cw_bat); // if the cw_capacity = 0 the cw2015 will qstrt
427 } else if ((if_quickstart == 1)&&(cw_bat->charger_mode == 0)) {
434 if (cw_bat->plat_data->chg_ok_pin != INVALID_GPIO) {
435 if(gpio_get_value(cw_bat->plat_data->chg_ok_pin) != cw_bat->plat_data->chg_ok_level) {
436 if (cw_capacity == 100) {
440 if (cw_bat->charger_mode > 0) {
447 #ifdef SYSTEM_SHUTDOWN_VOLTAGE
448 if ((cw_bat->charger_mode == 0) && (cw_capacity <= 10) && (cw_bat->voltage <= SYSTEM_SHUTDOWN_VOLTAGE)){
449 if (if_quickstart == 10){
450 cw_quickstart(cw_bat);
453 } else if (if_quickstart <= 10)
454 if_quickstart =if_quickstart+2;
455 dev_info(&cw_bat->client->dev, "the cw201x voltage is less than SYSTEM_SHUTDOWN_VOLTAGE !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
456 } else if ((cw_bat->charger_mode > 0)&& (if_quickstart <= 12)) {
463 static int cw_get_vol(struct cw_battery *cw_bat)
467 u16 value16, value16_1, value16_2, value16_3;
470 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
473 value16 = (reg_val[0] << 8) + reg_val[1];
475 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
478 value16_1 = (reg_val[0] << 8) + reg_val[1];
480 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
483 value16_2 = (reg_val[0] << 8) + reg_val[1];
486 if(value16 > value16_1)
490 value16_1 = value16_3;
493 if(value16_1 > value16_2)
495 value16_3 =value16_1;
496 value16_1 =value16_2;
497 value16_2 =value16_3;
500 if(value16 >value16_1)
504 value16_1 =value16_3;
507 voltage = value16_1 * 312 / 1024;
508 voltage = voltage * 1000;
513 #ifdef BAT_LOW_INTERRUPT
514 static int cw_get_alt(struct cw_battery *cw_bat)
521 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
527 //dev_info(&cw_bat->client->dev, "read RRT %d%%. value16 0x%x\n", alrt, value16);
528 value8 = value8&0x7f;
530 ret = cw_write(cw_bat->client, REG_RRT_ALERT, ®_val);
532 dev_err(&cw_bat->client->dev, "Error clear ALRT\n");
541 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
547 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
553 ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, ®_val);
557 value16 = ((value16 << 8) + reg_val) & 0x1fff;
561 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
565 cw_capacity = cw_get_capacity(cw_bat);
566 if ((cw_capacity >= 0) && (cw_capacity <= 100) && (cw_bat->capacity != cw_capacity)) {
567 cw_bat->capacity = cw_capacity;
568 cw_bat->bat_change = 1;
569 cw_update_time_member_capacity_change(cw_bat);
571 if (cw_bat->capacity == 0)
572 dev_info(&cw_bat->client->dev, "report battery capacity 0 and will shutdown if no changing");
579 static void rk_bat_update_vol(struct cw_battery *cw_bat)
582 ret = cw_get_vol(cw_bat);
583 if ((ret >= 0) && (cw_bat->voltage != ret)) {
584 cw_bat->voltage = ret;
585 cw_bat->bat_change = 1;
589 static void rk_bat_update_status(struct cw_battery *cw_bat)
594 if (cw_bat->charger_mode > 0) {
595 if (cw_bat->capacity >= 100)
596 status=POWER_SUPPLY_STATUS_FULL;
598 status=POWER_SUPPLY_STATUS_CHARGING;
600 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
603 if (cw_bat->status != status) {
604 cw_bat->status = status;
605 cw_bat->bat_change = 1;
610 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
613 ret = cw_get_time_to_empty(cw_bat);
614 if ((ret >= 0) && (cw_bat->time_to_empty != ret)) {
615 cw_bat->time_to_empty = ret;
616 cw_bat->bat_change = 1;
621 static int rk_ac_update_online(struct cw_battery *cw_bat)
625 if(cw_bat->plat_data->dc_det_pin == INVALID_GPIO) {
626 cw_bat->dc_online = 0;
630 if (cw_bat->plat_data->is_dc_charge == 0) {
631 cw_bat->dc_online = 0;
636 if (gpio_get_value(cw_bat->plat_data->dc_det_pin) == cw_bat->plat_data->dc_det_level) {
637 if (cw_bat->dc_online != 1) {
638 cw_update_time_member_charge_start(cw_bat);
639 cw_bat->dc_online = 1;
640 if (cw_bat->charger_mode != AC_CHARGER_MODE)
641 cw_bat->charger_mode = AC_CHARGER_MODE;
646 if (cw_bat->dc_online != 0) {
647 cw_update_time_member_charge_start(cw_bat);
648 cw_bat->dc_online = 0;
649 if (cw_bat->usb_online == 0)
650 cw_bat->charger_mode = 0;
657 static int get_usb_charge_state(struct cw_battery *cw_bat)
663 int gadget_status = get_gadget_connect_flag();
664 int usb_status = dwc_vbus_status();
666 get_monotonic_boottime(&ts);
667 time_from_boot = ts.tv_sec;
669 if (cw_bat->charger_init_mode) {
671 if (usb_status == 1 || usb_status == 2) {
672 cw_bat->charger_init_mode = 0;
673 } else if (time_from_boot < 8) {
674 usb_status = cw_bat->charger_init_mode;
675 } else if (strstr(saved_command_line,"charger")) {
676 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
677 usb_status = cw_bat->charger_init_mode;
680 #ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
681 if (cw_bat->usb_online == 1) {
683 charge_time = time_from_boot - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
684 if (charge_time > 3) {
685 if (gadget_status == 0 && dwc_vbus_status() == 1) {
693 dev_dbg(&cw_bat->client->dev, "%s usb_status=[%d],cw_bat->charger_mode=[%d],cw_bat->gadget_status=[%d], cw_bat->charger_init_mode = [%d]\n",__func__,usb_status,cw_bat->charger_mode,gadget_status, cw_bat->charger_init_mode);
699 static int rk_usb_update_online(struct cw_battery *cw_bat)
704 if (cw_bat->plat_data->is_usb_charge == 0) {
705 cw_bat->usb_online = 0;
710 usb_status = get_usb_charge_state(cw_bat);
711 if (usb_status == 2) {
712 if (cw_bat->charger_mode != AC_CHARGER_MODE) {
713 cw_bat->charger_mode = AC_CHARGER_MODE;
716 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO) {
717 if (gpio_get_value (cw_bat->plat_data->chg_mode_sel_pin) != cw_bat->plat_data->chg_mode_sel_level)
718 gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_HIGH : GPIO_LOW);
721 if (cw_bat->usb_online != 1) {
722 cw_bat->usb_online = 1;
723 cw_update_time_member_charge_start(cw_bat);
726 } else if (usb_status == 1) {
727 if ((cw_bat->charger_mode != USB_CHARGER_MODE) && (cw_bat->dc_online == 0)) {
728 cw_bat->charger_mode = USB_CHARGER_MODE;
732 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO) {
733 if (gpio_get_value (cw_bat->plat_data->chg_mode_sel_pin) == cw_bat->plat_data->chg_mode_sel_level)
734 gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_LOW : GPIO_HIGH);
736 if (cw_bat->usb_online != 1){
737 cw_bat->usb_online = 1;
738 cw_update_time_member_charge_start(cw_bat);
741 } else if (usb_status == 0 && cw_bat->usb_online != 0) {
743 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO) {
744 if (gpio_get_value (cw_bat->plat_data->chg_mode_sel_pin == cw_bat->plat_data->chg_mode_sel_level))
745 gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_LOW : GPIO_HIGH);
748 if (cw_bat->dc_online == 0)
749 cw_bat->charger_mode = 0;
751 cw_update_time_member_charge_start(cw_bat);
752 cw_bat->usb_online = 0;
759 static void cw_bat_work(struct work_struct *work)
761 struct delayed_work *delay_work;
762 struct cw_battery *cw_bat;
765 delay_work = container_of(work, struct delayed_work, work);
766 cw_bat = container_of(delay_work, struct cw_battery, battery_delay_work);
769 ret = rk_ac_update_online(cw_bat);
771 power_supply_changed(&cw_bat->rk_ac);
774 if (cw_bat->plat_data->is_usb_charge == 1) {
775 ret = rk_usb_update_online(cw_bat);
777 power_supply_changed(&cw_bat->rk_usb);
778 power_supply_changed(&cw_bat->rk_ac);
783 rk_bat_update_status(cw_bat);
784 rk_bat_update_capacity(cw_bat);
785 rk_bat_update_vol(cw_bat);
786 rk_bat_update_time_to_empty(cw_bat);
788 if (cw_bat->bat_change) {
789 power_supply_changed(&cw_bat->rk_bat);
790 cw_bat->bat_change = 0;
793 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
795 dev_dbg(&cw_bat->client->dev, "cw_bat->bat_change = %d, cw_bat->time_to_empty = %d, cw_bat->capacity = %d, cw_bat->voltage = %d, cw_bat->dc_online = %d, cw_bat->usb_online = %d\n",\
796 cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity, cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
799 static int rk_usb_get_property (struct power_supply *psy,
800 enum power_supply_property psp,
801 union power_supply_propval *val)
804 struct cw_battery *cw_bat;
806 cw_bat = container_of(psy, struct cw_battery, rk_usb);
808 case POWER_SUPPLY_PROP_ONLINE:
809 // val->intval = cw_bat->usb_online;
810 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
818 static enum power_supply_property rk_usb_properties[] = {
819 POWER_SUPPLY_PROP_ONLINE,
823 static int rk_ac_get_property (struct power_supply *psy,
824 enum power_supply_property psp,
825 union power_supply_propval *val)
828 struct cw_battery *cw_bat;
830 cw_bat = container_of(psy, struct cw_battery, rk_ac);
832 case POWER_SUPPLY_PROP_ONLINE:
833 // val->intval = cw_bat->dc_online;
834 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
842 static enum power_supply_property rk_ac_properties[] = {
843 POWER_SUPPLY_PROP_ONLINE,
846 static int rk_battery_get_property(struct power_supply *psy,
847 enum power_supply_property psp,
848 union power_supply_propval *val)
851 struct cw_battery *cw_bat;
853 cw_bat = container_of(psy, struct cw_battery, rk_bat);
855 case POWER_SUPPLY_PROP_CAPACITY:
856 val->intval = cw_bat->capacity;
858 case POWER_SUPPLY_PROP_STATUS:
859 val->intval = cw_bat->status;
862 case POWER_SUPPLY_PROP_HEALTH:
863 val->intval= POWER_SUPPLY_HEALTH_GOOD;
865 case POWER_SUPPLY_PROP_PRESENT:
866 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
869 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
870 val->intval = cw_bat->voltage;
873 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
874 val->intval = cw_bat->time_to_empty;
877 case POWER_SUPPLY_PROP_TECHNOLOGY:
878 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
887 static enum power_supply_property rk_battery_properties[] = {
888 POWER_SUPPLY_PROP_CAPACITY,
889 POWER_SUPPLY_PROP_STATUS,
890 POWER_SUPPLY_PROP_HEALTH,
891 POWER_SUPPLY_PROP_PRESENT,
892 POWER_SUPPLY_PROP_VOLTAGE_NOW,
893 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
894 POWER_SUPPLY_PROP_TECHNOLOGY,
897 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
901 gpio_free(cw_bat->plat_data->dc_det_pin);
902 if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
903 ret = gpio_request(cw_bat->plat_data->dc_det_pin, NULL);
905 dev_err(&cw_bat->client->dev, "failed to request dc_det_pin gpio\n");
906 goto request_dc_det_pin_fail;
909 gpio_pull_updown(cw_bat->plat_data->dc_det_pin, GPIOPullUp);
910 ret = gpio_direction_input(cw_bat->plat_data->dc_det_pin);
912 dev_err(&cw_bat->client->dev, "failed to set dc_det_pin input\n");
913 goto request_bat_low_pin_fail;
916 if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
917 ret = gpio_request(cw_bat->plat_data->bat_low_pin, NULL);
919 dev_err(&cw_bat->client->dev, "failed to request bat_low_pin gpio\n");
920 goto request_bat_low_pin_fail;
923 gpio_pull_updown(cw_bat->plat_data->bat_low_pin, GPIOPullUp);
924 ret = gpio_direction_input(cw_bat->plat_data->bat_low_pin);
926 dev_err(&cw_bat->client->dev, "failed to set bat_low_pin input\n");
927 goto request_chg_ok_pin_fail;
930 if (cw_bat->plat_data->chg_ok_pin != INVALID_GPIO) {
931 ret = gpio_request(cw_bat->plat_data->chg_ok_pin, NULL);
933 dev_err(&cw_bat->client->dev, "failed to request chg_ok_pin gpio\n");
934 goto request_chg_ok_pin_fail;
937 gpio_pull_updown(cw_bat->plat_data->chg_ok_pin, GPIOPullUp);
938 ret = gpio_direction_input(cw_bat->plat_data->chg_ok_pin);
940 dev_err(&cw_bat->client->dev, "failed to set chg_ok_pin input\n");
941 gpio_free(cw_bat->plat_data->chg_ok_pin);
942 goto request_chg_ok_pin_fail;
946 if ((cw_bat->plat_data->is_usb_charge == 1) && (cw_bat->plat_data->chg_mode_sel_pin!= INVALID_GPIO)) {
947 ret = gpio_request(cw_bat->plat_data->chg_mode_sel_pin, NULL);
949 dev_err(&cw_bat->client->dev, "failed to request chg_mode_sel_pin gpio\n");
950 goto request_chg_ok_pin_fail;
952 ret = gpio_direction_output(cw_bat->plat_data->chg_mode_sel_pin, (cw_bat->plat_data->chg_mode_sel_level==GPIO_HIGH) ? GPIO_LOW : GPIO_HIGH);
954 dev_err(&cw_bat->client->dev, "failed to set chg_mode_sel_pin input\n");
955 gpio_free(cw_bat->plat_data->chg_mode_sel_pin);
956 goto request_chg_ok_pin_fail;
963 request_chg_ok_pin_fail:
964 if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO)
965 gpio_free(cw_bat->plat_data->bat_low_pin);
967 request_bat_low_pin_fail:
968 if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO)
969 gpio_free(cw_bat->plat_data->dc_det_pin);
971 request_dc_det_pin_fail:
977 static void dc_detect_do_wakeup(struct work_struct *work)
983 struct delayed_work *delay_work;
984 struct cw_battery *cw_bat;
986 delay_work = container_of(work, struct delayed_work, work);
987 cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
989 rk28_send_wakeup_key();
991 /* this assume if usb insert or extract dc_det pin is change */
993 if(cw_bat->charger_init_mode)
994 cw_bat->charger_init_mode=0;
997 irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
998 type = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
999 ret = irq_set_irq_type(irq, type);
1001 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq, type);
1006 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
1008 struct cw_battery *cw_bat = dev_id;
1009 disable_irq_nosync(irq); // for irq debounce
1010 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work, msecs_to_jiffies(20));
1014 #ifdef BAT_LOW_INTERRUPT
1016 #define WAKE_LOCK_TIMEOUT (10 * HZ)
1017 static struct wake_lock bat_low_wakelock;
1019 static void bat_low_detect_do_wakeup(struct work_struct *work)
1021 struct delayed_work *delay_work;
1022 struct cw_battery *cw_bat;
1024 delay_work = container_of(work, struct delayed_work, work);
1025 cw_bat = container_of(delay_work, struct cw_battery, bat_low_wakeup_work);
1026 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
1031 static irqreturn_t bat_low_detect_irq_handler(int irq, void *dev_id)
1033 struct cw_battery *cw_bat = dev_id;
1034 // disable_irq_nosync(irq); // for irq debounce
1035 wake_lock_timeout(&bat_low_wakelock, WAKE_LOCK_TIMEOUT);
1036 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->bat_low_wakeup_work, msecs_to_jiffies(20));
1041 static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
1043 struct cw_battery *cw_bat;
1049 cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
1051 dev_err(&cw_bat->client->dev, "fail to allocate memory\n");
1055 i2c_set_clientdata(client, cw_bat);
1056 cw_bat->plat_data = client->dev.platform_data;
1057 ret = cw_bat_gpio_init(cw_bat);
1059 dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
1063 cw_bat->client = client;
1065 ret = cw_init(cw_bat);
1066 while ((loop++ < 200) && (ret != 0)) {
1067 ret = cw_init(cw_bat);
1073 cw_bat->rk_bat.name = "rk-bat";
1074 cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1075 cw_bat->rk_bat.properties = rk_battery_properties;
1076 cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
1077 cw_bat->rk_bat.get_property = rk_battery_get_property;
1078 ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
1080 dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n");
1081 goto rk_bat_register_fail;
1084 cw_bat->rk_ac.name = "rk-ac";
1085 cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
1086 cw_bat->rk_ac.properties = rk_ac_properties;
1087 cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
1088 cw_bat->rk_ac.get_property = rk_ac_get_property;
1089 ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1091 dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
1092 goto rk_ac_register_fail;
1095 cw_bat->rk_usb.name = "rk-usb";
1096 cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1097 cw_bat->rk_usb.properties = rk_usb_properties;
1098 cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1099 cw_bat->rk_usb.get_property = rk_usb_get_property;
1100 ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1102 dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
1103 goto rk_usb_register_fail;
1106 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1108 cw_bat->dc_online = 0;
1109 cw_bat->usb_online = 0;
1110 cw_bat->charger_mode = 0;
1111 cw_bat->capacity = 2;
1112 cw_bat->voltage = 0;
1114 cw_bat->time_to_empty = 0;
1115 cw_bat->bat_change = 0;
1117 cw_update_time_member_capacity_change(cw_bat);
1118 cw_update_time_member_charge_start(cw_bat);
1120 cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1121 INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1122 INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1123 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1125 if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
1126 irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
1127 irq_flags = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1128 ret = request_irq(irq, dc_detect_irq_handler, irq_flags, "usb_detect", cw_bat);
1130 pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1132 enable_irq_wake(irq);
1135 #ifdef BAT_LOW_INTERRUPT
1136 INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup);
1137 wake_lock_init(&bat_low_wakelock, WAKE_LOCK_SUSPEND, "bat_low_detect");
1138 if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
1139 irq = gpio_to_irq(cw_bat->plat_data->bat_low_pin);
1140 ret = request_irq(irq, bat_low_detect_irq_handler, IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
1142 gpio_free(cw_bat->plat_data->bat_low_pin);
1144 enable_irq_wake(irq);
1148 dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe sucess\n");
1151 rk_usb_register_fail:
1152 power_supply_unregister(&cw_bat->rk_bat);
1153 rk_ac_register_fail:
1154 power_supply_unregister(&cw_bat->rk_ac);
1155 rk_bat_register_fail:
1156 dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n");
1160 static int cw_bat_remove(struct i2c_client *client)
1162 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1163 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1164 cancel_delayed_work(&cw_bat->battery_delay_work);
1169 static int cw_bat_suspend(struct device *dev)
1171 struct i2c_client *client = to_i2c_client(dev);
1172 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1173 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1174 cancel_delayed_work(&cw_bat->battery_delay_work);
1178 static int cw_bat_resume(struct device *dev)
1180 struct i2c_client *client = to_i2c_client(dev);
1181 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1182 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1183 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1187 static const struct i2c_device_id cw_id[] = {
1190 MODULE_DEVICE_TABLE(i2c, cw_id);
1192 static const struct dev_pm_ops cw_bat_pm_ops = {
1193 .suspend = cw_bat_suspend,
1194 .resume = cw_bat_resume,
1198 static struct i2c_driver cw_bat_driver = {
1202 .pm = &cw_bat_pm_ops,
1206 .probe = cw_bat_probe,
1207 .remove = cw_bat_remove,
1211 static int __init cw_bat_init(void)
1213 return i2c_add_driver(&cw_bat_driver);
1216 static void __exit cw_bat_exit(void)
1218 i2c_del_driver(&cw_bat_driver);
1221 fs_initcall(cw_bat_init);
1222 module_exit(cw_bat_exit);
1224 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1225 MODULE_DESCRIPTION("cw2015/cw2013 battery driver");
1226 MODULE_LICENSE("GPL");