From nobody Thu Sep 11 12:57:03 2025 Return-Path: X-Spam-Checker-Version: SpamAssassin 3.4.0 (2014-02-07) on aws-us-west-2-korg-lkml-1.web.codeaurora.org Received: from vger.kernel.org (vger.kernel.org [23.128.96.18]) by smtp.lore.kernel.org (Postfix) with ESMTP id E41BBC04FE2 for ; Wed, 2 Aug 2023 12:38:46 +0000 (UTC) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S234544AbjHBMip (ORCPT ); Wed, 2 Aug 2023 08:38:45 -0400 Received: from lindbergh.monkeyblade.net ([23.128.96.19]:58636 "EHLO lindbergh.monkeyblade.net" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S234550AbjHBMic (ORCPT ); Wed, 2 Aug 2023 08:38:32 -0400 Received: from mail-lj1-x22e.google.com (mail-lj1-x22e.google.com [IPv6:2a00:1450:4864:20::22e]) by lindbergh.monkeyblade.net (Postfix) with ESMTPS id C9D942D4B for ; Wed, 2 Aug 2023 05:38:26 -0700 (PDT) Received: by mail-lj1-x22e.google.com with SMTP id 38308e7fff4ca-2b9d3dacb33so78556571fa.1 for ; Wed, 02 Aug 2023 05:38:26 -0700 (PDT) DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=linaro.org; s=google; t=1690979905; x=1691584705; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:from:to:cc:subject:date:message-id :reply-to; bh=iJaVfEevrIDPUXekp6Yb+UKvDKMRxHJjbqeCwp55ZcE=; b=qBK+Tal65SmDq4G8Iyif3lJ4KA9KoSFR7eqPC1L9DakULXreZ6MWKNvh7b+XCA+cFG 700/OZzirGVfqOvilUonR/yuUhKf9WIsU6lgQQslmrjcCdAbBxamHdzsyS0PInmfBpUW mklgDwV9KANlyhEeRFnupxVsYZhnqub/hODH6p3rMhUxxYJnZmrQa2ENiTfCb2dBHj4m 51JTFB2pzuoNTTYl8eAptWvKm+TPs+v+Z7VeaGHR8iYMRUU9sV9AeHS1sFO7OnddIPcn 4cImRkAistH13tHsbjIvdqwYbLWDm1uSA8P6XKb3U1eWK0rocKbPTxRNNjykR1Ask2gy HVzQ== X-Google-DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=1e100.net; s=20221208; t=1690979905; x=1691584705; h=cc:to:in-reply-to:references:message-id:content-transfer-encoding :mime-version:subject:date:from:x-gm-message-state:from:to:cc :subject:date:message-id:reply-to; bh=iJaVfEevrIDPUXekp6Yb+UKvDKMRxHJjbqeCwp55ZcE=; b=bfJSCUWsz6BnSh1q0usV2KiX2ysZbNEZlyz6ld5/y9tTXOMgfzaulpaIHJfeQbR1JL E26uZbsZa9ANzqUy4RNUuTwuq6t5OVn5Obg2/BOYS2G4P5TwH3NvRaFBIQMqyyYRx+/L h0C/qSE/N4ifQNjVtGdhrYlr5tQvNpiRyu6xu3eDIIvY2YLeIApDJjd1PFCSYjM+VEBu UuatL3pZiWD4ylO6ArVuqxPdmRsdwLYqxMJEQ5ijfG9IVBnXgflUodxV3YfIMuPTMHQC VUPy3JVaRQATEGFfkKN5tXU5H74+3bSFA76zzQaAM0lQ9Uba1qReJfHkHKl6zYYXiueb ycRQ== X-Gm-Message-State: ABy/qLYQTbnixpWrALXYI7zJkLrls56NBFQcll1rpnjAHC4Et3PR0ytV tptid62RYkFflSQDbuZG51hxDQ== X-Google-Smtp-Source: APBJJlEzKOcVEd3iItXizwUBQ7t/L7EOQxaMFx9Yhe6L5pN1vBtlbWk3ZgqpPsBP70WLLn4dEraXLQ== X-Received: by 2002:a2e:87cb:0:b0:2b1:ed29:7c47 with SMTP id v11-20020a2e87cb000000b002b1ed297c47mr4373125ljj.8.1690979904887; Wed, 02 Aug 2023 05:38:24 -0700 (PDT) Received: from [192.168.1.101] (abyk53.neoplus.adsl.tpnet.pl. [83.9.30.53]) by smtp.gmail.com with ESMTPSA id h8-20020a2e9ec8000000b002b9e5fe86dasm1897050ljk.81.2023.08.02.05.38.22 (version=TLS1_3 cipher=TLS_AES_256_GCM_SHA384 bits=256/256); Wed, 02 Aug 2023 05:38:24 -0700 (PDT) From: Konrad Dybcio Date: Wed, 02 Aug 2023 14:37:45 +0200 Subject: [PATCH v13 05/10] soc: qcom: cpr: Move common functions to new file MIME-Version: 1.0 Content-Type: text/plain; charset="utf-8" Content-Transfer-Encoding: quoted-printable Message-Id: <20230217-topic-cpr3h-v13-5-d01cff1c54cf@linaro.org> References: <20230217-topic-cpr3h-v13-0-d01cff1c54cf@linaro.org> In-Reply-To: <20230217-topic-cpr3h-v13-0-d01cff1c54cf@linaro.org> To: AngeloGioacchino Del Regno , Andy Gross , Bjorn Andersson , Rob Herring , Krzysztof Kozlowski , Viresh Kumar , Nishanth Menon , Stephen Boyd , Niklas Cassel , Liam Girdwood , Mark Brown , Conor Dooley , "Rafael J. Wysocki" , Viresh Kumar , Ulf Hansson Cc: Robert Marko , linux-kernel@vger.kernel.org, linux-arm-msm@vger.kernel.org, devicetree@vger.kernel.org, linux-pm@vger.kernel.org, Jeffrey Hugo , Marijn Suijten , Konrad Dybcio , AngeloGioacchino Del Regno X-Mailer: b4 0.12.2 X-Developer-Signature: v=1; a=ed25519-sha256; t=1690979891; l=27724; i=konrad.dybcio@linaro.org; s=20230215; h=from:subject:message-id; bh=2m1s6Aa0Vs0vvMZMKz2Y/KPCw/GBJCGnVw+RBYU9dUs=; b=0b9Fm56VxRvOxGPb+HircgnqIXd0HPkkloWgPdxf4wVsYJ2rAA8MrU4Gl/wa9qKgjgxpdfr4a NIMHeM+bh3FCu4BsHf2+oyKFUZ2ePFSGfXIV0/VS8qUdXZhhiGfunED X-Developer-Key: i=konrad.dybcio@linaro.org; a=ed25519; pk=iclgkYvtl2w05SSXO5EjjSYlhFKsJ+5OSZBjOkQuEms= Precedence: bulk List-ID: X-Mailing-List: linux-kernel@vger.kernel.org From: AngeloGioacchino Del Regno In preparation for implementing a new driver that will be handling CPRv3, CPRv4 and CPR-Hardened, format out common functions to a new file. Update cpr_get_fuses in preparation for CPR3 implementation, change parameters where necessary to not take cpr.c private data structures. Signed-off-by: AngeloGioacchino Del Regno [Konrad: rebase, apply review comments, improve msg, split] Tested-by: Jeffrey Hugo Signed-off-by: Konrad Dybcio --- drivers/genpd/qcom/Makefile | 2 +- drivers/genpd/qcom/cpr-common.c | 350 ++++++++++++++++++++++++++++++++++++ drivers/genpd/qcom/cpr-common.h | 103 +++++++++++ drivers/genpd/qcom/cpr.c | 384 +++---------------------------------= ---- 4 files changed, 475 insertions(+), 364 deletions(-) diff --git a/drivers/genpd/qcom/Makefile b/drivers/genpd/qcom/Makefile index 403dfc5af095..b28c8d9128c4 100644 --- a/drivers/genpd/qcom/Makefile +++ b/drivers/genpd/qcom/Makefile @@ -1,4 +1,4 @@ # SPDX-License-Identifier: GPL-2.0 -obj-$(CONFIG_QCOM_CPR) +=3D cpr.o +obj-$(CONFIG_QCOM_CPR) +=3D cpr-common.o cpr.o obj-$(CONFIG_QCOM_RPMPD) +=3D rpmpd.o obj-$(CONFIG_QCOM_RPMHPD) +=3D rpmhpd.o diff --git a/drivers/genpd/qcom/cpr-common.c b/drivers/genpd/qcom/cpr-commo= n.c new file mode 100644 index 000000000000..ea85f6b4bef8 --- /dev/null +++ b/drivers/genpd/qcom/cpr-common.c @@ -0,0 +1,350 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2013-2015, The Linux Foundation. All rights reserved. + * Copyright (c) 2019, Linaro Limited + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "cpr-common.h" + +int cpr_populate_ring_osc_idx(struct device *dev, + struct fuse_corner *fuse_corner, + const struct cpr_fuse *cpr_fuse, + int num_fuse_corners) +{ + struct fuse_corner *end =3D fuse_corner + num_fuse_corners; + u32 data; + int ret; + + for (; fuse_corner < end; fuse_corner++, cpr_fuse++) { + ret =3D nvmem_cell_read_variable_le_u32(dev, cpr_fuse->ring_osc, &data); + if (ret) + return ret; + fuse_corner->ring_osc_idx =3D data; + } + + return 0; +} +EXPORT_SYMBOL_GPL(cpr_populate_ring_osc_idx); + +static int cpr_read_fuse_uV(int init_v_width, int step_size_uV, int ref_uV, + int step_volt, const char *init_v_efuse, + struct device *dev) +{ + int steps, uV; + u32 bits =3D 0; + int ret; + + ret =3D nvmem_cell_read_variable_le_u32(dev, init_v_efuse, &bits); + if (ret) + return ret; + + steps =3D bits & ~BIT(init_v_width - 1); + /* Not two's complement.. instead highest bit is sign bit */ + if (bits & BIT(init_v_width - 1)) + steps =3D -steps; + + uV =3D ref_uV + steps * step_size_uV; + + return DIV_ROUND_UP(uV, step_volt) * step_volt; +} + +const struct cpr_fuse *cpr_get_fuses(struct device *dev, + unsigned int num_fuse_corners) +{ + struct cpr_fuse *fuses; + int i; + + fuses =3D devm_kcalloc(dev, num_fuse_corners, sizeof(*fuses), GFP_KERNEL); + if (!fuses) + return ERR_PTR(-ENOMEM); + + for (i =3D 0; i < num_fuse_corners; i++) { + char tbuf[32]; + + snprintf(tbuf, 32, "cpr_ring_osc%d", i + 1); + fuses[i].ring_osc =3D devm_kstrdup(dev, tbuf, GFP_KERNEL); + if (!fuses[i].ring_osc) + return ERR_PTR(-ENOMEM); + + snprintf(tbuf, 32, "cpr_init_voltage%d", i + 1); + fuses[i].init_voltage =3D devm_kstrdup(dev, tbuf, GFP_KERNEL); + if (!fuses[i].init_voltage) + return ERR_PTR(-ENOMEM); + + snprintf(tbuf, 32, "cpr_quotient%d", i + 1); + fuses[i].quotient =3D devm_kstrdup(dev, tbuf, GFP_KERNEL); + if (!fuses[i].quotient) + return ERR_PTR(-ENOMEM); + + snprintf(tbuf, 32, "cpr_quotient_offset%d", i + 1); + fuses[i].quotient_offset =3D devm_kstrdup(dev, tbuf, GFP_KERNEL); + if (!fuses[i].quotient_offset) + return ERR_PTR(-ENOMEM); + } + + return fuses; +} +EXPORT_SYMBOL_GPL(cpr_get_fuses); + +int cpr_populate_fuse_common(struct device *dev, + struct fuse_corner_data *fdata, + const struct cpr_fuse *cpr_fuse, + struct fuse_corner *fuse_corner, + int step_volt, int init_v_width, + int init_v_step) +{ + int uV, ret; + + /* Populate uV */ + uV =3D cpr_read_fuse_uV(init_v_width, init_v_step, + fdata->ref_uV, step_volt, + cpr_fuse->init_voltage, dev); + if (uV < 0) + return uV; + + /* + * Update SoC voltages: platforms might choose a different + * regulators than the one used to characterize the algorithms + * (ie, init_voltage_step). + */ + fdata->min_uV =3D roundup(fdata->min_uV, step_volt); + fdata->max_uV =3D roundup(fdata->max_uV, step_volt); + + fuse_corner->min_uV =3D fdata->min_uV; + fuse_corner->max_uV =3D fdata->max_uV; + fuse_corner->uV =3D clamp(uV, fuse_corner->min_uV, fuse_corner->max_uV); + + /* Populate target quotient by scaling */ + ret =3D nvmem_cell_read_variable_le_u32(dev, cpr_fuse->quotient, &fuse_co= rner->quot); + if (ret) + return ret; + + fuse_corner->quot *=3D fdata->quot_scale; + fuse_corner->quot +=3D fdata->quot_offset; + fuse_corner->quot +=3D fdata->quot_adjust; + + return 0; +} +EXPORT_SYMBOL_GPL(cpr_populate_fuse_common); + +int cpr_find_initial_corner(struct device *dev, struct clk *cpu_clk, + struct corner *corners, int num_corners) +{ + unsigned long rate; + struct corner *iter, *corner; + const struct corner *end; + unsigned int i =3D 0; + + if (!cpu_clk) { + dev_err(dev, "cannot get rate from NULL clk\n"); + return -EINVAL; + } + + end =3D &corners[num_corners - 1]; + rate =3D clk_get_rate(cpu_clk); + + /* + * Some bootloaders set a CPU clock frequency that is not defined + * in the OPP table. When running at an unlisted frequency, + * cpufreq_online() will change to the OPP which has the lowest + * frequency, at or above the unlisted frequency. + * Since cpufreq_online() always "rounds up" in the case of an + * unlisted frequency, this function always "rounds down" in case + * of an unlisted frequency. That way, when cpufreq_online() + * triggers the first ever call to cpr_set_performance_state(), + * it will correctly determine the direction as UP. + */ + for (iter =3D corners; iter <=3D end; iter++) { + if (iter->freq > rate) + break; + i++; + if (iter->freq =3D=3D rate) { + corner =3D iter; + break; + } + if (iter->freq < rate) + corner =3D iter; + } + + if (!corner) { + dev_err(dev, "boot up corner not found\n"); + return -EINVAL; + } + + dev_dbg(dev, "boot up perf state: %u\n", i); + + return 0; +} +EXPORT_SYMBOL_GPL(cpr_find_initial_corner); + +unsigned int cpr_get_fuse_corner(struct dev_pm_opp *opp) +{ + struct device_node *np; + unsigned int fuse_corner =3D 0; + + np =3D dev_pm_opp_get_of_node(opp); + if (of_property_read_u32(np, "qcom,opp-fuse-level", &fuse_corner)) + pr_err("%s: missing 'qcom,opp-fuse-level' property\n", + __func__); + + of_node_put(np); + + return fuse_corner; +} +EXPORT_SYMBOL_GPL(cpr_get_fuse_corner); + +unsigned long cpr_get_opp_hz_for_req(struct dev_pm_opp *ref, + struct device *cpu_dev) +{ + u64 rate =3D 0; + struct device_node *ref_np; + struct device_node *desc_np; + struct device_node *child_np =3D NULL; + struct device_node *child_req_np =3D NULL; + + desc_np =3D dev_pm_opp_of_get_opp_desc_node(cpu_dev); + if (!desc_np) + return 0; + + ref_np =3D dev_pm_opp_get_of_node(ref); + if (!ref_np) + goto out_ref; + + do { + of_node_put(child_req_np); + child_np =3D of_get_next_available_child(desc_np, child_np); + child_req_np =3D of_parse_phandle(child_np, "required-opps", 0); + } while (child_np && child_req_np !=3D ref_np); + + if (child_np && child_req_np =3D=3D ref_np) + of_property_read_u64(child_np, "opp-hz", &rate); + + of_node_put(child_req_np); + of_node_put(child_np); + of_node_put(ref_np); +out_ref: + of_node_put(desc_np); + + return (unsigned long) rate; +} +EXPORT_SYMBOL_GPL(cpr_get_opp_hz_for_req); + +int cpr_calculate_scaling(struct device *dev, + const char *quot_offset, + const struct fuse_corner_data *fdata, + const struct corner *corner) +{ + u32 quot_diff =3D 0; + unsigned long freq_diff; + int scaling; + const struct fuse_corner *fuse, *prev_fuse; + int ret; + + fuse =3D corner->fuse_corner; + prev_fuse =3D fuse - 1; + + if (quot_offset) { + ret =3D nvmem_cell_read_variable_le_u32(dev, quot_offset, "_diff); + if (ret) + return ret; + + quot_diff *=3D fdata->quot_offset_scale; + quot_diff +=3D fdata->quot_offset_adjust; + } else { + quot_diff =3D fuse->quot - prev_fuse->quot; + } + + freq_diff =3D fuse->max_freq - prev_fuse->max_freq; + freq_diff /=3D 1000000; /* Convert to MHz */ + scaling =3D 1000 * quot_diff / freq_diff; + return min(scaling, fdata->max_quot_scale); +} +EXPORT_SYMBOL_GPL(cpr_calculate_scaling); + +int cpr_interpolate(const struct corner *corner, int step_volt, + const struct fuse_corner_data *fdata) +{ + unsigned long f_high, f_low, f_diff; + int uV_high, uV_low, uV; + u64 temp, temp_limit; + const struct fuse_corner *fuse, *prev_fuse; + + fuse =3D corner->fuse_corner; + prev_fuse =3D fuse - 1; + + f_high =3D fuse->max_freq; + f_low =3D prev_fuse->max_freq; + uV_high =3D fuse->uV; + uV_low =3D prev_fuse->uV; + f_diff =3D fuse->max_freq - corner->freq; + + /* + * Don't interpolate in the wrong direction. This could happen + * if the adjusted fuse voltage overlaps with the previous fuse's + * adjusted voltage. + */ + if (f_high <=3D f_low || uV_high <=3D uV_low || f_high <=3D corner->freq) + return corner->uV; + + temp =3D f_diff * (uV_high - uV_low); + temp =3D div64_ul(temp, f_high - f_low); + + /* + * max_volt_scale has units of uV/MHz while freq values + * have units of Hz. Divide by 1000000 to convert to. + */ + temp_limit =3D f_diff * fdata->max_volt_scale; + do_div(temp_limit, 1000000); + + uV =3D uV_high - min(temp, temp_limit); + return roundup(uV, step_volt); +} +EXPORT_SYMBOL_GPL(cpr_interpolate); + +int cpr_check_vreg_constraints(struct device *dev, struct regulator *vreg, + struct fuse_corner *f) +{ + int ret; + + ret =3D regulator_is_supported_voltage(vreg, f->min_uV, f->min_uV); + if (!ret) { + dev_err(dev, "min uV: %d not supported by regulator\n", + f->min_uV); + return -EINVAL; + } + + ret =3D regulator_is_supported_voltage(vreg, f->max_uV, f->max_uV); + if (!ret) { + dev_err(dev, "max uV: %d not supported by regulator\n", + f->max_uV); + return -EINVAL; + } + + return 0; +} +EXPORT_SYMBOL_GPL(cpr_check_vreg_constraints); + +MODULE_DESCRIPTION("Core Power Reduction (CPR) common"); +MODULE_LICENSE("GPL"); diff --git a/drivers/genpd/qcom/cpr-common.h b/drivers/genpd/qcom/cpr-commo= n.h new file mode 100644 index 000000000000..1f2ebf9394cf --- /dev/null +++ b/drivers/genpd/qcom/cpr-common.h @@ -0,0 +1,103 @@ +/* SPDX-License-Identifier: GPL-2.0 */ + +#include +#include +#include +#include + +enum voltage_change_dir { + NO_CHANGE, + DOWN, + UP, +}; + +struct cpr_fuse { + char *ring_osc; + char *init_voltage; + char *quotient; + char *quotient_offset; +}; + +struct fuse_corner_data { + int ref_uV; + int max_uV; + int min_uV; + int max_volt_scale; + int max_quot_scale; + /* fuse quot */ + int quot_offset; + int quot_scale; + int quot_adjust; + /* fuse quot_offset */ + int quot_offset_scale; + int quot_offset_adjust; +}; + +struct fuse_corner { + int min_uV; + int max_uV; + int uV; + int quot; + int step_quot; + const struct reg_sequence *accs; + int num_accs; + unsigned long max_freq; + u8 ring_osc_idx; +}; + +struct corner { + int min_uV; + int max_uV; + int uV; + int last_uV; + int quot_adjust; + u32 save_ctl; + u32 save_irq; + unsigned long freq; + struct fuse_corner *fuse_corner; +}; + +struct corner_data { + unsigned int fuse_corner; + unsigned long freq; +}; + +struct acc_desc { + unsigned int enable_reg; + u32 enable_mask; + + struct reg_sequence *config; + struct reg_sequence *settings; + int num_regs_per_fuse; +}; + +struct cpr_acc_desc { + const struct cpr_desc *cpr_desc; + const struct acc_desc *acc_desc; +}; + +int cpr_populate_ring_osc_idx(struct device *dev, + struct fuse_corner *fuse_corner, + const struct cpr_fuse *cpr_fuse, + int num_fuse_corners); +const struct cpr_fuse *cpr_get_fuses(struct device *dev, + unsigned int num_fuse_corners); +int cpr_populate_fuse_common(struct device *dev, + struct fuse_corner_data *fdata, + const struct cpr_fuse *cpr_fuse, + struct fuse_corner *fuse_corner, + int step_volt, int init_v_width, + int init_v_step); +int cpr_find_initial_corner(struct device *dev, struct clk *cpu_clk, + struct corner *corners, int num_corners); +u32 cpr_get_fuse_corner(struct dev_pm_opp *opp); +unsigned long cpr_get_opp_hz_for_req(struct dev_pm_opp *ref, + struct device *cpu_dev); +int cpr_calculate_scaling(struct device *dev, + const char *quot_offset, + const struct fuse_corner_data *fdata, + const struct corner *corner); +int cpr_interpolate(const struct corner *corner, int step_volt, + const struct fuse_corner_data *fdata); +int cpr_check_vreg_constraints(struct device *dev, struct regulator *vreg, + struct fuse_corner *f); diff --git a/drivers/genpd/qcom/cpr.c b/drivers/genpd/qcom/cpr.c index 94a3f0977212..2cfeefebd24c 100644 --- a/drivers/genpd/qcom/cpr.c +++ b/drivers/genpd/qcom/cpr.c @@ -25,6 +25,8 @@ #include #include =20 +#include "cpr-common.h" + /* Register Offsets for RB-CPR and Bit Definitions */ =20 /* RBCPR Version Register */ @@ -123,45 +125,12 @@ =20 #define FUSE_REVISION_UNKNOWN (-1) =20 -enum voltage_change_dir { - NO_CHANGE, - DOWN, - UP, -}; - -struct cpr_fuse { - char *ring_osc; - char *init_voltage; - char *quotient; - char *quotient_offset; -}; - -struct fuse_corner_data { - int ref_uV; - int max_uV; - int min_uV; - int max_volt_scale; - int max_quot_scale; - /* fuse quot */ - int quot_offset; - int quot_scale; - int quot_adjust; - /* fuse quot_offset */ - int quot_offset_scale; - int quot_offset_adjust; -}; - struct cpr_fuses { int init_voltage_step; int init_voltage_width; struct fuse_corner_data *fuse_corner_data; }; =20 -struct corner_data { - unsigned int fuse_corner; - unsigned long freq; -}; - struct cpr_desc { unsigned int num_fuse_corners; int min_diff_quot; @@ -183,44 +152,6 @@ struct cpr_desc { bool reduce_to_corner_uV; }; =20 -struct acc_desc { - unsigned int enable_reg; - u32 enable_mask; - - struct reg_sequence *config; - struct reg_sequence *settings; - int num_regs_per_fuse; -}; - -struct cpr_acc_desc { - const struct cpr_desc *cpr_desc; - const struct acc_desc *acc_desc; -}; - -struct fuse_corner { - int min_uV; - int max_uV; - int uV; - int quot; - int step_quot; - const struct reg_sequence *accs; - int num_accs; - unsigned long max_freq; - u8 ring_osc_idx; -}; - -struct corner { - int min_uV; - int max_uV; - int uV; - int last_uV; - int quot_adjust; - u32 save_ctl; - u32 save_irq; - unsigned long freq; - struct fuse_corner *fuse_corner; -}; - struct cpr_drv { unsigned int num_corners; unsigned int ref_clk_khz; @@ -800,50 +731,6 @@ static int cpr_set_performance_state(struct generic_pm= _domain *domain, return ret; } =20 -static int -cpr_populate_ring_osc_idx(struct cpr_drv *drv) -{ - struct fuse_corner *fuse =3D drv->fuse_corners; - struct fuse_corner *end =3D fuse + drv->desc->num_fuse_corners; - const struct cpr_fuse *fuses =3D drv->cpr_fuses; - u32 data; - int ret; - - for (; fuse < end; fuse++, fuses++) { - ret =3D nvmem_cell_read_variable_le_u32(drv->dev, fuses->ring_osc, &data= ); - if (ret) - return ret; - fuse->ring_osc_idx =3D data; - } - - return 0; -} - -static int cpr_read_fuse_uV(const struct cpr_desc *desc, - const struct fuse_corner_data *fdata, - const char *init_v_efuse, - int step_volt, - struct cpr_drv *drv) -{ - int step_size_uV, steps, uV; - u32 bits =3D 0; - int ret; - - ret =3D nvmem_cell_read_variable_le_u32(drv->dev, init_v_efuse, &bits); - if (ret) - return ret; - - steps =3D bits & ~BIT(desc->cpr_fuses.init_voltage_width - 1); - /* Not two's complement.. instead highest bit is sign bit */ - if (bits & BIT(desc->cpr_fuses.init_voltage_width - 1)) - steps =3D -steps; - - step_size_uV =3D desc->cpr_fuses.init_voltage_step; - - uV =3D fdata->ref_uV + steps * step_size_uV; - return DIV_ROUND_UP(uV, step_volt) * step_volt; -} - static int cpr_fuse_corner_init(struct cpr_drv *drv) { const struct cpr_desc *desc =3D drv->desc; @@ -853,7 +740,6 @@ static int cpr_fuse_corner_init(struct cpr_drv *drv) unsigned int step_volt; struct fuse_corner_data *fdata; struct fuse_corner *fuse, *end; - int uV; const struct reg_sequence *accs; int ret; =20 @@ -869,23 +755,15 @@ static int cpr_fuse_corner_init(struct cpr_drv *drv) fdata =3D desc->cpr_fuses.fuse_corner_data; =20 for (i =3D 0; fuse <=3D end; fuse++, fuses++, i++, fdata++) { - /* - * Update SoC voltages: platforms might choose a different - * regulators than the one used to characterize the algorithms - * (ie, init_voltage_step). - */ - fdata->min_uV =3D roundup(fdata->min_uV, step_volt); - fdata->max_uV =3D roundup(fdata->max_uV, step_volt); + ret =3D cpr_populate_fuse_common(drv->dev, fdata, fuses, + fuse, step_volt, + desc->cpr_fuses.init_voltage_width, + desc->cpr_fuses.init_voltage_step); + if (ret) + return ret; =20 - /* Populate uV */ - uV =3D cpr_read_fuse_uV(desc, fdata, fuses->init_voltage, - step_volt, drv); - if (uV < 0) - return uV; =20 - fuse->min_uV =3D fdata->min_uV; - fuse->max_uV =3D fdata->max_uV; - fuse->uV =3D clamp(uV, fuse->min_uV, fuse->max_uV); + fuse->step_quot =3D desc->step_quot[fuse->ring_osc_idx]; =20 if (fuse =3D=3D end) { /* @@ -923,25 +801,9 @@ static int cpr_fuse_corner_init(struct cpr_drv *drv) else if (fuse->uV < fuse->min_uV) fuse->uV =3D fuse->min_uV; =20 - ret =3D regulator_is_supported_voltage(drv->vdd_apc, - fuse->min_uV, - fuse->min_uV); - if (!ret) { - dev_err(drv->dev, - "min uV: %d (fuse corner: %d) not supported by regulator\n", - fuse->min_uV, i); - return -EINVAL; - } - - ret =3D regulator_is_supported_voltage(drv->vdd_apc, - fuse->max_uV, - fuse->max_uV); - if (!ret) { - dev_err(drv->dev, - "max uV: %d (fuse corner: %d) not supported by regulator\n", - fuse->max_uV, i); - return -EINVAL; - } + ret =3D cpr_check_vreg_constraints(drv->dev, drv->vdd_apc, fuse); + if (ret) + return ret; =20 dev_dbg(drv->dev, "fuse corner %d: [%d %d %d] RO%hhu quot %d squot %d\n", @@ -952,126 +814,6 @@ static int cpr_fuse_corner_init(struct cpr_drv *drv) return 0; } =20 -static int cpr_calculate_scaling(const char *quot_offset, - struct cpr_drv *drv, - const struct fuse_corner_data *fdata, - const struct corner *corner) -{ - u32 quot_diff =3D 0; - unsigned long freq_diff; - int scaling; - const struct fuse_corner *fuse, *prev_fuse; - int ret; - - fuse =3D corner->fuse_corner; - prev_fuse =3D fuse - 1; - - if (quot_offset) { - ret =3D nvmem_cell_read_variable_le_u32(drv->dev, quot_offset, "_dif= f); - if (ret) - return ret; - - quot_diff *=3D fdata->quot_offset_scale; - quot_diff +=3D fdata->quot_offset_adjust; - } else { - quot_diff =3D fuse->quot - prev_fuse->quot; - } - - freq_diff =3D fuse->max_freq - prev_fuse->max_freq; - freq_diff /=3D 1000000; /* Convert to MHz */ - scaling =3D 1000 * quot_diff / freq_diff; - return min(scaling, fdata->max_quot_scale); -} - -static int cpr_interpolate(const struct corner *corner, int step_volt, - const struct fuse_corner_data *fdata) -{ - unsigned long f_high, f_low, f_diff; - int uV_high, uV_low, uV; - u64 temp, temp_limit; - const struct fuse_corner *fuse, *prev_fuse; - - fuse =3D corner->fuse_corner; - prev_fuse =3D fuse - 1; - - f_high =3D fuse->max_freq; - f_low =3D prev_fuse->max_freq; - uV_high =3D fuse->uV; - uV_low =3D prev_fuse->uV; - f_diff =3D fuse->max_freq - corner->freq; - - /* - * Don't interpolate in the wrong direction. This could happen - * if the adjusted fuse voltage overlaps with the previous fuse's - * adjusted voltage. - */ - if (f_high <=3D f_low || uV_high <=3D uV_low || f_high <=3D corner->freq) - return corner->uV; - - temp =3D f_diff * (uV_high - uV_low); - temp =3D div64_ul(temp, f_high - f_low); - - /* - * max_volt_scale has units of uV/MHz while freq values - * have units of Hz. Divide by 1000000 to convert to. - */ - temp_limit =3D f_diff * fdata->max_volt_scale; - do_div(temp_limit, 1000000); - - uV =3D uV_high - min(temp, temp_limit); - return roundup(uV, step_volt); -} - -static unsigned int cpr_get_fuse_corner(struct dev_pm_opp *opp) -{ - struct device_node *np; - unsigned int fuse_corner =3D 0; - - np =3D dev_pm_opp_get_of_node(opp); - if (of_property_read_u32(np, "qcom,opp-fuse-level", &fuse_corner)) - pr_err("%s: missing 'qcom,opp-fuse-level' property\n", - __func__); - - of_node_put(np); - - return fuse_corner; -} - -static unsigned long cpr_get_opp_hz_for_req(struct dev_pm_opp *ref, - struct device *cpu_dev) -{ - u64 rate =3D 0; - struct device_node *ref_np; - struct device_node *desc_np; - struct device_node *child_np =3D NULL; - struct device_node *child_req_np =3D NULL; - - desc_np =3D dev_pm_opp_of_get_opp_desc_node(cpu_dev); - if (!desc_np) - return 0; - - ref_np =3D dev_pm_opp_get_of_node(ref); - if (!ref_np) - goto out_ref; - - do { - of_node_put(child_req_np); - child_np =3D of_get_next_available_child(desc_np, child_np); - child_req_np =3D of_parse_phandle(child_np, "required-opps", 0); - } while (child_np && child_req_np !=3D ref_np); - - if (child_np && child_req_np =3D=3D ref_np) - of_property_read_u64(child_np, "opp-hz", &rate); - - of_node_put(child_req_np); - of_node_put(child_np); - of_node_put(ref_np); -out_ref: - of_node_put(desc_np); - - return (unsigned long) rate; -} - static int cpr_corner_init(struct cpr_drv *drv) { const struct cpr_desc *desc =3D drv->desc; @@ -1185,7 +927,7 @@ static int cpr_corner_init(struct cpr_drv *drv) corner->uV =3D fuse->uV; =20 if (prev_fuse && cdata[i - 1].freq =3D=3D prev_fuse->max_freq) { - scaling =3D cpr_calculate_scaling(quot_offset, drv, + scaling =3D cpr_calculate_scaling(drv->dev, quot_offset, fdata, corner); if (scaling < 0) return scaling; @@ -1223,47 +965,6 @@ static int cpr_corner_init(struct cpr_drv *drv) return 0; } =20 -static const struct cpr_fuse *cpr_get_fuses(struct cpr_drv *drv) -{ - const struct cpr_desc *desc =3D drv->desc; - struct cpr_fuse *fuses; - int i; - - fuses =3D devm_kcalloc(drv->dev, desc->num_fuse_corners, - sizeof(struct cpr_fuse), - GFP_KERNEL); - if (!fuses) - return ERR_PTR(-ENOMEM); - - for (i =3D 0; i < desc->num_fuse_corners; i++) { - char tbuf[32]; - - snprintf(tbuf, 32, "cpr_ring_osc%d", i + 1); - fuses[i].ring_osc =3D devm_kstrdup(drv->dev, tbuf, GFP_KERNEL); - if (!fuses[i].ring_osc) - return ERR_PTR(-ENOMEM); - - snprintf(tbuf, 32, "cpr_init_voltage%d", i + 1); - fuses[i].init_voltage =3D devm_kstrdup(drv->dev, tbuf, - GFP_KERNEL); - if (!fuses[i].init_voltage) - return ERR_PTR(-ENOMEM); - - snprintf(tbuf, 32, "cpr_quotient%d", i + 1); - fuses[i].quotient =3D devm_kstrdup(drv->dev, tbuf, GFP_KERNEL); - if (!fuses[i].quotient) - return ERR_PTR(-ENOMEM); - - snprintf(tbuf, 32, "cpr_quotient_offset%d", i + 1); - fuses[i].quotient_offset =3D devm_kstrdup(drv->dev, tbuf, - GFP_KERNEL); - if (!fuses[i].quotient_offset) - return ERR_PTR(-ENOMEM); - } - - return fuses; -} - static void cpr_set_loop_allowed(struct cpr_drv *drv) { drv->loop_disabled =3D false; @@ -1295,54 +996,6 @@ static int cpr_init_parameters(struct cpr_drv *drv) return 0; } =20 -static int cpr_find_initial_corner(struct cpr_drv *drv) -{ - unsigned long rate; - const struct corner *end; - struct corner *iter; - unsigned int i =3D 0; - - if (!drv->cpu_clk) { - dev_err(drv->dev, "cannot get rate from NULL clk\n"); - return -EINVAL; - } - - end =3D &drv->corners[drv->num_corners - 1]; - rate =3D clk_get_rate(drv->cpu_clk); - - /* - * Some bootloaders set a CPU clock frequency that is not defined - * in the OPP table. When running at an unlisted frequency, - * cpufreq_online() will change to the OPP which has the lowest - * frequency, at or above the unlisted frequency. - * Since cpufreq_online() always "rounds up" in the case of an - * unlisted frequency, this function always "rounds down" in case - * of an unlisted frequency. That way, when cpufreq_online() - * triggers the first ever call to cpr_set_performance_state(), - * it will correctly determine the direction as UP. - */ - for (iter =3D drv->corners; iter <=3D end; iter++) { - if (iter->freq > rate) - break; - i++; - if (iter->freq =3D=3D rate) { - drv->corner =3D iter; - break; - } - if (iter->freq < rate) - drv->corner =3D iter; - } - - if (!drv->corner) { - dev_err(drv->dev, "boot up corner not found\n"); - return -EINVAL; - } - - dev_dbg(drv->dev, "boot up perf state: %u\n", i); - - return 0; -} - static const struct cpr_desc qcs404_cpr_desc =3D { .num_fuse_corners =3D 3, .min_diff_quot =3D CPR_FUSE_MIN_QUOT_DIFF, @@ -1530,7 +1183,8 @@ static int cpr_pd_attach_dev(struct generic_pm_domain= *domain, if (ret) goto unlock; =20 - ret =3D cpr_find_initial_corner(drv); + ret =3D cpr_find_initial_corner(drv->dev, drv->cpu_clk, drv->corners, + drv->num_corners); if (ret) goto unlock; =20 @@ -1615,6 +1269,7 @@ static int cpr_probe(struct platform_device *pdev) { struct device *dev =3D &pdev->dev; struct cpr_drv *drv; + const struct cpr_desc *desc; int irq, ret; const struct cpr_acc_desc *data; struct device_node *np; @@ -1630,6 +1285,7 @@ static int cpr_probe(struct platform_device *pdev) drv->dev =3D dev; drv->desc =3D data->cpr_desc; drv->acc_desc =3D data->acc_desc; + desc =3D drv->desc; =20 drv->fuse_corners =3D devm_kcalloc(dev, drv->desc->num_fuse_corners, sizeof(*drv->fuse_corners), @@ -1669,11 +1325,13 @@ static int cpr_probe(struct platform_device *pdev) if (ret) return ret; =20 - drv->cpr_fuses =3D cpr_get_fuses(drv); + drv->cpr_fuses =3D cpr_get_fuses(drv->dev, desc->num_fuse_corners); if (IS_ERR(drv->cpr_fuses)) return PTR_ERR(drv->cpr_fuses); =20 - ret =3D cpr_populate_ring_osc_idx(drv); + ret =3D cpr_populate_ring_osc_idx(drv->dev, drv->fuse_corners, + drv->cpr_fuses, + desc->num_fuse_corners); if (ret) return ret; =20 --=20 2.41.0