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/slab.h>
28 #include <linux/power/cw2015_battery.h>
30 static int i2c_master_reg8_send(const struct i2c_client *client, const char reg,
31 const char *buf, int count, int scl_rate)
36 struct i2c_adapter *adap = client->adapter;
38 tx_buf = kzalloc(count + 1, GFP_KERNEL);
43 memcpy(tx_buf + 1, buf, count);
45 msg.addr = client->addr;
46 msg.flags = client->flags;
48 msg.buf = (char *)tx_buf;
49 msg.scl_rate = scl_rate;
51 ret = i2c_transfer(adap, &msg, 1);
54 return (ret == 1) ? count : ret;
57 static int i2c_master_reg8_recv(const struct i2c_client *client, const char reg,
58 char *buf, int count, int scl_rate)
60 struct i2c_adapter *adap = client->adapter;
61 struct i2c_msg msgs[2];
65 msgs[0].addr = client->addr;
66 msgs[0].flags = client->flags;
68 msgs[0].buf = ®_buf;
69 msgs[0].scl_rate = scl_rate;
71 msgs[1].addr = client->addr;
72 msgs[1].flags = client->flags | I2C_M_RD;
74 msgs[1].buf = (char *)buf;
75 msgs[1].scl_rate = scl_rate;
77 ret = i2c_transfer(adap, msgs, 2);
79 return (ret == 2) ? count : ret;
82 static int cw_read(struct i2c_client *client, u8 reg, u8 buf[])
86 ret = i2c_master_reg8_recv(client, reg, buf, 1, CW_I2C_SPEED);
91 static int cw_write(struct i2c_client *client, u8 reg, u8 const buf[])
95 ret = i2c_master_reg8_send(client, reg, buf, 1, CW_I2C_SPEED);
100 static int cw_read_word(struct i2c_client *client, u8 reg, u8 buf[])
104 ret = i2c_master_reg8_recv(client, reg, buf, 2, CW_I2C_SPEED);
109 static int cw_update_config_info(struct cw_battery *cw_bat)
116 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
118 /* make sure no in sleep mode */
119 ret = cw_read(cw_bat->client, REG_MODE, ®_val);
124 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
125 dev_err(&cw_bat->client->dev,
126 "Error, device in sleep mode, cannot update battery info\n");
130 /* update new battery info */
131 for (i = 0; i < SIZE_BATINFO; i++) {
133 cw_write(cw_bat->client, REG_BATINFO + i,
134 (u8 *)&cw_bat->plat_data.cw_bat_config_info[i]);
140 /* readback & check */
141 for (i = 0; i < SIZE_BATINFO; i++) {
142 ret = cw_read(cw_bat->client, REG_BATINFO + i, ®_val);
143 if (reg_val != cw_bat->plat_data.cw_bat_config_info[i])
147 /* set cw2015/cw2013 to use new battery info */
148 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
152 reg_val |= CONFIG_UPDATE_FLG; /* set UPDATE_FLAG */
153 reg_val &= 0x07; /* clear ATHD */
154 reg_val |= ATHD; /* set ATHD */
155 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
159 /* check 2015/cw2013 for ATHD & update_flag */
160 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
164 if (!(reg_val & CONFIG_UPDATE_FLG)) {
165 dev_info(&cw_bat->client->dev,
166 "update flag for new battery info have not set..\n");
169 if ((reg_val & 0xf8) != ATHD)
170 dev_info(&cw_bat->client->dev, "the new ATHD have not set..\n");
173 reset_val &= ~(MODE_RESTART);
174 reg_val = reset_val | MODE_RESTART;
175 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
180 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
187 static int cw_init(struct cw_battery *cw_bat)
191 u8 reg_val = MODE_SLEEP;
193 if ((reg_val & MODE_SLEEP_MASK) == MODE_SLEEP) {
194 reg_val = MODE_NORMAL;
195 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
200 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
204 if ((reg_val & 0xf8) != ATHD) {
205 dev_info(&cw_bat->client->dev, "the new ATHD have not set\n");
206 reg_val &= 0x07; /* clear ATHD */
207 reg_val |= ATHD; /* set ATHD */
208 ret = cw_write(cw_bat->client, REG_CONFIG, ®_val);
213 ret = cw_read(cw_bat->client, REG_CONFIG, ®_val);
217 if (!(reg_val & CONFIG_UPDATE_FLG)) {
218 dev_info(&cw_bat->client->dev,
219 "update flag for new battery info have not set\n");
220 ret = cw_update_config_info(cw_bat);
224 for (i = 0; i < SIZE_BATINFO; i++) {
226 cw_read(cw_bat->client, (REG_BATINFO + i),
231 if (cw_bat->plat_data.cw_bat_config_info[i] != reg_val)
235 if (i != SIZE_BATINFO) {
236 dev_info(&cw_bat->client->dev,
237 "update flag for new battery info have not set\n");
238 ret = cw_update_config_info(cw_bat);
244 for (i = 0; i < 30; i++) {
245 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
248 else if (reg_val <= 0x64)
253 dev_err(&cw_bat->client->dev,
254 "cw2015/cw2013 input unvalid power error\n");
258 reg_val = MODE_SLEEP;
259 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
260 dev_info(&cw_bat->client->dev, "report battery capacity error");
266 static void cw_update_time_member_charge_start(struct cw_battery *cw_bat)
273 new_run_time = ts.tv_sec;
275 get_monotonic_boottime(&ts);
276 new_sleep_time = ts.tv_sec - new_run_time;
278 cw_bat->run_time_charge_start = new_run_time;
279 cw_bat->sleep_time_charge_start = new_sleep_time;
282 static void cw_update_time_member_capacity_change(struct cw_battery *cw_bat)
289 new_run_time = ts.tv_sec;
291 get_monotonic_boottime(&ts);
292 new_sleep_time = ts.tv_sec - new_run_time;
294 cw_bat->run_time_capacity_change = new_run_time;
295 cw_bat->sleep_time_capacity_change = new_sleep_time;
299 static int cw_quickstart(struct cw_battery *cw_bat)
302 u8 reg_val = MODE_QUICK_START;
304 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
306 dev_err(&cw_bat->client->dev, "Error quick start1\n");
310 reg_val = MODE_NORMAL;
311 ret = cw_write(cw_bat->client, REG_MODE, ®_val);
313 dev_err(&cw_bat->client->dev, "Error quick start2\n");
319 static int cw_get_capacity(struct cw_battery *cw_bat)
330 long capacity_or_aconline_time;
331 static int if_quickstart;
332 static int jump_flag;
333 static int reset_loop;
336 ret = cw_read(cw_bat->client, REG_SOC, ®_val);
339 cw_capacity = reg_val;
341 if (cw_capacity == 0 && if_quickstart == 0) {
342 dev_info(&cw_bat->client->dev,
343 "the cw201x capacity is 0 !!!!!!!, funciton: %s, line: %d\n",
346 reset_val = MODE_SLEEP;
347 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
350 reset_val = MODE_NORMAL;
352 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
355 dev_info(&cw_bat->client->dev,
356 "report battery capacity error1");
360 dev_dbg(&cw_bat->client->dev,
361 "the cw201x capacity is %d, funciton: %s\n",
362 cw_capacity, __func__);
364 if (cw_capacity < 0 || cw_capacity > 100) {
365 dev_err(&cw_bat->client->dev,
366 "get cw_capacity error; cw_capacity = %d\n",
370 if (reset_loop > 5) {
371 reset_val = MODE_SLEEP;
372 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
375 reset_val = MODE_NORMAL;
377 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
380 dev_info(&cw_bat->client->dev,
381 "report battery capacity error");
382 ret = cw_update_config_info(cw_bat);
394 new_run_time = ts.tv_sec;
396 get_monotonic_boottime(&ts);
397 new_sleep_time = ts.tv_sec - new_run_time;
399 /* modify battery level swing */
400 if ((cw_bat->charger_mode > 0 &&
401 cw_capacity <= (cw_bat->capacity - 1) &&
402 cw_capacity > (cw_bat->capacity - 9)) ||
403 (cw_bat->charger_mode == 0 &&
404 cw_capacity == (cw_bat->capacity + 1))) {
405 if (!(cw_capacity == 0 && cw_bat->capacity <= 2))
406 cw_capacity = cw_bat->capacity;
409 /* avoid no charge full */
410 if (cw_bat->charger_mode > 0 &&
412 cw_capacity <= cw_bat->capacity) {
413 capacity_or_aconline_time =
414 (cw_bat->sleep_time_capacity_change >
415 cw_bat->sleep_time_charge_start) ? cw_bat->
416 sleep_time_capacity_change : cw_bat->
417 sleep_time_charge_start;
418 capacity_or_aconline_time +=
419 (cw_bat->run_time_capacity_change >
420 cw_bat->run_time_charge_start) ? cw_bat->
421 run_time_capacity_change : cw_bat->run_time_charge_start;
423 (new_sleep_time + new_run_time -
424 capacity_or_aconline_time) / BATTERY_UP_MAX_CHANGE;
425 if (allow_change > 0) {
426 allow_capacity = cw_bat->capacity + allow_change;
428 (allow_capacity <= 100) ? allow_capacity : 100;
430 } else if (cw_capacity <= cw_bat->capacity) {
431 cw_capacity = cw_bat->capacity;
434 /* avoid battery level jump to CW_BAT */
435 else if (cw_bat->charger_mode == 0 &&
436 cw_capacity <= cw_bat->capacity &&
437 cw_capacity >= 90 && jump_flag == 1) {
438 capacity_or_aconline_time =
439 (cw_bat->sleep_time_capacity_change >
440 cw_bat->sleep_time_charge_start) ? cw_bat->
441 sleep_time_capacity_change : cw_bat->
442 sleep_time_charge_start;
443 capacity_or_aconline_time +=
444 (cw_bat->run_time_capacity_change >
445 cw_bat->run_time_charge_start) ? cw_bat->
446 run_time_capacity_change : cw_bat->run_time_charge_start;
448 (new_sleep_time + new_run_time -
449 capacity_or_aconline_time) / BATTERY_DOWN_CHANGE;
450 if (allow_change > 0) {
451 allow_capacity = cw_bat->capacity - allow_change;
452 if (cw_capacity >= allow_capacity) {
457 100) ? allow_capacity : 100;
459 } else if (cw_capacity <= cw_bat->capacity) {
460 cw_capacity = cw_bat->capacity;
464 /* avoid battery level jump to 0% at a moment from more than 2% */
465 if (cw_capacity == 0 && cw_bat->capacity > 1) {
468 cw_bat->run_time_capacity_change) /
469 BATTERY_DOWN_MIN_CHANGE_RUN);
472 cw_bat->sleep_time_capacity_change) /
473 BATTERY_DOWN_MIN_CHANGE_SLEEP);
475 allow_capacity = cw_bat->capacity - allow_change;
478 cw_capacity) ? allow_capacity : cw_capacity;
479 dev_info(&cw_bat->client->dev, "report GGIC POR happened");
480 reset_val = MODE_SLEEP;
481 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
484 reset_val = MODE_NORMAL;
486 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
489 dev_info(&cw_bat->client->dev, "report battery capacity error");
490 ret = cw_update_config_info(cw_bat);
493 dev_info(&cw_bat->client->dev,
494 "report battery capacity jump 0 ");
497 if (cw_bat->charger_mode > 0 && cw_capacity == 0) {
499 new_sleep_time + new_run_time -
500 cw_bat->sleep_time_charge_start -
501 cw_bat->run_time_charge_start;
502 if (charge_time > BATTERY_DOWN_MAX_CHANGE_RUN_AC_ONLINE &&
503 if_quickstart == 0) {
504 reset_val = MODE_SLEEP;
505 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
508 reset_val = MODE_NORMAL;
510 ret = cw_write(cw_bat->client, REG_MODE, &reset_val);
513 dev_info(&cw_bat->client->dev,
514 "report battery capacity error");
515 ret = cw_update_config_info(cw_bat);
518 dev_info(&cw_bat->client->dev,
519 "report battery capacity still 0 if in changing");
522 } else if (if_quickstart == 1 && cw_bat->charger_mode == 0) {
527 #ifdef SYSTEM_SHUTDOWN_VOLTAGE
528 if (cw_bat->charger_mode == 0 && cw_capacity <= 10 &&
529 cw_bat->voltage <= SYSTEM_SHUTDOWN_VOLTAGE) {
530 if (if_quickstart == 10) {
531 cw_quickstart(cw_bat);
534 } else if (if_quickstart <= 10) {
535 if_quickstart = if_quickstart + 2;
537 dev_info(&cw_bat->client->dev,
538 "voltage is less than shutdown voltage\n");
539 } else if ((cw_bat->charger_mode > 0) && (if_quickstart <= 12)) {
546 static int cw_get_vol(struct cw_battery *cw_bat)
550 u16 value16, value16_1, value16_2, value16_3;
553 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
556 value16 = (reg_val[0] << 8) + reg_val[1];
558 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
561 value16_1 = (reg_val[0] << 8) + reg_val[1];
563 ret = cw_read_word(cw_bat->client, REG_VCELL, reg_val);
566 value16_2 = (reg_val[0] << 8) + reg_val[1];
568 if (value16 > value16_1) {
571 value16_1 = value16_3;
574 if (value16_1 > value16_2) {
575 value16_3 = value16_1;
576 value16_1 = value16_2;
577 value16_2 = value16_3;
580 if (value16 > value16_1) {
583 value16_1 = value16_3;
586 voltage = value16_1 * 305;
588 dev_dbg(&cw_bat->client->dev, "the cw201x voltage=%d,reg_val=%x %x\n",
589 voltage, reg_val[0], reg_val[1]);
593 #ifdef BAT_LOW_INTERRUPT
594 static int cw_get_alt(struct cw_battery *cw_bat)
601 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
607 value8 = value8 & 0x7f;
609 ret = cw_write(cw_bat->client, REG_RRT_ALERT, ®_val);
611 dev_err(&cw_bat->client->dev, "Error clear ALRT\n");
619 static int cw_get_time_to_empty(struct cw_battery *cw_bat)
625 ret = cw_read(cw_bat->client, REG_RRT_ALERT, ®_val);
631 ret = cw_read(cw_bat->client, REG_RRT_ALERT + 1, ®_val);
635 value16 = ((value16 << 8) + reg_val) & 0x1fff;
639 static void rk_bat_update_capacity(struct cw_battery *cw_bat)
643 cw_capacity = cw_get_capacity(cw_bat);
644 if ((cw_capacity >= 0) && (cw_capacity <= 100) &&
645 (cw_bat->capacity != cw_capacity)) {
646 cw_bat->capacity = cw_capacity;
647 cw_bat->bat_change = 1;
648 cw_update_time_member_capacity_change(cw_bat);
650 if (cw_bat->capacity == 0)
651 dev_info(&cw_bat->client->dev,
652 "report battery capacity 0 and will shutdown if no changing");
656 static void rk_bat_update_vol(struct cw_battery *cw_bat)
660 ret = cw_get_vol(cw_bat);
661 if ((ret >= 0) && (cw_bat->voltage != ret))
662 cw_bat->voltage = ret;
665 static void rk_bat_update_status(struct cw_battery *cw_bat)
669 if (cw_bat->charger_mode > 0) {
670 if (cw_bat->capacity >= 100)
671 status = POWER_SUPPLY_STATUS_FULL;
673 status = POWER_SUPPLY_STATUS_CHARGING;
675 status = POWER_SUPPLY_STATUS_NOT_CHARGING;
678 if (cw_bat->status != status) {
679 cw_bat->status = status;
680 cw_bat->bat_change = 1;
684 static void rk_bat_update_time_to_empty(struct cw_battery *cw_bat)
688 ret = cw_get_time_to_empty(cw_bat);
689 if ((ret >= 0) && (cw_bat->time_to_empty != ret))
690 cw_bat->time_to_empty = ret;
693 static int rk_ac_update_online(struct cw_battery *cw_bat)
697 if (!gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
698 cw_bat->dc_online = 0;
699 pr_info("%s dc charger without dc_det_pin\n", __func__);
703 if (gpio_get_value(cw_bat->plat_data.dc_det_pin) ==
704 cw_bat->plat_data.dc_det_level) {
705 if (cw_bat->dc_online != 1) {
706 cw_update_time_member_charge_start(cw_bat);
707 cw_bat->dc_online = 1;
708 if (cw_bat->charger_mode != AC_CHARGER_MODE)
709 cw_bat->charger_mode = AC_CHARGER_MODE;
714 if (cw_bat->dc_online != 0) {
715 cw_update_time_member_charge_start(cw_bat);
716 cw_bat->dc_online = 0;
717 if (cw_bat->usb_online == 0)
718 cw_bat->charger_mode = 0;
725 static int get_usb_charge_state(struct cw_battery *cw_bat)
731 int gadget_status = get_gadget_connect_flag();
732 int usb_status = dwc_vbus_status();
734 get_monotonic_boottime(&ts);
735 time_from_boot = ts.tv_sec;
737 if (cw_bat->charger_init_mode) {
738 if (usb_status == 1 || usb_status == 2) {
739 cw_bat->charger_init_mode = 0;
740 } else if (time_from_boot < 8) {
741 usb_status = cw_bat->charger_init_mode;
742 } else if (strstr(saved_command_line, "charger")) {
743 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
744 usb_status = cw_bat->charger_init_mode;
747 #ifdef NO_STANDARD_AC_BIG_CHARGE_MODE
748 if (cw_bat->usb_online == 1) {
750 time_from_boot - cw_bat->sleep_time_charge_start -
751 cw_bat->run_time_charge_start;
752 if (charge_time > 3) {
753 if (gadget_status == 0 && dwc_vbus_status() == 1)
759 dev_dbg(&cw_bat->client->dev,
760 "%s usb_status=[%d],cw_bat->charger_mode=[%d],cw_bat->gadget_status=[%d], cw_bat->charger_init_mode = [%d]\n",
761 __func__, usb_status, cw_bat->charger_mode, gadget_status,
762 cw_bat->charger_init_mode);
767 static int rk_usb_update_online(struct cw_battery *cw_bat)
774 gpio = cw_bat->plat_data.chg_mode_sel_pin;
775 value = cw_bat->plat_data.chg_mode_sel_level;
776 usb_status = get_usb_charge_state(cw_bat);
777 if (usb_status == 2) {
778 if (cw_bat->charger_mode != AC_CHARGER_MODE) {
779 cw_bat->charger_mode = AC_CHARGER_MODE;
782 if (gpio_is_valid(gpio)) {
783 if (gpio_get_value(gpio) != value)
784 gpio_direction_output(gpio, value);
787 if (cw_bat->usb_online != 1) {
788 cw_bat->usb_online = 1;
789 cw_update_time_member_charge_start(cw_bat);
792 } else if (usb_status == 1) {
793 if (cw_bat->charger_mode != USB_CHARGER_MODE &&
794 cw_bat->dc_online == 0) {
795 cw_bat->charger_mode = USB_CHARGER_MODE;
799 if (gpio_is_valid(gpio)) {
800 if (gpio_get_value(gpio) == value)
801 gpio_direction_output(gpio, !value);
803 if (cw_bat->usb_online != 1) {
804 cw_bat->usb_online = 1;
805 cw_update_time_member_charge_start(cw_bat);
808 } else if (usb_status == 0 && cw_bat->usb_online != 0) {
809 if (gpio_is_valid(gpio)) {
810 if (gpio_get_value(gpio) == value)
811 gpio_direction_output(gpio, !value);
814 if (cw_bat->dc_online == 0)
815 cw_bat->charger_mode = 0;
817 cw_update_time_member_charge_start(cw_bat);
818 cw_bat->usb_online = 0;
825 static void cw_bat_work(struct work_struct *work)
827 struct delayed_work *delay_work;
828 struct cw_battery *cw_bat;
831 delay_work = container_of(work, struct delayed_work, work);
833 container_of(delay_work, struct cw_battery, battery_delay_work);
835 if (cw_bat->plat_data.is_dc_charge == 1) {
836 ret = rk_ac_update_online(cw_bat);
838 power_supply_changed(&cw_bat->rk_ac);
841 if (cw_bat->plat_data.is_usb_charge == 1) {
842 ret = rk_usb_update_online(cw_bat);
844 power_supply_changed(&cw_bat->rk_usb);
845 power_supply_changed(&cw_bat->rk_ac);
849 rk_bat_update_status(cw_bat);
850 rk_bat_update_capacity(cw_bat);
851 rk_bat_update_vol(cw_bat);
852 rk_bat_update_time_to_empty(cw_bat);
854 if (cw_bat->bat_change) {
855 power_supply_changed(&cw_bat->rk_bat);
856 cw_bat->bat_change = 0;
859 queue_delayed_work(cw_bat->battery_workqueue,
860 &cw_bat->battery_delay_work, msecs_to_jiffies(1000));
862 dev_dbg(&cw_bat->client->dev,
863 "cw_bat->bat_change = %d, cw_bat->time_to_empty = %d, cw_bat->capacity = %d\n",
864 cw_bat->bat_change, cw_bat->time_to_empty, cw_bat->capacity);
866 dev_dbg(&cw_bat->client->dev,
867 "cw_bat->voltage = %d, cw_bat->dc_online = %d, cw_bat->usb_online = %d\n",
868 cw_bat->voltage, cw_bat->dc_online, cw_bat->usb_online);
871 static int rk_usb_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_usb);
880 case POWER_SUPPLY_PROP_ONLINE:
881 val->intval = (cw_bat->charger_mode == USB_CHARGER_MODE);
889 static enum power_supply_property rk_usb_properties[] = {
890 POWER_SUPPLY_PROP_ONLINE,
893 static int rk_ac_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_ac);
902 case POWER_SUPPLY_PROP_ONLINE:
903 val->intval = (cw_bat->charger_mode == AC_CHARGER_MODE);
911 static enum power_supply_property rk_ac_properties[] = {
912 POWER_SUPPLY_PROP_ONLINE,
915 static int rk_battery_get_property(struct power_supply *psy,
916 enum power_supply_property psp,
917 union power_supply_propval *val)
920 struct cw_battery *cw_bat;
922 cw_bat = container_of(psy, struct cw_battery, rk_bat);
924 case POWER_SUPPLY_PROP_CAPACITY:
925 val->intval = cw_bat->capacity;
927 case POWER_SUPPLY_PROP_STATUS:
928 val->intval = cw_bat->status;
931 case POWER_SUPPLY_PROP_HEALTH:
932 val->intval = POWER_SUPPLY_HEALTH_GOOD;
934 case POWER_SUPPLY_PROP_PRESENT:
935 val->intval = cw_bat->voltage <= 0 ? 0 : 1;
938 case POWER_SUPPLY_PROP_VOLTAGE_NOW:
939 val->intval = cw_bat->voltage;
942 case POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW:
943 val->intval = cw_bat->time_to_empty;
946 case POWER_SUPPLY_PROP_TECHNOLOGY:
947 val->intval = POWER_SUPPLY_TECHNOLOGY_LION;
956 static enum power_supply_property rk_battery_properties[] = {
957 POWER_SUPPLY_PROP_CAPACITY,
958 POWER_SUPPLY_PROP_STATUS,
959 POWER_SUPPLY_PROP_HEALTH,
960 POWER_SUPPLY_PROP_PRESENT,
961 POWER_SUPPLY_PROP_VOLTAGE_NOW,
962 POWER_SUPPLY_PROP_TIME_TO_EMPTY_NOW,
963 POWER_SUPPLY_PROP_TECHNOLOGY,
966 static int cw_bat_gpio_init(struct cw_battery *cw_bat)
970 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
971 ret = gpio_request(cw_bat->plat_data.dc_det_pin, NULL);
973 dev_err(&cw_bat->client->dev,
974 "failed to request dc_det_pin gpio\n");
975 goto request_dc_det_pin_fail;
977 ret = gpio_direction_input(cw_bat->plat_data.dc_det_pin);
979 dev_err(&cw_bat->client->dev,
980 "failed to set dc_det_pin input\n");
981 goto request_bat_low_pin_fail;
984 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
985 ret = gpio_request(cw_bat->plat_data.bat_low_pin, NULL);
987 dev_err(&cw_bat->client->dev,
988 "failed to request bat_low_pin gpio\n");
989 goto request_bat_low_pin_fail;
992 ret = gpio_direction_input(cw_bat->plat_data.bat_low_pin);
994 dev_err(&cw_bat->client->dev,
995 "failed to set bat_low_pin input\n");
996 goto request_bat_low_pin_fail;
999 if (gpio_is_valid(cw_bat->plat_data.chg_ok_pin)) {
1000 ret = gpio_request(cw_bat->plat_data.chg_ok_pin, NULL);
1002 dev_err(&cw_bat->client->dev,
1003 "failed to request chg_ok_pin gpio\n");
1004 goto request_chg_ok_pin_fail;
1007 ret = gpio_direction_input(cw_bat->plat_data.chg_ok_pin);
1009 dev_err(&cw_bat->client->dev,
1010 "failed to set chg_ok_pin input\n");
1011 gpio_free(cw_bat->plat_data.chg_ok_pin);
1012 goto request_chg_ok_pin_fail;
1016 if ((gpio_is_valid(cw_bat->plat_data.chg_mode_sel_pin))) {
1017 ret = gpio_request(cw_bat->plat_data.chg_mode_sel_pin, NULL);
1019 dev_err(&cw_bat->client->dev,
1020 "failed to request chg_mode_sel_pin gpio\n");
1021 goto request_chg_mode_sel_pin_fail;
1024 gpio_direction_output(cw_bat->plat_data.chg_mode_sel_pin,
1026 chg_mode_sel_level ==
1027 CW2015_GPIO_LOW) ? CW2015_GPIO_HIGH :
1030 dev_err(&cw_bat->client->dev,
1031 "failed to set chg_mode_sel_pin output\n");
1032 gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1033 goto request_chg_mode_sel_pin_fail;
1039 request_chg_mode_sel_pin_fail:
1040 gpio_free(cw_bat->plat_data.chg_mode_sel_pin);
1041 request_chg_ok_pin_fail:
1042 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin))
1043 gpio_free(cw_bat->plat_data.bat_low_pin);
1044 request_bat_low_pin_fail:
1045 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin))
1046 gpio_free(cw_bat->plat_data.dc_det_pin);
1047 request_dc_det_pin_fail:
1052 static void dc_detect_do_wakeup(struct work_struct *work)
1058 struct delayed_work *delay_work;
1059 struct cw_battery *cw_bat;
1061 delay_work = container_of(work, struct delayed_work, work);
1062 cw_bat = container_of(delay_work, struct cw_battery, dc_wakeup_work);
1064 rk_send_wakeup_key();
1066 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1068 gpio_get_value(cw_bat->plat_data.
1069 dc_det_pin) ? IRQ_TYPE_EDGE_FALLING :
1070 IRQ_TYPE_EDGE_RISING;
1071 ret = irq_set_irq_type(irq, type);
1073 pr_err("%s: irq_set_irq_type(%d, %d) failed\n", __func__, irq,
1079 static irqreturn_t dc_detect_irq_handler(int irq, void *dev_id)
1081 struct cw_battery *cw_bat = dev_id;
1083 /* for irq debounce */
1084 disable_irq_nosync(irq);
1085 queue_delayed_work(cw_bat->battery_workqueue, &cw_bat->dc_wakeup_work,
1086 msecs_to_jiffies(20));
1090 #ifdef BAT_LOW_INTERRUPT
1092 #define WAKE_LOCK_TIMEOUT (10 * HZ)
1094 static void bat_low_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);
1101 container_of(delay_work, struct cw_battery, bat_low_wakeup_work);
1102 dev_info(&cw_bat->client->dev, "func: %s-------\n", __func__);
1106 static irqreturn_t bat_low_detect_irq_handler(int irq, void *dev_id)
1108 struct cw_battery *cw_bat = dev_id;
1110 queue_delayed_work(cw_bat->battery_workqueue,
1111 &cw_bat->bat_low_wakeup_work, msecs_to_jiffies(20));
1117 static int cw2015_parse_dt(struct device *dev,
1118 struct cw_bat_platform_data *data)
1120 struct device_node *node = dev->of_node;
1121 enum of_gpio_flags flags;
1122 struct property *prop;
1130 memset(data, 0, sizeof(*data));
1132 /* determine the number of config info */
1133 prop = of_find_property(node, "bat_config_info", &length);
1137 length /= sizeof(u32);
1140 size_t size = sizeof(*data->cw_bat_config_info) * length;
1142 data->cw_bat_config_info = devm_kzalloc(dev, size, GFP_KERNEL);
1143 if (!data->cw_bat_config_info)
1146 ret = of_property_read_u32_array(node, "bat_config_info",
1147 data->cw_bat_config_info,
1153 data->dc_det_pin = of_get_named_gpio_flags(node, "dc_det_gpio", 0,
1155 if (data->dc_det_pin == -EPROBE_DEFER)
1156 pr_info("%s dc_det_gpio error\n", __func__);
1158 if (gpio_is_valid(data->dc_det_pin))
1159 data->dc_det_level =
1160 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1163 data->bat_low_pin = of_get_named_gpio_flags(node, "bat_low_gpio", 0,
1165 if (data->bat_low_pin == -EPROBE_DEFER)
1166 pr_info("%s bat_low_gpio error\n", __func__);
1168 if (gpio_is_valid(data->bat_low_pin))
1169 data->bat_low_level =
1170 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1173 data->chg_ok_pin = of_get_named_gpio_flags(node, "chg_ok_gpio", 0,
1175 if (data->chg_ok_pin == -EPROBE_DEFER)
1176 pr_info("%s chg_ok_gpio error\n", __func__);
1178 if (gpio_is_valid(data->chg_ok_pin))
1179 data->chg_ok_level =
1180 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1183 data->chg_mode_sel_pin =
1184 of_get_named_gpio_flags(node, "chg_mode_sel_gpio", 0, &flags);
1185 if (data->chg_mode_sel_pin == -EPROBE_DEFER)
1186 pr_info("%s chg_mod_sel_gpio error\n", __func__);
1188 if (gpio_is_valid(data->chg_mode_sel_pin))
1189 data->chg_mode_sel_level =
1190 (flags & OF_GPIO_ACTIVE_LOW) ? CW2015_GPIO_LOW :
1193 ret = of_property_read_u32(node, "is_dc_charge", &value);
1195 pr_info("%s:hardware unsupport dc charge\n", __func__);
1198 data->is_dc_charge = value;
1200 ret = of_property_read_u32(node, "is_usb_charge", &value);
1202 pr_info("%s:hardware unsupport usb charge\n", __func__);
1205 data->is_usb_charge = value;
1207 pr_info("cw201x:support %s %s charger\n",
1208 data->is_dc_charge ? "DC" : "",
1209 data->is_usb_charge ? "USB" : "");
1214 static int cw2015_parse_dt(struct device *dev,
1215 struct cw_bat_platform_data *data)
1221 static int cw_bat_probe(struct i2c_client *client,
1222 const struct i2c_device_id *id)
1224 struct cw_battery *cw_bat;
1225 struct cw_bat_platform_data *plat_data = client->dev.platform_data;
1231 cw_bat = devm_kzalloc(&client->dev, sizeof(*cw_bat), GFP_KERNEL);
1233 dev_err(&cw_bat->client->dev,
1234 "fail to allocate memory for cw2015\n");
1237 i2c_set_clientdata(client, cw_bat);
1240 ret = cw2015_parse_dt(&client->dev, &(cw_bat->plat_data));
1242 dev_err(&client->dev,
1243 "failed to find cw2015 platform data\n");
1248 cw_bat->client = client;
1249 ret = cw_bat_gpio_init(cw_bat);
1251 dev_err(&cw_bat->client->dev, "cw_bat_gpio_init error\n");
1255 ret = cw_init(cw_bat);
1257 pr_err("%s cw_init error\n", __func__);
1261 cw_bat->rk_bat.name = "rk-bat";
1262 cw_bat->rk_bat.type = POWER_SUPPLY_TYPE_BATTERY;
1263 cw_bat->rk_bat.properties = rk_battery_properties;
1264 cw_bat->rk_bat.num_properties = ARRAY_SIZE(rk_battery_properties);
1265 cw_bat->rk_bat.get_property = rk_battery_get_property;
1266 ret = power_supply_register(&client->dev, &cw_bat->rk_bat);
1268 dev_err(&cw_bat->client->dev,
1269 "power supply register rk_bat error\n");
1270 goto rk_bat_register_fail;
1273 cw_bat->rk_ac.name = "rk-ac";
1274 cw_bat->rk_ac.type = POWER_SUPPLY_TYPE_MAINS;
1275 cw_bat->rk_ac.properties = rk_ac_properties;
1276 cw_bat->rk_ac.num_properties = ARRAY_SIZE(rk_ac_properties);
1277 cw_bat->rk_ac.get_property = rk_ac_get_property;
1278 ret = power_supply_register(&client->dev, &cw_bat->rk_ac);
1280 dev_err(&cw_bat->client->dev,
1281 "power supply register rk_ac error\n");
1282 goto rk_ac_register_fail;
1285 if (cw_bat->plat_data.is_usb_charge == 1) {
1286 cw_bat->rk_usb.name = "rk-usb";
1287 cw_bat->rk_usb.type = POWER_SUPPLY_TYPE_USB;
1288 cw_bat->rk_usb.properties = rk_usb_properties;
1289 cw_bat->rk_usb.num_properties = ARRAY_SIZE(rk_usb_properties);
1290 cw_bat->rk_usb.get_property = rk_usb_get_property;
1291 ret = power_supply_register(&client->dev, &cw_bat->rk_usb);
1293 dev_err(&cw_bat->client->dev,
1294 "power supply register rk_usb error\n");
1295 goto rk_usb_register_fail;
1297 cw_bat->charger_init_mode = dwc_otg_check_dpdm();
1298 pr_info("%s cw2015 support charger by usb. usb_mode=%d\n",
1299 __func__, cw_bat->charger_init_mode);
1302 cw_bat->dc_online = 0;
1303 cw_bat->usb_online = 0;
1304 cw_bat->charger_mode = 0;
1305 cw_bat->capacity = 2;
1306 cw_bat->voltage = 0;
1308 cw_bat->time_to_empty = 0;
1309 cw_bat->bat_change = 0;
1311 cw_update_time_member_capacity_change(cw_bat);
1312 cw_update_time_member_charge_start(cw_bat);
1314 cw_bat->battery_workqueue = create_singlethread_workqueue("rk_battery");
1315 INIT_DELAYED_WORK(&cw_bat->battery_delay_work, cw_bat_work);
1316 INIT_DELAYED_WORK(&cw_bat->dc_wakeup_work, dc_detect_do_wakeup);
1317 queue_delayed_work(cw_bat->battery_workqueue,
1318 &cw_bat->battery_delay_work, msecs_to_jiffies(10));
1320 if (gpio_is_valid(cw_bat->plat_data.dc_det_pin)) {
1321 irq = gpio_to_irq(cw_bat->plat_data.dc_det_pin);
1322 level = gpio_get_value(cw_bat->plat_data.dc_det_pin);
1323 if (level == cw_bat->plat_data.dc_det_level) {
1324 pr_info("%s booting up with dc plug\n", __func__);
1325 cw_bat->status = POWER_SUPPLY_STATUS_CHARGING;
1327 irq_flags = level ? IRQF_TRIGGER_FALLING : IRQF_TRIGGER_RISING;
1329 request_irq(irq, dc_detect_irq_handler, irq_flags,
1330 "dc_detect", cw_bat);
1332 pr_err("%s: request_irq(%d) failed\n", __func__, irq);
1333 enable_irq_wake(irq);
1336 if (gpio_is_valid(cw_bat->plat_data.bat_low_pin)) {
1337 INIT_DELAYED_WORK(&cw_bat->bat_low_wakeup_work,
1338 bat_low_detect_do_wakeup);
1339 level = gpio_get_value(cw_bat->plat_data.bat_low_pin);
1340 if (level == cw_bat->plat_data.dc_det_level) {
1341 pr_info("%s booting up with lower power\n", __func__);
1342 cw_bat->capacity = 1;
1344 irq = gpio_to_irq(cw_bat->plat_data.bat_low_pin);
1346 request_irq(irq, bat_low_detect_irq_handler,
1347 IRQF_TRIGGER_RISING, "bat_low_detect", cw_bat);
1349 gpio_free(cw_bat->plat_data.bat_low_pin);
1351 enable_irq_wake(irq);
1354 dev_info(&cw_bat->client->dev,
1355 "cw2015/cw2013 driver v1.2 probe sucess\n");
1358 rk_usb_register_fail:
1359 power_supply_unregister(&cw_bat->rk_usb);
1360 rk_ac_register_fail:
1361 power_supply_unregister(&cw_bat->rk_ac);
1362 rk_bat_register_fail:
1363 power_supply_unregister(&cw_bat->rk_bat);
1365 dev_info(&cw_bat->client->dev,
1366 "cw2015/cw2013 driver v1.2 probe error!!!!\n");
1370 static int cw_bat_remove(struct i2c_client *client)
1372 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1374 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1375 cancel_delayed_work(&cw_bat->battery_delay_work);
1380 static int cw_bat_suspend(struct device *dev)
1382 struct i2c_client *client = to_i2c_client(dev);
1383 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1385 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1386 cancel_delayed_work(&cw_bat->battery_delay_work);
1390 static int cw_bat_resume(struct device *dev)
1392 struct i2c_client *client = to_i2c_client(dev);
1393 struct cw_battery *cw_bat = i2c_get_clientdata(client);
1395 dev_dbg(&cw_bat->client->dev, "%s\n", __func__);
1396 queue_delayed_work(cw_bat->battery_workqueue,
1397 &cw_bat->battery_delay_work, msecs_to_jiffies(100));
1401 static const struct i2c_device_id cw_id[] = {
1405 MODULE_DEVICE_TABLE(i2c, cw_id);
1407 static const struct dev_pm_ops cw_bat_pm_ops = {
1408 .suspend = cw_bat_suspend,
1409 .resume = cw_bat_resume,
1413 static struct i2c_driver cw_bat_driver = {
1417 .pm = &cw_bat_pm_ops,
1421 .probe = cw_bat_probe,
1422 .remove = cw_bat_remove,
1426 static int __init cw_bat_init(void)
1428 return i2c_add_driver(&cw_bat_driver);
1431 static void __exit cw_bat_exit(void)
1433 i2c_del_driver(&cw_bat_driver);
1436 fs_initcall(cw_bat_init);
1437 module_exit(cw_bat_exit);
1439 MODULE_AUTHOR("xhc<xhc@rock-chips.com>");
1440 MODULE_DESCRIPTION("cw2015/cw2013 battery driver");
1441 MODULE_LICENSE("GPL");