* [PATCH V2 01/21] dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 02/21] dt-bindings: clock: tegra124-dfll: add Tegra210 support Joseph Lo
` (19 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, devicetree, Joseph Lo
From: Peter De Schrijver <pdeschrijver@nvidia.com>
Add new properties to configure the DFLL PWM regulator support.
Cc: devicetree@vger.kernel.org
Signed-off-by: Peter De Schrijver <pdeschrijver@nvidia.com>
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- update the binding strings and descriptions for
nvidia,pwm-tristate-microvolts
nvidia,pwm-min-microvolts
nvidia,pwm-voltage-step-microvolts
---
.../bindings/clock/nvidia,tegra124-dfll.txt | 79 ++++++++++++++++++-
1 file changed, 77 insertions(+), 2 deletions(-)
diff --git a/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt b/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt
index dff236f524a7..38e8cc8c70a8 100644
--- a/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt
+++ b/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt
@@ -8,7 +8,6 @@ the fast CPU cluster. It consists of a free-running voltage controlled
oscillator connected to the CPU voltage rail (VDD_CPU), and a closed loop
control module that will automatically adjust the VDD_CPU voltage by
communicating with an off-chip PMIC either via an I2C bus or via PWM signals.
-Currently only the I2C mode is supported by these bindings.
Required properties:
- compatible : should be "nvidia,tegra124-dfll"
@@ -45,10 +44,31 @@ Required properties for the control loop parameters:
Optional properties for the control loop parameters:
- nvidia,cg-scale: Boolean value, see the field DFLL_PARAMS_CG_SCALE in the TRM.
+Optional properties for mode selection:
+- nvidia,pwm-to-pmic: Use PWM to control regulator rather then I2C.
+
Required properties for I2C mode:
- nvidia,i2c-fs-rate: I2C transfer rate, if using full speed mode.
-Example:
+Required properties for PWM mode:
+- nvidia,pwm-period: period of PWM square wave in microseconds.
+- nvidia,pwm-tristate-microvolts: Regulator voltage in micro volts when PWM
+ control is disabled and the PWM output is tristated. Note that this voltage is
+ configured in hardware, typically via a resistor divider.
+- nvidia,pwm-min-microvolts: Regulator voltage in micro volts when PWM control
+ is enabled and PWM output is low. Hence, this is the minimum output voltage
+ that the regulator supports when PWM control is enabled.
+- nvidia,pwm-voltage-step-microvolts: Voltage increase in micro volts
+ corresponding to a 1/33th increase in duty cycle. Eg the voltage for 2/33th
+ duty cycle would be: nvidia,pwm-min-microvolts +
+ nvidia,pwm-voltage-step-microvolts * 2.
+- pinctrl-0: I/O pad configuration when PWM control is enabled.
+- pinctrl-1: I/O pad configuration when PWM control is disabled.
+- pinctrl-names: must include the following entries:
+ - dvfs_pwm_enable: I/O pad configuration when PWM control is enabled.
+ - dvfs_pwm_disable: I/O pad configuration when PWM control is disabled.
+
+Example for I2C:
clock@70110000 {
compatible = "nvidia,tegra124-dfll";
@@ -76,3 +96,58 @@ clock@70110000 {
nvidia,i2c-fs-rate = <400000>;
};
+
+Example for PWM:
+
+clock@70110000 {
+ compatible = "nvidia,tegra124-dfll";
+ reg = <0 0x70110000 0 0x100>, /* DFLL control */
+ <0 0x70110000 0 0x100>, /* I2C output control */
+ <0 0x70110100 0 0x100>, /* Integrated I2C controller */
+ <0 0x70110200 0 0x100>; /* Look-up table RAM */
+ interrupts = <GIC_SPI 62 IRQ_TYPE_LEVEL_HIGH>;
+ clocks = <&tegra_car TEGRA210_CLK_DFLL_SOC>,
+ <&tegra_car TEGRA210_CLK_DFLL_REF>,
+ <&tegra_car TEGRA124_CLK_I2C5>;;
+ clock-names = "soc", "ref", "i2c";
+ resets = <&tegra_car TEGRA124_RST_DFLL_DVCO>;
+ reset-names = "dvco";
+ #clock-cells = <0>;
+ clock-output-names = "dfllCPU_out";
+
+ nvidia,sample-rate = <25000>;
+ nvidia,droop-ctrl = <0x00000f00>;
+ nvidia,force-mode = <1>;
+ nvidia,cf = <6>;
+ nvidia,ci = <0>;
+ nvidia,cg = <2>;
+
+ nvidia,pwm-min-microvolts = <708000>; /* 708mV */
+ nvidia,pwm-period = <2500>; /* 2.5us */
+ nvidia,pwm-to-pmic;
+ nvidia,pwm-tristate-microvolts = <1000000>;
+ nvidia,pwm-voltage-step-microvolts = <19200>; /* 19.2mV */
+
+ pinctrl-names = "dvfs_pwm_enable", "dvfs_pwm_disable";
+ pinctrl-0 = <&dvfs_pwm_active_state>;
+ pinctrl-1 = <&dvfs_pwm_inactive_state>;
+};
+
+/* pinmux nodes added for completeness. Binding doc can be found in:
+ * Documentation/devicetree/bindings/pinctrl/nvidia,tegra210-pinmux.txt
+ */
+
+pinmux: pinmux@700008d4 {
+ dvfs_pwm_active_state: dvfs_pwm_active {
+ dvfs_pwm_pbb1 {
+ nvidia,pins = "dvfs_pwm_pbb1";
+ nvidia,tristate = <TEGRA_PIN_DISABLE>;
+ };
+ };
+ dvfs_pwm_inactive_state: dvfs_pwm_inactive {
+ dvfs_pwm_pbb1 {
+ nvidia,pins = "dvfs_pwm_pbb1";
+ nvidia,tristate = <TEGRA_PIN_ENABLE>;
+ };
+ };
+};
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 02/21] dt-bindings: clock: tegra124-dfll: add Tegra210 support
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
2018-12-13 9:34 ` [PATCH V2 01/21] dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 03/21] dt-bindings: cpufreq: tegra124: remove vdd-cpu-supply from required properties Joseph Lo
` (18 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo, devicetree
Add Tegra210 support for DFLL clock.
Cc: devicetree@vger.kernel.org
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
.../devicetree/bindings/clock/nvidia,tegra124-dfll.txt | 4 +++-
1 file changed, 3 insertions(+), 1 deletion(-)
diff --git a/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt b/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt
index 38e8cc8c70a8..8a38c8e78acf 100644
--- a/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt
+++ b/Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt
@@ -10,7 +10,9 @@ control module that will automatically adjust the VDD_CPU voltage by
communicating with an off-chip PMIC either via an I2C bus or via PWM signals.
Required properties:
-- compatible : should be "nvidia,tegra124-dfll"
+- compatible : should be one of:
+ - "nvidia,tegra124-dfll": for Tegra124
+ - "nvidia,tegra210-dfll": for Tegra210
- reg : Defines the following set of registers, in the order listed:
- registers for the DFLL control logic.
- registers for the I2C output logic.
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 03/21] dt-bindings: cpufreq: tegra124: remove vdd-cpu-supply from required properties
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
2018-12-13 9:34 ` [PATCH V2 01/21] dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator Joseph Lo
2018-12-13 9:34 ` [PATCH V2 02/21] dt-bindings: clock: tegra124-dfll: add Tegra210 support Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 04/21] dt-bindings: cpufreq: tegra124: remove cpu_lp clock " Joseph Lo
` (17 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo, devicetree
The Tegra124 cpufreq driver works only with DFLL clock, which is a
hardware-based frequency/voltage controller. The driver doesn't need to
control the regulator itself. Hence remove that.
Cc: devicetree@vger.kernel.org
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
.../devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt | 2 --
1 file changed, 2 deletions(-)
diff --git a/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt b/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt
index b1669fbfb740..031545a29caf 100644
--- a/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt
+++ b/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt
@@ -13,7 +13,6 @@ Required properties:
- pll_x: Fast PLL clocksource.
- pll_p: Auxiliary PLL used during fast PLL rate changes.
- dfll: Fast DFLL clocksource that also automatically scales CPU voltage.
-- vdd-cpu-supply: Regulator for CPU voltage
Optional properties:
- clock-latency: Specify the possible maximum transition latency for clock,
@@ -37,7 +36,6 @@ cpus {
<&dfll>;
clock-names = "cpu_g", "cpu_lp", "pll_x", "pll_p", "dfll";
clock-latency = <300000>;
- vdd-cpu-supply: <&vdd_cpu>;
};
<...>
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 04/21] dt-bindings: cpufreq: tegra124: remove cpu_lp clock from required properties
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (2 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 03/21] dt-bindings: cpufreq: tegra124: remove vdd-cpu-supply from required properties Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 05/21] clk: tegra: dfll: registration for multiple SoCs Joseph Lo
` (16 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo, devicetree
The cpu_lp clock property is only needed when the CPUfreq driver
supports CPU cluster switching. But it was not a design for this driver
and it didn't handle that as well. So removing this property.
Cc: devicetree@vger.kernel.org
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
.../devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt | 4 +---
1 file changed, 1 insertion(+), 3 deletions(-)
diff --git a/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt b/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt
index 031545a29caf..03196d5ea515 100644
--- a/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt
+++ b/Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt
@@ -9,7 +9,6 @@ Required properties:
See ../clocks/clock-bindings.txt for details.
- clock-names: Must include the following entries:
- cpu_g: Clock mux for the fast CPU cluster.
- - cpu_lp: Clock mux for the low-power CPU cluster.
- pll_x: Fast PLL clocksource.
- pll_p: Auxiliary PLL used during fast PLL rate changes.
- dfll: Fast DFLL clocksource that also automatically scales CPU voltage.
@@ -30,11 +29,10 @@ cpus {
reg = <0>;
clocks = <&tegra_car TEGRA124_CLK_CCLK_G>,
- <&tegra_car TEGRA124_CLK_CCLK_LP>,
<&tegra_car TEGRA124_CLK_PLL_X>,
<&tegra_car TEGRA124_CLK_PLL_P>,
<&dfll>;
- clock-names = "cpu_g", "cpu_lp", "pll_x", "pll_p", "dfll";
+ clock-names = "cpu_g", "pll_x", "pll_p", "dfll";
clock-latency = <300000>;
};
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 05/21] clk: tegra: dfll: registration for multiple SoCs
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (3 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 04/21] dt-bindings: cpufreq: tegra124: remove cpu_lp clock " Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 06/21] clk: tegra: dfll: CVB calculation alignment with the regulator Joseph Lo
` (15 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
From: Peter De Schrijver <pdeschrijver@nvidia.com>
In a future patch, support for the DFLL in Tegra210 will be introduced.
This requires support for more than 1 set of CVB and CPU max frequency
tables.
Signed-off-by: Peter De Schrijver <pdeschrijver@nvidia.com>
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 45 ++++++++++++++++------
1 file changed, 34 insertions(+), 11 deletions(-)
diff --git a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
index 269d3595758b..1a2cc113e5c8 100644
--- a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
+++ b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
@@ -1,7 +1,7 @@
/*
* Tegra124 DFLL FCPU clock source driver
*
- * Copyright (C) 2012-2014 NVIDIA Corporation. All rights reserved.
+ * Copyright (C) 2012-2018 NVIDIA Corporation. All rights reserved.
*
* Aleksandr Frid <afrid@nvidia.com>
* Paul Walmsley <pwalmsley@nvidia.com>
@@ -21,6 +21,7 @@
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/init.h>
+#include <linux/of_device.h>
#include <linux/platform_device.h>
#include <soc/tegra/fuse.h>
@@ -28,8 +29,15 @@
#include "clk-dfll.h"
#include "cvb.h"
+struct dfll_fcpu_data {
+ const unsigned long *cpu_max_freq_table;
+ unsigned int cpu_max_freq_table_size;
+ const struct cvb_table *cpu_cvb_tables;
+ unsigned int cpu_cvb_tables_size;
+};
+
/* Maximum CPU frequency, indexed by CPU speedo id */
-static const unsigned long cpu_max_freq_table[] = {
+static const unsigned long tegra124_cpu_max_freq_table[] = {
[0] = 2014500000UL,
[1] = 2320500000UL,
[2] = 2116500000UL,
@@ -82,16 +90,36 @@ static const struct cvb_table tegra124_cpu_cvb_tables[] = {
},
};
+static const struct dfll_fcpu_data tegra124_dfll_fcpu_data = {
+ .cpu_max_freq_table = tegra124_cpu_max_freq_table,
+ .cpu_max_freq_table_size = ARRAY_SIZE(tegra124_cpu_max_freq_table),
+ .cpu_cvb_tables = tegra124_cpu_cvb_tables,
+ .cpu_cvb_tables_size = ARRAY_SIZE(tegra124_cpu_cvb_tables)
+};
+
+static const struct of_device_id tegra124_dfll_fcpu_of_match[] = {
+ {
+ .compatible = "nvidia,tegra124-dfll",
+ .data = &tegra124_dfll_fcpu_data,
+ },
+ { },
+};
+
static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
{
int process_id, speedo_id, speedo_value, err;
struct tegra_dfll_soc_data *soc;
+ const struct dfll_fcpu_data *fcpu_data;
+
+ fcpu_data = of_device_get_match_data(&pdev->dev);
+ if (!fcpu_data)
+ return -ENODEV;
process_id = tegra_sku_info.cpu_process_id;
speedo_id = tegra_sku_info.cpu_speedo_id;
speedo_value = tegra_sku_info.cpu_speedo_value;
- if (speedo_id >= ARRAY_SIZE(cpu_max_freq_table)) {
+ if (speedo_id >= fcpu_data->cpu_max_freq_table_size) {
dev_err(&pdev->dev, "unknown max CPU freq for speedo_id=%d\n",
speedo_id);
return -ENODEV;
@@ -107,10 +135,10 @@ static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
return -ENODEV;
}
- soc->max_freq = cpu_max_freq_table[speedo_id];
+ soc->max_freq = fcpu_data->cpu_max_freq_table[speedo_id];
- soc->cvb = tegra_cvb_add_opp_table(soc->dev, tegra124_cpu_cvb_tables,
- ARRAY_SIZE(tegra124_cpu_cvb_tables),
+ soc->cvb = tegra_cvb_add_opp_table(soc->dev, fcpu_data->cpu_cvb_tables,
+ fcpu_data->cpu_cvb_tables_size,
process_id, speedo_id, speedo_value,
soc->max_freq);
if (IS_ERR(soc->cvb)) {
@@ -142,11 +170,6 @@ static int tegra124_dfll_fcpu_remove(struct platform_device *pdev)
return 0;
}
-static const struct of_device_id tegra124_dfll_fcpu_of_match[] = {
- { .compatible = "nvidia,tegra124-dfll", },
- { },
-};
-
static const struct dev_pm_ops tegra124_dfll_pm_ops = {
SET_RUNTIME_PM_OPS(tegra_dfll_runtime_suspend,
tegra_dfll_runtime_resume, NULL)
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 06/21] clk: tegra: dfll: CVB calculation alignment with the regulator
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (4 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 05/21] clk: tegra: dfll: registration for multiple SoCs Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 11:18 ` Jon Hunter
2018-12-13 9:34 ` [PATCH V2 07/21] clk: tegra: dfll: support PWM regulator control Joseph Lo
` (14 subsequent siblings)
20 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
The CVB table contains calibration data for the CPU DFLL based on
process characterization. The regulator step and offset parameters depend
on the regulator supplying vdd-cpu, not on the specific Tegra SKU.
When using a PWM controlled regulator, the voltage step and offset are
determined by the regulator type in use. This is specified in DT. When
using an I2C controlled regulator, we can retrieve them from CPU regulator
Then pass this information to the CVB table calculation function.
Based on the work done of "Peter De Schrijver <pdeschrijver@nvidia.com>"
and "Alex Frid <afrid@nvidia.com>".
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- use the updated DT binding string for parsing
- update the mechanism for geting regulator data from DT (PWM mode) or
regulator (I2C mode)
---
drivers/clk/tegra/clk-dfll.h | 6 ++-
drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 57 ++++++++++++++++++++--
drivers/clk/tegra/cvb.c | 12 +++--
drivers/clk/tegra/cvb.h | 6 +--
4 files changed, 67 insertions(+), 14 deletions(-)
diff --git a/drivers/clk/tegra/clk-dfll.h b/drivers/clk/tegra/clk-dfll.h
index 83352c8078f2..ecc43cb9b6f1 100644
--- a/drivers/clk/tegra/clk-dfll.h
+++ b/drivers/clk/tegra/clk-dfll.h
@@ -1,6 +1,6 @@
/*
* clk-dfll.h - prototypes and macros for the Tegra DFLL clocksource driver
- * Copyright (C) 2013 NVIDIA Corporation. All rights reserved.
+ * Copyright (C) 2013-2018 NVIDIA Corporation. All rights reserved.
*
* Aleksandr Frid <afrid@nvidia.com>
* Paul Walmsley <pwalmsley@nvidia.com>
@@ -22,11 +22,14 @@
#include <linux/reset.h>
#include <linux/types.h>
+#include "cvb.h"
+
/**
* struct tegra_dfll_soc_data - SoC-specific hooks/integration for the DFLL driver
* @dev: struct device * that holds the OPP table for the DFLL
* @max_freq: maximum frequency supported on this SoC
* @cvb: CPU frequency table for this SoC
+ * @alignment: parameters of the regulator step and offset
* @init_clock_trimmers: callback to initialize clock trimmers
* @set_clock_trimmers_high: callback to tune clock trimmers for high voltage
* @set_clock_trimmers_low: callback to tune clock trimmers for low voltage
@@ -35,6 +38,7 @@ struct tegra_dfll_soc_data {
struct device *dev;
unsigned long max_freq;
const struct cvb_table *cvb;
+ struct rail_alignment alignment;
void (*init_clock_trimmers)(void);
void (*set_clock_trimmers_high)(void);
diff --git a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
index 1a2cc113e5c8..189b5e20ee4e 100644
--- a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
+++ b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
@@ -23,6 +23,7 @@
#include <linux/init.h>
#include <linux/of_device.h>
#include <linux/platform_device.h>
+#include <linux/regulator/consumer.h>
#include <soc/tegra/fuse.h>
#include "clk.h"
@@ -50,9 +51,6 @@ static const struct cvb_table tegra124_cpu_cvb_tables[] = {
.process_id = -1,
.min_millivolts = 900,
.max_millivolts = 1260,
- .alignment = {
- .step_uv = 10000, /* 10mV */
- },
.speedo_scale = 100,
.voltage_scale = 1000,
.entries = {
@@ -105,11 +103,45 @@ static const struct of_device_id tegra124_dfll_fcpu_of_match[] = {
{ },
};
+static void get_alignment_from_dt(struct device *dev,
+ struct rail_alignment *align)
+{
+ align->step_uv = 0;
+ align->offset_uv = 0;
+
+ if (of_property_read_u32(dev->of_node,
+ "nvidia,pwm-voltage-step-microvolts",
+ &align->step_uv))
+ align->step_uv = 0;
+
+ if (of_property_read_u32(dev->of_node,
+ "nvidia,pwm-min-microvolts",
+ &align->offset_uv))
+ align->offset_uv = 0;
+}
+
+static int get_alignment_from_regulator(struct device *dev,
+ struct rail_alignment *align)
+{
+ struct regulator *reg = devm_regulator_get(dev, "vdd-cpu");
+
+ if (IS_ERR(reg))
+ return PTR_ERR(reg);
+
+ align->offset_uv = regulator_list_voltage(reg, 0);
+ align->step_uv = regulator_get_linear_step(reg);
+
+ devm_regulator_put(reg);
+
+ return 0;
+}
+
static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
{
int process_id, speedo_id, speedo_value, err;
struct tegra_dfll_soc_data *soc;
const struct dfll_fcpu_data *fcpu_data;
+ struct rail_alignment align;
fcpu_data = of_device_get_match_data(&pdev->dev);
if (!fcpu_data)
@@ -135,12 +167,27 @@ static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
return -ENODEV;
}
+ if (of_property_read_bool(pdev->dev.of_node, "nvidia,pwm-to-pmic")) {
+ get_alignment_from_dt(&pdev->dev, &align);
+ } else {
+ err = get_alignment_from_regulator(&pdev->dev, &align);
+ if (err == -EPROBE_DEFER)
+ return -EPROBE_DEFER;
+ }
+
+ if (!align.step_uv) {
+ dev_err(&pdev->dev, "missing step uv\n");
+ return -EINVAL;
+ }
+
soc->max_freq = fcpu_data->cpu_max_freq_table[speedo_id];
soc->cvb = tegra_cvb_add_opp_table(soc->dev, fcpu_data->cpu_cvb_tables,
fcpu_data->cpu_cvb_tables_size,
- process_id, speedo_id, speedo_value,
- soc->max_freq);
+ &align, process_id, speedo_id,
+ speedo_value, soc->max_freq);
+ soc->alignment = align;
+
if (IS_ERR(soc->cvb)) {
dev_err(&pdev->dev, "couldn't add OPP table: %ld\n",
PTR_ERR(soc->cvb));
diff --git a/drivers/clk/tegra/cvb.c b/drivers/clk/tegra/cvb.c
index da9e8e7b5ce5..81dcb97a9e0a 100644
--- a/drivers/clk/tegra/cvb.c
+++ b/drivers/clk/tegra/cvb.c
@@ -1,7 +1,7 @@
/*
* Utility functions for parsing Tegra CVB voltage tables
*
- * Copyright (C) 2012-2014 NVIDIA Corporation. All rights reserved.
+ * Copyright (C) 2012-2018 NVIDIA Corporation. All rights reserved.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License version 2 as
@@ -62,9 +62,9 @@ static int round_voltage(int mv, const struct rail_alignment *align, int up)
}
static int build_opp_table(struct device *dev, const struct cvb_table *table,
+ struct rail_alignment *align,
int speedo_value, unsigned long max_freq)
{
- const struct rail_alignment *align = &table->alignment;
int i, ret, dfll_mv, min_mv, max_mv;
min_mv = round_voltage(table->min_millivolts, align, UP);
@@ -109,8 +109,9 @@ static int build_opp_table(struct device *dev, const struct cvb_table *table,
*/
const struct cvb_table *
tegra_cvb_add_opp_table(struct device *dev, const struct cvb_table *tables,
- size_t count, int process_id, int speedo_id,
- int speedo_value, unsigned long max_freq)
+ size_t count, struct rail_alignment *align,
+ int process_id, int speedo_id, int speedo_value,
+ unsigned long max_freq)
{
size_t i;
int ret;
@@ -124,7 +125,8 @@ tegra_cvb_add_opp_table(struct device *dev, const struct cvb_table *tables,
if (table->process_id != -1 && table->process_id != process_id)
continue;
- ret = build_opp_table(dev, table, speedo_value, max_freq);
+ ret = build_opp_table(dev, table, align, speedo_value,
+ max_freq);
return ret ? ERR_PTR(ret) : table;
}
diff --git a/drivers/clk/tegra/cvb.h b/drivers/clk/tegra/cvb.h
index c1f077993b2a..bcf15a089b93 100644
--- a/drivers/clk/tegra/cvb.h
+++ b/drivers/clk/tegra/cvb.h
@@ -49,7 +49,6 @@ struct cvb_table {
int min_millivolts;
int max_millivolts;
- struct rail_alignment alignment;
int speedo_scale;
int voltage_scale;
@@ -59,8 +58,9 @@ struct cvb_table {
const struct cvb_table *
tegra_cvb_add_opp_table(struct device *dev, const struct cvb_table *cvb_tables,
- size_t count, int process_id, int speedo_id,
- int speedo_value, unsigned long max_freq);
+ size_t count, struct rail_alignment *align,
+ int process_id, int speedo_id, int speedo_value,
+ unsigned long max_freq);
void tegra_cvb_remove_opp_table(struct device *dev,
const struct cvb_table *table,
unsigned long max_freq);
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 06/21] clk: tegra: dfll: CVB calculation alignment with the regulator
2018-12-13 9:34 ` [PATCH V2 06/21] clk: tegra: dfll: CVB calculation alignment with the regulator Joseph Lo
@ 2018-12-13 11:18 ` Jon Hunter
2018-12-14 7:08 ` Joseph Lo
0 siblings, 1 reply; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 11:18 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 13/12/2018 09:34, Joseph Lo wrote:
> The CVB table contains calibration data for the CPU DFLL based on
> process characterization. The regulator step and offset parameters depend
> on the regulator supplying vdd-cpu, not on the specific Tegra SKU.
>
> When using a PWM controlled regulator, the voltage step and offset are
> determined by the regulator type in use. This is specified in DT. When
> using an I2C controlled regulator, we can retrieve them from CPU regulator
> Then pass this information to the CVB table calculation function.
>
> Based on the work done of "Peter De Schrijver <pdeschrijver@nvidia.com>"
> and "Alex Frid <afrid@nvidia.com>".
>
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - use the updated DT binding string for parsing
> - update the mechanism for geting regulator data from DT (PWM mode) or
> regulator (I2C mode)
> ---
> drivers/clk/tegra/clk-dfll.h | 6 ++-
> drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 57 ++++++++++++++++++++--
> drivers/clk/tegra/cvb.c | 12 +++--
> drivers/clk/tegra/cvb.h | 6 +--
> 4 files changed, 67 insertions(+), 14 deletions(-)
>
> diff --git a/drivers/clk/tegra/clk-dfll.h b/drivers/clk/tegra/clk-dfll.h
> index 83352c8078f2..ecc43cb9b6f1 100644
> --- a/drivers/clk/tegra/clk-dfll.h
> +++ b/drivers/clk/tegra/clk-dfll.h
> @@ -1,6 +1,6 @@
> /*
> * clk-dfll.h - prototypes and macros for the Tegra DFLL clocksource driver
> - * Copyright (C) 2013 NVIDIA Corporation. All rights reserved.
> + * Copyright (C) 2013-2018 NVIDIA Corporation. All rights reserved.
> *
> * Aleksandr Frid <afrid@nvidia.com>
> * Paul Walmsley <pwalmsley@nvidia.com>
> @@ -22,11 +22,14 @@
> #include <linux/reset.h>
> #include <linux/types.h>
>
> +#include "cvb.h"
> +
> /**
> * struct tegra_dfll_soc_data - SoC-specific hooks/integration for the DFLL driver
> * @dev: struct device * that holds the OPP table for the DFLL
> * @max_freq: maximum frequency supported on this SoC
> * @cvb: CPU frequency table for this SoC
> + * @alignment: parameters of the regulator step and offset
> * @init_clock_trimmers: callback to initialize clock trimmers
> * @set_clock_trimmers_high: callback to tune clock trimmers for high voltage
> * @set_clock_trimmers_low: callback to tune clock trimmers for low voltage
> @@ -35,6 +38,7 @@ struct tegra_dfll_soc_data {
> struct device *dev;
> unsigned long max_freq;
> const struct cvb_table *cvb;
> + struct rail_alignment alignment;
>
> void (*init_clock_trimmers)(void);
> void (*set_clock_trimmers_high)(void);
> diff --git a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
> index 1a2cc113e5c8..189b5e20ee4e 100644
> --- a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
> +++ b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
> @@ -23,6 +23,7 @@
> #include <linux/init.h>
> #include <linux/of_device.h>
> #include <linux/platform_device.h>
> +#include <linux/regulator/consumer.h>
> #include <soc/tegra/fuse.h>
>
> #include "clk.h"
> @@ -50,9 +51,6 @@ static const struct cvb_table tegra124_cpu_cvb_tables[] = {
> .process_id = -1,
> .min_millivolts = 900,
> .max_millivolts = 1260,
> - .alignment = {
> - .step_uv = 10000, /* 10mV */
> - },
> .speedo_scale = 100,
> .voltage_scale = 1000,
> .entries = {
> @@ -105,11 +103,45 @@ static const struct of_device_id tegra124_dfll_fcpu_of_match[] = {
> { },
> };
>
> +static void get_alignment_from_dt(struct device *dev,
> + struct rail_alignment *align)
> +{
> + align->step_uv = 0;
> + align->offset_uv = 0;
> +
> + if (of_property_read_u32(dev->of_node,
> + "nvidia,pwm-voltage-step-microvolts",
> + &align->step_uv))
> + align->step_uv = 0;
Not sure why it is necessary to initialise this again on failure.
> +
> + if (of_property_read_u32(dev->of_node,
> + "nvidia,pwm-min-microvolts",
> + &align->offset_uv))
> + align->offset_uv = 0;
Same here.
> +}
> +
> +static int get_alignment_from_regulator(struct device *dev,
> + struct rail_alignment *align)
> +{
> + struct regulator *reg = devm_regulator_get(dev, "vdd-cpu");
> +
> + if (IS_ERR(reg))
> + return PTR_ERR(reg);
> +
> + align->offset_uv = regulator_list_voltage(reg, 0);
> + align->step_uv = regulator_get_linear_step(reg);
> +
> + devm_regulator_put(reg);
> +
> + return 0;
> +}
> +
> static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
> {
> int process_id, speedo_id, speedo_value, err;
> struct tegra_dfll_soc_data *soc;
> const struct dfll_fcpu_data *fcpu_data;
> + struct rail_alignment align;
>
> fcpu_data = of_device_get_match_data(&pdev->dev);
> if (!fcpu_data)
> @@ -135,12 +167,27 @@ static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
> return -ENODEV;
> }
>
> + if (of_property_read_bool(pdev->dev.of_node, "nvidia,pwm-to-pmic")) {
> + get_alignment_from_dt(&pdev->dev, &align);
> + } else {
> + err = get_alignment_from_regulator(&pdev->dev, &align);
> + if (err == -EPROBE_DEFER)
> + return -EPROBE_DEFER;
Why not return any error here? The print below maybe misleading.
> + }
> +
> + if (!align.step_uv) {
> + dev_err(&pdev->dev, "missing step uv\n");
> + return -EINVAL;
> + }
> +
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 06/21] clk: tegra: dfll: CVB calculation alignment with the regulator
2018-12-13 11:18 ` Jon Hunter
@ 2018-12-14 7:08 ` Joseph Lo
0 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-14 7:08 UTC (permalink / raw)
To: Jon Hunter, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 12/13/18 7:18 PM, Jon Hunter wrote:
>
> On 13/12/2018 09:34, Joseph Lo wrote:
>> The CVB table contains calibration data for the CPU DFLL based on
>> process characterization. The regulator step and offset parameters depend
>> on the regulator supplying vdd-cpu, not on the specific Tegra SKU.
>>
>> When using a PWM controlled regulator, the voltage step and offset are
>> determined by the regulator type in use. This is specified in DT. When
>> using an I2C controlled regulator, we can retrieve them from CPU regulator
>> Then pass this information to the CVB table calculation function.
>>
>> Based on the work done of "Peter De Schrijver <pdeschrijver@nvidia.com>"
>> and "Alex Frid <afrid@nvidia.com>".
>>
>> Signed-off-by: Joseph Lo <josephl@nvidia.com>
>> ---
>> *V2:
>> - use the updated DT binding string for parsing
>> - update the mechanism for geting regulator data from DT (PWM mode) or
>> regulator (I2C mode)
>> ---
>> drivers/clk/tegra/clk-dfll.h | 6 ++-
>> drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 57 ++++++++++++++++++++--
>> drivers/clk/tegra/cvb.c | 12 +++--
>> drivers/clk/tegra/cvb.h | 6 +--
>> 4 files changed, 67 insertions(+), 14 deletions(-)
>>
>> diff --git a/drivers/clk/tegra/clk-dfll.h b/drivers/clk/tegra/clk-dfll.h
>> index 83352c8078f2..ecc43cb9b6f1 100644
>> --- a/drivers/clk/tegra/clk-dfll.h
>> +++ b/drivers/clk/tegra/clk-dfll.h
>> @@ -1,6 +1,6 @@
>> /*
>> * clk-dfll.h - prototypes and macros for the Tegra DFLL clocksource driver
>> - * Copyright (C) 2013 NVIDIA Corporation. All rights reserved.
>> + * Copyright (C) 2013-2018 NVIDIA Corporation. All rights reserved.
>> *
>> * Aleksandr Frid <afrid@nvidia.com>
>> * Paul Walmsley <pwalmsley@nvidia.com>
>> @@ -22,11 +22,14 @@
>> #include <linux/reset.h>
>> #include <linux/types.h>
>>
>> +#include "cvb.h"
>> +
>> /**
>> * struct tegra_dfll_soc_data - SoC-specific hooks/integration for the DFLL driver
>> * @dev: struct device * that holds the OPP table for the DFLL
>> * @max_freq: maximum frequency supported on this SoC
>> * @cvb: CPU frequency table for this SoC
>> + * @alignment: parameters of the regulator step and offset
>> * @init_clock_trimmers: callback to initialize clock trimmers
>> * @set_clock_trimmers_high: callback to tune clock trimmers for high voltage
>> * @set_clock_trimmers_low: callback to tune clock trimmers for low voltage
>> @@ -35,6 +38,7 @@ struct tegra_dfll_soc_data {
>> struct device *dev;
>> unsigned long max_freq;
>> const struct cvb_table *cvb;
>> + struct rail_alignment alignment;
>>
>> void (*init_clock_trimmers)(void);
>> void (*set_clock_trimmers_high)(void);
>> diff --git a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
>> index 1a2cc113e5c8..189b5e20ee4e 100644
>> --- a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
>> +++ b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
>> @@ -23,6 +23,7 @@
>> #include <linux/init.h>
>> #include <linux/of_device.h>
>> #include <linux/platform_device.h>
>> +#include <linux/regulator/consumer.h>
>> #include <soc/tegra/fuse.h>
>>
>> #include "clk.h"
>> @@ -50,9 +51,6 @@ static const struct cvb_table tegra124_cpu_cvb_tables[] = {
>> .process_id = -1,
>> .min_millivolts = 900,
>> .max_millivolts = 1260,
>> - .alignment = {
>> - .step_uv = 10000, /* 10mV */
>> - },
>> .speedo_scale = 100,
>> .voltage_scale = 1000,
>> .entries = {
>> @@ -105,11 +103,45 @@ static const struct of_device_id tegra124_dfll_fcpu_of_match[] = {
>> { },
>> };
>>
>> +static void get_alignment_from_dt(struct device *dev,
>> + struct rail_alignment *align)
>> +{
>> + align->step_uv = 0;
>> + align->offset_uv = 0;
>> +
>> + if (of_property_read_u32(dev->of_node,
>> + "nvidia,pwm-voltage-step-microvolts",
>> + &align->step_uv))
>> + align->step_uv = 0;
>
> Not sure why it is necessary to initialise this again on failure.
Indeed, it's not necessary. Will remove two lines above.
>
>> +
>> + if (of_property_read_u32(dev->of_node,
>> + "nvidia,pwm-min-microvolts",
>> + &align->offset_uv))
>> + align->offset_uv = 0;
>
> Same here.
>
>> +}
>> +
>> +static int get_alignment_from_regulator(struct device *dev,
>> + struct rail_alignment *align)
>> +{
>> + struct regulator *reg = devm_regulator_get(dev, "vdd-cpu");
>> +
>> + if (IS_ERR(reg))
>> + return PTR_ERR(reg);
>> +
>> + align->offset_uv = regulator_list_voltage(reg, 0);
>> + align->step_uv = regulator_get_linear_step(reg);
>> +
>> + devm_regulator_put(reg);
>> +
>> + return 0;
>> +}
>> +
>> static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
>> {
>> int process_id, speedo_id, speedo_value, err;
>> struct tegra_dfll_soc_data *soc;
>> const struct dfll_fcpu_data *fcpu_data;
>> + struct rail_alignment align;
>>
>> fcpu_data = of_device_get_match_data(&pdev->dev);
>> if (!fcpu_data)
>> @@ -135,12 +167,27 @@ static int tegra124_dfll_fcpu_probe(struct platform_device *pdev)
>> return -ENODEV;
>> }
>>
>> + if (of_property_read_bool(pdev->dev.of_node, "nvidia,pwm-to-pmic")) {
>> + get_alignment_from_dt(&pdev->dev, &align);
>> + } else {
>> + err = get_alignment_from_regulator(&pdev->dev, &align);
>> + if (err == -EPROBE_DEFER)
>> + return -EPROBE_DEFER;
>
> Why not return any error here? The print below maybe misleading.
Okay, that should be fine. Will fix. Thanks.
Joseph
>
>> + }
>> +
>> + if (!align.step_uv) {
>> + dev_err(&pdev->dev, "missing step uv\n");
>> + return -EINVAL;
>> + }
>> +
>
> Cheers
> Jon
>
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 07/21] clk: tegra: dfll: support PWM regulator control
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (5 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 06/21] clk: tegra: dfll: CVB calculation alignment with the regulator Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 11:41 ` Jon Hunter
2018-12-13 9:34 ` [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment Joseph Lo
` (13 subsequent siblings)
20 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
The DFLL hardware supports two modes (I2C and PWM) for voltage control
when requesting a frequency. In this patch, we introduce PWM mode support.
To support that, we re-organize the LUT for unifying the table for both
cases of I2C and PWM mode. And generate that based on regulator info.
For the PWM-based regulator, we get this info from DT. And do the same as
the case of I2C LUT, which can help to map the PMIC voltage ID and voltages
that the regulator supported.
The other parts are the support code for initializing the DFLL hardware
to support PWM mode. Also, the register debugfs file is slightly
reworked to only show the i2c registers when I2C mode is in use.
Based on the work of Peter De Schrijver <pdeschrijver@nvidia.com>.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- move reg_init_uV to be with the PWM related variables
- fix the variable type to 'unsigned long' if it needs to catch the
return value from 'dev_pm_opp_get_voltage'
- update to use lut_uv table for LUT look up. This makes the generic
lut_uv table to work with both PWM and I2C mode.
---
drivers/clk/tegra/clk-dfll.c | 435 +++++++++++++++++++++++++++++------
1 file changed, 369 insertions(+), 66 deletions(-)
diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
index 609e363dabf8..72e02898006c 100644
--- a/drivers/clk/tegra/clk-dfll.c
+++ b/drivers/clk/tegra/clk-dfll.c
@@ -1,7 +1,7 @@
/*
* clk-dfll.c - Tegra DFLL clock source common code
*
- * Copyright (C) 2012-2014 NVIDIA Corporation. All rights reserved.
+ * Copyright (C) 2012-2018 NVIDIA Corporation. All rights reserved.
*
* Aleksandr Frid <afrid@nvidia.com>
* Paul Walmsley <pwalmsley@nvidia.com>
@@ -47,6 +47,7 @@
#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/of.h>
+#include <linux/pinctrl/consumer.h>
#include <linux/pm_opp.h>
#include <linux/pm_runtime.h>
#include <linux/regmap.h>
@@ -243,6 +244,12 @@ enum dfll_tune_range {
DFLL_TUNE_LOW = 1,
};
+
+enum tegra_dfll_pmu_if {
+ TEGRA_DFLL_PMU_I2C = 0,
+ TEGRA_DFLL_PMU_PWM = 1,
+};
+
/**
* struct dfll_rate_req - target DFLL rate request data
* @rate: target frequency, after the postscaling
@@ -300,10 +307,19 @@ struct tegra_dfll {
u32 i2c_reg;
u32 i2c_slave_addr;
- /* i2c_lut array entries are regulator framework selectors */
- unsigned i2c_lut[MAX_DFLL_VOLTAGES];
- int i2c_lut_size;
- u8 lut_min, lut_max, lut_safe;
+ /* lut array entries are regulator framework selectors or PWM values*/
+ unsigned lut[MAX_DFLL_VOLTAGES];
+ unsigned long lut_uv[MAX_DFLL_VOLTAGES];
+ int lut_size;
+ u8 lut_bottom, lut_min, lut_max, lut_safe;
+
+ /* PWM interface */
+ enum tegra_dfll_pmu_if pmu_if;
+ unsigned long pwm_rate;
+ struct pinctrl *pwm_pin;
+ struct pinctrl_state *pwm_enable_state;
+ struct pinctrl_state *pwm_disable_state;
+ u32 reg_init_uV;
};
#define clk_hw_to_dfll(_hw) container_of(_hw, struct tegra_dfll, dfll_clk_hw)
@@ -489,6 +505,34 @@ static void dfll_set_mode(struct tegra_dfll *td,
dfll_wmb(td);
}
+/*
+ * DVCO rate control
+ */
+
+static unsigned long get_dvco_rate_below(struct tegra_dfll *td, u8 out_min)
+{
+ struct dev_pm_opp *opp;
+ unsigned long rate, prev_rate;
+ unsigned long uv, min_uv;
+
+ min_uv = td->lut_uv[out_min];
+ for (rate = 0, prev_rate = 0; ; rate++) {
+ opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
+ if (IS_ERR(opp))
+ break;
+
+ uv = dev_pm_opp_get_voltage(opp);
+ dev_pm_opp_put(opp);
+
+ if (uv && uv > min_uv)
+ return prev_rate;
+
+ prev_rate = rate;
+ }
+
+ return prev_rate;
+}
+
/*
* DFLL-to-I2C controller interface
*/
@@ -518,6 +562,118 @@ static int dfll_i2c_set_output_enabled(struct tegra_dfll *td, bool enable)
return 0;
}
+
+/*
+ * DFLL-to-PWM controller interface
+ */
+
+/**
+ * dfll_pwm_set_output_enabled - enable/disable PWM voltage requests
+ * @td: DFLL instance
+ * @enable: whether to enable or disable the PWM voltage requests
+ *
+ * Set the master enable control for PWM control value updates. If disabled,
+ * then the PWM signal is not driven. Also configure the PWM output pad
+ * to the appropriate state.
+ */
+static int dfll_pwm_set_output_enabled(struct tegra_dfll *td, bool enable)
+{
+ int ret;
+ u32 val, div;
+
+ if (enable) {
+ ret = pinctrl_select_state(td->pwm_pin, td->pwm_enable_state);
+ if (ret < 0) {
+ dev_err(td->dev, "setting enable state failed\n");
+ return -EINVAL;
+ }
+ val = dfll_readl(td, DFLL_OUTPUT_CFG);
+ val &= ~DFLL_OUTPUT_CFG_PWM_DIV_MASK;
+ div = DIV_ROUND_UP(td->ref_rate, td->pwm_rate);
+ val |= (div << DFLL_OUTPUT_CFG_PWM_DIV_SHIFT)
+ & DFLL_OUTPUT_CFG_PWM_DIV_MASK;
+ dfll_writel(td, val, DFLL_OUTPUT_CFG);
+ dfll_wmb(td);
+
+ val |= DFLL_OUTPUT_CFG_PWM_ENABLE;
+ dfll_writel(td, val, DFLL_OUTPUT_CFG);
+ dfll_wmb(td);
+ } else {
+ ret = pinctrl_select_state(td->pwm_pin, td->pwm_disable_state);
+ if (ret < 0)
+ dev_warn(td->dev, "setting disable state failed\n");
+
+ val = dfll_readl(td, DFLL_OUTPUT_CFG);
+ val &= ~DFLL_OUTPUT_CFG_PWM_ENABLE;
+ dfll_writel(td, val, DFLL_OUTPUT_CFG);
+ dfll_wmb(td);
+ }
+
+ return 0;
+}
+
+/**
+ * dfll_set_force_output_value - set fixed value for force output
+ * @td: DFLL instance
+ * @out_val: value to force output
+ *
+ * Set the fixed value for force output, DFLL will output this value when
+ * force output is enabled.
+ */
+static u32 dfll_set_force_output_value(struct tegra_dfll *td, u8 out_val)
+{
+ u32 val = dfll_readl(td, DFLL_OUTPUT_FORCE);
+
+ val = (val & DFLL_OUTPUT_FORCE_ENABLE) | (out_val & OUT_MASK);
+ dfll_writel(td, val, DFLL_OUTPUT_FORCE);
+ dfll_wmb(td);
+
+ return dfll_readl(td, DFLL_OUTPUT_FORCE);
+}
+
+/**
+ * dfll_set_force_output_enabled - enable/disable force output
+ * @td: DFLL instance
+ * @enable: whether to enable or disable the force output
+ *
+ * Set the enable control for fouce output with fixed value.
+ */
+static void dfll_set_force_output_enabled(struct tegra_dfll *td, bool enable)
+{
+ u32 val = dfll_readl(td, DFLL_OUTPUT_FORCE);
+
+ if (enable)
+ val |= DFLL_OUTPUT_FORCE_ENABLE;
+ else
+ val &= ~DFLL_OUTPUT_FORCE_ENABLE;
+
+ dfll_writel(td, val, DFLL_OUTPUT_FORCE);
+ dfll_wmb(td);
+}
+
+/**
+ * dfll_force_output - force output a fixed value
+ * @td: DFLL instance
+ * @out_sel: value to force output
+ *
+ * Set the fixed value for force output, DFLL will output this value.
+ */
+static int dfll_force_output(struct tegra_dfll *td, unsigned int out_sel)
+{
+ u32 val;
+
+ if (out_sel > OUT_MASK)
+ return -EINVAL;
+
+ val = dfll_set_force_output_value(td, out_sel);
+ if ((td->mode < DFLL_CLOSED_LOOP) &&
+ !(val & DFLL_OUTPUT_FORCE_ENABLE)) {
+ dfll_set_force_output_enabled(td, true);
+ }
+
+ return 0;
+}
+
/**
* dfll_load_lut - load the voltage lookup table
* @td: struct tegra_dfll *
@@ -539,7 +695,7 @@ static void dfll_load_i2c_lut(struct tegra_dfll *td)
lut_index = i;
val = regulator_list_hardware_vsel(td->vdd_reg,
- td->i2c_lut[lut_index]);
+ td->lut[lut_index]);
__raw_writel(val, td->lut_base + i * 4);
}
@@ -594,24 +750,41 @@ static void dfll_init_out_if(struct tegra_dfll *td)
{
u32 val;
- td->lut_min = 0;
- td->lut_max = td->i2c_lut_size - 1;
- td->lut_safe = td->lut_min + 1;
+ td->lut_min = td->lut_bottom;
+ td->lut_max = td->lut_size - 1;
+ td->lut_safe = td->lut_min + (td->lut_min < td->lut_max ? 1 : 0);
+
+ /* clear DFLL_OUTPUT_CFG before setting new value */
+ dfll_writel(td, 0, DFLL_OUTPUT_CFG);
+ dfll_wmb(td);
- dfll_i2c_writel(td, 0, DFLL_OUTPUT_CFG);
val = (td->lut_safe << DFLL_OUTPUT_CFG_SAFE_SHIFT) |
- (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) |
- (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT);
- dfll_i2c_writel(td, val, DFLL_OUTPUT_CFG);
- dfll_i2c_wmb(td);
+ (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) |
+ (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT);
+ dfll_writel(td, val, DFLL_OUTPUT_CFG);
+ dfll_wmb(td);
dfll_writel(td, 0, DFLL_OUTPUT_FORCE);
dfll_i2c_writel(td, 0, DFLL_INTR_EN);
dfll_i2c_writel(td, DFLL_INTR_MAX_MASK | DFLL_INTR_MIN_MASK,
DFLL_INTR_STS);
- dfll_load_i2c_lut(td);
- dfll_init_i2c_if(td);
+ if (td->pmu_if == TEGRA_DFLL_PMU_PWM) {
+ int vinit = td->reg_init_uV;
+ int vstep = td->soc->alignment.step_uv;
+ int vmin = td->lut_uv[0];
+
+ /* set initial voltage */
+ if ((vinit >= vmin) && vstep) {
+ unsigned int vsel;
+
+ vsel = DIV_ROUND_UP((vinit - vmin), vstep);
+ dfll_force_output(td, vsel);
+ }
+ } else {
+ dfll_load_i2c_lut(td);
+ dfll_init_i2c_if(td);
+ }
}
/*
@@ -640,8 +813,8 @@ static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate)
uv = dev_pm_opp_get_voltage(opp);
dev_pm_opp_put(opp);
- for (i = 0; i < td->i2c_lut_size; i++) {
- if (regulator_list_voltage(td->vdd_reg, td->i2c_lut[i]) == uv)
+ for (i = td->lut_bottom; i < td->lut_size; i++) {
+ if (td->lut_uv[i] >= uv)
return i;
}
@@ -863,9 +1036,14 @@ static int dfll_lock(struct tegra_dfll *td)
return -EINVAL;
}
- dfll_i2c_set_output_enabled(td, true);
+ if (td->pmu_if == TEGRA_DFLL_PMU_PWM)
+ dfll_pwm_set_output_enabled(td, true);
+ else
+ dfll_i2c_set_output_enabled(td, true);
+
dfll_set_mode(td, DFLL_CLOSED_LOOP);
dfll_set_frequency_request(td, req);
+ dfll_set_force_output_enabled(td, false);
return 0;
default:
@@ -889,7 +1067,10 @@ static int dfll_unlock(struct tegra_dfll *td)
case DFLL_CLOSED_LOOP:
dfll_set_open_loop_config(td);
dfll_set_mode(td, DFLL_OPEN_LOOP);
- dfll_i2c_set_output_enabled(td, false);
+ if (td->pmu_if == TEGRA_DFLL_PMU_PWM)
+ dfll_pwm_set_output_enabled(td, false);
+ else
+ dfll_i2c_set_output_enabled(td, false);
return 0;
case DFLL_OPEN_LOOP:
@@ -1171,15 +1352,17 @@ static int attr_registers_show(struct seq_file *s, void *data)
seq_printf(s, "[0x%02x] = 0x%08x\n", offs,
dfll_i2c_readl(td, offs));
- seq_puts(s, "\nINTEGRATED I2C CONTROLLER REGISTERS:\n");
- offs = DFLL_I2C_CLK_DIVISOR;
- seq_printf(s, "[0x%02x] = 0x%08x\n", offs,
- __raw_readl(td->i2c_controller_base + offs));
-
- seq_puts(s, "\nLUT:\n");
- for (offs = 0; offs < 4 * MAX_DFLL_VOLTAGES; offs += 4)
+ if (td->pmu_if == TEGRA_DFLL_PMU_I2C) {
+ seq_puts(s, "\nINTEGRATED I2C CONTROLLER REGISTERS:\n");
+ offs = DFLL_I2C_CLK_DIVISOR;
seq_printf(s, "[0x%02x] = 0x%08x\n", offs,
- __raw_readl(td->lut_base + offs));
+ __raw_readl(td->i2c_controller_base + offs));
+
+ seq_puts(s, "\nLUT:\n");
+ for (offs = 0; offs < 4 * MAX_DFLL_VOLTAGES; offs += 4)
+ seq_printf(s, "[0x%02x] = 0x%08x\n", offs,
+ __raw_readl(td->lut_base + offs));
+ }
return 0;
}
@@ -1387,9 +1570,61 @@ static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV)
return -EINVAL;
}
+/*
+ * dfll_build_pwm_lut - build the PWM regulator lookup table
+ * @td: DFLL instance
+ * @v_max: Vmax from OPP table
+ *
+ * Look-up table in h/w is ignored when PWM is used as DFLL interface to PMIC.
+ * In this case closed loop output is controlling duty cycle directly. The s/w
+ * look-up that maps PWM duty cycle to voltage is still built by this function.
+ */
+static int dfll_build_pwm_lut(struct tegra_dfll *td, unsigned long v_max)
+{
+ int i;
+ unsigned long rate, reg_volt;
+ u8 lut_bottom = MAX_DFLL_VOLTAGES;
+ int v_min = td->soc->cvb->min_millivolts * 1000;
+
+ for (i = 0; i < MAX_DFLL_VOLTAGES; i++) {
+ reg_volt = td->lut_uv[i];
+
+ /* since opp voltage is exact mv */
+ reg_volt = (reg_volt / 1000) * 1000;
+ if (reg_volt > v_max)
+ break;
+
+ td->lut[i] = i;
+ if ((lut_bottom == MAX_DFLL_VOLTAGES) && (reg_volt >= v_min))
+ lut_bottom = i;
+ }
+
+ /* determine voltage boundaries */
+ td->lut_size = i;
+ if ((lut_bottom == MAX_DFLL_VOLTAGES) ||
+ (lut_bottom + 1 >= td->lut_size)) {
+ dev_err(td->dev, "no voltage above DFLL minimum %d mV\n",
+ td->soc->cvb->min_millivolts);
+ return -EINVAL;
+ }
+ td->lut_bottom = lut_bottom;
+
+ /* determine rate boundaries */
+ rate = get_dvco_rate_below(td, td->lut_bottom);
+ if (!rate) {
+ dev_err(td->dev, "no opp below DFLL minimum voltage %d mV\n",
+ td->soc->cvb->min_millivolts);
+ return -EINVAL;
+ }
+ td->dvco_rate_min = rate;
+
+ return 0;
+}
+
/**
* dfll_build_i2c_lut - build the I2C voltage register lookup table
* @td: DFLL instance
+ * @v_max: Vmax from OPP table
*
* The DFLL hardware has 33 bytes of look-up table RAM that must be filled with
* PMIC voltage register values that span the entire DFLL operating range.
@@ -1397,33 +1632,24 @@ static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV)
* the soc-specific platform driver (td->soc->opp_dev) and the PMIC
* register-to-voltage mapping queried from the regulator framework.
*
- * On success, fills in td->i2c_lut and returns 0, or -err on failure.
+ * On success, fills in td->lut and returns 0, or -err on failure.
*/
-static int dfll_build_i2c_lut(struct tegra_dfll *td)
+static int dfll_build_i2c_lut(struct tegra_dfll *td, unsigned long v_max)
{
+ unsigned long rate, v, v_opp;
int ret = -EINVAL;
- int j, v, v_max, v_opp;
- int selector;
- unsigned long rate;
- struct dev_pm_opp *opp;
- int lut;
-
- rate = ULONG_MAX;
- opp = dev_pm_opp_find_freq_floor(td->soc->dev, &rate);
- if (IS_ERR(opp)) {
- dev_err(td->dev, "couldn't get vmax opp, empty opp table?\n");
- goto out;
- }
- v_max = dev_pm_opp_get_voltage(opp);
- dev_pm_opp_put(opp);
+ int j, selector, lut;
v = td->soc->cvb->min_millivolts * 1000;
lut = find_vdd_map_entry_exact(td, v);
if (lut < 0)
goto out;
- td->i2c_lut[0] = lut;
+ td->lut[0] = lut;
+ td->lut_bottom = 0;
for (j = 1, rate = 0; ; rate++) {
+ struct dev_pm_opp *opp;
+
opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
if (IS_ERR(opp))
break;
@@ -1435,39 +1661,64 @@ static int dfll_build_i2c_lut(struct tegra_dfll *td)
dev_pm_opp_put(opp);
for (;;) {
- v += max(1, (v_max - v) / (MAX_DFLL_VOLTAGES - j));
+ v += max(1UL, (v_max - v) / (MAX_DFLL_VOLTAGES - j));
if (v >= v_opp)
break;
selector = find_vdd_map_entry_min(td, v);
if (selector < 0)
goto out;
- if (selector != td->i2c_lut[j - 1])
- td->i2c_lut[j++] = selector;
+ if (selector != td->lut[j - 1])
+ td->lut[j++] = selector;
}
v = (j == MAX_DFLL_VOLTAGES - 1) ? v_max : v_opp;
selector = find_vdd_map_entry_exact(td, v);
if (selector < 0)
goto out;
- if (selector != td->i2c_lut[j - 1])
- td->i2c_lut[j++] = selector;
+ if (selector != td->lut[j - 1])
+ td->lut[j++] = selector;
if (v >= v_max)
break;
}
- td->i2c_lut_size = j;
+ td->lut_size = j;
if (!td->dvco_rate_min)
dev_err(td->dev, "no opp above DFLL minimum voltage %d mV\n",
td->soc->cvb->min_millivolts);
- else
+ else {
ret = 0;
+ for (j = 0; j < td->lut_size; j++)
+ td->lut_uv[j] =
+ regulator_list_voltage(td->vdd_reg,
+ td->lut[j]);
+ }
out:
return ret;
}
+static int dfll_build_lut(struct tegra_dfll *td)
+{
+ unsigned long rate, v_max;
+ struct dev_pm_opp *opp;
+
+ rate = ULONG_MAX;
+ opp = dev_pm_opp_find_freq_floor(td->soc->dev, &rate);
+ if (IS_ERR(opp)) {
+ dev_err(td->dev, "couldn't get vmax opp, empty opp table?\n");
+ return -EINVAL;
+ }
+ v_max = dev_pm_opp_get_voltage(opp);
+ dev_pm_opp_put(opp);
+
+ if (td->pmu_if == TEGRA_DFLL_PMU_PWM)
+ return dfll_build_pwm_lut(td, v_max);
+ else
+ return dfll_build_i2c_lut(td, v_max);
+}
+
/**
* read_dt_param - helper function for reading required parameters from the DT
* @td: DFLL instance
@@ -1526,11 +1777,56 @@ static int dfll_fetch_i2c_params(struct tegra_dfll *td)
}
td->i2c_reg = vsel_reg;
- ret = dfll_build_i2c_lut(td);
- if (ret) {
- dev_err(td->dev, "couldn't build I2C LUT\n");
+ return 0;
+}
+
+static int dfll_fetch_pwm_params(struct tegra_dfll *td)
+{
+ int ret, i;
+ u32 pwm_period;
+
+ if (!td->soc->alignment.step_uv || !td->soc->alignment.offset_uv) {
+ dev_err(td->dev,
+ "Missing step or alignment info for PWM regulator");
+ return -EINVAL;
+ }
+ for (i = 0; i < MAX_DFLL_VOLTAGES; i++)
+ td->lut_uv[i] = td->soc->alignment.offset_uv +
+ i * td->soc->alignment.step_uv;
+
+ ret = read_dt_param(td, "nvidia,pwm-tristate-microvolts",
+ &td->reg_init_uV);
+ if (!ret) {
+ dev_err(td->dev, "couldn't get initialized voltage\n");
+ return ret;
+ }
+
+ ret = read_dt_param(td, "nvidia,pwm-period", &pwm_period);
+ if (!ret) {
+ dev_err(td->dev, "couldn't get PWM period\n");
return ret;
}
+ td->pwm_rate = (NSEC_PER_SEC / pwm_period) * (MAX_DFLL_VOLTAGES - 1);
+
+ td->pwm_pin = devm_pinctrl_get(td->dev);
+ if (IS_ERR(td->pwm_pin)) {
+ dev_err(td->dev, "DT: missing pinctrl device\n");
+ return PTR_ERR(td->pwm_pin);
+ }
+
+ td->pwm_enable_state = pinctrl_lookup_state(td->pwm_pin,
+ "dvfs_pwm_enable");
+ if (IS_ERR(td->pwm_enable_state)) {
+ dev_err(td->dev, "DT: missing pwm enabled state\n");
+ return PTR_ERR(td->pwm_enable_state);
+ }
+
+ td->pwm_disable_state = pinctrl_lookup_state(td->pwm_pin,
+ "dvfs_pwm_disable");
+ if (IS_ERR(td->pwm_disable_state)) {
+ dev_err(td->dev, "DT: missing pwm disabled state\n");
+ return PTR_ERR(td->pwm_disable_state);
+ }
return 0;
}
@@ -1597,16 +1893,6 @@ int tegra_dfll_register(struct platform_device *pdev,
td->soc = soc;
- td->vdd_reg = devm_regulator_get(td->dev, "vdd-cpu");
- if (IS_ERR(td->vdd_reg)) {
- ret = PTR_ERR(td->vdd_reg);
- if (ret != -EPROBE_DEFER)
- dev_err(td->dev, "couldn't get vdd_cpu regulator: %d\n",
- ret);
-
- return ret;
- }
-
td->dvco_rst = devm_reset_control_get(td->dev, "dvco");
if (IS_ERR(td->dvco_rst)) {
dev_err(td->dev, "couldn't get dvco reset\n");
@@ -1619,10 +1905,27 @@ int tegra_dfll_register(struct platform_device *pdev,
return ret;
}
- ret = dfll_fetch_i2c_params(td);
+ if (of_property_read_bool(td->dev->of_node, "nvidia,pwm-to-pmic")) {
+ td->pmu_if = TEGRA_DFLL_PMU_PWM;
+ ret = dfll_fetch_pwm_params(td);
+ } else {
+ td->vdd_reg = devm_regulator_get(td->dev, "vdd-cpu");
+ if (IS_ERR(td->vdd_reg)) {
+ dev_err(td->dev, "couldn't get vdd_cpu regulator\n");
+ return PTR_ERR(td->vdd_reg);
+ }
+ td->pmu_if = TEGRA_DFLL_PMU_I2C;
+ ret = dfll_fetch_i2c_params(td);
+ }
if (ret)
return ret;
+ ret = dfll_build_lut(td);
+ if (ret) {
+ dev_err(td->dev, "couldn't build LUT\n");
+ return ret;
+ }
+
mem = platform_get_resource(pdev, IORESOURCE_MEM, 0);
if (!mem) {
dev_err(td->dev, "no control register resource\n");
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 07/21] clk: tegra: dfll: support PWM regulator control
2018-12-13 9:34 ` [PATCH V2 07/21] clk: tegra: dfll: support PWM regulator control Joseph Lo
@ 2018-12-13 11:41 ` Jon Hunter
2018-12-14 7:11 ` Joseph Lo
0 siblings, 1 reply; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 11:41 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 13/12/2018 09:34, Joseph Lo wrote:
> The DFLL hardware supports two modes (I2C and PWM) for voltage control
> when requesting a frequency. In this patch, we introduce PWM mode support.
>
> To support that, we re-organize the LUT for unifying the table for both
> cases of I2C and PWM mode. And generate that based on regulator info.
> For the PWM-based regulator, we get this info from DT. And do the same as
> the case of I2C LUT, which can help to map the PMIC voltage ID and voltages
> that the regulator supported.
>
> The other parts are the support code for initializing the DFLL hardware
> to support PWM mode. Also, the register debugfs file is slightly
> reworked to only show the i2c registers when I2C mode is in use.
>
> Based on the work of Peter De Schrijver <pdeschrijver@nvidia.com>.
>
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - move reg_init_uV to be with the PWM related variables
> - fix the variable type to 'unsigned long' if it needs to catch the
> return value from 'dev_pm_opp_get_voltage'
> - update to use lut_uv table for LUT look up. This makes the generic
> lut_uv table to work with both PWM and I2C mode.
> ---
> drivers/clk/tegra/clk-dfll.c | 435 +++++++++++++++++++++++++++++------
> 1 file changed, 369 insertions(+), 66 deletions(-)
>
> diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
> index 609e363dabf8..72e02898006c 100644
> --- a/drivers/clk/tegra/clk-dfll.c
> +++ b/drivers/clk/tegra/clk-dfll.c
> @@ -1,7 +1,7 @@
> /*
> * clk-dfll.c - Tegra DFLL clock source common code
> *
> - * Copyright (C) 2012-2014 NVIDIA Corporation. All rights reserved.
> + * Copyright (C) 2012-2018 NVIDIA Corporation. All rights reserved.
> *
> * Aleksandr Frid <afrid@nvidia.com>
> * Paul Walmsley <pwalmsley@nvidia.com>
> @@ -47,6 +47,7 @@
> #include <linux/kernel.h>
> #include <linux/module.h>
> #include <linux/of.h>
> +#include <linux/pinctrl/consumer.h>
> #include <linux/pm_opp.h>
> #include <linux/pm_runtime.h>
> #include <linux/regmap.h>
> @@ -243,6 +244,12 @@ enum dfll_tune_range {
> DFLL_TUNE_LOW = 1,
> };
>
> +
> +enum tegra_dfll_pmu_if {
> + TEGRA_DFLL_PMU_I2C = 0,
> + TEGRA_DFLL_PMU_PWM = 1,
> +};
> +
> /**
> * struct dfll_rate_req - target DFLL rate request data
> * @rate: target frequency, after the postscaling
> @@ -300,10 +307,19 @@ struct tegra_dfll {
> u32 i2c_reg;
> u32 i2c_slave_addr;
>
> - /* i2c_lut array entries are regulator framework selectors */
> - unsigned i2c_lut[MAX_DFLL_VOLTAGES];
> - int i2c_lut_size;
> - u8 lut_min, lut_max, lut_safe;
> + /* lut array entries are regulator framework selectors or PWM values*/
> + unsigned lut[MAX_DFLL_VOLTAGES];
> + unsigned long lut_uv[MAX_DFLL_VOLTAGES];
> + int lut_size;
> + u8 lut_bottom, lut_min, lut_max, lut_safe;
> +
> + /* PWM interface */
> + enum tegra_dfll_pmu_if pmu_if;
> + unsigned long pwm_rate;
> + struct pinctrl *pwm_pin;
> + struct pinctrl_state *pwm_enable_state;
> + struct pinctrl_state *pwm_disable_state;
> + u32 reg_init_uV;
> };
>
> #define clk_hw_to_dfll(_hw) container_of(_hw, struct tegra_dfll, dfll_clk_hw)
> @@ -489,6 +505,34 @@ static void dfll_set_mode(struct tegra_dfll *td,
> dfll_wmb(td);
> }
>
> +/*
> + * DVCO rate control
> + */
> +
> +static unsigned long get_dvco_rate_below(struct tegra_dfll *td, u8 out_min)
> +{
> + struct dev_pm_opp *opp;
> + unsigned long rate, prev_rate;
> + unsigned long uv, min_uv;
> +
> + min_uv = td->lut_uv[out_min];
> + for (rate = 0, prev_rate = 0; ; rate++) {
> + opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
> + if (IS_ERR(opp))
> + break;
> +
> + uv = dev_pm_opp_get_voltage(opp);
> + dev_pm_opp_put(opp);
> +
> + if (uv && uv > min_uv)
> + return prev_rate;
> +
> + prev_rate = rate;
> + }
> +
> + return prev_rate;
> +}
> +
> /*
> * DFLL-to-I2C controller interface
> */
> @@ -518,6 +562,118 @@ static int dfll_i2c_set_output_enabled(struct tegra_dfll *td, bool enable)
> return 0;
> }
>
> +
> +/*
> + * DFLL-to-PWM controller interface
> + */
> +
> +/**
> + * dfll_pwm_set_output_enabled - enable/disable PWM voltage requests
> + * @td: DFLL instance
> + * @enable: whether to enable or disable the PWM voltage requests
> + *
> + * Set the master enable control for PWM control value updates. If disabled,
> + * then the PWM signal is not driven. Also configure the PWM output pad
> + * to the appropriate state.
> + */
> +static int dfll_pwm_set_output_enabled(struct tegra_dfll *td, bool enable)
> +{
> + int ret;
> + u32 val, div;
> +
> + if (enable) {
> + ret = pinctrl_select_state(td->pwm_pin, td->pwm_enable_state);
> + if (ret < 0) {
> + dev_err(td->dev, "setting enable state failed\n");
> + return -EINVAL;
> + }
> + val = dfll_readl(td, DFLL_OUTPUT_CFG);
> + val &= ~DFLL_OUTPUT_CFG_PWM_DIV_MASK;
> + div = DIV_ROUND_UP(td->ref_rate, td->pwm_rate);
> + val |= (div << DFLL_OUTPUT_CFG_PWM_DIV_SHIFT)
> + & DFLL_OUTPUT_CFG_PWM_DIV_MASK;
> + dfll_writel(td, val, DFLL_OUTPUT_CFG);
> + dfll_wmb(td);
> +
> + val |= DFLL_OUTPUT_CFG_PWM_ENABLE;
> + dfll_writel(td, val, DFLL_OUTPUT_CFG);
> + dfll_wmb(td);
> + } else {
> + ret = pinctrl_select_state(td->pwm_pin, td->pwm_disable_state);
> + if (ret < 0)
> + dev_warn(td->dev, "setting disable state failed\n");
> +
> + val = dfll_readl(td, DFLL_OUTPUT_CFG);
> + val &= ~DFLL_OUTPUT_CFG_PWM_ENABLE;
> + dfll_writel(td, val, DFLL_OUTPUT_CFG);
> + dfll_wmb(td);
> + }
> +
> + return 0;
> +}
> +
> +/**
> + * dfll_set_force_output_value - set fixed value for force output
> + * @td: DFLL instance
> + * @out_val: value to force output
> + *
> + * Set the fixed value for force output, DFLL will output this value when
> + * force output is enabled.
> + */
> +static u32 dfll_set_force_output_value(struct tegra_dfll *td, u8 out_val)
> +{
> + u32 val = dfll_readl(td, DFLL_OUTPUT_FORCE);
> +
> + val = (val & DFLL_OUTPUT_FORCE_ENABLE) | (out_val & OUT_MASK);
> + dfll_writel(td, val, DFLL_OUTPUT_FORCE);
> + dfll_wmb(td);
> +
> + return dfll_readl(td, DFLL_OUTPUT_FORCE);
> +}
> +
> +/**
> + * dfll_set_force_output_enabled - enable/disable force output
> + * @td: DFLL instance
> + * @enable: whether to enable or disable the force output
> + *
> + * Set the enable control for fouce output with fixed value.
> + */
> +static void dfll_set_force_output_enabled(struct tegra_dfll *td, bool enable)
> +{
> + u32 val = dfll_readl(td, DFLL_OUTPUT_FORCE);
> +
> + if (enable)
> + val |= DFLL_OUTPUT_FORCE_ENABLE;
> + else
> + val &= ~DFLL_OUTPUT_FORCE_ENABLE;
> +
> + dfll_writel(td, val, DFLL_OUTPUT_FORCE);
> + dfll_wmb(td);
> +}
> +
> +/**
> + * dfll_force_output - force output a fixed value
> + * @td: DFLL instance
> + * @out_sel: value to force output
> + *
> + * Set the fixed value for force output, DFLL will output this value.
> + */
> +static int dfll_force_output(struct tegra_dfll *td, unsigned int out_sel)
> +{
> + u32 val;
> +
> + if (out_sel > OUT_MASK)
> + return -EINVAL;
> +
> + val = dfll_set_force_output_value(td, out_sel);
> + if ((td->mode < DFLL_CLOSED_LOOP) &&
> + !(val & DFLL_OUTPUT_FORCE_ENABLE)) {
> + dfll_set_force_output_enabled(td, true);
> + }
> +
> + return 0;
> +}
> +
> /**
> * dfll_load_lut - load the voltage lookup table
> * @td: struct tegra_dfll *
> @@ -539,7 +695,7 @@ static void dfll_load_i2c_lut(struct tegra_dfll *td)
> lut_index = i;
>
> val = regulator_list_hardware_vsel(td->vdd_reg,
> - td->i2c_lut[lut_index]);
> + td->lut[lut_index]);
> __raw_writel(val, td->lut_base + i * 4);
> }
>
> @@ -594,24 +750,41 @@ static void dfll_init_out_if(struct tegra_dfll *td)
> {
> u32 val;
>
> - td->lut_min = 0;
> - td->lut_max = td->i2c_lut_size - 1;
> - td->lut_safe = td->lut_min + 1;
> + td->lut_min = td->lut_bottom;
> + td->lut_max = td->lut_size - 1;
> + td->lut_safe = td->lut_min + (td->lut_min < td->lut_max ? 1 : 0);
> +
> + /* clear DFLL_OUTPUT_CFG before setting new value */
> + dfll_writel(td, 0, DFLL_OUTPUT_CFG);
> + dfll_wmb(td);
>
> - dfll_i2c_writel(td, 0, DFLL_OUTPUT_CFG);
> val = (td->lut_safe << DFLL_OUTPUT_CFG_SAFE_SHIFT) |
> - (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) |
> - (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT);
> - dfll_i2c_writel(td, val, DFLL_OUTPUT_CFG);
> - dfll_i2c_wmb(td);
> + (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) |
> + (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT);
> + dfll_writel(td, val, DFLL_OUTPUT_CFG);
> + dfll_wmb(td);
>
> dfll_writel(td, 0, DFLL_OUTPUT_FORCE);
> dfll_i2c_writel(td, 0, DFLL_INTR_EN);
> dfll_i2c_writel(td, DFLL_INTR_MAX_MASK | DFLL_INTR_MIN_MASK,
> DFLL_INTR_STS);
>
> - dfll_load_i2c_lut(td);
> - dfll_init_i2c_if(td);
> + if (td->pmu_if == TEGRA_DFLL_PMU_PWM) {
> + int vinit = td->reg_init_uV;
This should be u32.
> + int vstep = td->soc->alignment.step_uv;
> + int vmin = td->lut_uv[0];
This should be unsigned long.
> +
> + /* set initial voltage */
> + if ((vinit >= vmin) && vstep) {
> + unsigned int vsel;
> +
> + vsel = DIV_ROUND_UP((vinit - vmin), vstep);
> + dfll_force_output(td, vsel);
> + }
> + } else {
> + dfll_load_i2c_lut(td);
> + dfll_init_i2c_if(td);
> + }
> }
>
> /*
> @@ -640,8 +813,8 @@ static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate)
> uv = dev_pm_opp_get_voltage(opp);
> dev_pm_opp_put(opp);
>
> - for (i = 0; i < td->i2c_lut_size; i++) {
> - if (regulator_list_voltage(td->vdd_reg, td->i2c_lut[i]) == uv)
> + for (i = td->lut_bottom; i < td->lut_size; i++) {
> + if (td->lut_uv[i] >= uv)
I think that we need to fix the type for 'uv' in this function while we
are at it.
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 07/21] clk: tegra: dfll: support PWM regulator control
2018-12-13 11:41 ` Jon Hunter
@ 2018-12-14 7:11 ` Joseph Lo
0 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-14 7:11 UTC (permalink / raw)
To: Jon Hunter, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 12/13/18 7:41 PM, Jon Hunter wrote:
>
> On 13/12/2018 09:34, Joseph Lo wrote:
>> The DFLL hardware supports two modes (I2C and PWM) for voltage control
>> when requesting a frequency. In this patch, we introduce PWM mode support.
>>
>> To support that, we re-organize the LUT for unifying the table for both
>> cases of I2C and PWM mode. And generate that based on regulator info.
>> For the PWM-based regulator, we get this info from DT. And do the same as
>> the case of I2C LUT, which can help to map the PMIC voltage ID and voltages
>> that the regulator supported.
>>
>> The other parts are the support code for initializing the DFLL hardware
>> to support PWM mode. Also, the register debugfs file is slightly
>> reworked to only show the i2c registers when I2C mode is in use.
>>
>> Based on the work of Peter De Schrijver <pdeschrijver@nvidia.com>.
>>
>> Signed-off-by: Joseph Lo <josephl@nvidia.com>
>> ---
>> *V2:
>> - move reg_init_uV to be with the PWM related variables
>> - fix the variable type to 'unsigned long' if it needs to catch the
>> return value from 'dev_pm_opp_get_voltage'
>> - update to use lut_uv table for LUT look up. This makes the generic
>> lut_uv table to work with both PWM and I2C mode.
>> ---
>> drivers/clk/tegra/clk-dfll.c | 435 +++++++++++++++++++++++++++++------
>> 1 file changed, 369 insertions(+), 66 deletions(-)
snip.
>> @@ -594,24 +750,41 @@ static void dfll_init_out_if(struct tegra_dfll *td)
>> {
>> u32 val;
>>
>> - td->lut_min = 0;
>> - td->lut_max = td->i2c_lut_size - 1;
>> - td->lut_safe = td->lut_min + 1;
>> + td->lut_min = td->lut_bottom;
>> + td->lut_max = td->lut_size - 1;
>> + td->lut_safe = td->lut_min + (td->lut_min < td->lut_max ? 1 : 0);
>> +
>> + /* clear DFLL_OUTPUT_CFG before setting new value */
>> + dfll_writel(td, 0, DFLL_OUTPUT_CFG);
>> + dfll_wmb(td);
>>
>> - dfll_i2c_writel(td, 0, DFLL_OUTPUT_CFG);
>> val = (td->lut_safe << DFLL_OUTPUT_CFG_SAFE_SHIFT) |
>> - (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) |
>> - (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT);
>> - dfll_i2c_writel(td, val, DFLL_OUTPUT_CFG);
>> - dfll_i2c_wmb(td);
>> + (td->lut_max << DFLL_OUTPUT_CFG_MAX_SHIFT) |
>> + (td->lut_min << DFLL_OUTPUT_CFG_MIN_SHIFT);
>> + dfll_writel(td, val, DFLL_OUTPUT_CFG);
>> + dfll_wmb(td);
>>
>> dfll_writel(td, 0, DFLL_OUTPUT_FORCE);
>> dfll_i2c_writel(td, 0, DFLL_INTR_EN);
>> dfll_i2c_writel(td, DFLL_INTR_MAX_MASK | DFLL_INTR_MIN_MASK,
>> DFLL_INTR_STS);
>>
>> - dfll_load_i2c_lut(td);
>> - dfll_init_i2c_if(td);
>> + if (td->pmu_if == TEGRA_DFLL_PMU_PWM) {
>> + int vinit = td->reg_init_uV;
>
> This should be u32.
>
>> + int vstep = td->soc->alignment.step_uv;
>> + int vmin = td->lut_uv[0];
>
> This should be unsigned long.
>
>> +
>> + /* set initial voltage */
>> + if ((vinit >= vmin) && vstep) {
>> + unsigned int vsel;
>> +
>> + vsel = DIV_ROUND_UP((vinit - vmin), vstep);
>> + dfll_force_output(td, vsel);
>> + }
>> + } else {
>> + dfll_load_i2c_lut(td);
>> + dfll_init_i2c_if(td);
>> + }
>> }
>>
>> /*
>> @@ -640,8 +813,8 @@ static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate)
>> uv = dev_pm_opp_get_voltage(opp);
>> dev_pm_opp_put(opp);
>>
>> - for (i = 0; i < td->i2c_lut_size; i++) {
>> - if (regulator_list_voltage(td->vdd_reg, td->i2c_lut[i]) == uv)
>> + for (i = td->lut_bottom; i < td->lut_size; i++) {
>> + if (td->lut_uv[i] >= uv)
>
> I think that we need to fix the type for 'uv' in this function while we
> are at it.
Okay, looks like I still have some variable type issue in V2. Will fix
accordingly.
Thanks,
Joseph
>
> Cheers
> Jon
>
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (6 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 07/21] clk: tegra: dfll: support PWM regulator control Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 11:46 ` Jon Hunter
2018-12-13 9:34 ` [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs Joseph Lo
` (12 subsequent siblings)
20 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
When generating the OPP table, the voltages are round down with the
alignment from the regulator. The alignment should be applied for
voltages look up as well.
Based on the work of Penny Chiu <pchiu@nvidia.com>.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- s/align_volt/align_step/
- s/reg_volt/reg_volt_id/
---
drivers/clk/tegra/clk-dfll.c | 26 +++++++++++++++-----------
1 file changed, 15 insertions(+), 11 deletions(-)
diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
index 72e02898006c..b3668073d9b4 100644
--- a/drivers/clk/tegra/clk-dfll.c
+++ b/drivers/clk/tegra/clk-dfll.c
@@ -804,17 +804,17 @@ static void dfll_init_out_if(struct tegra_dfll *td)
static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate)
{
struct dev_pm_opp *opp;
- int i, uv;
+ int i, align_step;
opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
if (IS_ERR(opp))
return PTR_ERR(opp);
- uv = dev_pm_opp_get_voltage(opp);
+ align_step = dev_pm_opp_get_voltage(opp) / td->soc->alignment.step_uv;
dev_pm_opp_put(opp);
for (i = td->lut_bottom; i < td->lut_size; i++) {
- if (td->lut_uv[i] >= uv)
+ if ((td->lut_uv[i] / td->soc->alignment.step_uv) >= align_step)
return i;
}
@@ -1532,15 +1532,17 @@ static int dfll_init(struct tegra_dfll *td)
*/
static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
{
- int i, n_voltages, reg_uV;
+ int i, n_voltages, reg_volt_id, align_step;
+ align_step = uV / td->soc->alignment.step_uv;
n_voltages = regulator_count_voltages(td->vdd_reg);
for (i = 0; i < n_voltages; i++) {
- reg_uV = regulator_list_voltage(td->vdd_reg, i);
- if (reg_uV < 0)
+ reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
+ td->soc->alignment.step_uv;
+ if (reg_volt_id < 0)
break;
- if (uV == reg_uV)
+ if (align_step == reg_volt_id)
return i;
}
@@ -1554,15 +1556,17 @@ static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
* */
static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV)
{
- int i, n_voltages, reg_uV;
+ int i, n_voltages, reg_volt_id, align_step;
+ align_step = uV / td->soc->alignment.step_uv;
n_voltages = regulator_count_voltages(td->vdd_reg);
for (i = 0; i < n_voltages; i++) {
- reg_uV = regulator_list_voltage(td->vdd_reg, i);
- if (reg_uV < 0)
+ reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
+ td->soc->alignment.step_uv;
+ if (reg_volt_id < 0)
break;
- if (uV <= reg_uV)
+ if (align_step <= reg_volt_id)
return i;
}
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment
2018-12-13 9:34 ` [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment Joseph Lo
@ 2018-12-13 11:46 ` Jon Hunter
2018-12-14 7:18 ` Joseph Lo
0 siblings, 1 reply; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 11:46 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 13/12/2018 09:34, Joseph Lo wrote:
> When generating the OPP table, the voltages are round down with the
> alignment from the regulator. The alignment should be applied for
> voltages look up as well.
>
> Based on the work of Penny Chiu <pchiu@nvidia.com>.
>
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - s/align_volt/align_step/
> - s/reg_volt/reg_volt_id/
> ---
> drivers/clk/tegra/clk-dfll.c | 26 +++++++++++++++-----------
> 1 file changed, 15 insertions(+), 11 deletions(-)
>
> diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
> index 72e02898006c..b3668073d9b4 100644
> --- a/drivers/clk/tegra/clk-dfll.c
> +++ b/drivers/clk/tegra/clk-dfll.c
> @@ -804,17 +804,17 @@ static void dfll_init_out_if(struct tegra_dfll *td)
> static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate)
> {
> struct dev_pm_opp *opp;
> - int i, uv;
> + int i, align_step;
>
> opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
> if (IS_ERR(opp))
> return PTR_ERR(opp);
>
> - uv = dev_pm_opp_get_voltage(opp);
> + align_step = dev_pm_opp_get_voltage(opp) / td->soc->alignment.step_uv;
> dev_pm_opp_put(opp);
>
> for (i = td->lut_bottom; i < td->lut_size; i++) {
> - if (td->lut_uv[i] >= uv)
> + if ((td->lut_uv[i] / td->soc->alignment.step_uv) >= align_step)
> return i;
> }
>
> @@ -1532,15 +1532,17 @@ static int dfll_init(struct tegra_dfll *td)
> */
> static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
> {
> - int i, n_voltages, reg_uV;
> + int i, n_voltages, reg_volt_id, align_step;
>
> + align_step = uV / td->soc->alignment.step_uv;
> n_voltages = regulator_count_voltages(td->vdd_reg);
> for (i = 0; i < n_voltages; i++) {
> - reg_uV = regulator_list_voltage(td->vdd_reg, i);
> - if (reg_uV < 0)
> + reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
> + td->soc->alignment.step_uv;
> + if (reg_volt_id < 0)
I don't think that this will work. If the step is say 10000 and we
return an error code greater than -10000, we will end up with 0.
> break;
>
> - if (uV == reg_uV)
> + if (align_step == reg_volt_id)
> return i;
> }
>
> @@ -1554,15 +1556,17 @@ static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
> * */
> static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV)
> {
> - int i, n_voltages, reg_uV;
> + int i, n_voltages, reg_volt_id, align_step;
>
> + align_step = uV / td->soc->alignment.step_uv;
> n_voltages = regulator_count_voltages(td->vdd_reg);
> for (i = 0; i < n_voltages; i++) {
> - reg_uV = regulator_list_voltage(td->vdd_reg, i);
> - if (reg_uV < 0)
> + reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
> + td->soc->alignment.step_uv;
> + if (reg_volt_id < 0)
Same here.
> break;
>
> - if (uV <= reg_uV)
> + if (align_step <= reg_volt_id)
> return i;
> }
>
>
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment
2018-12-13 11:46 ` Jon Hunter
@ 2018-12-14 7:18 ` Joseph Lo
2018-12-14 10:00 ` Jon Hunter
0 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-14 7:18 UTC (permalink / raw)
To: Jon Hunter, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 12/13/18 7:46 PM, Jon Hunter wrote:
>
> On 13/12/2018 09:34, Joseph Lo wrote:
>> When generating the OPP table, the voltages are round down with the
>> alignment from the regulator. The alignment should be applied for
>> voltages look up as well.
>>
>> Based on the work of Penny Chiu <pchiu@nvidia.com>.
>>
>> Signed-off-by: Joseph Lo <josephl@nvidia.com>
>> ---
>> *V2:
>> - s/align_volt/align_step/
>> - s/reg_volt/reg_volt_id/
>> ---
>> drivers/clk/tegra/clk-dfll.c | 26 +++++++++++++++-----------
>> 1 file changed, 15 insertions(+), 11 deletions(-)
>>
>> diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
>> index 72e02898006c..b3668073d9b4 100644
>> --- a/drivers/clk/tegra/clk-dfll.c
>> +++ b/drivers/clk/tegra/clk-dfll.c
>> @@ -804,17 +804,17 @@ static void dfll_init_out_if(struct tegra_dfll *td)
>> static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned long rate)
>> {
>> struct dev_pm_opp *opp;
>> - int i, uv;
>> + int i, align_step;
>>
>> opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
>> if (IS_ERR(opp))
>> return PTR_ERR(opp);
>>
>> - uv = dev_pm_opp_get_voltage(opp);
>> + align_step = dev_pm_opp_get_voltage(opp) / td->soc->alignment.step_uv;
>> dev_pm_opp_put(opp);
>>
>> for (i = td->lut_bottom; i < td->lut_size; i++) {
>> - if (td->lut_uv[i] >= uv)
>> + if ((td->lut_uv[i] / td->soc->alignment.step_uv) >= align_step)
>> return i;
>> }
>>
>> @@ -1532,15 +1532,17 @@ static int dfll_init(struct tegra_dfll *td)
>> */
>> static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
>> {
>> - int i, n_voltages, reg_uV;
>> + int i, n_voltages, reg_volt_id, align_step;
>>
>> + align_step = uV / td->soc->alignment.step_uv;
>> n_voltages = regulator_count_voltages(td->vdd_reg);
>> for (i = 0; i < n_voltages; i++) {
>> - reg_uV = regulator_list_voltage(td->vdd_reg, i);
>> - if (reg_uV < 0)
>> + reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
>> + td->soc->alignment.step_uv;
>> + if (reg_volt_id < 0)
>
> I don't think that this will work. If the step is say 10000 and we
> return an error code greater than -10000, we will end up with 0.
Ah,I think you mean when the error code smaller than step_uv. Yes, it
will be 0 in that case. I think I will just remove the 'if' clause, then
it will not match anything and leave the for loop. And return error if
it couldn't find anything. Same as below.
Thanks.
>
>> break;
>>
>> - if (uV == reg_uV)
>> + if (align_step == reg_volt_id)
>> return i;
>> }
>>
>> @@ -1554,15 +1556,17 @@ static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
>> * */
>> static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV)
>> {
>> - int i, n_voltages, reg_uV;
>> + int i, n_voltages, reg_volt_id, align_step;
>>
>> + align_step = uV / td->soc->alignment.step_uv;
>> n_voltages = regulator_count_voltages(td->vdd_reg);
>> for (i = 0; i < n_voltages; i++) {
>> - reg_uV = regulator_list_voltage(td->vdd_reg, i);
>> - if (reg_uV < 0)
>> + reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
>> + td->soc->alignment.step_uv;
>> + if (reg_volt_id < 0)
>
> Same here.
>
>> break;
>>
>> - if (uV <= reg_uV)
>> + if (align_step <= reg_volt_id)
>> return i;
>> }
>>
>>
>
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment
2018-12-14 7:18 ` Joseph Lo
@ 2018-12-14 10:00 ` Jon Hunter
0 siblings, 0 replies; 40+ messages in thread
From: Jon Hunter @ 2018-12-14 10:00 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-tegra, linux-clk, linux-arm-kernel
On 14/12/2018 07:18, Joseph Lo wrote:
> On 12/13/18 7:46 PM, Jon Hunter wrote:
>>
>> On 13/12/2018 09:34, Joseph Lo wrote:
>>> When generating the OPP table, the voltages are round down with the
>>> alignment from the regulator. The alignment should be applied for
>>> voltages look up as well.
>>>
>>> Based on the work of Penny Chiu <pchiu@nvidia.com>.
>>>
>>> Signed-off-by: Joseph Lo <josephl@nvidia.com>
>>> ---
>>> *V2:
>>> - s/align_volt/align_step/
>>> - s/reg_volt/reg_volt_id/
>>> ---
>>> drivers/clk/tegra/clk-dfll.c | 26 +++++++++++++++-----------
>>> 1 file changed, 15 insertions(+), 11 deletions(-)
>>>
>>> diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
>>> index 72e02898006c..b3668073d9b4 100644
>>> --- a/drivers/clk/tegra/clk-dfll.c
>>> +++ b/drivers/clk/tegra/clk-dfll.c
>>> @@ -804,17 +804,17 @@ static void dfll_init_out_if(struct tegra_dfll
>>> *td)
>>> static int find_lut_index_for_rate(struct tegra_dfll *td, unsigned
>>> long rate)
>>> {
>>> struct dev_pm_opp *opp;
>>> - int i, uv;
>>> + int i, align_step;
>>> opp = dev_pm_opp_find_freq_ceil(td->soc->dev, &rate);
>>> if (IS_ERR(opp))
>>> return PTR_ERR(opp);
>>> - uv = dev_pm_opp_get_voltage(opp);
>>> + align_step = dev_pm_opp_get_voltage(opp) /
>>> td->soc->alignment.step_uv;
>>> dev_pm_opp_put(opp);
>>> for (i = td->lut_bottom; i < td->lut_size; i++) {
>>> - if (td->lut_uv[i] >= uv)
>>> + if ((td->lut_uv[i] / td->soc->alignment.step_uv) >= align_step)
>>> return i;
>>> }
>>> @@ -1532,15 +1532,17 @@ static int dfll_init(struct tegra_dfll *td)
>>> */
>>> static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
>>> {
>>> - int i, n_voltages, reg_uV;
>>> + int i, n_voltages, reg_volt_id, align_step;
>>> + align_step = uV / td->soc->alignment.step_uv;
>>> n_voltages = regulator_count_voltages(td->vdd_reg);
>>> for (i = 0; i < n_voltages; i++) {
>>> - reg_uV = regulator_list_voltage(td->vdd_reg, i);
>>> - if (reg_uV < 0)
>>> + reg_volt_id = regulator_list_voltage(td->vdd_reg, i) /
>>> + td->soc->alignment.step_uv;
>>> + if (reg_volt_id < 0)
>>
>> I don't think that this will work. If the step is say 10000 and we
>> return an error code greater than -10000, we will end up with 0.
>
> Ah,I think you mean when the error code smaller than step_uv. Yes, it
> will be 0 in that case. I think I will just remove the 'if' clause, then
> it will not match anything and leave the for loop. And return error if
> it couldn't find anything. Same as below.
Looks like if you remove the if clause then if will try to look up
another voltage. Seems to me that we should just break out the loop on
the first failure as it does today.
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (7 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 08/21] clk: tegra: dfll: round down voltages based on alignment Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 12:46 ` Jon Hunter
2018-12-13 9:34 ` [PATCH V2 10/21] clk: tegra: dfll: add CVB tables for Tegra210 Joseph Lo
` (11 subsequent siblings)
20 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
The DFLL hardware supports both I2C and PWM based regulator. SW driver
only touches I2C regulator when generating LUT. And shouldn't touch it
anymore once the DFLL is enabled.
This patch adds the protection for the APIs that only work with I2C mode
to avoid they could be called accidentally.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- new added patch in V2
---
drivers/clk/tegra/clk-dfll.c | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/drivers/clk/tegra/clk-dfll.c b/drivers/clk/tegra/clk-dfll.c
index b3668073d9b4..93cc86f17f7b 100644
--- a/drivers/clk/tegra/clk-dfll.c
+++ b/drivers/clk/tegra/clk-dfll.c
@@ -1534,6 +1534,9 @@ static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV)
{
int i, n_voltages, reg_volt_id, align_step;
+ if (WARN_ON(td->pmu_if == TEGRA_DFLL_PMU_PWM))
+ return -EINVAL;
+
align_step = uV / td->soc->alignment.step_uv;
n_voltages = regulator_count_voltages(td->vdd_reg);
for (i = 0; i < n_voltages; i++) {
@@ -1558,6 +1561,9 @@ static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV)
{
int i, n_voltages, reg_volt_id, align_step;
+ if (WARN_ON(td->pmu_if == TEGRA_DFLL_PMU_PWM))
+ return -EINVAL;
+
align_step = uV / td->soc->alignment.step_uv;
n_voltages = regulator_count_voltages(td->vdd_reg);
for (i = 0; i < n_voltages; i++) {
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs
2018-12-13 9:34 ` [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs Joseph Lo
@ 2018-12-13 12:46 ` Jon Hunter
2018-12-14 7:42 ` Joseph Lo
0 siblings, 1 reply; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 12:46 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 13/12/2018 09:34, Joseph Lo wrote:
> The DFLL hardware supports both I2C and PWM based regulator. SW driver
> only touches I2C regulator when generating LUT. And shouldn't touch it
> anymore once the DFLL is enabled.
I am not sure that the last two sentences are above are relevant and
confused me a little at first. I would be tempted to drop them.
> This patch adds the protection for the APIs that only work with I2C mode
> to avoid they could be called accidentally.
>
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
Furthermore, I would be tempted to squash this into patch #7. I am not
sure another patch is warranted here.
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs
2018-12-13 12:46 ` Jon Hunter
@ 2018-12-14 7:42 ` Joseph Lo
2018-12-17 11:38 ` Peter De Schrijver
0 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-14 7:42 UTC (permalink / raw)
To: Jon Hunter, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 12/13/18 8:46 PM, Jon Hunter wrote:
>
> On 13/12/2018 09:34, Joseph Lo wrote:
>> The DFLL hardware supports both I2C and PWM based regulator. SW driver
>> only touches I2C regulator when generating LUT. And shouldn't touch it
>> anymore once the DFLL is enabled.
>
> I am not sure that the last two sentences are above are relevant and
> confused me a little at first. I would be tempted to drop them.
Indeed, they are irrelevant. Just want to describe that once we created
LUT table, it means we cached the regulator output table in driver. Then
we don't need to query voltage data from regulator again. This is
specific to the I2C mode only and happens in driver initialization time.
Which means the two APIs we add the WARN here maybe not really
necessary. Because this is suggested by Peter.
Hi Peter,
Just want to double confirm again, do we really need to add a WARN here?
Since we don't and shouldn't access these two APIs once the driver is
working, all the voltage query should be via LUT. So I think add WARN
here is not really necessary.
Thanks,
Joseph
>
>> This patch adds the protection for the APIs that only work with I2C mode
>> to avoid they could be called accidentally.
>>
>> Signed-off-by: Joseph Lo <josephl@nvidia.com>
>
> Furthermore, I would be tempted to squash this into patch #7. I am not
> sure another patch is warranted here.
>
> Cheers
> Jon
>
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs
2018-12-14 7:42 ` Joseph Lo
@ 2018-12-17 11:38 ` Peter De Schrijver
0 siblings, 0 replies; 40+ messages in thread
From: Peter De Schrijver @ 2018-12-17 11:38 UTC (permalink / raw)
To: Joseph Lo
Cc: Jon Hunter, Thierry Reding, linux-arm-kernel, linux-tegra, linux-clk
On Fri, Dec 14, 2018 at 03:42:45PM +0800, Joseph Lo wrote:
> On 12/13/18 8:46 PM, Jon Hunter wrote:
> >
> > On 13/12/2018 09:34, Joseph Lo wrote:
> > > The DFLL hardware supports both I2C and PWM based regulator. SW driver
> > > only touches I2C regulator when generating LUT. And shouldn't touch it
> > > anymore once the DFLL is enabled.
> >
> > I am not sure that the last two sentences are above are relevant and
> > confused me a little at first. I would be tempted to drop them.
>
> Indeed, they are irrelevant. Just want to describe that once we created LUT
> table, it means we cached the regulator output table in driver. Then we
> don't need to query voltage data from regulator again. This is specific to
> the I2C mode only and happens in driver initialization time. Which means the
> two APIs we add the WARN here maybe not really necessary. Because this is
> suggested by Peter.
>
> Hi Peter,
>
> Just want to double confirm again, do we really need to add a WARN here?
> Since we don't and shouldn't access these two APIs once the driver is
> working, all the voltage query should be via LUT. So I think add WARN here
> is not really necessary.
It's not really necessary. It's more of a safeguard to make sure someone
who modifies the code later and might not be aware of this limitation
would accidently call the functions when PWM mode is in use.
Peter.
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 10/21] clk: tegra: dfll: add CVB tables for Tegra210
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (8 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 09/21] clk: tegra: dfll: add protection for find_vdd_map APIs Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 12:50 ` Jon Hunter
2018-12-13 9:34 ` [PATCH V2 11/21] clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210 Joseph Lo
` (10 subsequent siblings)
20 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Add CVB tables with different chip characterization, so that we can
generate the customize OPP table that suitable for different chips with
different SKUs.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- no update
---
drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 426 +++++++++++++++++++++
drivers/clk/tegra/cvb.h | 1 +
2 files changed, 427 insertions(+)
diff --git a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
index 189b5e20ee4e..db117e9991e3 100644
--- a/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
+++ b/drivers/clk/tegra/clk-tegra124-dfll-fcpu.c
@@ -88,6 +88,421 @@ static const struct cvb_table tegra124_cpu_cvb_tables[] = {
},
};
+static const unsigned long tegra210_cpu_max_freq_table[] = {
+ [0] = 1912500000UL,
+ [1] = 1912500000UL,
+ [2] = 2218500000UL,
+ [3] = 1785000000UL,
+ [4] = 1632000000UL,
+ [5] = 1912500000UL,
+ [6] = 2014500000UL,
+ [7] = 1734000000UL,
+ [8] = 1683000000UL,
+ [9] = 1555500000UL,
+ [10] = 1504500000UL,
+};
+
+#define CPU_CVB_TABLE \
+ .speedo_scale = 100, \
+ .voltage_scale = 1000, \
+ .entries = { \
+ { 204000000UL, { 1007452, -23865, 370 } }, \
+ { 306000000UL, { 1052709, -24875, 370 } }, \
+ { 408000000UL, { 1099069, -25895, 370 } }, \
+ { 510000000UL, { 1146534, -26905, 370 } }, \
+ { 612000000UL, { 1195102, -27915, 370 } }, \
+ { 714000000UL, { 1244773, -28925, 370 } }, \
+ { 816000000UL, { 1295549, -29935, 370 } }, \
+ { 918000000UL, { 1347428, -30955, 370 } }, \
+ { 1020000000UL, { 1400411, -31965, 370 } }, \
+ { 1122000000UL, { 1454497, -32975, 370 } }, \
+ { 1224000000UL, { 1509687, -33985, 370 } }, \
+ { 1326000000UL, { 1565981, -35005, 370 } }, \
+ { 1428000000UL, { 1623379, -36015, 370 } }, \
+ { 1530000000UL, { 1681880, -37025, 370 } }, \
+ { 1632000000UL, { 1741485, -38035, 370 } }, \
+ { 1734000000UL, { 1802194, -39055, 370 } }, \
+ { 1836000000UL, { 1864006, -40065, 370 } }, \
+ { 1912500000UL, { 1910780, -40815, 370 } }, \
+ { 2014500000UL, { 1227000, 0, 0 } }, \
+ { 2218500000UL, { 1227000, 0, 0 } }, \
+ { 0UL, { 0, 0, 0 } }, \
+ }
+
+#define CPU_CVB_TABLE_XA \
+ .speedo_scale = 100, \
+ .voltage_scale = 1000, \
+ .entries = { \
+ { 204000000UL, { 1250024, -39785, 565 } }, \
+ { 306000000UL, { 1297556, -41145, 565 } }, \
+ { 408000000UL, { 1346718, -42505, 565 } }, \
+ { 510000000UL, { 1397511, -43855, 565 } }, \
+ { 612000000UL, { 1449933, -45215, 565 } }, \
+ { 714000000UL, { 1503986, -46575, 565 } }, \
+ { 816000000UL, { 1559669, -47935, 565 } }, \
+ { 918000000UL, { 1616982, -49295, 565 } }, \
+ { 1020000000UL, { 1675926, -50645, 565 } }, \
+ { 1122000000UL, { 1736500, -52005, 565 } }, \
+ { 1224000000UL, { 1798704, -53365, 565 } }, \
+ { 1326000000UL, { 1862538, -54725, 565 } }, \
+ { 1428000000UL, { 1928003, -56085, 565 } }, \
+ { 1530000000UL, { 1995097, -57435, 565 } }, \
+ { 1606500000UL, { 2046149, -58445, 565 } }, \
+ { 1632000000UL, { 2063822, -58795, 565 } }, \
+ { 0UL, { 0, 0, 0 } }, \
+ }
+
+#define CPU_CVB_TABLE_EUCM1 \
+ .speedo_scale = 100, \
+ .voltage_scale = 1000, \
+ .entries = { \
+ { 204000000UL, { 734429, 0, 0 } }, \
+ { 306000000UL, { 768191, 0, 0 } }, \
+ { 408000000UL, { 801953, 0, 0 } }, \
+ { 510000000UL, { 835715, 0, 0 } }, \
+ { 612000000UL, { 869477, 0, 0 } }, \
+ { 714000000UL, { 903239, 0, 0 } }, \
+ { 816000000UL, { 937001, 0, 0 } }, \
+ { 918000000UL, { 970763, 0, 0 } }, \
+ { 1020000000UL, { 1004525, 0, 0 } }, \
+ { 1122000000UL, { 1038287, 0, 0 } }, \
+ { 1224000000UL, { 1072049, 0, 0 } }, \
+ { 1326000000UL, { 1105811, 0, 0 } }, \
+ { 1428000000UL, { 1130000, 0, 0 } }, \
+ { 1555500000UL, { 1130000, 0, 0 } }, \
+ { 1632000000UL, { 1170000, 0, 0 } }, \
+ { 1734000000UL, { 1227500, 0, 0 } }, \
+ { 0UL, { 0, 0, 0 } }, \
+ }
+
+#define CPU_CVB_TABLE_EUCM2 \
+ .speedo_scale = 100, \
+ .voltage_scale = 1000, \
+ .entries = { \
+ { 204000000UL, { 742283, 0, 0 } }, \
+ { 306000000UL, { 776249, 0, 0 } }, \
+ { 408000000UL, { 810215, 0, 0 } }, \
+ { 510000000UL, { 844181, 0, 0 } }, \
+ { 612000000UL, { 878147, 0, 0 } }, \
+ { 714000000UL, { 912113, 0, 0 } }, \
+ { 816000000UL, { 946079, 0, 0 } }, \
+ { 918000000UL, { 980045, 0, 0 } }, \
+ { 1020000000UL, { 1014011, 0, 0 } }, \
+ { 1122000000UL, { 1047977, 0, 0 } }, \
+ { 1224000000UL, { 1081943, 0, 0 } }, \
+ { 1326000000UL, { 1090000, 0, 0 } }, \
+ { 1479000000UL, { 1090000, 0, 0 } }, \
+ { 1555500000UL, { 1162000, 0, 0 } }, \
+ { 1683000000UL, { 1195000, 0, 0 } }, \
+ { 0UL, { 0, 0, 0 } }, \
+ }
+
+#define CPU_CVB_TABLE_EUCM2_JOINT_RAIL \
+ .speedo_scale = 100, \
+ .voltage_scale = 1000, \
+ .entries = { \
+ { 204000000UL, { 742283, 0, 0 } }, \
+ { 306000000UL, { 776249, 0, 0 } }, \
+ { 408000000UL, { 810215, 0, 0 } }, \
+ { 510000000UL, { 844181, 0, 0 } }, \
+ { 612000000UL, { 878147, 0, 0 } }, \
+ { 714000000UL, { 912113, 0, 0 } }, \
+ { 816000000UL, { 946079, 0, 0 } }, \
+ { 918000000UL, { 980045, 0, 0 } }, \
+ { 1020000000UL, { 1014011, 0, 0 } }, \
+ { 1122000000UL, { 1047977, 0, 0 } }, \
+ { 1224000000UL, { 1081943, 0, 0 } }, \
+ { 1326000000UL, { 1090000, 0, 0 } }, \
+ { 1479000000UL, { 1090000, 0, 0 } }, \
+ { 1504500000UL, { 1120000, 0, 0 } }, \
+ { 0UL, { 0, 0, 0 } }, \
+ }
+
+#define CPU_CVB_TABLE_ODN \
+ .speedo_scale = 100, \
+ .voltage_scale = 1000, \
+ .entries = { \
+ { 204000000UL, { 721094, 0, 0 } }, \
+ { 306000000UL, { 754040, 0, 0 } }, \
+ { 408000000UL, { 786986, 0, 0 } }, \
+ { 510000000UL, { 819932, 0, 0 } }, \
+ { 612000000UL, { 852878, 0, 0 } }, \
+ { 714000000UL, { 885824, 0, 0 } }, \
+ { 816000000UL, { 918770, 0, 0 } }, \
+ { 918000000UL, { 915716, 0, 0 } }, \
+ { 1020000000UL, { 984662, 0, 0 } }, \
+ { 1122000000UL, { 1017608, 0, 0 } }, \
+ { 1224000000UL, { 1050554, 0, 0 } }, \
+ { 1326000000UL, { 1083500, 0, 0 } }, \
+ { 1428000000UL, { 1116446, 0, 0 } }, \
+ { 1581000000UL, { 1130000, 0, 0 } }, \
+ { 1683000000UL, { 1168000, 0, 0 } }, \
+ { 1785000000UL, { 1227500, 0, 0 } }, \
+ { 0UL, { 0, 0, 0 } }, \
+ }
+
+struct cvb_table tegra210_cpu_cvb_tables[] = {
+ {
+ .speedo_id = 10,
+ .process_id = 0,
+ .min_millivolts = 840,
+ .max_millivolts = 1120,
+ CPU_CVB_TABLE_EUCM2_JOINT_RAIL,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 10,
+ .process_id = 1,
+ .min_millivolts = 840,
+ .max_millivolts = 1120,
+ CPU_CVB_TABLE_EUCM2_JOINT_RAIL,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 9,
+ .process_id = 0,
+ .min_millivolts = 900,
+ .max_millivolts = 1162,
+ CPU_CVB_TABLE_EUCM2,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ }
+ },
+ {
+ .speedo_id = 9,
+ .process_id = 1,
+ .min_millivolts = 900,
+ .max_millivolts = 1162,
+ CPU_CVB_TABLE_EUCM2,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ }
+ },
+ {
+ .speedo_id = 8,
+ .process_id = 0,
+ .min_millivolts = 900,
+ .max_millivolts = 1195,
+ CPU_CVB_TABLE_EUCM2,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ }
+ },
+ {
+ .speedo_id = 8,
+ .process_id = 1,
+ .min_millivolts = 900,
+ .max_millivolts = 1195,
+ CPU_CVB_TABLE_EUCM2,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ }
+ },
+ {
+ .speedo_id = 7,
+ .process_id = 0,
+ .min_millivolts = 841,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE_EUCM1,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 7,
+ .process_id = 1,
+ .min_millivolts = 841,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE_EUCM1,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 6,
+ .process_id = 0,
+ .min_millivolts = 870,
+ .max_millivolts = 1150,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ }
+ },
+ {
+ .speedo_id = 6,
+ .process_id = 1,
+ .min_millivolts = 870,
+ .max_millivolts = 1150,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune1 = 0x25501d0,
+ }
+ },
+ {
+ .speedo_id = 5,
+ .process_id = 0,
+ .min_millivolts = 818,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 5,
+ .process_id = 1,
+ .min_millivolts = 818,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x25501d0,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 4,
+ .process_id = -1,
+ .min_millivolts = 918,
+ .max_millivolts = 1113,
+ CPU_CVB_TABLE_XA,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune1 = 0x17711BD,
+ }
+ },
+ {
+ .speedo_id = 3,
+ .process_id = 0,
+ .min_millivolts = 825,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE_ODN,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 3,
+ .process_id = 1,
+ .min_millivolts = 825,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE_ODN,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x25501d0,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 2,
+ .process_id = 0,
+ .min_millivolts = 870,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ }
+ },
+ {
+ .speedo_id = 2,
+ .process_id = 1,
+ .min_millivolts = 870,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune1 = 0x25501d0,
+ }
+ },
+ {
+ .speedo_id = 1,
+ .process_id = 0,
+ .min_millivolts = 837,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 1,
+ .process_id = 1,
+ .min_millivolts = 837,
+ .max_millivolts = 1227,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x25501d0,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 0,
+ .process_id = 0,
+ .min_millivolts = 850,
+ .max_millivolts = 1170,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x20091d9,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+ {
+ .speedo_id = 0,
+ .process_id = 1,
+ .min_millivolts = 850,
+ .max_millivolts = 1170,
+ CPU_CVB_TABLE,
+ .cpu_dfll_data = {
+ .tune0_low = 0xffead0ff,
+ .tune0_high = 0xffead0ff,
+ .tune1 = 0x25501d0,
+ .tune_high_min_millivolts = 864,
+ }
+ },
+};
+
static const struct dfll_fcpu_data tegra124_dfll_fcpu_data = {
.cpu_max_freq_table = tegra124_cpu_max_freq_table,
.cpu_max_freq_table_size = ARRAY_SIZE(tegra124_cpu_max_freq_table),
@@ -95,11 +510,22 @@ static const struct dfll_fcpu_data tegra124_dfll_fcpu_data = {
.cpu_cvb_tables_size = ARRAY_SIZE(tegra124_cpu_cvb_tables)
};
+static const struct dfll_fcpu_data tegra210_dfll_fcpu_data = {
+ .cpu_max_freq_table = tegra210_cpu_max_freq_table,
+ .cpu_max_freq_table_size = ARRAY_SIZE(tegra210_cpu_max_freq_table),
+ .cpu_cvb_tables = tegra210_cpu_cvb_tables,
+ .cpu_cvb_tables_size = ARRAY_SIZE(tegra210_cpu_cvb_tables),
+};
+
static const struct of_device_id tegra124_dfll_fcpu_of_match[] = {
{
.compatible = "nvidia,tegra124-dfll",
.data = &tegra124_dfll_fcpu_data,
},
+ {
+ .compatible = "nvidia,tegra210-dfll",
+ .data = &tegra210_dfll_fcpu_data
+ },
{ },
};
diff --git a/drivers/clk/tegra/cvb.h b/drivers/clk/tegra/cvb.h
index bcf15a089b93..91a1941c21ef 100644
--- a/drivers/clk/tegra/cvb.h
+++ b/drivers/clk/tegra/cvb.h
@@ -41,6 +41,7 @@ struct cvb_cpu_dfll_data {
u32 tune0_low;
u32 tune0_high;
u32 tune1;
+ unsigned int tune_high_min_millivolts;
};
struct cvb_table {
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 10/21] clk: tegra: dfll: add CVB tables for Tegra210
2018-12-13 9:34 ` [PATCH V2 10/21] clk: tegra: dfll: add CVB tables for Tegra210 Joseph Lo
@ 2018-12-13 12:50 ` Jon Hunter
2018-12-14 7:43 ` Joseph Lo
0 siblings, 1 reply; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 12:50 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 13/12/2018 09:34, Joseph Lo wrote:
> Add CVB tables with different chip characterization, so that we can
> generate the customize OPP table that suitable for different chips with
> different SKUs.
>
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
...
> diff --git a/drivers/clk/tegra/cvb.h b/drivers/clk/tegra/cvb.h
> index bcf15a089b93..91a1941c21ef 100644
> --- a/drivers/clk/tegra/cvb.h
> +++ b/drivers/clk/tegra/cvb.h
> @@ -41,6 +41,7 @@ struct cvb_cpu_dfll_data {
> u32 tune0_low;
> u32 tune0_high;
> u32 tune1;
> + unsigned int tune_high_min_millivolts;
> };
Sorry, I forgot to respond to this on the previous version. I think that
it is OK to add now, but please add a comment in the changelog to
reflect that this is not currently used, but we have plans to use it and
so we are adding all the data now.
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 10/21] clk: tegra: dfll: add CVB tables for Tegra210
2018-12-13 12:50 ` Jon Hunter
@ 2018-12-14 7:43 ` Joseph Lo
0 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-14 7:43 UTC (permalink / raw)
To: Jon Hunter, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 12/13/18 8:50 PM, Jon Hunter wrote:
>
> On 13/12/2018 09:34, Joseph Lo wrote:
>> Add CVB tables with different chip characterization, so that we can
>> generate the customize OPP table that suitable for different chips with
>> different SKUs.
>>
>> Signed-off-by: Joseph Lo <josephl@nvidia.com>
>
> ...
>
>> diff --git a/drivers/clk/tegra/cvb.h b/drivers/clk/tegra/cvb.h
>> index bcf15a089b93..91a1941c21ef 100644
>> --- a/drivers/clk/tegra/cvb.h
>> +++ b/drivers/clk/tegra/cvb.h
>> @@ -41,6 +41,7 @@ struct cvb_cpu_dfll_data {
>> u32 tune0_low;
>> u32 tune0_high;
>> u32 tune1;
>> + unsigned int tune_high_min_millivolts;
>> };
>
> Sorry, I forgot to respond to this on the previous version. I think that
> it is OK to add now, but please add a comment in the changelog to
> reflect that this is not currently used, but we have plans to use it and
> so we are adding all the data now.
Okay, will do. Thanks.
>
> Cheers
> Jon
>
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 11/21] clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (9 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 10/21] clk: tegra: dfll: add CVB tables for Tegra210 Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail Joseph Lo
` (9 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
From: Peter De Schrijver <pdeschrijver@nvidia.com>
Tegra210 has a DFLL as well and can share the majority of the code with
the Tegra124 implementation. So build the same code for both platforms.
Signed-off-by: Peter De Schrijver <pdeschrijver@nvidia.com>
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
drivers/clk/tegra/Kconfig | 5 +++++
drivers/clk/tegra/Makefile | 2 +-
2 files changed, 6 insertions(+), 1 deletion(-)
diff --git a/drivers/clk/tegra/Kconfig b/drivers/clk/tegra/Kconfig
index 7ddacae5d0b1..57902ab43f4a 100644
--- a/drivers/clk/tegra/Kconfig
+++ b/drivers/clk/tegra/Kconfig
@@ -5,3 +5,8 @@ config TEGRA_CLK_EMC
config CLK_TEGRA_BPMP
def_bool y
depends on TEGRA_BPMP
+
+config TEGRA_CLK_DFLL
+ depends on (ARCH_TEGRA_124_SOC || ARCH_TEGRA_210_SOC)
+ select PM_OPP
+ def_bool y
diff --git a/drivers/clk/tegra/Makefile b/drivers/clk/tegra/Makefile
index 6507acc843c7..4812e45c2214 100644
--- a/drivers/clk/tegra/Makefile
+++ b/drivers/clk/tegra/Makefile
@@ -20,7 +20,7 @@ obj-$(CONFIG_ARCH_TEGRA_2x_SOC) += clk-tegra20.o
obj-$(CONFIG_ARCH_TEGRA_3x_SOC) += clk-tegra30.o
obj-$(CONFIG_ARCH_TEGRA_114_SOC) += clk-tegra114.o
obj-$(CONFIG_ARCH_TEGRA_124_SOC) += clk-tegra124.o
-obj-$(CONFIG_ARCH_TEGRA_124_SOC) += clk-tegra124-dfll-fcpu.o
+obj-$(CONFIG_TEGRA_CLK_DFLL) += clk-tegra124-dfll-fcpu.o
obj-$(CONFIG_ARCH_TEGRA_132_SOC) += clk-tegra124.o
obj-y += cvb.o
obj-$(CONFIG_ARCH_TEGRA_210_SOC) += clk-tegra210.o
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (10 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 11/21] clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210 Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 10:49 ` Rafael J. Wysocki
` (2 more replies)
2018-12-13 9:34 ` [PATCH V2 13/21] cpufreq: tegra124: extend to support Tegra210 Joseph Lo
` (8 subsequent siblings)
20 siblings, 3 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo,
Viresh Kumar, linux-pm
The Tegra124 cpufreq driver has no information to handle the Vdd-CPU
rail. So this driver shouldn't handle for the CPU clock switching from
DFLL to other PLL clocks. It was designed to work on DFLL clock only,
which handle the frequency/voltage scaling in the background.
This patch removes the driver dependency of the CPU rail, as well as not
allow it to be built as a module and remove the removal function. So it
can keep working on DFLL clock.
Cc: Viresh Kumar <viresh.kumar@linaro.org>
Cc: linux-pm@vger.kernel.org
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- update the commit message since we change the driver not able to be
built as a module and remove the removal function in V2
---
drivers/cpufreq/Kconfig.arm | 4 +--
drivers/cpufreq/tegra124-cpufreq.c | 41 ++----------------------------
2 files changed, 4 insertions(+), 41 deletions(-)
diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
index 4e1131ef85ae..1d83b6e81222 100644
--- a/drivers/cpufreq/Kconfig.arm
+++ b/drivers/cpufreq/Kconfig.arm
@@ -261,8 +261,8 @@ config ARM_TEGRA20_CPUFREQ
This adds the CPUFreq driver support for Tegra20 SOCs.
config ARM_TEGRA124_CPUFREQ
- tristate "Tegra124 CPUFreq support"
- depends on ARCH_TEGRA && CPUFREQ_DT && REGULATOR
+ bool "Tegra124 CPUFreq support"
+ depends on ARCH_TEGRA && CPUFREQ_DT
default y
help
This adds the CPUFreq driver support for Tegra124 SOCs.
diff --git a/drivers/cpufreq/tegra124-cpufreq.c b/drivers/cpufreq/tegra124-cpufreq.c
index 43530254201a..a1bfde0a7950 100644
--- a/drivers/cpufreq/tegra124-cpufreq.c
+++ b/drivers/cpufreq/tegra124-cpufreq.c
@@ -22,11 +22,9 @@
#include <linux/of.h>
#include <linux/platform_device.h>
#include <linux/pm_opp.h>
-#include <linux/regulator/consumer.h>
#include <linux/types.h>
struct tegra124_cpufreq_priv {
- struct regulator *vdd_cpu_reg;
struct clk *cpu_clk;
struct clk *pllp_clk;
struct clk *pllx_clk;
@@ -60,14 +58,6 @@ static int tegra124_cpu_switch_to_dfll(struct tegra124_cpufreq_priv *priv)
return ret;
}
-static void tegra124_cpu_switch_to_pllx(struct tegra124_cpufreq_priv *priv)
-{
- clk_set_parent(priv->cpu_clk, priv->pllp_clk);
- clk_disable_unprepare(priv->dfll_clk);
- regulator_sync_voltage(priv->vdd_cpu_reg);
- clk_set_parent(priv->cpu_clk, priv->pllx_clk);
-}
-
static int tegra124_cpufreq_probe(struct platform_device *pdev)
{
struct tegra124_cpufreq_priv *priv;
@@ -88,16 +78,10 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
if (!np)
return -ENODEV;
- priv->vdd_cpu_reg = regulator_get(cpu_dev, "vdd-cpu");
- if (IS_ERR(priv->vdd_cpu_reg)) {
- ret = PTR_ERR(priv->vdd_cpu_reg);
- goto out_put_np;
- }
-
priv->cpu_clk = of_clk_get_by_name(np, "cpu_g");
if (IS_ERR(priv->cpu_clk)) {
ret = PTR_ERR(priv->cpu_clk);
- goto out_put_vdd_cpu_reg;
+ goto out_put_np;
}
priv->dfll_clk = of_clk_get_by_name(np, "dfll");
@@ -129,15 +113,13 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
platform_device_register_full(&cpufreq_dt_devinfo);
if (IS_ERR(priv->cpufreq_dt_pdev)) {
ret = PTR_ERR(priv->cpufreq_dt_pdev);
- goto out_switch_to_pllx;
+ goto out_put_pllp_clk;
}
platform_set_drvdata(pdev, priv);
return 0;
-out_switch_to_pllx:
- tegra124_cpu_switch_to_pllx(priv);
out_put_pllp_clk:
clk_put(priv->pllp_clk);
out_put_pllx_clk:
@@ -146,34 +128,15 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
clk_put(priv->dfll_clk);
out_put_cpu_clk:
clk_put(priv->cpu_clk);
-out_put_vdd_cpu_reg:
- regulator_put(priv->vdd_cpu_reg);
out_put_np:
of_node_put(np);
return ret;
}
-static int tegra124_cpufreq_remove(struct platform_device *pdev)
-{
- struct tegra124_cpufreq_priv *priv = platform_get_drvdata(pdev);
-
- platform_device_unregister(priv->cpufreq_dt_pdev);
- tegra124_cpu_switch_to_pllx(priv);
-
- clk_put(priv->pllp_clk);
- clk_put(priv->pllx_clk);
- clk_put(priv->dfll_clk);
- clk_put(priv->cpu_clk);
- regulator_put(priv->vdd_cpu_reg);
-
- return 0;
-}
-
static struct platform_driver tegra124_cpufreq_platdrv = {
.driver.name = "cpufreq-tegra124",
.probe = tegra124_cpufreq_probe,
- .remove = tegra124_cpufreq_remove,
};
static int __init tegra_cpufreq_init(void)
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail
2018-12-13 9:34 ` [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail Joseph Lo
@ 2018-12-13 10:49 ` Rafael J. Wysocki
2018-12-13 12:55 ` Jon Hunter
2018-12-18 5:34 ` Viresh Kumar
2 siblings, 0 replies; 40+ messages in thread
From: Rafael J. Wysocki @ 2018-12-13 10:49 UTC (permalink / raw)
To: josephl
Cc: Thierry Reding, Peter De Schrijver, Jon Hunter, Linux ARM,
linux-tegra, linux-clk, Viresh Kumar, Linux PM
On Thu, Dec 13, 2018 at 10:35 AM Joseph Lo <josephl@nvidia.com> wrote:
>
> The Tegra124 cpufreq driver has no information to handle the Vdd-CPU
> rail. So this driver shouldn't handle for the CPU clock switching from
> DFLL to other PLL clocks. It was designed to work on DFLL clock only,
> which handle the frequency/voltage scaling in the background.
>
> This patch removes the driver dependency of the CPU rail, as well as not
> allow it to be built as a module and remove the removal function. So it
> can keep working on DFLL clock.
I assume this entire series to go in via arm-soc, so I won't be
picking up cpufreq changes from it.
Thanks,
Rafael
^ permalink raw reply [flat|nested] 40+ messages in thread
* Re: [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail
2018-12-13 9:34 ` [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail Joseph Lo
2018-12-13 10:49 ` Rafael J. Wysocki
@ 2018-12-13 12:55 ` Jon Hunter
2018-12-18 5:34 ` Viresh Kumar
2 siblings, 0 replies; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 12:55 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk, Viresh Kumar, linux-pm
On 13/12/2018 09:34, Joseph Lo wrote:
> The Tegra124 cpufreq driver has no information to handle the Vdd-CPU
> rail. So this driver shouldn't handle for the CPU clock switching from
> DFLL to other PLL clocks. It was designed to work on DFLL clock only,
> which handle the frequency/voltage scaling in the background.
>
> This patch removes the driver dependency of the CPU rail, as well as not
> allow it to be built as a module and remove the removal function. So it
> can keep working on DFLL clock.
>
> Cc: Viresh Kumar <viresh.kumar@linaro.org>
> Cc: linux-pm@vger.kernel.org
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - update the commit message since we change the driver not able to be
> built as a module and remove the removal function in V2
> ---
> drivers/cpufreq/Kconfig.arm | 4 +--
> drivers/cpufreq/tegra124-cpufreq.c | 41 ++----------------------------
> 2 files changed, 4 insertions(+), 41 deletions(-)
>
> diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
> index 4e1131ef85ae..1d83b6e81222 100644
> --- a/drivers/cpufreq/Kconfig.arm
> +++ b/drivers/cpufreq/Kconfig.arm
> @@ -261,8 +261,8 @@ config ARM_TEGRA20_CPUFREQ
> This adds the CPUFreq driver support for Tegra20 SOCs.
>
> config ARM_TEGRA124_CPUFREQ
> - tristate "Tegra124 CPUFreq support"
> - depends on ARCH_TEGRA && CPUFREQ_DT && REGULATOR
> + bool "Tegra124 CPUFreq support"
> + depends on ARCH_TEGRA && CPUFREQ_DT
> default y
> help
> This adds the CPUFreq driver support for Tegra124 SOCs.
> diff --git a/drivers/cpufreq/tegra124-cpufreq.c b/drivers/cpufreq/tegra124-cpufreq.c
> index 43530254201a..a1bfde0a7950 100644
> --- a/drivers/cpufreq/tegra124-cpufreq.c
> +++ b/drivers/cpufreq/tegra124-cpufreq.c
> @@ -22,11 +22,9 @@
> #include <linux/of.h>
> #include <linux/platform_device.h>
> #include <linux/pm_opp.h>
> -#include <linux/regulator/consumer.h>
> #include <linux/types.h>
>
> struct tegra124_cpufreq_priv {
> - struct regulator *vdd_cpu_reg;
> struct clk *cpu_clk;
> struct clk *pllp_clk;
> struct clk *pllx_clk;
> @@ -60,14 +58,6 @@ static int tegra124_cpu_switch_to_dfll(struct tegra124_cpufreq_priv *priv)
> return ret;
> }
>
> -static void tegra124_cpu_switch_to_pllx(struct tegra124_cpufreq_priv *priv)
> -{
> - clk_set_parent(priv->cpu_clk, priv->pllp_clk);
> - clk_disable_unprepare(priv->dfll_clk);
> - regulator_sync_voltage(priv->vdd_cpu_reg);
> - clk_set_parent(priv->cpu_clk, priv->pllx_clk);
> -}
> -
> static int tegra124_cpufreq_probe(struct platform_device *pdev)
> {
> struct tegra124_cpufreq_priv *priv;
> @@ -88,16 +78,10 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
> if (!np)
> return -ENODEV;
>
> - priv->vdd_cpu_reg = regulator_get(cpu_dev, "vdd-cpu");
> - if (IS_ERR(priv->vdd_cpu_reg)) {
> - ret = PTR_ERR(priv->vdd_cpu_reg);
> - goto out_put_np;
> - }
> -
> priv->cpu_clk = of_clk_get_by_name(np, "cpu_g");
> if (IS_ERR(priv->cpu_clk)) {
> ret = PTR_ERR(priv->cpu_clk);
> - goto out_put_vdd_cpu_reg;
> + goto out_put_np;
> }
>
> priv->dfll_clk = of_clk_get_by_name(np, "dfll");
> @@ -129,15 +113,13 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
> platform_device_register_full(&cpufreq_dt_devinfo);
> if (IS_ERR(priv->cpufreq_dt_pdev)) {
> ret = PTR_ERR(priv->cpufreq_dt_pdev);
> - goto out_switch_to_pllx;
> + goto out_put_pllp_clk;
> }
>
> platform_set_drvdata(pdev, priv);
>
> return 0;
>
> -out_switch_to_pllx:
> - tegra124_cpu_switch_to_pllx(priv);
> out_put_pllp_clk:
> clk_put(priv->pllp_clk);
> out_put_pllx_clk:
> @@ -146,34 +128,15 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
> clk_put(priv->dfll_clk);
> out_put_cpu_clk:
> clk_put(priv->cpu_clk);
> -out_put_vdd_cpu_reg:
> - regulator_put(priv->vdd_cpu_reg);
> out_put_np:
> of_node_put(np);
>
> return ret;
> }
>
> -static int tegra124_cpufreq_remove(struct platform_device *pdev)
> -{
> - struct tegra124_cpufreq_priv *priv = platform_get_drvdata(pdev);
> -
> - platform_device_unregister(priv->cpufreq_dt_pdev);
> - tegra124_cpu_switch_to_pllx(priv);
> -
> - clk_put(priv->pllp_clk);
> - clk_put(priv->pllx_clk);
> - clk_put(priv->dfll_clk);
> - clk_put(priv->cpu_clk);
> - regulator_put(priv->vdd_cpu_reg);
> -
> - return 0;
> -}
> -
> static struct platform_driver tegra124_cpufreq_platdrv = {
> .driver.name = "cpufreq-tegra124",
> .probe = tegra124_cpufreq_probe,
> - .remove = tegra124_cpufreq_remove,
> };
>
> static int __init tegra_cpufreq_init(void)
>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail
2018-12-13 9:34 ` [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail Joseph Lo
2018-12-13 10:49 ` Rafael J. Wysocki
2018-12-13 12:55 ` Jon Hunter
@ 2018-12-18 5:34 ` Viresh Kumar
2 siblings, 0 replies; 40+ messages in thread
From: Viresh Kumar @ 2018-12-18 5:34 UTC (permalink / raw)
To: Joseph Lo
Cc: Thierry Reding, Peter De Schrijver, Jonathan Hunter,
linux-arm-kernel, linux-tegra, linux-clk, linux-pm
On 13-12-18, 17:34, Joseph Lo wrote:
> The Tegra124 cpufreq driver has no information to handle the Vdd-CPU
> rail. So this driver shouldn't handle for the CPU clock switching from
> DFLL to other PLL clocks. It was designed to work on DFLL clock only,
> which handle the frequency/voltage scaling in the background.
>
> This patch removes the driver dependency of the CPU rail, as well as not
> allow it to be built as a module and remove the removal function. So it
> can keep working on DFLL clock.
>
> Cc: Viresh Kumar <viresh.kumar@linaro.org>
> Cc: linux-pm@vger.kernel.org
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - update the commit message since we change the driver not able to be
> built as a module and remove the removal function in V2
> ---
> drivers/cpufreq/Kconfig.arm | 4 +--
> drivers/cpufreq/tegra124-cpufreq.c | 41 ++----------------------------
> 2 files changed, 4 insertions(+), 41 deletions(-)
>
> diff --git a/drivers/cpufreq/Kconfig.arm b/drivers/cpufreq/Kconfig.arm
> index 4e1131ef85ae..1d83b6e81222 100644
> --- a/drivers/cpufreq/Kconfig.arm
> +++ b/drivers/cpufreq/Kconfig.arm
> @@ -261,8 +261,8 @@ config ARM_TEGRA20_CPUFREQ
> This adds the CPUFreq driver support for Tegra20 SOCs.
>
> config ARM_TEGRA124_CPUFREQ
> - tristate "Tegra124 CPUFreq support"
> - depends on ARCH_TEGRA && CPUFREQ_DT && REGULATOR
> + bool "Tegra124 CPUFreq support"
> + depends on ARCH_TEGRA && CPUFREQ_DT
> default y
> help
> This adds the CPUFreq driver support for Tegra124 SOCs.
> diff --git a/drivers/cpufreq/tegra124-cpufreq.c b/drivers/cpufreq/tegra124-cpufreq.c
> index 43530254201a..a1bfde0a7950 100644
> --- a/drivers/cpufreq/tegra124-cpufreq.c
> +++ b/drivers/cpufreq/tegra124-cpufreq.c
> @@ -22,11 +22,9 @@
> #include <linux/of.h>
> #include <linux/platform_device.h>
> #include <linux/pm_opp.h>
> -#include <linux/regulator/consumer.h>
> #include <linux/types.h>
>
> struct tegra124_cpufreq_priv {
> - struct regulator *vdd_cpu_reg;
> struct clk *cpu_clk;
> struct clk *pllp_clk;
> struct clk *pllx_clk;
> @@ -60,14 +58,6 @@ static int tegra124_cpu_switch_to_dfll(struct tegra124_cpufreq_priv *priv)
> return ret;
> }
>
> -static void tegra124_cpu_switch_to_pllx(struct tegra124_cpufreq_priv *priv)
> -{
> - clk_set_parent(priv->cpu_clk, priv->pllp_clk);
> - clk_disable_unprepare(priv->dfll_clk);
> - regulator_sync_voltage(priv->vdd_cpu_reg);
> - clk_set_parent(priv->cpu_clk, priv->pllx_clk);
> -}
> -
> static int tegra124_cpufreq_probe(struct platform_device *pdev)
> {
> struct tegra124_cpufreq_priv *priv;
> @@ -88,16 +78,10 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
> if (!np)
> return -ENODEV;
>
> - priv->vdd_cpu_reg = regulator_get(cpu_dev, "vdd-cpu");
> - if (IS_ERR(priv->vdd_cpu_reg)) {
> - ret = PTR_ERR(priv->vdd_cpu_reg);
> - goto out_put_np;
> - }
> -
> priv->cpu_clk = of_clk_get_by_name(np, "cpu_g");
> if (IS_ERR(priv->cpu_clk)) {
> ret = PTR_ERR(priv->cpu_clk);
> - goto out_put_vdd_cpu_reg;
> + goto out_put_np;
> }
>
> priv->dfll_clk = of_clk_get_by_name(np, "dfll");
> @@ -129,15 +113,13 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
> platform_device_register_full(&cpufreq_dt_devinfo);
> if (IS_ERR(priv->cpufreq_dt_pdev)) {
> ret = PTR_ERR(priv->cpufreq_dt_pdev);
> - goto out_switch_to_pllx;
> + goto out_put_pllp_clk;
> }
>
> platform_set_drvdata(pdev, priv);
>
> return 0;
>
> -out_switch_to_pllx:
> - tegra124_cpu_switch_to_pllx(priv);
> out_put_pllp_clk:
> clk_put(priv->pllp_clk);
> out_put_pllx_clk:
> @@ -146,34 +128,15 @@ static int tegra124_cpufreq_probe(struct platform_device *pdev)
> clk_put(priv->dfll_clk);
> out_put_cpu_clk:
> clk_put(priv->cpu_clk);
> -out_put_vdd_cpu_reg:
> - regulator_put(priv->vdd_cpu_reg);
> out_put_np:
> of_node_put(np);
>
> return ret;
> }
>
> -static int tegra124_cpufreq_remove(struct platform_device *pdev)
> -{
> - struct tegra124_cpufreq_priv *priv = platform_get_drvdata(pdev);
> -
> - platform_device_unregister(priv->cpufreq_dt_pdev);
> - tegra124_cpu_switch_to_pllx(priv);
> -
> - clk_put(priv->pllp_clk);
> - clk_put(priv->pllx_clk);
> - clk_put(priv->dfll_clk);
> - clk_put(priv->cpu_clk);
> - regulator_put(priv->vdd_cpu_reg);
> -
> - return 0;
> -}
> -
> static struct platform_driver tegra124_cpufreq_platdrv = {
> .driver.name = "cpufreq-tegra124",
> .probe = tegra124_cpufreq_probe,
> - .remove = tegra124_cpufreq_remove,
> };
>
> static int __init tegra_cpufreq_init(void)
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
--
viresh
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 13/21] cpufreq: tegra124: extend to support Tegra210
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (11 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 12/21] cpufreq: tegra124: do not handle the CPU rail Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist Joseph Lo
` (7 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo,
Viresh Kumar, linux-pm
Tegra210 uses the same methodology as Tegra124 for CPUFreq controlling
that based on DFLL clock. So extending this driver to support Tegra210.
Cc: Viresh Kumar <viresh.kumar@linaro.org>
Cc: linux-pm@vger.kernel.org
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add two ack tags
---
drivers/cpufreq/tegra124-cpufreq.c | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git a/drivers/cpufreq/tegra124-cpufreq.c b/drivers/cpufreq/tegra124-cpufreq.c
index a1bfde0a7950..ba3795e13ac6 100644
--- a/drivers/cpufreq/tegra124-cpufreq.c
+++ b/drivers/cpufreq/tegra124-cpufreq.c
@@ -144,7 +144,8 @@ static int __init tegra_cpufreq_init(void)
int ret;
struct platform_device *pdev;
- if (!of_machine_is_compatible("nvidia,tegra124"))
+ if (!(of_machine_is_compatible("nvidia,tegra124") ||
+ of_machine_is_compatible("nvidia,tegra210")))
return -ENODEV;
/*
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (12 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 13/21] cpufreq: tegra124: extend to support Tegra210 Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 13:09 ` Jon Hunter
2018-12-18 5:33 ` Viresh Kumar
2018-12-13 9:34 ` [PATCH V2 15/21] arm64: dts: tegra210: add DFLL clock Joseph Lo
` (6 subsequent siblings)
20 siblings, 2 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo,
Viresh Kumar, linux-pm
Tegra210 uses "tegra124-cpufreq" platform driver to register device data
for "cpufreq-dt" driver. So add it in the blacklist for
"cpufreq-dt-platdev" driver to drop that.
Cc: Viresh Kumar <viresh.kumar@linaro.org>
Cc: linux-pm@vger.kernel.org
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- new added in V2
---
drivers/cpufreq/cpufreq-dt-platdev.c | 1 +
1 file changed, 1 insertion(+)
diff --git a/drivers/cpufreq/cpufreq-dt-platdev.c b/drivers/cpufreq/cpufreq-dt-platdev.c
index b1c5468dca16..47729a22c159 100644
--- a/drivers/cpufreq/cpufreq-dt-platdev.c
+++ b/drivers/cpufreq/cpufreq-dt-platdev.c
@@ -119,6 +119,7 @@ static const struct of_device_id blacklist[] __initconst = {
{ .compatible = "mediatek,mt8176", },
{ .compatible = "nvidia,tegra124", },
+ { .compatible = "nvidia,tegra210", },
{ .compatible = "qcom,apq8096", },
{ .compatible = "qcom,msm8996", },
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist
2018-12-13 9:34 ` [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist Joseph Lo
@ 2018-12-13 13:09 ` Jon Hunter
2018-12-18 5:33 ` Viresh Kumar
1 sibling, 0 replies; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 13:09 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk, Viresh Kumar, linux-pm
On 13/12/2018 09:34, Joseph Lo wrote:
> Tegra210 uses "tegra124-cpufreq" platform driver to register device data
> for "cpufreq-dt" driver. So add it in the blacklist for
> "cpufreq-dt-platdev" driver to drop that.
>
> Cc: Viresh Kumar <viresh.kumar@linaro.org>
> Cc: linux-pm@vger.kernel.org
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - new added in V2
> ---
> drivers/cpufreq/cpufreq-dt-platdev.c | 1 +
> 1 file changed, 1 insertion(+)
>
> diff --git a/drivers/cpufreq/cpufreq-dt-platdev.c b/drivers/cpufreq/cpufreq-dt-platdev.c
> index b1c5468dca16..47729a22c159 100644
> --- a/drivers/cpufreq/cpufreq-dt-platdev.c
> +++ b/drivers/cpufreq/cpufreq-dt-platdev.c
> @@ -119,6 +119,7 @@ static const struct of_device_id blacklist[] __initconst = {
> { .compatible = "mediatek,mt8176", },
>
> { .compatible = "nvidia,tegra124", },
> + { .compatible = "nvidia,tegra210", },
>
> { .compatible = "qcom,apq8096", },
> { .compatible = "qcom,msm8996", },
>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread* Re: [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist
2018-12-13 9:34 ` [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist Joseph Lo
2018-12-13 13:09 ` Jon Hunter
@ 2018-12-18 5:33 ` Viresh Kumar
1 sibling, 0 replies; 40+ messages in thread
From: Viresh Kumar @ 2018-12-18 5:33 UTC (permalink / raw)
To: Joseph Lo
Cc: Thierry Reding, Peter De Schrijver, Jonathan Hunter,
linux-arm-kernel, linux-tegra, linux-clk, linux-pm
On 13-12-18, 17:34, Joseph Lo wrote:
> Tegra210 uses "tegra124-cpufreq" platform driver to register device data
> for "cpufreq-dt" driver. So add it in the blacklist for
> "cpufreq-dt-platdev" driver to drop that.
>
> Cc: Viresh Kumar <viresh.kumar@linaro.org>
> Cc: linux-pm@vger.kernel.org
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - new added in V2
> ---
> drivers/cpufreq/cpufreq-dt-platdev.c | 1 +
> 1 file changed, 1 insertion(+)
>
> diff --git a/drivers/cpufreq/cpufreq-dt-platdev.c b/drivers/cpufreq/cpufreq-dt-platdev.c
> index b1c5468dca16..47729a22c159 100644
> --- a/drivers/cpufreq/cpufreq-dt-platdev.c
> +++ b/drivers/cpufreq/cpufreq-dt-platdev.c
> @@ -119,6 +119,7 @@ static const struct of_device_id blacklist[] __initconst = {
> { .compatible = "mediatek,mt8176", },
>
> { .compatible = "nvidia,tegra124", },
> + { .compatible = "nvidia,tegra210", },
>
> { .compatible = "qcom,apq8096", },
> { .compatible = "qcom,msm8996", },
Acked-by: Viresh Kumar <viresh.kumar@linaro.org>
--
viresh
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 15/21] arm64: dts: tegra210: add DFLL clock
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (13 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 14/21] cpufreq: dt-platdev: add Tegra210 to blacklist Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 16/21] arm64: dts: tegra210: add CPU clocks Joseph Lo
` (5 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Add essential DFLL clock properties for Tegra210.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
arch/arm64/boot/dts/nvidia/tegra210.dtsi | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/arch/arm64/boot/dts/nvidia/tegra210.dtsi b/arch/arm64/boot/dts/nvidia/tegra210.dtsi
index 2205d66b0443..a6db62157442 100644
--- a/arch/arm64/boot/dts/nvidia/tegra210.dtsi
+++ b/arch/arm64/boot/dts/nvidia/tegra210.dtsi
@@ -4,6 +4,7 @@
#include <dt-bindings/memory/tegra210-mc.h>
#include <dt-bindings/pinctrl/pinctrl-tegra.h>
#include <dt-bindings/pinctrl/pinctrl-tegra-io-pad.h>
+#include <dt-bindings/reset/tegra210-car.h>
#include <dt-bindings/interrupt-controller/arm-gic.h>
#include <dt-bindings/thermal/tegra124-soctherm.h>
@@ -1131,6 +1132,24 @@
#nvidia,mipi-calibrate-cells = <1>;
};
+ dfll: clock@70110000 {
+ compatible = "nvidia,tegra210-dfll";
+ reg = <0 0x70110000 0 0x100>, /* DFLL control */
+ <0 0x70110000 0 0x100>, /* I2C output control */
+ <0 0x70110100 0 0x100>, /* Integrated I2C controller */
+ <0 0x70110200 0 0x100>; /* Look-up table RAM */
+ interrupts = <GIC_SPI 62 IRQ_TYPE_LEVEL_HIGH>;
+ clocks = <&tegra_car TEGRA210_CLK_DFLL_SOC>,
+ <&tegra_car TEGRA210_CLK_DFLL_REF>,
+ <&tegra_car TEGRA210_CLK_I2C5>;
+ clock-names = "soc", "ref", "i2c";
+ resets = <&tegra_car TEGRA210_RST_DFLL_DVCO>;
+ reset-names = "dvco";
+ #clock-cells = <0>;
+ clock-output-names = "dfllCPU_out";
+ status = "disabled";
+ };
+
aconnect@702c0000 {
compatible = "nvidia,tegra210-aconnect";
clocks = <&tegra_car TEGRA210_CLK_APE>,
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 16/21] arm64: dts: tegra210: add CPU clocks
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (14 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 15/21] arm64: dts: tegra210: add DFLL clock Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 17/21] arm64: dts: tegra210-p2597: add pinmux for PWM-based DFLL support Joseph Lo
` (4 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Add CPU clocks for Tegra210.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
arch/arm64/boot/dts/nvidia/tegra210.dtsi | 6 ++++++
1 file changed, 6 insertions(+)
diff --git a/arch/arm64/boot/dts/nvidia/tegra210.dtsi b/arch/arm64/boot/dts/nvidia/tegra210.dtsi
index a6db62157442..e2baf52fe1af 100644
--- a/arch/arm64/boot/dts/nvidia/tegra210.dtsi
+++ b/arch/arm64/boot/dts/nvidia/tegra210.dtsi
@@ -1304,6 +1304,12 @@
device_type = "cpu";
compatible = "arm,cortex-a57";
reg = <0>;
+ clocks = <&tegra_car TEGRA210_CLK_CCLK_G>,
+ <&tegra_car TEGRA210_CLK_PLL_X>,
+ <&tegra_car TEGRA210_CLK_PLL_P_OUT4>,
+ <&dfll>;
+ clock-names = "cpu_g", "pll_x", "pll_p", "dfll";
+ clock-latency = <300000>;
};
cpu@1 {
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 17/21] arm64: dts: tegra210-p2597: add pinmux for PWM-based DFLL support
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (15 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 16/21] arm64: dts: tegra210: add CPU clocks Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 18/21] arm64: dts: tegra210-p2371-2180: enable DFLL clock Joseph Lo
` (3 subsequent siblings)
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Add pinmux for PWM-based DFLL support.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi | 14 ++++++++++++++
1 file changed, 14 insertions(+)
diff --git a/arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi b/arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi
index a96e6ee70c21..0ee25a5188f8 100644
--- a/arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi
+++ b/arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi
@@ -1278,6 +1278,20 @@
nvidia,open-drain = <TEGRA_PIN_DISABLE>;
};
};
+
+ dvfs_pwm_active_state: dvfs_pwm_active {
+ dvfs_pwm_pbb1 {
+ nvidia,pins = "dvfs_pwm_pbb1";
+ nvidia,tristate = <TEGRA_PIN_DISABLE>;
+ };
+ };
+
+ dvfs_pwm_inactive_state: dvfs_pwm_inactive {
+ dvfs_pwm_pbb1 {
+ nvidia,pins = "dvfs_pwm_pbb1";
+ nvidia,tristate = <TEGRA_PIN_ENABLE>;
+ };
+ };
};
pwm@7000a000 {
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 18/21] arm64: dts: tegra210-p2371-2180: enable DFLL clock
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (16 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 17/21] arm64: dts: tegra210-p2597: add pinmux for PWM-based DFLL support Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 13:11 ` Jon Hunter
2018-12-13 9:34 ` [PATCH V2 19/21] arm64: dts: tegra210-smaug: add CPU power rail regulator Joseph Lo
` (2 subsequent siblings)
20 siblings, 1 reply; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Enable DFLL clock for Jetson TX1 platform.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
---
*V2:
- remove non exist DT bindings
- update the PWM DT bindings accordingly
---
.../boot/dts/nvidia/tegra210-p2371-2180.dts | 21 +++++++++++++++++++
1 file changed, 21 insertions(+)
diff --git a/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts b/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts
index 37e3c46e753f..99c016bfc601 100644
--- a/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts
+++ b/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts
@@ -78,4 +78,25 @@
};
};
};
+
+ clock@70110000 {
+ status = "okay";
+
+ nvidia,cf = <6>;
+ nvidia,ci = <0>;
+ nvidia,cg = <2>;
+ nvidia,droop-ctrl = <0x00000f00>;
+ nvidia,force-mode = <1>;
+ nvidia,sample-rate = <25000>;
+
+ nvidia,pwm-min-microvolts = <708000>;
+ nvidia,pwm-period = <2500>; /* 2.5us */
+ nvidia,pwm-to-pmic;
+ nvidia,pwm-tristate-microvolts = <1000000>;
+ nvidia,pwm-voltage-step-microvolts = <19200>;
+
+ pinctrl-names = "dvfs_pwm_enable", "dvfs_pwm_disable";
+ pinctrl-0 = <&dvfs_pwm_active_state>;
+ pinctrl-1 = <&dvfs_pwm_inactive_state>;
+ };
};
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* Re: [PATCH V2 18/21] arm64: dts: tegra210-p2371-2180: enable DFLL clock
2018-12-13 9:34 ` [PATCH V2 18/21] arm64: dts: tegra210-p2371-2180: enable DFLL clock Joseph Lo
@ 2018-12-13 13:11 ` Jon Hunter
0 siblings, 0 replies; 40+ messages in thread
From: Jon Hunter @ 2018-12-13 13:11 UTC (permalink / raw)
To: Joseph Lo, Thierry Reding, Peter De Schrijver
Cc: linux-arm-kernel, linux-tegra, linux-clk
On 13/12/2018 09:34, Joseph Lo wrote:
> Enable DFLL clock for Jetson TX1 platform.
>
> Signed-off-by: Joseph Lo <josephl@nvidia.com>
> ---
> *V2:
> - remove non exist DT bindings
> - update the PWM DT bindings accordingly
> ---
> .../boot/dts/nvidia/tegra210-p2371-2180.dts | 21 +++++++++++++++++++
> 1 file changed, 21 insertions(+)
>
> diff --git a/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts b/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts
> index 37e3c46e753f..99c016bfc601 100644
> --- a/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts
> +++ b/arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts
> @@ -78,4 +78,25 @@
> };
> };
> };
> +
> + clock@70110000 {
> + status = "okay";
> +
> + nvidia,cf = <6>;
> + nvidia,ci = <0>;
> + nvidia,cg = <2>;
> + nvidia,droop-ctrl = <0x00000f00>;
> + nvidia,force-mode = <1>;
> + nvidia,sample-rate = <25000>;
> +
> + nvidia,pwm-min-microvolts = <708000>;
> + nvidia,pwm-period = <2500>; /* 2.5us */
> + nvidia,pwm-to-pmic;
> + nvidia,pwm-tristate-microvolts = <1000000>;
> + nvidia,pwm-voltage-step-microvolts = <19200>;
> +
> + pinctrl-names = "dvfs_pwm_enable", "dvfs_pwm_disable";
> + pinctrl-0 = <&dvfs_pwm_active_state>;
> + pinctrl-1 = <&dvfs_pwm_inactive_state>;
> + };
> };
Acked-by: Jon Hunter <jonathanh@nvidia.com>
Cheers
Jon
--
nvpublic
^ permalink raw reply [flat|nested] 40+ messages in thread
* [PATCH V2 19/21] arm64: dts: tegra210-smaug: add CPU power rail regulator
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (17 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 18/21] arm64: dts: tegra210-p2371-2180: enable DFLL clock Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 20/21] arm64: dts: tegra210-smaug: enable DFLL clock Joseph Lo
2018-12-13 9:34 ` [PATCH V2 21/21] arm64: defconfig: Enable MAX8973 regulator Joseph Lo
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Add CPU power rail regulator for Smaug board.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
arch/arm64/boot/dts/nvidia/tegra210-smaug.dts | 19 +++++++++++++++++++
1 file changed, 19 insertions(+)
diff --git a/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts b/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts
index 43cae4798870..79cfcd5b7e62 100644
--- a/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts
+++ b/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts
@@ -1340,6 +1340,25 @@
status = "okay";
clock-frequency = <1000000>;
+ max77621_cpu: max77621@1b {
+ compatible = "maxim,max77621";
+ reg = <0x1b>;
+ interrupt-parent = <&gpio>;
+ interrupts = <TEGRA_GPIO(Y, 1) IRQ_TYPE_LEVEL_LOW>;
+ regulator-always-on;
+ regulator-boot-on;
+ regulator-min-microvolt = <800000>;
+ regulator-max-microvolt = <1231250>;
+ regulator-name = "PPVAR_CPU";
+ regulator-ramp-delay = <12500>;
+ maxim,dvs-default-state = <1>;
+ maxim,enable-active-discharge;
+ maxim,enable-bias-control;
+ maxim,enable-etr;
+ maxim,enable-gpio = <&max77620 5 0>;
+ maxim,externally-enable;
+ };
+
max77620: max77620@3c {
compatible = "maxim,max77620";
reg = <0x3c>;
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 20/21] arm64: dts: tegra210-smaug: enable DFLL clock
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (18 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 19/21] arm64: dts: tegra210-smaug: add CPU power rail regulator Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
2018-12-13 9:34 ` [PATCH V2 21/21] arm64: defconfig: Enable MAX8973 regulator Joseph Lo
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
Enable DFLL clock for Smaug board.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
arch/arm64/boot/dts/nvidia/tegra210-smaug.dts | 12 ++++++++++++
1 file changed, 12 insertions(+)
diff --git a/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts b/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts
index 79cfcd5b7e62..c08c5471b974 100644
--- a/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts
+++ b/arch/arm64/boot/dts/nvidia/tegra210-smaug.dts
@@ -1698,6 +1698,18 @@
status = "okay";
};
+ clock@70110000 {
+ status = "okay";
+ nvidia,cf = <6>;
+ nvidia,ci = <0>;
+ nvidia,cg = <2>;
+ nvidia,droop-ctrl = <0x00000f00>;
+ nvidia,force-mode = <1>;
+ nvidia,i2c-fs-rate = <400000>;
+ nvidia,sample-rate = <12500>;
+ vdd-cpu-supply = <&max77621_cpu>;
+ };
+
aconnect@702c0000 {
status = "okay";
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread* [PATCH V2 21/21] arm64: defconfig: Enable MAX8973 regulator
2018-12-13 9:34 [PATCH V2 00/21] Tegra210 DFLL support Joseph Lo
` (19 preceding siblings ...)
2018-12-13 9:34 ` [PATCH V2 20/21] arm64: dts: tegra210-smaug: enable DFLL clock Joseph Lo
@ 2018-12-13 9:34 ` Joseph Lo
20 siblings, 0 replies; 40+ messages in thread
From: Joseph Lo @ 2018-12-13 9:34 UTC (permalink / raw)
To: Thierry Reding, Peter De Schrijver, Jonathan Hunter
Cc: linux-arm-kernel, linux-tegra, linux-clk, Joseph Lo
The Tegra210 Smaug board uses MAX77621 for both CPU & GPU rail. Note
that max8973 and max77621 share the same driver. So enable this driver
for the PMIC.
Signed-off-by: Joseph Lo <josephl@nvidia.com>
Acked-by: Jon Hunter <jonathanh@nvidia.com>
---
*V2:
- add ack tag
---
arch/arm64/configs/defconfig | 1 +
1 file changed, 1 insertion(+)
diff --git a/arch/arm64/configs/defconfig b/arch/arm64/configs/defconfig
index 5c2b1f6842f8..8dab129395a1 100644
--- a/arch/arm64/configs/defconfig
+++ b/arch/arm64/configs/defconfig
@@ -420,6 +420,7 @@ CONFIG_REGULATOR_GPIO=y
CONFIG_REGULATOR_HI6421V530=y
CONFIG_REGULATOR_HI655X=y
CONFIG_REGULATOR_MAX77620=y
+CONFIG_REGULATOR_MAX8973=y
CONFIG_REGULATOR_PWM=y
CONFIG_REGULATOR_QCOM_RPMH=y
CONFIG_REGULATOR_QCOM_SMD_RPM=y
--
2.19.2
^ permalink raw reply related [flat|nested] 40+ messages in thread