From patchwork Fri Jul 10 05:29:16 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sumit Semwal X-Patchwork-Id: 235203 Delivered-To: patch@linaro.org Received: by 2002:a92:d244:0:0:0:0:0 with SMTP id v4csp139757ilg; Thu, 9 Jul 2020 22:29:38 -0700 (PDT) X-Google-Smtp-Source: ABdhPJz5RFmTBPYfppEpDOSns8wTOjKGqiNBsChwdXAaRTai1vTGThBGJSdntXChdCpzIpSjFvj+ X-Received: by 2002:a50:ee8d:: with SMTP id f13mr72986353edr.302.1594358978818; Thu, 09 Jul 2020 22:29:38 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1594358978; cv=none; d=google.com; s=arc-20160816; b=fpjtnVCQlTN4HzITfwRRi+cdi937DwT5b6Uf5k7fRxVTtVsVa1Ql+i41hBW8pMiMG7 wksRRUH0QGxPfxW7jRGj43pM4RtL4NdExb40U5kS/pQLBa8IA0tf6HTx4DSEblClFqry fXG6h1W5pFk74T4iKfMTIC71E7y1+/RgoRs/QoMS1HJGQW+/hiKpu/mkTHeFyIy5i8Xd 4loRzFXkcqp+tb2sjMfBv/siFl9pPzIBN9w8G6Cn3CoLU8giMJmF79Wo0+4Zs49HhAJI xCGYvBuR/wuxpz+dOEtuQweZ+ZoeQvi9hDWWFHbbhEEdoLgFQhKC04ZOMSqn6eh1sakZ 6PZw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=MSKivOm6p95vIF+xsCRXaxJ3RfMT5lkhjSXb8u6KQ/A=; b=lCv+A4VfdobW27CaK4vHeoEc8fVpkeh746fzqbFRu6LlDk7x7PfDqNFPt5hXj8+r8F wPcjqSqNQEKdCl8B0WPzB30mWBu5iOceZ5UE2hQDEL/Ok8xbRXHe1W3dfiJAz6QO7L65 6hH4SpcaQy92dYEMtTct4t8N0hH4uyttmN48p7RTWWIotWVQaYDZKtiavQ+LzRE2GjCv pNVtNdFgHHgpHNc67RrhYIOFDCs6QuOVMO5EkfXc69/Sy7wIf6EmAWpXQSmNQjp4PF+x mXozBKhybq6Q3/utHlMPbAVn7P+JMF09/TO2/IcdIQgeKqviMWg11WNrOX8bERZbBgwz 5XkQ== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=AzRvCMOb; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-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. [23.128.96.18]) by mx.google.com with ESMTP id c25si3290501edw.141.2020.07.09.22.29.38; Thu, 09 Jul 2020 22:29:38 -0700 (PDT) Received-SPF: pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=AzRvCMOb; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-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 S1727876AbgGJF3g (ORCPT + 6 others); Fri, 10 Jul 2020 01:29:36 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45124 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727874AbgGJF3f (ORCPT ); Fri, 10 Jul 2020 01:29:35 -0400 Received: from mail-pj1-x1043.google.com (mail-pj1-x1043.google.com [IPv6:2607:f8b0:4864:20::1043]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id B4E25C08C5DC for ; Thu, 9 Jul 2020 22:29:34 -0700 (PDT) Received: by mail-pj1-x1043.google.com with SMTP id ch3so2116597pjb.5 for ; Thu, 09 Jul 2020 22:29:34 -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 :mime-version:content-transfer-encoding; bh=MSKivOm6p95vIF+xsCRXaxJ3RfMT5lkhjSXb8u6KQ/A=; b=AzRvCMObicHfAfSGOvZ/3ah30NFhC9vr98FBzkz4giER7xo0+6P8IUylJlSB5/iQOR 1VvOmSZfn07xLWzFBVbYNkXjFg5/hEO4mAIjtWCjDZKYF0WBcXc5x8h2sdfAKITqM93m LUfaYqFINu/y79ulwbcZypq3lkFVnBCWH1l8ygT14B3kZ9YGTiHyprIxFwmU0k1l+HHd 5RxkB4R1JoSG7iDSma0TeNvG6sLp9NzsoiJeSr+vlqkMS9EVRC0eRrWBRFv89p18uB+g nncHWKBmkoKK4W5ti6WZD3IBE+fVVtlKe4GcgJa2iBw6MKpBOP89QqIM4BZ/jnMg9dxq DdIg== 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=MSKivOm6p95vIF+xsCRXaxJ3RfMT5lkhjSXb8u6KQ/A=; b=TVBv67uqDjCNqTtlPdiMRHhWS9sNl5v4IjX33OK7mC7KiBtsyz5bjMVmZzWM6qI3cG juw1Xnr5B+Xt6oLAn64ypG89uDZ4uYsCaTxthOUeGaOLa4b2JgTAU8zbgP7UvtGlRpXL liL+PYxFMRv2dK3I7vuBLkma5tiR7y9pYEWsIbxEeAEykwdgQgGLkIi5twmTIvH5LHz8 bqjE5HlLQ1klSl1YDpU4ERCX8cDuUqb/uuJqHFiGehsgouDtxkQkwI5SrxnRL9kJazLq wFARATnfw7HlBFwl/ReU+7EoZIU/KjIfUefqFl/eyH/euV87qPhNWtNMikKjFVIdYq9Y uwRw== X-Gm-Message-State: AOAM531j0Z+HPX3NoB61Q+jW8CN5aAyOxgBOSORBoIBo/q5FyS9bbaiW G+2ZQW3yE0xT/mW0FhpmDMgZuoRlQ2yKPghc8cw= X-Received: by 2002:a17:902:ab94:: with SMTP id f20mr15348562plr.232.1594358973974; Thu, 09 Jul 2020 22:29:33 -0700 (PDT) Received: from nagraj.local ([49.206.21.239]) by smtp.gmail.com with ESMTPSA id j17sm4168320pgn.87.2020.07.09.22.29.30 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 09 Jul 2020 22:29:33 -0700 (PDT) From: Sumit Semwal To: agross@kernel.org, bjorn.andersson@linaro.org, lgirdwood@gmail.com, broonie@kernel.org, robh+dt@kernel.org Cc: nishakumari@codeaurora.org, linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, kgunda@codeaurora.org, rnayak@codeaurora.org, Sumit Semwal Subject: [RESEND: PATCH v5 1/4] regulator: Allow regulators to verify enabled during enable() Date: Fri, 10 Jul 2020 10:59:16 +0530 Message-Id: <20200710052919.2611-2-sumit.semwal@linaro.org> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200710052919.2611-1-sumit.semwal@linaro.org> References: <20200710052919.2611-1-sumit.semwal@linaro.org> MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org Some regulators might need to verify that they have indeed been enabled after the enable() call is made and enable_time delay has passed. This is implemented by repeatedly checking is_enabled() upto poll_enabled_time, waiting for the already calculated enable delay in each iteration. Signed-off-by: Sumit Semwal --- v3: addressed minor review comments, improved kernel doc v2: Address review comments, including swapping enable_time and poll_enabled_time. --- drivers/regulator/core.c | 63 +++++++++++++++++++++++++++++++- include/linux/regulator/driver.h | 5 +++ 2 files changed, 67 insertions(+), 1 deletion(-) -- 2.27.0 diff --git a/drivers/regulator/core.c b/drivers/regulator/core.c index 03154f5b939f..538a2779986a 100644 --- a/drivers/regulator/core.c +++ b/drivers/regulator/core.c @@ -2347,6 +2347,37 @@ static void _regulator_enable_delay(unsigned int delay) udelay(us); } +/** + * _regulator_check_status_enabled + * + * A helper function to check if the regulator status can be interpreted + * as 'regulator is enabled'. + * @rdev: the regulator device to check + * + * Return: + * * 1 - if status shows regulator is in enabled state + * * 0 - if not enabled state + * * Error Value - as received from ops->get_status() + */ +static inline int _regulator_check_status_enabled(struct regulator_dev *rdev) +{ + int ret = rdev->desc->ops->get_status(rdev); + + if (ret < 0) { + rdev_info(rdev, "get_status returned error: %d\n", ret); + return ret; + } + + switch (ret) { + case REGULATOR_STATUS_OFF: + case REGULATOR_STATUS_ERROR: + case REGULATOR_STATUS_UNDEFINED: + return 0; + default: + return 1; + } +} + static int _regulator_do_enable(struct regulator_dev *rdev) { int ret, delay; @@ -2407,7 +2438,37 @@ static int _regulator_do_enable(struct regulator_dev *rdev) * together. */ trace_regulator_enable_delay(rdev_get_name(rdev)); - _regulator_enable_delay(delay); + /* If poll_enabled_time is set, poll upto the delay calculated + * above, delaying poll_enabled_time uS to check if the regulator + * actually got enabled. + * If the regulator isn't enabled after enable_delay has + * expired, return -ETIMEDOUT. + */ + if (rdev->desc->poll_enabled_time) { + unsigned int time_remaining = delay; + + while (time_remaining > 0) { + _regulator_enable_delay(rdev->desc->poll_enabled_time); + + if (rdev->desc->ops->get_status) { + ret = _regulator_check_status_enabled(rdev); + if (ret < 0) + return ret; + else if (ret) + break; + } else if (rdev->desc->ops->is_enabled(rdev)) + break; + + time_remaining -= rdev->desc->poll_enabled_time; + } + + if (time_remaining <= 0) { + rdev_err(rdev, "Enabled check timed out\n"); + return -ETIMEDOUT; + } + } else { + _regulator_enable_delay(delay); + } trace_regulator_enable_complete(rdev_get_name(rdev)); diff --git a/include/linux/regulator/driver.h b/include/linux/regulator/driver.h index 7eb9fea8e482..436df3ba0b2a 100644 --- a/include/linux/regulator/driver.h +++ b/include/linux/regulator/driver.h @@ -305,6 +305,9 @@ enum regulator_type { * @enable_time: Time taken for initial enable of regulator (in uS). * @off_on_delay: guard time (in uS), before re-enabling a regulator * + * @poll_enabled_time: The polling interval (in uS) to use while checking that + * the regulator was actually enabled. Max upto enable_time. + * * @of_map_mode: Maps a hardware mode defined in a DeviceTree to a standard mode */ struct regulator_desc { @@ -372,6 +375,8 @@ struct regulator_desc { unsigned int off_on_delay; + unsigned int poll_enabled_time; + unsigned int (*of_map_mode)(unsigned int mode); }; From patchwork Fri Jul 10 05:29:19 2020 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Sumit Semwal X-Patchwork-Id: 235206 Delivered-To: patch@linaro.org Received: by 2002:a92:d244:0:0:0:0:0 with SMTP id v4csp139929ilg; Thu, 9 Jul 2020 22:29:59 -0700 (PDT) X-Google-Smtp-Source: ABdhPJx87V3Vt8mAb0IEVoXU8ylleMtVUwDWq8BXRbUByUtwrNJWPdrR7go8vLvbh6zmtXFZuri5 X-Received: by 2002:aa7:db53:: with SMTP id n19mr46588419edt.338.1594358998907; Thu, 09 Jul 2020 22:29:58 -0700 (PDT) ARC-Seal: i=1; a=rsa-sha256; t=1594358998; cv=none; d=google.com; s=arc-20160816; b=ukg8lm8vzaAZn0tJTWG3LezCb00lFTsCC9/CLqy5SVVfCQTueSUFj88Re6Nc7Tyl4Z 8vkhLwznks7zFLHfMC8FXzVpPMOLyPmWrLODikvdrh4vJh1b42cVFmhVkzTxrISgXGVo N8JvBKWGFDvxUXUyTQ4ysEVehAvMzd6ILXzC0NolV9eqWjNfhPBynQ3BYqg7X76BQ/gO T73ZINfRYbIw02OdWdMvj5Wje9auybP17+ywuln2wioC4bySArrRR7zW+scafUypCYEJ uK/fywwmc/Z+P2D8/7flT6okv4YqEbf96U6lr4fsRy8R8U0Xm0qmnBDGklzy9ZSVoM2p nhuw== ARC-Message-Signature: i=1; a=rsa-sha256; c=relaxed/relaxed; d=google.com; s=arc-20160816; h=list-id:precedence:sender:content-transfer-encoding:mime-version :references:in-reply-to:message-id:date:subject:cc:to:from :dkim-signature; bh=doG+Qibpx9UFueyy0W0CrVNyS15JzsuLsQupBt9QvgE=; b=cZz642O7uRDQhd8ywGhzG/XFz50SE4HSKXkrYzuc/2VGDmgzftn1LwkJvN2ZbX1XnK jBzVSYj2SJM8hjkRcF0rGkqrgMzqC6a1/qHmCGootOYJHcsUNSmNpAaqC2hZBQ5ubroj nPT9Qx31EnbPve1xf4QL5sEf9zwbYtUuTvDmzp3Yn0ea6r9USpt2lRUShsBDqmFhvklO 9g0FFxIFxBAuqpdrE5TJ8voedZ14e8VtP5tBoJVzc7gsZjR+NfjpmIXAZ/59qi2H4bsb ZrvFzIKqCxwAxU+ekHnM+/FGt2lVVPksOScEIOi9QTmRWVDg/iDdlzDqzRmVOpmUWwOl Ia5g== ARC-Authentication-Results: i=1; mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=uUgADqnE; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-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. [23.128.96.18]) by mx.google.com with ESMTP id l27si3193900ejg.613.2020.07.09.22.29.58; Thu, 09 Jul 2020 22:29:58 -0700 (PDT) Received-SPF: pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) client-ip=23.128.96.18; Authentication-Results: mx.google.com; dkim=pass header.i=@linaro.org header.s=google header.b=uUgADqnE; spf=pass (google.com: domain of devicetree-owner@vger.kernel.org designates 23.128.96.18 as permitted sender) smtp.mailfrom=devicetree-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 S1727939AbgGJF3s (ORCPT + 6 others); Fri, 10 Jul 2020 01:29:48 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:45174 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1727930AbgGJF3q (ORCPT ); Fri, 10 Jul 2020 01:29:46 -0400 Received: from mail-pg1-x541.google.com (mail-pg1-x541.google.com [IPv6:2607:f8b0:4864:20::541]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id 78C72C08C5DD for ; Thu, 9 Jul 2020 22:29:46 -0700 (PDT) Received: by mail-pg1-x541.google.com with SMTP id d4so2018410pgk.4 for ; Thu, 09 Jul 2020 22:29:46 -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 :mime-version:content-transfer-encoding; bh=doG+Qibpx9UFueyy0W0CrVNyS15JzsuLsQupBt9QvgE=; b=uUgADqnEcSThMAdW+hepQhnpUMquwdcTcQ3f5JzBGsoE4J0Hymi0cWovhmG27sDlu8 EeiMm5AhusAdsWgt+PMrkbhITH2foBHXISLlkrMkKz3TR9XZZRLiApPDs5ih/2UI/6k6 soAUKvzD0OFWVWykCH57O2sEAZxvAy28rZPaxl76YEXozJlSKwCeIC/iT2e7YdHY06pO Sx5S7ZVVwSDw0yPhfXEOCo6DML9DwTsPLjWwOmgK/qCXaM5Fzq66dUn2jlpxf05P9NQl iEmuRPXBvS00r6FgLWOB3UD7cB+OyeHx3p2TrLAL2tnKrAESTeBC6w0mhW+sd45sVxPl 6YiA== 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=doG+Qibpx9UFueyy0W0CrVNyS15JzsuLsQupBt9QvgE=; b=AQymmAeDvSZHTBvmvXN5zanLp4f154IqI0ZGvpOphcvPFyCzSXT4JZzbswaFbvip6D V8OdxwMWYDKagroYseOxKLZxnhqUzNNtYMqscyYNaAVbsA/FGD9JrAmCf4m+LMjHjIjA EZmktaolIUaDokkG43JxajZeIDSf+G8jV7VY6NUCzkrDeSxYK/DDQ0/C8gqIyVnjRzVK tyRAze2BNLi4w713SSIOmn4VLWj1et1ri74zO2+TxSJSuPAUiJnbdTcoCagUzc16bfs1 zPkJo7JjWxx18v1u4UzJ+w23oo6G3C4ENL2h5cE7is3gbzFwoxZbjJGZUVdAKTlMo8GT tgVA== X-Gm-Message-State: AOAM533auZtSTNIVk9+DyqlWozeIVzCZEtcpkdX8lpQoZX6Is+HqHEqO ZT3mA3B6SuhuTH1j4tFB5rwrkA== X-Received: by 2002:a62:7ccd:: with SMTP id x196mr58691244pfc.23.1594358985905; Thu, 09 Jul 2020 22:29:45 -0700 (PDT) Received: from nagraj.local ([49.206.21.239]) by smtp.gmail.com with ESMTPSA id j17sm4168320pgn.87.2020.07.09.22.29.42 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Thu, 09 Jul 2020 22:29:45 -0700 (PDT) From: Sumit Semwal To: agross@kernel.org, bjorn.andersson@linaro.org, lgirdwood@gmail.com, broonie@kernel.org, robh+dt@kernel.org Cc: nishakumari@codeaurora.org, linux-arm-msm@vger.kernel.org, linux-kernel@vger.kernel.org, devicetree@vger.kernel.org, kgunda@codeaurora.org, rnayak@codeaurora.org, Sumit Semwal Subject: [RESEND PATCH v5 4/4] regulator: qcom: Add labibb driver Date: Fri, 10 Jul 2020 10:59:19 +0530 Message-Id: <20200710052919.2611-5-sumit.semwal@linaro.org> X-Mailer: git-send-email 2.27.0 In-Reply-To: <20200710052919.2611-1-sumit.semwal@linaro.org> References: <20200710052919.2611-1-sumit.semwal@linaro.org> MIME-Version: 1.0 Sender: devicetree-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: devicetree@vger.kernel.org From: Nisha Kumari Qualcomm platforms have LAB(LCD AMOLED Boost)/IBB(Inverting Buck Boost) regulators, labibb for short, which are used as power supply for LCD Mode displays. This patch adds labibb regulator driver for pmi8998 PMIC, found on SDM845 platforms. Signed-off-by: Nisha Kumari [sumits: reworked the driver design as per upstream review] Signed-off-by: Sumit Semwal --- v5: sumits: review comments addressed - removed dev_info about registering - removed of_get_child_by_name() - changed from using STATUS1 register to using ENABLE_CTL; this allows us to use the regulator_*_regmap helpers and makes this code cleaner. (In limited testing, STATUS1 seemed to report the change faster than ENABLE_CTL, but in absence of mechanism to validate if the regulator has indeed fully ramped when STATUS1 starts flagging, broonie suggested to use the slower ENABLE_CTL path for safety). v4: sumits: address review comments from v3, including cleaning up register_labibb_regulator(), and adapted to updated meaning of poll_enabled_time. v3: sumits: addressed review comments from v2; moved to use core regulator features like enable_time, off_on_delay, and the newly added poll_enabled_time. Moved the check_enabled functionality to core framework via poll_enabled_time. v2: sumits: reworked the driver for more common code, and addressed review comments from v1 --- drivers/regulator/Kconfig | 10 ++ drivers/regulator/Makefile | 1 + drivers/regulator/qcom-labibb-regulator.c | 175 ++++++++++++++++++++++ 3 files changed, 186 insertions(+) create mode 100644 drivers/regulator/qcom-labibb-regulator.c -- 2.27.0 diff --git a/drivers/regulator/Kconfig b/drivers/regulator/Kconfig index 8f677f5d79b4..c6377df023bc 100644 --- a/drivers/regulator/Kconfig +++ b/drivers/regulator/Kconfig @@ -1178,5 +1178,15 @@ config REGULATOR_WM8994 This driver provides support for the voltage regulators on the WM8994 CODEC. +config REGULATOR_QCOM_LABIBB + tristate "QCOM LAB/IBB regulator support" + depends on SPMI || COMPILE_TEST + help + This driver supports Qualcomm's LAB/IBB regulators present on the + Qualcomm's PMIC chip pmi8998. QCOM LAB and IBB are SPMI + based PMIC implementations. LAB can be used as positive + boost regulator and IBB can be used as a negative boost regulator + for LCD display panel. + endif diff --git a/drivers/regulator/Makefile b/drivers/regulator/Makefile index e8f163371071..2c2b0861df76 100644 --- a/drivers/regulator/Makefile +++ b/drivers/regulator/Makefile @@ -88,6 +88,7 @@ obj-$(CONFIG_REGULATOR_MT6323) += mt6323-regulator.o obj-$(CONFIG_REGULATOR_MT6358) += mt6358-regulator.o obj-$(CONFIG_REGULATOR_MT6380) += mt6380-regulator.o obj-$(CONFIG_REGULATOR_MT6397) += mt6397-regulator.o +obj-$(CONFIG_REGULATOR_QCOM_LABIBB) += qcom-labibb-regulator.o obj-$(CONFIG_REGULATOR_QCOM_RPM) += qcom_rpm-regulator.o obj-$(CONFIG_REGULATOR_QCOM_RPMH) += qcom-rpmh-regulator.o obj-$(CONFIG_REGULATOR_QCOM_SMD_RPM) += qcom_smd-regulator.o diff --git a/drivers/regulator/qcom-labibb-regulator.c b/drivers/regulator/qcom-labibb-regulator.c new file mode 100644 index 000000000000..8c7dd1928380 --- /dev/null +++ b/drivers/regulator/qcom-labibb-regulator.c @@ -0,0 +1,175 @@ +// SPDX-License-Identifier: GPL-2.0-only +// Copyright (c) 2020, The Linux Foundation. All rights reserved. + +#include +#include +#include +#include +#include +#include +#include +#include + +#define REG_PERPH_TYPE 0x04 + +#define QCOM_LAB_TYPE 0x24 +#define QCOM_IBB_TYPE 0x20 + +#define PMI8998_LAB_REG_BASE 0xde00 +#define PMI8998_IBB_REG_BASE 0xdc00 + +#define REG_LABIBB_STATUS1 0x08 +#define REG_LABIBB_ENABLE_CTL 0x46 +#define LABIBB_STATUS1_VREG_OK_BIT BIT(7) +#define LABIBB_CONTROL_ENABLE BIT(7) + +#define LAB_ENABLE_CTL_MASK BIT(7) +#define IBB_ENABLE_CTL_MASK (BIT(7) | BIT(6)) + +#define LABIBB_OFF_ON_DELAY 1000 +#define LAB_ENABLE_TIME (LABIBB_OFF_ON_DELAY * 2) +#define IBB_ENABLE_TIME (LABIBB_OFF_ON_DELAY * 10) +#define LABIBB_POLL_ENABLED_TIME 1000 + +struct labibb_regulator { + struct regulator_desc desc; + struct device *dev; + struct regmap *regmap; + struct regulator_dev *rdev; + u16 base; + u8 type; +}; + +struct labibb_regulator_data { + const char *name; + u8 type; + u16 base; + struct regulator_desc *desc; +}; + +static struct regulator_ops qcom_labibb_ops = { + .enable = regulator_enable_regmap, + .disable = regulator_disable_regmap, + .is_enabled = regulator_is_enabled_regmap, +}; + +static struct regulator_desc pmi8998_lab_desc = { + .enable_mask = LAB_ENABLE_CTL_MASK, + .enable_reg = (PMI8998_LAB_REG_BASE + REG_LABIBB_ENABLE_CTL), + .enable_val = LABIBB_CONTROL_ENABLE, + .enable_time = LAB_ENABLE_TIME, + .poll_enabled_time = LABIBB_POLL_ENABLED_TIME, + .off_on_delay = LABIBB_OFF_ON_DELAY, + .owner = THIS_MODULE, + .type = REGULATOR_VOLTAGE, + .ops = &qcom_labibb_ops, +}; + +static struct regulator_desc pmi8998_ibb_desc = { + .enable_mask = IBB_ENABLE_CTL_MASK, + .enable_reg = (PMI8998_IBB_REG_BASE + REG_LABIBB_ENABLE_CTL), + .enable_val = LABIBB_CONTROL_ENABLE, + .enable_time = IBB_ENABLE_TIME, + .poll_enabled_time = LABIBB_POLL_ENABLED_TIME, + .off_on_delay = LABIBB_OFF_ON_DELAY, + .owner = THIS_MODULE, + .type = REGULATOR_VOLTAGE, + .ops = &qcom_labibb_ops, +}; + +static const struct labibb_regulator_data pmi8998_labibb_data[] = { + {"lab", QCOM_LAB_TYPE, PMI8998_LAB_REG_BASE, &pmi8998_lab_desc}, + {"ibb", QCOM_IBB_TYPE, PMI8998_IBB_REG_BASE, &pmi8998_ibb_desc}, + { }, +}; + +static const struct of_device_id qcom_labibb_match[] = { + { .compatible = "qcom,pmi8998-lab-ibb", .data = &pmi8998_labibb_data}, + { }, +}; +MODULE_DEVICE_TABLE(of, qcom_labibb_match); + +static int qcom_labibb_regulator_probe(struct platform_device *pdev) +{ + struct labibb_regulator *vreg; + struct device *dev = &pdev->dev; + struct regulator_config cfg = {}; + + const struct of_device_id *match; + const struct labibb_regulator_data *reg_data; + struct regmap *reg_regmap; + unsigned int type; + int ret; + + reg_regmap = dev_get_regmap(pdev->dev.parent, NULL); + if (!reg_regmap) { + dev_err(&pdev->dev, "Couldn't get parent's regmap\n"); + return -ENODEV; + } + + match = of_match_device(qcom_labibb_match, &pdev->dev); + if (!match) + return -ENODEV; + + for (reg_data = match->data; reg_data->name; reg_data++) { + + /* Validate if the type of regulator is indeed + * what's mentioned in DT. + */ + ret = regmap_read(reg_regmap, reg_data->base + REG_PERPH_TYPE, + &type); + if (ret < 0) { + dev_err(dev, + "Peripheral type read failed ret=%d\n", + ret); + return -EINVAL; + } + + if (WARN_ON((type != QCOM_LAB_TYPE) && (type != QCOM_IBB_TYPE)) || + WARN_ON(type != reg_data->type)) + return -EINVAL; + + vreg = devm_kzalloc(&pdev->dev, sizeof(*vreg), + GFP_KERNEL); + if (!vreg) + return -ENOMEM; + + vreg->regmap = reg_regmap; + vreg->dev = dev; + vreg->base = reg_data->base; + vreg->type = reg_data->type; + + memcpy(&vreg->desc, reg_data->desc, sizeof(vreg->desc)); + vreg->desc.of_match = reg_data->name; + vreg->desc.name = reg_data->name; + + cfg.dev = vreg->dev; + cfg.driver_data = vreg; + cfg.regmap = vreg->regmap; + + vreg->rdev = devm_regulator_register(vreg->dev, &vreg->desc, + &cfg); + + if (IS_ERR(vreg->rdev)) { + dev_err(dev, "qcom_labibb: error registering %s : %d\n", + reg_data->name, ret); + return PTR_ERR(vreg->rdev); + } + } + + return 0; +} + +static struct platform_driver qcom_labibb_regulator_driver = { + .driver = { + .name = "qcom-lab-ibb-regulator", + .of_match_table = qcom_labibb_match, + }, + .probe = qcom_labibb_regulator_probe, +}; +module_platform_driver(qcom_labibb_regulator_driver); + +MODULE_DESCRIPTION("Qualcomm labibb driver"); +MODULE_AUTHOR("Nisha Kumari "); +MODULE_AUTHOR("Sumit Semwal "); +MODULE_LICENSE("GPL v2");