Release 4.11 drivers/power/supply/axp288_charger.c

/*
 * axp288_charger.c - X-power AXP288 PMIC Charger driver
 *
 * Copyright (C) 2014 Intel Corporation
 * Author: Ramakrishna Pallala <ramakrishna.pallala@intel.com>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * This program is distributed in the hope that 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/module.h>
#include <linux/device.h>
#include <linux/regmap.h>
#include <linux/workqueue.h>
#include <linux/delay.h>
#include <linux/platform_device.h>
#include <linux/usb/otg.h>
#include <linux/notifier.h>
#include <linux/power_supply.h>
#include <linux/property.h>
#include <linux/mfd/axp20x.h>
#include <linux/extcon.h>


#define PS_STAT_VBUS_TRIGGER		(1 << 0)

#define PS_STAT_BAT_CHRG_DIR		(1 << 2)

#define PS_STAT_VBAT_ABOVE_VHOLD	(1 << 3)

#define PS_STAT_VBUS_VALID		(1 << 4)

#define PS_STAT_VBUS_PRESENT		(1 << 5)


#define CHRG_STAT_BAT_SAFE_MODE		(1 << 3)

#define CHRG_STAT_BAT_VALID		(1 << 4)

#define CHRG_STAT_BAT_PRESENT		(1 << 5)

#define CHRG_STAT_CHARGING		(1 << 6)

#define CHRG_STAT_PMIC_OTP		(1 << 7)


#define VBUS_ISPOUT_CUR_LIM_MASK	0x03

#define VBUS_ISPOUT_CUR_LIM_BIT_POS	0

#define VBUS_ISPOUT_CUR_LIM_900MA	0x0	
/* 900mA */

#define VBUS_ISPOUT_CUR_LIM_1500MA	0x1	
/* 1500mA */

#define VBUS_ISPOUT_CUR_LIM_2000MA	0x2	
/* 2000mA */

#define VBUS_ISPOUT_CUR_NO_LIM		0x3	
/* 2500mA */

#define VBUS_ISPOUT_VHOLD_SET_MASK	0x31

#define VBUS_ISPOUT_VHOLD_SET_BIT_POS	0x3

#define VBUS_ISPOUT_VHOLD_SET_OFFSET	4000	
/* 4000mV */

#define VBUS_ISPOUT_VHOLD_SET_LSB_RES	100	
/* 100mV */

#define VBUS_ISPOUT_VHOLD_SET_4300MV	0x3	
/* 4300mV */

#define VBUS_ISPOUT_VBUS_PATH_DIS	(1 << 7)


#define CHRG_CCCV_CC_MASK		0xf		
/* 4 bits */

#define CHRG_CCCV_CC_BIT_POS		0

#define CHRG_CCCV_CC_OFFSET		200		
/* 200mA */

#define CHRG_CCCV_CC_LSB_RES		200		
/* 200mA */

#define CHRG_CCCV_ITERM_20P		(1 << 4)	
/* 20% of CC */

#define CHRG_CCCV_CV_MASK		0x60		
/* 2 bits */

#define CHRG_CCCV_CV_BIT_POS		5

#define CHRG_CCCV_CV_4100MV		0x0		
/* 4.10V */

#define CHRG_CCCV_CV_4150MV		0x1		
/* 4.15V */

#define CHRG_CCCV_CV_4200MV		0x2		
/* 4.20V */

#define CHRG_CCCV_CV_4350MV		0x3		
/* 4.35V */

#define CHRG_CCCV_CHG_EN		(1 << 7)


#define CNTL2_CC_TIMEOUT_MASK		0x3	
/* 2 bits */

#define CNTL2_CC_TIMEOUT_OFFSET		6	
/* 6 Hrs */

#define CNTL2_CC_TIMEOUT_LSB_RES	2	
/* 2 Hrs */

#define CNTL2_CC_TIMEOUT_12HRS		0x3	
/* 12 Hrs */

#define CNTL2_CHGLED_TYPEB		(1 << 4)

#define CNTL2_CHG_OUT_TURNON		(1 << 5)

#define CNTL2_PC_TIMEOUT_MASK		0xC0

#define CNTL2_PC_TIMEOUT_OFFSET		40	
/* 40 mins */

#define CNTL2_PC_TIMEOUT_LSB_RES	10	
/* 10 mins */

#define CNTL2_PC_TIMEOUT_70MINS		0x3


#define CHRG_ILIM_TEMP_LOOP_EN		(1 << 3)

#define CHRG_VBUS_ILIM_MASK		0xf0

#define CHRG_VBUS_ILIM_BIT_POS		4

#define CHRG_VBUS_ILIM_100MA		0x0	
/* 100mA */

#define CHRG_VBUS_ILIM_500MA		0x1	
/* 500mA */

#define CHRG_VBUS_ILIM_900MA		0x2	
/* 900mA */

#define CHRG_VBUS_ILIM_1500MA		0x3	
/* 1500mA */

#define CHRG_VBUS_ILIM_2000MA		0x4	
/* 2000mA */

#define CHRG_VBUS_ILIM_2500MA		0x5	
/* 2500mA */

#define CHRG_VBUS_ILIM_3000MA		0x6	
/* 3000mA */


#define CHRG_VLTFC_0C			0xA5	
/* 0 DegC */

#define CHRG_VHTFC_45C			0x1F	
/* 45 DegC */


#define FG_CNTL_OCV_ADJ_EN		(1 << 3)


#define CV_4100MV			4100	
/* 4100mV */

#define CV_4150MV			4150	
/* 4150mV */

#define CV_4200MV			4200	
/* 4200mV */

#define CV_4350MV			4350	
/* 4350mV */


#define CC_200MA			200	
/*  200mA */

#define CC_600MA			600	
/*  600mA */

#define CC_800MA			800	
/*  800mA */

#define CC_1000MA			1000	
/* 1000mA */

#define CC_1600MA			1600	
/* 1600mA */

#define CC_2000MA			2000	
/* 2000mA */


#define ILIM_100MA			100	
/* 100mA */

#define ILIM_500MA			500	
/* 500mA */

#define ILIM_900MA			900	
/* 900mA */

#define ILIM_1500MA			1500	
/* 1500mA */

#define ILIM_2000MA			2000	
/* 2000mA */

#define ILIM_2500MA			2500	
/* 2500mA */

#define ILIM_3000MA			3000	
/* 3000mA */


#define AXP288_EXTCON_DEV_NAME		"axp288_extcon"

#define USB_HOST_EXTCON_DEV_NAME	"INT3496:00"


static const unsigned int cable_ids[] =
	{ EXTCON_CHG_USB_SDP, EXTCON_CHG_USB_CDP, EXTCON_CHG_USB_DCP };

enum {
	
VBUS_OV_IRQ = 0,
	
CHARGE_DONE_IRQ,
	
CHARGE_CHARGING_IRQ,
	
BAT_SAFE_QUIT_IRQ,
	
BAT_SAFE_ENTER_IRQ,
	
QCBTU_IRQ,
	
CBTU_IRQ,
	
QCBTO_IRQ,
	
CBTO_IRQ,
	
CHRG_INTR_END,
};


struct axp288_chrg_info {
	
struct platform_device *pdev;
	
struct regmap *regmap;
	
struct regmap_irq_chip_data *regmap_irqc;
	
int irq[CHRG_INTR_END];
	
struct power_supply *psy_usb;
	
struct mutex lock;

	/* OTG/Host mode */
	struct {
		
struct work_struct work;
		
struct extcon_dev *cable;
		
struct notifier_block id_nb;
		
bool id_short;
	} 
otg;

	/* SDP/CDP/DCP USB charging cable notifications */
	struct {
		
struct extcon_dev *edev;
		
bool connected;
		
enum power_supply_type chg_type;
		
struct notifier_block nb[ARRAY_SIZE(cable_ids)];
		
struct work_struct work;
	} 
cable;

	
int inlmt;
	
int cc;
	
int cv;
	
int max_cc;
	
int max_cv;
	
int is_charger_enabled;
};



static inline int axp288_charger_set_cc(struct axp288_chrg_info *info, int cc)
{
	u8 reg_val;
	int ret;

	if (cc < CHRG_CCCV_CC_OFFSET)
		cc = CHRG_CCCV_CC_OFFSET;
	else if (cc > info->max_cc)
		cc = info->max_cc;

	reg_val = (cc - CHRG_CCCV_CC_OFFSET) / CHRG_CCCV_CC_LSB_RES;
	cc = (reg_val * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
	reg_val = reg_val << CHRG_CCCV_CC_BIT_POS;

	ret = regmap_update_bits(info->regmap,
				AXP20X_CHRG_CTRL1,
				CHRG_CCCV_CC_MASK, reg_val);
	if (ret >= 0)
		info->cc = cc;

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
102
100.00%
1
100.00%
Total
102
100.00%
1
100.00%



static inline int axp288_charger_set_cv(struct axp288_chrg_info *info, int cv)
{
	u8 reg_val;
	int ret;

	if (cv <= CV_4100MV) {
		reg_val = CHRG_CCCV_CV_4100MV;
		cv = CV_4100MV;
	} else if (cv <= CV_4150MV) {
		reg_val = CHRG_CCCV_CV_4150MV;
		cv = CV_4150MV;
	} else if (cv <= CV_4200MV) {
		reg_val = CHRG_CCCV_CV_4200MV;
		cv = CV_4200MV;
	} else {
		reg_val = CHRG_CCCV_CV_4350MV;
		cv = CV_4350MV;
	}

	reg_val = reg_val << CHRG_CCCV_CV_BIT_POS;

	ret = regmap_update_bits(info->regmap,
				AXP20X_CHRG_CTRL1,
				CHRG_CCCV_CV_MASK, reg_val);

	if (ret >= 0)
		info->cv = cv;

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
118
100.00%
1
100.00%
Total
118
100.00%
1
100.00%



static inline int axp288_charger_set_vbus_inlmt(struct axp288_chrg_info *info,
					   int inlmt)
{
	int ret;
	unsigned int val;
	u8 reg_val;

	/* Read in limit register */
	ret = regmap_read(info->regmap, AXP20X_CHRG_BAK_CTRL, &val);
	if (ret < 0)
		goto set_inlmt_fail;

	if (inlmt <= ILIM_100MA) {
		reg_val = CHRG_VBUS_ILIM_100MA;
		inlmt = ILIM_100MA;
	} else if (inlmt <= ILIM_500MA) {
		reg_val = CHRG_VBUS_ILIM_500MA;
		inlmt = ILIM_500MA;
	} else if (inlmt <= ILIM_900MA) {
		reg_val = CHRG_VBUS_ILIM_900MA;
		inlmt = ILIM_900MA;
	} else if (inlmt <= ILIM_1500MA) {
		reg_val = CHRG_VBUS_ILIM_1500MA;
		inlmt = ILIM_1500MA;
	} else if (inlmt <= ILIM_2000MA) {
		reg_val = CHRG_VBUS_ILIM_2000MA;
		inlmt = ILIM_2000MA;
	} else if (inlmt <= ILIM_2500MA) {
		reg_val = CHRG_VBUS_ILIM_2500MA;
		inlmt = ILIM_2500MA;
	} else {
		reg_val = CHRG_VBUS_ILIM_3000MA;
		inlmt = ILIM_3000MA;
	}

	reg_val = (val & ~CHRG_VBUS_ILIM_MASK)
			| (reg_val << CHRG_VBUS_ILIM_BIT_POS);
	ret = regmap_write(info->regmap, AXP20X_CHRG_BAK_CTRL, reg_val);
	if (ret >= 0)
		info->inlmt = inlmt;
	else
		dev_err(&info->pdev->dev, "charger BAK control %d\n", ret);


set_inlmt_fail:
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
221
100.00%
1
100.00%
Total
221
100.00%
1
100.00%



static int axp288_charger_vbus_path_select(struct axp288_chrg_info *info,
								bool enable)
{
	int ret;

	if (enable)
		ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
					VBUS_ISPOUT_VBUS_PATH_DIS, 0);
	else
		ret = regmap_update_bits(info->regmap, AXP20X_VBUS_IPSOUT_MGMT,
			VBUS_ISPOUT_VBUS_PATH_DIS, VBUS_ISPOUT_VBUS_PATH_DIS);

	if (ret < 0)
		dev_err(&info->pdev->dev, "axp288 vbus path select %d\n", ret);


	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
75
100.00%
1
100.00%
Total
75
100.00%
1
100.00%



static int axp288_charger_enable_charger(struct axp288_chrg_info *info,
								bool enable)
{
	int ret;

	if ((int)enable == info->is_charger_enabled)
		return 0;

	if (enable)
		ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
				CHRG_CCCV_CHG_EN, CHRG_CCCV_CHG_EN);
	else
		ret = regmap_update_bits(info->regmap, AXP20X_CHRG_CTRL1,
				CHRG_CCCV_CHG_EN, 0);
	if (ret < 0)
		dev_err(&info->pdev->dev, "axp288 enable charger %d\n", ret);
	else
		info->is_charger_enabled = enable;

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
82
85.42%
1
33.33%
Hans de Goede
14
14.58%
2
66.67%
Total
96
100.00%
3
100.00%



static int axp288_charger_is_present(struct axp288_chrg_info *info)
{
	int ret, present = 0;
	unsigned int val;

	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
	if (ret < 0)
		return ret;

	if (val & PS_STAT_VBUS_PRESENT)
		present = 1;
	return present;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%



static int axp288_charger_is_online(struct axp288_chrg_info *info)
{
	int ret, online = 0;
	unsigned int val;

	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
	if (ret < 0)
		return ret;

	if (val & PS_STAT_VBUS_VALID)
		online = 1;
	return online;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
58
100.00%
1
100.00%
Total
58
100.00%
1
100.00%



static int axp288_get_charger_health(struct axp288_chrg_info *info)
{
	int ret, pwr_stat, chrg_stat;
	int health = POWER_SUPPLY_HEALTH_UNKNOWN;
	unsigned int val;

	ret = regmap_read(info->regmap, AXP20X_PWR_INPUT_STATUS, &val);
	if ((ret < 0) || !(val & PS_STAT_VBUS_PRESENT))
		goto health_read_fail;
	else
		pwr_stat = val;

	ret = regmap_read(info->regmap, AXP20X_PWR_OP_MODE, &val);
	if (ret < 0)
		goto health_read_fail;
	else
		chrg_stat = val;

	if (!(pwr_stat & PS_STAT_VBUS_VALID))
		health = POWER_SUPPLY_HEALTH_DEAD;
	else if (chrg_stat & CHRG_STAT_PMIC_OTP)
		health = POWER_SUPPLY_HEALTH_OVERHEAT;
	else if (chrg_stat & CHRG_STAT_BAT_SAFE_MODE)
		health = POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE;
	else
		health = POWER_SUPPLY_HEALTH_GOOD;

health_read_fail:
	return health;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
137
100.00%
1
100.00%
Total
137
100.00%
1
100.00%



static int axp288_charger_usb_set_property(struct power_supply *psy,
				    enum power_supply_property psp,
				    const union power_supply_propval *val)
{
	struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
	int ret = 0;
	int scaled_val;

	mutex_lock(&info->lock);

	switch (psp) {
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
		scaled_val = min(val->intval, info->max_cc);
		scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
		ret = axp288_charger_set_cc(info, scaled_val);
		if (ret < 0)
			dev_warn(&info->pdev->dev, "set charge current failed\n");
		break;
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
		scaled_val = min(val->intval, info->max_cv);
		scaled_val = DIV_ROUND_CLOSEST(scaled_val, 1000);
		ret = axp288_charger_set_cv(info, scaled_val);
		if (ret < 0)
			dev_warn(&info->pdev->dev, "set charge voltage failed\n");
		break;
	default:
		ret = -EINVAL;
	}

	mutex_unlock(&info->lock);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
176
100.00%
1
100.00%
Total
176
100.00%
1
100.00%



static int axp288_charger_usb_get_property(struct power_supply *psy,
				    enum power_supply_property psp,
				    union power_supply_propval *val)
{
	struct axp288_chrg_info *info = power_supply_get_drvdata(psy);
	int ret = 0;

	mutex_lock(&info->lock);

	switch (psp) {
	case POWER_SUPPLY_PROP_PRESENT:
		/* Check for OTG case first */
		if (info->otg.id_short) {
			val->intval = 0;
			break;
		}
		ret = axp288_charger_is_present(info);
		if (ret < 0)
			goto psy_get_prop_fail;
		val->intval = ret;
		break;
	case POWER_SUPPLY_PROP_ONLINE:
		/* Check for OTG case first */
		if (info->otg.id_short) {
			val->intval = 0;
			break;
		}
		ret = axp288_charger_is_online(info);
		if (ret < 0)
			goto psy_get_prop_fail;
		val->intval = ret;
		break;
	case POWER_SUPPLY_PROP_HEALTH:
		val->intval = axp288_get_charger_health(info);
		break;
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
		val->intval = info->cc * 1000;
		break;
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
		val->intval = info->max_cc * 1000;
		break;
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
		val->intval = info->cv * 1000;
		break;
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
		val->intval = info->max_cv * 1000;
		break;
	case POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT:
		val->intval = info->inlmt * 1000;
		break;
	default:
		ret = -EINVAL;
		goto psy_get_prop_fail;
	}

psy_get_prop_fail:
	mutex_unlock(&info->lock);
	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
240
99.17%
1
50.00%
Hans de Goede
2
0.83%
1
50.00%
Total
242
100.00%
2
100.00%



static int axp288_charger_property_is_writeable(struct power_supply *psy,
		enum power_supply_property psp)
{
	int ret;

	switch (psp) {
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT:
	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE:
		ret = 1;
		break;
	default:
		ret = 0;
	}

	return ret;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
43
100.00%
1
100.00%
Total
43
100.00%
1
100.00%


static enum power_supply_property axp288_usb_props[] = {
	POWER_SUPPLY_PROP_PRESENT,
	POWER_SUPPLY_PROP_ONLINE,
	POWER_SUPPLY_PROP_TYPE,
	POWER_SUPPLY_PROP_HEALTH,
	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT,
	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE,
	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
	POWER_SUPPLY_PROP_CHARGE_CONTROL_LIMIT,
};


static const struct power_supply_desc axp288_charger_desc = {
	.name			= "axp288_charger",
	.type			= POWER_SUPPLY_TYPE_USB,
	.properties		= axp288_usb_props,
	.num_properties		= ARRAY_SIZE(axp288_usb_props),
	.get_property		= axp288_charger_usb_get_property,
	.set_property		= axp288_charger_usb_set_property,
	.property_is_writeable	= axp288_charger_property_is_writeable,
};



static irqreturn_t axp288_charger_irq_thread_handler(int irq, void *dev)
{
	struct axp288_chrg_info *info = dev;
	int i;

	for (i = 0; i < CHRG_INTR_END; i++) {
		if (info->irq[i] == irq)
			break;
	}

	if (i >= CHRG_INTR_END) {
		dev_warn(&info->pdev->dev, "spurious interrupt!!\n");
		return IRQ_NONE;
	}

	switch (i) {
	case VBUS_OV_IRQ:
		dev_dbg(&info->pdev->dev, "VBUS Over Voltage INTR\n");
		break;
	case CHARGE_DONE_IRQ:
		dev_dbg(&info->pdev->dev, "Charging Done INTR\n");
		break;
	case CHARGE_CHARGING_IRQ:
		dev_dbg(&info->pdev->dev, "Start Charging IRQ\n");
		break;
	case BAT_SAFE_QUIT_IRQ:
		dev_dbg(&info->pdev->dev,
			"Quit Safe Mode(restart timer) Charging IRQ\n");
		break;
	case BAT_SAFE_ENTER_IRQ:
		dev_dbg(&info->pdev->dev,
			"Enter Safe Mode(timer expire) Charging IRQ\n");
		break;
	case QCBTU_IRQ:
		dev_dbg(&info->pdev->dev,
			"Quit Battery Under Temperature(CHRG) INTR\n");
		break;
	case CBTU_IRQ:
		dev_dbg(&info->pdev->dev,
			"Hit Battery Under Temperature(CHRG) INTR\n");
		break;
	case QCBTO_IRQ:
		dev_dbg(&info->pdev->dev,
			"Quit Battery Over Temperature(CHRG) INTR\n");
		break;
	case CBTO_IRQ:
		dev_dbg(&info->pdev->dev,
			"Hit Battery Over Temperature(CHRG) INTR\n");
		break;
	default:
		dev_warn(&info->pdev->dev, "Spurious Interrupt!!!\n");
		goto out;
	}

	power_supply_changed(info->psy_usb);
out:
	return IRQ_HANDLED;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
251
100.00%
1
100.00%
Total
251
100.00%
1
100.00%



static void axp288_charger_extcon_evt_worker(struct work_struct *work)
{
	struct axp288_chrg_info *info =
	    container_of(work, struct axp288_chrg_info, cable.work);
	int ret, current_limit;
	struct extcon_dev *edev = info->cable.edev;
	bool old_connected = info->cable.connected;
	enum power_supply_type old_chg_type = info->cable.chg_type;

	/* Determine cable/charger type */
	if (extcon_get_state(edev, EXTCON_CHG_USB_SDP) > 0) {
		dev_dbg(&info->pdev->dev, "USB SDP charger  is connected");
		info->cable.connected = true;
		info->cable.chg_type = POWER_SUPPLY_TYPE_USB;
	} else if (extcon_get_state(edev, EXTCON_CHG_USB_CDP) > 0) {
		dev_dbg(&info->pdev->dev, "USB CDP charger is connected");
		info->cable.connected = true;
		info->cable.chg_type = POWER_SUPPLY_TYPE_USB_CDP;
	} else if (extcon_get_state(edev, EXTCON_CHG_USB_DCP) > 0) {
		dev_dbg(&info->pdev->dev, "USB DCP charger is connected");
		info->cable.connected = true;
		info->cable.chg_type = POWER_SUPPLY_TYPE_USB_DCP;
	} else {
		if (old_connected)
			dev_dbg(&info->pdev->dev, "USB charger disconnected");
		info->cable.connected = false;
		info->cable.chg_type = POWER_SUPPLY_TYPE_USB;
	}

	/* Cable status changed */
	if (old_connected == info->cable.connected &&
	    old_chg_type == info->cable.chg_type)
		return;

	mutex_lock(&info->lock);

	if (info->cable.connected) {
		axp288_charger_enable_charger(info, false);

		switch (info->cable.chg_type) {
		case POWER_SUPPLY_TYPE_USB:
			current_limit = ILIM_500MA;
			break;
		case POWER_SUPPLY_TYPE_USB_CDP:
			current_limit = ILIM_1500MA;
			break;
		case POWER_SUPPLY_TYPE_USB_DCP:
			current_limit = ILIM_2000MA;
			break;
		default:
			/* Unknown */
			current_limit = 0;
			break;
		}

		/* Set vbus current limit first, then enable charger */
		ret = axp288_charger_set_vbus_inlmt(info, current_limit);
		if (ret == 0)
			axp288_charger_enable_charger(info, true);
		else
			dev_err(&info->pdev->dev,
				"error setting current limit (%d)", ret);
	} else {
		axp288_charger_enable_charger(info, false);
	}

	mutex_unlock(&info->lock);

	power_supply_changed(info->psy_usb);
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
337
90.35%
1
20.00%
Hans de Goede
30
8.04%
2
40.00%
Chanwoo Choi
6
1.61%
2
40.00%
Total
373
100.00%
5
100.00%

/*
 * We need 3 copies of this, because there is no way to find out for which
 * cable id we are being called from the passed in arguments; and we must
 * have a separate nb for each extcon_register_notifier call.
 */


static int axp288_charger_handle_cable0_evt(struct notifier_block *nb,
					    unsigned long event, void *param)
{
	struct axp288_chrg_info *info =
		container_of(nb, struct axp288_chrg_info, cable.nb[0]);
	schedule_work(&info->cable.work);
	return NOTIFY_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hans de Goede
52
100.00%
1
100.00%
Total
52
100.00%
1
100.00%



static int axp288_charger_handle_cable1_evt(struct notifier_block *nb,
					    unsigned long event, void *param)
{
	struct axp288_chrg_info *info =
		container_of(nb, struct axp288_chrg_info, cable.nb[1]);
	schedule_work(&info->cable.work);
	return NOTIFY_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
32
61.54%
1
50.00%
Hans de Goede
20
38.46%
1
50.00%
Total
52
100.00%
2
100.00%



static int axp288_charger_handle_cable2_evt(struct notifier_block *nb,
					    unsigned long event, void *param)
{
	struct axp288_chrg_info *info =
		container_of(nb, struct axp288_chrg_info, cable.nb[2]);
	schedule_work(&info->cable.work);
	return NOTIFY_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Hans de Goede
36
69.23%
1
50.00%
Ramakrishna Pallala
16
30.77%
1
50.00%
Total
52
100.00%
2
100.00%



static void axp288_charger_otg_evt_worker(struct work_struct *work)
{
	struct axp288_chrg_info *info =
	    container_of(work, struct axp288_chrg_info, otg.work);
	struct extcon_dev *edev = info->otg.cable;
	int ret, usb_host = extcon_get_state(edev, EXTCON_USB_HOST);

	dev_dbg(&info->pdev->dev, "external connector USB-Host is %s\n",
				usb_host ? "attached" : "detached");

	/*
         * Set usb_id_short flag to avoid running charger detection logic
         * in case usb host.
         */
	info->otg.id_short = usb_host;

	/* Disable VBUS path before enabling the 5V boost */
	ret = axp288_charger_vbus_path_select(info, !info->otg.id_short);
	if (ret < 0)
		dev_warn(&info->pdev->dev, "vbus path disable failed\n");
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
64
57.66%
1
50.00%
Hans de Goede
47
42.34%
1
50.00%
Total
111
100.00%
2
100.00%



static int axp288_charger_handle_otg_evt(struct notifier_block *nb,
				   unsigned long event, void *param)
{
	struct axp288_chrg_info *info =
	    container_of(nb, struct axp288_chrg_info, otg.id_nb);

	schedule_work(&info->otg.work);

	return NOTIFY_OK;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
49
100.00%
1
100.00%
Total
49
100.00%
1
100.00%



static int charger_init_hw_regs(struct axp288_chrg_info *info)
{
	int ret, cc, cv;
	unsigned int val;

	/* Program temperature thresholds */
	ret = regmap_write(info->regmap, AXP20X_V_LTF_CHRG, CHRG_VLTFC_0C);
	if (ret < 0) {
		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
							AXP20X_V_LTF_CHRG, ret);
		return ret;
	}

	ret = regmap_write(info->regmap, AXP20X_V_HTF_CHRG, CHRG_VHTFC_45C);
	if (ret < 0) {
		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
							AXP20X_V_HTF_CHRG, ret);
		return ret;
	}

	/* Do not turn-off charger o/p after charge cycle ends */
	ret = regmap_update_bits(info->regmap,
				AXP20X_CHRG_CTRL2,
				CNTL2_CHG_OUT_TURNON, CNTL2_CHG_OUT_TURNON);
	if (ret < 0) {
		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
						AXP20X_CHRG_CTRL2, ret);
		return ret;
	}

	/* Setup ending condition for charging to be 10% of I(chrg) */
	ret = regmap_update_bits(info->regmap,
				AXP20X_CHRG_CTRL1,
				CHRG_CCCV_ITERM_20P, 0);
	if (ret < 0) {
		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
						AXP20X_CHRG_CTRL1, ret);
		return ret;
	}

	/* Disable OCV-SOC curve calibration */
	ret = regmap_update_bits(info->regmap,
				AXP20X_CC_CTRL,
				FG_CNTL_OCV_ADJ_EN, 0);
	if (ret < 0) {
		dev_err(&info->pdev->dev, "register(%x) write error(%d)\n",
						AXP20X_CC_CTRL, ret);
		return ret;
	}

	/* Read current charge voltage and current limit */
	ret = regmap_read(info->regmap, AXP20X_CHRG_CTRL1, &val);
	if (ret < 0) {
		dev_err(&info->pdev->dev, "register(%x) read error(%d)\n",
			AXP20X_CHRG_CTRL1, ret);
		return ret;
	}

	/* Determine charge voltage */
	cv = (val & CHRG_CCCV_CV_MASK) >> CHRG_CCCV_CV_BIT_POS;
	switch (cv) {
	case CHRG_CCCV_CV_4100MV:
		info->cv = CV_4100MV;
		break;
	case CHRG_CCCV_CV_4150MV:
		info->cv = CV_4150MV;
		break;
	case CHRG_CCCV_CV_4200MV:
		info->cv = CV_4200MV;
		break;
	case CHRG_CCCV_CV_4350MV:
		info->cv = CV_4350MV;
		break;
	}

	/* Determine charge current limit */
	cc = (ret & CHRG_CCCV_CC_MASK) >> CHRG_CCCV_CC_BIT_POS;
	cc = (cc * CHRG_CCCV_CC_LSB_RES) + CHRG_CCCV_CC_OFFSET;
	info->cc = cc;

	/*
         * Do not allow the user to configure higher settings then those
         * set by the firmware
         */
	info->max_cv = info->cv;
	info->max_cc = info->cc;

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
323
85.45%
1
25.00%
Hans de Goede
55
14.55%
3
75.00%
Total
378
100.00%
4
100.00%



static int axp288_charger_probe(struct platform_device *pdev)
{
	int ret, i, pirq;
	struct axp288_chrg_info *info;
	struct device *dev = &pdev->dev;
	struct axp20x_dev *axp20x = dev_get_drvdata(pdev->dev.parent);
	struct power_supply_config charger_cfg = {};
	info = devm_kzalloc(&pdev->dev, sizeof(*info), GFP_KERNEL);
	if (!info)
		return -ENOMEM;

	info->pdev = pdev;
	info->regmap = axp20x->regmap;
	info->regmap_irqc = axp20x->regmap_irqc;
	info->cable.chg_type = -1;
	info->is_charger_enabled = -1;

	info->cable.edev = extcon_get_extcon_dev(AXP288_EXTCON_DEV_NAME);
	if (info->cable.edev == NULL) {
		dev_dbg(&pdev->dev, "%s is not ready, probe deferred\n",
			AXP288_EXTCON_DEV_NAME);
		return -EPROBE_DEFER;
	}

	info->otg.cable = extcon_get_extcon_dev(USB_HOST_EXTCON_DEV_NAME);
	if (info->otg.cable == NULL) {
		dev_dbg(dev, "EXTCON_USB_HOST is not ready, probe deferred\n");
		return -EPROBE_DEFER;
	}

	platform_set_drvdata(pdev, info);
	mutex_init(&info->lock);

	ret = charger_init_hw_regs(info);
	if (ret)
		return ret;

	/* Register with power supply class */
	charger_cfg.drv_data = info;
	info->psy_usb = devm_power_supply_register(dev, &axp288_charger_desc,
						   &charger_cfg);
	if (IS_ERR(info->psy_usb)) {
		ret = PTR_ERR(info->psy_usb);
		dev_err(dev, "failed to register power supply: %d\n", ret);
		return ret;
	}

	/* Register for extcon notification */
	INIT_WORK(&info->cable.work, axp288_charger_extcon_evt_worker);
	info->cable.nb[0].notifier_call = axp288_charger_handle_cable0_evt;
	info->cable.nb[1].notifier_call = axp288_charger_handle_cable1_evt;
	info->cable.nb[2].notifier_call = axp288_charger_handle_cable2_evt;
	for (i = 0; i < ARRAY_SIZE(cable_ids); i++) {
		ret = devm_extcon_register_notifier(dev, info->cable.edev,
					  cable_ids[i], &info->cable.nb[i]);
		if (ret) {
			dev_err(dev, "failed to register extcon notifier for %u: %d\n",
				cable_ids[i], ret);
			return ret;
		}
	}
	schedule_work(&info->cable.work);

	/* Register for OTG notification */
	INIT_WORK(&info->otg.work, axp288_charger_otg_evt_worker);
	info->otg.id_nb.notifier_call = axp288_charger_handle_otg_evt;
	ret = devm_extcon_register_notifier(&pdev->dev, info->otg.cable,
					EXTCON_USB_HOST, &info->otg.id_nb);
	if (ret) {
		dev_err(dev, "failed to register EXTCON_USB_HOST notifier\n");
		return ret;
	}
	schedule_work(&info->otg.work);

	/* Register charger interrupts */
	for (i = 0; i < CHRG_INTR_END; i++) {
		pirq = platform_get_irq(info->pdev, i);
		info->irq[i] = regmap_irq_get_virq(info->regmap_irqc, pirq);
		if (info->irq[i] < 0) {
			dev_warn(&info->pdev->dev,
				"failed to get virtual interrupt=%d\n", pirq);
			return info->irq[i];
		}
		ret = devm_request_threaded_irq(&info->pdev->dev, info->irq[i],
					NULL, axp288_charger_irq_thread_handler,
					IRQF_ONESHOT, info->pdev->name, info);
		if (ret) {
			dev_err(&pdev->dev, "failed to request interrupt=%d\n",
								info->irq[i]);
			return ret;
		}
	}

	return 0;
}

Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
356
57.51%
1
10.00%
Hans de Goede
208
33.60%
6
60.00%
Chanwoo Choi
54
8.72%
2
20.00%
Stephen Rothwell
1
0.16%
1
10.00%
Total
619
100.00%
10
100.00%


static const struct platform_device_id axp288_charger_id_table[] = {
	{ .name = "axp288_charger" },
	{},
};
MODULE_DEVICE_TABLE(platform, axp288_charger_id_table);


static struct platform_driver axp288_charger_driver = {
	.probe = axp288_charger_probe,
	.id_table = axp288_charger_id_table,
	.driver = {
		.name = "axp288_charger",
        },
};


module_platform_driver(axp288_charger_driver);

MODULE_AUTHOR("Ramakrishna Pallala <ramakrishna.pallala@intel.com>");
MODULE_DESCRIPTION("X-power AXP288 Charger Driver");
MODULE_LICENSE("GPL v2");
Overall Contributors
Person
Tokens
Prop
Commits
CommitProp
Ramakrishna Pallala
3360
85.19%
1
6.25%
Hans de Goede
521
13.21%
12
75.00%
Chanwoo Choi
62
1.57%
2
12.50%
Stephen Rothwell
1
0.03%
1
6.25%
Total
3944
100.00%
16
100.00%
Directory: drivers/power/supply

Information contained on this website is for historical information purposes only and does not indicate or represent copyright ownership.