Tegra210 DFLL support
Subsystems (5)
v3 cover Tegra210 DFLL support
This series introduces support for the DFLL as a CPU clock source on Tegra210. As Jetson TX1 uses a PWM controlled regulator IC which is driven directly by the DFLLs PWM output, we also introduce support for PWM regulators next to I2C controlled regulators. The DFLL output frequency is directly controlled by the regulator voltage. The registers for controlling the PWM are part of the DFLL IP block, so there's no separate linux regulator object involved because the regulator IC only supplies the rail powering the CPUs. It doesn't have any other controls.
The patch 1~4 are the patches of DT bindings update for DFLL clock and Tegra124 cpufreq, which add PWM and Tegra210 support for DFLL clock and remove deprecate properties for Tegra124 cpufreq bindings.
The patch 5~10 are the patches for DFLL clock driver update for PWM-mode DFLL support.
The patch 11~13 are the Tegra124 cpufreq driver update to make it work with Tegra210.
The patch 14~19 are the devicetree files update for Tegra210 SoC and platforms. Two platforms are updated here for different DFLL mode usage. The Tegra210-p2371-2180 (a.k.a. Jetson Tx1) uses DFLL-PWM and the Tegra210-smaug (a.k.a. Pixel C) uses DFLL-I2C. So two different modes are verified with this series.
The patch 20 is the patch for enabling the CPU regulator for Smaug board.
* Update in V3:
- Squash patch 9 in previous series into patch 7 (ref. [0])
- minor fixes in patch 6 for geting alignment data
- more variable type fixes in patch 7
- fix the error handling in patch 8
- collect more ack tags
* Update in V2:
- Add two patches that suggested from comments in V1. See patch 9 and 14.
- Update DT binding for DFLL-PWM mode in patch 1.
- Update the code for how to get regulator data from DT or regulator API in patch 6.
- Update to use lut_uv table for LUT lookup in patch 7. That makes the generic lut table to work with both I2C and PWM mode.
- not allow Tegra124 cpufreq driver to be built as a module and remove the removal function in patch 12.
[0]: http://patchwork.ozlabs.org/project/linux-tegra/list/?series=81595
Joseph Lo (17):
dt-bindings: clock: tegra124-dfll: add Tegra210 support
dt-bindings: cpufreq: tegra124: remove vdd-cpu-supply from required
properties
dt-bindings: cpufreq: tegra124: remove cpu_lp clock from required
properties
clk: tegra: dfll: CVB calculation alignment with the regulator
clk: tegra: dfll: support PWM regulator control
clk: tegra: dfll: round down voltages based on alignment
clk: tegra: dfll: add CVB tables for Tegra210
cpufreq: tegra124: do not handle the CPU rail
cpufreq: tegra124: extend to support Tegra210
cpufreq: dt-platdev: add Tegra210 to blacklist
arm64: dts: tegra210: add DFLL clock
arm64: dts: tegra210: add CPU clocks
arm64: dts: tegra210-p2597: add pinmux for PWM-based DFLL support
arm64: dts: tegra210-p2371-2180: enable DFLL clock
arm64: dts: tegra210-smaug: add CPU power rail regulator
arm64: dts: tegra210-smaug: enable DFLL clock
arm64: defconfig: Enable MAX8973 regulator
Peter De Schrijver (3):
dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM
regulator
clk: tegra: dfll: registration for multiple SoCs
clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210
.../bindings/clock/nvidia,tegra124-dfll.txt | 83 ++- .../cpufreq/nvidia,tegra124-cpufreq.txt | 6 +- .../boot/dts/nvidia/tegra210-p2371-2180.dts | 21 + .../arm64/boot/dts/nvidia/tegra210-p2597.dtsi | 14 + arch/arm64/boot/dts/nvidia/tegra210-smaug.dts | 31 ++ arch/arm64/boot/dts/nvidia/tegra210.dtsi | 25 + arch/arm64/configs/defconfig | 1 + drivers/clk/tegra/Kconfig | 5 + drivers/clk/tegra/Makefile | 2 +- drivers/clk/tegra/clk-dfll.c | 459 +++++++++++++--- drivers/clk/tegra/clk-dfll.h | 6 +- drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 520 +++++++++++++++++- drivers/clk/tegra/cvb.c | 12 +- drivers/clk/tegra/cvb.h | 7 +- drivers/cpufreq/Kconfig.arm | 4 +- drivers/cpufreq/cpufreq-dt-platdev.c | 1 + drivers/cpufreq/tegra124-cpufreq.c | 44 +- 17 files changed, 1093 insertions(+), 148 deletions(-)
Signature · 1 line
2.20.1
PATCH v3 1/20 dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator
From: Peter De Schrijver <[email protected]>
Add new properties to configure the DFLL PWM regulator support.
---
*V3:
- no change
*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(-)
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +77 -2
@@ -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>; + }; + }; +};
Signature · 1 line
2.20.1
Re: [PATCH V3 01/20] dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator
Quoted 114 lines · Joseph Lo
From: Peter De Schrijver <[email protected]>
Add new properties to configure the DFLL PWM regulator support.
Signed-off-by Peter De Schrijver <[email protected]>Signed-off-by Joseph Lo <[email protected]>---
*V3:
- no change
*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(-)Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +67
-2@@ -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";
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt clock@70110000 { · line 153
Quoted 10 lines
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +10
-0+ 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>; + }; + }; +};
Cheers
Jon
Signature · 1 line
nvpublic
Rob Herring
maintainerRe: [PATCH V3 01/20] dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator
In reply to Joseph LoQuoted 34 lines · Joseph Lo
From: Peter De Schrijver <[email protected]>
Add new properties to configure the DFLL PWM regulator support.
Signed-off-by Peter De Schrijver <[email protected]>Signed-off-by Joseph Lo <[email protected]>---
*V3:
- no change
*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(-)Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +0
-1@@ -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.
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt Required properties for the control loop parameters: · line 54
Quoted 10 lines
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +5
-1+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.
Needs unit suffix.
Re: [PATCH V3 01/20] dt-bindings: clock: tegra124-dfll: Update DFLL binding for PWM regulator
Quoted 42 lines · Rob Herring
Quoted 41 lines · Joseph Lo
From: Peter De Schrijver <[email protected]>
Add new properties to configure the DFLL PWM regulator support.
Signed-off-by Peter De Schrijver <[email protected]>Signed-off-by Joseph Lo <[email protected]>---
*V3:
- no change
*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(-)Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +3
-1@@ -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.
Quoted 6 lines
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt Required properties for the control loop parameters: · line 54
Quoted 3 lines
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +2
-1-Example: +Required properties for PWM mode: +- nvidia,pwm-period: period of PWM square wave in microseconds.Needs unit suffix.
Hi Rob,
Thanks for reviewing these DT binding patches, will fix it.
Joseph
PATCH v3 2/20 dt-bindings: clock: tegra124-dfll: add Tegra210 support
In reply to Joseph LoAdd Tegra210 support for DFLL clock.
---
*V3:
- no change
*V2:
- add ack tag
--- .../devicetree/bindings/clock/nvidia,tegra124-dfll.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
Documentation/devicetree/bindings/clock/nvidia,tegra124-dfll.txt +3 -1
@@ -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.
Signature · 1 line
2.20.1
Re: [PATCH V3 02/20] dt-bindings: clock: tegra124-dfll: add Tegra210 support
Quoted 5 lines · Joseph Lo
Add Tegra210 support for DFLL clock.
Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>
Quoted 9 lines
---
*V3:
- no change
*V2:
- add ack tag--- .../devicetree/bindings/clock/nvidia,tegra124-dfll.txt | 4 +++- 1 file changed, 3 insertions(+), 1 deletion(-)
Re: [PATCH V3 02/20] dt-bindings: clock: tegra124-dfll: add Tegra210 support
In reply to Joseph LoQuoting Joseph Lo (2018-12-18 01:12:14)
Quoted 6 lines
Add Tegra210 support for DFLL clock.
Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>---
PATCH v3 3/20 dt-bindings: cpufreq: tegra124: remove vdd-cpu-supply from required properties
In reply to Joseph LoThe 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.
---
*V3:
- no change
*V2:
- add ack tag
--- .../devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt | 2 -- 1 file changed, 2 deletions(-)
Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt +0 -2
@@ -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>; }; <...>
Signature · 1 line
2.20.1
Re: [PATCH V3 03/20] dt-bindings: cpufreq: tegra124: remove vdd-cpu-supply from required properties
Quoted 7 lines · Joseph Lo
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.
Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>
Quoted 9 lines
---
*V3:
- no change
*V2:
- add ack tag--- .../devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt | 2 -- 1 file changed, 2 deletions(-)
PATCH v3 4/20 dt-bindings: cpufreq: tegra124: remove cpu_lp clock from required properties
In reply to Joseph LoThe 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.
---
*V3:
- no change
*V2:
- add ack tag
--- .../devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
Documentation/devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt +1 -3
@@ -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>; };
Signature · 1 line
2.20.1
Re: [PATCH V3 04/20] dt-bindings: cpufreq: tegra124: remove cpu_lp clock from required properties
Quoted 7 lines · Joseph Lo
The
cpu_lpclock 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.Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>
Quoted 9 lines
---
*V3:
- no change
*V2:
- add ack tag--- .../devicetree/bindings/cpufreq/nvidia,tegra124-cpufreq.txt | 4 +--- 1 file changed, 1 insertion(+), 3 deletions(-)
PATCH v3 5/20 clk: tegra: dfll: registration for multiple SoCs
In reply to Joseph LoFrom: Peter De Schrijver <[email protected]>
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.
---
*V3:
- no change
*V2:
- add ack tag
--- drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 45 ++++++++++++++++------ 1 file changed, 34 insertions(+), 11 deletions(-)
drivers/clk/tegra/clk-tegra124-dfll-fcpu.c +34 -11
@@ -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 <[email protected]> * Paul Walmsley <[email protected]>
@@ -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 )
Signature · 1 line
2.20.1
Re: [PATCH V3 05/20] clk: tegra: dfll: registration for multiple SoCs
Quoting Joseph Lo (2018-12-18 01:12:17)
Quoted 10 lines
From: Peter De Schrijver <[email protected]>
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 <[email protected]>Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>---
PATCH v3 6/20 clk: tegra: dfll: CVB calculation alignment with the regulator
In reply to Joseph LoThe 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 <[email protected]>" and "Alex Frid <[email protected]>".
---
*V3:
- remove redundant variable initialization code in get_alignment_from_dt
- fix the error handling when retuning error from get_alignment_from_regulator
*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 | 49 +++++++++++++++++++--- drivers/clk/tegra/cvb.c | 12 +++--- drivers/clk/tegra/cvb.h | 6 +-- 4 files changed, 59 insertions(+), 14 deletions(-)
drivers/clk/tegra/clk-dfll.h +5 -1
@@ -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 <[email protected]> * Paul Walmsley <[email protected]>
@@ -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 );
drivers/clk/tegra/clk-tegra124-dfll-fcpu.c +44 -5
82 lines not on this page · raw message
drivers/clk/tegra/cvb.c +7 -5
@@ -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; }
drivers/clk/tegra/cvb.h +3 -3
@@ -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);
Signature · 1 line
2.20.1
Re: [PATCH V3 06/20] clk: tegra: dfll: CVB calculation alignment with the regulator
Quoted 215 lines · 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 <[email protected]>" and "Alex Frid <[email protected]>".
Signed-off-by Joseph Lo <[email protected]>---
*V3:
- remove redundant variable initialization code inget_alignment_from_dt
- fix the error handling when retuning error fromget_alignment_from_regulator
*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 | 49 +++++++++++++++++++--- drivers/clk/tegra/cvb.c | 12 +++--- drivers/clk/tegra/cvb.h | 6 +-- 4 files changed, 59 insertions(+), 14 deletions(-)drivers/clk/tegra/clk-dfll.h +5
-1@@ -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 <[email protected]> * Paul Walmsley <[email protected]> @@ -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 );drivers/clk/tegra/clk-tegra124-dfll-fcpu.c +44
-5@@ -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,42 @@ static const struct of_device_id tegra124_dfll_fcpu_of_match[] = { { }, }; +static void get_alignment_from_dt (struct device *dev, +struct rail_alignment *align) +{ +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 +164,22 @@ 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) +return err; + } + 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));drivers/clk/tegra/cvb.c +7
-5@@ -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; }drivers/clk/tegra/cvb.h +0
-1@@ -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 {
drivers/clk/tegra/cvb.h struct cvb_table { · line 66
Quoted 10 lines
drivers/clk/tegra/cvb.h +3
-2const 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);
Cheers
Jon
Signature · 1 line
nvpublic
Re: [PATCH V3 06/20] clk: tegra: dfll: CVB calculation alignment with the regulator
In reply to Joseph LoQuoting Joseph Lo (2018-12-18 01:12:18)
Quoted 9 lines
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.
Quoted 5 lines
Based on the work done of "Peter De Schrijver <[email protected]>" and "Alex Frid <[email protected]>".
Signed-off-by Joseph Lo <[email protected]>---
PATCH v3 7/20 clk: tegra: dfll: support PWM regulator control
In reply to Joseph LoThe 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 <[email protected]>.
---
*V3:
- more variable type fixes for reg_init_uV and lut_uv
- add WARN_ON for 'find_vdd_map_*' APIs if that could be called accidently in PWM mode
*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 | 444 +++++++++++++++++++++++++++++------ 1 file changed, 377 insertions(+), 67 deletions(-)
drivers/clk/tegra/clk-dfll.c +377 -67
@@ -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 <[email protected]> * Paul Walmsley <[email protected]>
@@ -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 ) { +u32 vinit = td->reg_init_uV; +int vstep = td->soc->alignment.step_uv; +unsigned long 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); + } }/*
@@ -631,7 +804,8 @@ 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; +unsigned long uv; +int i; opp =dev_pm_opp_find_freq_ceil (td->soc->dev, &rate);if (IS_ERR (opp))
@@ -640,8 +814,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 +1037,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 +1068,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 +1353,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 ; }
@@ -1351,6 +1535,9 @@ static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV) {int i, n_voltages, reg_uV; +if (WARN_ON (td->pmu_if ==TEGRA_DFLL_PMU_PWM )) +return -EINVAL ; + n_voltages =regulator_count_voltages (td->vdd_reg);for (i =0 ; i < n_voltages; i++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);
@@ -1373,6 +1560,9 @@ static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV) {int i, n_voltages, reg_uV; +if (WARN_ON (td->pmu_if ==TEGRA_DFLL_PMU_PWM )) +return -EINVAL ; + n_voltages =regulator_count_voltages (td->vdd_reg);for (i =0 ; i < n_voltages; i++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);
@@ -1387,9 +1577,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 +1639,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 +1668,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 +1784,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 +1900,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 +1912,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" );
Signature · 1 line
2.20.1
Re: [PATCH V3 07/20] clk: tegra: dfll: support PWM regulator control
Quoted 672 lines · 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 <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
*V3:
- more variable type fixes forreg_init_uVandlut_uv
- addWARN_ONfor 'find_vdd_map_*' APIs if that could be called accidently in PWM mode
*V2:
- movereg_init_uVto 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 uselut_uvtable for LUT look up. This makes the genericlut_uvtable to work with both PWM and I2C mode.--- drivers/clk/tegra/clk-dfll.c | 444 +++++++++++++++++++++++++++++------ 1 file changed, 377 insertions(+), 67 deletions(-)drivers/clk/tegra/clk-dfll.c +371
-67@@ -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 <[email protected]> * Paul Walmsley <[email protected]> @@ -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 ) { +u32 vinit = td->reg_init_uV; +int vstep = td->soc->alignment.step_uv; +unsigned long 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); + } }/* @@ -631,7 +804,8 @@ 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; +unsigned long uv; +int i; opp =dev_pm_opp_find_freq_ceil (td->soc->dev, &rate);if (IS_ERR (opp))@@ -640,8 +814,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 +1037,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 +1068,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 +1353,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 ; }@@ -1351,6 +1535,9 @@ static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV) {int i, n_voltages, reg_uV; +if (WARN_ON (td->pmu_if ==TEGRA_DFLL_PMU_PWM )) +return -EINVAL ; + n_voltages =regulator_count_voltages (td->vdd_reg);for (i =0 ; i < n_voltages; i++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);@@ -1373,6 +1560,9 @@ static int find_vdd_map_entry_min(struct tegra_dfll *td, int uV) {int i, n_voltages, reg_uV; +if (WARN_ON (td->pmu_if ==TEGRA_DFLL_PMU_PWM )) +return -EINVAL ; + n_voltages =regulator_count_voltages (td->vdd_reg);for (i =0 ; i < n_voltages; i++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);@@ -1387,9 +1577,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 +1639,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 +1668,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 +1784,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 +1900,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 +1912,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;
drivers/clk/tegra/clk-dfll.c int tegra_dfll_register(struct platform_device *pdev, · line 1938
Quoted 10 lines
drivers/clk/tegra/clk-dfll.c +6
-0+ 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" );
Cheers
Jon
Signature · 1 line
nvpublic
Re: [PATCH V3 07/20] clk: tegra: dfll: support PWM regulator control
In reply to Joseph LoQuoting Joseph Lo (2018-12-18 01:12:19)
Quoted 9 lines
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.
Quoted 8 lines
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 <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
PATCH v3 8/20 clk: tegra: dfll: round down voltages based on alignment
In reply to Joseph LoWhen 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 <[email protected]>.
---
*v3:
- fix error handling code when regulator_list_voltage returns error
*V2:
- s/align_volt/align_step/
- s/reg_volt/reg_volt_id/
--- drivers/clk/tegra/clk-dfll.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-)
drivers/clk/tegra/clk-dfll.c +13 -8
@@ -804,18 +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; -unsigned long uv; -int i; +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; }
@@ -1533,18 +1532,21 @@ 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_uV,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++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);if (reg_uV <0 )break ; -if (uV == reg_uV) + reg_volt_id = reg_uV / td->soc->alignment.step_uv; + +if (align_step == reg_volt_id)return i; }
@@ -1558,18 +1560,21 @@ 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_uV, 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++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);if (reg_uV <0 )break ; -if (uV <= reg_uV) + reg_volt_id = reg_uV / td->soc->alignment.step_uv; + +if (align_step <= reg_volt_id)return i; }
Signature · 1 line
2.20.1
Re: [PATCH V3 08/20] clk: tegra: dfll: round down voltages based on alignment
Quoted 82 lines · 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 <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
*v3:
- fix error handling code whenregulator_list_voltagereturns error
*V2:
- s/align_volt/align_step/
- s/reg_volt/reg_volt_id/--- drivers/clk/tegra/clk-dfll.c | 21 +++++++++++++-------- 1 file changed, 13 insertions(+), 8 deletions(-)drivers/clk/tegra/clk-dfll.c +10
-7@@ -804,18 +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; -unsigned long uv; -int i; +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; }@@ -1533,18 +1532,21 @@ 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_uV,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++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);if (reg_uV <0 )break ; -if (uV == reg_uV) + reg_volt_id = reg_uV / td->soc->alignment.step_uv; + +if (align_step == reg_volt_id)return i; }@@ -1558,18 +1560,21 @@ 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_uV, 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++) { reg_uV =regulator_list_voltage (td->vdd_reg, i);
drivers/clk/tegra/clk-dfll.c static int find_vdd_map_entry_exact(struct tegra_dfll *td, int uV) · line 1580
Quoted 10 lines
drivers/clk/tegra/clk-dfll.c +3
-1if (reg_uV <0 )break ; -if (uV <= reg_uV) + reg_volt_id = reg_uV / td->soc->alignment.step_uv; + +if (align_step <= reg_volt_id)return i; }
Cheers
Jon
Signature · 1 line
nvpublic
Re: [PATCH V3 08/20] clk: tegra: dfll: round down voltages based on alignment
In reply to Joseph LoQuoting Joseph Lo (2018-12-18 01:12:20)
Quoted 8 lines
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 <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
PATCH v3 9/20 clk: tegra: dfll: add CVB tables for Tegra210
In reply to Joseph LoAdd CVB tables with different chip characterization, so that we can generate the customize OPP table that suitable for different chips with different SKUs.
The parameter 'tune_high_min_millivolts' is first time introduced in this patch, which didn't use in the DFLL driver for clock and voltage tuning before. It will be used later when DFLL in high voltage range.
---
*V3:
- update the commit message for 'tune_high_min_millivolts' parameter
*V2:
- no update
--- drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 426 +++++++++++++++++++++ drivers/clk/tegra/cvb.h | 1 + 2 files changed, 427 insertions(+)
drivers/clk/tegra/clk-tegra124-dfll-fcpu.c +426 -0
@@ -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 + }, { }, };
drivers/clk/tegra/cvb.h +1 -0
@@ -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 {
Signature · 1 line
2.20.1
Re: [PATCH V3 09/20] clk: tegra: dfll: add CVB tables for Tegra210
Quoted 474 lines · 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.
The parameter '
tune_high_min_millivolts' is first time introduced in this patch, which didn't use in the DFLL driver for clock and voltage tuning before. It will be used later when DFLL in high voltage range.Signed-off-by Joseph Lo <[email protected]>---
*V3:
- update the commit message for 'tune_high_min_millivolts' parameter
*V2:
- no update--- drivers/clk/tegra/clk-tegra124-dfll-fcpu.c | 426 +++++++++++++++++++++ drivers/clk/tegra/cvb.h | 1 + 2 files changed, 427 insertions(+)drivers/clk/tegra/clk-tegra124-dfll-fcpu.c +426
-0@@ -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 + }, { }, };drivers/clk/tegra/cvb.h +0
-0
drivers/clk/tegra/cvb.h struct cvb_cpu_dfll_data { · line 47
Quoted 7 lines
drivers/clk/tegra/cvb.h +1
-0@@ -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 {
Cheers
Jon
Signature · 1 line
nvpublic
Re: [PATCH V3 09/20] clk: tegra: dfll: add CVB tables for Tegra210
In reply to Joseph LoQuoting Joseph Lo (2018-12-18 01:12:21)
Quoted 10 lines
Add CVB tables with different chip characterization, so that we can generate the customize OPP table that suitable for different chips with different SKUs.
The parameter '
tune_high_min_millivolts' is first time introduced in this patch, which didn't use in the DFLL driver for clock and voltage tuning before. It will be used later when DFLL in high voltage range.Signed-off-by Joseph Lo <[email protected]>---
PATCH v3 10/20 clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210
In reply to Joseph LoFrom: Peter De Schrijver <[email protected]>
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.
---
*V3:
- no change
*V2:
- add ack tag
--- drivers/clk/tegra/Kconfig | 5 +++++ drivers/clk/tegra/Makefile | 2 +- 2 files changed, 6 insertions(+), 1 deletion(-)
drivers/clk/tegra/Kconfig +5 -0
@@ -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
drivers/clk/tegra/Makefile +1 -1
@@ -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
Signature · 1 line
2.20.1
Stephen Boyd
maintainerRe: [PATCH V3 10/20] clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210
Quoting Joseph Lo (2018-12-18 01:12:22)
drivers/clk/tegra/Kconfig config TEGRA_CLK_EMC · line 10
Quoted 11 lines
drivers/clk/tegra/Kconfig +3
-0@@ -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)
Nitpick: Drop the parenthesis please.
Quoted 2 lines
drivers/clk/tegra/Kconfig +2
-0+ select PM_OPP + def_bool y
Re: [PATCH V3 10/20] clk: tegra: dfll: build clk-dfll.c for Tegra124 and Tegra210
Quoted 14 lines · Stephen Boyd
Quoting Joseph Lo (2018-12-18 01:12:22)
drivers/clk/tegra/Kconfig config TEGRA_CLK_EMC · line 10
Quoted 11 lines
drivers/clk/tegra/Kconfig +3
-0@@ -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)Nitpick: Drop the parenthesis please.
Hi Stephen,
Thanks for reviewing. Will fix that.
Joseph
Quoted 11 lines
drivers/clk/tegra/Kconfig config TEGRA_CLK_EMC · line 12
Quoted 3 lines
drivers/clk/tegra/Kconfig +2
-0+ select PM_OPP + def_bool y_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v3 11/20 cpufreq: tegra124: do not handle the CPU rail
In reply to Joseph LoThe 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.
---
*V3:
- add ack tags
*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(-)
drivers/cpufreq/Kconfig.arm +2 -2
@@ -272,8 +272,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.
drivers/cpufreq/tegra124-cpufreq.c +2 -39
92 lines not on this page · raw message
Signature · 1 line
2.20.1
Rafael J. Wysocki
maintainerRe: [PATCH V3 11/20] cpufreq: tegra124: do not handle the CPU rail
Quoted 10 lines · Joseph Lo
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.
Quoted 5 lines
Cc Viresh Kumar <[email protected]>Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>Acked-by Viresh Kumar <[email protected]>
I'm assuming that this entire series will go in via arm-soc, so I won't be picking up the cpufreq patches from it.
Please let me know if that is not what you want.
Thanks,
Rafael
Re: [PATCH V3 11/20] cpufreq: tegra124: do not handle the CPU rail
Quoted 17 lines · Rafael J. Wysocki
Quoted 10 lines · Joseph Lo
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.
Quoted 5 lines
Cc Viresh Kumar <[email protected]>Signed-off-by Joseph Lo <[email protected]>Acked-by Jon Hunter <[email protected]>Acked-by Viresh Kumar <[email protected]>
Quoted 8 lines
I'm assuming that this entire series will go in via arm-soc, so I won't be picking up the cpufreq patches from it.
Please let me know if that is not what you want.
Thanks,
Rafael
Hi Rafael,
Thanks, will check with Thierry.
Joseph
PATCH v3 12/20 cpufreq: tegra124: extend to support Tegra210
In reply to Joseph LoTegra210 uses the same methodology as Tegra124 for CPUFreq controlling that based on DFLL clock. So extending this driver to support Tegra210.
---
*V3:
- no change
*V2:
- add two ack tags
--- drivers/cpufreq/tegra124-cpufreq.c | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-)
drivers/cpufreq/tegra124-cpufreq.c +2 -1
@@ -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 ;/*
Signature · 1 line
2.20.1
PATCH v3 13/20 cpufreq: dt-platdev: add Tegra210 to blacklist
In reply to Joseph LoTegra210 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.
---
*V3:
- add ack tags
*V2:
- new added in V2
--- drivers/cpufreq/cpufreq-dt-platdev.c | 1 + 1 file changed, 1 insertion(+)
drivers/cpufreq/cpufreq-dt-platdev.c +1 -0
@@ -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", },
Signature · 1 line
2.20.1
PATCH v3 14/20 arm64: dts: tegra210: add DFLL clock
In reply to Joseph LoAdd essential DFLL clock properties for Tegra210.
---
*V3:
- no change
*V2:
- add ack tag
--- arch/arm64/boot/dts/nvidia/tegra210.dtsi | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
arch/arm64/boot/dts/nvidia/tegra210.dtsi +19 -0
@@ -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>,
Signature · 1 line
2.20.1
PATCH v3 15/20 arm64: dts: tegra210: add CPU clocks
In reply to Joseph LoAdd CPU clocks for Tegra210.
---
*V3:
- no change
*V2:
- add ack tag
--- arch/arm64/boot/dts/nvidia/tegra210.dtsi | 6 ++++++ 1 file changed, 6 insertions(+)
arch/arm64/boot/dts/nvidia/tegra210.dtsi +6 -0
@@ -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 {
Signature · 1 line
2.20.1
PATCH v3 16/20 arm64: dts: tegra210-p2597: add pinmux for PWM-based DFLL support
In reply to Joseph LoAdd pinmux for PWM-based DFLL support.
---
*V3:
- no change
*V2:
- add ack tag
--- arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi | 14 ++++++++++++++ 1 file changed, 14 insertions(+)
arch/arm64/boot/dts/nvidia/tegra210-p2597.dtsi +14 -0
@@ -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 {
Signature · 1 line
2.20.1
PATCH v3 17/20 arm64: dts: tegra210-p2371-2180: enable DFLL clock
In reply to Joseph LoEnable DFLL clock for Jetson TX1 platform.
---
*V3:
- add ack tag
*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(+)
arch/arm64/boot/dts/nvidia/tegra210-p2371-2180.dts +21 -0
@@ -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>; + }; };
Signature · 1 line
2.20.1
PATCH v3 18/20 arm64: dts: tegra210-smaug: add CPU power rail regulator
In reply to Joseph LoAdd CPU power rail regulator for Smaug board.
---
*V3:
- no change
*V2:
- add ack tag
--- arch/arm64/boot/dts/nvidia/tegra210-smaug.dts | 19 +++++++++++++++++++ 1 file changed, 19 insertions(+)
arch/arm64/boot/dts/nvidia/tegra210-smaug.dts +19 -0
@@ -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>;
Signature · 1 line
2.20.1
PATCH v3 19/20 arm64: dts: tegra210-smaug: enable DFLL clock
In reply to Joseph LoEnable DFLL clock for Smaug board.
---
*V3:
- no change
*V2:
- add ack tag
--- arch/arm64/boot/dts/nvidia/tegra210-smaug.dts | 12 ++++++++++++ 1 file changed, 12 insertions(+)
arch/arm64/boot/dts/nvidia/tegra210-smaug.dts +12 -0
@@ -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";
Signature · 1 line
2.20.1
PATCH v3 20/20 arm64: defconfig: Enable MAX8973 regulator
In reply to Joseph LoThe 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.
---
*V3:
- no change
*V2:
- add ack tag
--- arch/arm64/configs/defconfig | 1 + 1 file changed, 1 insertion(+)
arch/arm64/configs/defconfig +1 -0
@@ -438,6 +438,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
Signature · 1 line
2.20.1