From mboxrd@z Thu Jan 1 00:00:00 1970 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id CD479C6FA86 for ; Mon, 12 Sep 2022 10:28:42 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S229527AbiILK2l (ORCPT ); Mon, 12 Sep 2022 06:28:41 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:49860 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S230162AbiILK2k (ORCPT ); Mon, 12 Sep 2022 06:28:40 -0400 Received: from madras.collabora.co.uk (madras.collabora.co.uk [46.235.227.172]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 166AF1B7B0; Mon, 12 Sep 2022 03:28:36 -0700 (PDT) Received: from mercury (unknown [185.122.133.20]) (using TLSv1.3 with cipher TLS_AES_256_GCM_SHA384 (256/256 bits) key-exchange X25519 server-signature RSA-PSS (4096 bits) server-digest SHA256) (No client certificate requested) (Authenticated sender: sre) by madras.collabora.co.uk (Postfix) with ESMTPSA id BC86C6601FDB; Mon, 12 Sep 2022 11:28:34 +0100 (BST) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=collabora.com; s=mail; t=1662978514; bh=mCQSK0s6vzQCvM2HKZv1+cvttCDGFozFzPPMDYSd7AA=; h=Date:From:To:Cc:Subject:References:In-Reply-To:From; b=ZKCPsx2IteS2VwCqrBj42KCp2eSgCVbfZAXYG0r2/R2DS6unEhuKjm7MgLIsyGqBO ijsvxGhScEYXeDUdAHRuBS/Oy+Bd8yJmF66xp9qOZRhqf2X9r3m+P/H+jvbVSdUq6Z Os7bE1d4gWio4J2BZx4bIz+pXBlFDuZNYYK8hSauaQqyNB34TVphJVNqZom7wIglUH 1XM5SN13CcakF6oji9cH8TLCE+JdO6vyZeq6pxPIYkttGqDC+OXTbXTlTIT9h7A928 6V0ysrhcUgFFqU32IZldk2U8/Y3fdHsm+nLJuVdGUHgFVgiKhMzqgPUPdSPHA7HFt3 n0GdjJWBupSVQ== Received: by mercury (Postfix, from userid 1000) id 0B0EA1063348; Sun, 11 Sep 2022 14:16:07 +0200 (CEST) Date: Sun, 11 Sep 2022 14:16:07 +0200 From: Sebastian Reichel To: lee@kernel.org, Chris Morgan Cc: linux-pm@vger.kernel.org, linux-rockchip@lists.infradead.org, devicetree@vger.kernel.org, zhangqing@rock-chips.com, zyw@rock-chips.com, jon.lin@rock-chips.com, maccraft123mc@gmail.com, heiko@sntech.de, krzysztof.kozlowski+dt@linaro.org, robh+dt@kernel.org, philip@pscan.uk, mazziesaccount@gmail.com, Chris Morgan Subject: Re: [PATCH V10 3/4] power: supply: Add charger driver for Rockchip RK817 Message-ID: <20220911121607.q2yah7msv7argxts@mercury.elektranox.org> References: <20220827021623.23829-1-macroalpha82@gmail.com> <20220827021623.23829-4-macroalpha82@gmail.com> MIME-Version: 1.0 Content-Type: multipart/signed; micalg=pgp-sha512; protocol="application/pgp-signature"; boundary="7lhanzew6atwvykv" Content-Disposition: inline In-Reply-To: <20220827021623.23829-4-macroalpha82@gmail.com> Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org --7lhanzew6atwvykv Content-Type: text/plain; charset=us-ascii Content-Disposition: inline Content-Transfer-Encoding: quoted-printable Hi, On Fri, Aug 26, 2022 at 09:16:22PM -0500, Chris Morgan wrote: > From: Chris Morgan >=20 > Add support for the Rockchip rk817 battery charger integrated into the > rk817 PMIC. >=20 > Signed-off-by: Chris Morgan > Signed-off-by: Maya Matuszczyk > --- I can't pick this, since it depends on the previous patch merged by Lee. I suppose the easiest route now is for Lee to queue this patch via MFD, so: Acked-by: Sebastian Reichel -- Sebastian > drivers/power/supply/Kconfig | 6 + > drivers/power/supply/Makefile | 1 + > drivers/power/supply/rk817_charger.c | 1211 ++++++++++++++++++++++++++ > 3 files changed, 1218 insertions(+) > create mode 100644 drivers/power/supply/rk817_charger.c >=20 > diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig > index 1aa8323ad9f6..56e70a68679a 100644 > --- a/drivers/power/supply/Kconfig > +++ b/drivers/power/supply/Kconfig > @@ -708,6 +708,12 @@ config CHARGER_BQ256XX > charge management and system power path management devices for single > cell Li-ion and Li-polymer batteries. > =20 > +config CHARGER_RK817 > + tristate "Rockchip RK817 PMIC Battery Charger" > + depends on MFD_RK808 > + help > + Say Y to include support for Rockchip RK817 Battery Charger. > + > config CHARGER_SMB347 > tristate "Summit Microelectronics SMB3XX Battery Charger" > depends on I2C > diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile > index 7f02f36aea55..3040a1de81b8 100644 > --- a/drivers/power/supply/Makefile > +++ b/drivers/power/supply/Makefile > @@ -91,6 +91,7 @@ obj-$(CONFIG_CHARGER_BQ2515X) +=3D bq2515x_charger.o > obj-$(CONFIG_CHARGER_BQ25890) +=3D bq25890_charger.o > obj-$(CONFIG_CHARGER_BQ25980) +=3D bq25980_charger.o > obj-$(CONFIG_CHARGER_BQ256XX) +=3D bq256xx_charger.o > +obj-$(CONFIG_CHARGER_RK817) +=3D rk817_charger.o > obj-$(CONFIG_CHARGER_SMB347) +=3D smb347-charger.o > obj-$(CONFIG_CHARGER_TPS65090) +=3D tps65090-charger.o > obj-$(CONFIG_CHARGER_TPS65217) +=3D tps65217_charger.o > diff --git a/drivers/power/supply/rk817_charger.c b/drivers/power/supply/= rk817_charger.c > new file mode 100644 > index 000000000000..635f051b0821 > --- /dev/null > +++ b/drivers/power/supply/rk817_charger.c > @@ -0,0 +1,1211 @@ > +// SPDX-License-Identifier: GPL-2.0+ > +/* > + * Charger Driver for Rockchip rk817 > + * > + * Copyright (c) 2021 Maya Matuszczyk > + * > + * Authors: Maya Matuszczyk > + * Chris Morgan > + */ > + > +#include > +#include > +#include > +#include > +#include > +#include > +#include > +#include > + > +/* Charging statuses reported by hardware register */ > +enum rk817_charge_status { > + CHRG_OFF, > + DEAD_CHRG, > + TRICKLE_CHRG, > + CC_OR_CV_CHRG, > + CHARGE_FINISH, > + USB_OVER_VOL, > + BAT_TMP_ERR, > + BAT_TIM_ERR, > +}; > + > +/* > + * Max charging current read to/written from hardware register. > + * Note how highest value corresponding to 0x7 is the lowest > + * current, this is per the datasheet. > + */ > +enum rk817_chg_cur { > + CHG_1A, > + CHG_1_5A, > + CHG_2A, > + CHG_2_5A, > + CHG_2_75A, > + CHG_3A, > + CHG_3_5A, > + CHG_0_5A, > +}; > + > +struct rk817_charger { > + struct device *dev; > + struct rk808 *rk808; > + > + struct power_supply *bat_ps; > + struct power_supply *chg_ps; > + bool plugged_in; > + bool battery_present; > + > + /* > + * voltage_k and voltage_b values are used to calibrate the ADC > + * voltage readings. While they are documented in the BSP kernel and > + * datasheet as voltage_k and voltage_b, there is no further > + * information explaining them in more detail. > + */ > + > + uint32_t voltage_k; > + uint32_t voltage_b; > + > + /* > + * soc - state of charge - like the BSP this is stored as a percentage, > + * to the thousandth. BSP has a display state of charge (dsoc) and a > + * remaining state of charge (rsoc). This value will be used for both > + * purposes here so we don't do any fancy math to try and "smooth" the > + * charge and just report it as it is. Note for example an soc of 100 > + * is stored as 100000, an soc of 50 is stored as 50000, etc. > + */ > + int soc; > + > + /* > + * Capacity of battery when fully charged, equal or less than design > + * capacity depending upon wear. BSP kernel saves to nvram in mAh, > + * so this value is in mAh not the standard uAh. > + */ > + int fcc_mah; > + > + /* > + * Calibrate the SOC on a fully charged battery, this way we can use > + * the calibrated SOC value to correct for columb counter drift. > + */ > + bool soc_cal; > + > + /* Implementation specific immutable properties from device tree */ > + int res_div; > + int sleep_enter_current_ua; > + int sleep_filter_current_ua; > + int bat_charge_full_design_uah; > + int bat_voltage_min_design_uv; > + int bat_voltage_max_design_uv; > + > + /* Values updated periodically by driver for display. */ > + int charge_now_uah; > + int volt_avg_uv; > + int cur_avg_ua; > + int max_chg_cur_ua; > + int max_chg_volt_uv; > + int charge_status; > + int charger_input_volt_avg_uv; > + > + /* Work queue to periodically update values. */ > + struct delayed_work work; > +}; > + > +/* ADC coefficients extracted from BSP kernel */ > +#define ADC_TO_CURRENT(adc_value, res_div) \ > + (adc_value * 172 / res_div) > + > +#define CURRENT_TO_ADC(current, samp_res) \ > + (current * samp_res / 172) > + > +#define CHARGE_TO_ADC(capacity, res_div) \ > + (capacity * res_div * 3600 / 172 * 1000) > + > +#define ADC_TO_CHARGE_UAH(adc_value, res_div) \ > + (adc_value / 3600 * 172 / res_div) > + > +static u8 rk817_chg_cur_to_reg(u32 chg_cur_ma) > +{ > + if (chg_cur_ma >=3D 3500) > + return CHG_3_5A; > + else if (chg_cur_ma >=3D 3000) > + return CHG_3A; > + else if (chg_cur_ma >=3D 2750) > + return CHG_2_75A; > + else if (chg_cur_ma >=3D 2500) > + return CHG_2_5A; > + else if (chg_cur_ma >=3D 2000) > + return CHG_2A; > + else if (chg_cur_ma >=3D 1500) > + return CHG_1_5A; > + else if (chg_cur_ma >=3D 1000) > + return CHG_1A; > + else if (chg_cur_ma >=3D 500) > + return CHG_0_5A; > + else > + return -EINVAL; > +} > + > +static int rk817_chg_cur_from_reg(u8 reg) > +{ > + switch (reg) { > + case CHG_0_5A: > + return 500000; > + case CHG_1A: > + return 1000000; > + case CHG_1_5A: > + return 1500000; > + case CHG_2A: > + return 2000000; > + case CHG_2_5A: > + return 2500000; > + case CHG_2_75A: > + return 2750000; > + case CHG_3A: > + return 3000000; > + case CHG_3_5A: > + return 3500000; > + default: > + return -EINVAL; > + } > +} > + > +static void rk817_bat_calib_vol(struct rk817_charger *charger) > +{ > + uint32_t vcalib0 =3D 0; > + uint32_t vcalib1 =3D 0; > + u8 bulk_reg[2]; > + > + /* calibrate voltage */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_VCALIB0_H, > + bulk_reg, 2); > + vcalib0 =3D get_unaligned_be16(bulk_reg); > + > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_VCALIB1_H, > + bulk_reg, 2); > + vcalib1 =3D get_unaligned_be16(bulk_reg); > + > + /* values were taken from BSP kernel */ > + charger->voltage_k =3D (4025 - 2300) * 1000 / > + ((vcalib1 - vcalib0) ? (vcalib1 - vcalib0) : 1); > + charger->voltage_b =3D 4025 - (charger->voltage_k * vcalib1) / 1000; > +} > + > +static void rk817_bat_calib_cur(struct rk817_charger *charger) > +{ > + u8 bulk_reg[2]; > + > + /* calibrate current */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_IOFFSET_H, > + bulk_reg, 2); > + regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_CAL_OFFSET_H, > + bulk_reg, 2); > +} > + > +/* > + * note that only the fcc_mah is really used by this driver, the other v= alues > + * are to ensure we can remain backwards compatible with the BSP kernel. > + */ > +static int rk817_record_battery_nvram_values(struct rk817_charger *charg= er) > +{ > + u8 bulk_reg[3]; > + int ret, rsoc; > + > + /* > + * write the soc value to the nvram location used by the BSP kernel > + * for the dsoc value. > + */ > + put_unaligned_le24(charger->soc, bulk_reg); > + ret =3D regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_R= 1, > + bulk_reg, 3); > + if (ret < 0) > + return ret; > + /* > + * write the remaining capacity in mah to the nvram location used by > + * the BSP kernel for the rsoc value. > + */ > + rsoc =3D (charger->soc * charger->fcc_mah) / 100000; > + put_unaligned_le24(rsoc, bulk_reg); > + ret =3D regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_DATA0, > + bulk_reg, 3); > + if (ret < 0) > + return ret; > + /* write the fcc_mah in mAh, just as the BSP kernel does. */ > + put_unaligned_le24(charger->fcc_mah, bulk_reg); > + ret =3D regmap_bulk_write(charger->rk808->regmap, RK817_GAS_GAUGE_DATA3, > + bulk_reg, 3); > + if (ret < 0) > + return ret; > + > + return 0; > +} > + > +static int rk817_bat_calib_cap(struct rk817_charger *charger) > +{ > + struct rk808 *rk808 =3D charger->rk808; > + int tmp, charge_now, charge_now_adc, volt_avg; > + u8 bulk_reg[4]; > + > + /* Calibrate the soc and fcc on a fully charged battery */ > + > + if (charger->charge_status =3D=3D CHARGE_FINISH && (!charger->soc_cal))= { > + /* > + * soc should be 100000 and columb counter should show the full > + * charge capacity. Note that if the device is unplugged for a > + * period of several days the columb counter will have a large > + * margin of error, so setting it back to the full charge on > + * a completed charge cycle should correct this (my device was > + * showing 33% battery after 3 days unplugged when it should > + * have been closer to 95% based on voltage and charge > + * current). > + */ > + > + charger->soc =3D 100000; > + charge_now_adc =3D CHARGE_TO_ADC(charger->fcc_mah, > + charger->res_div); > + put_unaligned_be32(charge_now_adc, bulk_reg); > + regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H3, > + bulk_reg, 4); > + > + charger->soc_cal =3D 1; > + dev_dbg(charger->dev, > + "Fully charged. SOC is %d, full capacity is %d\n", > + charger->soc, charger->fcc_mah * 1000); > + } > + > + /* > + * The columb counter can drift up slightly, so we should correct for > + * it. But don't correct it until we're at 100% soc. > + */ > + if (charger->charge_status =3D=3D CHARGE_FINISH && charger->soc_cal) { > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, > + bulk_reg, 4); > + charge_now_adc =3D get_unaligned_be32(bulk_reg); > + if (charge_now_adc < 0) > + return charge_now_adc; > + charge_now =3D ADC_TO_CHARGE_UAH(charge_now_adc, > + charger->res_div); > + > + /* > + * Re-init columb counter with updated values to correct drift. > + */ > + if (charge_now / 1000 > charger->fcc_mah) { > + dev_dbg(charger->dev, > + "Recalibrating columb counter to %d uah\n", > + charge_now); > + /* > + * Order of operations matters here to ensure we keep > + * enough precision until the last step to keep from > + * making needless updates to columb counter. > + */ > + charge_now_adc =3D CHARGE_TO_ADC(charger->fcc_mah, > + charger->res_div); > + put_unaligned_be32(charge_now_adc, bulk_reg); > + regmap_bulk_write(rk808->regmap, > + RK817_GAS_GAUGE_Q_INIT_H3, > + bulk_reg, 4); > + } > + } > + > + /* > + * Calibrate the fully charged capacity when we previously had a full > + * battery (soc_cal =3D 1) and are now empty (at or below minimum design > + * voltage). If our columb counter is still positive, subtract that > + * from our fcc value to get a calibrated fcc, and if our columb > + * counter is negative add that to our fcc (but not to exceed our > + * design capacity). > + */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_VOL_H, > + bulk_reg, 2); > + tmp =3D get_unaligned_be16(bulk_reg); > + volt_avg =3D (charger->voltage_k * tmp) + 1000 * charger->voltage_b; > + if (volt_avg <=3D charger->bat_voltage_min_design_uv && > + charger->soc_cal) { > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, > + bulk_reg, 4); > + charge_now_adc =3D get_unaligned_be32(bulk_reg); > + charge_now =3D ADC_TO_CHARGE_UAH(charge_now_adc, > + charger->res_div); > + /* > + * Note, if charge_now is negative this will add it (what we > + * want) and if it's positive this will subtract (also what > + * we want). > + */ > + charger->fcc_mah =3D charger->fcc_mah - (charge_now / 1000); > + > + dev_dbg(charger->dev, > + "Recalibrating full charge capacity to %d uah\n", > + charger->fcc_mah * 1000); > + } > + > + rk817_record_battery_nvram_values(charger); > + > + return 0; > +} > + > +static void rk817_read_props(struct rk817_charger *charger) > +{ > + int tmp, reg; > + u8 bulk_reg[4]; > + > + /* > + * Recalibrate voltage and current readings if we need to BSP does both > + * on CUR_CALIB_UPD, ignoring VOL_CALIB_UPD. Curiously enough, both > + * documentation and the BSP show that you perform an update if bit 7 > + * is 1, but you clear the status by writing a 1 to bit 7. > + */ > + regmap_read(charger->rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG1, ®); > + if (reg & RK817_VOL_CUR_CALIB_UPD) { > + rk817_bat_calib_cur(charger); > + rk817_bat_calib_vol(charger); > + regmap_write_bits(charger->rk808->regmap, > + RK817_GAS_GAUGE_ADC_CONFIG1, > + RK817_VOL_CUR_CALIB_UPD, > + RK817_VOL_CUR_CALIB_UPD); > + } > + > + /* Update reported charge. */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, > + bulk_reg, 4); > + tmp =3D get_unaligned_be32(bulk_reg); > + charger->charge_now_uah =3D ADC_TO_CHARGE_UAH(tmp, charger->res_div); > + if (charger->charge_now_uah < 0) > + charger->charge_now_uah =3D 0; > + if (charger->charge_now_uah > charger->fcc_mah * 1000) > + charger->charge_now_uah =3D charger->fcc_mah * 1000; > + > + /* Update soc based on reported charge. */ > + charger->soc =3D charger->charge_now_uah * 100 / charger->fcc_mah; > + > + /* Update reported voltage. */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_VOL_H, > + bulk_reg, 2); > + tmp =3D get_unaligned_be16(bulk_reg); > + charger->volt_avg_uv =3D (charger->voltage_k * tmp) + 1000 * > + charger->voltage_b; > + > + /* > + * Update reported current. Note value from registers is a signed 16 > + * bit int. > + */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_BAT_CUR_H, > + bulk_reg, 2); > + tmp =3D (short int)get_unaligned_be16(bulk_reg); > + charger->cur_avg_ua =3D ADC_TO_CURRENT(tmp, charger->res_div); > + > + /* > + * Update the max charge current. This value shouldn't change, but we > + * can read it to report what the PMIC says it is instead of simply > + * returning the default value. > + */ > + regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_OUT, ®); > + charger->max_chg_cur_ua =3D > + rk817_chg_cur_from_reg(reg & RK817_CHRG_CUR_SEL); > + > + /* > + * Update max charge voltage. Like the max charge current this value > + * shouldn't change, but we can report what the PMIC says. > + */ > + regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_OUT, ®); > + charger->max_chg_volt_uv =3D ((((reg & RK817_CHRG_VOL_SEL) >> 4) * > + 50000) + 4100000); > + > + /* Check if battery still present. */ > + regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_STS, ®); > + charger->battery_present =3D (reg & RK817_BAT_EXS); > + > + /* Get which type of charge we are using (if any). */ > + regmap_read(charger->rk808->regmap, RK817_PMIC_CHRG_STS, ®); > + charger->charge_status =3D (reg >> 4) & 0x07; > + > + /* > + * Get charger input voltage. Note that on my example hardware (an > + * Odroid Go Advance) the voltage of the power connector is measured > + * on the register labelled USB in the datasheet; I don't know if this > + * is how it is designed or just a quirk of the implementation. I > + * believe this will also measure the voltage of the USB output when in > + * OTG mode, if that is the case we may need to change this in the > + * future to return 0 if the power supply status is offline (I can't > + * test this with my current implementation. Also, when the voltage > + * should be zero sometimes the ADC still shows a single bit (which > + * would register as 20000uv). When this happens set it to 0. > + */ > + regmap_bulk_read(charger->rk808->regmap, RK817_GAS_GAUGE_USB_VOL_H, > + bulk_reg, 2); > + reg =3D get_unaligned_be16(bulk_reg); > + if (reg > 1) { > + tmp =3D ((charger->voltage_k * reg / 1000 + charger->voltage_b) * > + 60 / 46); > + charger->charger_input_volt_avg_uv =3D tmp * 1000; > + } else { > + charger->charger_input_volt_avg_uv =3D 0; > + } > + > + /* Calibrate battery capacity and soc. */ > + rk817_bat_calib_cap(charger); > +} > + > +static int rk817_bat_get_prop(struct power_supply *ps, > + enum power_supply_property prop, > + union power_supply_propval *val) > +{ > + struct rk817_charger *charger =3D power_supply_get_drvdata(ps); > + > + switch (prop) { > + case POWER_SUPPLY_PROP_PRESENT: > + val->intval =3D charger->battery_present; > + break; > + case POWER_SUPPLY_PROP_STATUS: > + if (charger->cur_avg_ua < 0) { > + val->intval =3D POWER_SUPPLY_STATUS_DISCHARGING; > + break; > + } > + switch (charger->charge_status) { > + case CHRG_OFF: > + val->intval =3D POWER_SUPPLY_STATUS_NOT_CHARGING; > + break; > + /* > + * Dead charge is documented, but not explained. I never > + * observed it but assume it's a pre-charge for a dead > + * battery. > + */ > + case DEAD_CHRG: > + case TRICKLE_CHRG: > + case CC_OR_CV_CHRG: > + val->intval =3D POWER_SUPPLY_STATUS_CHARGING; > + break; > + case CHARGE_FINISH: > + val->intval =3D POWER_SUPPLY_STATUS_FULL; > + break; > + default: > + val->intval =3D POWER_SUPPLY_STATUS_UNKNOWN; > + return -EINVAL; > + > + } > + break; > + case POWER_SUPPLY_PROP_CHARGE_TYPE: > + switch (charger->charge_status) { > + case CHRG_OFF: > + case CHARGE_FINISH: > + val->intval =3D POWER_SUPPLY_CHARGE_TYPE_NONE; > + break; > + case TRICKLE_CHRG: > + val->intval =3D POWER_SUPPLY_CHARGE_TYPE_TRICKLE; > + break; > + case DEAD_CHRG: > + case CC_OR_CV_CHRG: > + val->intval =3D POWER_SUPPLY_CHARGE_TYPE_STANDARD; > + break; > + default: > + val->intval =3D POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; > + break; > + } > + break; > + case POWER_SUPPLY_PROP_CHARGE_FULL: > + val->intval =3D charger->fcc_mah * 1000; > + break; > + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: > + val->intval =3D charger->bat_charge_full_design_uah; > + break; > + case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: > + val->intval =3D 0; > + break; > + case POWER_SUPPLY_PROP_CHARGE_NOW: > + val->intval =3D charger->charge_now_uah; > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: > + val->intval =3D charger->bat_voltage_min_design_uv; > + break; > + case POWER_SUPPLY_PROP_CAPACITY: > + /* Add 500 so that values like 99999 are 100% not 99%. */ > + val->intval =3D (charger->soc + 500) / 1000; > + if (val->intval > 100) > + val->intval =3D 100; > + if (val->intval < 0) > + val->intval =3D 0; > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_AVG: > + val->intval =3D charger->volt_avg_uv; > + break; > + case POWER_SUPPLY_PROP_CURRENT_AVG: > + val->intval =3D charger->cur_avg_ua; > + break; > + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: > + val->intval =3D charger->max_chg_cur_ua; > + break; > + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: > + val->intval =3D charger->max_chg_volt_uv; > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: > + val->intval =3D charger->bat_voltage_max_design_uv; > + break; > + default: > + return -EINVAL; > + } > + return 0; > +} > + > +static int rk817_chg_get_prop(struct power_supply *ps, > + enum power_supply_property prop, > + union power_supply_propval *val) > +{ > + struct rk817_charger *charger =3D power_supply_get_drvdata(ps); > + > + switch (prop) { > + case POWER_SUPPLY_PROP_ONLINE: > + val->intval =3D charger->plugged_in; > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: > + /* max voltage from datasheet at 5.5v (default 5.0v) */ > + val->intval =3D 5500000; > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: > + /* min voltage from datasheet at 3.8v (default 5.0v) */ > + val->intval =3D 3800000; > + break; > + case POWER_SUPPLY_PROP_VOLTAGE_AVG: > + val->intval =3D charger->charger_input_volt_avg_uv; > + break; > + /* > + * While it's possible that other implementations could use different > + * USB types, the current implementation for this PMIC (the Odroid Go > + * Advance) only uses a dedicated charging port with no rx/tx lines. > + */ > + case POWER_SUPPLY_PROP_USB_TYPE: > + val->intval =3D POWER_SUPPLY_USB_TYPE_DCP; > + break; > + default: > + return -EINVAL; > + } > + return 0; > + > +} > + > +static irqreturn_t rk817_plug_in_isr(int irq, void *cg) > +{ > + struct rk817_charger *charger; > + > + charger =3D (struct rk817_charger *)cg; > + charger->plugged_in =3D 1; > + power_supply_changed(charger->chg_ps); > + power_supply_changed(charger->bat_ps); > + /* try to recalibrate capacity if we hit full charge. */ > + charger->soc_cal =3D 0; > + > + rk817_read_props(charger); > + > + dev_dbg(charger->dev, "Power Cord Inserted\n"); > + > + return IRQ_HANDLED; > +} > + > +static irqreturn_t rk817_plug_out_isr(int irq, void *cg) > +{ > + struct rk817_charger *charger; > + struct rk808 *rk808; > + > + charger =3D (struct rk817_charger *)cg; > + rk808 =3D charger->rk808; > + charger->plugged_in =3D 0; > + power_supply_changed(charger->bat_ps); > + power_supply_changed(charger->chg_ps); > + > + /* > + * For some reason the bits of RK817_PMIC_CHRG_IN reset whenever the > + * power cord is unplugged. This was not documented in the BSP kernel > + * or the datasheet and only discovered by trial and error. Set minimum > + * USB input voltage to 4.5v and enable USB voltage input limit. > + */ > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, > + RK817_USB_VLIM_SEL, (0x05 << 4)); > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_VLIM_EN, > + (0x01 << 7)); > + > + /* > + * Set average USB input current limit to 1.5A and enable USB current > + * input limit. > + */ > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, > + RK817_USB_ILIM_SEL, 0x03); > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_ILIM_EN, > + (0x01 << 3)); > + > + rk817_read_props(charger); > + > + dev_dbg(charger->dev, "Power Cord Removed\n"); > + > + return IRQ_HANDLED; > +} > + > +static enum power_supply_property rk817_bat_props[] =3D { > + POWER_SUPPLY_PROP_PRESENT, > + POWER_SUPPLY_PROP_STATUS, > + POWER_SUPPLY_PROP_CHARGE_TYPE, > + POWER_SUPPLY_PROP_CHARGE_FULL, > + POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN, > + POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN, > + POWER_SUPPLY_PROP_CHARGE_NOW, > + POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, > + POWER_SUPPLY_PROP_VOLTAGE_AVG, > + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, > + POWER_SUPPLY_PROP_CURRENT_AVG, > + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, > + POWER_SUPPLY_PROP_CAPACITY, > + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, > +}; > + > +static enum power_supply_property rk817_chg_props[] =3D { > + POWER_SUPPLY_PROP_ONLINE, > + POWER_SUPPLY_PROP_USB_TYPE, > + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, > + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, > + POWER_SUPPLY_PROP_VOLTAGE_AVG, > +}; > + > +static enum power_supply_usb_type rk817_usb_type[] =3D { > + POWER_SUPPLY_USB_TYPE_DCP, > + POWER_SUPPLY_USB_TYPE_UNKNOWN, > +}; > + > +static const struct power_supply_desc rk817_bat_desc =3D { > + .name =3D "rk817-battery", > + .type =3D POWER_SUPPLY_TYPE_BATTERY, > + .properties =3D rk817_bat_props, > + .num_properties =3D ARRAY_SIZE(rk817_bat_props), > + .get_property =3D rk817_bat_get_prop, > +}; > + > +static const struct power_supply_desc rk817_chg_desc =3D { > + .name =3D "rk817-charger", > + .type =3D POWER_SUPPLY_TYPE_USB, > + .usb_types =3D rk817_usb_type, > + .num_usb_types =3D ARRAY_SIZE(rk817_usb_type), > + .properties =3D rk817_chg_props, > + .num_properties =3D ARRAY_SIZE(rk817_chg_props), > + .get_property =3D rk817_chg_get_prop, > +}; > + > +static int rk817_read_battery_nvram_values(struct rk817_charger *charger) > +{ > + u8 bulk_reg[3]; > + int ret; > + > + /* Read the nvram data for full charge capacity. */ > + ret =3D regmap_bulk_read(charger->rk808->regmap, > + RK817_GAS_GAUGE_DATA3, bulk_reg, 3); > + if (ret < 0) > + return ret; > + charger->fcc_mah =3D get_unaligned_le24(bulk_reg); > + > + /* > + * Sanity checking for values equal to zero or less than would be > + * practical for this device (BSP Kernel assumes 500mAH or less) for > + * practicality purposes. Also check if the value is too large and > + * correct it. > + */ > + if ((charger->fcc_mah < 500) || > + ((charger->fcc_mah * 1000) > charger->bat_charge_full_design_uah)) { > + dev_info(charger->dev, > + "Invalid NVRAM max charge, setting to %u uAH\n", > + charger->bat_charge_full_design_uah); > + charger->fcc_mah =3D charger->bat_charge_full_design_uah / 1000; > + } > + > + /* > + * Read the nvram for state of charge. Sanity check for values greater > + * than 100 (10000). If the value is off it should get corrected > + * automatically when the voltage drops to the min (soc is 0) or when > + * the battery is full (soc is 100). > + */ > + ret =3D regmap_bulk_read(charger->rk808->regmap, > + RK817_GAS_GAUGE_BAT_R1, bulk_reg, 3); > + if (ret < 0) > + return ret; > + charger->soc =3D get_unaligned_le24(bulk_reg); > + if (charger->soc > 10000) > + charger->soc =3D 10000; > + > + return 0; > +} > + > +static int > +rk817_read_or_set_full_charge_on_boot(struct rk817_charger *charger, > + struct power_supply_battery_info *bat_info) > +{ > + struct rk808 *rk808 =3D charger->rk808; > + u8 bulk_reg[4]; > + u32 boot_voltage, boot_charge_mah, tmp; > + int ret, reg, off_time; > + bool first_boot; > + > + /* > + * Check if the battery is uninitalized. If it is, the columb counter > + * needs to be set up. > + */ > + ret =3D regmap_read(rk808->regmap, RK817_GAS_GAUGE_GG_STS, ®); > + if (ret < 0) > + return ret; > + first_boot =3D reg & RK817_BAT_CON; > + /* > + * If the battery is uninitialized, use the poweron voltage and an ocv > + * lookup to guess our charge. The number won't be very accurate until > + * we hit either our minimum voltage (0%) or full charge (100%). > + */ > + if (first_boot) { > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_PWRON_VOL_H, > + bulk_reg, 2); > + tmp =3D get_unaligned_be16(bulk_reg); > + boot_voltage =3D (charger->voltage_k * tmp) + > + 1000 * charger->voltage_b; > + /* > + * Since only implementation has no working thermistor, assume > + * 20C for OCV lookup. If lookup fails, report error with OCV > + * table. > + */ > + charger->soc =3D power_supply_batinfo_ocv2cap(bat_info, > + boot_voltage, > + 20) * 1000; > + if (charger->soc < 0) > + charger->soc =3D 0; > + > + /* Guess that full charge capacity is the design capacity */ > + charger->fcc_mah =3D charger->bat_charge_full_design_uah / 1000; > + /* > + * Set battery as "set up". BSP driver uses this value even > + * though datasheet claims it's a read-only value. > + */ > + regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_GG_STS, > + RK817_BAT_CON, 0); > + /* Save nvram values */ > + ret =3D rk817_record_battery_nvram_values(charger); > + if (ret < 0) > + return ret; > + } else { > + ret =3D rk817_read_battery_nvram_values(charger); > + if (ret < 0) > + return ret; > + > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, > + bulk_reg, 4); > + tmp =3D get_unaligned_be32(bulk_reg); > + if (tmp < 0) > + tmp =3D 0; > + boot_charge_mah =3D ADC_TO_CHARGE_UAH(tmp, > + charger->res_div) / 1000; > + /* > + * Check if the columb counter has been off for more than 300 > + * minutes as it tends to drift downward. If so, re-init soc > + * with the boot voltage instead. Note the unit values for the > + * OFF_CNT register appear to be in decaminutes and stops > + * counting at 2550 (0xFF) minutes. BSP kernel used OCV, but > + * for me occasionally that would show invalid values. Boot > + * voltage is only accurate for me on first poweron (not > + * reboots), but we shouldn't ever encounter an OFF_CNT more > + * than 0 on a reboot anyway. > + */ > + regmap_read(rk808->regmap, RK817_GAS_GAUGE_OFF_CNT, &off_time); > + if (off_time >=3D 30) { > + regmap_bulk_read(rk808->regmap, > + RK817_GAS_GAUGE_PWRON_VOL_H, > + bulk_reg, 2); > + tmp =3D get_unaligned_be16(bulk_reg); > + boot_voltage =3D (charger->voltage_k * tmp) + > + 1000 * charger->voltage_b; > + charger->soc =3D > + power_supply_batinfo_ocv2cap(bat_info, > + boot_voltage, > + 20) * 1000; > + } else { > + charger->soc =3D (boot_charge_mah * 1000 * 100 / > + charger->fcc_mah); > + } > + } > + > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_PWRON_VOL_H, > + bulk_reg, 2); > + tmp =3D get_unaligned_be16(bulk_reg); > + boot_voltage =3D (charger->voltage_k * tmp) + 1000 * charger->voltage_b; > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, > + bulk_reg, 4); > + tmp =3D get_unaligned_be32(bulk_reg); > + if (tmp < 0) > + tmp =3D 0; > + boot_charge_mah =3D ADC_TO_CHARGE_UAH(tmp, charger->res_div) / 1000; > + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_OCV_VOL_H, > + bulk_reg, 2); > + tmp =3D get_unaligned_be16(bulk_reg); > + boot_voltage =3D (charger->voltage_k * tmp) + 1000 * charger->voltage_b; > + > + /* > + * Now we have our full charge capacity and soc, init the columb > + * counter. > + */ > + boot_charge_mah =3D charger->soc * charger->fcc_mah / 100 / 1000; > + if (boot_charge_mah > charger->fcc_mah) > + boot_charge_mah =3D charger->fcc_mah; > + tmp =3D CHARGE_TO_ADC(boot_charge_mah, charger->res_div); > + put_unaligned_be32(tmp, bulk_reg); > + ret =3D regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H3, > + bulk_reg, 4); > + if (ret < 0) > + return ret; > + > + /* Set QMAX value to max design capacity. */ > + tmp =3D CHARGE_TO_ADC((charger->bat_charge_full_design_uah / 1000), > + charger->res_div); > + put_unaligned_be32(tmp, bulk_reg); > + ret =3D regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_MAX_H3, > + bulk_reg, 4); > + if (ret < 0) > + return ret; > + > + return 0; > +} > + > +static int rk817_battery_init(struct rk817_charger *charger, > + struct power_supply_battery_info *bat_info) > +{ > + struct rk808 *rk808 =3D charger->rk808; > + u32 tmp, max_chg_vol_mv, max_chg_cur_ma; > + u8 max_chg_vol_reg, chg_term_i_reg, max_chg_cur_reg; > + int ret, chg_term_ma; > + u8 bulk_reg[2]; > + > + /* Get initial plug state */ > + regmap_read(rk808->regmap, RK817_SYS_STS, &tmp); > + charger->plugged_in =3D (tmp & RK817_PLUG_IN_STS); > + > + /* > + * Turn on all ADC functions to measure battery, USB, and sys voltage, > + * as well as batt temp. Note only tested implementation so far does > + * not use a battery with a thermistor. > + */ > + regmap_write(rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG0, 0xfc); > + > + /* > + * Set relax mode voltage sampling interval and ADC offset calibration > + * interval to 8 minutes to mirror BSP kernel. Set voltage and current > + * modes to average to mirror BSP kernel. > + */ > + regmap_write(rk808->regmap, RK817_GAS_GAUGE_GG_CON, 0x04); > + > + /* Calibrate voltage like the BSP does here. */ > + rk817_bat_calib_vol(charger); > + > + /* Write relax threshold, derived from sleep enter current. */ > + tmp =3D CURRENT_TO_ADC(charger->sleep_enter_current_ua, > + charger->res_div); > + put_unaligned_be16(tmp, bulk_reg); > + regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_RELAX_THRE_H, > + bulk_reg, 2); > + > + /* Write sleep sample current, derived from sleep filter current. */ > + tmp =3D CURRENT_TO_ADC(charger->sleep_filter_current_ua, > + charger->res_div); > + put_unaligned_be16(tmp, bulk_reg); > + regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_H, > + bulk_reg, 2); > + > + /* Restart battery relax voltage */ > + regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_GG_STS, > + RK817_RELAX_VOL_UPD, (0x0 << 2)); > + > + /* > + * Set OCV Threshold Voltage to 127.5mV. This was hard coded like this > + * in the BSP. > + */ > + regmap_write(rk808->regmap, RK817_GAS_GAUGE_OCV_THRE_VOL, 0xff); > + > + /* > + * Set maximum charging voltage to battery max voltage. Trying to be > + * incredibly safe with these value, as setting them wrong could > + * overcharge the battery, which would be very bad. > + */ > + max_chg_vol_mv =3D bat_info->constant_charge_voltage_max_uv / 1000; > + max_chg_cur_ma =3D bat_info->constant_charge_current_max_ua / 1000; > + > + if (max_chg_vol_mv < 4100) { > + return dev_err_probe(charger->dev, -EINVAL, > + "invalid max charger voltage, value %u unsupported\n", > + max_chg_vol_mv * 1000); > + } > + if (max_chg_vol_mv > 4450) { > + dev_info(charger->dev, > + "Setting max charge voltage to 4450000uv\n"); > + max_chg_vol_mv =3D 4450; > + } > + > + if (max_chg_cur_ma < 500) { > + return dev_err_probe(charger->dev, -EINVAL, > + "invalid max charger current, value %u unsupported\n", > + max_chg_cur_ma * 1000); > + } > + if (max_chg_cur_ma > 3500) > + dev_info(charger->dev, > + "Setting max charge current to 3500000ua\n"); > + > + /* > + * Now that the values are sanity checked, if we subtract 4100 from the > + * max voltage and divide by 50, we conviently get the exact value for > + * the registers, which are 4.1v, 4.15v, 4.2v, 4.25v, 4.3v, 4.35v, > + * 4.4v, and 4.45v; these correspond to values 0x00 through 0x07. > + */ > + max_chg_vol_reg =3D (max_chg_vol_mv - 4100) / 50; > + > + max_chg_cur_reg =3D rk817_chg_cur_to_reg(max_chg_cur_ma); > + > + if (max_chg_vol_reg < 0 || max_chg_vol_reg > 7) { > + return dev_err_probe(charger->dev, -EINVAL, > + "invalid max charger voltage, value %u unsupported\n", > + max_chg_vol_mv * 1000); > + } > + if (max_chg_cur_reg < 0 || max_chg_cur_reg > 7) { > + return dev_err_probe(charger->dev, -EINVAL, > + "invalid max charger current, value %u unsupported\n", > + max_chg_cur_ma * 1000); > + } > + > + /* > + * Write the values to the registers, and deliver an emergency warning > + * in the event they are not written correctly. > + */ > + ret =3D regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_OUT, > + RK817_CHRG_VOL_SEL, (max_chg_vol_reg << 4)); > + if (ret) { > + dev_emerg(charger->dev, > + "Danger, unable to set max charger voltage: %u\n", > + ret); > + } > + > + ret =3D regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_OUT, > + RK817_CHRG_CUR_SEL, max_chg_cur_reg); > + if (ret) { > + dev_emerg(charger->dev, > + "Danger, unable to set max charger current: %u\n", > + ret); > + } > + > + /* Set charge finishing mode to analog */ > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM, > + RK817_CHRG_TERM_ANA_DIG, (0x0 << 2)); > + > + /* > + * Set charge finish current, warn if value not in range and keep > + * default. > + */ > + chg_term_ma =3D bat_info->charge_term_current_ua / 1000; > + if (chg_term_ma < 150 || chg_term_ma > 400) { > + dev_warn(charger->dev, > + "Invalid charge termination %u, keeping default\n", > + chg_term_ma * 1000); > + chg_term_ma =3D 200; > + } > + > + /* > + * Values of 150ma, 200ma, 300ma, and 400ma correspond to 00, 01, 10, > + * and 11. > + */ > + chg_term_i_reg =3D (chg_term_ma - 100) / 100; > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM, > + RK817_CHRG_TERM_ANA_SEL, chg_term_i_reg); > + > + ret =3D rk817_read_or_set_full_charge_on_boot(charger, bat_info); > + if (ret < 0) > + return ret; > + > + /* > + * Set minimum USB input voltage to 4.5v and enable USB voltage input > + * limit. > + */ > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, > + RK817_USB_VLIM_SEL, (0x05 << 4)); > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_VLIM_EN, > + (0x01 << 7)); > + > + /* > + * Set average USB input current limit to 1.5A and enable USB current > + * input limit. > + */ > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, > + RK817_USB_ILIM_SEL, 0x03); > + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_IN, RK817_USB_ILIM_EN, > + (0x01 << 3)); > + > + return 0; > +} > + > +static void rk817_charging_monitor(struct work_struct *work) > +{ > + struct rk817_charger *charger; > + > + charger =3D container_of(work, struct rk817_charger, work.work); > + > + rk817_read_props(charger); > + > + /* Run every 8 seconds like the BSP driver did. */ > + queue_delayed_work(system_wq, &charger->work, msecs_to_jiffies(8000)); > +} > + > +static int rk817_charger_probe(struct platform_device *pdev) > +{ > + struct rk808 *rk808 =3D dev_get_drvdata(pdev->dev.parent); > + struct rk817_charger *charger; > + struct device_node *node; > + struct power_supply_battery_info *bat_info; > + struct device *dev =3D &pdev->dev; > + struct power_supply_config pscfg =3D {}; > + int plugin_irq, plugout_irq; > + int of_value; > + int ret; > + > + node =3D of_get_child_by_name(dev->parent->of_node, "charger"); > + if (!node) > + return -ENODEV; > + > + charger =3D devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL); > + if (!charger) > + return -ENOMEM; > + > + charger->rk808 =3D rk808; > + > + charger->dev =3D &pdev->dev; > + platform_set_drvdata(pdev, charger); > + > + rk817_bat_calib_vol(charger); > + > + pscfg.drv_data =3D charger; > + pscfg.of_node =3D node; > + > + /* > + * Get sample resistor value. Note only values of 10000 or 20000 > + * microohms are allowed. Schematic for my test implementation (an > + * Odroid Go Advance) shows a 10 milliohm resistor for reference. > + */ > + ret =3D of_property_read_u32(node, "rockchip,resistor-sense-micro-ohms", > + &of_value); > + if (ret < 0) { > + return dev_err_probe(dev, ret, > + "Error reading sample resistor value\n"); > + } > + /* > + * Store as a 1 or a 2, since all we really use the value for is as a > + * divisor in some calculations. > + */ > + charger->res_div =3D (of_value =3D=3D 20000) ? 2 : 1; > + > + /* > + * Get sleep enter current value. Not sure what this value is for > + * other than to help calibrate the relax threshold. > + */ > + ret =3D of_property_read_u32(node, > + "rockchip,sleep-enter-current-microamp", > + &of_value); > + if (ret < 0) { > + return dev_err_probe(dev, ret, > + "Error reading sleep enter cur value\n"); > + } > + charger->sleep_enter_current_ua =3D of_value; > + > + /* Get sleep filter current value */ > + ret =3D of_property_read_u32(node, > + "rockchip,sleep-filter-current-microamp", > + &of_value); > + if (ret < 0) { > + return dev_err_probe(dev, ret, > + "Error reading sleep filter cur value\n"); > + } > + > + charger->sleep_filter_current_ua =3D of_value; > + > + charger->bat_ps =3D devm_power_supply_register(&pdev->dev, > + &rk817_bat_desc, &pscfg); > + > + charger->chg_ps =3D devm_power_supply_register(&pdev->dev, > + &rk817_chg_desc, &pscfg); > + > + if (IS_ERR(charger->chg_ps)) > + return dev_err_probe(dev, -EINVAL, > + "Battery failed to probe\n"); > + > + if (IS_ERR(charger->chg_ps)) > + return dev_err_probe(dev, -EINVAL, > + "Charger failed to probe\n"); > + > + ret =3D power_supply_get_battery_info(charger->bat_ps, > + &bat_info); > + if (ret) { > + return dev_err_probe(dev, ret, > + "Unable to get battery info: %d\n", ret); > + } > + > + if ((bat_info->charge_full_design_uah <=3D 0) || > + (bat_info->voltage_min_design_uv <=3D 0) || > + (bat_info->voltage_max_design_uv <=3D 0) || > + (bat_info->constant_charge_voltage_max_uv <=3D 0) || > + (bat_info->constant_charge_current_max_ua <=3D 0) || > + (bat_info->charge_term_current_ua <=3D 0)) { > + return dev_err_probe(dev, -EINVAL, > + "Required bat info missing or invalid\n"); > + } > + > + charger->bat_charge_full_design_uah =3D bat_info->charge_full_design_ua= h; > + charger->bat_voltage_min_design_uv =3D bat_info->voltage_min_design_uv; > + charger->bat_voltage_max_design_uv =3D bat_info->voltage_max_design_uv; > + > + /* > + * Has to run after power_supply_get_battery_info as it depends on some > + * values discovered from that routine. > + */ > + ret =3D rk817_battery_init(charger, bat_info); > + if (ret) > + return ret; > + > + power_supply_put_battery_info(charger->bat_ps, bat_info); > + > + plugin_irq =3D platform_get_irq(pdev, 0); > + if (plugin_irq < 0) > + return plugin_irq; > + > + plugout_irq =3D platform_get_irq(pdev, 1); > + if (plugout_irq < 0) > + return plugout_irq; > + > + ret =3D devm_request_threaded_irq(charger->dev, plugin_irq, NULL, > + rk817_plug_in_isr, > + IRQF_TRIGGER_RISING | IRQF_ONESHOT, > + "rk817_plug_in", charger); > + if (ret) { > + return dev_err_probe(&pdev->dev, ret, > + "plug_in_irq request failed!\n"); > + } > + > + ret =3D devm_request_threaded_irq(charger->dev, plugout_irq, NULL, > + rk817_plug_out_isr, > + IRQF_TRIGGER_RISING | IRQF_ONESHOT, > + "rk817_plug_out", charger); > + if (ret) { > + return dev_err_probe(&pdev->dev, ret, > + "plug_out_irq request failed!\n"); > + } > + > + ret =3D devm_delayed_work_autocancel(&pdev->dev, &charger->work, > + rk817_charging_monitor); > + if (ret) > + return ret; > + > + /* Force the first update immediately. */ > + mod_delayed_work(system_wq, &charger->work, 0); > + > + return 0; > +} > + > + > +static struct platform_driver rk817_charger_driver =3D { > + .probe =3D rk817_charger_probe, > + .driver =3D { > + .name =3D "rk817-charger", > + }, > +}; > +module_platform_driver(rk817_charger_driver); > + > +MODULE_DESCRIPTION("Battery power supply driver for RK817 PMIC"); > +MODULE_AUTHOR("Maya Matuszczyk "); > +MODULE_AUTHOR("Chris Morgan "); > +MODULE_LICENSE("GPL"); > --=20 > 2.25.1 >=20 --7lhanzew6atwvykv Content-Type: application/pgp-signature; name="signature.asc" -----BEGIN PGP SIGNATURE----- iQIzBAABCgAdFiEE72YNB0Y/i3JqeVQT2O7X88g7+poFAmMd0YMACgkQ2O7X88g7 +pqzBg/+JtAbF/H+L5PTirUKbOhc7RgdmoznjB3L/VuiNn54+H2McPmxPojKBFvt aHb6YsRRU+jTZwogo3DZBbqtceeUYKVZ+ts0o0oZtj5hm9bOwRq0f+zgsRQP+RHn uysGK4H1V250HSPhx3wpmEf7PZuvyM4WR/tN2n8NAfnD9vlBv1Pzt91NOWqKm2Gr cWRA+MCxVHU/xvG3bYmVSRYLYW/gA143A8jD5p1QYXmd414aLLMCJ3GQgNP2H9at QsvGEgZBGPRI79m4RSKeeuDYiA2mkuN3mmh1Ya/uZg+2VlLdEkTARDsopAWJZ3M3 smkZIr527b7hmz1t469aPCBTKOhKdspgTbMFYAYnFWCehZPZ8TTJSaS1eEvX/FSe 3vOA7tXehoWLcOEIUvU6p1GCuNQCb6uRJ4viNu9mVL1d+/bxhQWvI7KH3Yw2iz6n N53QhxMXfhm+yci9BfWeFGDIuq+DnXpjeKAd/ZqB1vuL53jlp5J0l11v8tfGPsv7 0k80HNi2BngtFQalhPY2dS98pJ2VYr8eZsI5KfSX7RDf/IURuyRQ3K+VMu8EhG7O UoJ7PQt3wRmtLt9fTUIMNoVWarn5YWYXJK7+Ig+JKt8EyY+BlFArH0GMn5FV9VHi uaVcsQsa5QaCg1crmqdFm4kpNu+lPhmHECjE06XLYFSQOF0/IGI= =WEWY -----END PGP SIGNATURE----- --7lhanzew6atwvykv--