From patchwork Fri Oct 19 10:53:11 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "\(Exiting\) Baolin Wang" X-Patchwork-Id: 149252 Delivered-To: patch@linaro.org Received: by 2002:a2e:8595:0:0:0:0:0 with SMTP id b21-v6csp3143342lji; Fri, 19 Oct 2018 03:53:48 -0700 (PDT) X-Google-Smtp-Source: ACcGV62dbTtL7WqY2fwHTzAzqj1lbMmZaXhJxCmlLCaqHigbwHn701jB2qrfAzyoNS3pp4SUkdsl X-Received: by 2002:a17:902:848f:: with SMTP id c15-v6mr32677292plo.119.1539946428852; Fri, 19 Oct 2018 03:53:48 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1539946428; cv=none; d=google.com; s=arc-20160816; b=KcKqp/3rI06RFsOnInKaUDHk6nanLZgSU1vYydMjm4pgF8xeXGpShG6/JlRBfFvsmQ a1Q6e5WVl1Fxo6X+wGVmOf6OgvEeM9xgRtkZJsoh/6hwn24cx+7UT6OGAioRBW3O2q6+ 49Mkog51BZ1xJrPR3UvO4GK8L75L5iwFRpfgLhtVudFtWZykBcpxYDQKE1cGZiABPiA4 aAz4v1FiXRfHwD2FEBxbIHMszkeJLWKSNYNPV9vHEFzTgRrcWb8jWEG/RI2K4bGzdObe xAqNK0AjyMXORbY0zxkmlQxiJc2MEQPqeELYrkgaI0HP5e9u09zB87XbBFmKXLEY60pK 8LiA== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:dkim-signature; bh=iqKD9byHso6OMx8L+zAYM7NHKckUL6NGilBoDBaqk1Y=; b=kfegeuSGofs84V9h871bqVty7CiXf8ooccIjiqk4C1MEmz0j3Dx2N03c6g2weCJZix W5bnFVfniF1mmz5nsv6tzYvROokpRthyz/I10s8Y/B79lbXnr0xyiaxVlQPyQgNcwhJb 17WDvmYMPJ0dK3BCm4gZNGYAfAw8EnSnCT83/9xJ/kJlWTFJBAPciCtaRUuhWyDryDyD n04IfzWj2x7VeLzrXu9mdo/JTJp+WWJLBB0xCrsjnw5oCKpsEI61GJk81IoQyFxYWVVP Pbr+lnCtwRxx655bPPbhlBhEukeF3PzAKSHJXb1hTI1NPLE8slTnIwUpXHGpHJW4K8+d kpqQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=UnHMeEeq; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id q13-v6si23310790pgq.526.2018.10.19.03.53.48; Fri, 19 Oct 2018 03:53:48 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=UnHMeEeq; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727175AbeJSS7K (ORCPT + 32 others); Fri, 19 Oct 2018 14:59:10 -0400 Received: from mail-pg1-f196.google.com ([209.85.215.196]:40731 "EHLO mail-pg1-f196.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1726647AbeJSS7J (ORCPT ); Fri, 19 Oct 2018 14:59:09 -0400 Received: by mail-pg1-f196.google.com with SMTP id n31-v6so15621956pgm.7 for ; Fri, 19 Oct 2018 03:53:37 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :in-reply-to:references; bh=iqKD9byHso6OMx8L+zAYM7NHKckUL6NGilBoDBaqk1Y=; b=UnHMeEeq5DgBn1FBAnCUVHjVAQ3cCPpbV2op4fk/HIXIw0+1RzpNUfolS7d8PK5jN5 IGH6HUMRsn34E4vn/bAfWLblkzE0bZ+9QJ4G36bIUpM6YFxNV65fAunw3AEIOCi7etb6 1PEnP3GkQTvWwkc/inwzmM2p9P3M6LRCW7DtU= 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:in-reply-to:references; bh=iqKD9byHso6OMx8L+zAYM7NHKckUL6NGilBoDBaqk1Y=; b=LHphmTcIBBlpFHhQP3/Z8oEgneZ4lpuGYpkqTxvKXizcOvTGRaZRi0mhNJNUwuCW/L MF0KA/vVRyWAhDYe3+6M52OWCz/s8ZVk65Jjo0uFxELwOjCSsA8510y2n+EkUPn+FbFu qc2wslQ6ix4JNmFxcykSduA0UWLzmZBb04pD09pa7voULn9ITCk9mG5gsblIMWOndjr4 BbJ9dNoF/P8HbSJDr4rzBqb2yTJ4z8XfM9F3ZTlzGPYwh/hB8/d/sUqWiYT2u0u97mKL 90dbaBg/ERXqUJQj1ypw2UvEDFO60SzL+F+npj2IOR89eJK7HmBZEeZCQtjMHwbzf3aO du9g== X-Gm-Message-State: ABuFfojC92Kp3Civfnx6FxmXO6lfJag5F4egYzXQBAgkLN6xPr43v62Z V6ZiYj9PccOxDfdlNAdH9iom/g== X-Received: by 2002:a63:1f05:: with SMTP id f5-v6mr1341281pgf.313.1539946416809; Fri, 19 Oct 2018 03:53:36 -0700 (PDT) Received: from baolinwangubtpc.spreadtrum.com ([117.18.48.102]) by smtp.gmail.com with ESMTPSA id m67-v6sm54918pfm.13.2018.10.19.03.53.32 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 19 Oct 2018 03:53:35 -0700 (PDT) From: Baolin Wang To: sre@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com Cc: linux-pm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, yuanjiang.yu@unisoc.com, baolin.wang@linaro.org, broonie@kernel.org, ctatlor97@gmail.com, linus.walleij@linaro.org Subject: [PATCH v5 2/6] power: supply: core: Add one field to present the battery internal resistance Date: Fri, 19 Oct 2018 18:53:11 +0800 Message-Id: X-Mailer: git-send-email 1.7.9.5 In-Reply-To: References: In-Reply-To: References: Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Add one field for 'struct power_supply_battery_info' to present the battery factory internal resistance. Signed-off-by: Baolin Wang Reviewed-by: Linus Walleij --- Changes from v4: - None. Changes from v3: - New patch in v3, which splits code into one separate patch. - Add Linusw reviewed tag. --- drivers/power/supply/power_supply_core.c | 3 +++ include/linux/power_supply.h | 1 + 2 files changed, 4 insertions(+) -- 1.7.9.5 diff --git a/drivers/power/supply/power_supply_core.c b/drivers/power/supply/power_supply_core.c index e853618..307e0995 100644 --- a/drivers/power/supply/power_supply_core.c +++ b/drivers/power/supply/power_supply_core.c @@ -579,6 +579,7 @@ int power_supply_get_battery_info(struct power_supply *psy, info->charge_term_current_ua = -EINVAL; info->constant_charge_current_max_ua = -EINVAL; info->constant_charge_voltage_max_uv = -EINVAL; + info->factory_internal_resistance_uohm = -EINVAL; if (!psy->of_node) { dev_warn(&psy->dev, "%s currently only supports devicetree\n", @@ -616,6 +617,8 @@ int power_supply_get_battery_info(struct power_supply *psy, &info->constant_charge_current_max_ua); of_property_read_u32(battery_np, "constant_charge_voltage_max_microvolt", &info->constant_charge_voltage_max_uv); + of_property_read_u32(battery_np, "factory-internal-resistance-micro-ohms", + &info->factory_internal_resistance_uohm); return 0; } diff --git a/include/linux/power_supply.h b/include/linux/power_supply.h index f807691..d089566 100644 --- a/include/linux/power_supply.h +++ b/include/linux/power_supply.h @@ -326,6 +326,7 @@ struct power_supply_battery_info { int charge_term_current_ua; /* microAmps */ int constant_charge_current_max_ua; /* microAmps */ int constant_charge_voltage_max_uv; /* microVolts */ + int factory_internal_resistance_uohm; /* microOhms */ }; extern struct atomic_notifier_head power_supply_notifier; From patchwork Fri Oct 19 10:53:12 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "\(Exiting\) Baolin Wang" X-Patchwork-Id: 149253 Delivered-To: patch@linaro.org Received: by 2002:a2e:8595:0:0:0:0:0 with SMTP id b21-v6csp3143349lji; Fri, 19 Oct 2018 03:53:49 -0700 (PDT) X-Google-Smtp-Source: ACcGV63JkImMwBhv0WCrVQnLbYeB1dcHkEE6rl8IQsGgn+47Tr8BerJlKv1ko5yMhLoBeqzdUtWw X-Received: by 2002:a17:902:9002:: with SMTP id a2-v6mr10386212plp.291.1539946429197; Fri, 19 Oct 2018 03:53:49 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1539946429; cv=none; d=google.com; s=arc-20160816; b=XrpQYYMYGcIFEpoSBXYnT8TC4BKr0XP5fsIryp5MPMn4AgTVXItBAvmFf46+5xNcu+ D+tXyyXX8JnGLlDD26hJQ//AsCLTATHL25RweCVZRzrtPOBdwDZbPIfKTffrcYu05m6s Jfkq1rLiJCbFZGtYZf5KDTaYg6f2GH09ak1Yyy0U4etFdFTEDaLdiQIgj7gGUp25NY0j upDfD2c1F1qpydFfqQ3M0n7+7zUuht13xvMuu7cwCQBBb6jBw8qDjlm+C7qU2STkL5a7 AYq0mx70NNz2e8JKwFz0h7UZt9BizwnNTCMy0mhPyuzTURXIG5vMx1ebd5KlmukhHHll 1M/w== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:dkim-signature; bh=IZj3v1SW4CS/dfK2+z6yc+Dtbx1/tbGykpj1YfOFLRk=; b=E78XIcThlLd1QVOMlf99s9QLvsu2r3rkArM8zjbzw8eEyjdRwOGr9ykH2bkjhIHfm7 b9m5aJjaMzQztfpocmIIOPl5jHEdVuW/9OlW8ikBUY51uYNcnhVaefyknwXOQz7ZEfPd fcc8QDox/NqoJnZQIk7Jl9ubbdTo90hofZ6rQFXeFLzw7vHfirCMJtOGXpW3tdXQotqB azWAX4hIIiBPk9Ok1e+MBWnaoPpMR5ArlqEWLfuj3NrjJWDQw1mFQmDcKLHu5Ff7Uk+v S+cWXbnt44/4DhFgsdUiWtsd6zM8GDJQjvUnKRNaHz3mW+vYiGnQALK8oXbgSv2sQM8v YRjA== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jCj+8VG6; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id q13-v6si23310790pgq.526.2018.10.19.03.53.48; Fri, 19 Oct 2018 03:53:49 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=jCj+8VG6; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727242AbeJSS7N (ORCPT + 32 others); Fri, 19 Oct 2018 14:59:13 -0400 Received: from mail-pf1-f195.google.com ([209.85.210.195]:42224 "EHLO mail-pf1-f195.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727178AbeJSS7N (ORCPT ); Fri, 19 Oct 2018 14:59:13 -0400 Received: by mail-pf1-f195.google.com with SMTP id f26-v6so16315716pfn.9 for ; Fri, 19 Oct 2018 03:53:41 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :in-reply-to:references; bh=IZj3v1SW4CS/dfK2+z6yc+Dtbx1/tbGykpj1YfOFLRk=; b=jCj+8VG6l9AH69XTMJY6zE7PAKm5zlf0reQKiCaZ1hl8Kp4Sl3zhyQsCny4/2NKwsF 59hmweq5vwTIziFMfW91uNvtuCab873/lRepjzYeUa/pntNEwmTl9/tikYDXei/M7t7L NFyFyVlnShPTMsEZ2j0W/ySwz+0OT558UEFrk= 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:in-reply-to:references; bh=IZj3v1SW4CS/dfK2+z6yc+Dtbx1/tbGykpj1YfOFLRk=; b=P8sfV0awqJuRhzL4O3EraZKp0vMCRnj16OTsPzEl1U7+s/bqebOpo7oEFRJV+41VBV jemmOKchVdnCyi9uXCaSxNo8ON2nCPZGqZGwoeN1bWnSOZ1gQXySg/VWRq7Iu/mQedy+ JbIVx0O7yLplEspDERSRNoqZW7As14BB5thlF2l+we7rAKCqqQbJwJFm/e0ckTRUQmTw gCFnrlOtT2qbCCzczFQpwikqkpHYzUFuy2irG0D9Cxe7ksykGSmQGt7UHud5AuRJ8XbK QjTS3FOMmG8oBukweUmNbu8YruvO07ptO/dFrkOy04YesqkLEBsAXPvC3fl2PMVR3ZS2 978w== X-Gm-Message-State: ABuFfoji1MUr7QFxqAHBgmjcd/or04Is5bTz+NOVKRXKIdzihdMxQ3oG 3z/yCepDXA8Asm1tPFgUaqt0vQ== X-Received: by 2002:a63:cc:: with SMTP id 195-v6mr31477894pga.44.1539946420740; Fri, 19 Oct 2018 03:53:40 -0700 (PDT) Received: from baolinwangubtpc.spreadtrum.com ([117.18.48.102]) by smtp.gmail.com with ESMTPSA id m67-v6sm54918pfm.13.2018.10.19.03.53.37 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 19 Oct 2018 03:53:39 -0700 (PDT) From: Baolin Wang To: sre@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com Cc: linux-pm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, yuanjiang.yu@unisoc.com, baolin.wang@linaro.org, broonie@kernel.org, ctatlor97@gmail.com, linus.walleij@linaro.org Subject: [PATCH v5 3/6] dt-bindings: power: Introduce properties to present the battery OCV capacity table Date: Fri, 19 Oct 2018 18:53:12 +0800 Message-Id: <3a0c6487c9503cf64432f630e65790cc5c3f70ab.1539915051.git.baolin.wang@linaro.org> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: References: In-Reply-To: References: Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org Some battery driver will use the open circuit voltage (OCV) value to look up the corresponding battery capacity percent in one certain degree Celsius. Thus this patch provides some battery properties to present the OCV table temperatures and OCV capacity table values. Suggested-by: Sebastian Reichel Signed-off-by: Baolin Wang Reviewed-by: Linus Walleij --- Changes from v4: - Improve the description of ocv-capacity-table-n to make the order clear. Changes from v3: - Split binding into one separate patch. - Rename ocv-capacity-table-temperatures to ocv-capacity-celsius. - Add some words to specify the OCV's unit. Changes from v2: - Use type __be32 to calculate the table length. - Update error messages. - Add some helper functions. Changes from v1: - New patch in v2. --- .../devicetree/bindings/power/supply/battery.txt | 15 +++++++++++++++ 1 file changed, 15 insertions(+) -- 1.7.9.5 diff --git a/Documentation/devicetree/bindings/power/supply/battery.txt b/Documentation/devicetree/bindings/power/supply/battery.txt index 938d027..89871ab 100644 --- a/Documentation/devicetree/bindings/power/supply/battery.txt +++ b/Documentation/devicetree/bindings/power/supply/battery.txt @@ -23,6 +23,17 @@ Optional Properties: - constant-charge-current-max-microamp: maximum constant input current - constant-charge-voltage-max-microvolt: maximum constant input voltage - factory-internal-resistance-micro-ohms: battery factory internal resistance + - ocv-capacity-table-0: An array providing the open circuit voltage (OCV) + of the battery and corresponding battery capacity percent, which is used + to look up battery capacity according to current OCV value. And the open + circuit voltage unit is microvolt. + - ocv-capacity-table-1: Same as ocv-capacity-table-0 + ...... + - ocv-capacity-table-n: Same as ocv-capacity-table-0 + - ocv-capacity-celsius: An array containing the temperature in degree Celsius, + for each of the battery capacity lookup table. The first temperature value + specifies the OCV table 0, and the second temperature value specifies the + OCV table 1, and so on. Battery properties are named, where possible, for the corresponding elements in enum power_supply_property, defined in @@ -44,6 +55,10 @@ Example: constant-charge-current-max-microamp = <900000>; constant-charge-voltage-max-microvolt = <4200000>; factory-internal-resistance-micro-ohms = <250000>; + ocv-capacity-celsius = <(-10) 0 10>; + ocv-capacity-table-0 = <4185000 100>, <4113000 95>, <4066000 90>, ...; + ocv-capacity-table-1 = <4200000 100>, <4185000 95>, <4113000 90>, ...; + ocv-capacity-table-2 = <4250000 100>, <4200000 95>, <4185000 90>, ...; }; charger: charger@11 { From patchwork Fri Oct 19 10:53:15 2018 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: "\(Exiting\) Baolin Wang" X-Patchwork-Id: 149256 Delivered-To: patch@linaro.org Received: by 2002:a2e:8595:0:0:0:0:0 with SMTP id b21-v6csp3143447lji; Fri, 19 Oct 2018 03:53:57 -0700 (PDT) X-Google-Smtp-Source: ACcGV61UxWkYUqGJaQXlila/a14iAoAuw/0FYmAVushDd39I/s9ayI5W8BpSKFJWWnUTVsL0tVYj X-Received: by 2002:a63:1520:: with SMTP id v32-v6mr32482644pgl.150.1539946437211; Fri, 19 Oct 2018 03:53:57 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1539946437; cv=none; d=google.com; s=arc-20160816; b=jw1A5rJD/PwyjecnqoUlV1ZnV0EIug0vNo5WJ/eA+ihZAxQV9Ndxrjj3cNHRI8zPTb h7VdShSyu/ksPECNKCyhL+/nxxDe0KQ9ahBgUcPYJZmOGk1P4CpcPZR2uKg0DVd+llXq ttMBqdgYaNTnvz1gjx/9/BVFiTy6/Cl7lj9cMdDzt3afswlchz+n+ZQNOX7pco4C32Nn O1TwUXY/rxv+uLvG8vTHAbXg2ONbIDS6wqYI5VQMIegFx1PuYHhhdE3KM2BrWSjN98bd 1qM32IMYUTrO28D7CTrWzk4wtEFtIJNQkJIX2PlYlg/Eetdhnriwz4Ukwrt6chwqqe3m a8yg== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:references:in-reply-to:references :in-reply-to:message-id:date:subject:cc:to:from:dkim-signature; bh=dCynuCiyPpCjkYS4g4UbL0i7EfcDUd9DXfSOlCpdkZw=; b=xkYQSpVhAbQUCGM2rSb1xV++PTaU6GALpQILHx4rqgV8JD0rUMDPPFJsuHL0DncPar ma7APKSWnzTHo3JSErTwDxZ2hlk7JIrXfOpXZtlQiapSY+aA7+XYHw3Zr1+ZhVX0QHOP 693AjkP8OjkaYVCrtTNdMvCCH+kZBdnB4J5L01mI/EyFg4Z0yJE0MT0LGF2VS/UFu7TA w7UwFR73QQY26X8n1EIq1EBT1w67iyv4N/uuXVPCZnDCVm+7T7wzpIebnlE7SjsBsxUE Wnp1zakzp0FGoEZue3LiectmNVBwM1UfeSpGLj+UrHIJO3SriYqbqCsENk/B6w9bJrpm jB8Q== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ExOASKxL; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Return-Path: Received: from vger.kernel.org (vger.kernel.org. [209.132.180.67]) by mx.google.com with ESMTP id w16-v6si24000511pll.234.2018.10.19.03.53.56; Fri, 19 Oct 2018 03:53:57 -0700 (PDT) Received-SPF: pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) client-ip=209.132.180.67; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=ExOASKxL; spf=pass (google.com: best guess record for domain of linux-kernel-owner@vger.kernel.org designates 209.132.180.67 as permitted sender) smtp.mailfrom=linux-kernel-owner@vger.kernel.org; dmarc=pass (p=NONE sp=NONE dis=NONE) header.from=linaro.org Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1727408AbeJSS71 (ORCPT + 32 others); Fri, 19 Oct 2018 14:59:27 -0400 Received: from mail-pl1-f194.google.com ([209.85.214.194]:44886 "EHLO mail-pl1-f194.google.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727365AbeJSS70 (ORCPT ); Fri, 19 Oct 2018 14:59:26 -0400 Received: by mail-pl1-f194.google.com with SMTP id d23-v6so2275087pls.11 for ; Fri, 19 Oct 2018 03:53:53 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; h=from:to:cc:subject:date:message-id:in-reply-to:references :in-reply-to:references; bh=dCynuCiyPpCjkYS4g4UbL0i7EfcDUd9DXfSOlCpdkZw=; b=ExOASKxL5+INTVcA0ByWMftRtfSWm2ALEMM8MGDSgaiho3qo4hlVQExgWO8cKASJwk GoGm/DlRLSmNfO8FUGx4vIjbFzIZacU5sbrMdpBE8ueYAjuen07yOwcf71VUY51MwlGy qvTXT13MbxNuda+dfqhFvwpxyoimLMJJdkm9E= 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:in-reply-to:references; bh=dCynuCiyPpCjkYS4g4UbL0i7EfcDUd9DXfSOlCpdkZw=; b=m7CgerTo1ierWnhr0HmE7djPds1UrBdxkJyG9QyB0WeW+ONPWUJiYbFn1LHFH6OOG7 hwWRaHCRm7w3NgP157yAvaBnT+RAL6NhNq5dBp1UgMVBVyZ6vnmqMQg8intxDPzeWTyv dmgtO2V8vMf9LAF9FGJrazh/AC1Zr54jCVEpMXwaHIRnk9VU3LDq2oeIE+EYWpDgRGw1 7tkexMlfiK2ZOES21iQM40iOQCFwSvAA9Ys1vCVsldabUkd4JwOZyRWbdjtcHy5Vbiz9 p3zmQyAPsyGQipXIJ/A67ZnENNLyUdB7Fyl++XELPVQeIYKd7pzoE5NGNOW/H00UgMiM sxqg== X-Gm-Message-State: ABuFfogbVPC5Bcjc/DkE3syAjLAJQ/WnaAguhtusB2kFVGnnXGmKsznF 3/xNYjq94bDwV3iytcwAwIoLfw== X-Received: by 2002:a17:902:2867:: with SMTP id e94-v6mr20562678plb.317.1539946432763; Fri, 19 Oct 2018 03:53:52 -0700 (PDT) Received: from baolinwangubtpc.spreadtrum.com ([117.18.48.102]) by smtp.gmail.com with ESMTPSA id m67-v6sm54918pfm.13.2018.10.19.03.53.48 (version=TLS1 cipher=ECDHE-RSA-AES128-SHA bits=128/128); Fri, 19 Oct 2018 03:53:51 -0700 (PDT) From: Baolin Wang To: sre@kernel.org, robh+dt@kernel.org, mark.rutland@arm.com Cc: linux-pm@vger.kernel.org, devicetree@vger.kernel.org, linux-kernel@vger.kernel.org, yuanjiang.yu@unisoc.com, baolin.wang@linaro.org, broonie@kernel.org, ctatlor97@gmail.com, linus.walleij@linaro.org Subject: [PATCH v5 6/6] power: supply: Add Spreadtrum SC27XX fuel gauge unit driver Date: Fri, 19 Oct 2018 18:53:15 +0800 Message-Id: <2983281f449d180d008c2f49133088a12ea4046d.1539915051.git.baolin.wang@linaro.org> X-Mailer: git-send-email 1.7.9.5 In-Reply-To: References: In-Reply-To: References: Sender: linux-kernel-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org This patch adds the Spreadtrum SC27XX serial PMICs fuel gauge support, which is used to calculate the battery capacity. Original-by: Yuanjiang Yu Signed-off-by: Baolin Wang Acked-by: Linus Walleij --- Changes from v4: - None. Changes from v3: - None. Changes from v2: - Use core helper functions to look up OCV capacity table. - Use device_property_read_u32() instead of of_property_read_u32(). - Add acked tag from Linus. Changes from v1: - Use battery standard properties to get internal resistance and ocv table. - Change devm_gpiod_get_optional() to devm_gpiod_get(). - Add power_supply_changed() when detecting battery present change. - Return micro volts for sc27xx_fgu_get_vbat_ocv(). --- drivers/power/supply/Kconfig | 7 + drivers/power/supply/Makefile | 1 + drivers/power/supply/sc27xx_fuel_gauge.c | 661 ++++++++++++++++++++++++++++++ 3 files changed, 669 insertions(+) create mode 100644 drivers/power/supply/sc27xx_fuel_gauge.c -- 1.7.9.5 diff --git a/drivers/power/supply/Kconfig b/drivers/power/supply/Kconfig index f27cf07..917f4b7 100644 --- a/drivers/power/supply/Kconfig +++ b/drivers/power/supply/Kconfig @@ -652,4 +652,11 @@ config CHARGER_SC2731 Say Y here to enable support for battery charging with SC2731 PMIC chips. +config FUEL_GAUGE_SC27XX + tristate "Spreadtrum SC27XX fuel gauge driver" + depends on MFD_SC27XX_PMIC || COMPILE_TEST + help + Say Y here to enable support for fuel gauge with SC27XX + PMIC chips. + endif # POWER_SUPPLY diff --git a/drivers/power/supply/Makefile b/drivers/power/supply/Makefile index 767105b..b731c2a 100644 --- a/drivers/power/supply/Makefile +++ b/drivers/power/supply/Makefile @@ -86,3 +86,4 @@ obj-$(CONFIG_AXP288_FUEL_GAUGE) += axp288_fuel_gauge.o obj-$(CONFIG_AXP288_CHARGER) += axp288_charger.o obj-$(CONFIG_CHARGER_CROS_USBPD) += cros_usbpd-charger.o obj-$(CONFIG_CHARGER_SC2731) += sc2731_charger.o +obj-$(CONFIG_FUEL_GAUGE_SC27XX) += sc27xx_fuel_gauge.o diff --git a/drivers/power/supply/sc27xx_fuel_gauge.c b/drivers/power/supply/sc27xx_fuel_gauge.c new file mode 100644 index 0000000..1c0b856 --- /dev/null +++ b/drivers/power/supply/sc27xx_fuel_gauge.c @@ -0,0 +1,661 @@ +// SPDX-License-Identifier: GPL-2.0 +// Copyright (C) 2018 Spreadtrum Communications Inc. + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +/* PMIC global control registers definition */ +#define SC27XX_MODULE_EN0 0xc08 +#define SC27XX_CLK_EN0 0xc18 +#define SC27XX_FGU_EN BIT(7) +#define SC27XX_FGU_RTC_EN BIT(6) + +/* FGU registers definition */ +#define SC27XX_FGU_START 0x0 +#define SC27XX_FGU_CONFIG 0x4 +#define SC27XX_FGU_ADC_CONFIG 0x8 +#define SC27XX_FGU_STATUS 0xc +#define SC27XX_FGU_INT_EN 0x10 +#define SC27XX_FGU_INT_CLR 0x14 +#define SC27XX_FGU_INT_STS 0x1c +#define SC27XX_FGU_VOLTAGE 0x20 +#define SC27XX_FGU_OCV 0x24 +#define SC27XX_FGU_POCV 0x28 +#define SC27XX_FGU_CURRENT 0x2c +#define SC27XX_FGU_CLBCNT_SETH 0x50 +#define SC27XX_FGU_CLBCNT_SETL 0x54 +#define SC27XX_FGU_CLBCNT_VALH 0x68 +#define SC27XX_FGU_CLBCNT_VALL 0x6c +#define SC27XX_FGU_CLBCNT_QMAXL 0x74 + +#define SC27XX_WRITE_SELCLB_EN BIT(0) +#define SC27XX_FGU_CLBCNT_MASK GENMASK(15, 0) +#define SC27XX_FGU_CLBCNT_SHIFT 16 + +#define SC27XX_FGU_1000MV_ADC 686 +#define SC27XX_FGU_1000MA_ADC 1372 +#define SC27XX_FGU_CUR_BASIC_ADC 8192 +#define SC27XX_FGU_SAMPLE_HZ 2 + +/* + * struct sc27xx_fgu_data: describe the FGU device + * @regmap: regmap for register access + * @dev: platform device + * @battery: battery power supply + * @base: the base offset for the controller + * @lock: protect the structure + * @gpiod: GPIO for battery detection + * @channel: IIO channel to get battery temperature + * @internal_resist: the battery internal resistance in mOhm + * @total_cap: the total capacity of the battery in mAh + * @init_cap: the initial capacity of the battery in mAh + * @init_clbcnt: the initial coulomb counter + * @max_volt: the maximum constant input voltage in millivolt + * @table_len: the capacity table length + * @cap_table: capacity table with corresponding ocv + */ +struct sc27xx_fgu_data { + struct regmap *regmap; + struct device *dev; + struct power_supply *battery; + u32 base; + struct mutex lock; + struct gpio_desc *gpiod; + struct iio_channel *channel; + bool bat_present; + int internal_resist; + int total_cap; + int init_cap; + int init_clbcnt; + int max_volt; + int table_len; + struct power_supply_battery_ocv_table *cap_table; +}; + +static const char * const sc27xx_charger_supply_name[] = { + "sc2731_charger", + "sc2720_charger", + "sc2721_charger", + "sc2723_charger", +}; + +static int sc27xx_fgu_adc_to_current(int adc) +{ + return (adc * 1000) / SC27XX_FGU_1000MA_ADC; +} + +static int sc27xx_fgu_adc_to_voltage(int adc) +{ + return (adc * 1000) / SC27XX_FGU_1000MV_ADC; +} + +/* + * When system boots on, we can not read battery capacity from coulomb + * registers, since now the coulomb registers are invalid. So we should + * calculate the battery open circuit voltage, and get current battery + * capacity according to the capacity table. + */ +static int sc27xx_fgu_get_boot_capacity(struct sc27xx_fgu_data *data, int *cap) +{ + int volt, cur, oci, ocv, ret; + + /* + * After system booting on, the SC27XX_FGU_CLBCNT_QMAXL register saved + * the first sampled open circuit current. + */ + ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_QMAXL, + &cur); + if (ret) + return ret; + + cur <<= 1; + oci = sc27xx_fgu_adc_to_current(cur - SC27XX_FGU_CUR_BASIC_ADC); + + /* + * Should get the OCV from SC27XX_FGU_POCV register at the system + * beginning. It is ADC values reading from registers which need to + * convert the corresponding voltage. + */ + ret = regmap_read(data->regmap, data->base + SC27XX_FGU_POCV, &volt); + if (ret) + return ret; + + volt = sc27xx_fgu_adc_to_voltage(volt); + ocv = volt - (oci * data->internal_resist) / 1000; + + /* + * Parse the capacity table to look up the correct capacity percent + * according to current battery's corresponding OCV values. + */ + *cap = power_supply_ocv2cap_simple(data->cap_table, data->table_len, + ocv); + + return 0; +} + +static int sc27xx_fgu_set_clbcnt(struct sc27xx_fgu_data *data, int clbcnt) +{ + int ret; + + clbcnt *= SC27XX_FGU_SAMPLE_HZ; + + ret = regmap_update_bits(data->regmap, + data->base + SC27XX_FGU_CLBCNT_SETL, + SC27XX_FGU_CLBCNT_MASK, clbcnt); + if (ret) + return ret; + + ret = regmap_update_bits(data->regmap, + data->base + SC27XX_FGU_CLBCNT_SETH, + SC27XX_FGU_CLBCNT_MASK, + clbcnt >> SC27XX_FGU_CLBCNT_SHIFT); + if (ret) + return ret; + + return regmap_update_bits(data->regmap, data->base + SC27XX_FGU_START, + SC27XX_WRITE_SELCLB_EN, + SC27XX_WRITE_SELCLB_EN); +} + +static int sc27xx_fgu_get_clbcnt(struct sc27xx_fgu_data *data, int *clb_cnt) +{ + int ccl, cch, ret; + + ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_VALL, + &ccl); + if (ret) + return ret; + + ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CLBCNT_VALH, + &cch); + if (ret) + return ret; + + *clb_cnt = ccl & SC27XX_FGU_CLBCNT_MASK; + *clb_cnt |= (cch & SC27XX_FGU_CLBCNT_MASK) << SC27XX_FGU_CLBCNT_SHIFT; + *clb_cnt /= SC27XX_FGU_SAMPLE_HZ; + + return 0; +} + +static int sc27xx_fgu_get_capacity(struct sc27xx_fgu_data *data, int *cap) +{ + int ret, cur_clbcnt, delta_clbcnt, delta_cap, temp; + + /* Get current coulomb counters firstly */ + ret = sc27xx_fgu_get_clbcnt(data, &cur_clbcnt); + if (ret) + return ret; + + delta_clbcnt = cur_clbcnt - data->init_clbcnt; + + /* + * Convert coulomb counter to delta capacity (mAh), and set multiplier + * as 100 to improve the precision. + */ + temp = DIV_ROUND_CLOSEST(delta_clbcnt, 360); + temp = sc27xx_fgu_adc_to_current(temp); + + /* + * Convert to capacity percent of the battery total capacity, + * and multiplier is 100 too. + */ + delta_cap = DIV_ROUND_CLOSEST(temp * 100, data->total_cap); + *cap = delta_cap + data->init_cap; + + return 0; +} + +static int sc27xx_fgu_get_vbat_vol(struct sc27xx_fgu_data *data, int *val) +{ + int ret, vol; + + ret = regmap_read(data->regmap, data->base + SC27XX_FGU_VOLTAGE, &vol); + if (ret) + return ret; + + /* + * It is ADC values reading from registers which need to convert to + * corresponding voltage values. + */ + *val = sc27xx_fgu_adc_to_voltage(vol); + + return 0; +} + +static int sc27xx_fgu_get_current(struct sc27xx_fgu_data *data, int *val) +{ + int ret, cur; + + ret = regmap_read(data->regmap, data->base + SC27XX_FGU_CURRENT, &cur); + if (ret) + return ret; + + /* + * It is ADC values reading from registers which need to convert to + * corresponding current values. + */ + *val = sc27xx_fgu_adc_to_current(cur - SC27XX_FGU_CUR_BASIC_ADC); + + return 0; +} + +static int sc27xx_fgu_get_vbat_ocv(struct sc27xx_fgu_data *data, int *val) +{ + int vol, cur, ret; + + ret = sc27xx_fgu_get_vbat_vol(data, &vol); + if (ret) + return ret; + + ret = sc27xx_fgu_get_current(data, &cur); + if (ret) + return ret; + + /* Return the battery OCV in micro volts. */ + *val = vol * 1000 - cur * data->internal_resist; + + return 0; +} + +static int sc27xx_fgu_get_temp(struct sc27xx_fgu_data *data, int *temp) +{ + return iio_read_channel_processed(data->channel, temp); +} + +static int sc27xx_fgu_get_health(struct sc27xx_fgu_data *data, int *health) +{ + int ret, vol; + + ret = sc27xx_fgu_get_vbat_vol(data, &vol); + if (ret) + return ret; + + if (vol > data->max_volt) + *health = POWER_SUPPLY_HEALTH_OVERVOLTAGE; + else + *health = POWER_SUPPLY_HEALTH_GOOD; + + return 0; +} + +static int sc27xx_fgu_get_status(struct sc27xx_fgu_data *data, int *status) +{ + union power_supply_propval val; + struct power_supply *psy; + int i, ret = -EINVAL; + + for (i = 0; i < ARRAY_SIZE(sc27xx_charger_supply_name); i++) { + psy = power_supply_get_by_name(sc27xx_charger_supply_name[i]); + if (!psy) + continue; + + ret = power_supply_get_property(psy, POWER_SUPPLY_PROP_STATUS, + &val); + power_supply_put(psy); + if (ret) + return ret; + + *status = val.intval; + } + + return ret; +} + +static int sc27xx_fgu_get_property(struct power_supply *psy, + enum power_supply_property psp, + union power_supply_propval *val) +{ + struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); + int ret = 0; + int value; + + mutex_lock(&data->lock); + + switch (psp) { + case POWER_SUPPLY_PROP_STATUS: + ret = sc27xx_fgu_get_status(data, &value); + if (ret) + goto error; + + val->intval = value; + break; + + case POWER_SUPPLY_PROP_HEALTH: + ret = sc27xx_fgu_get_health(data, &value); + if (ret) + goto error; + + val->intval = value; + break; + + case POWER_SUPPLY_PROP_PRESENT: + val->intval = data->bat_present; + break; + + case POWER_SUPPLY_PROP_TEMP: + ret = sc27xx_fgu_get_temp(data, &value); + if (ret) + goto error; + + val->intval = value; + break; + + case POWER_SUPPLY_PROP_TECHNOLOGY: + val->intval = POWER_SUPPLY_TECHNOLOGY_LION; + break; + + case POWER_SUPPLY_PROP_CAPACITY: + ret = sc27xx_fgu_get_capacity(data, &value); + if (ret) + goto error; + + val->intval = value; + break; + + case POWER_SUPPLY_PROP_VOLTAGE_NOW: + ret = sc27xx_fgu_get_vbat_vol(data, &value); + if (ret) + goto error; + + val->intval = value * 1000; + break; + + case POWER_SUPPLY_PROP_VOLTAGE_OCV: + ret = sc27xx_fgu_get_vbat_ocv(data, &value); + if (ret) + goto error; + + val->intval = value; + break; + + case POWER_SUPPLY_PROP_CURRENT_NOW: + case POWER_SUPPLY_PROP_CURRENT_AVG: + ret = sc27xx_fgu_get_current(data, &value); + if (ret) + goto error; + + val->intval = value * 1000; + break; + + default: + ret = -EINVAL; + break; + } + +error: + mutex_unlock(&data->lock); + return ret; +} + +static void sc27xx_fgu_external_power_changed(struct power_supply *psy) +{ + struct sc27xx_fgu_data *data = power_supply_get_drvdata(psy); + + power_supply_changed(data->battery); +} + +static enum power_supply_property sc27xx_fgu_props[] = { + POWER_SUPPLY_PROP_STATUS, + POWER_SUPPLY_PROP_HEALTH, + POWER_SUPPLY_PROP_PRESENT, + POWER_SUPPLY_PROP_TEMP, + POWER_SUPPLY_PROP_TECHNOLOGY, + POWER_SUPPLY_PROP_CAPACITY, + POWER_SUPPLY_PROP_VOLTAGE_NOW, + POWER_SUPPLY_PROP_VOLTAGE_OCV, + POWER_SUPPLY_PROP_CURRENT_NOW, + POWER_SUPPLY_PROP_CURRENT_AVG, +}; + +static const struct power_supply_desc sc27xx_fgu_desc = { + .name = "sc27xx-fgu", + .type = POWER_SUPPLY_TYPE_BATTERY, + .properties = sc27xx_fgu_props, + .num_properties = ARRAY_SIZE(sc27xx_fgu_props), + .get_property = sc27xx_fgu_get_property, + .external_power_changed = sc27xx_fgu_external_power_changed, +}; + +static irqreturn_t sc27xx_fgu_bat_detection(int irq, void *dev_id) +{ + struct sc27xx_fgu_data *data = dev_id; + int state; + + mutex_lock(&data->lock); + + state = gpiod_get_value_cansleep(data->gpiod); + if (state < 0) { + dev_err(data->dev, "failed to get gpio state\n"); + mutex_unlock(&data->lock); + return IRQ_RETVAL(state); + } + + data->bat_present = !!state; + + mutex_unlock(&data->lock); + + power_supply_changed(data->battery); + return IRQ_HANDLED; +} + +static void sc27xx_fgu_disable(void *_data) +{ + struct sc27xx_fgu_data *data = _data; + + regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0); + regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0); +} + +static int sc27xx_fgu_cap_to_clbcnt(struct sc27xx_fgu_data *data, int capacity) +{ + /* + * Get current capacity (mAh) = battery total capacity (mAh) * + * current capacity percent (capacity / 100). + */ + int cur_cap = DIV_ROUND_CLOSEST(data->total_cap * capacity, 100); + + /* + * Convert current capacity (mAh) to coulomb counter according to the + * formula: 1 mAh =3.6 coulomb. + */ + return DIV_ROUND_CLOSEST(cur_cap * 36, 10); +} + +static int sc27xx_fgu_hw_init(struct sc27xx_fgu_data *data) +{ + struct power_supply_battery_info info = { }; + struct power_supply_battery_ocv_table *table; + int ret, i; + + ret = power_supply_get_battery_info(data->battery, &info); + if (ret) { + dev_err(data->dev, "failed to get battery information\n"); + return ret; + } + + data->total_cap = info.charge_full_design_uah / 1000; + data->max_volt = info.constant_charge_voltage_max_uv / 1000; + data->internal_resist = info.factory_internal_resistance_uohm / 1000; + + /* + * For SC27XX fuel gauge device, we only use one ocv-capacity + * table in normal temperature 20 Celsius. + */ + table = power_supply_find_ocv2cap_table(&info, 20, &data->table_len); + if (!table) + return -EINVAL; + + data->cap_table = devm_kzalloc(data->dev, + data->table_len * sizeof(*table), + GFP_KERNEL); + if (!data->cap_table) { + power_supply_put_battery_info(data->battery, &info); + return -ENOMEM; + } + + for (i = 0; i < data->table_len; i++) { + data->cap_table[i].ocv = table[i].ocv / 1000; + data->cap_table[i].capacity = table[i].capacity; + } + + power_supply_put_battery_info(data->battery, &info); + + /* Enable the FGU module */ + ret = regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, + SC27XX_FGU_EN, SC27XX_FGU_EN); + if (ret) { + dev_err(data->dev, "failed to enable fgu\n"); + return ret; + } + + /* Enable the FGU RTC clock to make it work */ + ret = regmap_update_bits(data->regmap, SC27XX_CLK_EN0, + SC27XX_FGU_RTC_EN, SC27XX_FGU_RTC_EN); + if (ret) { + dev_err(data->dev, "failed to enable fgu RTC clock\n"); + goto disable_fgu; + } + + /* + * Get the boot battery capacity when system powers on, which is used to + * initialize the coulomb counter. After that, we can read the coulomb + * counter to measure the battery capacity. + */ + ret = sc27xx_fgu_get_boot_capacity(data, &data->init_cap); + if (ret) { + dev_err(data->dev, "failed to get boot capacity\n"); + goto disable_clk; + } + + /* + * Convert battery capacity to the corresponding initial coulomb counter + * and set into coulomb counter registers. + */ + data->init_clbcnt = sc27xx_fgu_cap_to_clbcnt(data, data->init_cap); + ret = sc27xx_fgu_set_clbcnt(data, data->init_clbcnt); + if (ret) { + dev_err(data->dev, "failed to initialize coulomb counter\n"); + goto disable_clk; + } + + return 0; + +disable_clk: + regmap_update_bits(data->regmap, SC27XX_CLK_EN0, SC27XX_FGU_RTC_EN, 0); +disable_fgu: + regmap_update_bits(data->regmap, SC27XX_MODULE_EN0, SC27XX_FGU_EN, 0); + + return ret; +} + +static int sc27xx_fgu_probe(struct platform_device *pdev) +{ + struct device_node *np = pdev->dev.of_node; + struct power_supply_config fgu_cfg = { }; + struct sc27xx_fgu_data *data; + int ret, irq; + + data = devm_kzalloc(&pdev->dev, sizeof(*data), GFP_KERNEL); + if (!data) + return -ENOMEM; + + data->regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!data->regmap) { + dev_err(&pdev->dev, "failed to get regmap\n"); + return -ENODEV; + } + + ret = device_property_read_u32(&pdev->dev, "reg", &data->base); + if (ret) { + dev_err(&pdev->dev, "failed to get fgu address\n"); + return ret; + } + + data->channel = devm_iio_channel_get(&pdev->dev, "bat-temp"); + if (IS_ERR(data->channel)) { + dev_err(&pdev->dev, "failed to get IIO channel\n"); + return PTR_ERR(data->channel); + } + + data->gpiod = devm_gpiod_get(&pdev->dev, "bat-detect", GPIOD_IN); + if (IS_ERR(data->gpiod)) { + dev_err(&pdev->dev, "failed to get battery detection GPIO\n"); + return PTR_ERR(data->gpiod); + } + + ret = gpiod_get_value_cansleep(data->gpiod); + if (ret < 0) { + dev_err(&pdev->dev, "failed to get gpio state\n"); + return ret; + } + + data->bat_present = !!ret; + mutex_init(&data->lock); + data->dev = &pdev->dev; + + fgu_cfg.drv_data = data; + fgu_cfg.of_node = np; + data->battery = devm_power_supply_register(&pdev->dev, &sc27xx_fgu_desc, + &fgu_cfg); + if (IS_ERR(data->battery)) { + dev_err(&pdev->dev, "failed to register power supply\n"); + return PTR_ERR(data->battery); + } + + ret = sc27xx_fgu_hw_init(data); + if (ret) { + dev_err(&pdev->dev, "failed to initialize fgu hardware\n"); + return ret; + } + + ret = devm_add_action(&pdev->dev, sc27xx_fgu_disable, data); + if (ret) { + sc27xx_fgu_disable(data); + dev_err(&pdev->dev, "failed to add fgu disable action\n"); + return ret; + } + + irq = gpiod_to_irq(data->gpiod); + if (irq < 0) { + dev_err(&pdev->dev, "failed to translate GPIO to IRQ\n"); + return irq; + } + + ret = devm_request_threaded_irq(&pdev->dev, irq, NULL, + sc27xx_fgu_bat_detection, + IRQF_ONESHOT | IRQF_TRIGGER_RISING | + IRQF_TRIGGER_FALLING, + pdev->name, data); + if (ret) { + dev_err(&pdev->dev, "failed to request IRQ\n"); + return ret; + } + + return 0; +} + +static const struct of_device_id sc27xx_fgu_of_match[] = { + { .compatible = "sprd,sc2731-fgu", }, + { } +}; + +static struct platform_driver sc27xx_fgu_driver = { + .probe = sc27xx_fgu_probe, + .driver = { + .name = "sc27xx-fgu", + .of_match_table = sc27xx_fgu_of_match, + } +}; + +module_platform_driver(sc27xx_fgu_driver); + +MODULE_DESCRIPTION("Spreadtrum SC27XX PMICs Fual Gauge Unit Driver"); +MODULE_LICENSE("GPL v2");