Message-ID: <uarjdpyemkqnwneoj6kdj7vfzzllbqmsurjnsjr5hkujao6thx@2ysih3s7mftj>
Date: Fri, 19 Sep 2025 01:43:02 +0200
From: Sebastian Reichel <sebastian.reichel@...labora.com>
To: cy_huang@...htek.com
Cc: Krzysztof Kozlowski <krzk+dt@...nel.org>, 
	Rob Herring <robh@...nel.org>, Conor Dooley <conor+dt@...nel.org>, devicetree@...r.kernel.org, 
	linux-pm@...r.kernel.org, linux-kernel@...r.kernel.org
Subject: Re: [PATCH RESEND v2 2/3] power: supply: rt9756: Add Richtek RT9756
 smart cap divider charger

Hi,

On Thu, Aug 14, 2025 at 03:31:07PM +0800, cy_huang@...htek.com wrote:
> From: ChiYuan Huang <cy_huang@...htek.com>
> 
> Add support for RT9756 smart cap divider charger.
> 
> The RT9759 is a high efficiency and high charge current charger. The
> maximum charge current is up to 8A. It integrates a dual-phase charge
> pump core with ADC monitoring.
> 
> Signed-off-by: ChiYuan Huang <cy_huang@...htek.com>
> ---

Sorry for the delay. This looks mostly good, but I really don't like
the custom properties for the battery voltage and current. Instead
of handling via custom properties, register a second power_supply
device with POWER_SUPPLY_TYPE_BATTERY and use the normal 
POWER_SUPPLY_PROP_VOLTAGE_NOW and POWER_SUPPLY_PROP_CURRENT_NOW
properties. Having custom properties for the watchdog and the
operating mode is fine with me, as these two things are quite
specific to the RT9756 chips.

While you are at it, you can also add this constant property for
the battery device:

POWER_SUPPLY_PROP_TECHNOLOGY = POWER_SUPPLY_TECHNOLOGY_LION

Also the charger's power_supply_config should set the
.supplied_to, listing the battery device, so that the kernel
is aware of the link between those two devices.

Greetings,

-- Sebastian

>  drivers/power/supply/Kconfig  |  15 +
>  drivers/power/supply/Makefile |   1 +
>  drivers/power/supply/rt9756.c | 932 ++++++++++++++++++++++++++++++++++
>  3 files changed, 948 insertions(+)
>  create mode 100644 drivers/power/supply/rt9756.c
> 
> diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig
> index 79ddb006e2da..aff192474140 100644
> --- a/drivers/power/supply/Kconfig
> +++ b/drivers/power/supply/Kconfig
> @@ -909,6 +909,21 @@ config CHARGER_RT9471
>  	  This driver can also be built as a module. If so, the module will be
>  	  called rt9471.
>  
> +config CHARGER_RT9756
> +	tristate "Richtek RT9756 smart cap divider charger driver"
> +	depends on I2C
> +	select REGMAP_I2C
> +	select LINEAR_RANGES
> +	help
> +	  This adds support for Richtek RT9756 smart cap divider charger driver.
> +	  It's a high efficiency and high charge current charger. the device
> +	  integrates smart cap divider topology with 9-channel high speed
> +	  ADCs that can provide input and output voltage, current and
> +	  temperature monitoring.
> +
> +	  This driver can also be built as a module. If so, the module will be
> +	  called rt9756.
> +
>  config CHARGER_CROS_USBPD
>  	tristate "ChromeOS EC based USBPD charger"
>  	depends on CROS_USBPD_NOTIFY
> diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile
> index 4f5f8e3507f8..a529f217f0ad 100644
> --- a/drivers/power/supply/Makefile
> +++ b/drivers/power/supply/Makefile
> @@ -62,6 +62,7 @@ obj-$(CONFIG_CHARGER_RT5033)	+= rt5033_charger.o
>  obj-$(CONFIG_CHARGER_RT9455)	+= rt9455_charger.o
>  obj-$(CONFIG_CHARGER_RT9467)	+= rt9467-charger.o
>  obj-$(CONFIG_CHARGER_RT9471)	+= rt9471.o
> +obj-$(CONFIG_CHARGER_RT9756)	+= rt9756.o
>  obj-$(CONFIG_BATTERY_TWL4030_MADC)	+= twl4030_madc_battery.o
>  obj-$(CONFIG_CHARGER_88PM860X)	+= 88pm860x_charger.o
>  obj-$(CONFIG_BATTERY_RX51)	+= rx51_battery.o
> diff --git a/drivers/power/supply/rt9756.c b/drivers/power/supply/rt9756.c
> new file mode 100644
> index 000000000000..99bfbcc37272
> --- /dev/null
> +++ b/drivers/power/supply/rt9756.c
> @@ -0,0 +1,932 @@
> +// SPDX-License-Identifier: GPL-2.0-only
> +//
> +// Copyright (C) 2025 Richtek Technology Corp.
> +//
> +// Authors: ChiYuan Huang <cy_huang@...htek.com>
> +
> +#include <linux/atomic.h>
> +#include <linux/cleanup.h>
> +#include <linux/i2c.h>
> +#include <linux/kernel.h>
> +#include <linux/linear_range.h>
> +#include <linux/interrupt.h>
> +#include <linux/mod_devicetable.h>
> +#include <linux/module.h>
> +#include <linux/mutex.h>
> +#include <linux/power_supply.h>
> +#include <linux/property.h>
> +#include <linux/regmap.h>
> +#include <linux/sysfs.h>
> +#include <linux/util_macros.h>
> +
> +#define RT9756_REG_INTFLAG1	0x0B
> +#define RT9756_REG_INTFLAG2	0x0D
> +#define RT9756_REG_INTFLAG3	0x0F
> +#define RT9756_REG_ADCCTL	0x11
> +#define RT9756_REG_VBUSADC	0x12
> +#define RT9756_REG_BC12FLAG	0x45
> +#define RT9756_REG_INTFLAG4	0x49
> +
> +/* Flag1 */
> +#define RT9756_EVT_BUSOVP	BIT(3)
> +#define RT9756_EVT_BUSOCP	BIT(2)
> +#define RT9756_EVT_BUSUCP	BIT(0)
> +/* Flag2 */
> +#define RT9756_EVT_BATOVP	BIT(7)
> +#define RT9756_EVT_BATOCP	BIT(6)
> +#define RT9756_EVT_TDIEOTP	BIT(3)
> +#define RT9756_EVT_VBUSLOW_ERR	BIT(2)
> +#define RT9756_EVT_VAC_INSERT	BIT(0)
> +/* Flag3 */
> +#define RT9756_EVT_WDT		BIT(5)
> +#define RT9756_EVT_VAC_UVLO	BIT(4)
> +/* ADCCTL */
> +#define RT9756_ADCEN_MASK	BIT(7)
> +#define RT9756_ADCONCE_MASK	BIT(6)
> +/* Bc12_flag */
> +#define RT9756_EVT_BC12_DONE	BIT(3)
> +/* Flag4 */
> +#define RT9756_EVT_OUTOVP	BIT(0)
> +
> +#define RICHTEK_DEVID		7
> +#define RT9756_REVID		0
> +#define RT9756A_REVID		1
> +#define RT9757_REVID		2
> +#define RT9757A_REVID		3
> +#define RT9756_ADC_CONVTIME	1200
> +#define RT9756_ADC_MAXWAIT	16000
> +
> +enum rt9756_model {
> +	MODEL_RT9756 = 0,
> +	MODEL_RT9757,
> +	MODEL_RT9770,
> +	MODEL_MAX
> +};
> +
> +enum rt9756_adc_chan {
> +	ADC_VBUS = 0,
> +	ADC_IBUS,
> +	ADC_VBAT,
> +	ADC_IBAT,
> +	ADC_TDIE,
> +	ADC_MAX_CHANNEL
> +};
> +
> +enum rt9756_usb_type {
> +	USB_NO_VBUS = 0,
> +	USB_SDP = 2,
> +	USB_NSTD,
> +	USB_DCP,
> +	USB_CDP,
> +	MAX_USB_TYPE
> +};
> +
> +enum rt9756_fields {
> +	F_VBATOVP = 0,
> +	F_VBATOVP_EN,
> +	F_IBATOCP,
> +	F_IBATOCP_EN,
> +	F_VBUSOVP,
> +	F_VBUSOVP_EN,
> +	F_IBUSOCP,
> +	F_IBUSOCP_EN,
> +	F_SWITCHING,
> +	F_REG_RST,
> +	F_CHG_EN,
> +	F_OP_MODE,
> +	F_WDT_DIS,
> +	F_WDT_TMR,
> +	F_DEV_ID,
> +	F_BC12_EN,
> +	F_USB_STATE,
> +	F_VBUS_STATE,
> +	F_IBAT_RSEN,
> +	F_REVISION,
> +	F_MAX_FIELD
> +};
> +
> +enum rt9756_ranges {
> +	R_VBATOVP = 0,
> +	R_IBATOCP,
> +	R_VBUSOVP,
> +	R_IBUSOCP,
> +	R_MAX_RANGE
> +};
> +
> +static const struct reg_field rt9756_chg_fields[F_MAX_FIELD] = {
> +	[F_VBATOVP]	= REG_FIELD(0x08, 0, 4),
> +	[F_VBATOVP_EN]	= REG_FIELD(0x08, 7, 7),
> +	[F_IBATOCP]	= REG_FIELD(0x09, 0, 5),
> +	[F_IBATOCP_EN]	= REG_FIELD(0x09, 7, 7),
> +	[F_VBUSOVP]	= REG_FIELD(0x06, 0, 5),
> +	[F_VBUSOVP_EN]	= REG_FIELD(0x06, 7, 7),
> +	[F_IBUSOCP]	= REG_FIELD(0x07, 0, 4),
> +	[F_IBUSOCP_EN]	= REG_FIELD(0x07, 5, 5),
> +	[F_SWITCHING]	= REG_FIELD(0x5c, 7, 7),
> +	[F_REG_RST]	= REG_FIELD(0x00, 7, 7),
> +	[F_CHG_EN]	= REG_FIELD(0x00, 6, 6),
> +	[F_OP_MODE]	= REG_FIELD(0x00, 5, 5),
> +	[F_WDT_DIS]	= REG_FIELD(0x00, 3, 3),
> +	[F_WDT_TMR]	= REG_FIELD(0x00, 0, 2),
> +	[F_DEV_ID]	= REG_FIELD(0x03, 0, 3),
> +	[F_BC12_EN]	= REG_FIELD(0x44, 7, 7),
> +	[F_USB_STATE]	= REG_FIELD(0x46, 5, 7),
> +	[F_VBUS_STATE]	= REG_FIELD(0x4c, 0, 0),
> +	[F_IBAT_RSEN]	= REG_FIELD(0x5e, 0, 1),
> +	[F_REVISION]	= REG_FIELD(0x62, 0, 1),
> +};
> +
> +static const struct reg_field rt9770_chg_fields[F_MAX_FIELD] = {
> +	[F_VBATOVP]	= REG_FIELD(0x08, 0, 4),
> +	[F_VBATOVP_EN]	= REG_FIELD(0x08, 7, 7),
> +	[F_IBATOCP]	= REG_FIELD(0x09, 0, 5),
> +	[F_IBATOCP_EN]	= REG_FIELD(0x09, 7, 7),
> +	[F_VBUSOVP]	= REG_FIELD(0x06, 0, 5),
> +	[F_VBUSOVP_EN]	= REG_FIELD(0x06, 7, 7),
> +	[F_IBUSOCP]	= REG_FIELD(0x07, 0, 4),
> +	[F_IBUSOCP_EN]	= REG_FIELD(0x07, 5, 5),
> +	[F_SWITCHING]	= REG_FIELD(0x5c, 7, 7),
> +	[F_REG_RST]	= REG_FIELD(0x00, 7, 7),
> +	[F_CHG_EN]	= REG_FIELD(0x00, 6, 6),
> +	[F_OP_MODE]	= REG_FIELD(0x00, 5, 5),
> +	[F_WDT_DIS]	= REG_FIELD(0x00, 3, 3),
> +	[F_WDT_TMR]	= REG_FIELD(0x00, 0, 2),
> +	[F_DEV_ID]	= REG_FIELD(0x60, 0, 3),
> +	[F_BC12_EN]	= REG_FIELD(0x03, 7, 7),
> +	[F_USB_STATE]	= REG_FIELD(0x02, 5, 7),
> +	[F_VBUS_STATE]	= REG_FIELD(0x4c, 0, 0),
> +	[F_IBAT_RSEN]	= REG_FIELD(0x5e, 0, 1),
> +	[F_REVISION]	= REG_FIELD(0x62, 3, 7),
> +};
> +
> +/* All converted to microvolt or microamp */
> +static const struct linear_range rt9756_chg_ranges[R_MAX_RANGE] = {
> +	LINEAR_RANGE_IDX(R_VBATOVP, 4200000, 0, 31, 25000),
> +	LINEAR_RANGE_IDX(R_IBATOCP, 2000000, 0, 63, 100000),
> +	LINEAR_RANGE_IDX(R_VBUSOVP, 3000000, 0, 63, 50000),
> +	LINEAR_RANGE_IDX(R_IBUSOCP, 1000000, 0, 31, 250000),
> +};
> +
> +struct charger_event {
> +	unsigned int flag1;
> +	unsigned int flag2;
> +	unsigned int flag3;
> +	unsigned int flag4;
> +};
> +
> +struct rt9756_data {
> +	struct device *dev;
> +	struct regmap *regmap;
> +	struct regmap_field *rm_fields[F_MAX_FIELD];
> +	struct power_supply *psy;
> +	struct mutex adc_lock;
> +	struct power_supply_desc psy_desc;
> +	struct charger_event chg_evt;
> +	unsigned int rg_resistor;
> +	unsigned int real_resistor;
> +	enum rt9756_model model;
> +	atomic_t usb_type;
> +};
> +
> +struct rt975x_dev_data {
> +	const struct regmap_config *regmap_config;
> +	const struct reg_field *reg_fields;
> +	const struct reg_sequence *init_regs;
> +	size_t num_init_regs;
> +	int (*check_device_model)(struct rt9756_data *data);
> +};
> +
> +static int rt9756_get_value_field_range(struct rt9756_data *data, enum rt9756_fields en_field,
> +					enum rt9756_fields field, enum rt9756_ranges rsel, int *val)
> +{
> +	const struct linear_range *range = rt9756_chg_ranges + rsel;
> +	unsigned int enable, selector, value;
> +	int ret;
> +
> +	ret = regmap_field_read(data->rm_fields[en_field], &enable);
> +	if (ret)
> +		return ret;
> +
> +	if (!enable) {
> +		*val = 0;
> +		return 0;
> +	}
> +
> +	ret = regmap_field_read(data->rm_fields[field], &selector);
> +	if (ret)
> +		return ret;
> +
> +	ret = linear_range_get_value(range, selector, &value);
> +	if (ret)
> +		return ret;
> +
> +	*val = (int)value;
> +
> +	return 0;
> +}
> +
> +static int rt9756_set_value_field_range(struct rt9756_data *data, enum rt9756_fields en_field,
> +					enum rt9756_fields field, enum rt9756_ranges rsel, int val)
> +{
> +	const struct linear_range *range = rt9756_chg_ranges + rsel;
> +	unsigned int selector, value;
> +	int ret;
> +
> +	if (!val)
> +		return regmap_field_write(data->rm_fields[en_field], 0);
> +
> +	value = (unsigned int)val;
> +	linear_range_get_selector_within(range, value, &selector);
> +	ret = regmap_field_write(data->rm_fields[field], selector);
> +	if (ret)
> +		return ret;
> +
> +	return regmap_field_write(data->rm_fields[en_field], 1);
> +}
> +
> +static int rt9756_get_adc(struct rt9756_data *data, enum rt9756_adc_chan chan,
> +			  int *val)
> +{
> +	struct regmap *regmap = data->regmap;
> +	unsigned int reg_addr = RT9756_REG_VBUSADC + chan * 2;
> +	unsigned int mask = RT9756_ADCEN_MASK | RT9756_ADCONCE_MASK;
> +	unsigned int shift = 0, adc_cntl;
> +	__be16 raws;
> +	int scale, offset = 0, ret;
> +
> +	guard(mutex)(&data->adc_lock);
> +
> +	ret = regmap_update_bits(regmap, RT9756_REG_ADCCTL, mask, mask);
> +	if (ret)
> +		return ret;
> +
> +	ret = regmap_read_poll_timeout(regmap, RT9756_REG_ADCCTL, adc_cntl,
> +				       !(adc_cntl & RT9756_ADCEN_MASK),
> +				       RT9756_ADC_CONVTIME, RT9756_ADC_MAXWAIT);
> +	if (ret && ret != -ETIMEDOUT)
> +		return ret;
> +
> +	ret = regmap_raw_read(regmap, reg_addr, &raws, sizeof(raws));
> +	if (ret)
> +		return ret;
> +
> +	/*
> +	 * TDIE LSB 1'c, others LSB 1000uV or 1000uA.
> +	 * Rsense ratio is needed for IBAT channel
> +	 */
> +	if (chan == ADC_TDIE) {
> +		scale = 10;
> +		shift = 8;
> +		offset = -40;
> +	} else if (chan == ADC_IBAT)
> +		scale = 1000 * data->rg_resistor / data->real_resistor;
> +	else
> +		scale = 1000;
> +
> +	*val = ((be16_to_cpu(raws) >> shift) + offset) * scale;
> +
> +	return regmap_update_bits(regmap, RT9756_REG_ADCCTL, mask, 0);
> +}
> +
> +static int rt9756_get_switching_state(struct rt9756_data *data, int *status)
> +{
> +	unsigned int switching_state;
> +	int ret;
> +
> +	ret = regmap_field_read(data->rm_fields[F_SWITCHING], &switching_state);
> +	if (ret)
> +		return ret;
> +
> +	if (switching_state)
> +		*status = POWER_SUPPLY_STATUS_CHARGING;
> +	else
> +		*status = POWER_SUPPLY_STATUS_NOT_CHARGING;
> +
> +	return 0;
> +}
> +
> +static int rt9756_get_charger_health(struct rt9756_data *data)
> +{
> +	struct charger_event *evt = &data->chg_evt;
> +
> +	if (evt->flag2 & RT9756_EVT_VBUSLOW_ERR)
> +		return POWER_SUPPLY_HEALTH_UNDERVOLTAGE;
> +
> +	if (evt->flag1 & RT9756_EVT_BUSOVP || evt->flag2 & RT9756_EVT_BATOVP ||
> +	    evt->flag4 & RT9756_EVT_OUTOVP)
> +		return POWER_SUPPLY_HEALTH_OVERVOLTAGE;
> +
> +	if (evt->flag1 & RT9756_EVT_BUSOCP || evt->flag2 & RT9756_EVT_BATOCP)
> +		return POWER_SUPPLY_HEALTH_OVERCURRENT;
> +
> +	if (evt->flag1 & RT9756_EVT_BUSUCP)
> +		return POWER_SUPPLY_HEALTH_UNSPEC_FAILURE;
> +
> +	if (evt->flag2 & RT9756_EVT_TDIEOTP)
> +		return POWER_SUPPLY_HEALTH_OVERHEAT;
> +
> +	if (evt->flag3 & RT9756_EVT_WDT)
> +		return POWER_SUPPLY_HEALTH_WATCHDOG_TIMER_EXPIRE;
> +
> +	return POWER_SUPPLY_HEALTH_GOOD;
> +}
> +
> +static int rt9756_get_charger_online(struct rt9756_data *data, int *val)
> +{
> +	unsigned int online;
> +	int ret;
> +
> +	ret = regmap_field_read(data->rm_fields[F_VBUS_STATE], &online);
> +	if (ret)
> +		return ret;
> +
> +	*val = !!online;
> +	return 0;
> +}
> +
> +static int rt9756_get_vbus_ovp(struct rt9756_data *data, int *val)
> +{
> +	unsigned int opmode;
> +	int ovpval, ret;
> +
> +	/* operating mode -> 0 bypass, 1 div2 */
> +	ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode);
> +	if (ret)
> +		return ret;
> +
> +	ret = rt9756_get_value_field_range(data, F_VBUSOVP_EN, F_VBUSOVP, R_VBUSOVP, &ovpval);
> +	if (ret)
> +		return ret;
> +
> +	*val = opmode ? ovpval * 2 : ovpval;
> +	return 0;
> +}
> +
> +static int rt9756_set_vbus_ovp(struct rt9756_data *data, int val)
> +{
> +	unsigned int opmode;
> +	int ret;
> +
> +	/* operating mode -> 0 bypass, 1 div2 */
> +	ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode);
> +	if (ret)
> +		return ret;
> +
> +	return rt9756_set_value_field_range(data, F_VBUSOVP_EN, F_VBUSOVP, R_VBUSOVP,
> +					    opmode ? val / 2 : val);
> +}
> +
> +static const char * const rt9756_manufacturer = "Richtek Technology Corp.";
> +static const char * const rt9756_model[MODEL_MAX] =  { "RT9756", "RT9757", "RT9770" };
> +
> +static int rt9756_psy_get_property(struct power_supply *psy,
> +				   enum power_supply_property psp,
> +				   union power_supply_propval *val)
> +{
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	int *pval = &val->intval;
> +
> +	switch (psp) {
> +	case POWER_SUPPLY_PROP_STATUS:
> +		return rt9756_get_switching_state(data, pval);
> +	case POWER_SUPPLY_PROP_HEALTH:
> +		*pval = rt9756_get_charger_health(data);
> +		return 0;
> +	case POWER_SUPPLY_PROP_ONLINE:
> +		return rt9756_get_charger_online(data, pval);
> +	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
> +		return rt9756_get_vbus_ovp(data, pval);
> +	case POWER_SUPPLY_PROP_VOLTAGE_NOW:
> +		return rt9756_get_adc(data, ADC_VBUS, pval);
> +	case POWER_SUPPLY_PROP_CURRENT_MAX:
> +		return rt9756_get_value_field_range(data, F_IBUSOCP_EN, F_IBUSOCP, R_IBUSOCP, pval);
> +	case POWER_SUPPLY_PROP_CURRENT_NOW:
> +		return rt9756_get_adc(data, ADC_IBUS, pval);
> +	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
> +		return rt9756_get_value_field_range(data, F_VBATOVP_EN, F_VBATOVP, R_VBATOVP, pval);
> +	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
> +		return rt9756_get_value_field_range(data, F_IBATOCP_EN, F_IBATOCP, R_IBATOCP, pval);
> +	case POWER_SUPPLY_PROP_TEMP:
> +		return rt9756_get_adc(data, ADC_TDIE, pval);
> +	case POWER_SUPPLY_PROP_USB_TYPE:
> +		*pval = atomic_read(&data->usb_type);
> +		return 0;
> +	case POWER_SUPPLY_PROP_MODEL_NAME:
> +		val->strval = rt9756_model[data->model];
> +		return 0;
> +	case POWER_SUPPLY_PROP_MANUFACTURER:
> +		val->strval = rt9756_manufacturer;
> +		return 0;
> +	default:
> +		return -ENODATA;
> +	}
> +}
> +
> +static int rt9756_psy_set_property(struct power_supply *psy,
> +				   enum power_supply_property psp,
> +				   const union power_supply_propval *val)
> +{
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	int intval = val->intval;
> +
> +	switch (psp) {
> +	case POWER_SUPPLY_PROP_STATUS:
> +		memset(&data->chg_evt, 0, sizeof(data->chg_evt));
> +		return regmap_field_write(data->rm_fields[F_CHG_EN], !!intval);
> +	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
> +		return rt9756_set_vbus_ovp(data, intval);
> +	case POWER_SUPPLY_PROP_CURRENT_MAX:
> +		return rt9756_set_value_field_range(data, F_IBUSOCP_EN, F_IBUSOCP, R_IBUSOCP,
> +						    intval);
> +	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
> +		return rt9756_set_value_field_range(data, F_VBATOVP_EN, F_VBATOVP, R_VBATOVP,
> +						    intval);
> +	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
> +		return rt9756_set_value_field_range(data, F_IBATOCP_EN, F_IBATOCP, R_IBATOCP,
> +						    intval);
> +	case POWER_SUPPLY_PROP_USB_TYPE:
> +		return regmap_field_write(data->rm_fields[F_BC12_EN], !!intval);
> +	default:
> +		return -EINVAL;
> +	}
> +}
> +
> +static const enum power_supply_property rt9756_psy_properties[] = {
> +	POWER_SUPPLY_PROP_STATUS,
> +	POWER_SUPPLY_PROP_ONLINE,
> +	POWER_SUPPLY_PROP_HEALTH,
> +	POWER_SUPPLY_PROP_ONLINE,
> +	POWER_SUPPLY_PROP_VOLTAGE_MAX,
> +	POWER_SUPPLY_PROP_VOLTAGE_NOW,
> +	POWER_SUPPLY_PROP_CURRENT_MAX,
> +	POWER_SUPPLY_PROP_CURRENT_NOW,
> +	POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX,
> +	POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX,
> +	POWER_SUPPLY_PROP_TEMP,
> +	POWER_SUPPLY_PROP_USB_TYPE,
> +	POWER_SUPPLY_PROP_MODEL_NAME,
> +	POWER_SUPPLY_PROP_MANUFACTURER,
> +};
> +
> +static int rt9756_psy_property_is_writeable(struct power_supply *psy,
> +					    enum power_supply_property psp)
> +{
> +	switch (psp) {
> +	case POWER_SUPPLY_PROP_STATUS:
> +	case POWER_SUPPLY_PROP_ONLINE:
> +	case POWER_SUPPLY_PROP_VOLTAGE_MAX:
> +	case POWER_SUPPLY_PROP_CURRENT_MAX:
> +	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX:
> +	case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX:
> +	case POWER_SUPPLY_PROP_USB_TYPE:
> +		return 1;
> +	default:
> +		return 0;
> +	}
> +}
> +
> +static const unsigned int rt9756_wdt_millisecond[] = {
> +	500, 1000, 5000, 30000, 40000, 80000, 128000, 255000
> +};
> +
> +static ssize_t watchdog_timer_show(struct device *dev,
> +				   struct device_attribute *attr, char *buf)
> +{
> +	struct power_supply *psy = to_power_supply(dev);
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	unsigned int wdt_tmr_now = 0, wdt_sel, wdt_dis;
> +	int ret;
> +
> +	ret = regmap_field_read(data->rm_fields[F_WDT_DIS], &wdt_dis);
> +	if (ret)
> +		return ret;
> +
> +	if (!wdt_dis) {
> +		ret = regmap_field_read(data->rm_fields[F_WDT_TMR], &wdt_sel);
> +		if (ret)
> +			return ret;
> +
> +		wdt_tmr_now = rt9756_wdt_millisecond[wdt_sel];
> +	}
> +
> +	return sysfs_emit(buf, "%d\n", wdt_tmr_now);
> +}
> +
> +static ssize_t watchdog_timer_store(struct device *dev,
> +				    struct device_attribute *attr,
> +				    const char *buf, size_t count)
> +{
> +	struct power_supply *psy = to_power_supply(dev);
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	unsigned int wdt_set, wdt_sel;
> +	int ret;
> +
> +	ret = kstrtouint(buf, 10, &wdt_set);
> +	if (ret)
> +		return ret;
> +
> +	ret = regmap_field_write(data->rm_fields[F_WDT_DIS], 1);
> +	if (ret)
> +		return ret;
> +
> +	wdt_sel = find_closest(wdt_set, rt9756_wdt_millisecond,
> +			       ARRAY_SIZE(rt9756_wdt_millisecond));
> +
> +	ret = regmap_field_write(data->rm_fields[F_WDT_TMR], wdt_sel);
> +	if (ret)
> +		return ret;
> +
> +	if (wdt_set) {
> +		ret = regmap_field_write(data->rm_fields[F_WDT_DIS], 0);
> +		if (ret)
> +			return ret;
> +	}
> +
> +	return count;
> +}
> +
> +static ssize_t battery_voltage_show(struct device *dev,
> +				    struct device_attribute *attr, char *buf)
> +{
> +	struct power_supply *psy = to_power_supply(dev);
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	int vbat_now, ret;
> +
> +	ret = rt9756_get_adc(data, ADC_VBAT, &vbat_now);
> +	if (ret)
> +		return ret;
> +
> +	return sysfs_emit(buf, "%d\n", vbat_now);
> +}
> +
> +static ssize_t battery_current_show(struct device *dev,
> +				    struct device_attribute *attr, char *buf)
> +{
> +	struct power_supply *psy = to_power_supply(dev);
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	int ibat_now, ret;
> +
> +	ret = rt9756_get_adc(data, ADC_IBAT, &ibat_now);
> +	if (ret)
> +		return ret;
> +
> +	return sysfs_emit(buf, "%d\n", ibat_now);
> +}
> +
> +static const char * const rt9756_opmode_str[] = { "bypass", "div2" };
> +
> +static ssize_t operation_mode_show(struct device *dev,
> +				   struct device_attribute *attr, char *buf)
> +{
> +	struct power_supply *psy = to_power_supply(dev);
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	unsigned int opmode;
> +	int ret;
> +
> +	ret = regmap_field_read(data->rm_fields[F_OP_MODE], &opmode);
> +	if (ret)
> +		return ret;
> +
> +	return sysfs_emit(buf, "%s\n", rt9756_opmode_str[opmode]);
> +}
> +
> +static ssize_t operation_mode_store(struct device *dev,
> +				    struct device_attribute *attr,
> +				    const char *buf, size_t count)
> +{
> +	struct power_supply *psy = to_power_supply(dev);
> +	struct rt9756_data *data = power_supply_get_drvdata(psy);
> +	int index, ret;
> +
> +	index = sysfs_match_string(rt9756_opmode_str, buf);
> +	if (index < 0)
> +		return index;
> +
> +	ret = regmap_field_write(data->rm_fields[F_OP_MODE], index);
> +
> +	return ret ?: count;
> +}
> +
> +static DEVICE_ATTR_RW(watchdog_timer);
> +static DEVICE_ATTR_RO(battery_voltage);
> +static DEVICE_ATTR_RO(battery_current);
> +static DEVICE_ATTR_RW(operation_mode);
> +
> +static struct attribute *rt9756_sysfs_attrs[] = {
> +	&dev_attr_watchdog_timer.attr,
> +	&dev_attr_battery_voltage.attr,
> +	&dev_attr_battery_current.attr,
> +	&dev_attr_operation_mode.attr,
> +	NULL
> +};
> +ATTRIBUTE_GROUPS(rt9756_sysfs);
> +
> +static int rt9756_register_psy(struct rt9756_data *data)
> +{
> +	struct power_supply_desc *desc = &data->psy_desc;
> +	struct power_supply_config cfg = {};
> +	struct device *dev = data->dev;
> +	char *psy_name;
> +
> +	cfg.drv_data = data;
> +	cfg.fwnode = dev_fwnode(dev);
> +	cfg.attr_grp = rt9756_sysfs_groups;
> +
> +	psy_name = devm_kasprintf(dev, GFP_KERNEL, "rt9756-%s", dev_name(dev));
> +	if (!psy_name)
> +		return -ENOMEM;
> +
> +	desc->name = psy_name;
> +	desc->type = POWER_SUPPLY_TYPE_USB;
> +	desc->usb_types = BIT(POWER_SUPPLY_USB_TYPE_UNKNOWN) | BIT(POWER_SUPPLY_USB_TYPE_SDP) |
> +			  BIT(POWER_SUPPLY_USB_TYPE_DCP) | BIT(POWER_SUPPLY_USB_TYPE_CDP);
> +	desc->properties = rt9756_psy_properties;
> +	desc->num_properties = ARRAY_SIZE(rt9756_psy_properties);
> +	desc->property_is_writeable = rt9756_psy_property_is_writeable;
> +	desc->get_property = rt9756_psy_get_property;
> +	desc->set_property = rt9756_psy_set_property;
> +
> +	data->psy = devm_power_supply_register(dev, desc, &cfg);
> +
> +	return PTR_ERR_OR_ZERO(data->psy);
> +}
> +
> +static int rt9756_get_usb_type(struct rt9756_data *data)
> +{
> +	unsigned int type;
> +	int report_type, ret;
> +
> +	ret = regmap_field_read(data->rm_fields[F_USB_STATE], &type);
> +	if (ret)
> +		return ret;
> +
> +	switch (type) {
> +	case USB_SDP:
> +	case USB_NSTD:
> +		report_type = POWER_SUPPLY_USB_TYPE_SDP;
> +		break;
> +	case USB_DCP:
> +		report_type = POWER_SUPPLY_USB_TYPE_DCP;
> +		break;
> +	case USB_CDP:
> +		report_type = POWER_SUPPLY_USB_TYPE_CDP;
> +		break;
> +	case USB_NO_VBUS:
> +	default:
> +		report_type = POWER_SUPPLY_USB_TYPE_UNKNOWN;
> +		break;
> +	}
> +
> +	atomic_set(&data->usb_type, report_type);
> +	return 0;
> +}
> +
> +static irqreturn_t rt9756_irq_handler(int irq, void *devid)
> +{
> +	struct rt9756_data *data = devid;
> +	struct regmap *regmap = data->regmap;
> +	struct charger_event *evt = &data->chg_evt;
> +	unsigned int bc12_flag = 0;
> +	int ret;
> +
> +	ret = regmap_read(regmap, RT9756_REG_INTFLAG1, &evt->flag1);
> +	if (ret)
> +		return IRQ_NONE;
> +
> +	ret = regmap_read(regmap, RT9756_REG_INTFLAG2, &evt->flag2);
> +	if (ret)
> +		return IRQ_NONE;
> +
> +	ret = regmap_read(regmap, RT9756_REG_INTFLAG3, &evt->flag3);
> +	if (ret)
> +		return IRQ_NONE;
> +
> +	if (data->model != MODEL_RT9770) {
> +		ret = regmap_read(regmap, RT9756_REG_INTFLAG4, &evt->flag4);
> +		if (ret)
> +			return IRQ_NONE;
> +
> +		ret = regmap_read(regmap, RT9756_REG_BC12FLAG, &bc12_flag);
> +		if (ret)
> +			return IRQ_NONE;
> +	}
> +
> +	dev_dbg(data->dev, "events: 0x%02x,%02x,%02x,%02x,%02x\n", evt->flag1, evt->flag2,
> +		evt->flag3, evt->flag4, bc12_flag);
> +
> +	if (evt->flag2 & RT9756_EVT_VAC_INSERT) {
> +		ret = regmap_field_write(data->rm_fields[F_BC12_EN], 1);
> +		if (ret)
> +			return IRQ_NONE;
> +	}
> +
> +	if (evt->flag3 & RT9756_EVT_VAC_UVLO)
> +		atomic_set(&data->usb_type, POWER_SUPPLY_USB_TYPE_UNKNOWN);
> +
> +	if (bc12_flag & RT9756_EVT_BC12_DONE) {
> +		ret = rt9756_get_usb_type(data);
> +		if (ret)
> +			return IRQ_NONE;
> +	}
> +
> +	power_supply_changed(data->psy);
> +
> +	return IRQ_HANDLED;
> +}
> +
> +static int rt9756_config_batsense_resistor(struct rt9756_data *data)
> +{
> +	unsigned int shunt_resistor_uohms = 2000, rsense_sel;
> +
> +	device_property_read_u32(data->dev, "shunt-resistor-micro-ohms", &shunt_resistor_uohms);
> +
> +	if (!shunt_resistor_uohms || shunt_resistor_uohms > 5000)
> +		return -EINVAL;
> +
> +	data->real_resistor = shunt_resistor_uohms;
> +
> +	/* Always choose the larger or equal one to prevent false ocp alarm */
> +	if (shunt_resistor_uohms <= 1000) {
> +		rsense_sel = 0;
> +		data->rg_resistor = 1000;
> +	} else if (shunt_resistor_uohms <= 2000) {
> +		rsense_sel = 1;
> +		data->rg_resistor = 2000;
> +	} else {
> +		rsense_sel = 2;
> +		data->rg_resistor = 5000;
> +	}
> +
> +	return regmap_field_write(data->rm_fields[F_IBAT_RSEN], rsense_sel);
> +}
> +
> +static const struct reg_sequence rt9756_init_regs[] = {
> +	REG_SEQ(0x00, 0x80, 1000), /* REG_RESET */
> +	REG_SEQ0(0x04, 0x13), /* VACOVP/OVPGATE 12V */
> +	REG_SEQ0(0x00, 0x28), /* WDT_DIS = 1 */
> +	REG_SEQ0(0x0c, 0x02), /* MASK FLAG1 */
> +	REG_SEQ0(0x0e, 0x06), /* MASK FLAG2 */
> +	REG_SEQ0(0x10, 0xca), /* MASK FLAG3 */
> +	REG_SEQ0(0x44, 0xa0), /* BC12_EN */
> +	REG_SEQ0(0x47, 0x07), /* MASK BC12FLAG */
> +	REG_SEQ0(0x4a, 0xfe), /* MASK FLAG4 */
> +	REG_SEQ0(0x5c, 0x40), /* MASK CON_SWITCHING */
> +	REG_SEQ0(0x63, 0x01), /* MASK VDDA_UVLO */
> +};
> +
> +static const struct reg_sequence rt9770_init_regs[] = {
> +	REG_SEQ(0x00, 0x80, 1000), /* REG_RESET */
> +	REG_SEQ0(0x04, 0x13), /* VACOVP/OVPGATE 12V */
> +	REG_SEQ0(0x00, 0x28), /* WDT_DIS = 1 */
> +	REG_SEQ0(0x0c, 0x02), /* MASK FLAG1 */
> +	REG_SEQ0(0x0e, 0x06), /* MASK FLAG2 */
> +	REG_SEQ0(0x10, 0xca), /* MASK FLAG3 */
> +	REG_SEQ0(0x5c, 0x40), /* MASK CON_SWITCHING */
> +	REG_SEQ0(0x63, 0x01), /* MASK VDDA_UVLO */
> +};
> +
> +static const struct regmap_config rt9756_regmap_config = {
> +	.name = "rt9756",
> +	.reg_bits = 16,
> +	.val_bits = 8,
> +	.max_register = 0x1ff,
> +};
> +
> +static const struct regmap_config rt9770_regmap_config = {
> +	.name = "rt9770",
> +	.reg_bits = 8,
> +	.val_bits = 8,
> +	.max_register = 0xff,
> +};
> +
> +static int rt9756_check_device_model(struct rt9756_data *data)
> +{
> +	struct device *dev = data->dev;
> +	unsigned int revid;
> +	int ret;
> +
> +	ret = regmap_field_read(data->rm_fields[F_REVISION], &revid);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to read revid\n");
> +
> +	if (revid == RT9757_REVID || revid == RT9757A_REVID)
> +		data->model = MODEL_RT9757;
> +	else if (revid == RT9756_REVID || revid == RT9756A_REVID)
> +		data->model = MODEL_RT9756;
> +	else
> +		return dev_err_probe(dev, -EINVAL, "Unknown revision %d\n", revid);
> +
> +	return 0;
> +}
> +
> +static int rt9770_check_device_model(struct rt9756_data *data)
> +{
> +	data->model = MODEL_RT9770;
> +	return 0;
> +}
> +
> +static int rt9756_probe(struct i2c_client *i2c)
> +{
> +	const struct rt975x_dev_data *dev_data;
> +	struct device *dev = &i2c->dev;
> +	struct rt9756_data *data;
> +	struct regmap *regmap;
> +	unsigned int devid;
> +	int ret;
> +
> +	dev_data = device_get_match_data(dev);
> +	if (!dev_data)
> +		return dev_err_probe(dev, -EINVAL, "No device data found\n");
> +
> +	data = devm_kzalloc(dev, sizeof(*data), GFP_KERNEL);
> +	if (!data)
> +		return -ENOMEM;
> +
> +	data->dev = dev;
> +	mutex_init(&data->adc_lock);
> +	atomic_set(&data->usb_type, POWER_SUPPLY_USB_TYPE_UNKNOWN);
> +	i2c_set_clientdata(i2c, data);
> +
> +	regmap = devm_regmap_init_i2c(i2c, dev_data->regmap_config);
> +	if (IS_ERR(regmap))
> +		return dev_err_probe(dev, PTR_ERR(regmap), "Failed to init regmap\n");
> +
> +	data->regmap = regmap;
> +
> +	ret = devm_regmap_field_bulk_alloc(dev, regmap, data->rm_fields, dev_data->reg_fields,
> +					   F_MAX_FIELD);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to alloc regmap fields\n");
> +
> +	/* Richtek Device ID check */
> +	ret = regmap_field_read(data->rm_fields[F_DEV_ID], &devid);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to read devid\n");
> +
> +	if (devid != RICHTEK_DEVID)
> +		return dev_err_probe(dev, -ENODEV, "Incorrect VID 0x%02x\n", devid);
> +
> +	/* Get specific model */
> +	ret = dev_data->check_device_model(data);
> +	if (ret)
> +		return ret;
> +
> +	ret = regmap_register_patch(regmap, dev_data->init_regs, dev_data->num_init_regs);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to init registers\n");
> +
> +	ret = rt9756_config_batsense_resistor(data);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to config batsense resistor\n");
> +
> +	ret = rt9756_register_psy(data);
> +	if (ret)
> +		return dev_err_probe(dev, ret, "Failed to init power supply\n");
> +
> +	return devm_request_threaded_irq(dev, i2c->irq, NULL, rt9756_irq_handler, IRQF_ONESHOT,
> +					 dev_name(dev), data);
> +}
> +
> +static void rt9756_shutdown(struct i2c_client *i2c)
> +{
> +	struct rt9756_data *data = i2c_get_clientdata(i2c);
> +
> +	regmap_field_write(data->rm_fields[F_REG_RST], 1);
> +}
> +
> +static const struct rt975x_dev_data rt9756_dev_data = {
> +	.regmap_config		= &rt9756_regmap_config,
> +	.reg_fields		= rt9756_chg_fields,
> +	.init_regs		= rt9756_init_regs,
> +	.num_init_regs		= ARRAY_SIZE(rt9756_init_regs),
> +	.check_device_model	= rt9756_check_device_model,
> +};
> +
> +static const struct rt975x_dev_data rt9770_dev_data = {
> +	.regmap_config		= &rt9770_regmap_config,
> +	.reg_fields		= rt9770_chg_fields,
> +	.init_regs		= rt9770_init_regs,
> +	.num_init_regs		= ARRAY_SIZE(rt9770_init_regs),
> +	.check_device_model	= rt9770_check_device_model,
> +};
> +
> +static const struct of_device_id rt9756_device_match_table[] = {
> +	{ .compatible = "richtek,rt9756", .data = &rt9756_dev_data },
> +	{ .compatible = "richtek,rt9770", .data = &rt9770_dev_data },
> +	{}
> +};
> +MODULE_DEVICE_TABLE(of, rt9756_device_match_table);
> +
> +static struct i2c_driver rt9756_charger_driver = {
> +	.driver = {
> +		.name = "rt9756",
> +		.of_match_table = rt9756_device_match_table,
> +	},
> +	.probe = rt9756_probe,
> +	.shutdown = rt9756_shutdown,
> +};
> +module_i2c_driver(rt9756_charger_driver);
> +
> +MODULE_DESCRIPTION("Richtek RT9756 charger driver");
> +MODULE_AUTHOR("ChiYuan Huang <cy_huang@...htek.com>");
> +MODULE_LICENSE("GPL");
> -- 
> 2.34.1
> 

Download attachment "signature.asc" of type "application/pgp-signature" (834 bytes)

Powered by blists - more mailing lists