nathan/CoolPi-Armbian-Rockchip-RK3588-Upstream-Linux-6.1-LTS-Kernel
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
CoolPi-Armbian-Rockchip-RK3.../drivers/power/supply/rk818_charger.c

1890 lines
48 KiB
C
Raw Blame History

/*
* rk818 charger driver
*
* Copyright (C) 2016 Rockchip Electronics Co., Ltd.
* chenjh <chenjh@rock-chips.com>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms and conditions of the GNU General Public License,
* version 2, as published by the Free Software Foundation.
*
* This program is distributed in the hope it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
*/
#include <linux/delay.h>
#include <linux/extcon.h>
#include <linux/gpio.h>
#include <linux/irq.h>
#include <linux/irqdomain.h>
#include <linux/jiffies.h>
#include <linux/kernel.h>
#include <linux/mfd/rk808.h>
#include <linux/module.h>
#include <linux/of_device.h>
#include <linux/of_gpio.h>
#include <linux/platform_device.h>
#include <linux/power_supply.h>
#include <linux/power/rk_usbbc.h>
#include <linux/regmap.h>
#include <linux/rk_keys.h>
#include <linux/rtc.h>
#include <linux/timer.h>
#include <linux/workqueue.h>
#include "rk818_battery.h"
static int dbg_enable = 0;
module_param_named(dbg_level, dbg_enable, int, 0644);
#define DBG(args...) \
do { \
if (dbg_enable) { \
pr_info(args); \
} \
} while (0)
#define CG_INFO(fmt, args...) pr_info("rk818-charger: "fmt, ##args)
#define DEFAULT_CHRG_CURRENT 1400
#define DEFAULT_INPUT_CURRENT 2000
#define DEFAULT_CHRG_VOLTAGE 4200
#define SAMPLE_RES_10MR 10
#define SAMPLE_RES_20MR 20
#define SAMPLE_RES_DIV1 1
#define SAMPLE_RES_DIV2 2
/* RK818_USB_CTRL_REG */
#define INPUT_CUR450MA (0x00)
#define INPUT_CUR80MA (0x01)
#define INPUT_CUR850MA (0x02)
#define INPUT_CUR1500MA (0x05)
#define INPUT_CUR_MSK (0x0f)
/* RK818_CHRG_CTRL_REG3 */
#define CHRG_FINISH_MODE_MSK BIT(5)
#define CHRG_FINISH_ANA_SIGNAL (0)
#define CHRG_FINISH_DIG_SIGNAL BIT(5)
/* RK818_SUP_STS_REG */
#define BAT_EXS BIT(7)
#define USB_VLIMIT_EN BIT(3)
#define USB_CLIMIT_EN BIT(2)
/* RK818_CHRG_CTRL_REG1 */
#define CHRG_EN BIT(7)
#define CHRG_CUR_MSK (0x0f)
/* RK818_INT_STS_MSK_REG2 */
#define CHRG_CVTLMT_INT_MSK BIT(6)
#define PLUG_OUT_MSK BIT(1)
#define PLUG_IN_MSK BIT(0)
/* RK818_VB_MON_REG */
#define PLUG_IN_STS BIT(6)
/* RK818_TS_CTRL_REG */
#define GG_EN BIT(7)
#define TS2_FUN_ADC BIT(5)
/* RK818_ADC_CTRL_REG */
#define ADC_TS2_EN BIT(4)
#define CG_DRIVER_VERSION "2.0"
#define DEFAULT_TS2_THRESHOLD_VOL 4350
#define DEFAULT_TS2_VALID_VOL 1000
#define DEFAULT_TS2_VOL_MULTI 0
#define DEFAULT_TS2_CHECK_CNT 5
enum charger_t {
USB_TYPE_UNKNOWN_CHARGER,
USB_TYPE_NONE_CHARGER,
USB_TYPE_USB_CHARGER,
USB_TYPE_AC_CHARGER,
USB_TYPE_CDP_CHARGER,
DC_TYPE_DC_CHARGER,
DC_TYPE_NONE_CHARGER,
};
enum {
OFFLINE = 0,
ONLINE
};
struct temp_chrg_table {
int temp_down;
int temp_up;
u32 chrg_current;
u8 set_chrg_current;
};
struct charger_platform_data {
u32 max_input_current;
u32 max_chrg_current;
u32 max_chrg_voltage;
u32 pwroff_vol;
u32 power_dc2otg;
u32 dc_det_level;
int dc_det_pin;
bool support_dc_det;
int virtual_power;
int sample_res;
int otg5v_suspend_enable;
bool extcon;
int ts2_vol_multi;
struct temp_chrg_table *tc_table;
u32 tc_count;
};
struct rk818_charger {
struct platform_device *pdev;
struct device *dev;
struct rk808 *rk818;
struct regmap *regmap;
struct power_supply *ac_psy;
struct power_supply *usb_psy;
struct power_supply *bat_psy;
struct extcon_dev *cable_edev;
struct charger_platform_data *pdata;
struct workqueue_struct *usb_charger_wq;
struct workqueue_struct *dc_charger_wq;
struct workqueue_struct *finish_sig_wq;
struct workqueue_struct *ts2_wq;
struct delayed_work dc_work;
struct delayed_work usb_work;
struct delayed_work host_work;
struct delayed_work discnt_work;
struct delayed_work finish_sig_work;
struct delayed_work irq_work;
struct delayed_work ts2_vol_work;
struct notifier_block bc_nb;
struct notifier_block cable_cg_nb;
struct notifier_block cable_host_nb;
struct notifier_block cable_discnt_nb;
struct notifier_block temp_nb;
unsigned int bc_event;
enum charger_t usb_charger;
enum charger_t dc_charger;
struct regulator *otg5v_rdev;
u8 ac_in;
u8 usb_in;
u8 otg_in; /* OTG device attached status */
u8 otg_pmic5v; /* OTG device power supply from PMIC */
u8 dc_in;
u8 prop_status;
u8 chrg_voltage;
u8 chrg_input;
u8 chrg_current;
u8 res_div;
u8 sleep_set_off_reg1;
u8 plugin_trigger;
u8 plugout_trigger;
int plugin_irq;
int plugout_irq;
int charger_changed;
};
static int rk818_reg_read(struct rk818_charger *cg, u8 reg)
{
int ret, val;
ret = regmap_read(cg->regmap, reg, &val);
if (ret)
dev_err(cg->dev, "i2c read reg: 0x%2x failed\n", reg);
return val;
}
static int rk818_reg_write(struct rk818_charger *cg, u8 reg, u8 buf)
{
int ret;
ret = regmap_write(cg->regmap, reg, buf);
if (ret)
dev_err(cg->dev, "i2c write reg: 0x%2x failed\n", reg);
return ret;
}
static int rk818_reg_set_bits(struct rk818_charger *cg, u8 reg, u8 mask, u8 buf)
{
int ret;
ret = regmap_update_bits(cg->regmap, reg, mask, buf);
if (ret)
dev_err(cg->dev, "i2c set reg: 0x%2x failed\n", reg);
return ret;
}
static int rk818_reg_clear_bits(struct rk818_charger *cg, u8 reg, u8 mask)
{
int ret;
ret = regmap_update_bits(cg->regmap, reg, mask, 0);
if (ret)
dev_err(cg->dev, "i2c clr reg: 0x%02x failed\n", reg);
return ret;
}
static int rk818_cg_online(struct rk818_charger *cg)
{
return (cg->ac_in | cg->usb_in | cg->dc_in);
}
static int rk818_cg_get_dsoc(struct rk818_charger *cg)
{
return rk818_reg_read(cg, RK818_SOC_REG);
}
static int rk818_cg_get_avg_current(struct rk818_charger *cg)
{
int cur, val = 0;
val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGL) << 0;
val |= rk818_reg_read(cg, RK818_BAT_CUR_AVG_REGH) << 8;
if (val & 0x800)
val -= 4096;
cur = val * cg->res_div * 1506 / 1000;
return cur;
}
static int rk818_cg_get_ts2_voltage(struct rk818_charger *cg)
{
u32 val = 0;
int voltage;
val |= rk818_reg_read(cg, RK818_TS2_ADC_REGL) << 0;
val |= rk818_reg_read(cg, RK818_TS2_ADC_REGH) << 8;
/* refer voltage 2.2V, 12bit adc accuracy */
voltage = val * 2200 * cg->pdata->ts2_vol_multi / 4095;
DBG("********* ts2 adc=%d, vol=%d\n", val, voltage);
return voltage;
}
static u64 get_boot_sec(void)
{
struct timespec64 ts;
ktime_get_boottime_ts64(&ts);
return ts.tv_sec;
}
static int rk818_cg_lowpwr_check(struct rk818_charger *cg)
{
u8 buf;
static u64 time;
int current_avg, dsoc, fake_offline = 0;
buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
if (!(buf & GG_EN))
return fake_offline;
dsoc = rk818_cg_get_dsoc(cg);
current_avg = rk818_cg_get_avg_current(cg);
if ((current_avg < 0) && (dsoc == 0)) {
if (!time)
time = get_boot_sec();
if ((get_boot_sec() - time) >= 30) {
fake_offline = 1;
CG_INFO("low power....soc=%d, current=%d\n",
dsoc, current_avg);
}
} else {
time = 0;
fake_offline = 0;
}
DBG("<%s>. t=%lld, dsoc=%d, current=%d, fake_offline=%d\n",
__func__, get_boot_sec() - time, dsoc, current_avg, fake_offline);
return fake_offline;
}
static int rk818_cg_get_bat_psy(struct device *dev, void *data)
{
struct rk818_charger *cg = data;
struct power_supply *psy = dev_get_drvdata(dev);
if (psy->desc->type == POWER_SUPPLY_TYPE_BATTERY) {
cg->bat_psy = psy;
return 1;
}
return 0;
}
static void rk818_cg_get_psy(struct rk818_charger *cg)
{
if (!cg->bat_psy)
class_for_each_device(power_supply_class, NULL, (void *)cg,
rk818_cg_get_bat_psy);
}
static int rk818_cg_get_bat_max_cur(struct rk818_charger *cg)
{
union power_supply_propval val;
int ret;
rk818_cg_get_psy(cg);
if (!cg->bat_psy)
return cg->pdata->max_chrg_current;
ret = cg->bat_psy->desc->get_property(cg->bat_psy,
POWER_SUPPLY_PROP_CURRENT_MAX,
&val);
if (!ret && val.intval)
return val.intval;
return cg->pdata->max_chrg_current;
}
static int rk818_cg_get_bat_max_vol(struct rk818_charger *cg)
{
union power_supply_propval val;
int ret;
rk818_cg_get_psy(cg);
if (!cg->bat_psy)
return cg->pdata->max_chrg_voltage;
ret = cg->bat_psy->desc->get_property(cg->bat_psy,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
&val);
if (!ret && val.intval)
return val.intval;
return cg->pdata->max_chrg_voltage;
}
static enum power_supply_property rk818_ac_props[] = {
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_CURRENT_MAX,
};
static enum power_supply_property rk818_usb_props[] = {
POWER_SUPPLY_PROP_ONLINE,
POWER_SUPPLY_PROP_STATUS,
POWER_SUPPLY_PROP_VOLTAGE_MAX,
POWER_SUPPLY_PROP_CURRENT_MAX,
};
static int rk818_cg_ac_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct rk818_charger *cg = power_supply_get_drvdata(psy);
int fake_offline = 0, ret = 0;
if (rk818_cg_online(cg))
fake_offline = rk818_cg_lowpwr_check(cg);
switch (psp) {
case POWER_SUPPLY_PROP_ONLINE:
if (cg->pdata->virtual_power)
val->intval = 1;
else if (fake_offline)
val->intval = 0;
else
val->intval = (cg->ac_in | cg->dc_in);
DBG("report online: %d\n", val->intval);
break;
case POWER_SUPPLY_PROP_STATUS:
if (cg->pdata->virtual_power)
val->intval = POWER_SUPPLY_STATUS_CHARGING;
else if (fake_offline)
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
else
val->intval = cg->prop_status;
DBG("report prop: %d\n", val->intval);
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
val->intval = rk818_cg_get_bat_max_vol(cg);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
val->intval = rk818_cg_get_bat_max_cur(cg);
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
static int rk818_cg_usb_get_property(struct power_supply *psy,
enum power_supply_property psp,
union power_supply_propval *val)
{
struct rk818_charger *cg = power_supply_get_drvdata(psy);
int fake_offline = 0, ret = 0;
if (rk818_cg_online(cg))
fake_offline = rk818_cg_lowpwr_check(cg);
switch (psp) {
case POWER_SUPPLY_PROP_ONLINE:
if (cg->pdata->virtual_power)
val->intval = 1;
else if (fake_offline)
val->intval = 0;
else
val->intval = cg->usb_in;
DBG("report online: %d\n", val->intval);
break;
case POWER_SUPPLY_PROP_STATUS:
if (cg->pdata->virtual_power)
val->intval = POWER_SUPPLY_STATUS_CHARGING;
else if (fake_offline)
val->intval = POWER_SUPPLY_STATUS_DISCHARGING;
else
val->intval = cg->prop_status;
DBG("report prop: %d\n", val->intval);
break;
case POWER_SUPPLY_PROP_VOLTAGE_MAX:
val->intval = rk818_cg_get_bat_max_vol(cg);
break;
case POWER_SUPPLY_PROP_CURRENT_MAX:
val->intval = rk818_cg_get_bat_max_cur(cg);
break;
default:
ret = -EINVAL;
break;
}
return ret;
}
static const struct power_supply_desc rk818_ac_desc = {
.name = "ac",
.type = POWER_SUPPLY_TYPE_MAINS,
.properties = rk818_ac_props,
.num_properties = ARRAY_SIZE(rk818_ac_props),
.get_property = rk818_cg_ac_get_property,
};
static const struct power_supply_desc rk818_usb_desc = {
.name = "usb",
.type = POWER_SUPPLY_TYPE_USB,
.properties = rk818_usb_props,
.num_properties = ARRAY_SIZE(rk818_usb_props),
.get_property = rk818_cg_usb_get_property,
};
static int rk818_cg_init_power_supply(struct rk818_charger *cg)
{
struct power_supply_config psy_cfg = { .drv_data = cg, };
cg->usb_psy = devm_power_supply_register(cg->dev, &rk818_usb_desc,
&psy_cfg);
if (IS_ERR(cg->usb_psy)) {
dev_err(cg->dev, "register usb power supply fail\n");
return PTR_ERR(cg->usb_psy);
}
cg->ac_psy = devm_power_supply_register(cg->dev, &rk818_ac_desc,
&psy_cfg);
if (IS_ERR(cg->ac_psy)) {
dev_err(cg->dev, "register ac power supply fail\n");
return PTR_ERR(cg->ac_psy);
}
return 0;
}
static void rk818_cg_pr_info(struct rk818_charger *cg)
{
u8 usb_ctrl, chrg_ctrl1;
usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
CG_INFO("ac=%d usb=%d dc=%d otg=%d 5v=%d, v=%d chrg=%d input=%d virt=%d\n",
cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in, cg->otg_pmic5v,
chrg_vol_sel_array[(chrg_ctrl1 & 0x70) >> 4],
chrg_cur_sel_array[chrg_ctrl1 & 0x0f] * cg->res_div,
chrg_cur_input_array[usb_ctrl & 0x0f],
cg->pdata->virtual_power);
}
static bool is_battery_exist(struct rk818_charger *cg)
{
return (rk818_reg_read(cg, RK818_SUP_STS_REG) & BAT_EXS) ? true : false;
}
static void rk818_cg_set_chrg_current(struct rk818_charger *cg,
u8 chrg_current)
{
u8 chrg_ctrl_reg1;
chrg_ctrl_reg1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
chrg_ctrl_reg1 &= ~CHRG_CUR_MSK;
chrg_ctrl_reg1 |= (chrg_current);
rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl_reg1);
}
static void rk818_cg_set_input_current(struct rk818_charger *cg,
int input_current)
{
u8 usb_ctrl;
if (cg->pdata->virtual_power) {
CG_INFO("warning: virtual power mode...\n");
input_current = cg->chrg_input;
}
usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
usb_ctrl &= ~INPUT_CUR_MSK;
usb_ctrl |= (input_current);
rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
}
static void rk818_cg_set_finish_sig(struct rk818_charger *cg, int mode)
{
u8 buf;
buf = rk818_reg_read(cg, RK818_CHRG_CTRL_REG3);
buf &= ~CHRG_FINISH_MODE_MSK;
buf |= mode;
rk818_reg_write(cg, RK818_CHRG_CTRL_REG3, buf);
}
static void rk818_cg_finish_sig_work(struct work_struct *work)
{
struct rk818_charger *cg;
cg = container_of(work, struct rk818_charger, finish_sig_work.work);
if (rk818_cg_online(cg))
rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
else
rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
}
static void rk818_cg_set_chrg_param(struct rk818_charger *cg,
enum charger_t charger)
{
u8 buf;
switch (charger) {
case USB_TYPE_NONE_CHARGER:
cg->usb_in = 0;
cg->ac_in = 0;
if (cg->dc_in == 0) {
cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
}
power_supply_changed(cg->usb_psy);
power_supply_changed(cg->ac_psy);
break;
case USB_TYPE_USB_CHARGER:
cg->usb_in = 1;
cg->ac_in = 0;
cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
if (cg->dc_in == 0) {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
}
power_supply_changed(cg->usb_psy);
power_supply_changed(cg->ac_psy);
break;
case USB_TYPE_CDP_CHARGER:
cg->usb_in = 1;
cg->ac_in = 0;
cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
if (cg->dc_in == 0) {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
}
power_supply_changed(cg->usb_psy);
power_supply_changed(cg->ac_psy);
break;
case USB_TYPE_AC_CHARGER:
cg->ac_in = 1;
cg->usb_in = 0;
cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
if (charger == USB_TYPE_AC_CHARGER) {
if (cg->pdata->ts2_vol_multi) {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
queue_delayed_work(cg->ts2_wq,
&cg->ts2_vol_work,
msecs_to_jiffies(0));
} else {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, cg->chrg_input);
}
} else {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR1500MA);
}
power_supply_changed(cg->usb_psy);
power_supply_changed(cg->ac_psy);
break;
case DC_TYPE_DC_CHARGER:
cg->dc_in = 1;
cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
if (cg->pdata->ts2_vol_multi) {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
queue_delayed_work(cg->ts2_wq,
&cg->ts2_vol_work,
msecs_to_jiffies(0));
} else {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, cg->chrg_input);
}
power_supply_changed(cg->usb_psy);
power_supply_changed(cg->ac_psy);
break;
case DC_TYPE_NONE_CHARGER:
cg->dc_in = 0;
buf = rk818_reg_read(cg, RK818_VB_MON_REG);
if ((buf & PLUG_IN_STS) == 0) {
cg->ac_in = 0;
cg->usb_in = 0;
cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
} else if (cg->usb_in) {
rk818_cg_set_chrg_current(cg, cg->chrg_current);
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
cg->prop_status = POWER_SUPPLY_STATUS_CHARGING;
}
power_supply_changed(cg->usb_psy);
power_supply_changed(cg->ac_psy);
break;
default:
cg->prop_status = POWER_SUPPLY_STATUS_DISCHARGING;
break;
}
cg->charger_changed = 1;
if (rk818_cg_online(cg) && rk818_cg_get_dsoc(cg) == 100)
cg->prop_status = POWER_SUPPLY_STATUS_FULL;
if (cg->finish_sig_wq)
queue_delayed_work(cg->finish_sig_wq, &cg->finish_sig_work,
msecs_to_jiffies(1000));
}
static void rk818_cg_set_otg_in(struct rk818_charger *cg, int online)
{
cg->otg_in = online;
}
static void rk818_cg_set_otg_power(struct rk818_charger *cg, int state)
{
int ret;
switch (state) {
case USB_OTG_POWER_ON:
if (cg->otg_pmic5v) {
CG_INFO("otg5v is on yet, ignore..\n");
} else {
if (IS_ERR(cg->otg5v_rdev)) {
CG_INFO("not get otg_switch regulator!\n");
return;
}
if (!regulator_is_enabled(cg->otg5v_rdev)) {
ret = regulator_enable(cg->otg5v_rdev);
if (ret) {
CG_INFO("enable otg5v failed:%d\n",
ret);
return;
}
}
cg->otg_pmic5v = 1;
disable_irq(cg->plugin_irq);
disable_irq(cg->plugout_irq);
CG_INFO("enable otg5v\n");
}
break;
case USB_OTG_POWER_OFF:
if (!cg->otg_pmic5v) {
CG_INFO("otg5v is off yet, ignore..\n");
} else {
if (IS_ERR(cg->otg5v_rdev)) {
CG_INFO("not get otg_switch regulator!\n");
return;
}
if (regulator_is_enabled(cg->otg5v_rdev)) {
ret = regulator_disable(cg->otg5v_rdev);
if (ret) {
CG_INFO("disable otg5v failed: %d\n",
ret);
return;
}
}
cg->otg_pmic5v = 0;
enable_irq(cg->plugin_irq);
enable_irq(cg->plugout_irq);
CG_INFO("disable otg5v\n");
}
break;
default:
dev_err(cg->dev, "error otg type\n");
break;
}
}
static enum charger_t rk818_cg_get_dc_state(struct rk818_charger *cg)
{
int level;
if (!gpio_is_valid(cg->pdata->dc_det_pin))
return DC_TYPE_NONE_CHARGER;
level = gpio_get_value(cg->pdata->dc_det_pin);
return (level == cg->pdata->dc_det_level) ?
DC_TYPE_DC_CHARGER : DC_TYPE_NONE_CHARGER;
}
static void rk818_cg_dc_det_worker(struct work_struct *work)
{
enum charger_t charger;
struct rk818_charger *cg = container_of(work,
struct rk818_charger, dc_work.work);
charger = rk818_cg_get_dc_state(cg);
if (charger == DC_TYPE_DC_CHARGER) {
CG_INFO("detect dc charger in..\n");
rk818_cg_set_chrg_param(cg, DC_TYPE_DC_CHARGER);
/* check otg supply */
if (cg->otg_in && cg->pdata->power_dc2otg) {
CG_INFO("otg power from dc adapter\n");
rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
}
} else {
CG_INFO("detect dc charger out..\n");
rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
/* check otg supply, power on anyway */
if (cg->otg_in)
rk818_cg_set_otg_power(cg, USB_OTG_POWER_ON);
}
rk_send_wakeup_key();
rk818_cg_pr_info(cg);
}
static u8 rk818_cg_decode_chrg_vol(struct rk818_charger *cg, u32 chrg_vol)
{
u8 val = 0, index;
for (index = 0; index < ARRAY_SIZE(chrg_vol_sel_array); index++) {
if (chrg_vol < chrg_vol_sel_array[index])
break;
val = index << 4;
}
return val;
}
static u8 rk818_cg_decode_input_current(struct rk818_charger *cg,
u32 input_current)
{
u8 val = 0, index;
for (index = 2; index < ARRAY_SIZE(chrg_cur_input_array); index++) {
if (input_current < 850 && input_current > 80) {
val = 0x0; /* 450mA */
break;
} else if (input_current <= 80) {
val = 0x1; /* 80mA */
break;
} else {
if (input_current < chrg_cur_input_array[index])
break;
val = index << 0;
}
}
return val;
}
static u8 rk818_cg_decode_chrg_current(struct rk818_charger *cg,
u32 chrg_current)
{
u8 val = 0, index;
if (cg->pdata->sample_res == SAMPLE_RES_10MR) {
if (chrg_current > 2000)
chrg_current /= cg->res_div;
else
chrg_current = 1000;
}
for (index = 0; index < ARRAY_SIZE(chrg_cur_sel_array); index++) {
if (chrg_current < chrg_cur_sel_array[index])
break;
val = index << 0;
}
return val;
}
static void rk818_cg_init_config(struct rk818_charger *cg)
{
u8 usb_ctrl, sup_sts, chrg_ctrl1;
cg->chrg_voltage = rk818_cg_decode_chrg_vol(cg,
cg->pdata->max_chrg_voltage);
cg->chrg_current = rk818_cg_decode_chrg_current(cg,
cg->pdata->max_chrg_current);
cg->chrg_input = rk818_cg_decode_input_current(cg,
cg->pdata->max_input_current);
sup_sts = rk818_reg_read(cg, RK818_SUP_STS_REG);
usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
/* set charge current and voltage */
usb_ctrl &= ~INPUT_CUR_MSK;
usb_ctrl |= cg->chrg_input;
chrg_ctrl1 = (CHRG_EN | cg->chrg_voltage | cg->chrg_current);
/* disable voltage limit and enable input current limit */
sup_sts &= ~USB_VLIMIT_EN;
sup_sts |= USB_CLIMIT_EN;
rk818_reg_write(cg, RK818_SUP_STS_REG, sup_sts);
rk818_reg_write(cg, RK818_USB_CTRL_REG, usb_ctrl);
rk818_reg_write(cg, RK818_CHRG_CTRL_REG1, chrg_ctrl1);
}
static void rk818_ts2_vol_work(struct work_struct *work)
{
struct rk818_charger *cg;
int ts2_vol, input_current, invalid_cnt = 0, confirm_cnt = 0;
cg = container_of(work, struct rk818_charger, ts2_vol_work.work);
input_current = INPUT_CUR80MA;
while (input_current < cg->chrg_input) {
msleep(100);
ts2_vol = rk818_cg_get_ts2_voltage(cg);
/* filter invalid voltage */
if (ts2_vol <= DEFAULT_TS2_VALID_VOL) {
invalid_cnt++;
DBG("%s: invalid ts2 voltage: %d\n, cnt=%d",
__func__, ts2_vol, invalid_cnt);
if (invalid_cnt < DEFAULT_TS2_CHECK_CNT)
continue;
/* if fail, set max input current as default */
input_current = cg->chrg_input;
rk818_cg_set_input_current(cg, input_current);
break;
}
/* update input current */
if (ts2_vol >= DEFAULT_TS2_THRESHOLD_VOL) {
/* update input current */
input_current++;
rk818_cg_set_input_current(cg, input_current);
DBG("********* input=%d\n",
chrg_cur_input_array[input_current & 0x0f]);
} else {
/* confirm lower threshold voltage */
confirm_cnt++;
if (confirm_cnt < DEFAULT_TS2_CHECK_CNT) {
DBG("%s: confirm ts2 voltage: %d\n, cnt=%d",
__func__, ts2_vol, confirm_cnt);
continue;
}
/* trigger threshold, so roll back 1 step */
input_current--;
if (input_current == INPUT_CUR80MA ||
input_current < 0)
input_current = INPUT_CUR450MA;
rk818_cg_set_input_current(cg, input_current);
break;
}
}
if (input_current != cg->chrg_input)
CG_INFO("adjust input current: %dma\n",
chrg_cur_input_array[input_current & 0x0f]);
}
static int rk818_cg_charger_evt_notifier(struct notifier_block *nb,
unsigned long event, void *ptr)
{
struct rk818_charger *cg =
container_of(nb, struct rk818_charger, cable_cg_nb);
queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
msecs_to_jiffies(10));
return NOTIFY_DONE;
}
static int rk818_cg_discnt_evt_notfier(struct notifier_block *nb,
unsigned long event, void *ptr)
{
struct rk818_charger *cg =
container_of(nb, struct rk818_charger, cable_discnt_nb);
queue_delayed_work(cg->usb_charger_wq, &cg->discnt_work,
msecs_to_jiffies(10));
return NOTIFY_DONE;
}
static int rk818_cg_host_evt_notifier(struct notifier_block *nb,
unsigned long event, void *ptr)
{
struct rk818_charger *cg =
container_of(nb, struct rk818_charger, cable_host_nb);
queue_delayed_work(cg->usb_charger_wq, &cg->host_work,
msecs_to_jiffies(10));
return NOTIFY_DONE;
}
static int rk818_cg_bc_evt_notifier(struct notifier_block *nb,
unsigned long event, void *ptr)
{
struct rk818_charger *cg =
container_of(nb, struct rk818_charger, bc_nb);
cg->bc_event = event;
queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
msecs_to_jiffies(10));
return NOTIFY_DONE;
}
static void rk818_cg_bc_evt_worker(struct work_struct *work)
{
struct rk818_charger *cg = container_of(work,
struct rk818_charger, usb_work.work);
const char *event_name[] = {"DISCNT", "USB", "AC", "CDP1.5A",
"UNKNOWN", "OTG ON", "OTG OFF"};
switch (cg->bc_event) {
case USB_BC_TYPE_DISCNT:
rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
break;
case USB_BC_TYPE_SDP:
rk818_cg_set_chrg_param(cg, USB_TYPE_USB_CHARGER);
break;
case USB_BC_TYPE_DCP:
rk818_cg_set_chrg_param(cg, USB_TYPE_AC_CHARGER);
break;
case USB_BC_TYPE_CDP:
rk818_cg_set_chrg_param(cg, USB_TYPE_CDP_CHARGER);
break;
case USB_OTG_POWER_ON:
rk818_cg_set_otg_in(cg, ONLINE);
if (cg->pdata->power_dc2otg && cg->dc_in)
CG_INFO("otg power from dc adapter\n");
else
rk818_cg_set_otg_power(cg, USB_OTG_POWER_ON);
break;
case USB_OTG_POWER_OFF:
rk818_cg_set_otg_in(cg, OFFLINE);
rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
break;
default:
break;
}
CG_INFO("receive bc notifier event: %s..\n", event_name[cg->bc_event]);
rk818_cg_pr_info(cg);
}
static void rk818_cg_irq_delay_work(struct work_struct *work)
{
struct rk818_charger *cg = container_of(work,
struct rk818_charger, irq_work.work);
if (cg->plugin_trigger) {
CG_INFO("pmic: plug in\n");
cg->plugin_trigger = 0;
rk_send_wakeup_key();
if (cg->pdata->extcon)
queue_delayed_work(cg->usb_charger_wq, &cg->usb_work,
msecs_to_jiffies(10));
} else if (cg->plugout_trigger) {
CG_INFO("pmic: plug out\n");
cg->plugout_trigger = 0;
rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
rk818_cg_set_chrg_param(cg, DC_TYPE_NONE_CHARGER);
rk_send_wakeup_key();
rk818_cg_pr_info(cg);
} else {
CG_INFO("pmic: unknown irq\n");
}
}
static irqreturn_t rk818_plug_in_isr(int irq, void *cg)
{
struct rk818_charger *icg;
icg = (struct rk818_charger *)cg;
icg->plugin_trigger = 1;
queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
msecs_to_jiffies(10));
return IRQ_HANDLED;
}
static irqreturn_t rk818_plug_out_isr(int irq, void *cg)
{
struct rk818_charger *icg;
icg = (struct rk818_charger *)cg;
icg->plugout_trigger = 1;
queue_delayed_work(icg->usb_charger_wq, &icg->irq_work,
msecs_to_jiffies(10));
return IRQ_HANDLED;
}
static irqreturn_t rk818_dc_det_isr(int irq, void *charger)
{
struct rk818_charger *cg = (struct rk818_charger *)charger;
if (gpio_get_value(cg->pdata->dc_det_pin))
irq_set_irq_type(irq, IRQF_TRIGGER_LOW);
else
irq_set_irq_type(irq, IRQF_TRIGGER_HIGH);
queue_delayed_work(cg->dc_charger_wq, &cg->dc_work,
msecs_to_jiffies(10));
return IRQ_HANDLED;
}
static int rk818_cg_init_irqs(struct rk818_charger *cg)
{
struct rk808 *rk818 = cg->rk818;
struct platform_device *pdev = cg->pdev;
int ret, plug_in_irq, plug_out_irq;
plug_in_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_IN);
if (plug_in_irq < 0) {
dev_err(cg->dev, "plug_in_irq request failed!\n");
return plug_in_irq;
}
plug_out_irq = regmap_irq_get_virq(rk818->irq_data, RK818_IRQ_PLUG_OUT);
if (plug_out_irq < 0) {
dev_err(cg->dev, "plug_out_irq request failed!\n");
return plug_out_irq;
}
ret = devm_request_threaded_irq(cg->dev, plug_in_irq, NULL,
rk818_plug_in_isr,
IRQF_TRIGGER_RISING,
"rk818_plug_in", cg);
if (ret) {
dev_err(&pdev->dev, "plug_in_irq request failed!\n");
return ret;
}
ret = devm_request_threaded_irq(cg->dev, plug_out_irq, NULL,
rk818_plug_out_isr,
IRQF_TRIGGER_FALLING,
"rk818_plug_out", cg);
if (ret) {
dev_err(&pdev->dev, "plug_out_irq request failed!\n");
return ret;
}
cg->plugin_irq = plug_in_irq;
cg->plugout_irq = plug_out_irq;
INIT_DELAYED_WORK(&cg->irq_work, rk818_cg_irq_delay_work);
return 0;
}
static int rk818_cg_init_dc(struct rk818_charger *cg)
{
int ret, level;
unsigned long irq_flags;
unsigned int dc_det_irq;
cg->dc_charger_wq = alloc_ordered_workqueue("%s",
WQ_MEM_RECLAIM | WQ_FREEZABLE,
"rk818-dc-wq");
INIT_DELAYED_WORK(&cg->dc_work, rk818_cg_dc_det_worker);
cg->dc_charger = DC_TYPE_NONE_CHARGER;
if (!cg->pdata->support_dc_det)
return 0;
ret = devm_gpio_request(cg->dev, cg->pdata->dc_det_pin, "rk818_dc_det");
if (ret < 0) {
dev_err(cg->dev, "failed to request gpio %d\n",
cg->pdata->dc_det_pin);
return ret;
}
ret = gpio_direction_input(cg->pdata->dc_det_pin);
if (ret) {
dev_err(cg->dev, "failed to set gpio input\n");
return ret;
}
level = gpio_get_value(cg->pdata->dc_det_pin);
if (level == cg->pdata->dc_det_level)
cg->dc_charger = DC_TYPE_DC_CHARGER;
else
cg->dc_charger = DC_TYPE_NONE_CHARGER;
if (level)
irq_flags = IRQF_TRIGGER_LOW;
else
irq_flags = IRQF_TRIGGER_HIGH;
dc_det_irq = gpio_to_irq(cg->pdata->dc_det_pin);
ret = devm_request_irq(cg->dev, dc_det_irq, rk818_dc_det_isr,
irq_flags, "rk818_dc_det", cg);
if (ret != 0) {
dev_err(cg->dev, "rk818_dc_det_irq request failed!\n");
return ret;
}
enable_irq_wake(dc_det_irq);
return 0;
}
static void rk818_cg_discnt_evt_worker(struct work_struct *work)
{
struct rk818_charger *cg = container_of(work,
struct rk818_charger, discnt_work.work);
if (extcon_get_state(cg->cable_edev, EXTCON_USB) == 0) {
CG_INFO("receive type-c notifier event: DISCNT...\n");
rk818_cg_set_chrg_param(cg, USB_TYPE_NONE_CHARGER);
rk818_cg_pr_info(cg);
}
}
static void rk818_cg_host_evt_worker(struct work_struct *work)
{
struct rk818_charger *cg = container_of(work,
struct rk818_charger, host_work.work);
struct extcon_dev *edev = cg->cable_edev;
/* Determine charger type */
if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) > 0) {
rk818_cg_set_otg_in(cg, ONLINE);
CG_INFO("receive type-c notifier event: OTG ON...\n");
if (cg->dc_in && cg->pdata->power_dc2otg)
CG_INFO("otg power from dc adapter\n");
else
rk818_cg_set_otg_power(cg, USB_OTG_POWER_ON);
} else if (extcon_get_state(edev, EXTCON_USB_VBUS_EN) == 0) {
CG_INFO("receive type-c notifier event: OTG OFF...\n");
rk818_cg_set_otg_in(cg, OFFLINE);
rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
}
rk818_cg_pr_info(cg);
}
static void rk818_cg_charger_evt_worker(struct work_struct *work)
{
struct rk818_charger *cg = container_of(work,
struct rk818_charger, usb_work.work);
struct extcon_dev *edev = cg->cable_edev;
enum charger_t charger = USB_TYPE_UNKNOWN_CHARGER;
const char *event[] = {"UN", "NONE", "USB", "AC", "CDP1.5A"};
/* Determine charger type */
if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0)
charger = USB_TYPE_USB_CHARGER;
else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0)
charger = USB_TYPE_AC_CHARGER;
else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0)
charger = USB_TYPE_CDP_CHARGER;
if (charger != USB_TYPE_UNKNOWN_CHARGER) {
CG_INFO("receive type-c notifier event: %s...\n",
event[charger]);
cg->usb_charger = charger;
rk818_cg_set_chrg_param(cg, charger);
rk818_cg_pr_info(cg);
}
}
static long rk818_cg_init_usb(struct rk818_charger *cg)
{
enum charger_t charger;
enum bc_port_type bc_type;
struct extcon_dev *edev;
struct device *dev = cg->dev;
int ret;
cg->usb_charger_wq = alloc_ordered_workqueue("%s",
WQ_MEM_RECLAIM | WQ_FREEZABLE,
"rk818-usb-wq");
cg->usb_charger = USB_TYPE_NONE_CHARGER;
/* type-C */
if (cg->pdata->extcon) {
edev = extcon_get_edev_by_phandle(dev->parent, 0);
if (IS_ERR(edev)) {
if (PTR_ERR(edev) != -EPROBE_DEFER)
dev_err(dev, "Invalid or missing extcon\n");
return PTR_ERR(edev);
}
/* Register chargers */
INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_charger_evt_worker);
cg->cable_cg_nb.notifier_call = rk818_cg_charger_evt_notifier;
ret = extcon_register_notifier(edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
if (ret < 0) {
dev_err(dev, "failed to register notifier for SDP\n");
return ret;
}
ret = extcon_register_notifier(edev, EXTCON_CHG_USB_DCP,
&cg->cable_cg_nb);
if (ret < 0) {
dev_err(dev, "failed to register notifier for DCP\n");
extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
return ret;
}
ret = extcon_register_notifier(edev, EXTCON_CHG_USB_CDP,
&cg->cable_cg_nb);
if (ret < 0) {
dev_err(dev, "failed to register notifier for CDP\n");
extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
&cg->cable_cg_nb);
return ret;
}
/* Register host */
INIT_DELAYED_WORK(&cg->host_work, rk818_cg_host_evt_worker);
cg->cable_host_nb.notifier_call = rk818_cg_host_evt_notifier;
ret = extcon_register_notifier(edev, EXTCON_USB_VBUS_EN,
&cg->cable_host_nb);
if (ret < 0) {
dev_err(dev, "failed to register notifier for HOST\n");
extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
&cg->cable_cg_nb);
extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
&cg->cable_cg_nb);
return ret;
}
/* Register discnt usb */
INIT_DELAYED_WORK(&cg->discnt_work, rk818_cg_discnt_evt_worker);
cg->cable_discnt_nb.notifier_call = rk818_cg_discnt_evt_notfier;
ret = extcon_register_notifier(edev, EXTCON_USB,
&cg->cable_discnt_nb);
if (ret < 0) {
dev_err(dev, "failed to register notifier for HOST\n");
extcon_unregister_notifier(edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(edev, EXTCON_CHG_USB_DCP,
&cg->cable_cg_nb);
extcon_unregister_notifier(edev, EXTCON_CHG_USB_CDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(edev, EXTCON_USB_VBUS_EN,
&cg->cable_host_nb);
return ret;
}
cg->cable_edev = edev;
schedule_delayed_work(&cg->host_work, 0);
schedule_delayed_work(&cg->usb_work, 0);
CG_INFO("register typec extcon evt notifier\n");
} else {
INIT_DELAYED_WORK(&cg->usb_work, rk818_cg_bc_evt_worker);
cg->bc_nb.notifier_call = rk818_cg_bc_evt_notifier;
ret = rk_bc_detect_notifier_register(&cg->bc_nb, &bc_type);
if (ret) {
dev_err(dev, "failed to register notifier for bc\n");
return -EINVAL;
}
switch (bc_type) {
case USB_BC_TYPE_DISCNT:
charger = USB_TYPE_NONE_CHARGER;
break;
case USB_BC_TYPE_SDP:
case USB_BC_TYPE_CDP:
charger = USB_TYPE_USB_CHARGER;
break;
case USB_BC_TYPE_DCP:
charger = USB_TYPE_AC_CHARGER;
break;
default:
charger = USB_TYPE_NONE_CHARGER;
break;
}
cg->usb_charger = charger;
CG_INFO("register bc evt notifier\n");
}
return 0;
}
static void rk818_cg_init_finish_sig(struct rk818_charger *cg)
{
if (rk818_cg_online(cg))
rk818_cg_set_finish_sig(cg, CHRG_FINISH_DIG_SIGNAL);
else
rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
cg->finish_sig_wq = alloc_ordered_workqueue("%s",
WQ_MEM_RECLAIM | WQ_FREEZABLE,
"rk818-finish-sig-wq");
INIT_DELAYED_WORK(&cg->finish_sig_work, rk818_cg_finish_sig_work);
}
static void rk818_cg_init_ts2_detect(struct rk818_charger *cg)
{
u8 buf;
cg->ts2_wq = alloc_ordered_workqueue("%s",
WQ_MEM_RECLAIM | WQ_FREEZABLE,
"rk818-ts2-wq");
INIT_DELAYED_WORK(&cg->ts2_vol_work, rk818_ts2_vol_work);
if (!cg->pdata->ts2_vol_multi)
return;
/* TS2 adc mode */
buf = rk818_reg_read(cg, RK818_TS_CTRL_REG);
buf |= TS2_FUN_ADC;
rk818_reg_write(cg, RK818_TS_CTRL_REG, buf);
/* TS2 adc enable */
buf = rk818_reg_read(cg, RK818_ADC_CTRL_REG);
buf |= ADC_TS2_EN;
rk818_reg_write(cg, RK818_ADC_CTRL_REG, buf);
CG_INFO("enable ts2 voltage detect, multi=%d\n",
cg->pdata->ts2_vol_multi);
}
static void rk818_cg_init_charger_state(struct rk818_charger *cg)
{
rk818_cg_init_config(cg);
rk818_cg_init_finish_sig(cg);
rk818_cg_set_chrg_param(cg, cg->dc_charger);
rk818_cg_set_chrg_param(cg, cg->usb_charger);
if (cg->otg_in && cg->dc_in && cg->pdata->power_dc2otg) {
CG_INFO("otg power from dc adapter\n");
rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
}
CG_INFO("ac=%d, usb=%d, dc=%d, otg=%d, 5v=%d\n",
cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in, cg->otg_pmic5v);
}
static int rk818_cg_temperature_notifier_call(struct notifier_block *nb,
unsigned long temp, void *data)
{
struct rk818_charger *cg =
container_of(nb, struct rk818_charger, temp_nb);
static int temp_triggered, config_index = -1;
int i, up_temp, down_temp, cfg_current;
int now_temp = temp;
u8 usb_ctrl, chrg_ctrl1;
DBG("%s: receive notify temperature = %d\n", __func__, now_temp);
for (i = 0; i < cg->pdata->tc_count; i++) {
up_temp = cg->pdata->tc_table[i].temp_up;
down_temp = cg->pdata->tc_table[i].temp_down;
cfg_current = cg->pdata->tc_table[i].chrg_current;
if (now_temp >= down_temp && now_temp <= up_temp) {
/* Temp range or charger are not update, return */
if (config_index == i && !cg->charger_changed)
return NOTIFY_DONE;
config_index = i;
cg->charger_changed = 0;
temp_triggered = 1;
if (cg->pdata->tc_table[i].set_chrg_current) {
rk818_cg_set_chrg_current(cg, cfg_current);
CG_INFO("temperature = %d'C[%d~%d'C], "
"chrg current = %d\n",
now_temp, down_temp, up_temp,
chrg_cur_sel_array[cfg_current] *
cg->res_div);
} else {
rk818_cg_set_input_current(cg, cfg_current);
CG_INFO("temperature = %d'C[%d~%d'C], "
"input current = %d\n",
now_temp, down_temp, up_temp,
chrg_cur_input_array[cfg_current]);
}
return NOTIFY_DONE;
}
}
/*
* means: current temperature not covers above case, temperature rolls
* back to normal range, so restore default value
*/
if (temp_triggered) {
temp_triggered = 0;
config_index = -1;
rk818_cg_set_chrg_current(cg, cg->chrg_current);
if (cg->ac_in || cg->dc_in)
rk818_cg_set_input_current(cg, cg->chrg_input);
else
rk818_cg_set_input_current(cg, INPUT_CUR450MA);
usb_ctrl = rk818_reg_read(cg, RK818_USB_CTRL_REG);
chrg_ctrl1 = rk818_reg_read(cg, RK818_CHRG_CTRL_REG1);
CG_INFO("roll back temp %d'C, current chrg = %d, input = %d\n",
now_temp,
chrg_cur_sel_array[(chrg_ctrl1 & 0x0f)] * cg->res_div,
chrg_cur_input_array[(usb_ctrl & 0x0f)]);
}
return NOTIFY_DONE;
}
static int parse_temperature_chrg_table(struct rk818_charger *cg,
struct device_node *np)
{
int size, count;
int i, chrg_current;
const __be32 *list;
if (!of_find_property(np, "temperature_chrg_table_v2", &size))
return 0;
list = of_get_property(np, "temperature_chrg_table_v2", &size);
size /= sizeof(u32);
if (!size || (size % 3)) {
dev_err(cg->dev,
"invalid temperature_chrg_table: size=%d\n", size);
return -EINVAL;
}
count = size / 3;
cg->pdata->tc_count = count;
cg->pdata->tc_table = devm_kzalloc(cg->dev,
count * sizeof(*cg->pdata->tc_table),
GFP_KERNEL);
if (!cg->pdata->tc_table)
return -ENOMEM;
for (i = 0; i < count; i++) {
/* temperature */
cg->pdata->tc_table[i].temp_down = be32_to_cpu(*list++);
cg->pdata->tc_table[i].temp_up = be32_to_cpu(*list++);
/*
* because charge current lowest level is 1000mA:
* higher than or equal 1000ma, select charge current;
* lower than 1000ma, must select input current.
*/
chrg_current = be32_to_cpu(*list++);
if (chrg_current >= 1000) {
cg->pdata->tc_table[i].set_chrg_current = 1;
cg->pdata->tc_table[i].chrg_current =
rk818_cg_decode_chrg_current(cg, chrg_current);
} else {
cg->pdata->tc_table[i].chrg_current =
rk818_cg_decode_input_current(cg, chrg_current);
}
DBG("temp%d: [%d, %d], chrg_current=%d\n",
i, cg->pdata->tc_table[i].temp_down,
cg->pdata->tc_table[i].temp_up,
cg->pdata->tc_table[i].chrg_current);
}
return 0;
}
static int rk818_cg_register_temp_notifier(struct rk818_charger *cg)
{
int ret;
if (!cg->pdata->tc_count)
return 0;
cg->temp_nb.notifier_call = rk818_cg_temperature_notifier_call,
ret = rk818_bat_temp_notifier_register(&cg->temp_nb);
if (ret) {
dev_err(cg->dev,
"battery temperature notify register failed:%d\n", ret);
return ret;
}
CG_INFO("enable set charge current by temperature\n");
return 0;
}
static int rk818_cg_get_otg5v_regulator(struct rk818_charger *cg)
{
int ret;
/* not necessary */
cg->otg5v_rdev = devm_regulator_get(cg->dev, "otg_switch");
if (IS_ERR(cg->otg5v_rdev)) {
ret = PTR_ERR(cg->otg5v_rdev);
dev_warn(cg->dev, "failed to get otg regulator: %d\n", ret);
}
return 0;
}
#ifdef CONFIG_OF
static int rk818_cg_parse_dt(struct rk818_charger *cg)
{
struct device_node *np;
struct charger_platform_data *pdata;
enum of_gpio_flags flags;
struct device *dev = cg->dev;
int ret;
np = of_find_node_by_name(cg->pdev->dev.of_node, "battery");
if (!np) {
dev_err(dev, "battery node not found!\n");
return -ENODEV;
}
pdata = devm_kzalloc(dev, sizeof(*pdata), GFP_KERNEL);
if (!pdata)
return -ENOMEM;
cg->pdata = pdata;
pdata->max_chrg_current = DEFAULT_CHRG_CURRENT;
pdata->max_input_current = DEFAULT_INPUT_CURRENT;
pdata->max_chrg_voltage = DEFAULT_CHRG_VOLTAGE;
pdata->extcon = device_property_read_bool(dev->parent, "extcon");
ret = of_property_read_u32(np, "max_chrg_current",
&pdata->max_chrg_current);
if (ret < 0)
dev_err(dev, "max_chrg_current missing!\n");
ret = of_property_read_u32(np, "max_input_current",
&pdata->max_input_current);
if (ret < 0)
dev_err(dev, "max_input_current missing!\n");
ret = of_property_read_u32(np, "max_chrg_voltage",
&pdata->max_chrg_voltage);
if (ret < 0)
dev_err(dev, "max_chrg_voltage missing!\n");
ret = of_property_read_u32(np, "virtual_power", &pdata->virtual_power);
if (ret < 0)
dev_err(dev, "virtual_power missing!\n");
ret = of_property_read_u32(np, "power_dc2otg", &pdata->power_dc2otg);
if (ret < 0)
dev_err(dev, "power_dc2otg missing!\n");
ret = of_property_read_u32(np, "sample_res", &pdata->sample_res);
if (ret < 0) {
pdata->sample_res = SAMPLE_RES_20MR;
dev_err(dev, "sample_res missing!\n");
}
ret = of_property_read_u32(np, "otg5v_suspend_enable",
&pdata->otg5v_suspend_enable);
if (ret < 0) {
pdata->otg5v_suspend_enable = 1;
dev_err(dev, "otg5v_suspend_enable missing!\n");
}
ret = of_property_read_u32(np, "ts2_vol_multi",
&pdata->ts2_vol_multi);
if (!is_battery_exist(cg))
pdata->virtual_power = 1;
cg->res_div = (cg->pdata->sample_res == SAMPLE_RES_20MR) ?
SAMPLE_RES_DIV1 : SAMPLE_RES_DIV2;
if (!of_find_property(np, "dc_det_gpio", &ret)) {
pdata->support_dc_det = false;
CG_INFO("not support dc\n");
} else {
pdata->support_dc_det = true;
pdata->dc_det_pin = of_get_named_gpio_flags(np, "dc_det_gpio",
0, &flags);
if (gpio_is_valid(pdata->dc_det_pin)) {
CG_INFO("support dc\n");
pdata->dc_det_level = (flags & OF_GPIO_ACTIVE_LOW) ?
0 : 1;
} else {
dev_err(dev, "invalid dc det gpio!\n");
return -EINVAL;
}
}
ret = parse_temperature_chrg_table(cg, np);
if (ret)
return ret;
DBG("input_current:%d\n"
"chrg_current:%d\n"
"chrg_voltage:%d\n"
"sample_res:%d\n"
"extcon:%d\n"
"ts2_vol_multi:%d\n"
"virtual_power:%d\n"
"power_dc2otg:%d\n",
pdata->max_input_current, pdata->max_chrg_current,
pdata->max_chrg_voltage, pdata->sample_res, pdata->extcon,
pdata->ts2_vol_multi, pdata->virtual_power, pdata->power_dc2otg);
return 0;
}
#else
static int rk818_cg_parse_dt(struct rk818_charger *cg)
{
return -ENODEV;
}
#endif
static int rk818_charger_probe(struct platform_device *pdev)
{
struct rk808 *rk818 = dev_get_drvdata(pdev->dev.parent);
struct rk818_charger *cg;
int ret;
cg = devm_kzalloc(&pdev->dev, sizeof(*cg), GFP_KERNEL);
if (!cg)
return -ENOMEM;
cg->rk818 = rk818;
cg->pdev = pdev;
cg->dev = &pdev->dev;
cg->regmap = rk818->regmap;
platform_set_drvdata(pdev, cg);
ret = rk818_cg_parse_dt(cg);
if (ret < 0) {
dev_err(cg->dev, "parse dt failed!\n");
return ret;
}
rk818_cg_init_ts2_detect(cg);
rk818_cg_get_otg5v_regulator(cg);
ret = rk818_cg_init_dc(cg);
if (ret) {
dev_err(cg->dev, "init dc failed!\n");
return ret;
}
ret = rk818_cg_init_usb(cg);
if (ret) {
dev_err(cg->dev, "init usb failed!\n");
return ret;
}
ret = rk818_cg_init_power_supply(cg);
if (ret) {
dev_err(cg->dev, "init power supply fail!\n");
return ret;
}
rk818_cg_init_charger_state(cg);
ret = rk818_cg_register_temp_notifier(cg);
if (ret) {
dev_err(cg->dev, "register temp notify failed!\n");
goto notify_fail;
}
ret = rk818_cg_init_irqs(cg);
if (ret) {
dev_err(cg->dev, "init irqs failed!\n");
goto irq_fail;
}
CG_INFO("driver version: %s\n", CG_DRIVER_VERSION);
return 0;
irq_fail:
rk818_bat_temp_notifier_unregister(&cg->temp_nb);
notify_fail:
/* type-c only */
if (cg->pdata->extcon) {
cancel_delayed_work_sync(&cg->host_work);
cancel_delayed_work_sync(&cg->discnt_work);
}
cancel_delayed_work_sync(&cg->usb_work);
cancel_delayed_work_sync(&cg->dc_work);
cancel_delayed_work_sync(&cg->finish_sig_work);
cancel_delayed_work_sync(&cg->irq_work);
cancel_delayed_work_sync(&cg->ts2_vol_work);
destroy_workqueue(cg->ts2_wq);
destroy_workqueue(cg->usb_charger_wq);
destroy_workqueue(cg->dc_charger_wq);
destroy_workqueue(cg->finish_sig_wq);
if (cg->pdata->extcon) {
extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
&cg->cable_cg_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
&cg->cable_host_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
&cg->cable_discnt_nb);
} else {
rk_bc_detect_notifier_unregister(&cg->bc_nb);
}
return ret;
}
static void rk818_charger_shutdown(struct platform_device *pdev)
{
struct rk818_charger *cg = platform_get_drvdata(pdev);
/* type-c only */
if (cg->pdata->extcon) {
cancel_delayed_work_sync(&cg->host_work);
cancel_delayed_work_sync(&cg->discnt_work);
}
rk818_cg_set_otg_power(cg, USB_OTG_POWER_OFF);
disable_irq(cg->plugin_irq);
disable_irq(cg->plugout_irq);
cancel_delayed_work_sync(&cg->usb_work);
cancel_delayed_work_sync(&cg->dc_work);
cancel_delayed_work_sync(&cg->finish_sig_work);
cancel_delayed_work_sync(&cg->irq_work);
cancel_delayed_work_sync(&cg->ts2_vol_work);
flush_workqueue(cg->ts2_wq);
flush_workqueue(cg->usb_charger_wq);
flush_workqueue(cg->dc_charger_wq);
flush_workqueue(cg->finish_sig_wq);
if (cg->pdata->extcon) {
extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_SDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_DCP,
&cg->cable_cg_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_CHG_USB_CDP,
&cg->cable_cg_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_USB_VBUS_EN,
&cg->cable_host_nb);
extcon_unregister_notifier(cg->cable_edev, EXTCON_USB,
&cg->cable_discnt_nb);
} else {
rk_bc_detect_notifier_unregister(&cg->bc_nb);
}
rk818_bat_temp_notifier_unregister(&cg->temp_nb);
rk818_cg_set_finish_sig(cg, CHRG_FINISH_ANA_SIGNAL);
CG_INFO("shutdown: ac=%d usb=%d dc=%d otg=%d 5v=%d\n",
cg->ac_in, cg->usb_in, cg->dc_in, cg->otg_in, cg->otg_pmic5v);
}
static int rk818_charger_suspend(struct platform_device *pdev,
pm_message_t state)
{
struct rk818_charger *cg = platform_get_drvdata(pdev);
cg->sleep_set_off_reg1 = rk818_reg_read(cg, RK818_SLEEP_SET_OFF_REG1);
/* enable sleep boost5v and otg5v */
if (cg->pdata->otg5v_suspend_enable) {
if ((cg->otg_in && !cg->dc_in) ||
(cg->otg_in && cg->dc_in && !cg->pdata->power_dc2otg)) {
rk818_reg_clear_bits(cg, RK818_SLEEP_SET_OFF_REG1,
OTG_BOOST_SLP_OFF);
CG_INFO("suspend: otg 5v on\n");
return 0;
}
}
/* disable sleep otg5v */
rk818_reg_set_bits(cg, RK818_SLEEP_SET_OFF_REG1,
OTG_SLP_SET_OFF, OTG_SLP_SET_OFF);
CG_INFO("suspend: otg 5v off\n");
return 0;
}
static int rk818_charger_resume(struct platform_device *pdev)
{
struct rk818_charger *cg = platform_get_drvdata(pdev);
/* resume sleep boost5v and otg5v */
rk818_reg_set_bits(cg, RK818_SLEEP_SET_OFF_REG1,
OTG_BOOST_SLP_OFF, cg->sleep_set_off_reg1);
return 0;
}
static struct platform_driver rk818_charger_driver = {
.probe = rk818_charger_probe,
.suspend = rk818_charger_suspend,
.resume = rk818_charger_resume,
.shutdown = rk818_charger_shutdown,
.driver = {
.name = "rk818-charger",
},
};
static int __init charger_init(void)
{
return platform_driver_register(&rk818_charger_driver);
}
module_init(charger_init);
static void __exit charger_exit(void)
{
platform_driver_unregister(&rk818_charger_driver);
}
module_exit(charger_exit);
MODULE_LICENSE("GPL");
MODULE_ALIAS("platform:rk818-charger");
MODULE_AUTHOR("chenjh<chenjh@rock-chips.com>");
Reference in New Issue View Git Blame Copy Permalink