From patchwork Mon Jul 26 19:01:27 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Morgan X-Patchwork-Id: 12400603 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.7 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8FF71C4338F for ; Mon, 26 Jul 2021 19:02:05 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 49E6360F11 for ; Mon, 26 Jul 2021 19:02:05 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 49E6360F11 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=QDegWRq/NzQCQgLLmXAFg9HkLKlQQGlGHQtxXCglmjI=; b=UquppRg9GAMqYt T+gZcEy5tBQhjMZKwM2HJFgeGGnznln6iqGZI/4qThoNfLb2TFG13c+sN+fuY8RNIlBNuLBkIPLch gCc6u0AmgO5XiwVGKon7JcwW+2dXNfSRWzEY26ykBKuzHG1xskcLLsoFx8qSzdKVzcturIzxsv9We Dz/ZWl7yZwEqel/cW2enkfz19sQaS0kkynKgmy6G05NgnnfHZqSyXtAveW52PCybko3RFvYH7IdYs nf3O/sAWtfKL6q7hHQqDyePxGyw/Fg/Sh1uAE93YoH6465Eeu68Kf7y0j3VzRqr4tmU4cGu/js/NS Nd4BF7BM3JIzmVKZ/+/g==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rU-00CJEv-P5; Mon, 26 Jul 2021 19:02:00 +0000 Received: from mail-oo1-xc2a.google.com ([2607:f8b0:4864:20::c2a]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rE-00CJ88-Fc; Mon, 26 Jul 2021 19:01:46 +0000 Received: by mail-oo1-xc2a.google.com with SMTP id w24-20020a4ac1980000b0290251d599f19bso2483195oop.8; Mon, 26 Jul 2021 12:01:44 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=xjQq4w89JxvSdKOOfsY9AtY7TN3aPy/MaODSkX355Ug=; b=UngmKHBwhsMSd1k9L9YcJfhTednReksxg+DgmLwELsHoLdvANjLKLnqOZBAps7s0zM M2xWlEArxsY96VjtLd4xp6SoyFgQugQHPoS+tSwTJulBqIExEh37mA67XCaD1PaKeaeg XWahPoH1ncKsKj4DTG+ehgiTxpkbdot+ouqHv7E7wnA6F67kb9Ds0/oOstNV8hXlAb0d R66o6f/WN0jHxp548aBmhb2YrqEy0nG2w5JVazpjjCWOf7269N4e6T7L+YA8FQI/l95P yReocm9HWLPIQEqs36yHcYYRBYwNU11qOfn5DlRhh4kIa2PpgVV7z23WOQVMrQuA3cm+ Dlkg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=xjQq4w89JxvSdKOOfsY9AtY7TN3aPy/MaODSkX355Ug=; b=UXXrMXZO3xoLVwUu0p48GPFsmUj74vqfsrsiVvhwVln854bswhtGyS4CsEmyjEyXEk PyrL/UcFjQxbQatpC9udtyPFcK9G/ryXFFUy7g2rPztN5mdR644DjenM2NWSCWwystgG XcHMMBZ+dnRiJakR6uzuqtSPQ2Q1S4lK5elNePb8oUQ5HSYBmA08+pJlp5+808hrugsw qzTJcUwCGBKgkM+NoPJYUNNCAY87JVaY+0pUcKxaXF4005wFyVe50pJHEZe8BZAo1BzR W8UdWMw37yP1SVEH45JLpqK47TIQhwGnb8YMUbQ0cgw/5VvxEwsYKJQlyV383dAQ1U4Y JmGA== X-Gm-Message-State: AOAM532EDXe0OKPJzq8LNH++JiFXQJgHsjuGDPku6nPp8xmf6fjWquep mwyhssu6LsOxRpHhi9SjeTQ= X-Google-Smtp-Source: ABdhPJyvXA3k5XqWanLGCHj51hHNxgycx5xHgCxTPsmupY+HaT+lZvA91oxoWDYFgZ3xtt9XUCyY5g== X-Received: by 2002:a4a:e5c8:: with SMTP id r8mr11420915oov.65.1627326103607; Mon, 26 Jul 2021 12:01:43 -0700 (PDT) Received: from wintermute.localdomain (cpe-76-183-134-35.tx.res.rr.com. [76.183.134.35]) by smtp.gmail.com with ESMTPSA id v7sm106610ooj.46.2021.07.26.12.01.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 26 Jul 2021 12:01:43 -0700 (PDT) From: Chris Morgan To: linux-pm@vger.kernel.org Cc: linux-rockchip@lists.infradead.org, linux-arm-kernel@lists.infradead.org, maccraft123mc@gmail.com, sre@kernel.org, heiko@sntech.de, robh+dt@kernel.org, lee.jones@linaro.org, Chris Morgan Subject: [RFC v2 1/4] dt-bindings: Add Rockchip rk817 battery charger support Date: Mon, 26 Jul 2021 14:01:27 -0500 Message-Id: <20210726190130.1973-2-macroalpha82@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210726190130.1973-1-macroalpha82@gmail.com> References: <20210726190130.1973-1-macroalpha82@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210726_120144_587955_81EB0953 X-CRM114-Status: GOOD ( 15.56 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org From: Chris Morgan Create dt-binding documentation to document rk817 battery and charger usage. New device-tree properties have been added. - rockchip,resistor-sense: The value in microohms of the sample resistor. - rockchip,sleep-enter-current: The value in microamps of the sleep enter current. - rockchip,sleep-filter-current: The value in microamps of the sleep filter current. Signed-off-by: Chris Morgan Signed-off-by: Maya Matuszczyk --- .../devicetree/bindings/mfd/rk808.txt | 35 +++++++++++++++++-- 1 file changed, 33 insertions(+), 2 deletions(-) diff --git a/Documentation/devicetree/bindings/mfd/rk808.txt b/Documentation/devicetree/bindings/mfd/rk808.txt index 23a17a6663ec..fa42b6253d26 100644 --- a/Documentation/devicetree/bindings/mfd/rk808.txt +++ b/Documentation/devicetree/bindings/mfd/rk808.txt @@ -70,13 +70,37 @@ Optional RK817 properties: - vcc8-supply: The input supply for BOOST - vcc9-supply: The input supply for OTG_SWITCH + - codec: The child node for the codec to hold additional properties. If no additional properties are required for the codec, this node can be omitted. - -- rockchip,mic-in-differential: Telling if the microphone uses differential +- rockchip,mic-in-differential: Telling if the microphone uses differential mode. Should be under the codec child node. +- battery: The child node for the charger to hold additional properties. + If a battery is not in use, this node can be omitted. If a + battery node is used, the following values are required: + rockchip,resistor-sense, rockchip,sleep-enter-current, + rockchip,sleep-filter-current, and a phandle to a + monitored-battery node that contains a valid value for + charge-full-design-microamp-hours, + charge-term-current-microamp, + constant-charge-current-max-microamp, + constant-charge-voltage-max-microvolt, + voltage-max-design-microvolt, voltage-min-design-microvolt, + and a valid ocv-capacity table. +- rockchip,resistor-sense: Value in microohms of the battery sense resistor. + The PMIC only supports values of either 10000 or + 20000. This value is used by the driver to set + the correct divisor value to translate ADC readings + into the proper units of measure. +- rockchip,sleep-enter-current: Value in microamps of the sleep enter current + for the charger. Value is used by the driver + to calibrate the relax threshold. +- rockchip,sleep-filter-current: Value in microamps of the sleep filter current + for the charger. Value is used by the driver + to derive the sleep sample current. + Optional RK818 properties: - vcc1-supply: The input supply for DCDC_REG1 - vcc2-supply: The input supply for DCDC_REG2 @@ -459,6 +483,13 @@ Example: }; }; + rk817_battery: battery { + monitored-battery = <&battery_cell>; + rockchip,resistor-sense = <10000>; + rockchip,sleep-enter-current = <300000>; + rockchip,sleep-filter-current = <100000>; + }; + rk817_codec: codec { rockchip,mic-in-differential; }; From patchwork Mon Jul 26 19:01:28 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Morgan X-Patchwork-Id: 12400601 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.7 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id E7C76C432BE for ; Mon, 26 Jul 2021 19:02:03 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id AD47060F5D for ; Mon, 26 Jul 2021 19:02:03 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org AD47060F5D Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=xlhFb0lIrXMiUpVZ206pOQoX6CcngVCc5aXC1TXJcyY=; b=xD1t6KLx4ghoTv Sa1DEdsKdiSkgRKjxUrf2WgwdnaZDKIr9jtskh8ew5vf7hIpKu1d2Km03mNuS89rJrLNsdK40cbP5 Lg/WpshZKtaJkbZx55qXu/S/WOXiKfVqU96OOOH/JmahOFQamJwKamzZebKhSPW89zgCEMn3HL5TU iSeWqlJtQg8SneNg+y74cjKUa2Gc6z4eCJG6zI9W9C2uA5kLZGS3IECa8GL6pAJ9sY7mM06GmjCIP 9bzhQ4EvTqXHy4y7L0lM3J+acn3hdCR55ji+KrdKgRM9rBnM7JqJfCFS7m6i7JEYN0lZbuHpxssNZ JVcQ+/NAse1ujryaAV3A==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rU-00CJEk-3i; Mon, 26 Jul 2021 19:02:00 +0000 Received: from mail-oi1-x22c.google.com ([2607:f8b0:4864:20::22c]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rF-00CJ8t-Ps; Mon, 26 Jul 2021 19:01:47 +0000 Received: by mail-oi1-x22c.google.com with SMTP id u10so12133490oiw.4; Mon, 26 Jul 2021 12:01:45 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=cB1/AbegbOKUFF7ZFth5GO71zeXj6fXOTx2GEHYhefE=; b=ZrWJGv2wKPV3JOO+Z1opgUMw1SXTdrokunTFWnSzgB0PRYZQ0o6Bukz9iTzAooP/sM NBo2UvlEyrVCMMwaD57BM2agekXiUKjdVWL7n1AgnyPGuVRqgNiNb3V0lclrQ2wy6ci5 LOJUCY+DR6K+bYVHIGUnI7AIeVhLsekUI8s80KRf0gFJ0HQK7djfZpJDc7UoOCp6NU06 KXqQmenoU07/e+LW9dZNAyAMUh+RkY8lLhZJzaxrLwYswxQVIo9vDgYLkxb9Lmx809zO laJiUi89zxhzRm9Frt4pu1Ys5wNz2QpeHqU0xWfNt9Tj9c9tcBgGeKy65oexRz56Yq7B i/lg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=cB1/AbegbOKUFF7ZFth5GO71zeXj6fXOTx2GEHYhefE=; b=elYYV4pX7B6XotOkI2Sk0NMUEtaoCsVU1YF3fiCHhZtbgbQkjRCCM+XhQv/WBiodY1 4XEoOMnY0SN+nLeFYynVt6MKPVYTW68erszBQeJmhAWskOxlpOaaUuQKOD/QEteM+Ua2 sVncQkw/CG2jM42peDw5fS5BwuoPghaqCZzyEdxGjKQE2BRbvaWpEN0uosIwU5dpXsny Qgf8xNafCBRj0+6+hRtiz2lugSYgoMYfsBdB7Iid6xWQNLG6+zDt9luxGiy+m/L1QVEr XC6+5rartYbDNQNn2cdrgP1IWhMrn+5ooqzM68kzo/py4ydcgisU51ZPMECbRtRCJ5w7 eBdA== X-Gm-Message-State: AOAM530kqKJ/o5kZzgOy9VqNOL4HYJVGYZZMWbwr24HAA8FZJG4xcc/d KiloQnB2DMtgFfyrrqbvZgY= X-Google-Smtp-Source: ABdhPJzYJpCARU3n8Q+mSyLR80NW7MFFLUgl7fsbAZ95NfakJ3zRj21iKCit1X7EAGJOhor3HOjvrg== X-Received: by 2002:aca:5d83:: with SMTP id r125mr2650678oib.113.1627326104976; Mon, 26 Jul 2021 12:01:44 -0700 (PDT) Received: from wintermute.localdomain (cpe-76-183-134-35.tx.res.rr.com. [76.183.134.35]) by smtp.gmail.com with ESMTPSA id v7sm106610ooj.46.2021.07.26.12.01.43 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 26 Jul 2021 12:01:44 -0700 (PDT) From: Chris Morgan To: linux-pm@vger.kernel.org Cc: linux-rockchip@lists.infradead.org, linux-arm-kernel@lists.infradead.org, maccraft123mc@gmail.com, sre@kernel.org, heiko@sntech.de, robh+dt@kernel.org, lee.jones@linaro.org, Chris Morgan Subject: [RFC v2 2/4] mfd: Add Rockchip rk817 battery charger support Date: Mon, 26 Jul 2021 14:01:28 -0500 Message-Id: <20210726190130.1973-3-macroalpha82@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210726190130.1973-1-macroalpha82@gmail.com> References: <20210726190130.1973-1-macroalpha82@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210726_120145_918606_C90B4A71 X-CRM114-Status: GOOD ( 13.38 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org From: Chris Morgan Add rk817 charger support cell to rk808 mfd driver. Signed-off-by: Chris Morgan Signed-off-by: Maya Matuszczyk --- drivers/mfd/rk808.c | 16 ++++++- include/linux/mfd/rk808.h | 87 +++++++++++++++++++++++++++++++++++++++ 2 files changed, 102 insertions(+), 1 deletion(-) diff --git a/drivers/mfd/rk808.c b/drivers/mfd/rk808.c index 77ccd31ca1d9..edc779aee667 100644 --- a/drivers/mfd/rk808.c +++ b/drivers/mfd/rk808.c @@ -66,6 +66,10 @@ static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg) case RK817_SECONDS_REG ... RK817_WEEKS_REG: case RK817_RTC_STATUS_REG: case RK817_CODEC_DTOP_LPT_SRST: + case RK817_GAS_GAUGE_ADC_CONFIG0 ... RK817_GAS_GAUGE_CUR_ADC_K0: + case RK817_PMIC_CHRG_STS: + case RK817_PMIC_CHRG_OUT: + case RK817_PMIC_CHRG_IN: case RK817_INT_STS_REG0: case RK817_INT_STS_REG1: case RK817_INT_STS_REG2: @@ -73,7 +77,7 @@ static bool rk817_is_volatile_reg(struct device *dev, unsigned int reg) return true; } - return true; + return false; } static const struct regmap_config rk818_regmap_config = { @@ -126,6 +130,11 @@ static const struct resource rk817_pwrkey_resources[] = { DEFINE_RES_IRQ(RK817_IRQ_PWRON_FALL), }; +static const struct resource rk817_charger_resources[] = { + DEFINE_RES_IRQ(RK817_IRQ_PLUG_IN), + DEFINE_RES_IRQ(RK817_IRQ_PLUG_OUT), +}; + static const struct mfd_cell rk805s[] = { { .name = "rk808-clkout", }, { .name = "rk808-regulator", }, @@ -165,6 +174,11 @@ static const struct mfd_cell rk817s[] = { .resources = &rk817_rtc_resources[0], }, { .name = "rk817-codec",}, + { + .name = "rk817-charger", + .num_resources = ARRAY_SIZE(rk817_charger_resources), + .resources = &rk817_charger_resources[0], + }, }; static const struct mfd_cell rk818s[] = { diff --git a/include/linux/mfd/rk808.h b/include/linux/mfd/rk808.h index a96e6d43ca06..1390432c0222 100644 --- a/include/linux/mfd/rk808.h +++ b/include/linux/mfd/rk808.h @@ -518,6 +518,74 @@ enum rk809_reg_id { #define MIC_DIFF_DIS (0x0 << 7) #define MIC_DIFF_EN (0x1 << 7) +/* RK817 Battery Registers */ +#define RK817_GAS_GAUGE_ADC_CONFIG0 0x50 +#define RK817_GG_EN (0x1 << 7) +#define RK817_SYS_VOL_ADC_EN (0x1 << 6) +#define RK817_TS_ADC_EN (0x1 << 5) +#define RK817_USB_VOL_ADC_EN (0x1 << 4) +#define RK817_BAT_VOL_ADC_EN (0x1 << 3) +#define RK817_BAT_CUR_ADC_EN (0x1 << 2) + +#define RK817_GAS_GAUGE_ADC_CONFIG1 0x55 + +#define RK817_CUR_CALIB_UPD (0x1 << 7) +#define RK817_VOL_CALIB_UPD (0x1 << 6) + +#define RK817_GAS_GAUGE_GG_CON 0x56 +#define RK817_GAS_GAUGE_GG_STS 0x57 + +#define RK817_RELAX_VOL_UPD (0x3 << 2) +#define RK817_RELAX_STS (0x1 << 1) + +#define RK817_GAS_GAUGE_RELAX_THRE_H 0x58 +#define RK817_GAS_GAUGE_RELAX_THRE_L 0x59 +#define RK817_GAS_GAUGE_OCV_THRE_VOL 0x62 +#define RK817_GAS_GAUGE_OCV_VOL_H 0x63 +#define RK817_GAS_GAUGE_OCV_VOL_L 0x64 +#define RK817_GAS_GAUGE_PWRON_VOL_H 0x6b +#define RK817_GAS_GAUGE_PWRON_VOL_L 0x6c +#define RK817_GAS_GAUGE_PWRON_CUR_H 0x6d +#define RK817_GAS_GAUGE_PWRON_CUR_L 0x6e +#define RK817_GAS_GAUGE_OFF_CNT 0x6f +#define RK817_GAS_GAUGE_Q_INIT_H3 0x70 +#define RK817_GAS_GAUGE_Q_INIT_H2 0x71 +#define RK817_GAS_GAUGE_Q_INIT_L1 0x72 +#define RK817_GAS_GAUGE_Q_INIT_L0 0x73 +#define RK817_GAS_GAUGE_Q_PRES_H3 0x74 +#define RK817_GAS_GAUGE_Q_PRES_H2 0x75 +#define RK817_GAS_GAUGE_Q_PRES_L1 0x76 +#define RK817_GAS_GAUGE_Q_PRES_L0 0x77 +#define RK817_GAS_GAUGE_BAT_VOL_H 0x78 +#define RK817_GAS_GAUGE_BAT_VOL_L 0x79 +#define RK817_GAS_GAUGE_BAT_CUR_H 0x7a +#define RK817_GAS_GAUGE_BAT_CUR_L 0x7b +#define RK817_GAS_GAUGE_USB_VOL_H 0x7e +#define RK817_GAS_GAUGE_USB_VOL_L 0x7f +#define RK817_GAS_GAUGE_SYS_VOL_H 0x80 +#define RK817_GAS_GAUGE_SYS_VOL_L 0x81 +#define RK817_GAS_GAUGE_Q_MAX_H3 0x82 +#define RK817_GAS_GAUGE_Q_MAX_H2 0x83 +#define RK817_GAS_GAUGE_Q_MAX_L1 0x84 +#define RK817_GAS_GAUGE_Q_MAX_L0 0x85 +#define RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_H 0x8f +#define RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_L 0x90 +#define RK817_GAS_GAUGE_CAL_OFFSET_H 0x91 +#define RK817_GAS_GAUGE_CAL_OFFSET_L 0x92 +#define RK817_GAS_GAUGE_VCALIB0_H 0x93 +#define RK817_GAS_GAUGE_VCALIB0_L 0x94 +#define RK817_GAS_GAUGE_VCALIB1_H 0x95 +#define RK817_GAS_GAUGE_VCALIB1_L 0x96 +#define RK817_GAS_GAUGE_IOFFSET_H 0x97 +#define RK817_GAS_GAUGE_IOFFSET_L 0x98 +#define RK817_GAS_GAUGE_BAT_R1 0x9a +#define RK817_GAS_GAUGE_BAT_R2 0x9b +#define RK817_GAS_GAUGE_BAT_R3 0x9c +#define RK817_GAS_GAUGE_DATA3 0xa0 +#define RK817_GAS_GAUGE_DATA4 0xa1 +#define RK817_GAS_GAUGE_DATA5 0xa2 +#define RK817_GAS_GAUGE_CUR_ADC_K0 0xb0 + #define RK817_POWER_EN_REG(i) (0xb1 + (i)) #define RK817_POWER_SLP_EN_REG(i) (0xb5 + (i)) @@ -543,10 +611,29 @@ enum rk809_reg_id { #define RK817_LDO_ON_VSEL_REG(idx) (0xcc + (idx) * 2) #define RK817_BOOST_OTG_CFG (0xde) +#define RK817_PMIC_CHRG_OUT 0xe4 +#define RK817_CHRG_VOL_SEL (0x07 << 4) +#define RK817_CHRG_CUR_SEL (0x07 << 0) + +#define RK817_PMIC_CHRG_IN 0xe5 +#define RK817_USB_VLIM_EN (0x01 << 7) +#define RK817_USB_VLIM_SEL (0x07 << 4) +#define RK817_USB_ILIM_EN (0x01 << 3) +#define RK817_USB_ILIM_SEL (0x07 << 0) +#define RK817_PMIC_CHRG_TERM 0xe6 +#define RK817_CHRG_TERM_ANA_DIG (0x01 << 2) +#define RK817_CHRG_TERM_ANA_SEL (0x03 << 0) +#define RK817_CHRG_EN (0x01 << 6) + +#define RK817_PMIC_CHRG_STS 0xeb +#define RK817_CHG_STS (0x07 << 4) + #define RK817_ID_MSB 0xed #define RK817_ID_LSB 0xee #define RK817_SYS_STS 0xf0 +#define RK817_PLUG_IN_STS (0x1 << 6) + #define RK817_SYS_CFG(i) (0xf1 + (i)) #define RK817_ON_SOURCE_REG 0xf5 From patchwork Mon Jul 26 19:01:29 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Morgan X-Patchwork-Id: 12400607 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-10.9 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS, UNWANTED_LANGUAGE_BODY,URIBL_BLOCKED,USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 8C6DFC4338F for ; Mon, 26 Jul 2021 19:02:48 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id 458F660F8F for ; Mon, 26 Jul 2021 19:02:48 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org 458F660F8F Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=mkX35K4Hoijc1Ptf11duS83HYkhztMJ44r07olghYdA=; b=js1CLih+FMppXl lDYSEDTckXtn7VPn1kZhU0vYa68QRuw22jub1N+Zf4rBdbUhtX3h7oZ1XY7B1UrfAt5VsMMPNR6hA ykF9tdiyuoBitxHFg1iliiK3Xq7kNnKWy9O6ilMVsIEmQPJzZMG4MTD5oYoOP1ppQfd+Zsy33lEo5 zEUCGYg7lWgqANUwPmzcMhgyGJMis7cFUCX8EBYNV0tp15Z9Kc52Q/D+GT7YTafumckaM83lwhe16 pWqrsTFlJ0oZ7NiGVeCTWURUF9dzsFymfeHORrqOMwdosWu6cuIF+LmYNVmID5bTCrc/XstKnTjXw HajBizKr/zBG7d0HMl2Q==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85sC-00CJXc-Fm; Mon, 26 Jul 2021 19:02:44 +0000 Received: from mail-oi1-x22d.google.com ([2607:f8b0:4864:20::22d]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rH-00CJ9S-Bx; Mon, 26 Jul 2021 19:01:51 +0000 Received: by mail-oi1-x22d.google.com with SMTP id l126so12151140oib.2; Mon, 26 Jul 2021 12:01:47 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=Kpk5fJ9sWAmAZQNsGb2qXDfyIZ4WF/Ppi9KCcJULeoM=; b=kIzq1Z/Gyrt1UwpNFtSEf+G9OkGN56/ZOEFxzRRdpXocA59DJjyxODTf3nyNE0hpP+ LatLJItGIAem6FEvjt9x/gJ6H0lUuh63xun/pX3w4doVJJLlVn8fGA/ITVPq8/i+SIvz yqlrBZtdQnlizmbL4RFwIOMwGeCtIxiFLTx0oJg/idtMh2Ao4BJgeSkgLyXaCw4ei+Rv Gvql8b+ku3pZP6Q0geSaH6UcT2TiLHT7jnFyKOOD42g83qbJ5FsXXZ/7uxwEVDnywmKr 7tKREp9TXMO/lxOTaxhmJOZioixQ9H1zxzbQGZba28dsl9XtSS0f75iYGt6DWXy+yXg+ XhMg== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=Kpk5fJ9sWAmAZQNsGb2qXDfyIZ4WF/Ppi9KCcJULeoM=; b=a914ywVn6yiJCC+O/nmyNBh+rXi0W84Y3LaFPBztdYWW5QzhKPiWU5D6TNBYopCyyY UKfjsaZA+wFD4AuZkZEiNxOfl62gKef2Y4qJc32OKW59VwewukAk+d9OUjdATTOdK/QB LhhGGc0IK2NTaJzabl0Spg0vOwvunWKSfGazqGImc+GnXoFUgc/+OU/PWTqAMhz9JjE3 pGUIf6qzEmmac86R9om9iYOqP6JfYMAkbBPM4WBbpAESQCBoEBXeea0lvFznEfZwqsW2 7IyA1q9oEwN+80/4P9vPT+sq/m1WjuV0yFBvQEcNWSel8nl3Llw+pEneqc356kfn17lQ /nlg== X-Gm-Message-State: AOAM530zS7nqZRZ1BkgChOr09yQFX0oaeYUAvcJal6X8kosJ1408jke3 K7UAM69XOfFiNXKj6HHYbec= X-Google-Smtp-Source: ABdhPJx6ixMJIEQADeHtT9Smm06eAA6YclwroGxClfQOmTym7Fnt2U9siCKQUyYbWD1pmvWUI3UTHQ== X-Received: by 2002:aca:a8cf:: with SMTP id r198mr12014777oie.143.1627326106212; Mon, 26 Jul 2021 12:01:46 -0700 (PDT) Received: from wintermute.localdomain (cpe-76-183-134-35.tx.res.rr.com. [76.183.134.35]) by smtp.gmail.com with ESMTPSA id v7sm106610ooj.46.2021.07.26.12.01.45 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 26 Jul 2021 12:01:45 -0700 (PDT) From: Chris Morgan To: linux-pm@vger.kernel.org Cc: linux-rockchip@lists.infradead.org, linux-arm-kernel@lists.infradead.org, maccraft123mc@gmail.com, sre@kernel.org, heiko@sntech.de, robh+dt@kernel.org, lee.jones@linaro.org, Chris Morgan Subject: [RFC v2 3/4] power: supply: Add charger driver for Rockchip RK817 Date: Mon, 26 Jul 2021 14:01:29 -0500 Message-Id: <20210726190130.1973-4-macroalpha82@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210726190130.1973-1-macroalpha82@gmail.com> References: <20210726190130.1973-1-macroalpha82@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210726_120147_614550_50089C3A X-CRM114-Status: GOOD ( 26.81 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org From: Chris Morgan Add support for the Rockchip rk817 battery charger integrated into the rk817 PMIC. Signed-off-by: Chris Morgan Signed-off-by: Maya Matuszczyk --- drivers/power/supply/Kconfig | 6 + drivers/power/supply/Makefile | 1 + drivers/power/supply/rk817_charger.c | 932 +++++++++++++++++++++++++++ 3 files changed, 939 insertions(+) create mode 100644 drivers/power/supply/rk817_charger.c diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig index 11f5368e810e..311130da36ff 100644 --- a/drivers/power/supply/Kconfig +++ b/drivers/power/supply/Kconfig @@ -666,6 +666,12 @@ config CHARGER_BQ256XX charge management and system power path management devices for single cell Li-ion and Li-polymer batteries. +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 33059a91f60c..9497d2105712 100644 --- a/drivers/power/supply/Makefile +++ b/drivers/power/supply/Makefile @@ -87,6 +87,7 @@ obj-$(CONFIG_CHARGER_BQ2515X) += bq2515x_charger.o obj-$(CONFIG_CHARGER_BQ25890) += bq25890_charger.o obj-$(CONFIG_CHARGER_BQ25980) += bq25980_charger.o obj-$(CONFIG_CHARGER_BQ256XX) += bq256xx_charger.o +obj-$(CONFIG_CHARGER_RK817) += rk817_charger.o obj-$(CONFIG_CHARGER_SMB347) += smb347-charger.o obj-$(CONFIG_CHARGER_TPS65090) += tps65090-charger.o obj-$(CONFIG_CHARGER_TPS65217) += 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..0861bd428756 --- /dev/null +++ b/drivers/power/supply/rk817_charger.c @@ -0,0 +1,932 @@ +// SPDX-License-Identifier: GPL-2.0-only +/* + * Charger Driver for Rockchip rk817 + * + * Copyright (c) 2021 + * + * Authors: Maya Matuszczyk + * Chris Morgan + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#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_battery_info bat_info; + + struct power_supply *chg_ps; + bool plugged_in; + + uint32_t voltage_k; + uint32_t voltage_b; + + /* dsoc seems to be difference between full charge and actual charge in + * BSP stored as a percentage, to the thousandth. + */ + int dsoc; + + /* Implementation specific properties from device tree */ + int res_div; + int sleep_enter_current; + int sleep_filter_current; +}; + +/* 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) + +#define ADC_TO_CAPACITY(adc_value, res_div) \ + (adc_value / 1000 * 172 / 3600 / res_div) + +static u8 rk817_chg_cur_to_reg(u32 chg_cur_ma) +{ + if (chg_cur_ma < 500) + return -EINVAL; + else if (chg_cur_ma < 1000) + return CHG_0_5A; + else if (chg_cur_ma < 1500) + return CHG_1A; + else if (chg_cur_ma < 2000) + return CHG_1_5A; + else if (chg_cur_ma < 2500) + return CHG_2A; + else if (chg_cur_ma < 2750) + return CHG_2_5A; + else if (chg_cur_ma < 3000) + return CHG_2_75A; + else if (chg_cur_ma < 3500) + return CHG_3A; + else + return CHG_3_5A; +} + +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 int rk817_get_reg_hl(struct rk817_charger *charger, int regH, int regL) +{ + int tmp, ret; + uint32_t out; + struct rk808 *rk808 = charger->rk808; + + ret = regmap_read(rk808->regmap, regL, &tmp); + if (ret) + return ret; + out = tmp; + + ret = regmap_read(rk808->regmap, regH, &tmp); + if (ret) + return ret; + out |= tmp << 8; + + return out; +} + +static void rk817_write_reg_hl(struct rk817_charger *charger, int regH, + int regL, int val) +{ + uint8_t tmp; + struct rk808 *rk808 = charger->rk808; + + tmp = val & 0xff; + regmap_write(rk808->regmap, regL, tmp); + tmp = (val >> 8) & 0xff; + regmap_write(rk808->regmap, regH, tmp); +} + +static void rk817_bat_calib_vol(struct rk817_charger *charger) +{ + uint32_t vcalib0 = 0; + uint32_t vcalib1 = 0; + + /* calibrate voltage */ + vcalib0 = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_VCALIB0_H, + RK817_GAS_GAUGE_VCALIB0_L); + vcalib1 = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_VCALIB1_H, + RK817_GAS_GAUGE_VCALIB1_L); + + /* values were taken from BSP kernel */ + charger->voltage_k = (4025 - 2300) * 1000 / + ((vcalib1 - vcalib0) ? (vcalib1 - vcalib0) : 1); + charger->voltage_b = 4025 - (charger->voltage_k * vcalib1) / 1000; +} + +static void rk817_bat_calib_cur(struct rk817_charger *charger) +{ + int ioffset = 0; + /* calibrate current */ + ioffset = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_IOFFSET_H, + RK817_GAS_GAUGE_IOFFSET_L); + rk817_write_reg_hl(charger, RK817_GAS_GAUGE_CAL_OFFSET_H, + RK817_GAS_GAUGE_CAL_OFFSET_L, ioffset); +} + +static int rk817_bat_calib_cap(struct rk817_charger *charger) +{ + struct rk808 *rk808 = charger->rk808; + struct power_supply_battery_info *info = &charger->bat_info; + int reg, tmp, charge_now, charge_now_adc, dsoc_value; + u8 bulk_reg[4]; + + /* Calibrate the capacity on a fully charged battery */ + + regmap_read(rk808->regmap, RK817_PMIC_CHRG_STS, ®); + tmp = (reg >> 4) & 0x07; + if (tmp == CHARGE_FINISH) { + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, + bulk_reg, 4); + charge_now_adc = (bulk_reg[0] << 24) | (bulk_reg[1] << 16) | + (bulk_reg[2] << 8) | bulk_reg[3]; + if (charge_now_adc < 0) + charge_now_adc = 0; + charge_now = ADC_TO_CHARGE_UAH(charge_now_adc, charger->res_div); + dsoc_value = ((charge_now * 100) / + (info->charge_full_design_uah / 1000)); + if (dsoc_value > 100000) + charger->dsoc = 100000; + if (dsoc_value != charger->dsoc) { + charger->dsoc = dsoc_value; + bulk_reg[2] = (dsoc_value >> 16) & 0xff; + bulk_reg[1] = (dsoc_value >> 8) & 0xff; + bulk_reg[0] = dsoc_value & 0xff; + regmap_bulk_write(rk808->regmap, + RK817_GAS_GAUGE_BAT_R1, bulk_reg, 3); + } + } + + return 0; + +} + +static int rk817_bat_get_prop(struct power_supply *ps, + enum power_supply_property prop, + union power_supply_propval *val) +{ + struct rk817_charger *charger = power_supply_get_drvdata(ps); + uint32_t tmp = 0; + /* Registers for current is a signed 16bit int */ + short int cur = 0; + /* Registers for capacity-now is a signed 32bit int */ + int32_t charge_now = 0; + int ret = 0; + int reg = 0; + u8 bulk_reg[4]; + struct rk808 *rk808 = charger->rk808; + + /* 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(rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG1, ®); + tmp = (reg >> 7) & 0x01; + if (tmp) { + rk817_bat_calib_cur(charger); + rk817_bat_calib_vol(charger); + regmap_write_bits(rk808->regmap, RK817_GAS_GAUGE_ADC_CONFIG1, + RK817_CUR_CALIB_UPD, (1 << 7)); + } + + rk817_bat_calib_cap(charger); + + switch (prop) { + case POWER_SUPPLY_PROP_PRESENT: + regmap_read(rk808->regmap, RK817_PMIC_CHRG_STS, ®); + val->intval = (reg >> 7); + break; + case POWER_SUPPLY_PROP_STATUS: + if (!charger->plugged_in) { + val->intval = POWER_SUPPLY_STATUS_DISCHARGING; + break; + } + ret = regmap_read(rk808->regmap, RK817_PMIC_CHRG_STS, ®); + if (ret) + return ret; + tmp = (reg >> 4) & 0x07; + switch (tmp) { + case CHRG_OFF: + val->intval = 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 = POWER_SUPPLY_STATUS_CHARGING; + break; + case CHARGE_FINISH: + val->intval = POWER_SUPPLY_STATUS_FULL; + break; + default: + val->intval = POWER_SUPPLY_STATUS_UNKNOWN; + return -EINVAL; + + } + break; + case POWER_SUPPLY_PROP_CHARGE_TYPE: + ret = regmap_read(rk808->regmap, RK817_PMIC_CHRG_STS, ®); + if (ret) + return ret; + tmp = (reg >> 4) & 0x07; + switch (tmp) { + case CHRG_OFF: + case CHARGE_FINISH: + val->intval = POWER_SUPPLY_CHARGE_TYPE_NONE; + break; + case TRICKLE_CHRG: + val->intval = POWER_SUPPLY_CHARGE_TYPE_TRICKLE; + break; + case DEAD_CHRG: + case CC_OR_CV_CHRG: + val->intval = POWER_SUPPLY_CHARGE_TYPE_STANDARD; + break; + default: + val->intval = POWER_SUPPLY_CHARGE_TYPE_UNKNOWN; + break; + } + break; + case POWER_SUPPLY_PROP_CHARGE_FULL: + val->intval = ((charger->bat_info.charge_full_design_uah / + 1000) * charger->dsoc) / 100; + break; + case POWER_SUPPLY_PROP_CHARGE_FULL_DESIGN: + val->intval = charger->bat_info.charge_full_design_uah; + break; + case POWER_SUPPLY_PROP_CHARGE_EMPTY_DESIGN: + val->intval = 0; + break; + case POWER_SUPPLY_PROP_CHARGE_NOW: + regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_Q_PRES_H3, + bulk_reg, 4); + charge_now = (bulk_reg[0] << 24) | (bulk_reg[1] << 16) | + (bulk_reg[2] << 8) | bulk_reg[3]; + if (charge_now < 0) + charge_now = 0; + val->intval = ADC_TO_CHARGE_UAH(charge_now, charger->res_div); + break; + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + val->intval = charger->bat_info.voltage_min_design_uv; + break; + case POWER_SUPPLY_PROP_VOLTAGE_BOOT: + tmp = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_PWRON_VOL_H, + RK817_GAS_GAUGE_PWRON_VOL_L); + val->intval = (1000 * (((charger->voltage_k * tmp) / 1000) + + charger->voltage_b)); + break; + case POWER_SUPPLY_PROP_VOLTAGE_AVG: + tmp = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_BAT_VOL_H, + RK817_GAS_GAUGE_BAT_VOL_L); + val->intval = (1000 * (((charger->voltage_k * tmp) / 1000) + + charger->voltage_b)); + break; + case POWER_SUPPLY_PROP_VOLTAGE_OCV: + tmp = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_OCV_VOL_H, + RK817_GAS_GAUGE_OCV_VOL_H); + val->intval = (1000 * (((charger->voltage_k * tmp) / 1000) + + charger->voltage_b)); + break; + case POWER_SUPPLY_PROP_CURRENT_BOOT: + cur = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_PWRON_CUR_H, + RK817_GAS_GAUGE_PWRON_CUR_H); + val->intval = ADC_TO_CURRENT(cur, charger->res_div); + break; + case POWER_SUPPLY_PROP_CURRENT_AVG: + cur = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_BAT_CUR_H, + RK817_GAS_GAUGE_BAT_CUR_L); + val->intval = ADC_TO_CURRENT(cur, charger->res_div); + break; + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX: + regmap_read(rk808->regmap, RK817_PMIC_CHRG_OUT, &tmp); + val->intval = rk817_chg_cur_from_reg(tmp & RK817_CHRG_CUR_SEL); + break; + case POWER_SUPPLY_PROP_CONSTANT_CHARGE_VOLTAGE_MAX: + regmap_read(rk808->regmap, RK817_PMIC_CHRG_OUT, &tmp); + val->intval = ((((tmp & RK817_CHRG_VOL_SEL) >> 4) * 50000) + + 4100000); + break; + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + val->intval = charger->bat_info.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 = power_supply_get_drvdata(ps); + int vol, tmp = 0; + + switch (prop) { + case POWER_SUPPLY_PROP_ONLINE: + val->intval = charger->plugged_in; + break; + case POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN: + /* max voltage from datasheet at 5.5v (default 5.0v) */ + val->intval = 5500000; + break; + case POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN: + /* min voltage from datasheet at 3.8v (default 5.0v) */ + val->intval = 3800000; + break; + case POWER_SUPPLY_PROP_VOLTAGE_AVG: + /* 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. + */ + tmp = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_USB_VOL_H, + RK817_GAS_GAUGE_USB_VOL_L); + vol = ((charger->voltage_k * tmp / 1000 + charger->voltage_b) * + 60 / 46); + val->intval = vol * 1000; + break; + default: + return -EINVAL; + } + return 0; + +} + +static irqreturn_t rk817_plug_in_isr(int irq, void *cg) +{ + struct rk817_charger *charger; + + charger = (struct rk817_charger *)cg; + charger->plugged_in = 1; + power_supply_changed(charger->chg_ps); + power_supply_changed(charger->bat_ps); + 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 = (struct rk817_charger *)cg; + rk808 = charger->rk808; + charger->plugged_in = 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)); + + dev_dbg(charger->dev, "Power Cord Removed\n"); + + return IRQ_HANDLED; +} + +static enum power_supply_property rk817_bat_props[] = { + 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_BOOT, + POWER_SUPPLY_PROP_VOLTAGE_AVG, + POWER_SUPPLY_PROP_VOLTAGE_OCV, + POWER_SUPPLY_PROP_CONSTANT_CHARGE_CURRENT_MAX, + POWER_SUPPLY_PROP_CURRENT_BOOT, + POWER_SUPPLY_PROP_CURRENT_AVG, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, +}; + +static enum power_supply_property rk817_chg_props[] = { + POWER_SUPPLY_PROP_ONLINE, + POWER_SUPPLY_PROP_VOLTAGE_MAX_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_MIN_DESIGN, + POWER_SUPPLY_PROP_VOLTAGE_AVG, +}; + +static const struct power_supply_desc rk817_bat_desc = { + .name = "rk817-battery", + .type = POWER_SUPPLY_TYPE_BATTERY, + .properties = rk817_bat_props, + .num_properties = ARRAY_SIZE(rk817_bat_props), + .get_property = rk817_bat_get_prop, +}; + +/* Note that all known existing implementations use a "USB" port that is either + * a power only port (no data lines) or use barrel plug to USB cable. Setting + * to POWER_SUPPLY_TYPE_USB_DCP. + */ +static const struct power_supply_desc rk817_chg_desc = { + .name = "rk817-charger", + .type = POWER_SUPPLY_TYPE_USB_DCP, + .properties = rk817_chg_props, + .num_properties = ARRAY_SIZE(rk817_chg_props), + .get_property = rk817_chg_get_prop, +}; + +static int rk817_read_or_set_full_charge_on_boot(struct rk817_charger *charger) +{ + struct rk808 *rk808 = charger->rk808; + struct power_supply_battery_info *info = &charger->bat_info; + u8 reg[4]; + u32 design_charge_mah = (info->charge_full_design_uah / 1000); + u32 boot_voltage, boot_charge, tmp, full_charge_cap; + int ret, boot_capacity; + + /* Read DSOC value if pre-existing. If not, initialize at 100%. + * Note endianness, also register says it's for resistance, + * however BSP kernel treats this as an nvram field for the DSOC + * as best I can tell. Doing the same for backwards compatibility. + */ + ret = regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_BAT_R1, reg, 3); + if (ret < 0) + return ret; + + charger->dsoc = (reg[2] << 16) | (reg[1] << 8) | (reg[0]); + /* If we have an invalid DSOC, write 100 (100000) as default. */ + if (charger->dsoc < 1000 || charger->dsoc > 100000) { + regmap_write(rk808->regmap, RK817_GAS_GAUGE_BAT_R1, 0xa0); + regmap_write(rk808->regmap, RK817_GAS_GAUGE_BAT_R2, 0x86); + regmap_write(rk808->regmap, RK817_GAS_GAUGE_BAT_R3, 0x01); + charger->dsoc = 100000; + } + + /* Register appears to be nvram that stores capacity in mAH. Note + * endianness, keeping consistent with BSP kernel, however it looks + * like we can use any arbitrary method to store value if we don't care + * about compatibility. Additionally, it doesn't appear that this value + * is used for anything, so realistically getting it and setting it is + * to ensure backward compatibility with BSP and serves no purpose with + * this driver, and I'm not sure if the BSP driver does anything with + * this value either. + */ + + ret = regmap_bulk_read(rk808->regmap, RK817_GAS_GAUGE_DATA3, reg, 3); + if (ret < 0) + return ret; + + full_charge_cap = (reg[2] << 16) | (reg[1] << 8) | (reg[0]); + + /* 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. + */ + if (full_charge_cap < 500) { + reg[2] = (design_charge_mah >> 16) & 0xff; + reg[1] = (design_charge_mah >> 8) & 0xff; + reg[0] = design_charge_mah & 0xff; + ret = regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_DATA3, reg, 3); + if (ret < 0) + return ret; + dev_info(charger->dev, + "Invalid NVRAM Data for max charge, setting to design capacity %u uAH\n", + design_charge_mah*1000); + } + + /* Capture boot voltage and look up boot capacity from OCV tables. */ + + tmp = rk817_get_reg_hl(charger, RK817_GAS_GAUGE_PWRON_VOL_H, + RK817_GAS_GAUGE_PWRON_VOL_L); + boot_voltage = (1000 * (((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. + */ + boot_capacity = power_supply_batinfo_ocv2cap(info, boot_voltage, 20); + if (boot_capacity < 0) { + dev_err(charger->dev, + "Unable to read boot charge from OCV table: %i\n", + boot_capacity); + return boot_capacity; + } + + /* Write boot charge to registers, estimate boot charge based on + * capacity and max charge of battery. + */ + boot_charge = (boot_capacity * info->charge_full_design_uah) / 100; + tmp = CHARGE_TO_ADC((boot_charge / 1000), charger->res_div); + regmap_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H3, + (tmp >> 24) & 0xFF); + regmap_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_H2, + (tmp >> 16) & 0xFF); + regmap_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_L1, + (tmp >> 8) & 0xFF); + regmap_write(rk808->regmap, RK817_GAS_GAUGE_Q_INIT_L0, + tmp & 0xFF); + + /* Set QMAX value to max design capacity. */ + tmp = CHARGE_TO_ADC((info->charge_full_design_uah / 1000), + charger->res_div); + reg[0] = (tmp >> 24) & 0xff; + reg[1] = (tmp >> 16) & 0xff; + reg[2] = (tmp >> 8) & 0xff; + reg[3] = tmp & 0xff; + ret = regmap_bulk_write(rk808->regmap, RK817_GAS_GAUGE_Q_MAX_H3, + reg, 4); + if (ret < 0) + return ret; + + return 0; + +} + +static int rk817_battery_init(struct rk817_charger *charger) +{ + struct rk808 *rk808 = charger->rk808; + struct power_supply_battery_info *info = &charger->bat_info; + 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; + + /* Get initial plug state */ + regmap_read(rk808->regmap, RK817_SYS_STS, &tmp); + charger->plugged_in = (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); + + /* Write relax threshold, derived from sleep enter current. */ + tmp = CURRENT_TO_ADC(charger->sleep_enter_current, charger->res_div); + rk817_write_reg_hl(charger, RK817_GAS_GAUGE_RELAX_THRE_H, + RK817_GAS_GAUGE_RELAX_THRE_L, tmp); + + /* Write sleep sample current, derived from sleep filter current. */ + tmp = CURRENT_TO_ADC(charger->sleep_filter_current, charger->res_div); + rk817_write_reg_hl(charger, RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_H, + RK817_GAS_GAUGE_SLEEP_CON_SAMP_CUR_L, tmp); + + /* 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 = info->constant_charge_voltage_max_uv / 1000; + max_chg_cur_ma = info->constant_charge_current_max_ua / 1000; + + if (max_chg_vol_mv < 4100) { + dev_emerg(charger->dev, + "Danger, invalid max charger voltage! Value %u unsupported\n", + max_chg_vol_mv * 1000); + return -EINVAL; + } + if (max_chg_vol_mv > 4450) { + dev_info(charger->dev, + "Setting max charge voltage to 4450000uv\n"); + max_chg_vol_mv = 4450; + } + + if (max_chg_cur_ma < 500) { + dev_emerg(charger->dev, + "Danger, invalid max charger current! Value %u unsupported\n", + max_chg_cur_ma * 1000); + return -EINVAL; + } + 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 = (max_chg_vol_mv - 4100) / 50; + + max_chg_cur_reg = rk817_chg_cur_to_reg(max_chg_cur_ma); + + if (max_chg_vol_reg < 0 || max_chg_vol_reg > 7) { + dev_emerg(charger->dev, + "Danger, invalid max charger voltage! Value %u unsupported\n", + max_chg_vol_mv * 1000); + return -EINVAL; + } + if (max_chg_cur_reg < 0 || max_chg_cur_reg > 7) { + dev_emerg(charger->dev, + "Danger, invalid max charger voltage! Value %u unsupported\n", + max_chg_cur_ma * 1000); + return -EINVAL; + } + + /* Write the values to the registers, and deliver an emergency warning + * in the event they are not written correctly. + */ + ret = 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 = 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 = info->charge_term_current_ua / 1000; + if (chg_term_ma < 150 || chg_term_ma > 400) { + dev_warn(charger->dev, + "Invalid charge termination value %u, keeping default\n", + chg_term_ma * 1000); + chg_term_ma = 200; + } + + /* Values of 150ma, 200ma, 300ma, and 400ma correspond to 00, 01, 10, + * and 11. + */ + chg_term_i_reg = (chg_term_ma - 100) / 100; + regmap_write_bits(rk808->regmap, RK817_PMIC_CHRG_TERM, + RK817_CHRG_TERM_ANA_SEL, chg_term_i_reg); + + ret = rk817_read_or_set_full_charge_on_boot(charger); + 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 int rk817_charger_probe(struct platform_device *pdev) +{ + struct rk808 *rk808 = dev_get_drvdata(pdev->dev.parent); + struct rk817_charger *charger; + struct device_node *node; + struct power_supply_battery_info *info; + struct device *dev = &pdev->dev; + struct power_supply_config pscfg = {}; + int plugin_irq, plugout_irq; + int of_value; + int ret; + + node = of_get_child_by_name(dev->parent->of_node, "battery"); + if (!node) + return -ENODEV; + + charger = devm_kzalloc(&pdev->dev, sizeof(*charger), GFP_KERNEL); + if (!charger) + return -ENOMEM; + + charger->rk808 = rk808; + + charger->dev = &pdev->dev; + platform_set_drvdata(pdev, charger); + + rk817_bat_calib_vol(charger); + + pscfg.drv_data = charger; + pscfg.of_node = 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 = of_property_read_u32(node, "rockchip,resistor-sense", &of_value); + if (ret < 0) { + dev_err(dev, "Error reading sample resistor value: %i\n", ret); + return ret; + } + /* 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 = (of_value == 20000) ? 2 : 1; + + /* Get sleep enter current value. Not sure what this value is for + * other than to help calibrate the relax threshold. + */ + ret = of_property_read_u32(node, "rockchip,sleep-enter-current", + &of_value); + if (ret < 0) { + dev_err(dev, "Error reading sleep enter current value: %i\n", + ret); + return ret; + } + charger->sleep_enter_current = of_value; + + /* Get sleep filter current value */ + ret = of_property_read_u32(node, "rockchip,sleep-filter-current", + &of_value); + if (ret < 0) { + dev_err(dev, "Error reading sleep filter current value: %i\n", + ret); + return ret; + } + charger->sleep_filter_current = of_value; + + charger->bat_ps = devm_power_supply_register(&pdev->dev, + &rk817_bat_desc, &pscfg); + + charger->chg_ps = devm_power_supply_register(&pdev->dev, + &rk817_chg_desc, &pscfg); + + ret = power_supply_get_battery_info(charger->bat_ps, + &charger->bat_info); + if (ret) { + dev_err(dev, "Unable to get battery info: %d\n", ret); + return ret; + } + + info = &charger->bat_info; + if ((!info->charge_full_design_uah) || + (!info->voltage_min_design_uv) || + (!info->voltage_max_design_uv) || + (!info->constant_charge_voltage_max_uv) || + (!info->constant_charge_current_max_ua) || + (!info->charge_term_current_ua)) { + dev_err(dev, "Required battery information missing.\n"); + return -EINVAL; + } + + /* Has to run after power_supply_get_battery_info as it depends on some + * values discovered from that routine. + */ + ret = rk817_battery_init(charger); + if (ret) + return ret; + + plugin_irq = platform_get_irq(pdev, 0); + if (plugin_irq < 0) + return plugin_irq; + + plugout_irq = platform_get_irq(pdev, 1); + if (plugout_irq < 0) + return plugout_irq; + + ret = devm_request_threaded_irq(charger->dev, plugin_irq, NULL, + rk817_plug_in_isr, + IRQF_TRIGGER_RISING | IRQF_ONESHOT, + "rk817_plug_in", charger); + if (ret) { + dev_err(&pdev->dev, "plug_in_irq request failed!\n"); + return ret; + } + + ret = devm_request_threaded_irq(charger->dev, plugout_irq, NULL, + rk817_plug_out_isr, + IRQF_TRIGGER_RISING | IRQF_ONESHOT, + "rk817_plug_out", charger); + if (ret) { + dev_err(&pdev->dev, "plug_out_irq request failed!\n"); + return ret; + } + + return 0; +} + + +static struct platform_driver rk817_charger_driver = { + .probe = rk817_charger_probe, + .driver = { + .name = "rk817-charger", + }, +}; +module_platform_driver(rk817_charger_driver); + +MODULE_DESCRIPTION("Battery power supply driver for RK817 PMIC"); +MODULE_AUTHOR("Maya Matuszczyk "); +MODULE_LICENSE("GPL"); From patchwork Mon Jul 26 19:01:30 2021 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Chris Morgan X-Patchwork-Id: 12400605 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org X-Spam-Level: X-Spam-Status: No, score=-13.7 required=3.0 tests=BAYES_00, DKIM_ADSP_CUSTOM_MED,DKIM_SIGNED,DKIM_VALID,FREEMAIL_FORGED_FROMDOMAIN, FREEMAIL_FROM,HEADER_FROM_DIFFERENT_DOMAINS,INCLUDES_CR_TRAILER, INCLUDES_PATCH,MAILING_LIST_MULTI,SPF_HELO_NONE,SPF_PASS,URIBL_BLOCKED, USER_AGENT_GIT autolearn=unavailable autolearn_force=no version=3.4.0 Received: from mail.kernel.org (mail.kernel.org [198.145.29.99]) by smtp.lore.kernel.org (Postfix) with ESMTP id 04AC1C432BE for ; Mon, 26 Jul 2021 19:02:32 +0000 (UTC) Received: from bombadil.infradead.org (bombadil.infradead.org [198.137.202.133]) (using TLSv1.2 with cipher ECDHE-RSA-AES256-GCM-SHA384 (256/256 bits)) (No client certificate requested) by mail.kernel.org (Postfix) with ESMTPS id C9CBC60F11 for ; Mon, 26 Jul 2021 19:02:31 +0000 (UTC) DMARC-Filter: OpenDMARC Filter v1.4.1 mail.kernel.org C9CBC60F11 Authentication-Results: mail.kernel.org; dmarc=fail (p=none dis=none) header.from=gmail.com Authentication-Results: mail.kernel.org; spf=none smtp.mailfrom=lists.infradead.org DKIM-Signature: v=1; a=rsa-sha256; q=dns/txt; c=relaxed/relaxed; d=lists.infradead.org; s=bombadil.20210309; h=Sender: Content-Transfer-Encoding:Content-Type:List-Subscribe:List-Help:List-Post: List-Archive:List-Unsubscribe:List-Id:MIME-Version:References:In-Reply-To: Message-Id:Date:Subject:Cc:To:From:Reply-To:Content-ID:Content-Description: Resent-Date:Resent-From:Resent-Sender:Resent-To:Resent-Cc:Resent-Message-ID: List-Owner; bh=cbVTMhZtjhqXnJC5+btx/AHTUUl30bOv3yM7uOpX5d8=; b=4CdYJ+p2u/zpZ0 T+KMW2wyhBdPusBECH/YwixYXdjLhffJaoaQY6xW6LirFgX4Yu4p1NqopgdLKvw2SUUW4m9EwX4So tW8QwuPYtx1/ZMculYmHzB7Na/hFkf9M7YBAyvZJpwr/S388XILUs7GejUF7YOMQS8EAnNc3WN5T5 iY4Ypm4FSw1EOv/ztaiQlLPrKPcWU9gLQJWhheaB8jZ55rLZFIc4QU73nRWiMwNw3SRN3KFnV40QL 6vI+C50VMcC1+tpSwtE0vwWjOJMkiy7oDGxIyP9MqwdXMeuatO+bCCh83SK8yfKHdrjJaoNrorop8 WE+d3v82tQyeXbe4IM3w==; Received: from localhost ([::1] helo=bombadil.infradead.org) by bombadil.infradead.org with esmtp (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rw-00CJPq-Ev; Mon, 26 Jul 2021 19:02:28 +0000 Received: from mail-ot1-x334.google.com ([2607:f8b0:4864:20::334]) by bombadil.infradead.org with esmtps (Exim 4.94.2 #2 (Red Hat Linux)) id 1m85rI-00CJA5-EP; Mon, 26 Jul 2021 19:01:49 +0000 Received: by mail-ot1-x334.google.com with SMTP id f20-20020a9d6c140000b02904bb9756274cso10992635otq.6; Mon, 26 Jul 2021 12:01:48 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20161025; h=from:to:cc:subject:date:message-id:in-reply-to:references :mime-version:content-transfer-encoding; bh=vZfHRgT3Nz1lZYd7karZdl8CVKgaGTnZLjBxunPxNVw=; b=PNOfy3Hm9aXJEig+isQo3IM60LQrOlNBuPH4HHe+eTLZyHaDKOpmKItM3UUwwdXU8m PxJm3GU3oWHf2xM/DjGTjUEya1YOAXwdEjPhN9HvcV9eP7aJDCWmQYABzi8E/zaDcnfn Fv6ZGZiJNuRIW8g/7/KZdFTL/0VuZLZDhnWqXKgRjk3rsPG0ZD9sgNeXuSSaZLpf4z3u BrrefWncHg+temdILD1BkzmCOis1pBWbWiCSNdf0XSZQdsIkwlmJmS6cXXbSfdiGLtyr Jm+g7mCrzI1RrNw9y1E0B6LxCFpiWzhkyQN4mtzjIToJYG5rpbXNyl1biRIQItMtDFaR /29g== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20161025; h=x-gm-message-state:from:to:cc:subject:date:message-id:in-reply-to :references:mime-version:content-transfer-encoding; bh=vZfHRgT3Nz1lZYd7karZdl8CVKgaGTnZLjBxunPxNVw=; b=aHNyVxdkPM0bmGYyGINP1LfXoNKpJmB+8S+8PhjJ0a/miwhJGSRAOcmsdL611Doqzx DuqX40OnyI8vWCoGNdK7+DvVI8nrWYL7t2elB+vGWIYfzcxbPj2SXmh2Ta/plkMhoFqw Eip+rL3g/OhaLHdOIyCi1W6bY6gW6/NaCqJVc6/mJhJXXRzP4zFycOR8v1kYhiXIy24K wFdGNYR79+sseWnVPv6XnXqQPw8SqXRV1qxpvM2VDtJchv0+sFq/R6hbKaEGTkavfOVk frdYQ+lYE6v0TkcVtrqIUveK7lezZyTj9W6bcYgrjz12TaQBdgm5oC9Zsf3edFGNI0hz 2lIA== X-Gm-Message-State: AOAM5318aqpVjJ67VLlc7Nqig7uL3XVqN4h6qt83+xRz/5FO99jxhQsZ vmofkem+7+9KagYBMwCwakFvCSGgInQ= X-Google-Smtp-Source: ABdhPJxXNYp3ueyrRFGE3rLDg2ezTp+nMBK/elezfPDGJqQc4RY2bdb4DQU7t87TXRF3yoyeLwgyQg== X-Received: by 2002:a9d:550c:: with SMTP id l12mr1495048oth.169.1627326107547; Mon, 26 Jul 2021 12:01:47 -0700 (PDT) Received: from wintermute.localdomain (cpe-76-183-134-35.tx.res.rr.com. [76.183.134.35]) by smtp.gmail.com with ESMTPSA id v7sm106610ooj.46.2021.07.26.12.01.46 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Mon, 26 Jul 2021 12:01:47 -0700 (PDT) From: Chris Morgan To: linux-pm@vger.kernel.org Cc: linux-rockchip@lists.infradead.org, linux-arm-kernel@lists.infradead.org, maccraft123mc@gmail.com, sre@kernel.org, heiko@sntech.de, robh+dt@kernel.org, lee.jones@linaro.org, Chris Morgan Subject: [RFC v2 4/4] arm64: dts: rockchip: add rk817 charger to Odroid Go Advance Date: Mon, 26 Jul 2021 14:01:30 -0500 Message-Id: <20210726190130.1973-5-macroalpha82@gmail.com> X-Mailer: git-send-email 2.25.1 In-Reply-To: <20210726190130.1973-1-macroalpha82@gmail.com> References: <20210726190130.1973-1-macroalpha82@gmail.com> MIME-Version: 1.0 X-CRM114-Version: 20100106-BlameMichelson ( TRE 0.8.0 (BSD) ) MR-646709E3 X-CRM114-CacheID: sfid-20210726_120148_548691_8F1FE8AA X-CRM114-Status: GOOD ( 11.86 ) X-BeenThere: linux-rockchip@lists.infradead.org X-Mailman-Version: 2.1.34 Precedence: list List-Id: Upstream kernel work for Rockchip platforms List-Unsubscribe: , List-Archive: List-Post: List-Help: List-Subscribe: , Sender: "Linux-rockchip" Errors-To: linux-rockchip-bounces+linux-rockchip=archiver.kernel.org@lists.infradead.org From: Chris Morgan Add the new rk817 charger driver to the Odroid Go Advance. Create a monitored battery node as well for the charger to use. All values from monitored battery are gathered from the BSP kernel for the Odroid Go Advance provided by HardKernel. Signed-off-by: Chris Morgan Signed-off-by: Maya Matuszczyk --- .../boot/dts/rockchip/rk3326-odroid-go2.dts | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/arch/arm64/boot/dts/rockchip/rk3326-odroid-go2.dts b/arch/arm64/boot/dts/rockchip/rk3326-odroid-go2.dts index 7fc674a99a6c..333bcf8da450 100644 --- a/arch/arm64/boot/dts/rockchip/rk3326-odroid-go2.dts +++ b/arch/arm64/boot/dts/rockchip/rk3326-odroid-go2.dts @@ -52,6 +52,25 @@ backlight: backlight { pwms = <&pwm1 0 25000 0>; }; + battery_cell: battery-cell { + compatible = "simple-battery"; + charge-full-design-microamp-hours = <3000000>; + charge-term-current-microamp = <300000>; + constant-charge-current-max-microamp = <2000000>; + constant-charge-voltage-max-microvolt = <4200000>; + factory-internal-resistance-micro-ohms = <180000>; + voltage-max-design-microvolt = <4100000>; + voltage-min-design-microvolt = <3500000>; + + ocv-capacity-celsius = <20>; + ocv-capacity-table-0 = <4106000 100>, <4071000 95>, <4018000 90>, <3975000 85>, + <3946000 80>, <3908000 75>, <3877000 70>, <3853000 65>, + <3834000 60>, <3816000 55>, <3802000 50>, <3788000 45>, + <3774000 40>, <3760000 35>, <3748000 30>, <3735000 25>, + <3718000 20>, <3697000 15>, <3685000 10>, <3625000 5>, + <3500000 0>; + }; + gpio-keys { compatible = "gpio-keys"; pinctrl-names = "default"; @@ -462,6 +481,13 @@ regulator-state-mem { }; }; + rk817_battery: battery { + monitored-battery = <&battery_cell>; + rockchip,resistor-sense = <10000>; + rockchip,sleep-enter-current = <300000>; + rockchip,sleep-filter-current = <100000>; + }; + rk817_codec: codec { rockchip,mic-in-differential; };