2 * Fuel gauge driver for CellWise 2013 / 2015
4 * Copyright (C) 2012, RockChip
6 * Authors: xuhuicong <xhc@rock-chips.com>
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License version 2 as
10 * published by the Free Software Foundation.
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/time.h>
24 #include <linux/interrupt.h>
25 #include <linux/irq.h>
26 #include <linux/rk_keys.h>
27 #include <linux/slab.h>
29 #include <linux/power/cw2015_battery.h>
31 static int i2c_master_reg8_send(const struct i2c_client *client, const char reg,
32 const char *buf, int count, int scl_rate)
37 struct i2c_adapter *adap = client->adapter;
39 tx_buf = kzalloc(count + 1, GFP_KERNEL);
44 memcpy(tx_buf + 1, buf, count);
46 msg.addr = client->addr;
47 msg.flags = client->flags;
49 msg.buf = (char *)tx_buf;
50 msg.scl_rate = scl_rate;
52 ret = i2c_transfer(adap, &msg, 1);
55 return (ret == 1) ? count : ret;
58 static int i2c_master_reg8_recv(const struct i2c_client *client, const char reg,
59 char *buf, int count, int scl_rate)
61 struct i2c_adapter *adap = client->adapter;
62 struct i2c_msg msgs[2];
66 msgs[0].addr = client->addr;
67 msgs[0].flags = client->flags;
69 msgs[0].buf = ®_buf;
70 msgs[0].scl_rate = scl_rate;
72 msgs[1].addr = client->addr;
73 msgs[1].flags = client->flags | I2C_M_RD;
75 msgs[1].buf = (char *)buf;
76 msgs[1].scl_rate = scl_rate;
78 ret = i2c_transfer(adap, msgs, 2);
80 return (ret == 2) ? count : ret;
83 static int cw_read(struct i2c_client *client, u8 reg, u8 buf[])
87 ret = i2c_master_reg8_recv(client, reg, buf, 1, CW_I2C_SPEED);
92 static int cw_write(struct i2c_client *client, u8 reg, u8 const buf[])
96 ret = i2c_master_reg8_send(client, reg, buf, 1, CW_I2C_SPEED);
101 static int cw_read_word(struct i2c_client *client, u8 reg, u8 buf[])
105 ret = i2c_master_reg8_recv(client, reg, buf, 2, CW_I2C_SPEED);
110 static int cw_update_config_info(struct cw_battery *cw_bat)
117 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
119 /* make sure no in sleep mode */
120 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
125 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
126 dev_err(&cw_bat->client->dev,
127 "Error, device in sleep mode, cannot update battery info\n");
131 /* update new battery info */
132 for (i = 0; i < SIZE_BATINFO; i++) {
134 cw_write(cw_bat->client, REG_BATINFO + i,
135 (u8 *)&cw_bat->plat_data.cw_bat_config_info[i]);
141 /* readback & check */
142 for (i = 0; i < SIZE_BATINFO; i++) {
143 ret = cw_read(cw_bat->client, REG_BATINFO + i, ®_val);
144 if (reg_val != cw_bat->plat_data.cw_bat_config_info[i])
148 /* set cw2015/cw2013 to use new battery info */
149 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
153 reg_val |= CONFIG_UPDATE_FLG; /* set UPDATE_FLAG */
154 reg_val &= 0x07; /* clear ATHD */
155 reg_val |= ATHD; /* set ATHD */
156 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
160 /* check 2015/cw2013 for ATHD & update_flag */
161 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
165 if (!(reg_val & CONFIG_UPDATE_FLG)) {
166 dev_info(&cw_bat->client->dev,
167 "update flag for new battery info have not set..\n");
170 if ((reg_val & 0xf8) != ATHD)
171 dev_info(&cw_bat->client->dev, "the new ATHD have not set..\n");
174 reset_val &= ~(MODE_RESTART);
175 reg_val = reset_val | MODE_RESTART;
176 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
181 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
188 static int cw_init(struct cw_battery *cw_bat)
192 u8 reg_val = MODE_SLEEP;
194 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
195 reg_val = MODE_NORMAL;
196 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
201 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
205 if ((reg_val & 0xf8) != ATHD) {
206 dev_info(&cw_bat->client->dev, "the new ATHD have not set\n");
207 reg_val &= 0x07; /* clear ATHD */
208 reg_val |= ATHD; /* set ATHD */
209 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
214 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
218 if (!(reg_val & CONFIG_UPDATE_FLG)) {
219 dev_info(&cw_bat->client->dev,
220 "update flag for new battery info have not set\n");
221 ret = cw_update_config_info(cw_bat);
225 for (i = 0; i < SIZE_BATINFO; i++) {
227 cw_read(cw_bat->client, (REG_BATINFO + i),
232 if (cw_bat->plat_data.cw_bat_config_info[i] != reg_val)
236 if (i != SIZE_BATINFO) {
237 dev_info(&cw_bat->client->dev,
238 "update flag for new battery info have not set\n");
239 ret = cw_update_config_info(cw_bat);
245 for (i = 0; i < 30; i++) {
246 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
249 else if (reg_val <= 0x64)
254 dev_err(&cw_bat->client->dev,
255 "cw2015/cw2013 input unvalid power error\n");
259 reg_val = MODE_SLEEP;
260 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
261 dev_info(&cw_bat->client->dev, "report battery capacity error");
267 static void cw_update_time_member_charge_start(struct cw_battery *cw_bat)
274 new_run_time = ts.tv_sec;
276 get_monotonic_boottime(&ts);
277 new_sleep_time = ts.tv_sec - new_run_time;
279 cw_bat->run_time_charge_start = new_run_time;
280 cw_bat->sleep_time_charge_start = new_sleep_time;
283 static void cw_update_time_member_capacity_change(struct cw_battery *cw_bat)
290 new_run_time = ts.tv_sec;
292 get_monotonic_boottime(&ts);
293 new_sleep_time = ts.tv_sec - new_run_time;
295 cw_bat->run_time_capacity_change = new_run_time;
296 cw_bat->sleep_time_capacity_change = new_sleep_time;
300 static int cw_quickstart(struct cw_battery *cw_bat)
303 u8 reg_val = MODE_QUICK_START;
305 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
307 dev_err(&cw_bat->client->dev, "Error quick start1\n");
311 reg_val = MODE_NORMAL;
312 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
314 dev_err(&cw_bat->client->dev, "Error quick start2\n");
320 static int cw_get_capacity(struct cw_battery *cw_bat)
331 long capacity_or_aconline_time;
332 static int if_quickstart;
333 static int jump_flag;
334 static int reset_loop;
337 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
340 cw_capacity = reg_val;
342 if (cw_capacity < 0 || cw_capacity > 100) {
343 dev_err(&cw_bat->client->dev,
344 "get cw_capacity error; cw_capacity = %d\n",
348 if (reset_loop > 5) {
349 reset_val = MODE_SLEEP;
350 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
353 reset_val = MODE_NORMAL;
355 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
358 dev_info(&cw_bat->client->dev,
359 "report battery capacity error");
360 ret = cw_update_config_info(cw_bat);
372 new_run_time = ts.tv_sec;
374 get_monotonic_boottime(&ts);
375 new_sleep_time = ts.tv_sec - new_run_time;
377 /* modify battery level swing */
378 if ((cw_bat->charger_mode > 0 &&
379 cw_capacity <= (cw_bat->capacity - 1) &&
380 cw_capacity > (cw_bat->capacity - 9)) ||
381 (cw_bat->charger_mode == 0 &&
382 cw_capacity == (cw_bat->capacity + 1))) {
383 if (!(cw_capacity == 0 && cw_bat->capacity <= 2))
384 cw_capacity = cw_bat->capacity;
387 /* avoid no charge full */
388 if (cw_bat->charger_mode > 0 &&
390 cw_capacity <= cw_bat->capacity) {
391 capacity_or_aconline_time =
392 (cw_bat->sleep_time_capacity_change >
393 cw_bat->sleep_time_charge_start) ? cw_bat->
394 sleep_time_capacity_change : cw_bat->
395 sleep_time_charge_start;
396 capacity_or_aconline_time +=
397 (cw_bat->run_time_capacity_change >
398 cw_bat->run_time_charge_start) ? cw_bat->
399 run_time_capacity_change : cw_bat->run_time_charge_start;
401 (new_sleep_time + new_run_time -
402 capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
403 if (allow_change > 0) {
404 allow_capacity = cw_bat->capacity + allow_change;
406 (allow_capacity <= 100) ? allow_capacity : 100;
408 } else if (cw_capacity <= cw_bat->capacity) {
409 cw_capacity = cw_bat->capacity;
412 /* avoid battery level jump to CW_BAT */
413 else if (cw_bat->charger_mode == 0 &&
414 cw_capacity <= cw_bat->capacity &&
415 cw_capacity >= 90 && jump_flag == 1) {
416 capacity_or_aconline_time =
417 (cw_bat->sleep_time_capacity_change >
418 cw_bat->sleep_time_charge_start) ? cw_bat->
419 sleep_time_capacity_change : cw_bat->
420 sleep_time_charge_start;
421 capacity_or_aconline_time +=
422 (cw_bat->run_time_capacity_change >
423 cw_bat->run_time_charge_start) ? cw_bat->
424 run_time_capacity_change : cw_bat->run_time_charge_start;
426 (new_sleep_time + new_run_time -
427 capacity_or_aconline_time) / BATTERY_DOWN_CHANGE;
428 if (allow_change > 0) {
429 allow_capacity = cw_bat->capacity - allow_change;
430 if (cw_capacity >= allow_capacity) {
435 100) ? allow_capacity : 100;
437 } else if (cw_capacity <= cw_bat->capacity) {
438 cw_capacity = cw_bat->capacity;
442 /* avoid battery level jump to 0% at a moment from more than 2% */
443 if (cw_capacity == 0 && cw_bat->capacity > 1) {
446 cw_bat->run_time_capacity_change) /
447 BATTERY_DOWN_MIN_CHANGE_RUN);
450 cw_bat->sleep_time_capacity_change) /
451 BATTERY_DOWN_MIN_CHANGE_SLEEP);
453 allow_capacity = cw_bat->capacity - allow_change;
456 cw_capacity) ? allow_capacity : cw_capacity;
457 dev_info(&cw_bat->client->dev, "report GGIC POR happened");
458 reset_val = MODE_SLEEP;
459 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
462 reset_val = MODE_NORMAL;
464 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
467 dev_info(&cw_bat->client->dev, "report battery capacity error");
468 ret = cw_update_config_info(cw_bat);
471 dev_info(&cw_bat->client->dev,
472 "report battery capacity jump 0 ");
475 if (cw_bat->charger_mode > 0 && cw_capacity == 0) {
477 new_sleep_time + new_run_time -
478 cw_bat->sleep_time_charge_start -
479 cw_bat->run_time_charge_start;
480 if (charge_time > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE &&
481 if_quickstart == 0) {
482 reset_val = MODE_SLEEP;
483 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
486 reset_val = MODE_NORMAL;
488 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
491 dev_info(&cw_bat->client->dev,
492 "report battery capacity error");
493 ret = cw_update_config_info(cw_bat);
496 dev_info(&cw_bat->client->dev,
497 "report battery capacity still 0 if in changing");
500 } else if (if_quickstart == 1 && cw_bat->charger_mode == 0) {
505 #ifdef SYSTEM_SHUTDOWN_VOLTAGE
506 if (cw_bat->charger_mode == 0 && cw_capacity <= 10 &&
507 cw_bat->voltage <= SYSTEM_SHUTDOWN_VOLTAGE) {
508 if (if_quickstart == 10) {
509 cw_quickstart(cw_bat);
512 } else if (if_quickstart <= 10) {
513 if_quickstart = if_quickstart + 2;
515 dev_info(&cw_bat->client->dev,
516 "voltage is less than shutdown voltage\n");
517 } else if ((cw_bat->charger_mode > 0) && (if_quickstart <= 12)) {
524 static int cw_get_vol(struct cw_battery *cw_bat)
528 u16 value16, value16_1, value16_2, value16_3;
531 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
534 value16 = (reg_val[0] << 8) + reg_val[1];
536 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
539 value16_1 = (reg_val[0] << 8) + reg_val[1];
541 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
544 value16_2 = (reg_val[0] << 8) + reg_val[1];
546 if (value16 > value16_1) {
549 value16_1 = value16_3;
552 if (value16_1 > value16_2) {
553 value16_3 = value16_1;
554 value16_1 = value16_2;
555 value16_2 = value16_3;
558 if (value16 > value16_1) {
561 value16_1 = value16_3;
564 voltage = value16_1 * 305;
566 dev_dbg(&cw_bat->client->dev, "the cw201x voltage=%d,reg_val=%x %x\n",
567 voltage, reg_val[0], reg_val[1]);
571 #ifdef BAT_LOW_INTERRUPT
572 static int cw_get_alt(struct cw_battery *cw_bat)
579 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
585 value8 = value8 & 0x7f;
587 ret = cw_write(cw_bat->client, REG_RRT_ALERT, ®_val);
589 dev_err(&cw_bat->client->dev, "Error clear ALRT\n");
597 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
603 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
609 ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, ®_val);
613 value16 = ((value16 << 8) + reg_val) & 0x1fff;
617 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
621 cw_capacity = cw_get_capacity(cw_bat);
622 if ((cw_capacity >= 0) && (cw_capacity <= 100) &&
623 (cw_bat->capacity != cw_capacity)) {
624 cw_bat->capacity = cw_capacity;
625 cw_bat->bat_change = 1;
626 cw_update_time_member_capacity_change(cw_bat);
628 if (cw_bat->capacity == 0)
629 dev_info(&cw_bat->client->dev,
630 "report battery capacity 0 and will shutdown if no changing");
634 static void rk_bat_update_vol(struct cw_battery *cw_bat)
638 ret = cw_get_vol(cw_bat);
639 if ((ret >= 0) && (cw_bat->voltage != ret))
640 cw_bat->voltage = ret;
643 static void rk_bat_update_status(struct cw_battery *cw_bat)
647 if (cw_bat->charger_mode > 0) {
648 if (cw_bat->capacity >= 100)
649 status = POWER_SUPPLY_STATUS_FULL;
651 status = POWER_SUPPLY_STATUS_CHARGING;
653 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
656 if (cw_bat->status != status) {
657 cw_bat->status = status;
658 cw_bat->bat_change = 1;
662 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
666 ret = cw_get_time_to_empty(cw_bat);
667 if ((ret >= 0) && (cw_bat->time_to_empty != ret))
668 cw_bat->time_to_empty = ret;
671 static int rk_ac_update_online(struct cw_battery *cw_bat)
675 if (!gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
676 cw_bat->dc_online = 0;
677 pr_info("%s dc charger without dc_det_pin\n", __func__);
681 if (gpio_get_value(cw_bat->plat_data.dc_det_pin) ==
682 cw_bat->plat_data.dc_det_level) {
683 if (cw_bat->dc_online != 1) {
684 cw_update_time_member_charge_start(cw_bat);
685 cw_bat->dc_online = 1;
686 if (cw_bat->charger_mode != AC_CHARGER_MODE)
687 cw_bat->charger_mode = AC_CHARGER_MODE;
692 if (cw_bat->dc_online != 0) {
693 cw_update_time_member_charge_start(cw_bat);
694 cw_bat->dc_online = 0;
695 if (cw_bat->usb_online == 0)
696 cw_bat->charger_mode = 0;
703 static int get_usb_charge_state(struct cw_battery *cw_bat)
709 int gadget_status = get_gadget_connect_flag();
710 int usb_status = dwc_vbus_status();
712 get_monotonic_boottime(&ts);
713 time_from_boot = ts.tv_sec;
715 if (cw_bat->charger_init_mode) {
716 if (usb_status == 1 || usb_status == 2) {
717 cw_bat->charger_init_mode = 0;
718 } else if (time_from_boot < 8) {
719 usb_status = cw_bat->charger_init_mode;
720 } else if (strstr(saved_command_line, "charger")) {
721 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
722 usb_status = cw_bat->charger_init_mode;
725 #ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
726 if (cw_bat->usb_online == 1) {
728 time_from_boot - cw_bat->sleep_time_charge_start -
729 cw_bat->run_time_charge_start;
730 if (charge_time > 3) {
731 if (gadget_status == 0 && dwc_vbus_status() == 1)
737 dev_dbg(&cw_bat->client->dev,
738 "%s usb_status=[%d],cw_bat->charger_mode=[%d],cw_bat->gadget_status=[%d], cw_bat->charger_init_mode = [%d]\n",
739 __func__, usb_status, cw_bat->charger_mode, gadget_status,
740 cw_bat->charger_init_mode);
745 static int rk_usb_update_online(struct cw_battery *cw_bat)
752 gpio = cw_bat->plat_data.chg_mode_sel_pin;
753 value = cw_bat->plat_data.chg_mode_sel_level;
754 usb_status = get_usb_charge_state(cw_bat);
755 if (usb_status == 2) {
756 if (cw_bat->charger_mode != AC_CHARGER_MODE) {
757 cw_bat->charger_mode = AC_CHARGER_MODE;
760 if (gpio_is_valid(gpio)) {
761 if (gpio_get_value(gpio) != value)
762 gpio_direction_output(gpio, value);
765 if (cw_bat->usb_online != 1) {
766 cw_bat->usb_online = 1;
767 cw_update_time_member_charge_start(cw_bat);
770 } else if (usb_status == 1) {
771 if (cw_bat->charger_mode != USB_CHARGER_MODE &&
772 cw_bat->dc_online == 0) {
773 cw_bat->charger_mode = USB_CHARGER_MODE;
777 if (gpio_is_valid(gpio)) {
778 if (gpio_get_value(gpio) == value)
779 gpio_direction_output(gpio, !value);
781 if (cw_bat->usb_online != 1) {
782 cw_bat->usb_online = 1;
783 cw_update_time_member_charge_start(cw_bat);
786 } else if (usb_status == 0 && cw_bat->usb_online != 0) {
787 if (gpio_is_valid(gpio)) {
788 if (gpio_get_value(gpio) == value)
789 gpio_direction_output(gpio, !value);
792 if (cw_bat->dc_online == 0)
793 cw_bat->charger_mode = 0;
795 cw_update_time_member_charge_start(cw_bat);
796 cw_bat->usb_online = 0;
803 static void cw_bat_work(struct work_struct *work)
805 struct delayed_work *delay_work;
806 struct cw_battery *cw_bat;
809 delay_work = container_of(work, struct delayed_work, work);
811 container_of(delay_work, struct cw_battery, battery_delay_work);
813 if (cw_bat->plat_data.is_dc_charge == 1) {
814 ret = rk_ac_update_online(cw_bat);
816 power_supply_changed(&cw_bat->rk_ac);
819 if (cw_bat->plat_data.is_usb_charge == 1) {
820 ret = rk_usb_update_online(cw_bat);
822 power_supply_changed(&cw_bat->rk_usb);
823 power_supply_changed(&cw_bat->rk_ac);
827 rk_bat_update_status(cw_bat);
828 rk_bat_update_capacity(cw_bat);
829 rk_bat_update_vol(cw_bat);
830 rk_bat_update_time_to_empty(cw_bat);
832 if (cw_bat->bat_change) {
833 power_supply_changed(&cw_bat->rk_bat);
834 cw_bat->bat_change = 0;
837 queue_delayed_work(cw_bat->battery_workqueue,
838 &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
840 dev_dbg(&cw_bat->client->dev,
841 "cw_bat->bat_change = %d, cw_bat->time_to_empty = %d, cw_bat->capacity = %d\n",
842 cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity);
844 dev_dbg(&cw_bat->client->dev,
845 "cw_bat->voltage = %d, cw_bat->dc_online = %d, cw_bat->usb_online = %d\n",
846 cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
849 static int rk_usb_get_property(struct power_supply *psy,
850 enum power_supply_property psp,
851 union power_supply_propval *val)
854 struct cw_battery *cw_bat;
856 cw_bat = container_of(psy, struct cw_battery, rk_usb);
858 case POWER_SUPPLY_PROP_ONLINE:
859 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
867 static enum power_supply_property rk_usb_properties[] = {
868 POWER_SUPPLY_PROP_ONLINE,
871 static int rk_ac_get_property(struct power_supply *psy,
872 enum power_supply_property psp,
873 union power_supply_propval *val)
876 struct cw_battery *cw_bat;
878 cw_bat = container_of(psy, struct cw_battery, rk_ac);
880 case POWER_SUPPLY_PROP_ONLINE:
881 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
889 static enum power_supply_property rk_ac_properties[] = {
890 POWER_SUPPLY_PROP_ONLINE,
893 static int rk_battery_get_property(struct power_supply *psy,
894 enum power_supply_property psp,
895 union power_supply_propval *val)
898 struct cw_battery *cw_bat;
900 cw_bat = container_of(psy, struct cw_battery, rk_bat);
902 case POWER_SUPPLY_PROP_CAPACITY:
903 val->intval = cw_bat->capacity;
905 case POWER_SUPPLY_PROP_STATUS:
906 val->intval = cw_bat->status;
909 case POWER_SUPPLY_PROP_HEALTH:
910 val->intval = POWER_SUPPLY_HEALTH_GOOD;
912 case POWER_SUPPLY_PROP_PRESENT:
913 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
916 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
917 val->intval = cw_bat->voltage;
920 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
921 val->intval = cw_bat->time_to_empty;
924 case POWER_SUPPLY_PROP_TECHNOLOGY:
925 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
934 static enum power_supply_property rk_battery_properties[] = {
935 POWER_SUPPLY_PROP_CAPACITY,
936 POWER_SUPPLY_PROP_STATUS,
937 POWER_SUPPLY_PROP_HEALTH,
938 POWER_SUPPLY_PROP_PRESENT,
939 POWER_SUPPLY_PROP_VOLTAGE_NOW,
940 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
941 POWER_SUPPLY_PROP_TECHNOLOGY,
944 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
948 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
949 ret = gpio_request(cw_bat->plat_data.dc_det_pin, NULL);
951 dev_err(&cw_bat->client->dev,
952 "failed to request dc_det_pin gpio\n");
953 goto request_dc_det_pin_fail;
955 ret = gpio_direction_input(cw_bat->plat_data.dc_det_pin);
957 dev_err(&cw_bat->client->dev,
958 "failed to set dc_det_pin input\n");
959 goto request_bat_low_pin_fail;
962 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
963 ret = gpio_request(cw_bat->plat_data.bat_low_pin, NULL);
965 dev_err(&cw_bat->client->dev,
966 "failed to request bat_low_pin gpio\n");
967 goto request_bat_low_pin_fail;
970 ret = gpio_direction_input(cw_bat->plat_data.bat_low_pin);
972 dev_err(&cw_bat->client->dev,
973 "failed to set bat_low_pin input\n");
974 goto request_bat_low_pin_fail;
977 if (gpio_is_valid(cw_bat->plat_data.chg_ok_pin)) {
978 ret = gpio_request(cw_bat->plat_data.chg_ok_pin, NULL);
980 dev_err(&cw_bat->client->dev,
981 "failed to request chg_ok_pin gpio\n");
982 goto request_chg_ok_pin_fail;
985 ret = gpio_direction_input(cw_bat->plat_data.chg_ok_pin);
987 dev_err(&cw_bat->client->dev,
988 "failed to set chg_ok_pin input\n");
989 gpio_free(cw_bat->plat_data.chg_ok_pin);
990 goto request_chg_ok_pin_fail;
994 if ((gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin))) {
995 ret = gpio_request(cw_bat->plat_data.chg_mode_sel_pin, NULL);
997 dev_err(&cw_bat->client->dev,
998 "failed to request chg_mode_sel_pin gpio\n");
999 goto request_chg_mode_sel_pin_fail;
1002 gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin,
1004 chg_mode_sel_level ==
1005 CW2015_GPIO_LOW) ? CW2015_GPIO_HIGH :
1008 dev_err(&cw_bat->client->dev,
1009 "failed to set chg_mode_sel_pin output\n");
1010 gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1011 goto request_chg_mode_sel_pin_fail;
1017 request_chg_mode_sel_pin_fail:
1018 gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1019 request_chg_ok_pin_fail:
1020 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin))
1021 gpio_free(cw_bat->plat_data.bat_low_pin);
1022 request_bat_low_pin_fail:
1023 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin))
1024 gpio_free(cw_bat->plat_data.dc_det_pin);
1025 request_dc_det_pin_fail:
1030 static void dc_detect_do_wakeup(struct work_struct *work)
1036 struct delayed_work *delay_work;
1037 struct cw_battery *cw_bat;
1039 delay_work = container_of(work, struct delayed_work, work);
1040 cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
1042 rk_send_wakeup_key();
1044 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1046 gpio_get_value(cw_bat->plat_data.
1047 dc_det_pin) ? IRQ_TYPE_EDGE_FALLING :
1048 IRQ_TYPE_EDGE_RISING;
1049 ret = irq_set_irq_type(irq, type);
1051 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq,
1057 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
1059 struct cw_battery *cw_bat = dev_id;
1061 /* for irq debounce */
1062 disable_irq_nosync(irq);
1063 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work,
1064 msecs_to_jiffies(20));
1068 #ifdef BAT_LOW_INTERRUPT
1070 #define WAKE_LOCK_TIMEOUT (10 * HZ)
1072 static void bat_low_detect_do_wakeup(struct work_struct *work)
1074 struct delayed_work *delay_work;
1075 struct cw_battery *cw_bat;
1077 delay_work = container_of(work, struct delayed_work, work);
1079 container_of(delay_work, struct cw_battery, bat_low_wakeup_work);
1080 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
1084 static irqreturn_t bat_low_detect_irq_handler(int irq, void *dev_id)
1086 struct cw_battery *cw_bat = dev_id;
1088 queue_delayed_work(cw_bat->battery_workqueue,
1089 &cw_bat->bat_low_wakeup_work, msecs_to_jiffies(20));
1095 static int cw2015_parse_dt(struct device *dev,
1096 struct cw_bat_platform_data *data)
1098 struct device_node *node = dev->of_node;
1099 enum of_gpio_flags flags;
1100 struct property *prop;
1108 memset(data, 0, sizeof(*data));
1110 /* determine the number of config info */
1111 prop = of_find_property(node, "bat_config_info", &length);
1115 length /= sizeof(u32);
1118 size_t size = sizeof(*data->cw_bat_config_info) * length;
1120 data->cw_bat_config_info = devm_kzalloc(dev, size, GFP_KERNEL);
1121 if (!data->cw_bat_config_info)
1124 ret = of_property_read_u32_array(node, "bat_config_info",
1125 data->cw_bat_config_info,
1131 data->dc_det_pin = of_get_named_gpio_flags(node, "dc_det_gpio", 0,
1133 if (data->dc_det_pin == -EPROBE_DEFER)
1134 pr_info("%s dc_det_gpio error\n", __func__);
1136 if (gpio_is_valid(data->dc_det_pin))
1137 data->dc_det_level =
1138 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1141 data->bat_low_pin = of_get_named_gpio_flags(node, "bat_low_gpio", 0,
1143 if (data->bat_low_pin == -EPROBE_DEFER)
1144 pr_info("%s bat_low_gpio error\n", __func__);
1146 if (gpio_is_valid(data->bat_low_pin))
1147 data->bat_low_level =
1148 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1151 data->chg_ok_pin = of_get_named_gpio_flags(node, "chg_ok_gpio", 0,
1153 if (data->chg_ok_pin == -EPROBE_DEFER)
1154 pr_info("%s chg_ok_gpio error\n", __func__);
1156 if (gpio_is_valid(data->chg_ok_pin))
1157 data->chg_ok_level =
1158 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1161 data->chg_mode_sel_pin =
1162 of_get_named_gpio_flags(node, "chg_mode_sel_gpio", 0, &flags);
1163 if (data->chg_mode_sel_pin == -EPROBE_DEFER)
1164 pr_info("%s chg_mod_sel_gpio error\n", __func__);
1166 if (gpio_is_valid(data->chg_mode_sel_pin))
1167 data->chg_mode_sel_level =
1168 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1171 ret = of_property_read_u32(node, "is_dc_charge", &value);
1173 pr_info("%s:hardware unsupport dc charge\n", __func__);
1176 data->is_dc_charge = value;
1178 ret = of_property_read_u32(node, "is_usb_charge", &value);
1180 pr_info("%s:hardware unsupport usb charge\n", __func__);
1183 data->is_usb_charge = value;
1185 pr_info("cw201x:support %s %s charger\n",
1186 data->is_dc_charge ? "DC" : "",
1187 data->is_usb_charge ? "USB" : "");
1192 static int cw2015_parse_dt(struct device *dev,
1193 struct cw_bat_platform_data *data)
1199 static int cw_bat_probe(struct i2c_client *client,
1200 const struct i2c_device_id *id)
1202 struct cw_battery *cw_bat;
1203 struct cw_bat_platform_data *plat_data = client->dev.platform_data;
1209 cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
1211 dev_err(&cw_bat->client->dev,
1212 "fail to allocate memory for cw2015\n");
1215 i2c_set_clientdata(client, cw_bat);
1218 ret = cw2015_parse_dt(&client->dev, &(cw_bat->plat_data));
1220 dev_err(&client->dev,
1221 "failed to find cw2015 platform data\n");
1226 cw_bat->client = client;
1227 ret = cw_bat_gpio_init(cw_bat);
1229 dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
1233 ret = cw_init(cw_bat);
1235 pr_err("%s cw_init error\n", __func__);
1239 cw_bat->rk_bat.name = "rk-bat";
1240 cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1241 cw_bat->rk_bat.properties = rk_battery_properties;
1242 cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
1243 cw_bat->rk_bat.get_property = rk_battery_get_property;
1244 ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
1246 dev_err(&cw_bat->client->dev,
1247 "power supply register rk_bat error\n");
1248 goto rk_bat_register_fail;
1251 cw_bat->rk_ac.name = "rk-ac";
1252 cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
1253 cw_bat->rk_ac.properties = rk_ac_properties;
1254 cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
1255 cw_bat->rk_ac.get_property = rk_ac_get_property;
1256 ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1258 dev_err(&cw_bat->client->dev,
1259 "power supply register rk_ac error\n");
1260 goto rk_ac_register_fail;
1263 if (cw_bat->plat_data.is_usb_charge == 1) {
1264 cw_bat->rk_usb.name = "rk-usb";
1265 cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1266 cw_bat->rk_usb.properties = rk_usb_properties;
1267 cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1268 cw_bat->rk_usb.get_property = rk_usb_get_property;
1269 ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1271 dev_err(&cw_bat->client->dev,
1272 "power supply register rk_usb error\n");
1273 goto rk_usb_register_fail;
1275 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1276 pr_info("%s cw2015 support charger by usb. usb_mode=%d\n",
1277 __func__, cw_bat->charger_init_mode);
1280 cw_bat->dc_online = 0;
1281 cw_bat->usb_online = 0;
1282 cw_bat->charger_mode = 0;
1283 cw_bat->capacity = 1;
1284 cw_bat->voltage = 0;
1286 cw_bat->time_to_empty = 0;
1287 cw_bat->bat_change = 0;
1289 cw_update_time_member_capacity_change(cw_bat);
1290 cw_update_time_member_charge_start(cw_bat);
1292 cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1293 INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1294 INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1295 queue_delayed_work(cw_bat->battery_workqueue,
1296 &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1298 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
1299 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1300 level = gpio_get_value(cw_bat->plat_data.dc_det_pin);
1301 if (level == cw_bat->plat_data.dc_det_level) {
1302 pr_info("%s booting up with dc plug\n", __func__);
1303 cw_bat->status = POWER_SUPPLY_STATUS_CHARGING;
1305 irq_flags = level ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1307 request_irq(irq, dc_detect_irq_handler, irq_flags,
1308 "dc_detect", cw_bat);
1310 pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1311 enable_irq_wake(irq);
1314 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
1315 INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work,
1316 bat_low_detect_do_wakeup);
1317 level = gpio_get_value(cw_bat->plat_data.bat_low_pin);
1318 if (level == cw_bat->plat_data.dc_det_level) {
1319 pr_info("%s booting up with lower power\n", __func__);
1320 cw_bat->capacity = 1;
1322 irq = gpio_to_irq(cw_bat->plat_data.bat_low_pin);
1324 request_irq(irq, bat_low_detect_irq_handler,
1325 IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
1327 gpio_free(cw_bat->plat_data.bat_low_pin);
1329 enable_irq_wake(irq);
1332 dev_info(&cw_bat->client->dev,
1333 "cw2015/cw2013 driver v1.2 probe sucess\n");
1336 rk_usb_register_fail:
1337 power_supply_unregister(&cw_bat->rk_usb);
1338 rk_ac_register_fail:
1339 power_supply_unregister(&cw_bat->rk_ac);
1340 rk_bat_register_fail:
1341 power_supply_unregister(&cw_bat->rk_bat);
1343 dev_info(&cw_bat->client->dev,
1344 "cw2015/cw2013 driver v1.2 probe error!!!!\n");
1348 static int cw_bat_remove(struct i2c_client *client)
1350 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1352 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1353 cancel_delayed_work(&cw_bat->battery_delay_work);
1358 static int cw_bat_suspend(struct device *dev)
1360 struct i2c_client *client = to_i2c_client(dev);
1361 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1363 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1364 cancel_delayed_work(&cw_bat->battery_delay_work);
1368 static int cw_bat_resume(struct device *dev)
1370 struct i2c_client *client = to_i2c_client(dev);
1371 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1373 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1374 queue_delayed_work(cw_bat->battery_workqueue,
1375 &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1379 static const struct i2c_device_id cw_id[] = {
1383 MODULE_DEVICE_TABLE(i2c, cw_id);
1385 static const struct dev_pm_ops cw_bat_pm_ops = {
1386 .suspend = cw_bat_suspend,
1387 .resume = cw_bat_resume,
1391 static struct i2c_driver cw_bat_driver = {
1395 .pm = &cw_bat_pm_ops,
1399 .probe = cw_bat_probe,
1400 .remove = cw_bat_remove,
1404 static int __init cw_bat_init(void)
1406 return i2c_add_driver(&cw_bat_driver);
1409 static void __exit cw_bat_exit(void)
1411 i2c_del_driver(&cw_bat_driver);
1414 fs_initcall(cw_bat_init);
1415 module_exit(cw_bat_exit);
1417 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1418 MODULE_DESCRIPTION("cw2015/cw2013 battery driver");
1419 MODULE_LICENSE("GPL");