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.
13 #include <linux/platform_device.h>
14 #include <linux/power_supply.h>
15 #include <linux/workqueue.h>
16 #include <linux/kernel.h>
17 #include <linux/i2c.h>
18 #include <mach/gpio.h>
19 #include <linux/delay.h>
20 #include <linux/power/cw2015_battery.h>
21 #include <linux/time.h>
22 #include <linux/interrupt.h>
23 #include <linux/irq.h>
24 #include <mach/board.h>
26 #define REG_VERSION 0x0
29 #define REG_RRT_ALERT 0x6
30 #define REG_CONFIG 0x8
32 #define REG_BATINFO 0x10
34 #define MODE_SLEEP_MASK (0x3<<6)
35 #define MODE_SLEEP (0x3<<6)
36 #define MODE_NORMAL (0x0<<6)
37 #define MODE_QUICK_START (0x3<<4)
38 #define MODE_RESTART (0xf<<0)
40 #define CONFIG_UPDATE_FLG (0x1<<1)
41 #define ATHD (0x0<<3) //ATHD =10%
43 #define CW_I2C_SPEED 100000 // default i2c speed set 100khz
45 #define BATTERY_UP_MAX_CHANGE 420 // the max time allow battery change quantity
46 #define BATTERY_DOWN_CHANGE 60 // the max time allow battery change quantity
47 #define BATTERY_DOWN_MIN_CHANGE_RUN 30 // the min time allow battery change quantity when run
48 #define BATTERY_DOWN_MIN_CHANGE_SLEEP 1800 // the min time allow battery change quantity when run 30min
50 #define BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE 3600
52 #define Enable_BATDRV_LOG 0
54 #define USB_CHARGER_MODE 1
55 #define AC_CHARGER_MODE 2
59 #define xprintk(format, arg...) printk("func: %s\n" format, __FUNCTION__, ##arg)
61 #define xprintk(format, ...)
64 extern int dwc_otg_check_dpdm(void);
65 extern int get_gadget_connect_flag(void);
66 extern int dwc_vbus_status( void );
69 struct i2c_client *client;
70 struct workqueue_struct *battery_workqueue;
71 struct delayed_work battery_delay_work;
72 struct delayed_work dc_wakeup_work;
73 const struct cw_bat_platform_data *plat_data;
75 struct power_supply rk_bat;
76 struct power_supply rk_ac;
77 struct power_supply rk_usb;
79 long sleep_time_capacity; // the sleep time from capacity change to present, it will set 0 when capacity change
80 long run_time_capacity;
82 long sleep_time_ac_online; // the sleep time from insert ac to present, it will set 0 when insert ac
83 long run_time_ac_online;
88 int charger_init_mode;
98 static int cw_read(struct i2c_client *client, u8 reg, u8 buf[])
101 ret = i2c_master_reg8_recv(client, reg, buf, 1, CW_I2C_SPEED);
105 static int cw_write(struct i2c_client *client, u8 reg, u8 const buf[])
108 ret = i2c_master_reg8_send(client, reg, buf, 1, CW_I2C_SPEED);
111 static int cw_read_word(struct i2c_client *client, u8 reg, u8 buf[])
114 ret = i2c_master_reg8_recv(client, reg, buf, 2, CW_I2C_SPEED);
119 static int cw_write_word(struct i2c_client *client, u8 reg, u8 const buf[])
122 ret = i2c_master_reg8_send(client, reg, buf, 2, CW_I2C_SPEED);
129 static int cw_update_config_info(struct cw_battery *cw_bat)
136 printk("func: %s-------\n", __func__);
137 /* make sure no in sleep mode */
138 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
143 if((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
144 printk("Error, device in sleep mode, cannot update battery info\n");
148 /* update new battery info */
150 for (i = 0; i < SIZE_BATINFO; i++) {
151 printk("cw_bat->plat_data->cw_bat_config_info[%d] = 0x%x\n", i, \
152 cw_bat->plat_data->cw_bat_config_info[i]);
153 ret = cw_write(cw_bat->client, REG_BATINFO + i, &cw_bat->plat_data->cw_bat_config_info[i]);
159 /* readback & check */
160 for (i = 0; i < SIZE_BATINFO; i++) {
161 ret = cw_read(cw_bat->client, REG_BATINFO + i, ®_val);
162 if (reg_val != cw_bat->plat_data->cw_bat_config_info[i])
167 /* set cw2015 to use new battery info */
168 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
172 reg_val |= CONFIG_UPDATE_FLG;/* set UPDATE_FLAG */
173 reg_val &= 0x07; // clear ATHD
174 reg_val |= ATHD; // set ATHD
175 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
179 /* check 2015 for ATHD & update_flag */
180 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
184 if (!(reg_val & CONFIG_UPDATE_FLG)) {
185 printk("update flag for new battery info have not set..\n");
188 if ((reg_val & 0xf8) != ATHD) {
189 printk("the new ATHD have not set..\n");
193 reset_val &= ~(MODE_RESTART);
194 reg_val = reset_val | MODE_RESTART;
195 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
200 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
207 static int cw_init(struct cw_battery *cw_bat)
211 u8 reg_val = MODE_SLEEP;
213 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
217 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
218 reg_val = MODE_NORMAL;
219 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
224 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
228 if ((reg_val & 0xf8) != ATHD) {
229 printk("the new ATHD have not set\n");
230 reg_val &= 0x07; // clear ATHD
231 reg_val |= ATHD; // set ATHD
232 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
237 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
241 if (!(reg_val & CONFIG_UPDATE_FLG)) {
242 printk("update flag for new battery info have not set\n");
243 ret = cw_update_config_info(cw_bat);
247 for(i = 0; i < SIZE_BATINFO; i++) {
248 ret = cw_read(cw_bat->client, (REG_BATINFO + i), ®_val);
252 if (cw_bat->plat_data->cw_bat_config_info[i] != reg_val)
256 if (i != SIZE_BATINFO) {
257 printk("update flag for new battery info have not set\n");
258 ret = cw_update_config_info(cw_bat);
264 for (i = 0; i < 30; i++) {
265 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
268 else if (ret != 0xff)
273 printk("cw2015 input unvalid power error\n");
280 static void cw_update_time_member_ac_online(struct cw_battery *cw_bat)
287 new_run_time = ts.tv_sec;
289 get_monotonic_boottime(&ts);
290 new_sleep_time = ts.tv_sec - new_run_time;
292 cw_bat->run_time_ac_online = new_run_time;
293 cw_bat->sleep_time_ac_online = new_sleep_time;
296 static void cw_update_time_member_capacity(struct cw_battery *cw_bat)
303 new_run_time = ts.tv_sec;
305 get_monotonic_boottime(&ts);
306 new_sleep_time = ts.tv_sec - new_run_time;
308 cw_bat->run_time_capacity = new_run_time;
309 cw_bat->sleep_time_capacity = new_sleep_time;
312 static int cw_quickstart(struct cw_battery *cw_bat)
315 u8 reg_val = MODE_QUICK_START;
317 ret = cw_write(cw_bat->client, REG_MODE, ®_val); //(MODE_QUICK_START | MODE_NORMAL)); // 0x30
319 printk("Error quick start1\n");
323 reg_val = MODE_NORMAL;
324 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
326 printk("Error quick start2\n");
332 static int cw_get_capacity(struct cw_battery *cw_bat)
341 long capacity_or_aconline_time;
344 static int if_quickstart = 0;
345 static int jump_flag =0;
348 // ret = cw_read(cw_bat->client, REG_SOC, ®_val);
349 ret = cw_read_word(cw_bat->client, REG_SOC, reg_val);
353 cw_capacity = reg_val[0];
354 if ((cw_capacity < 0) || (cw_capacity > 100)) {
355 printk("get cw_capacity error; cw_capacity = %d\n", cw_capacity);
359 if (cw_capacity == 0)
360 xprintk("the cw201x capacity is 0 !!!!!!!, funciton: %s, line: %d\n", __func__, __LINE__);
362 xprintk("the cw201x capacity is %d, funciton: %s\n", cw_capacity, __func__);
364 // ret = cw_read(cw_bat->client, REG_SOC + 1, ®_val);
367 new_run_time = ts.tv_sec;
369 get_monotonic_boottime(&ts);
370 new_sleep_time = ts.tv_sec - new_run_time;
372 if ((cw_bat->charger_mode > 0) && (cw_capacity >= 95) && (cw_capacity <= cw_bat->capacity)) { // avoid no charge full
374 capacity_or_aconline_time = (cw_bat->sleep_time_capacity > cw_bat->sleep_time_ac_online) ? cw_bat->sleep_time_capacity : cw_bat->sleep_time_ac_online;
375 capacity_or_aconline_time += (cw_bat->run_time_capacity > cw_bat->run_time_ac_online) ? cw_bat->run_time_capacity : cw_bat->run_time_ac_online;
376 allow_change = (new_sleep_time + new_run_time - capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
377 if (allow_change > 0) {
378 allow_capacity = cw_bat->capacity + allow_change;
379 cw_capacity = (allow_capacity <= 100) ? allow_capacity : 100;
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) / BATTERY_DOWN_MIN_CHANGE_RUN);
393 allow_change += ((new_sleep_time - cw_bat->sleep_time_capacity) / 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 > cw_bat->sleep_time_ac_online) ? cw_bat->sleep_time_capacity : cw_bat->sleep_time_ac_online;
404 capacity_or_aconline_time += (cw_bat->run_time_capacity > cw_bat->run_time_ac_online) ? cw_bat->run_time_capacity : cw_bat->run_time_ac_online;
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;
418 if((cw_bat->charger_mode > 0) &&(cw_capacity == 0))
420 if (((new_sleep_time + new_run_time - cw_bat->sleep_time_ac_online - cw_bat->run_time_ac_online) > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE) && (if_quickstart == 0)) {
421 cw_quickstart(cw_bat); // if the cw_capacity = 0 the cw2015 will qstrt
424 } else if ((if_quickstart == 1)&&(cw_bat->charger_mode == 0)) {
430 if (cw_bat->plat_data->chg_ok_pin != INVALID_GPIO) {
431 if((cw_capacity == 100) && (gpio_get_value(cw_bat->plat_data->chg_ok_pin) != cw_bat->plat_data->chg_ok_level))
438 static int cw_get_vol(struct cw_battery *cw_bat)
442 u16 value16, value16_1, value16_2, value16_3;
445 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
448 value16 = (reg_val[0] << 8) + reg_val[1];
450 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
453 value16_1 = (reg_val[0] << 8) + reg_val[1];
455 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
458 value16_2 = (reg_val[0] << 8) + reg_val[1];
461 if(value16 > value16_1)
465 value16_1 = value16_3;
468 if(value16_1 > value16_2)
470 value16_3 =value16_1;
471 value16_1 =value16_2;
472 value16_2 =value16_3;
475 if(value16 >value16_1)
479 value16_1 =value16_3;
482 voltage = value16_1 * 312 / 1024;
488 static int cw_get_alt(struct cw_battery *cw_bat)
495 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
501 //dev_info(&client->dev, "read RRT %d%%. value16 0x%x\n", alrt, value16);
502 value8 = value8&0x7f;
504 ret = cw_write(cw_bat->client, REG_RRT_ALERT, ®_val);
506 printk("Error clear ALRT\n");
515 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
521 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
527 ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, ®_val);
531 value16 = ((value16 << 8) + reg_val) & 0x1fff;
535 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
539 cw_capacity = cw_get_capacity(cw_bat);
540 if ((cw_capacity >= 0) && (cw_capacity <= 100) && (cw_bat->capacity != cw_capacity)) {
541 cw_bat->capacity = cw_capacity;
542 cw_bat->bat_change = 1;
543 cw_update_time_member_capacity(cw_bat);
545 if (cw_bat->capacity == 0)
546 printk("report battery capacity 0 and will shutdown if no changing");
553 static void rk_bat_update_vol(struct cw_battery *cw_bat)
556 ret = cw_get_vol(cw_bat);
557 if ((ret >= 0) && (cw_bat->voltage != ret)) {
558 cw_bat->voltage = ret;
559 cw_bat->bat_change = 1;
563 static void rk_bat_update_status(struct cw_battery *cw_bat)
568 if ((cw_bat->dc_online == 1) || (cw_bat->usb_online == 1)) {
569 if (cw_bat->capacity >= 100)
570 status=POWER_SUPPLY_STATUS_FULL;
572 status=POWER_SUPPLY_STATUS_CHARGING;
574 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
577 if (cw_bat->status != status) {
578 cw_bat->status = status;
579 cw_bat->bat_change = 1;
584 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
587 ret = cw_get_time_to_empty(cw_bat);
588 if ((ret >= 0) && (cw_bat->time_to_empty != ret)) {
589 cw_bat->time_to_empty = ret;
590 cw_bat->bat_change = 1;
595 static int rk_ac_update_online(struct cw_battery *cw_bat)
597 if(cw_bat->plat_data->dc_det_pin == INVALID_GPIO)
599 if (gpio_get_value(cw_bat->plat_data->dc_det_pin) == cw_bat->plat_data->dc_det_level) {
600 if (cw_bat->dc_online != 1) {
601 cw_update_time_member_ac_online(cw_bat);
602 cw_bat->dc_online = 1;
603 if (cw_bat->charger_mode != AC_CHARGER_MODE)
604 cw_bat->charger_mode = AC_CHARGER_MODE;
609 if (cw_bat->dc_online != 0) {
610 cw_update_time_member_ac_online(cw_bat);
611 cw_bat->dc_online = 0;
612 if ((cw_bat->usb_online == 0)&&(cw_bat->charger_mode != 0))
613 cw_bat->charger_mode = 0;
622 static int rk_usb_update_online(struct cw_battery *cw_bat)
624 int usb_status = dwc_vbus_status();
625 int gadget_status =get_gadget_connect_flag();
627 xprintk("%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);
630 if (cw_bat->plat_data->is_usb_charge == 0) {
631 cw_bat->usb_online = 0;
636 if (((usb_status == 2) || (cw_bat->charger_init_mode==2)) && (cw_bat->charger_mode != AC_CHARGER_MODE)){
638 if (cw_bat->charger_mode != AC_CHARGER_MODE)
639 cw_bat->charger_mode = AC_CHARGER_MODE;
640 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO)
641 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);
642 if (cw_bat->usb_online != 1){
643 cw_bat->usb_online = 1;
644 cw_update_time_member_ac_online(cw_bat);
647 } else if ((usb_status == 1) || ((cw_bat->charger_init_mode==1))) {
649 if (0 == gadget_status){
650 if (cw_bat->charger_mode != AC_CHARGER_MODE)
651 cw_bat->charger_mode = AC_CHARGER_MODE;
652 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO)
653 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);
654 if (cw_bat->usb_online != 1){
655 cw_bat->usb_online = 1;
656 cw_update_time_member_ac_online(cw_bat);
662 if (cw_bat->charger_mode != USB_CHARGER_MODE)
663 cw_bat->charger_mode = USB_CHARGER_MODE;
664 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO)
665 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);
666 if (cw_bat->usb_online != 1){
667 cw_bat->usb_online = 1;
668 cw_update_time_member_ac_online(cw_bat);
672 } else {//if (usb_status == 0){
673 if (cw_bat->plat_data->chg_mode_sel_pin != INVALID_GPIO)
674 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);
675 if ((cw_bat->dc_online == 0)&&(cw_bat->charger_mode != 0))
676 cw_bat->charger_mode = 0;
677 if (cw_bat->usb_online != 0) {
678 cw_update_time_member_ac_online(cw_bat);
679 cw_bat->usb_online = 0;
688 static void cw_bat_work(struct work_struct *work)
690 struct delayed_work *delay_work;
691 struct cw_battery *cw_bat;
697 delay_work = container_of(work, struct delayed_work, work);
698 cw_bat = container_of(delay_work, struct cw_battery, battery_delay_work);
700 get_monotonic_boottime(&ts);
701 time_from_boot = ts.tv_sec;
702 if ((time_from_boot > 30) && cw_bat->charger_init_mode) {
703 cw_bat->charger_init_mode = 0;
706 ret = rk_ac_update_online(cw_bat);
708 power_supply_changed(&cw_bat->rk_ac);
711 if (cw_bat->plat_data->is_usb_charge == 1) {
712 ret = rk_usb_update_online(cw_bat);
714 power_supply_changed(&cw_bat->rk_usb);
715 power_supply_changed(&cw_bat->rk_ac); /////////////////////////////////////////////////////
720 rk_bat_update_status(cw_bat);
721 rk_bat_update_capacity(cw_bat);
722 rk_bat_update_vol(cw_bat);
723 rk_bat_update_time_to_empty(cw_bat);
725 if (cw_bat->bat_change) {
726 power_supply_changed(&cw_bat->rk_bat);
727 cw_bat->bat_change = 0;
730 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
732 xprintk("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",\
733 cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity, cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
736 static int rk_usb_get_property (struct power_supply *psy,
737 enum power_supply_property psp,
738 union power_supply_propval *val)
741 struct cw_battery *cw_bat;
743 cw_bat = container_of(psy, struct cw_battery, rk_usb);
745 case POWER_SUPPLY_PROP_ONLINE:
746 // val->intval = cw_bat->usb_online;
747 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
755 static enum power_supply_property rk_usb_properties[] = {
756 POWER_SUPPLY_PROP_ONLINE,
760 static int rk_ac_get_property (struct power_supply *psy,
761 enum power_supply_property psp,
762 union power_supply_propval *val)
765 struct cw_battery *cw_bat;
767 cw_bat = container_of(psy, struct cw_battery, rk_ac);
769 case POWER_SUPPLY_PROP_ONLINE:
770 // val->intval = cw_bat->dc_online;
771 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
779 static enum power_supply_property rk_ac_properties[] = {
780 POWER_SUPPLY_PROP_ONLINE,
783 static int rk_battery_get_property(struct power_supply *psy,
784 enum power_supply_property psp,
785 union power_supply_propval *val)
788 struct cw_battery *cw_bat;
790 cw_bat = container_of(psy, struct cw_battery, rk_bat);
792 case POWER_SUPPLY_PROP_CAPACITY:
793 val->intval = cw_bat->capacity;
795 case POWER_SUPPLY_PROP_STATUS:
796 val->intval = cw_bat->status;
799 case POWER_SUPPLY_PROP_HEALTH:
800 val->intval= POWER_SUPPLY_HEALTH_GOOD;
802 case POWER_SUPPLY_PROP_PRESENT:
803 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
806 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
807 val->intval = cw_bat->voltage;
810 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
811 val->intval = cw_bat->time_to_empty;
814 case POWER_SUPPLY_PROP_TECHNOLOGY:
815 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
824 static enum power_supply_property rk_battery_properties[] = {
825 POWER_SUPPLY_PROP_CAPACITY,
826 POWER_SUPPLY_PROP_STATUS,
827 POWER_SUPPLY_PROP_HEALTH,
828 POWER_SUPPLY_PROP_PRESENT,
829 POWER_SUPPLY_PROP_VOLTAGE_NOW,
830 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
831 POWER_SUPPLY_PROP_TECHNOLOGY,
834 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
838 gpio_free(cw_bat->plat_data->dc_det_pin);
839 if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO) {
840 ret = gpio_request(cw_bat->plat_data->dc_det_pin, NULL);
842 printk("failed to request dc_det_pin gpio\n");
843 goto request_dc_det_pin_fail;
846 gpio_pull_updown(cw_bat->plat_data->dc_det_pin, GPIOPullUp);
847 ret = gpio_direction_input(cw_bat->plat_data->dc_det_pin);
849 printk("failed to set dc_det_pin input\n");
850 goto request_bat_low_pin_fail;
853 if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO) {
854 ret = gpio_request(cw_bat->plat_data->bat_low_pin, NULL);
856 printk("failed to request bat_low_pin gpio\n");
857 goto request_bat_low_pin_fail;
860 gpio_pull_updown(cw_bat->plat_data->bat_low_pin, GPIOPullUp);
861 ret = gpio_direction_input(cw_bat->plat_data->bat_low_pin);
863 printk("failed to set bat_low_pin input\n");
864 goto request_chg_ok_pin_fail;
867 if (cw_bat->plat_data->chg_ok_pin != INVALID_GPIO) {
868 ret = gpio_request(cw_bat->plat_data->chg_ok_pin, NULL);
870 printk("failed to request chg_ok_pin gpio\n");
871 goto request_chg_ok_pin_fail;
874 gpio_pull_updown(cw_bat->plat_data->chg_ok_pin, GPIOPullUp);
875 ret = gpio_direction_input(cw_bat->plat_data->chg_ok_pin);
877 printk("failed to set chg_ok_pin input\n");
878 gpio_free(cw_bat->plat_data->chg_ok_pin);
879 goto request_chg_ok_pin_fail;
883 if ((cw_bat->plat_data->is_usb_charge == 1) && (cw_bat->plat_data->chg_mode_sel_pin!= INVALID_GPIO)) {
884 ret = gpio_request(cw_bat->plat_data->chg_mode_sel_pin, NULL);
886 printk("failed to request chg_mode_sel_pin gpio\n");
887 goto request_chg_ok_pin_fail;
889 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);
891 printk("failed to set chg_mode_sel_pin input\n");
892 gpio_free(cw_bat->plat_data->chg_mode_sel_pin);
893 goto request_chg_ok_pin_fail;
900 request_chg_ok_pin_fail:
901 if (cw_bat->plat_data->bat_low_pin != INVALID_GPIO)
902 gpio_free(cw_bat->plat_data->bat_low_pin);
904 request_bat_low_pin_fail:
905 if (cw_bat->plat_data->dc_det_pin != INVALID_GPIO)
906 gpio_free(cw_bat->plat_data->dc_det_pin);
908 request_dc_det_pin_fail:
914 static void dc_detect_do_wakeup(struct work_struct *work)
920 struct delayed_work *delay_work;
921 struct cw_battery *cw_bat;
923 delay_work = container_of(work, struct delayed_work, work);
924 cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
926 rk28_send_wakeup_key();
928 /* this assume if usb insert or extract dc_det pin is change */
929 if(cw_bat->charger_init_mode)
930 cw_bat->charger_init_mode=0;
932 irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
933 type = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQ_TYPE_EDGE_FALLING : IRQ_TYPE_EDGE_RISING;
934 ret = irq_set_irq_type(irq, type);
936 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq, type);
941 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
943 struct cw_battery *cw_bat = dev_id;
944 disable_irq_nosync(irq); // for irq debounce
945 //wake_lock_timeout(&usb_wakelock, WAKE_LOCK_TIMEOUT);
946 //schedule_delayed_work(&wakeup_work, HZ / 10);
947 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work, msecs_to_jiffies(20));
952 static int cw_bat_probe(struct i2c_client *client, const struct i2c_device_id *id)
954 struct cw_battery *cw_bat;
960 cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
962 printk("fail to allocate memory\n");
966 i2c_set_clientdata(client, cw_bat);
967 cw_bat->plat_data = client->dev.platform_data;
968 ret = cw_bat_gpio_init(cw_bat);
970 printk("cw_bat_gpio_init error\n");
974 cw_bat->client = client;
976 ret = cw_init(cw_bat);
977 while ((loop++ < 200) && (ret != 0)) {
978 ret = cw_init(cw_bat);
984 cw_bat->rk_bat.name = "rk-bat";
985 cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
986 cw_bat->rk_bat.properties = rk_battery_properties;
987 cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
988 cw_bat->rk_bat.get_property = rk_battery_get_property;
989 ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
991 printk("power supply register rk_bat error\n");
992 goto rk_bat_register_fail;
995 cw_bat->rk_ac.name = "rk-ac";
996 cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
997 cw_bat->rk_ac.properties = rk_ac_properties;
998 cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
999 cw_bat->rk_ac.get_property = rk_ac_get_property;
1000 ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1002 printk("power supply register rk_ac error\n");
1003 goto rk_ac_register_fail;
1006 cw_bat->rk_usb.name = "rk-usb";
1007 cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1008 cw_bat->rk_usb.properties = rk_usb_properties;
1009 cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1010 cw_bat->rk_usb.get_property = rk_usb_get_property;
1011 ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1013 printk("power supply register rk_ac error\n");
1014 goto rk_usb_register_fail;
1017 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1019 cw_bat->dc_online = 0;
1020 cw_bat->usb_online = 0;
1021 cw_bat->charger_mode = 0;
1022 cw_bat->capacity = 2;
1023 cw_bat->voltage = 0;
1025 cw_bat->time_to_empty = 0;
1026 cw_bat->bat_change = 0;
1028 cw_update_time_member_capacity(cw_bat);
1029 cw_update_time_member_ac_online(cw_bat);
1031 cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1032 INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1033 INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1034 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1036 irq = gpio_to_irq(cw_bat->plat_data->dc_det_pin);
1037 irq_flags = gpio_get_value(cw_bat->plat_data->dc_det_pin) ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1038 ret = request_irq(irq, dc_detect_irq_handler, irq_flags, "usb_detect", cw_bat);
1040 pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1042 enable_irq_wake(irq);
1044 printk("cw2015 driver v1.0 probe sucess\n");
1047 rk_usb_register_fail:
1048 power_supply_unregister(&cw_bat->rk_bat);
1049 rk_ac_register_fail:
1050 power_supply_unregister(&cw_bat->rk_ac);
1051 rk_bat_register_fail:
1052 printk("cw2015 driver v1.0 probe error!!!!\n");
1056 static int cw_bat_remove(struct i2c_client *client)
1058 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1060 cancel_delayed_work(&cw_bat->battery_delay_work);
1065 static int cw_bat_suspend(struct device *dev)
1067 struct i2c_client *client = to_i2c_client(dev);
1068 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1070 cancel_delayed_work(&cw_bat->battery_delay_work);
1074 static int cw_bat_resume(struct device *dev)
1076 struct i2c_client *client = to_i2c_client(dev);
1077 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1079 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1083 static const struct i2c_device_id cw_id[] = {
1086 MODULE_DEVICE_TABLE(i2c, cw_id);
1088 static const struct dev_pm_ops cw_bat_pm_ops = {
1089 .suspend = cw_bat_suspend,
1090 .resume = cw_bat_resume,
1094 static struct i2c_driver cw_bat_driver = {
1098 .pm = &cw_bat_pm_ops,
1102 .probe = cw_bat_probe,
1103 .remove = cw_bat_remove,
1107 static int __init cw_bat_init(void)
1110 return i2c_add_driver(&cw_bat_driver);
1113 static void __exit cw_bat_exit(void)
1116 i2c_del_driver(&cw_bat_driver);
1119 fs_initcall(cw_bat_init);
1120 module_exit(cw_bat_exit);
1122 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1123 MODULE_DESCRIPTION("cw2015 battery driver");
1124 MODULE_LICENSE("GPL");