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.
14 #include <linux/gpio.h>
15 #include <linux/of_gpio.h>
16 #include <linux/platform_device.h>
17 #include <linux/power_supply.h>
18 #include <linux/workqueue.h>
19 #include <linux/kernel.h>
20 #include <linux/i2c.h>
21 #include <linux/module.h>
22 #include <linux/delay.h>
23 #include <linux/power/cw2015_battery.h>
24 #include <linux/time.h>
25 #include <linux/interrupt.h>
26 #include <linux/irq.h>
27 #include <linux/slab.h>
29 #define CW2015_GPIO_HIGH 1
30 #define CW2015_GPIO_LOW 0
32 #define REG_VERSION 0x0
35 #define REG_RRT_ALERT 0x6
36 #define REG_CONFIG 0x8
38 #define REG_BATINFO 0x10
40 #define MODE_SLEEP_MASK (0x3<<6)
41 #define MODE_SLEEP (0x3<<6)
42 #define MODE_NORMAL (0x0<<6)
43 #define MODE_QUICK_START (0x3<<4)
44 #define MODE_RESTART (0xf<<0)
46 #define CONFIG_UPDATE_FLG (0x1<<1)
47 #define ATHD (0x0<<3) //ATHD = 0%
49 #define CW_I2C_SPEED 100000 // default i2c speed set 100khz
50 #define BATTERY_UP_MAX_CHANGE 420 // the max time allow battery change quantity
51 #define BATTERY_DOWN_CHANGE 60 // the max time allow battery change quantity
52 #define BATTERY_DOWN_MIN_CHANGE_RUN 30 // the min time allow battery change quantity when run
53 #define BATTERY_DOWN_MIN_CHANGE_SLEEP 1800 // the min time allow battery change quantity when run 30min
55 #define BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE 3600
57 #define NO_STANDARD_AC_BIG_CHARGE_MODE 1
58 // #define SYSTEM_SHUTDOWN_VOLTAGE 3400000 //set system shutdown voltage related in battery info.
59 #define BAT_LOW_INTERRUPT 1
61 #define USB_CHARGER_MODE 1
62 #define AC_CHARGER_MODE 2
63 #define CW_QUICKSTART 0
65 extern int dwc_otg_check_dpdm(void);
66 extern int get_gadget_connect_flag(void);
67 extern int dwc_vbus_status( void );
70 struct i2c_client *client;
71 struct workqueue_struct *battery_workqueue;
72 struct delayed_work battery_delay_work;
73 struct delayed_work dc_wakeup_work;
74 struct delayed_work bat_low_wakeup_work;
75 struct cw_bat_platform_data plat_data;
77 struct power_supply rk_bat;
78 struct power_supply rk_ac;
79 struct power_supply rk_usb;
81 long sleep_time_capacity_change; // the sleep time from capacity change to present, it will set 0 when capacity change
82 long run_time_capacity_change;
84 long sleep_time_charge_start; // the sleep time from insert ac to present, it will set 0 when insert ac
85 long run_time_charge_start;
90 int charger_init_mode;
100 static int i2c_master_reg8_send(const struct i2c_client *client, const char reg, const char *buf, int count, int scl_rate)
102 struct i2c_adapter *adap=client->adapter;
105 char *tx_buf = (char *)kzalloc(count + 1, GFP_KERNEL);
109 memcpy(tx_buf+1, buf, count);
111 msg.addr = client->addr;
112 msg.flags = client->flags;
114 msg.buf = (char *)tx_buf;
115 msg.scl_rate = scl_rate;
117 ret = i2c_transfer(adap, &msg, 1);
119 return (ret == 1) ? count : ret;
123 static int i2c_master_reg8_recv(const struct i2c_client *client, const char reg, char *buf, int count, int scl_rate)
125 struct i2c_adapter *adap=client->adapter;
126 struct i2c_msg msgs[2];
130 msgs[0].addr = client->addr;
131 msgs[0].flags = client->flags;
133 msgs[0].buf = ®_buf;
134 msgs[0].scl_rate = scl_rate;
136 msgs[1].addr = client->addr;
137 msgs[1].flags = client->flags | I2C_M_RD;
139 msgs[1].buf = (char *)buf;
140 msgs[1].scl_rate = scl_rate;
142 ret = i2c_transfer(adap, msgs, 2);
144 return (ret == 2)? count : ret;
147 static int cw_read(struct i2c_client *client, u8 reg, u8 buf[])
150 ret = i2c_master_reg8_recv(client, reg, buf, 1, CW_I2C_SPEED);
154 static int cw_write(struct i2c_client *client, u8 reg, u8 const buf[])
157 ret = i2c_master_reg8_send(client, reg, buf, 1, CW_I2C_SPEED);
161 static int cw_read_word(struct i2c_client *client, u8 reg, u8 buf[])
164 ret = i2c_master_reg8_recv(client, reg, buf, 2, CW_I2C_SPEED);
169 static int cw_write_word(struct i2c_client *client, u8 reg, u8 const buf[])
172 ret = i2c_master_reg8_send(client, reg, buf, 2, CW_I2C_SPEED);
179 static int cw_update_config_info(struct cw_battery *cw_bat)
186 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
188 /* make sure no in sleep mode */
189 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
194 if((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
195 dev_err(&cw_bat->client->dev, "Error, device in sleep mode, cannot update battery info\n");
199 /* update new battery info */
200 for (i = 0; i < SIZE_BATINFO; i++) {
201 // dev_info(&cw_bat->client->dev, "cw_bat->plat_data.cw_bat_config_info[%d] = 0x%x\n", i, cw_bat->plat_data.cw_bat_config_info[i]);
202 ret = cw_write(cw_bat->client, REG_BATINFO + i, (u8 *)&cw_bat->plat_data.cw_bat_config_info[i]);
208 /* readback & check */
209 for (i = 0; i < SIZE_BATINFO; i++) {
210 ret = cw_read(cw_bat->client, REG_BATINFO + i, ®_val);
211 if (reg_val != cw_bat->plat_data.cw_bat_config_info[i])
215 /* set cw2015/cw2013 to use new battery info */
216 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
220 reg_val |= CONFIG_UPDATE_FLG; /* set UPDATE_FLAG */
221 reg_val &= 0x07; /* clear ATHD */
222 reg_val |= ATHD; /* set ATHD */
223 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
227 /* check 2015/cw2013 for ATHD & update_flag */
228 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
232 if (!(reg_val & CONFIG_UPDATE_FLG)) {
233 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set..\n");
236 if ((reg_val & 0xf8) != ATHD) {
237 dev_info(&cw_bat->client->dev, "the new ATHD have not set..\n");
241 reset_val &= ~(MODE_RESTART);
242 reg_val = reset_val | MODE_RESTART;
243 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
248 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
255 static int cw_init(struct cw_battery *cw_bat)
259 u8 reg_val = MODE_SLEEP;
261 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
265 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
266 reg_val = MODE_NORMAL;
267 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
272 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
276 if ((reg_val & 0xf8) != ATHD) {
277 dev_info(&cw_bat->client->dev, "the new ATHD have not set\n");
278 reg_val &= 0x07; /* clear ATHD */
279 reg_val |= ATHD; /* set ATHD */
280 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
285 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
289 if (!(reg_val & CONFIG_UPDATE_FLG)) {
290 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set\n");
291 ret = cw_update_config_info(cw_bat);
295 for(i = 0; i < SIZE_BATINFO; i++) {
296 ret = cw_read(cw_bat->client, (REG_BATINFO + i), ®_val);
300 if (cw_bat->plat_data.cw_bat_config_info[i] != reg_val)
304 if (i != SIZE_BATINFO) {
305 dev_info(&cw_bat->client->dev, "update flag for new battery info have not set\n");
306 ret = cw_update_config_info(cw_bat);
312 for (i = 0; i < 30; i++) {
313 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
316 else if (reg_val <= 0x64)
321 dev_err(&cw_bat->client->dev, "cw2015/cw2013 input unvalid power error\n");
325 reg_val = MODE_SLEEP;
326 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
327 dev_info(&cw_bat->client->dev, "report battery capacity error");
333 static void cw_update_time_member_charge_start(struct cw_battery *cw_bat)
340 new_run_time = ts.tv_sec;
342 get_monotonic_boottime(&ts);
343 new_sleep_time = ts.tv_sec - new_run_time;
345 cw_bat->run_time_charge_start = new_run_time;
346 cw_bat->sleep_time_charge_start = new_sleep_time;
349 static void cw_update_time_member_capacity_change(struct cw_battery *cw_bat)
356 new_run_time = ts.tv_sec;
358 get_monotonic_boottime(&ts);
359 new_sleep_time = ts.tv_sec - new_run_time;
361 cw_bat->run_time_capacity_change = new_run_time;
362 cw_bat->sleep_time_capacity_change = new_sleep_time;
366 static int cw_quickstart(struct cw_battery *cw_bat)
369 u8 reg_val = MODE_QUICK_START;
371 ret = cw_write(cw_bat->client, REG_MODE, ®_val); //(MODE_QUICK_START | MODE_NORMAL)); // 0x30
373 dev_err(&cw_bat->client->dev, "Error quick start1\n");
377 reg_val = MODE_NORMAL;
378 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
380 dev_err(&cw_bat->client->dev, "Error quick start2\n");
386 static int cw_get_capacity(struct cw_battery *cw_bat)
395 long capacity_or_aconline_time;
398 static int if_quickstart = 0;
399 static int jump_flag =0;
400 static int reset_loop =0;
405 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
406 //ret = cw_read_word(cw_bat->client, REG_SOC, reg_val);
409 cw_capacity = reg_val;
411 if ((cw_capacity == 0)&&(if_quickstart ==0)) {
412 dev_info(&cw_bat->client->dev, "the cw201x capacity is 0 !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
414 reset_val = MODE_SLEEP;
415 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
418 reset_val = MODE_NORMAL;
420 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
423 dev_info(&cw_bat->client->dev, "report battery capacity error1");
424 // ret = cw_update_config_info(cw_bat);
430 dev_dbg(&cw_bat->client->dev, "the cw201x capacity is %d, funciton: %s\n", cw_capacity, __func__);
432 if ((cw_capacity < 0) || (cw_capacity > 100)) {
433 dev_err(&cw_bat->client->dev, "get cw_capacity error; cw_capacity = %d\n", cw_capacity);
438 reset_val = MODE_SLEEP;
439 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
442 reset_val = MODE_NORMAL;
444 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
447 dev_info(&cw_bat->client->dev, "report battery capacity error");
448 ret = cw_update_config_info(cw_bat);
461 new_run_time = ts.tv_sec;
463 get_monotonic_boottime(&ts);
464 new_sleep_time = ts.tv_sec - new_run_time;
466 if (((cw_bat->charger_mode > 0) && (cw_capacity <= (cw_bat->capacity - 1)) && (cw_capacity > (cw_bat->capacity - 9)))
467 || ((cw_bat->charger_mode == 0) && (cw_capacity == (cw_bat->capacity + 1)))) { // modify battery level swing
469 if (!(cw_capacity == 0 && cw_bat->capacity <= 2)) {
470 cw_capacity = cw_bat->capacity;
474 if ((cw_bat->charger_mode > 0) && (cw_capacity >= 95) && (cw_capacity <= cw_bat->capacity)) { // avoid no charge full
476 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;
477 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;
478 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
479 if (allow_change > 0) {
480 allow_capacity = cw_bat->capacity + allow_change;
481 cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
483 } else if (cw_capacity <= cw_bat->capacity) {
484 cw_capacity = cw_bat->capacity;
489 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
490 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;
491 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;
492 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_DOWN_CHANGE;
493 if (allow_change > 0) {
494 allow_capacity = cw_bat->capacity - allow_change;
495 if (cw_capacity >= allow_capacity){
499 cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
501 } else if (cw_capacity <= cw_bat->capacity) {
502 cw_capacity = cw_bat->capacity;
506 if ((cw_capacity == 0) && (cw_bat->capacity > 1)) { // avoid battery level jump to 0% at a moment from more than 2%
507 allow_change = ((new_run_time - cw_bat->run_time_capacity_change) / BATTERY_DOWN_MIN_CHANGE_RUN);
508 allow_change += ((new_sleep_time - cw_bat->sleep_time_capacity_change) / BATTERY_DOWN_MIN_CHANGE_SLEEP);
510 allow_capacity = cw_bat->capacity - allow_change;
511 cw_capacity = (allow_capacity >= cw_capacity) ? allow_capacity: cw_capacity;
512 dev_info(&cw_bat->client->dev, "report GGIC POR happened");
513 reset_val = MODE_SLEEP;
514 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
517 reset_val = MODE_NORMAL;
519 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
522 dev_info(&cw_bat->client->dev, "report battery capacity error");
523 ret = cw_update_config_info(cw_bat);
526 dev_info(&cw_bat->client->dev, "report battery capacity jump 0 ");
530 if((cw_bat->charger_mode > 0) &&(cw_capacity == 0))
532 charge_time = new_sleep_time + new_run_time - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
533 if ((charge_time > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE) && (if_quickstart == 0)) {
534 //cw_quickstart(cw_bat); // if the cw_capacity = 0 the cw2015 will qstrt/
535 reset_val = MODE_SLEEP;
536 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
539 reset_val = MODE_NORMAL;
541 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
544 dev_info(&cw_bat->client->dev, "report battery capacity error");
545 ret = cw_update_config_info(cw_bat);
548 dev_info(&cw_bat->client->dev, "report battery capacity still 0 if in changing");
551 } else if ((if_quickstart == 1)&&(cw_bat->charger_mode == 0)) {
558 if (gpio_is_valid(cw_bat->plat_data.chg_ok_pin)) {
559 if(gpio_get_value(cw_bat->plat_data.chg_ok_pin) != cw_bat->plat_data.chg_ok_level) {
560 if (cw_capacity == 100) {
564 if (cw_bat->charger_mode > 0) {
571 #ifdef SYSTEM_SHUTDOWN_VOLTAGE
572 if ((cw_bat->charger_mode == 0) && (cw_capacity <= 10) && (cw_bat->voltage <= SYSTEM_SHUTDOWN_VOLTAGE)){
573 if (if_quickstart == 10){
574 cw_quickstart(cw_bat);
577 } else if (if_quickstart <= 10)
578 if_quickstart =if_quickstart+2;
579 dev_info(&cw_bat->client->dev, "the cw201x voltage is less than SYSTEM_SHUTDOWN_VOLTAGE !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
580 } else if ((cw_bat->charger_mode > 0)&& (if_quickstart <= 12)) {
587 static int cw_get_vol(struct cw_battery *cw_bat)
591 u16 value16, value16_1, value16_2, value16_3;
594 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
597 value16 = (reg_val[0] << 8) + reg_val[1];
599 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
602 value16_1 = (reg_val[0] << 8) + reg_val[1];
604 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
607 value16_2 = (reg_val[0] << 8) + reg_val[1];
610 if(value16 > value16_1)
614 value16_1 = value16_3;
617 if(value16_1 > value16_2)
619 value16_3 =value16_1;
620 value16_1 =value16_2;
621 value16_2 =value16_3;
624 if(value16 >value16_1)
628 value16_1 =value16_3;
631 voltage = value16_1 * 305;
633 dev_dbg(&cw_bat->client->dev, "the cw201x voltage=%d,reg_val=%x %x\n",voltage,reg_val[0],reg_val[1]);
637 #ifdef BAT_LOW_INTERRUPT
638 static int cw_get_alt(struct cw_battery *cw_bat)
645 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
651 //dev_info(&cw_bat->client->dev, "read RRT %d%%. value16 0x%x\n", alrt, value16);
652 value8 = value8&0x7f;
654 ret = cw_write(cw_bat->client, REG_RRT_ALERT, ®_val);
656 dev_err(&cw_bat->client->dev, "Error clear ALRT\n");
665 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
671 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
677 ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, ®_val);
681 value16 = ((value16 << 8) + reg_val) & 0x1fff;
685 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
689 cw_capacity = cw_get_capacity(cw_bat);
690 if ((cw_capacity >= 0) && (cw_capacity <= 100) && (cw_bat->capacity != cw_capacity)) {
691 cw_bat->capacity = cw_capacity;
692 cw_bat->bat_change = 1;
693 cw_update_time_member_capacity_change(cw_bat);
695 if (cw_bat->capacity == 0)
696 dev_info(&cw_bat->client->dev, "report battery capacity 0 and will shutdown if no changing");
703 static void rk_bat_update_vol(struct cw_battery *cw_bat)
706 ret = cw_get_vol(cw_bat);
707 if ((ret >= 0) && (cw_bat->voltage != ret)) {
708 cw_bat->voltage = ret;
709 // cw_bat->bat_change = 1;
713 static void rk_bat_update_status(struct cw_battery *cw_bat)
718 if (cw_bat->charger_mode > 0) {
719 if (cw_bat->capacity >= 100)
720 status=POWER_SUPPLY_STATUS_FULL;
722 status=POWER_SUPPLY_STATUS_CHARGING;
724 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
727 if (cw_bat->status != status) {
728 cw_bat->status = status;
729 cw_bat->bat_change = 1;
734 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
737 ret = cw_get_time_to_empty(cw_bat);
738 if ((ret >= 0) && (cw_bat->time_to_empty != ret)) {
739 cw_bat->time_to_empty = ret;
740 // cw_bat->bat_change = 1;
745 static int rk_ac_update_online(struct cw_battery *cw_bat)
749 if(!gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
750 cw_bat->dc_online = 0;
751 printk("%s cw2015 dc charger but without dc_det_pin,maybe error\n",__func__);
755 if (gpio_get_value(cw_bat->plat_data.dc_det_pin) == cw_bat->plat_data.dc_det_level) {
756 if (cw_bat->dc_online != 1) {
757 cw_update_time_member_charge_start(cw_bat);
758 cw_bat->dc_online = 1;
759 if (cw_bat->charger_mode != AC_CHARGER_MODE)
760 cw_bat->charger_mode = AC_CHARGER_MODE;
765 if (cw_bat->dc_online != 0) {
766 cw_update_time_member_charge_start(cw_bat);
767 cw_bat->dc_online = 0;
768 if (cw_bat->usb_online == 0)
769 cw_bat->charger_mode = 0;
776 static int get_usb_charge_state(struct cw_battery *cw_bat)
782 int gadget_status = get_gadget_connect_flag();
783 int usb_status = dwc_vbus_status();
785 get_monotonic_boottime(&ts);
786 time_from_boot = ts.tv_sec;
788 if (cw_bat->charger_init_mode) {
789 if (usb_status == 1 || usb_status == 2) {
790 cw_bat->charger_init_mode = 0;
791 } else if (time_from_boot < 8) {
792 usb_status = cw_bat->charger_init_mode;
793 } else if (strstr(saved_command_line,"charger")) {
794 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
795 usb_status = cw_bat->charger_init_mode;
798 #ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
799 if (cw_bat->usb_online == 1) {
801 charge_time = time_from_boot - cw_bat->sleep_time_charge_start - cw_bat->run_time_charge_start;
802 if (charge_time > 3) {
803 if (gadget_status == 0 && dwc_vbus_status() == 1) {
810 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);
815 static int rk_usb_update_online(struct cw_battery *cw_bat)
821 usb_status = get_usb_charge_state(cw_bat);
822 if (usb_status == 2) {
823 if (cw_bat->charger_mode != AC_CHARGER_MODE) {
824 cw_bat->charger_mode = AC_CHARGER_MODE;
827 if (gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin)) {
828 if (gpio_get_value (cw_bat->plat_data.chg_mode_sel_pin) != cw_bat->plat_data.chg_mode_sel_level)
829 gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin, (cw_bat->plat_data.chg_mode_sel_level==CW2015_GPIO_LOW) ? CW2015_GPIO_LOW : CW2015_GPIO_HIGH);
832 if (cw_bat->usb_online != 1) {
833 cw_bat->usb_online = 1;
834 cw_update_time_member_charge_start(cw_bat);
837 } else if (usb_status == 1) {
838 if ((cw_bat->charger_mode != USB_CHARGER_MODE) && (cw_bat->dc_online == 0)) {
839 cw_bat->charger_mode = USB_CHARGER_MODE;
843 if (gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin)) {
844 if (gpio_get_value (cw_bat->plat_data.chg_mode_sel_pin) == cw_bat->plat_data.chg_mode_sel_level)
845 gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin, (cw_bat->plat_data.chg_mode_sel_level==CW2015_GPIO_LOW) ? CW2015_GPIO_HIGH : CW2015_GPIO_LOW);
847 if (cw_bat->usb_online != 1){
848 cw_bat->usb_online = 1;
849 cw_update_time_member_charge_start(cw_bat);
852 } else if (usb_status == 0 && cw_bat->usb_online != 0) {
854 if (gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin)) {
855 if (gpio_get_value (cw_bat->plat_data.chg_mode_sel_pin == cw_bat->plat_data.chg_mode_sel_level))
856 gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin, (cw_bat->plat_data.chg_mode_sel_level==CW2015_GPIO_LOW) ? CW2015_GPIO_HIGH : CW2015_GPIO_LOW);
859 if (cw_bat->dc_online == 0)
860 cw_bat->charger_mode = 0;
862 cw_update_time_member_charge_start(cw_bat);
863 cw_bat->usb_online = 0;
870 static void cw_bat_work(struct work_struct *work)
872 struct delayed_work *delay_work;
873 struct cw_battery *cw_bat;
876 delay_work = container_of(work, struct delayed_work, work);
877 cw_bat = container_of(delay_work, struct cw_battery, battery_delay_work);
879 if (cw_bat->plat_data.is_dc_charge == 1) {
880 ret = rk_ac_update_online(cw_bat);
882 power_supply_changed(&cw_bat->rk_ac);
886 if (cw_bat->plat_data.is_usb_charge == 1) {
887 ret = rk_usb_update_online(cw_bat);
889 power_supply_changed(&cw_bat->rk_usb);
890 power_supply_changed(&cw_bat->rk_ac);
895 rk_bat_update_status(cw_bat);
896 rk_bat_update_capacity(cw_bat);
897 rk_bat_update_vol(cw_bat);
898 rk_bat_update_time_to_empty(cw_bat);
900 if (cw_bat->bat_change) {
901 power_supply_changed(&cw_bat->rk_bat);
902 cw_bat->bat_change = 0;
905 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
907 dev_dbg(&cw_bat->client->dev, "cw_bat->bat_change = %d, cw_bat->time_to_empty = %d, cw_bat->capacity = %d\n",\
908 cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity);
910 dev_dbg(&cw_bat->client->dev, "cw_bat->voltage = %d, cw_bat->dc_online = %d, cw_bat->usb_online = %d\n",\
911 cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
914 static int rk_usb_get_property (struct power_supply *psy,
915 enum power_supply_property psp,
916 union power_supply_propval *val)
919 struct cw_battery *cw_bat;
921 cw_bat = container_of(psy, struct cw_battery, rk_usb);
923 case POWER_SUPPLY_PROP_ONLINE:
924 // val->intval = cw_bat->usb_online;
925 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
933 static enum power_supply_property rk_usb_properties[] = {
934 POWER_SUPPLY_PROP_ONLINE,
938 static int rk_ac_get_property (struct power_supply *psy,
939 enum power_supply_property psp,
940 union power_supply_propval *val)
943 struct cw_battery *cw_bat;
945 cw_bat = container_of(psy, struct cw_battery, rk_ac);
947 case POWER_SUPPLY_PROP_ONLINE:
948 // val->intval = cw_bat->dc_online;
949 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
957 static enum power_supply_property rk_ac_properties[] = {
958 POWER_SUPPLY_PROP_ONLINE,
961 static int rk_battery_get_property(struct power_supply *psy,
962 enum power_supply_property psp,
963 union power_supply_propval *val)
966 struct cw_battery *cw_bat;
968 cw_bat = container_of(psy, struct cw_battery, rk_bat);
970 case POWER_SUPPLY_PROP_CAPACITY:
971 val->intval = cw_bat->capacity;
973 case POWER_SUPPLY_PROP_STATUS:
974 val->intval = cw_bat->status;
977 case POWER_SUPPLY_PROP_HEALTH:
978 val->intval= POWER_SUPPLY_HEALTH_GOOD;
980 case POWER_SUPPLY_PROP_PRESENT:
981 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
984 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
985 val->intval = cw_bat->voltage;
988 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
989 val->intval = cw_bat->time_to_empty;
992 case POWER_SUPPLY_PROP_TECHNOLOGY:
993 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
1002 static enum power_supply_property rk_battery_properties[] = {
1003 POWER_SUPPLY_PROP_CAPACITY,
1004 POWER_SUPPLY_PROP_STATUS,
1005 POWER_SUPPLY_PROP_HEALTH,
1006 POWER_SUPPLY_PROP_PRESENT,
1007 POWER_SUPPLY_PROP_VOLTAGE_NOW,
1008 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
1009 POWER_SUPPLY_PROP_TECHNOLOGY,
1012 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
1017 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
1018 ret = gpio_request(cw_bat->plat_data.dc_det_pin, NULL);
1020 dev_err(&cw_bat->client->dev, "failed to request dc_det_pin gpio\n");
1021 goto request_dc_det_pin_fail;
1023 ret = gpio_direction_input(cw_bat->plat_data.dc_det_pin);
1025 dev_err(&cw_bat->client->dev, "failed to set dc_det_pin input\n");
1026 goto request_bat_low_pin_fail;
1029 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
1030 ret = gpio_request(cw_bat->plat_data.bat_low_pin, NULL);
1032 dev_err(&cw_bat->client->dev, "failed to request bat_low_pin gpio\n");
1033 goto request_bat_low_pin_fail;
1036 ret = gpio_direction_input(cw_bat->plat_data.bat_low_pin);
1038 dev_err(&cw_bat->client->dev, "failed to set bat_low_pin input\n");
1039 goto request_bat_low_pin_fail;
1042 if (gpio_is_valid(cw_bat->plat_data.chg_ok_pin)) {
1043 ret = gpio_request(cw_bat->plat_data.chg_ok_pin, NULL);
1045 dev_err(&cw_bat->client->dev, "failed to request chg_ok_pin gpio\n");
1046 goto request_chg_ok_pin_fail;
1049 ret = gpio_direction_input(cw_bat->plat_data.chg_ok_pin);
1051 dev_err(&cw_bat->client->dev, "failed to set chg_ok_pin input\n");
1052 gpio_free(cw_bat->plat_data.chg_ok_pin);
1053 goto request_chg_ok_pin_fail;
1057 if ((gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin))) {
1058 ret = gpio_request(cw_bat->plat_data.chg_mode_sel_pin, NULL);
1060 dev_err(&cw_bat->client->dev, "failed to request chg_mode_sel_pin gpio\n");
1061 goto request_chg_mode_sel_pin_fail;
1063 ret = gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin, (cw_bat->plat_data.chg_mode_sel_level==CW2015_GPIO_LOW) ? CW2015_GPIO_HIGH : CW2015_GPIO_LOW);
1065 dev_err(&cw_bat->client->dev, "failed to set chg_mode_sel_pin output\n");
1066 gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1067 goto request_chg_mode_sel_pin_fail;
1073 request_chg_mode_sel_pin_fail:
1074 gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1076 request_chg_ok_pin_fail:
1077 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin))
1078 gpio_free(cw_bat->plat_data.bat_low_pin);
1080 request_bat_low_pin_fail:
1081 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin))
1082 gpio_free(cw_bat->plat_data.dc_det_pin);
1084 request_dc_det_pin_fail:
1090 static void dc_detect_do_wakeup(struct work_struct *work)
1096 struct delayed_work *delay_work;
1097 struct cw_battery *cw_bat;
1099 delay_work = container_of(work, struct delayed_work, work);
1100 cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
1102 rk_send_wakeup_key();
1104 /* this assume if usb insert or extract dc_det pin is change */
1106 if(cw_bat->charger_init_mode)
1107 cw_bat->charger_init_mode=0;
1110 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1111 type = gpio_get_value(cw_bat->plat_data.dc_det_pin) ? IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
1112 ret = irq_set_irq_type(irq, type);
1114 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq, type);
1119 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
1121 struct cw_battery *cw_bat = dev_id;
1122 disable_irq_nosync(irq); // for irq debounce
1123 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work, msecs_to_jiffies(20));
1127 #ifdef BAT_LOW_INTERRUPT
1129 #define WAKE_LOCK_TIMEOUT (10 * HZ)
1131 static void bat_low_detect_do_wakeup(struct work_struct *work)
1133 struct delayed_work *delay_work;
1134 struct cw_battery *cw_bat;
1136 delay_work = container_of(work, struct delayed_work, work);
1137 cw_bat = container_of(delay_work, struct cw_battery, bat_low_wakeup_work);
1138 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
1143 static irqreturn_t bat_low_detect_irq_handler(int irq, void *dev_id)
1145 struct cw_battery *cw_bat = dev_id;
1146 // disable_irq_nosync(irq); // for irq debounce
1147 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->bat_low_wakeup_work, msecs_to_jiffies(20));
1153 static int cw2015_parse_dt(struct device *dev,
1154 struct cw_bat_platform_data *data)
1156 struct device_node *node = dev->of_node;
1157 enum of_gpio_flags flags;
1158 struct property *prop;
1166 memset(data, 0, sizeof(*data));
1168 /* determine the number of config info */
1169 prop = of_find_property(node, "bat_config_info", &length);
1173 length /= sizeof(u32);
1176 size_t size = sizeof(*data->cw_bat_config_info) * length;
1177 data->cw_bat_config_info = devm_kzalloc(dev, size, GFP_KERNEL);
1178 if (!data->cw_bat_config_info)
1181 ret = of_property_read_u32_array(node, "bat_config_info",
1182 data->cw_bat_config_info,
1188 data->dc_det_pin = of_get_named_gpio_flags(node, "dc_det_gpio", 0,
1190 if (data->dc_det_pin == -EPROBE_DEFER)
1191 printk("%s dc_det_gpio error\n",__func__);
1193 if (gpio_is_valid(data->dc_det_pin))
1194 data->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW)? CW2015_GPIO_LOW:CW2015_GPIO_HIGH;
1197 data->bat_low_pin = of_get_named_gpio_flags(node, "bat_low_gpio", 0,
1199 if (data->bat_low_pin == -EPROBE_DEFER)
1200 printk("%s bat_low_gpio error\n",__func__);
1202 if (gpio_is_valid(data->bat_low_pin))
1203 data->bat_low_level = (flags & OF_GPIO_ACTIVE_LOW)? CW2015_GPIO_LOW:CW2015_GPIO_HIGH;
1206 data->chg_ok_pin = of_get_named_gpio_flags(node, "chg_ok_gpio", 0,
1208 if (data->chg_ok_pin == -EPROBE_DEFER)
1209 printk("%s chg_ok_gpio error\n",__func__);
1211 if (gpio_is_valid(data->chg_ok_pin))
1212 data->chg_ok_level = (flags & OF_GPIO_ACTIVE_LOW)? CW2015_GPIO_LOW:CW2015_GPIO_HIGH;
1214 data->chg_mode_sel_pin = of_get_named_gpio_flags(node, "chg_mode_sel_gpio", 0,
1216 if (data->chg_mode_sel_pin == -EPROBE_DEFER)
1217 printk("%s chg_mod_sel_gpio error\n",__func__);
1219 if (gpio_is_valid(data->chg_mode_sel_pin))
1220 data->chg_mode_sel_level = (flags & OF_GPIO_ACTIVE_LOW)? CW2015_GPIO_LOW:CW2015_GPIO_HIGH;
1223 ret = of_property_read_u32(node, "is_dc_charge",
1227 printk("%s:hardware unsupport dc charge\n",__func__);
1230 data->is_dc_charge = value;
1232 ret = of_property_read_u32(node, "is_usb_charge",
1236 printk("%s:hardware unsupport usb charge\n",__func__);
1239 data->is_usb_charge = value;
1241 printk("cw201x:support %s %s charger\n",
1242 data->is_dc_charge ? "DC" : "", data->is_usb_charge ? "USB" : "");
1247 static int cw2015_parse_dt(struct device *dev,
1248 struct cw_bat_platform_data *data)
1254 static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
1256 struct cw_battery *cw_bat;
1257 struct cw_bat_platform_data *plat_data = client->dev.platform_data;
1263 cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
1265 dev_err(&cw_bat->client->dev, "fail to allocate memory for cw2015\n");
1268 i2c_set_clientdata(client, cw_bat);
1271 ret = cw2015_parse_dt(&client->dev, &(cw_bat->plat_data));
1273 dev_err(&client->dev, "failed to find cw2015 platform data\n");
1278 cw_bat->client = client;
1279 ret = cw_bat_gpio_init(cw_bat);
1281 dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
1285 ret = cw_init(cw_bat);
1287 while ((loop++ < 200) && (ret != 0)) {
1288 ret = cw_init(cw_bat);
1293 printk("%s cw_init error\n",__func__);
1297 cw_bat->rk_bat.name = "rk-bat";
1298 cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1299 cw_bat->rk_bat.properties = rk_battery_properties;
1300 cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
1301 cw_bat->rk_bat.get_property = rk_battery_get_property;
1302 ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
1304 dev_err(&cw_bat->client->dev, "power supply register rk_bat error\n");
1305 goto rk_bat_register_fail;
1308 cw_bat->rk_ac.name = "rk-ac";
1309 cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
1310 cw_bat->rk_ac.properties = rk_ac_properties;
1311 cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
1312 cw_bat->rk_ac.get_property = rk_ac_get_property;
1313 ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1315 dev_err(&cw_bat->client->dev, "power supply register rk_ac error\n");
1316 goto rk_ac_register_fail;
1319 if (cw_bat->plat_data.is_usb_charge == 1) {
1320 cw_bat->rk_usb.name = "rk-usb";
1321 cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1322 cw_bat->rk_usb.properties = rk_usb_properties;
1323 cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1324 cw_bat->rk_usb.get_property = rk_usb_get_property;
1325 ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1327 dev_err(&cw_bat->client->dev, "power supply register rk_usb error\n");
1328 goto rk_usb_register_fail;
1330 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1331 printk("%s cw2015 support charger by usb. usb_mode=%d\n",__func__,cw_bat->charger_init_mode);
1334 cw_bat->dc_online = 0;
1335 cw_bat->usb_online = 0;
1336 cw_bat->charger_mode = 0;
1337 cw_bat->capacity = 2;
1338 cw_bat->voltage = 0;
1340 cw_bat->time_to_empty = 0;
1341 cw_bat->bat_change = 0;
1343 cw_update_time_member_capacity_change(cw_bat);
1344 cw_update_time_member_charge_start(cw_bat);
1346 cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1347 INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1348 INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1349 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1351 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
1352 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1353 level = gpio_get_value(cw_bat->plat_data.dc_det_pin);
1354 if (level == cw_bat->plat_data.dc_det_level)
1356 printk("%s booting up with dc plug\n",__func__);
1357 cw_bat->status = POWER_SUPPLY_STATUS_CHARGING;
1359 irq_flags = level ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1360 ret = request_irq(irq, dc_detect_irq_handler, irq_flags, "dc_detect", cw_bat);
1362 pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1364 enable_irq_wake(irq);
1368 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
1369 INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work, bat_low_detect_do_wakeup);
1370 level = gpio_get_value(cw_bat->plat_data.bat_low_pin);
1371 if (level == cw_bat->plat_data.dc_det_level)
1373 printk("%s booting up with lower power\n",__func__);
1374 cw_bat->capacity = 1;
1376 irq = gpio_to_irq(cw_bat->plat_data.bat_low_pin);
1377 ret = request_irq(irq, bat_low_detect_irq_handler, IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
1379 gpio_free(cw_bat->plat_data.bat_low_pin);
1381 enable_irq_wake(irq);
1384 dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe sucess\n");
1387 rk_usb_register_fail:
1388 power_supply_unregister(&cw_bat->rk_usb);
1389 rk_ac_register_fail:
1390 power_supply_unregister(&cw_bat->rk_ac);
1391 rk_bat_register_fail:
1392 power_supply_unregister(&cw_bat->rk_bat);
1394 dev_info(&cw_bat->client->dev, "cw2015/cw2013 driver v1.2 probe error!!!!\n");
1398 static int cw_bat_remove(struct i2c_client *client)
1400 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1401 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1402 cancel_delayed_work(&cw_bat->battery_delay_work);
1407 static int cw_bat_suspend(struct device *dev)
1409 struct i2c_client *client = to_i2c_client(dev);
1410 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1411 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1412 cancel_delayed_work(&cw_bat->battery_delay_work);
1416 static int cw_bat_resume(struct device *dev)
1418 struct i2c_client *client = to_i2c_client(dev);
1419 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1420 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1421 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1425 static const struct i2c_device_id cw_id[] = {
1429 MODULE_DEVICE_TABLE(i2c, cw_id);
1431 static const struct dev_pm_ops cw_bat_pm_ops = {
1432 .suspend = cw_bat_suspend,
1433 .resume = cw_bat_resume,
1437 static struct i2c_driver cw_bat_driver = {
1441 .pm = &cw_bat_pm_ops,
1445 .probe = cw_bat_probe,
1446 .remove = cw_bat_remove,
1450 static int __init cw_bat_init(void)
1452 return i2c_add_driver(&cw_bat_driver);
1455 static void __exit cw_bat_exit(void)
1457 i2c_del_driver(&cw_bat_driver);
1460 fs_initcall(cw_bat_init);
1461 module_exit(cw_bat_exit);
1464 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1465 MODULE_DESCRIPTION("cw2015/cw2013 battery driver");
1466 MODULE_LICENSE("GPL");