From nobody Tue Sep 9 12:56:54 2025 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 D8464C001DC for ; Wed, 26 Jul 2023 07:16:56 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S230119AbjGZHQy (ORCPT ); Wed, 26 Jul 2023 03:16:54 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48612 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232380AbjGZHQA (ORCPT ); Wed, 26 Jul 2023 03:16:00 -0400 Received: from mg.richtek.com (mg.richtek.com [220.130.44.152]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id 0B25E422F; Wed, 26 Jul 2023 00:13:33 -0700 (PDT) X-MailGates: (SIP:2,PASS,NONE)(compute_score:DELIVER,40,3) Received: from 192.168.10.47 by mg.richtek.com with MailGates ESMTPS Server V6.0(1318264:0:AUTH_RELAY) (envelope-from ) (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256/256); Wed, 26 Jul 2023 15:13:16 +0800 (CST) Received: from ex4.rt.l (192.168.10.47) by ex4.rt.l (192.168.10.47) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.25; Wed, 26 Jul 2023 15:13:16 +0800 Received: from linuxcarl2.richtek.com (192.168.10.154) by ex4.rt.l (192.168.10.45) with Microsoft SMTP Server id 15.2.1118.25 via Frontend Transport; Wed, 26 Jul 2023 15:13:16 +0800 From: Alina Yu To: , , , , CC: , , Subject: [PATCH v5 1/2] regulator: dt-bindings: rtq2208: Add Richtek RTQ2208 SubPMIC Date: Wed, 26 Jul 2023 15:13:11 +0800 Message-ID: <1690355592-10920-2-git-send-email-alina_yu@richtek.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1690355592-10920-1-git-send-email-alina_yu@richtek.com> References: <1690355592-10920-1-git-send-email-alina_yu@richtek.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add bindings for Richtek RTQ2208 IC controlled SubPMIC Signed-off-by: Alina Yu --- v5 - Revise filename from $id - Remove "regulator-compatible" for ldos - Add missing "high" for "richtek,mtp-sel-high" - Remove "regulator-mode" property - Add and modify "unevaluatedProperties: false" and "additionalProperties: = false" - Remove "richtek,fixed-uV" - Remove redundant space in "buck-a" and "ldo2" v4 - Modify filename to "richtek,rtq2208" - Add more desciptions for "regulator-allowed-modes" --- .../bindings/regulator/richtek,rtq2208.yaml | 196 +++++++++++++++++= ++++ 1 file changed, 196 insertions(+) create mode 100644 Documentation/devicetree/bindings/regulator/richtek,rtq= 2208.yaml diff --git a/Documentation/devicetree/bindings/regulator/richtek,rtq2208.ya= ml b/Documentation/devicetree/bindings/regulator/richtek,rtq2208.yaml new file mode 100644 index 0000000..63453f2 --- /dev/null +++ b/Documentation/devicetree/bindings/regulator/richtek,rtq2208.yaml @@ -0,0 +1,196 @@ +# SPDX-License-Identifier: GPL-2.0-only OR BSD-2-Clause +%YAML 1.2 +--- +$id: http://devicetree.org/schemas/regulator/richtek,rtq2208.yaml# +$schema: http://devicetree.org/meta-schemas/core.yaml# + +title: Richtek RTQ2208 SubPMIC Regulator + +maintainers: + - Alina Yu + +description: | + RTQ2208 is a highly integrated power converter that offers functional sa= fety dual + multi-configurable synchronous buck converters and two LDOs. + + Bucks support "regulator-allowed-modes" and "regulator-mode". The former= defines the permitted + switching operation in normal mode; the latter defines the operation in = suspend to RAM mode. + + No matter the RTQ2208 is configured to normal or suspend to RAM mode, th= ere are two switching + operation modes for all buck rails, automatic power saving mode (Auto mo= de) and forced continuous + conduction mode (FCCM). + + The definition of modes is in the datasheet which is available in below = link + and their meaning is:: + 0 - Auto mode for power saving, which reducing the switching frequency= at light load condition + to maintain high frequency. + 1 - FCCM to meet the strict voltage regulation accuracy, which keeping= constant switching frequency. + + Datasheet will be available soon at + https://www.richtek.com/assets/Products + +properties: + compatible: + enum: + - richtek,rtq2208 + + reg: + maxItems: 1 + + interrupts: + maxItems: 1 + =20 + richtek,mtp-sel-high: + type: boolean + description: + vout register selection based on this boolean value. + false - Using DVS0 register setting to adjust vout + true - Using DVS1 register setting to adjust vout + + regulators: + type: object + + patternProperties: + "^buck-[a-h]$": + type: object + $ref: regulator.yaml# + unevaluatedProperties: false + description: + description for buck-[a-h] regulator. + + properties: + regulator-allowed-modes: + description: + two buck modes in different switching accuracy. + 0 - Auto mode + 1 - FCCM + items: + enum: [0, 1] + + "^ldo[1-2]$": + type: object + $ref: regulator.yaml# + unevaluatedProperties: false + description: + regulator description for ldo[1-2]. + +required: + - compatible + - reg + - regulators + +additionalProperties: false + +examples: + - | + #include + i2c { + #address-cells =3D <1>; + #size-cells =3D <0>; + + pmic@10 { + compatible =3D "richtek,rtq2208"; + reg =3D <0x10>; + interrupts-extended =3D <&gpio26 0 IRQ_TYPE_LEVEL_LOW>; + richtek,mtp-sel-high; + + regulators { + buck-a { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-b { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-c { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-d { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-e { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-f { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-g { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + buck-h { + regulator-min-microvolt =3D <400000>; + regulator-max-microvolt =3D <2050000>; + regulator-allowed-modes =3D <0 1>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + regulator-mode =3D <1>; + }; + }; + ldo1 { + regulator-min-microvolt =3D <1200000>; + regulator-max-microvolt =3D <1200000>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + }; + }; + ldo2 { + regulator-min-microvolt =3D <3300000>; + regulator-max-microvolt =3D <3300000>; + regulator-always-on; + regulator-state-mem { + regulator-on-in-suspend; + }; + }; + }; + }; + }; --=20 2.7.4 From nobody Tue Sep 9 12:56:54 2025 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 7DD04C001DC for ; Wed, 26 Jul 2023 07:17:04 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S231675AbjGZHRA (ORCPT ); Wed, 26 Jul 2023 03:17:00 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:48626 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S232571AbjGZHQC (ORCPT ); Wed, 26 Jul 2023 03:16:02 -0400 Received: from mg.richtek.com (mg.richtek.com [220.130.44.152]) by lindbergh.monkeyblade.net (Postfix) with ESMTP id A41C74488; Wed, 26 Jul 2023 00:13:35 -0700 (PDT) X-MailGates: (SIP:2,PASS,NONE)(compute_score:DELIVER,40,3) Received: from 192.168.10.47 by mg.richtek.com with MailGates ESMTPS Server V6.0(1318260:0:AUTH_RELAY) (envelope-from ) (version=TLSv1.2 cipher=ECDHE-RSA-AES256-GCM-SHA384 bits=256/256); Wed, 26 Jul 2023 15:13:17 +0800 (CST) Received: from ex4.rt.l (192.168.10.47) by ex4.rt.l (192.168.10.47) with Microsoft SMTP Server (version=TLS1_2, cipher=TLS_ECDHE_RSA_WITH_AES_256_GCM_SHA384) id 15.2.1118.25; Wed, 26 Jul 2023 15:13:17 +0800 Received: from linuxcarl2.richtek.com (192.168.10.154) by ex4.rt.l (192.168.10.45) with Microsoft SMTP Server id 15.2.1118.25 via Frontend Transport; Wed, 26 Jul 2023 15:13:17 +0800 From: Alina Yu To: , , , , CC: , , Subject: [PATCH v5 2/2] regulator: rtq2208: Add Richtek RTQ2208 SubPMIC driver Date: Wed, 26 Jul 2023 15:13:12 +0800 Message-ID: <1690355592-10920-3-git-send-email-alina_yu@richtek.com> X-Mailer: git-send-email 1.8.3.1 In-Reply-To: <1690355592-10920-1-git-send-email-alina_yu@richtek.com> References: <1690355592-10920-1-git-send-email-alina_yu@richtek.com> MIME-Version: 1.0 Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Content-Transfer-Encoding: quoted-printable Content-Type: text/plain; charset="utf-8" Add support for the RTQ2208 SubPMIC This ic integrates with configurable, synchrnous buck converters and two ldos. Signed-off-by: Alina Yu Reported-by: kernel test robot --- v5 - Modify 'rdesc->fixed_uV' get, becasue "richtek,fixed-uV" is removed from = yaml - Modify 'mtp_sel' get because read property is changed from "richtek,mtp-s= el" to "richtek,mtp-sel-high" in yaml - Add missing regulators_node points to regulator node in yaml - Include for 'FIELD_PREP' reported by kernel test robot --- drivers/regulator/Kconfig | 11 + drivers/regulator/Makefile | 1 + drivers/regulator/rtq2208-regulator.c | 549 ++++++++++++++++++++++++++++++= ++++ 3 files changed, 561 insertions(+) create mode 100644 drivers/regulator/rtq2208-regulator.c diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig index e5f3613..a6b2c84 100644 --- a/drivers/regulator/Kconfig +++ b/drivers/regulator/Kconfig @@ -1213,6 +1213,17 @@ config REGULATOR_RTQ6752 synchronous boost converters for PAVDD, and one synchronous NAVDD buck-boost. This device is suitable for automotive TFT-LCD panel. =20 +config REGULATOR_RTQ2208 + tristate "Richtek RTQ2208 SubPMIC Regulator" + depends on I2C + select REGMAP_I2C + help + This driver adds support for RTQ2208 SubPMIC regulators. + The RTQ2208 is a multi-phase, programmable power management IC that + integrate with dual multi-configurable, synchronous buck converters + and two ldos. It features wide output voltage range from 0.4V to 2.05V + and the capability to configure the corresponding power stages. + config REGULATOR_S2MPA01 tristate "Samsung S2MPA01 voltage regulator" depends on MFD_SEC_CORE || COMPILE_TEST diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile index 58dfe01..04cbad17 100644 --- a/drivers/regulator/Makefile +++ b/drivers/regulator/Makefile @@ -143,6 +143,7 @@ obj-$(CONFIG_REGULATOR_RT6245) +=3D rt6245-regulator.o obj-$(CONFIG_REGULATOR_RTMV20) +=3D rtmv20-regulator.o obj-$(CONFIG_REGULATOR_RTQ2134) +=3D rtq2134-regulator.o obj-$(CONFIG_REGULATOR_RTQ6752) +=3D rtq6752-regulator.o +obj-$(CONFIG_REGULATOR_RTQ2208) +=3D rtq2208-regulator.o obj-$(CONFIG_REGULATOR_S2MPA01) +=3D s2mpa01.o obj-$(CONFIG_REGULATOR_S2MPS11) +=3D s2mps11.o obj-$(CONFIG_REGULATOR_S5M8767) +=3D s5m8767.o diff --git a/drivers/regulator/rtq2208-regulator.c b/drivers/regulator/rtq2= 208-regulator.c new file mode 100644 index 0000000..2cfbc68 --- /dev/null +++ b/drivers/regulator/rtq2208-regulator.c @@ -0,0 +1,549 @@ +// SPDX-License-Identifier: GPL-2.0+ + +#include +#include +#include +#include +#include +#include +#include + +/* Register */ +#define RTQ2208_REG_GLOBAL_INT1 0x12 +#define RTQ2208_REG_FLT_RECORDBUCK_CB 0x18 +#define RTQ2208_REG_GLOBAL_INT1_MASK 0x1D +#define RTQ2208_REG_FLT_MASKBUCK_CB 0x1F +#define RTQ2208_REG_BUCK_C_CFG0 0x32 +#define RTQ2208_REG_BUCK_B_CFG0 0x42 +#define RTQ2208_REG_BUCK_A_CFG0 0x52 +#define RTQ2208_REG_BUCK_D_CFG0 0x62 +#define RTQ2208_REG_BUCK_G_CFG0 0x72 +#define RTQ2208_REG_BUCK_F_CFG0 0x82 +#define RTQ2208_REG_BUCK_E_CFG0 0x92 +#define RTQ2208_REG_BUCK_H_CFG0 0xA2 +#define RTQ2208_REG_LDO1_CFG 0xB1 +#define RTQ2208_REG_LDO2_CFG 0xC1 + +/* Mask */ +#define RTQ2208_BUCK_NR_MTP_SEL_MASK GENMASK(7, 0) +#define RTQ2208_BUCK_EN_NR_MTP_SEL0_MASK BIT(0) +#define RTQ2208_BUCK_EN_NR_MTP_SEL1_MASK BIT(1) +#define RTQ2208_BUCK_RSPUP_MASK GENMASK(6, 4) +#define RTQ2208_BUCK_RSPDN_MASK GENMASK(2, 0) +#define RTQ2208_BUCK_NRMODE_MASK BIT(5) +#define RTQ2208_BUCK_STRMODE_MASK BIT(5) +#define RTQ2208_BUCK_EN_STR_MASK BIT(0) +#define RTQ2208_LDO_EN_STR_MASK BIT(7) +#define RTQ2208_EN_DIS_MASK BIT(0) +#define RTQ2208_BUCK_RAMP_SEL_MASK GENMASK(2, 0) +#define RTQ2208_HD_INT_MASK BIT(0) + +/* Size */ +#define RTQ2208_VOUT_MAXNUM 256 +#define RTQ2208_BUCK_NUM_IRQ_REGS 5 +#define RTQ2208_STS_NUM_IRQ_REGS 2 + +/* Value */ +#define RTQ2208_RAMP_VALUE_MIN_uV 500 +#define RTQ2208_RAMP_VALUE_MAX_uV 64000 + +#define RTQ2208_BUCK_MASK(uv_irq, ov_irq) (1 << ((uv_irq) % 8) | 1 << ((ov= _irq) % 8)) + +enum { + RTQ2208_BUCK_B =3D 0, + RTQ2208_BUCK_C, + RTQ2208_BUCK_D, + RTQ2208_BUCK_A, + RTQ2208_BUCK_F, + RTQ2208_BUCK_G, + RTQ2208_BUCK_H, + RTQ2208_BUCK_E, + RTQ2208_LDO2, + RTQ2208_LDO1, + RTQ2208_LDO_MAX, +}; + +enum { + RTQ2208_AUTO_MODE =3D 0, + RTQ2208_FCCM, +}; + +struct rtq2208_regulator_desc { + struct regulator_desc desc; + unsigned int mtp_sel_reg; + unsigned int mtp_sel_mask; + unsigned int mode_reg; + unsigned int mode_mask; + unsigned int suspend_config_reg; + unsigned int suspend_enable_mask; + unsigned int suspend_mode_mask; + unsigned int fixed_uV; +}; + +struct rtq2208_rdev_map { + struct regulator_dev *rdev[RTQ2208_LDO_MAX]; + struct regmap *regmap; + struct device *dev; +}; + +/* set Normal Auto/FCCM mode */ +static int rtq2208_set_mode(struct regulator_dev *rdev, unsigned int mode) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)rdev->desc; + unsigned int val, shift; + + switch (mode) { + case REGULATOR_MODE_NORMAL: + val =3D RTQ2208_AUTO_MODE; + break; + case REGULATOR_MODE_FAST: + val =3D RTQ2208_FCCM; + break; + default: + return -EINVAL; + } + + shift =3D ffs(rdesc->mode_mask) - 1; + return regmap_update_bits(rdev->regmap, rdesc->mode_reg, + rdesc->mode_mask, val << shift); +} + +static unsigned int rtq2208_get_mode(struct regulator_dev *rdev) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)rdev->desc; + unsigned int mode_val; + int ret; + + ret =3D regmap_read(rdev->regmap, rdesc->mode_reg, &mode_val); + if (ret) + return REGULATOR_MODE_INVALID; + + return (mode_val & rdesc->mode_mask) ? REGULATOR_MODE_FAST : REGULATOR_MO= DE_NORMAL; +} + +static int rtq2208_set_ramp_delay(struct regulator_dev *rdev, int ramp_del= ay) +{ + const struct regulator_desc *rdesc =3D rdev->desc; + unsigned int sel =3D 0, val; + + ramp_delay =3D max(ramp_delay, RTQ2208_RAMP_VALUE_MIN_uV); + ramp_delay =3D min(ramp_delay, RTQ2208_RAMP_VALUE_MAX_uV); + + ramp_delay /=3D RTQ2208_RAMP_VALUE_MIN_uV; + + /* + * fls(ramp_delay) - 1: doing LSB shift, let it starts from 0 + * + * RTQ2208_BUCK_RAMP_SEL_MASK - sel: doing descending order shifting. + * Because the relation of seleltion and value is like that + * + * seletion: value + * 000: 64mv + * 001: 32mv + * ... + * 111: 0.5mv + * + * For example, if I would like to select 64mv, the fls(ramp_delay) - 1 w= ill be 0b111, + * and I need to use 0b111 - sel to do the shifting + */ + + sel =3D fls(ramp_delay) - 1; + sel =3D RTQ2208_BUCK_RAMP_SEL_MASK - sel; + + val =3D FIELD_PREP(RTQ2208_BUCK_RSPUP_MASK, sel) | FIELD_PREP(RTQ2208_BUC= K_RSPDN_MASK, sel); + + return regmap_update_bits(rdev->regmap, rdesc->ramp_reg, + RTQ2208_BUCK_RSPUP_MASK | RTQ2208_BUCK_RSPDN_MASK, val); +} + +static int rtq2208_set_suspend_enable(struct regulator_dev *rdev) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)rdev->desc; + + return regmap_set_bits(rdev->regmap, rdesc->suspend_config_reg, rdesc->su= spend_enable_mask); +} + +static int rtq2208_set_suspend_disable(struct regulator_dev *rdev) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)rdev->desc; + + return regmap_update_bits(rdev->regmap, rdesc->suspend_config_reg, rdesc-= >suspend_enable_mask, 0); +} + +static int rtq2208_set_suspend_mode(struct regulator_dev *rdev, unsigned i= nt mode) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)rdev->desc; + unsigned int val, shift; + + switch (mode) { + case REGULATOR_MODE_NORMAL: + val =3D RTQ2208_AUTO_MODE; + break; + case REGULATOR_MODE_FAST: + val =3D RTQ2208_FCCM; + break; + default: + return -EINVAL; + } + + shift =3D ffs(rdesc->suspend_mode_mask) - 1; + + return regmap_update_bits(rdev->regmap, rdesc->suspend_config_reg, + rdesc->suspend_mode_mask, val << shift); +} + +static int rtq2208_ldo_get_voltage(struct regulator_dev *rdev) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)rdev->desc; + + return rdesc->fixed_uV; +} + +static const struct regulator_ops rtq2208_regulator_buck_ops =3D { + .enable =3D regulator_enable_regmap, + .disable =3D regulator_disable_regmap, + .is_enabled =3D regulator_is_enabled_regmap, + .list_voltage =3D regulator_list_voltage_linear_range, + .set_voltage_sel =3D regulator_set_voltage_sel_regmap, + .get_voltage_sel =3D regulator_get_voltage_sel_regmap, + .set_mode =3D rtq2208_set_mode, + .get_mode =3D rtq2208_get_mode, + .set_ramp_delay =3D rtq2208_set_ramp_delay, + .set_active_discharge =3D regulator_set_active_discharge_regmap, + .set_suspend_enable =3D rtq2208_set_suspend_enable, + .set_suspend_disable =3D rtq2208_set_suspend_disable, + .set_suspend_mode =3D rtq2208_set_suspend_mode, +}; + +static const struct regulator_ops rtq2208_regulator_ldo_ops =3D { + .enable =3D regulator_enable_regmap, + .disable =3D regulator_disable_regmap, + .is_enabled =3D regulator_is_enabled_regmap, + .set_active_discharge =3D regulator_set_active_discharge_regmap, + .set_suspend_enable =3D rtq2208_set_suspend_enable, + .set_suspend_disable =3D rtq2208_set_suspend_disable, + .get_voltage =3D rtq2208_ldo_get_voltage, +}; + +static int rtq2208_of_parse_cb(struct device_node *np, + const struct regulator_desc *desc, + struct regulator_config *config) +{ + struct rtq2208_regulator_desc *rdesc =3D + (struct rtq2208_regulator_desc *)desc; + u32 min_uV, max_uV; + int ret; + + ret =3D of_property_read_u32(np, "regulator-min-microvolt", &min_uV); + if (ret) + return ret; + + ret =3D of_property_read_u32(np, "regulator-max-microvolt", &max_uV); + if (ret) + return ret; + + if (min_uV =3D=3D max_uV) + rdesc->fixed_uV =3D min_uV; + + return ret; +} + +static unsigned int rtq2208_of_map_mode(unsigned int mode) +{ + switch (mode) { + case RTQ2208_AUTO_MODE: + return REGULATOR_MODE_NORMAL; + case RTQ2208_FCCM: + return REGULATOR_MODE_FAST; + default: + return REGULATOR_MODE_INVALID; + } +} + +static int rtq2208_init_irq_mask(struct rtq2208_rdev_map *rdev_map, unsign= ed int *buck_masks) +{ + unsigned char buck_clr_masks[5] =3D {0x33, 0x33, 0x33, 0x33, 0x33}, + sts_clr_masks[2] =3D {0xE7, 0xF7}, sts_masks[2] =3D {0xE6, 0xF6}; + int ret; + + /* write clear all buck irq once */ + ret =3D regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB= , buck_clr_masks, 5); + if (ret) + return dev_err_probe(rdev_map->dev, ret, "Failed to clr buck irqs\n"); + + /* write clear general irq once */ + ret =3D regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, sts_= clr_masks, 2); + if (ret) + return dev_err_probe(rdev_map->dev, ret, "Failed to clr general irqs\n"); + + /* unmask buck ov/uv irq */ + ret =3D regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_MASKBUCK_CB, = buck_masks, 5); + if (ret) + return dev_err_probe(rdev_map->dev, ret, "Failed to unmask buck irqs\n"); + + /* unmask needed general irq */ + return regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1_MASK, = sts_masks, 2); +} + +static irqreturn_t rtq2208_irq_handler(int irqno, void *devid) +{ + unsigned char buck_flags[RTQ2208_BUCK_NUM_IRQ_REGS], sts_flags[RTQ2208_ST= S_NUM_IRQ_REGS]; + int ret =3D 0, i, uv_bit, ov_bit; + struct rtq2208_rdev_map *rdev_map =3D devid; + struct regulator_dev *rdev; + + if (!rdev_map) + return IRQ_NONE; + + /* read irq event */ + ret =3D regmap_bulk_read(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, + buck_flags, ARRAY_SIZE(buck_flags)); + if (ret) + return IRQ_NONE; + + ret =3D regmap_bulk_read(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, + sts_flags, ARRAY_SIZE(sts_flags)); + if (ret) + return IRQ_NONE; + + /* clear irq event */ + ret =3D regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_FLT_RECORDBUCK_CB, + buck_flags, ARRAY_SIZE(buck_flags)); + if (ret) + return IRQ_NONE; + + ret =3D regmap_bulk_write(rdev_map->regmap, RTQ2208_REG_GLOBAL_INT1, + sts_flags, ARRAY_SIZE(sts_flags)); + if (ret) + return IRQ_NONE; + + for (i =3D 0; i < RTQ2208_LDO_MAX; i++) { + if (!rdev_map->rdev[i]) + continue; + + rdev =3D rdev_map->rdev[i]; + /* uv irq */ + uv_bit =3D (i & 1) ? 4 : 0; + if (buck_flags[i >> 1] & (1 << uv_bit)) + regulator_notifier_call_chain(rdev, + REGULATOR_EVENT_UNDER_VOLTAGE, NULL); + /* ov irq */ + ov_bit =3D uv_bit + 1; + if (buck_flags[i >> 1] & (1 << ov_bit)) + regulator_notifier_call_chain(rdev, + REGULATOR_EVENT_REGULATION_OUT, NULL); + + /* hd irq */ + if (sts_flags[1] & RTQ2208_HD_INT_MASK) + regulator_notifier_call_chain(rdev, + REGULATOR_EVENT_OVER_TEMP, NULL); + } + + return IRQ_HANDLED; +} + +#define RTQ2208_REGULATOR_INFO(_name, _base) \ +{ \ + .name =3D #_name, \ + .base =3D _base, \ +} +#define BUCK_RG_BASE(_id) RTQ2208_REG_BUCK_##_id##_CFG0 +#define BUCK_RG_SHIFT(_base, _shift) (_base + _shift) +#define LDO_RG_BASE(_id) RTQ2208_REG_LDO##_id##_CFG +#define LDO_RG_SHIFT(_base, _shift) (_base + _shift) +#define VSEL_SHIFT(_sel) (_sel ? 3 : 1) +#define MTP_SEL_MASK(_sel) RTQ2208_BUCK_EN_NR_MTP_SEL##_sel##_MASK + +static const struct linear_range rtq2208_vout_range[] =3D { + REGULATOR_LINEAR_RANGE(400000, 0, 180, 5000), + REGULATOR_LINEAR_RANGE(1310000, 181, 255, 10000), +}; + +static void rtq2208_init_regulator_desc(struct rtq2208_regulator_desc *rde= sc, int mtp_sel, int idx) +{ + struct regulator_desc *desc; + static const struct { + char *name; + int base; + } regulator_info[] =3D { + RTQ2208_REGULATOR_INFO(buck-b, BUCK_RG_BASE(B)), + RTQ2208_REGULATOR_INFO(buck-c, BUCK_RG_BASE(C)), + RTQ2208_REGULATOR_INFO(buck-d, BUCK_RG_BASE(D)), + RTQ2208_REGULATOR_INFO(buck-a, BUCK_RG_BASE(A)), + RTQ2208_REGULATOR_INFO(buck-f, BUCK_RG_BASE(F)), + RTQ2208_REGULATOR_INFO(buck-g, BUCK_RG_BASE(G)), + RTQ2208_REGULATOR_INFO(buck-h, BUCK_RG_BASE(H)), + RTQ2208_REGULATOR_INFO(buck-e, BUCK_RG_BASE(E)), + RTQ2208_REGULATOR_INFO(ldo2, LDO_RG_BASE(2)), + RTQ2208_REGULATOR_INFO(ldo1, LDO_RG_BASE(1)), + }, *curr_info; + + curr_info =3D regulator_info + idx; + desc =3D &rdesc->desc; + desc->name =3D curr_info->name; + desc->of_match =3D of_match_ptr(curr_info->name); + desc->regulators_node =3D of_match_ptr("regulators"); + desc->id =3D idx; + desc->owner =3D THIS_MODULE; + desc->type =3D REGULATOR_VOLTAGE; + desc->enable_mask =3D mtp_sel ? MTP_SEL_MASK(1) : MTP_SEL_MASK(0); + desc->active_discharge_on =3D RTQ2208_EN_DIS_MASK; + desc->active_discharge_off =3D 0; + desc->active_discharge_mask =3D RTQ2208_EN_DIS_MASK; + + rdesc->mode_mask =3D RTQ2208_BUCK_NRMODE_MASK; + + if (idx >=3D RTQ2208_BUCK_B && idx <=3D RTQ2208_BUCK_E) { + /* init buck desc */ + desc->enable_reg =3D BUCK_RG_SHIFT(curr_info->base, 2); + desc->ops =3D &rtq2208_regulator_buck_ops; + desc->vsel_reg =3D curr_info->base + VSEL_SHIFT(mtp_sel); + desc->vsel_mask =3D RTQ2208_BUCK_NR_MTP_SEL_MASK; + desc->n_voltages =3D RTQ2208_VOUT_MAXNUM; + desc->linear_ranges =3D rtq2208_vout_range; + desc->n_linear_ranges =3D ARRAY_SIZE(rtq2208_vout_range); + desc->ramp_reg =3D BUCK_RG_SHIFT(curr_info->base, 5); + desc->active_discharge_reg =3D curr_info->base; + desc->of_map_mode =3D rtq2208_of_map_mode; + + rdesc->mode_reg =3D BUCK_RG_SHIFT(curr_info->base, 2); + rdesc->suspend_config_reg =3D BUCK_RG_SHIFT(curr_info->base, 4); + rdesc->suspend_enable_mask =3D RTQ2208_BUCK_EN_STR_MASK; + rdesc->suspend_mode_mask =3D RTQ2208_BUCK_STRMODE_MASK; + } else { + /* init ldo desc */ + desc->enable_reg =3D curr_info->base; + desc->ops =3D &rtq2208_regulator_ldo_ops; + desc->n_voltages =3D 1; + desc->active_discharge_reg =3D LDO_RG_SHIFT(curr_info->base, 2); + desc->of_parse_cb =3D rtq2208_of_parse_cb; + + rdesc->suspend_config_reg =3D curr_info->base; + rdesc->suspend_enable_mask =3D RTQ2208_LDO_EN_STR_MASK; + } +} + +/** different slave address corresponds different used bucks + * slave address 0x10: BUCK[BCA FGE] + * slave address 0x20: BUCK[BC FGHE] + * slave address 0x40: BUCK[C G] + */ +static int rtq2208_regulator_check(int slave_addr, int *num, int *regulato= r_idx_table, unsigned int *buck_masks) +{ + static bool rtq2208_used_table[3][RTQ2208_LDO_MAX] =3D { + /* BUCK[BCA FGE], LDO[12] */ + {1, 1, 0, 1, 1, 1, 0, 1, 1, 1}, + /* BUCK[BC FGHE], LDO[12]*/ + {1, 1, 0, 0, 1, 1, 1, 1, 1, 1}, + /* BUCK[C G], LDO[12] */ + {0, 1, 0, 0, 0, 1, 0, 0, 1, 1}, + }; + int i, idx =3D ffs(slave_addr >> 4) - 1; + u8 mask; + + for (i =3D 0; i < RTQ2208_LDO_MAX; i++) { + if (!rtq2208_used_table[idx][i]) + continue; + + regulator_idx_table[(*num)++] =3D i; + + mask =3D RTQ2208_BUCK_MASK(4 * i, 4 * i + 1); + buck_masks[i >> 1] &=3D ~mask; + } + + return 0; +} + +static const struct regmap_config rtq2208_regmap_config =3D { + .reg_bits =3D 8, + .val_bits =3D 8, + .max_register =3D 0xEF, +}; + +static int rtq2208_probe(struct i2c_client *i2c) +{ + struct device *dev =3D &i2c->dev; + struct regmap *regmap; + struct rtq2208_regulator_desc *rdesc; + struct regulator_dev *rdev; + struct regulator_config cfg; + struct rtq2208_rdev_map *rdev_map; + int i, ret =3D 0, idx, mtp_sel, n_regulator =3D 0; + unsigned int regulator_idx_table[RTQ2208_LDO_MAX], + buck_masks[RTQ2208_BUCK_NUM_IRQ_REGS] =3D {0x33, 0x33, 0x33, 0x33, = 0x33}; + + rdev_map =3D devm_kzalloc(dev, sizeof(struct rtq2208_rdev_map), GFP_KERNE= L); + if (!rdev_map) + return -ENOMEM; + + /* get mtp_sel0 or mtp_sel1 */ + mtp_sel =3D device_property_read_bool(dev, "richtek,mtp-sel-high"); + + regmap =3D devm_regmap_init_i2c(i2c, &rtq2208_regmap_config); + if (IS_ERR(regmap)) + return dev_err_probe(dev, PTR_ERR(regmap), "Failed to allocate regmap\n"= ); + + /* get needed regulator */ + ret =3D rtq2208_regulator_check(i2c->addr, &n_regulator, regulator_idx_ta= ble, buck_masks); + if (ret) + return dev_err_probe(dev, ret, "Failed to check used regulators\n"); + + rdev_map->regmap =3D regmap; + rdev_map->dev =3D dev; + + cfg.dev =3D dev; + + for (i =3D 0; i < n_regulator; i++) { + idx =3D regulator_idx_table[i]; + + rdesc =3D devm_kcalloc(dev, 1, sizeof(struct rtq2208_regulator_desc), GF= P_KERNEL); + if (!rdesc) + return -ENOMEM; + + /* init regulator desc */ + rtq2208_init_regulator_desc(rdesc, mtp_sel, idx); + + /* regiser regulator */ + rdev =3D devm_regulator_register(dev, &rdesc->desc, &cfg); + if (IS_ERR(rdev)) + return PTR_ERR(rdev); + + rdev_map->rdev[idx] =3D rdev; + } + + /* init interrupt mask */ + ret =3D rtq2208_init_irq_mask(rdev_map, buck_masks); + if (ret) + return ret; + + /* register interrupt */ + ret =3D devm_request_threaded_irq(dev, i2c->irq, NULL, rtq2208_irq_handle= r, + IRQF_ONESHOT, dev_name(dev), rdev_map); + + return ret; +} + +static const struct of_device_id __maybe_unused rtq2208_device_tables[] = =3D { + { .compatible =3D "richtek,rtq2208", }, + {} +}; +MODULE_DEVICE_TABLE(of, rtq2208_device_tables); + +static struct i2c_driver rtq2208_driver =3D { + .driver =3D { + .name =3D "rtq2208", + .of_match_table =3D rtq2208_device_tables, + }, + .probe_new =3D rtq2208_probe, +}; +module_i2c_driver(rtq2208_driver); + +MODULE_AUTHOR("Alina Yu "); +MODULE_DESCRIPTION("Richtek RTQ2208 Regulator Driver"); +MODULE_LICENSE("GPL v2"); --=20 2.7.4