From nobody Mon Feb 9 10:28:15 2026 Received: from smtp.kernel.org (aws-us-west-2-korg-mail-1.web.codeaurora.org [10.30.226.201]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by smtp.subspace.kernel.org (Postfix) with ESMTPS id 56D892EB866; Wed, 21 Jan 2026 01:00:15 +0000 (UTC) Authentication-Results: smtp.subspace.kernel.org; arc=none smtp.client-ip=10.30.226.201 ARC-Seal: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768957215; cv=none; b=AxJ0Sji7He9HWKtykxzOq12s95JAFxqeaYMHoRX3LbuoXxnlXQScGdfvsole10lC1nh/Eqd9ksvAE8SZld5ZUdmnihWxVb6wogTgXJlMSwMFR9SGseULs+w4MFu5k5JZ2RlAmexiyNoHWWI3GWdHcJFz1Kz2+YTZIsI4ALGN5rg= ARC-Message-Signature: i=1; a=rsa-sha256; d=subspace.kernel.org; s=arc-20240116; t=1768957215; c=relaxed/simple; bh=/PC9MUOCxByjN3I0Jc/Q7TZqVjFR10HfUf76dbNxcJ4=; h=From:Date:Subject:MIME-Version:Content-Type:Message-Id:References: In-Reply-To:To:Cc; b=XVgv/mPcgAweUqyrE9Bjoftrn/e04HtMozdaWtUXJktAOefBX4hSwPLbbQJPSAhFaeSzDmfWgeuDZiJxU17ynlDOx7XldOLSIUljnWdkz2YYDOUoZZHNryDm/slvxeYYA7tZ9E/C+oQSxCFQsosi6vaKHfFkymMh+d8MNOZKLOM= ARC-Authentication-Results: i=1; smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b=Ct2rPDiX; arc=none smtp.client-ip=10.30.226.201 Authentication-Results: smtp.subspace.kernel.org; dkim=pass (2048-bit key) header.d=kernel.org header.i=@kernel.org header.b="Ct2rPDiX" Received: by smtp.kernel.org (Postfix) with ESMTPS id 679DBC19425; Wed, 21 Jan 2026 01:00:14 +0000 (UTC) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/simple; d=kernel.org; s=k20201202; t=1768957214; bh=/PC9MUOCxByjN3I0Jc/Q7TZqVjFR10HfUf76dbNxcJ4=; h=From:Date:Subject:References:In-Reply-To:To:Cc:Reply-To:From; b=Ct2rPDiXjV2Fn0tdNDLoPtaSZqChRxtiXEN9mLH6dkqtJyrNje8C12l9EUpvkvaer DCmdptGsjjKWOUMwhhUVxVbihXNJmRFMZcFsayPNqJNP29R3NsFjIBtirjtkWOZtC3 N6e4p9GxhwgDAlbb8nLsBv6/8KADfKnIryoiN200Z/GcZD/nfjxgmQG3OXvpQjTqB9 fjPac/MUxYid1YUw4I5iKfGrqCIo+c67Z9iLVAu7L4t+mT/bw0eUVazNTeSVJwtKhC spOJ1YOExGt30/bpwF2l6qYVMKTO5NbxoBtT7712Uyx7ooQrcrpqV9O+w0X6cgNIEE N3Pcwp7qvlqNw== Received: from aws-us-west-2-korg-lkml-1.web.codeaurora.org (localhost.localdomain [127.0.0.1]) by smtp.lore.kernel.org (Postfix) with ESMTP id 5E5C2D262AF; Wed, 21 Jan 2026 01:00:14 +0000 (UTC) From: Amit Sunil Dhamne via B4 Relay Date: Wed, 21 Jan 2026 00:59:38 +0000 Subject: [PATCH v4 4/5] power: supply: max77759: add charger driver Precedence: bulk X-Mailing-List: linux-kernel@vger.kernel.org List-Id: List-Subscribe: List-Unsubscribe: MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20260121-max77759-charger-v4-4-694234c8ded1@google.com> References: <20260121-max77759-charger-v4-0-694234c8ded1@google.com> In-Reply-To: <20260121-max77759-charger-v4-0-694234c8ded1@google.com> To: Sebastian Reichel , Rob Herring , Krzysztof Kozlowski , Conor Dooley , =?utf-8?q?Andr=C3=A9_Draszik?= , Lee Jones , Greg Kroah-Hartman , Badhri Jagan Sridharan , Heikki Krogerus , Peter Griffin , Tudor Ambarus , Alim Akhtar Cc: linux-kernel@vger.kernel.org, linux-pm@vger.kernel.org, devicetree@vger.kernel.org, linux-usb@vger.kernel.org, linux-arm-kernel@lists.infradead.org, linux-samsung-soc@vger.kernel.org, RD Babiera , Kyle Tso , Amit Sunil Dhamne X-Mailer: b4 0.14.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1768957213; l=23735; i=amitsd@google.com; s=20241031; h=from:subject:message-id; bh=QOqr9vYPB6KQgFCf8ul2Q6C3SqRFh4tWZK5173NQ25M=; b=Q0L2PCUfBRyfZbNcLunRNnKwAKpCfK78EeXEYcpe6pUCja5SAB7qxpJ6LrFllDJT+P6s4fkcg hprtLSUYtOLD2SaAUSE5AvsJEyweh4XdeT4JA8phXcFix4/hsk0qUoI X-Developer-Key: i=amitsd@google.com; a=ed25519; pk=wD+XZSST4dmnNZf62/lqJpLm7fiyT8iv462zmQ3H6bI= X-Endpoint-Received: by B4 Relay for amitsd@google.com/20241031 with auth_id=262 X-Original-From: Amit Sunil Dhamne Reply-To: amitsd@google.com From: Amit Sunil Dhamne Add support for MAX77759 battery charger driver. This is a 4A 1-Cell Li+/LiPoly dual input switch mode charger. While the device can support USB & wireless charger inputs, this implementation only supports USB input. This implementation supports both buck and boost modes. Signed-off-by: Amit Sunil Dhamne --- MAINTAINERS | 6 + drivers/power/supply/Kconfig | 11 + drivers/power/supply/Makefile | 1 + drivers/power/supply/max77759_charger.c | 737 ++++++++++++++++++++++++++++= ++++ 4 files changed, 755 insertions(+) diff --git a/MAINTAINERS b/MAINTAINERS index 0d044a58cbfe0f2b97f3682a86708e1ece108e9f..38354964a85c34611b1b54e2065= 1b360f3b9c11e 100644 --- a/MAINTAINERS +++ b/MAINTAINERS @@ -15546,6 +15546,12 @@ F: drivers/mfd/max77759.c F: drivers/nvmem/max77759-nvmem.c F: include/linux/mfd/max77759.h =20 +MAXIM MAX77759 BATTERY CHARGER DRIVER +M: Amit Sunil Dhamne +L: linux-kernel@vger.kernel.org +S: Maintained +F: drivers/power/supply/max77759_charger.c + MAXIM MAX77802 PMIC REGULATOR DEVICE DRIVER M: Javier Martinez Canillas L: linux-kernel@vger.kernel.org diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig index 92f9f7aae92f249aa165e68dbcd4cebb569286ea..3a2cdb95c98e44324151ac2b86d= 740ae2923ee77 100644 --- a/drivers/power/supply/Kconfig +++ b/drivers/power/supply/Kconfig @@ -631,6 +631,17 @@ config CHARGER_MAX77705 help Say Y to enable support for the Maxim MAX77705 battery charger. =20 +config CHARGER_MAX77759 + tristate "Maxim MAX77759 battery charger driver" + depends on MFD_MAX77759 && REGULATOR + default MFD_MAX77759 + help + Say M or Y here to enable the MAX77759 battery charger. MAX77759 + charger is a function of the MAX77759 PMIC. This is a dual input + switch-mode charger. This driver supports buck and OTG boost modes. + + If built as a module, it will be called max77759_charger. + config CHARGER_MAX77976 tristate "Maxim MAX77976 battery charger driver" depends on I2C diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile index 4b79d5abc49a7fd1e37a26d0c89f94d9fe3a916f..6af905875ad5e3b393a70304053= 55b9a975870f6 100644 --- a/drivers/power/supply/Makefile +++ b/drivers/power/supply/Makefile @@ -128,3 +128,4 @@ obj-$(CONFIG_CHARGER_SURFACE) +=3D surface_charger.o obj-$(CONFIG_BATTERY_UG3105) +=3D ug3105_battery.o obj-$(CONFIG_CHARGER_QCOM_SMB2) +=3D qcom_smbx.o obj-$(CONFIG_FUEL_GAUGE_MM8013) +=3D mm8013.o +obj-$(CONFIG_CHARGER_MAX77759) +=3D max77759_charger.o diff --git a/drivers/power/supply/max77759_charger.c b/drivers/power/supply= /max77759_charger.c new file mode 100644 index 0000000000000000000000000000000000000000..34b5ea0967eb7b4716e81ee1a55= 227ac872493b0 --- /dev/null +++ b/drivers/power/supply/max77759_charger.c @@ -0,0 +1,737 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * max77759_charger.c - Battery charger driver for MAX77759 charger device. + * + * Copyright 2025 Google LLC. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* Default values for Fast Charge Current & Float Voltage */ +#define CHG_CC_DEFAULT_UA 2266770 +#define CHG_FV_DEFAULT_MV 4300 + +#define FOREACH_IRQ(S) \ + S(AICL), \ + S(CHGIN), \ + S(CHG), \ + S(INLIM), \ + S(BAT_OILO), \ + S(CHG_STA_CC), \ + S(CHG_STA_CV), \ + S(CHG_STA_TO), \ + S(CHG_STA_DONE) + +#define GENERATE_ENUM(e) e +#define GENERATE_STRING(s) #s + +enum { + FOREACH_IRQ(GENERATE_ENUM) +}; + +static const char *const chgr_irqs_str[] =3D { + FOREACH_IRQ(GENERATE_STRING) +}; + +#define NUM_IRQS ARRAY_SIZE(chgr_irqs_str) + +struct max77759_charger { + struct device *dev; + struct regmap *regmap; + struct power_supply *psy; + struct regulator_dev *chgin_otg_rdev; + struct notifier_block nb; + struct power_supply *tcpm_psy; + struct work_struct psy_work; + int irqs[NUM_IRQS]; + struct mutex lock; /* protects the state below */ + enum max77759_chgr_mode mode; +}; + +static inline int regval_to_val(int reg, int reg_offset, int step, int min= val) +{ + return ((reg - reg_offset) * step) + minval; +} + +static inline int val_to_regval(int val, int minval, int step, int reg_off= set) +{ + s64 dividend; + + if (unlikely(step =3D=3D 0)) + return reg_offset; + + dividend =3D (s64)val - minval; + return DIV_S64_ROUND_CLOSEST(dividend, step) + reg_offset; +} + +static inline int unlock_prot_regs(struct max77759_charger *chg, bool unlo= ck) +{ + return regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_06, + MAX77759_CHGR_REG_CHG_CNFG_06_CHGPROT, unlock + ? MAX77759_CHGR_REG_CHG_CNFG_06_CHGPROT : 0); +} + +static int charger_input_valid(struct max77759_charger *chg) +{ + u32 val; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_INT_OK, &val); + if (ret) + return ret; + + return (val & MAX77759_CHGR_REG_CHG_INT_CHG) && + (val & MAX77759_CHGR_REG_CHG_INT_CHGIN); +} + +static int get_online(struct max77759_charger *chg) +{ + u32 val; + int ret; + + ret =3D charger_input_valid(chg); + if (ret <=3D 0) + return ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_DETAILS_02, &val); + if (ret) + return ret; + + guard(mutex)(&chg->lock); + return (val & MAX77759_CHGR_REG_CHG_DETAILS_02_CHGIN_STS) && + (chg->mode =3D=3D MAX77759_CHGR_MODE_CHG_BUCK_ON); +} + +static int get_status(struct max77759_charger *chg) +{ + u32 val; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_DETAILS_01, &val); + if (ret) + return ret; + + switch (FIELD_GET(MAX77759_CHGR_REG_CHG_DETAILS_01_CHG_DTLS, val)) { + case MAX77759_CHGR_CHG_DTLS_PREQUAL: + case MAX77759_CHGR_CHG_DTLS_CC: + case MAX77759_CHGR_CHG_DTLS_CV: + case MAX77759_CHGR_CHG_DTLS_TO: + return POWER_SUPPLY_STATUS_CHARGING; + case MAX77759_CHGR_CHG_DTLS_DONE: + return POWER_SUPPLY_STATUS_FULL; + case MAX77759_CHGR_CHG_DTLS_TIMER_FAULT: + case MAX77759_CHGR_CHG_DTLS_SUSP_BATT_THM: + case MAX77759_CHGR_CHG_DTLS_OFF_WDOG_TIMER: + case MAX77759_CHGR_CHG_DTLS_SUSP_JEITA: + return POWER_SUPPLY_STATUS_NOT_CHARGING; + case MAX77759_CHGR_CHG_DTLS_OFF: + return POWER_SUPPLY_STATUS_DISCHARGING; + default: + break; + } + + return POWER_SUPPLY_STATUS_UNKNOWN; +} + +static int get_charge_type(struct max77759_charger *chg) +{ + u32 val; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_DETAILS_01, &val); + if (ret) + return ret; + + switch (FIELD_GET(MAX77759_CHGR_REG_CHG_DETAILS_01_CHG_DTLS, val)) { + case MAX77759_CHGR_CHG_DTLS_PREQUAL: + return POWER_SUPPLY_CHARGE_TYPE_TRICKLE; + case MAX77759_CHGR_CHG_DTLS_CC: + case MAX77759_CHGR_CHG_DTLS_CV: + return POWER_SUPPLY_CHARGE_TYPE_FAST; + case MAX77759_CHGR_CHG_DTLS_TO: + return POWER_SUPPLY_CHARGE_TYPE_STANDARD; + case MAX77759_CHGR_CHG_DTLS_DONE: + case MAX77759_CHGR_CHG_DTLS_TIMER_FAULT: + case MAX77759_CHGR_CHG_DTLS_SUSP_BATT_THM: + case MAX77759_CHGR_CHG_DTLS_OFF_WDOG_TIMER: + case MAX77759_CHGR_CHG_DTLS_SUSP_JEITA: + case MAX77759_CHGR_CHG_DTLS_OFF: + return POWER_SUPPLY_CHARGE_TYPE_NONE; + default: + break; + } + + return POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; +} + +static int get_chg_health(struct max77759_charger *chg) +{ + u32 val; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_DETAILS_00, &val); + if (ret) + return ret; + + switch (FIELD_GET(MAX77759_CHGR_REG_CHG_DETAILS_OO_CHGIN_DTLS, val)) { + case MAX77759_CHGR_CHGIN_DTLS_VBUS_UNDERVOLTAGE: + case MAX77759_CHGR_CHGIN_DTLS_VBUS_MARGINAL_VOLTAGE: + return POWER_SUPPLY_HEALTH_UNDERVOLTAGE; + case MAX77759_CHGR_CHGIN_DTLS_VBUS_OVERVOLTAGE: + return POWER_SUPPLY_HEALTH_OVERVOLTAGE; + case MAX77759_CHGR_CHGIN_DTLS_VBUS_VALID: + return POWER_SUPPLY_HEALTH_GOOD; + default: + break; + } + + return POWER_SUPPLY_HEALTH_UNKNOWN; +} + +static int get_batt_health(struct max77759_charger *chg) +{ + u32 val; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_DETAILS_01, &val); + if (ret) + return ret; + + switch (FIELD_GET(MAX77759_CHGR_REG_CHG_DETAILS_01_BAT_DTLS, val)) { + case MAX77759_CHGR_BAT_DTLS_NO_BATT_CHG_SUSP: + return POWER_SUPPLY_HEALTH_NO_BATTERY; + case MAX77759_CHGR_BAT_DTLS_DEAD_BATTERY: + return POWER_SUPPLY_HEALTH_DEAD; + case MAX77759_CHGR_BAT_DTLS_BAT_CHG_TIMER_FAULT: + return POWER_SUPPLY_HEALTH_SAFETY_TIMER_EXPIRE; + case MAX77759_CHGR_BAT_DTLS_BAT_OKAY: + case MAX77759_CHGR_BAT_DTLS_BAT_ONLY_MODE: + return POWER_SUPPLY_HEALTH_GOOD; + case MAX77759_CHGR_BAT_DTLS_BAT_UNDERVOLTAGE: + return POWER_SUPPLY_HEALTH_UNDERVOLTAGE; + case MAX77759_CHGR_BAT_DTLS_BAT_OVERVOLTAGE: + return POWER_SUPPLY_HEALTH_OVERVOLTAGE; + case MAX77759_CHGR_BAT_DTLS_BAT_OVERCURRENT: + return POWER_SUPPLY_HEALTH_OVERCURRENT; + default: + break; + } + + return POWER_SUPPLY_HEALTH_UNKNOWN; +} + +static int get_health(struct max77759_charger *chg) +{ + int ret; + + ret =3D get_online(chg); + if (ret < 0) + return ret; + + if (ret) { + ret =3D get_chg_health(chg); + if (ret < 0 || ret !=3D POWER_SUPPLY_HEALTH_GOOD) + return ret; + } + + return get_batt_health(chg); +} + +static int get_fast_charge_current(struct max77759_charger *chg) +{ + u32 regval; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_02, ®val); + if (ret) + return ret; + + ret =3D FIELD_GET(MAX77759_CHGR_REG_CHG_CNFG_02_CHGCC, regval); + if (ret <=3D MAX77759_CHGR_CHGCC_REG_OFFSET) + return MAX77759_CHGR_CHGCC_MIN_UA; + + return regval_to_val(ret, MAX77759_CHGR_CHGCC_REG_OFFSET, + MAX77759_CHGR_CHGCC_STEP_UA, + MAX77759_CHGR_CHGCC_MIN_UA); +} + +static int set_fast_charge_current_limit(struct max77759_charger *chg, + u32 cc_max_ua) +{ + u32 val; + + if (cc_max_ua < MAX77759_CHGR_CHGCC_MIN_UA || + cc_max_ua > MAX77759_CHGR_CHGCC_MAX_UA) + return -EINVAL; + + val =3D val_to_regval(cc_max_ua, MAX77759_CHGR_CHGCC_MIN_UA, + MAX77759_CHGR_CHGCC_STEP_UA, + MAX77759_CHGR_CHGCC_REG_OFFSET); + return regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_02, + MAX77759_CHGR_REG_CHG_CNFG_02_CHGCC, val); +} + +static int get_float_voltage(struct max77759_charger *chg) +{ + u32 regval; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_04, ®val); + if (ret) + return ret; + + ret =3D FIELD_GET(MAX77759_CHGR_REG_CHG_CNFG_04_CHG_CV_PRM, regval); + switch (ret) { + case MAX77759_CHGR_CHG_CV_PRM_HI_MIN_REG ... MAX77759_CHGR_CHG_CV_PRM_HI_= MAX_REG: + return regval_to_val(ret, MAX77759_CHGR_CHG_CV_PRM_HI_MIN_REG, + MAX77759_CHGR_CHG_CV_PRM_HI_STEP_MV, + MAX77759_CHGR_CHG_CV_PRM_HI_MIN_MV); + case MAX77759_CHGR_CHG_CV_PRM_LO_MIN_REG ... MAX77759_CHGR_CHG_CV_PRM_LO_= MAX_REG: + return regval_to_val(ret, MAX77759_CHGR_CHG_CV_PRM_LO_MIN_REG, + MAX77759_CHGR_CHG_CV_PRM_LO_STEP_MV, + MAX77759_CHGR_CHG_CV_PRM_LO_MIN_MV); + default: + return -EINVAL; + } + + return 0; +} + +static int set_float_voltage_limit(struct max77759_charger *chg, u32 fv_mv) +{ + u32 regval; + + if (fv_mv >=3D MAX77759_CHGR_CHG_CV_PRM_LO_MIN_MV && + fv_mv <=3D MAX77759_CHGR_CHG_CV_PRM_LO_MAX_MV) { + regval =3D val_to_regval(fv_mv, + MAX77759_CHGR_CHG_CV_PRM_LO_MIN_MV, + MAX77759_CHGR_CHG_CV_PRM_LO_STEP_MV, + MAX77759_CHGR_CHG_CV_PRM_LO_MIN_REG); + } else if (fv_mv >=3D MAX77759_CHGR_CHG_CV_PRM_HI_MIN_MV && + fv_mv <=3D MAX77759_CHGR_CHG_CV_PRM_HI_MAX_MV) { + regval =3D val_to_regval(fv_mv, + MAX77759_CHGR_CHG_CV_PRM_HI_MIN_MV, + MAX77759_CHGR_CHG_CV_PRM_HI_STEP_MV, + MAX77759_CHGR_CHG_CV_PRM_HI_MIN_REG); + } else { + return -EINVAL; + } + + return regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_04, + MAX77759_CHGR_REG_CHG_CNFG_04_CHG_CV_PRM, + regval); +} + +static int get_input_current_limit(struct max77759_charger *chg) +{ + u32 regval; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_09, ®val); + if (ret) + return ret; + + ret =3D FIELD_GET(MAX77759_CHGR_REG_CHG_CNFG_09_CHGIN_ILIM, regval); + if (ret <=3D MAX77759_CHGR_CHGIN_ILIM_REG_OFFSET) + return MAX77759_CHGR_CHGIN_ILIM_MIN_UA; + + return regval_to_val(ret, MAX77759_CHGR_CHGIN_ILIM_REG_OFFSET, + MAX77759_CHGR_CHGIN_ILIM_STEP_UA, + MAX77759_CHGR_CHGIN_ILIM_MIN_UA); +} + +static int set_input_current_limit(struct max77759_charger *chg, int ilim_= ua) +{ + u32 regval; + + if (ilim_ua < 0) + return -EINVAL; + + ilim_ua =3D clamp(ilim_ua, MAX77759_CHGR_CHGIN_ILIM_MIN_UA, + MAX77759_CHGR_CHGIN_ILIM_MAX_UA); + + regval =3D val_to_regval(ilim_ua, MAX77759_CHGR_CHGIN_ILIM_MIN_UA, + MAX77759_CHGR_CHGIN_ILIM_STEP_UA, + MAX77759_CHGR_CHGIN_ILIM_REG_OFFSET); + return regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_09, + MAX77759_CHGR_REG_CHG_CNFG_09_CHGIN_ILIM, + regval); +} + +static const enum power_supply_property max77759_charger_props[] =3D { + POWER_SUPPLY_PROP_ONLINE, + POWER_SUPPLY_PROP_PRESENT, + POWER_SUPPLY_PROP_STATUS, + POWER_SUPPLY_PROP_CHARGE_TYPE, + POWER_SUPPLY_PROP_HEALTH, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX, + POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT, +}; + +static int max77759_charger_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *pval) +{ + struct max77759_charger *chg =3D power_supply_get_drvdata(psy); + int ret; + + switch (psp) { + case POWER_SUPPLY_PROP_ONLINE: + ret =3D get_online(chg); + break; + case POWER_SUPPLY_PROP_PRESENT: + ret =3D charger_input_valid(chg); + break; + case POWER_SUPPLY_PROP_STATUS: + ret =3D get_status(chg); + break; + case POWER_SUPPLY_PROP_CHARGE_TYPE: + ret =3D get_charge_type(chg); + break; + case POWER_SUPPLY_PROP_HEALTH: + ret =3D get_health(chg); + break; + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + ret =3D get_fast_charge_current(chg); + break; + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: + ret =3D get_float_voltage(chg); + break; + case POWER_SUPPLY_PROP_INPUT_CURRENT_LIMIT: + ret =3D get_input_current_limit(chg); + break; + default: + ret =3D -EINVAL; + } + + pval->intval =3D ret; + return ret < 0 ? ret : 0; +} + +static const struct power_supply_desc max77759_charger_desc =3D { + .name =3D "max77759-charger", + .type =3D POWER_SUPPLY_TYPE_USB, + .properties =3D max77759_charger_props, + .num_properties =3D ARRAY_SIZE(max77759_charger_props), + .get_property =3D max77759_charger_get_property, +}; + +static int charger_set_mode(struct max77759_charger *chg, + enum max77759_chgr_mode mode) +{ + int ret; + + guard(mutex)(&chg->lock); + + if (chg->mode =3D=3D mode) + return 0; + + if ((mode =3D=3D MAX77759_CHGR_MODE_CHG_BUCK_ON || + mode =3D=3D MAX77759_CHGR_MODE_OTG_BOOST_ON) && + chg->mode !=3D MAX77759_CHGR_MODE_OFF) { + dev_err(chg->dev, "Invalid mode transition from %d to %d", + chg->mode, mode); + return -EINVAL; + } + + ret =3D regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_00, + MAX77759_CHGR_REG_CHG_CNFG_00_MODE, mode); + if (ret) + return ret; + + chg->mode =3D mode; + return 0; +} + +static int enable_chgin_otg(struct regulator_dev *rdev) +{ + struct max77759_charger *chg =3D rdev_get_drvdata(rdev); + + return charger_set_mode(chg, MAX77759_CHGR_MODE_OTG_BOOST_ON); +} + +static int disable_chgin_otg(struct regulator_dev *rdev) +{ + struct max77759_charger *chg =3D rdev_get_drvdata(rdev); + + return charger_set_mode(chg, MAX77759_CHGR_MODE_OFF); +} + +static int chgin_otg_status(struct regulator_dev *rdev) +{ + struct max77759_charger *chg =3D rdev_get_drvdata(rdev); + + guard(mutex)(&chg->lock); + return chg->mode =3D=3D MAX77759_CHGR_MODE_OTG_BOOST_ON; +} + +static const struct regulator_ops chgin_otg_reg_ops =3D { + .enable =3D enable_chgin_otg, + .disable =3D disable_chgin_otg, + .is_enabled =3D chgin_otg_status, +}; + +static const struct regulator_desc chgin_otg_reg_desc =3D { + .name =3D "chgin-otg", + .of_match =3D of_match_ptr("chgin-otg-regulator"), + .owner =3D THIS_MODULE, + .ops =3D &chgin_otg_reg_ops, + .fixed_uV =3D 5000000, + .n_voltages =3D 1, +}; + +static irqreturn_t irq_handler(int irq, void *data) +{ + struct max77759_charger *chg =3D data; + struct device *dev =3D chg->dev; + int i; + + for (i =3D 0; i < NUM_IRQS && chg->irqs[i] !=3D irq; i++) + ; + + if (i =3D=3D NUM_IRQS) { + dev_err(dev, "Unable to handle irq=3D%d", irq); + return IRQ_NONE; + } else if (i =3D=3D BAT_OILO) { + dev_warn(dev, "Battery over-current threshold crossed"); + } + + power_supply_changed(chg->psy); + return IRQ_HANDLED; +} + +static int max77759_init_irqhandler(struct max77759_charger *chg) +{ + struct device *dev =3D chg->dev; + int i, ret; + + for (i =3D 0; i < ARRAY_SIZE(chgr_irqs_str); i++) { + ret =3D platform_get_irq_byname(to_platform_device(dev), + chgr_irqs_str[i]); + if (ret < 0) + return dev_err_probe(dev, ret, + "Failed to get irq resource for %s", + chgr_irqs_str[i]); + + chg->irqs[i] =3D ret; + ret =3D devm_request_threaded_irq(dev, chg->irqs[i], NULL, + irq_handler, 0, dev_name(dev), + chg); + if (ret) + return dev_err_probe(dev, ret, + "Unable to register irq handler for %s", + chgr_irqs_str[i]); + } + + return 0; +} + +static int max77759_charger_init(struct max77759_charger *chg) +{ + struct power_supply_battery_info *info; + u32 regval, fast_chg_curr, fv; + int ret; + + ret =3D regmap_read(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_00, ®val); + if (ret) + return ret; + + chg->mode =3D FIELD_GET(MAX77759_CHGR_REG_CHG_CNFG_00_MODE, regval); + ret =3D charger_set_mode(chg, MAX77759_CHGR_MODE_OFF); + if (ret) + return ret; + + if (power_supply_get_battery_info(chg->psy, &info)) { + fv =3D CHG_FV_DEFAULT_MV; + fast_chg_curr =3D CHG_CC_DEFAULT_UA; + } else { + fv =3D info->constant_charge_voltage_max_uv / 1000; + fast_chg_curr =3D info->constant_charge_current_max_ua; + } + + ret =3D set_fast_charge_current_limit(chg, fast_chg_curr); + if (ret) + return ret; + + ret =3D set_float_voltage_limit(chg, fv); + if (ret) + return ret; + + ret =3D unlock_prot_regs(chg, true); + if (ret) + return ret; + + /* Disable wireless charging input */ + ret =3D regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_12, + MAX77759_CHGR_REG_CHG_CNFG_12_WCINSEL, 0); + if (ret) + return ret; + + ret =3D regmap_update_bits(chg->regmap, MAX77759_CHGR_REG_CHG_CNFG_18, + MAX77759_CHGR_REG_CHG_CNFG_18_WDTEN, 0); + if (ret) + return ret; + + return unlock_prot_regs(chg, false); +} + +static void psy_work_item(struct work_struct *work) +{ + struct max77759_charger *chg =3D + container_of(work, struct max77759_charger, psy_work); + union power_supply_propval current_limit, online; + int ret; + + ret =3D power_supply_get_property(chg->tcpm_psy, + POWER_SUPPLY_PROP_CURRENT_MAX, + ¤t_limit); + if (ret) { + dev_err(chg->dev, + "Failed to get CURRENT_MAX psy property, ret=3D%d", + ret); + return; + } + + ret =3D power_supply_get_property(chg->tcpm_psy, POWER_SUPPLY_PROP_ONLINE, + &online); + if (ret) { + dev_err(chg->dev, + "Failed to get ONLINE psy property, ret=3D%d", + ret); + return; + } + + if (online.intval && current_limit.intval) { + ret =3D set_input_current_limit(chg, current_limit.intval); + if (ret) + dev_err(chg->dev, + "Unable to set current limit, ret=3D%d", ret); + + charger_set_mode(chg, MAX77759_CHGR_MODE_CHG_BUCK_ON); + } else { + charger_set_mode(chg, MAX77759_CHGR_MODE_OFF); + } +} + +static int psy_changed(struct notifier_block *nb, unsigned long evt, void = *data) +{ + struct max77759_charger *chg =3D container_of(nb, struct max77759_charger, + nb); + const char *psy_name =3D "tcpm-source"; + struct power_supply *psy =3D data; + + if (!strnstr(psy->desc->name, psy_name, strlen(psy_name)) || + evt !=3D PSY_EVENT_PROP_CHANGED) + return NOTIFY_OK; + + chg->tcpm_psy =3D psy; + schedule_work(&chg->psy_work); + + return NOTIFY_OK; +} + +static void max_tcpci_unregister_psy_notifier(void *nb) +{ + power_supply_unreg_notifier(nb); +} + +static int max77759_charger_probe(struct platform_device *pdev) +{ + struct regulator_config chgin_otg_reg_cfg; + struct power_supply_config psy_cfg; + struct device *dev =3D &pdev->dev; + struct max77759_charger *chg; + int ret; + + device_set_of_node_from_dev(dev, dev->parent); + chg =3D devm_kzalloc(dev, sizeof(*chg), GFP_KERNEL); + if (!chg) + return -ENOMEM; + + platform_set_drvdata(pdev, chg); + chg->dev =3D dev; + chg->regmap =3D dev_get_regmap(dev->parent, "charger"); + if (!chg->regmap) + return dev_err_probe(dev, -ENODEV, "Missing regmap"); + + ret =3D devm_mutex_init(dev, &chg->lock); + if (ret) + return dev_err_probe(dev, ret, "Failed to initialize lock"); + + psy_cfg.fwnode =3D dev_fwnode(dev); + psy_cfg.drv_data =3D chg; + chg->psy =3D devm_power_supply_register(dev, &max77759_charger_desc, + &psy_cfg); + if (IS_ERR(chg->psy)) + return dev_err_probe(dev, -EPROBE_DEFER, + "Failed to register psy, ret=3D%ld", + PTR_ERR(chg->psy)); + + ret =3D max77759_charger_init(chg); + if (ret) + return dev_err_probe(dev, ret, + "Failed to initialize max77759 charger"); + + chgin_otg_reg_cfg.dev =3D dev; + chgin_otg_reg_cfg.driver_data =3D chg; + chgin_otg_reg_cfg.of_node =3D dev_of_node(dev); + chg->chgin_otg_rdev =3D devm_regulator_register(dev, &chgin_otg_reg_desc, + &chgin_otg_reg_cfg); + if (IS_ERR(chg->chgin_otg_rdev)) + return dev_err_probe(dev, PTR_ERR(chg->chgin_otg_rdev), + "Failed to register chgin otg regulator"); + + ret =3D devm_work_autocancel(dev, &chg->psy_work, psy_work_item); + if (ret) + return dev_err_probe(dev, ret, "Failed to initialize psy work"); + + chg->nb.notifier_call =3D psy_changed; + ret =3D power_supply_reg_notifier(&chg->nb); + if (ret) + return dev_err_probe(dev, ret, + "Unable to register psy notifier"); + + ret =3D devm_add_action_or_reset(dev, max_tcpci_unregister_psy_notifier, + &chg->nb); + if (ret) + return dev_err_probe(dev, ret, + "Failed to add devm action to unregister psy notifier"); + + return max77759_init_irqhandler(chg); +} + +static const struct platform_device_id max77759_charger_id[] =3D { + {"max77759-charger",}, + { } +}; +MODULE_DEVICE_TABLE(platform, max77759_charger_id); + +static struct platform_driver max77759_charger_driver =3D { + .driver =3D { + .name =3D "max77759-charger", + }, + .probe =3D max77759_charger_probe, + .id_table =3D max77759_charger_id, +}; +module_platform_driver(max77759_charger_driver); + +MODULE_AUTHOR("Amit Sunil Dhamne "); +MODULE_DESCRIPTION("Maxim MAX77759 charger driver"); +MODULE_LICENSE("GPL"); --=20 2.52.0.457.g6b5491de43-goog