Add EMC scaling support for Tegra210
Subsystems (5)
v3 cover Add EMC scaling support for Tegra210
This series introduces the EMC clock scaling support for Tegra210. The new version has a significant change, which drops the EMC table bindings and replaces by memory region node of EMC table.
And most of the comments in V1 have been addressed. Thanks.
Joseph Lo (8):
dt-bindings: memory: tegra: Add external memory controller binding for
Tegra210
clk: tegra: Add PLLP_UD and PLLMB_UD for Tegra210
clk: tegra: Export functions for EMC clock scaling
memory: tegra: Add Tegra210 EMC clock driver
memory: tegra: Add EMC scaling support code for Tegra210
memory: tegra: Add EMC scaling sequence code for Tegra210
clk: tegra: Remove the old emc_mux clock for Tegra210
arm64: tegra: Add external memory controller node for Tegra210
.../nvidia,tegra210-emc.txt | 55 + arch/arm64/boot/dts/nvidia/tegra210.dtsi | 33 + drivers/clk/tegra/clk-tegra210.c | 85 +- drivers/memory/tegra/Kconfig | 10 + drivers/memory/tegra/Makefile | 1 + drivers/memory/tegra/tegra210-emc-cc-r21021.c | 1953 +++++++++++++++ drivers/memory/tegra/tegra210-emc.c | 2123 +++++++++++++++++ drivers/memory/tegra/tegra210-emc.h | 1037 ++++++++ include/dt-bindings/clock/tegra210-car.h | 4 +- include/linux/clk/tegra.h | 5 + 10 files changed, 5288 insertions(+), 18 deletions(-) create mode 100644 Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt create mode 100644 drivers/memory/tegra/tegra210-emc-cc-r21021.c create mode 100644 drivers/memory/tegra/tegra210-emc.c create mode 100644 drivers/memory/tegra/tegra210-emc.h
Signature · 1 line
2.21.0
PATCH v3 1/8 dt-bindings: memory: tegra: Add external memory controller binding for Tegra210
Add the binding document for the external memory controller (EMC) which communicates with external LPDDR4 devices. It includes the bindings of the EMC node and a sub-node of EMC table which under the reserved memory node. The EMC table contains the data of the rates that EMC supported.
---
v3:
- drop the bindings of EMC table
- add memory-region and reserved-memory node for EMC table
--- .../nvidia,tegra210-emc.txt | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +55 -0
@@ -0,0 +1,55 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Device node +=========== +Required properties : +- compatible : should be "nvidia,tegra210-emc". +- reg : physical base address and length of the controller's registers. +- clocks : phandles of the possible source clocks. +- clock-names : names of the possible source clocks. +- interrupts : Should contain the EMC general interrupt. +- memory-region : phandle to the reserved memory (see + Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt) which + contains a sub-node of EMC table. +- nvidia,memory-controller : phandle of the memory controller. + +Reserved memory node +==================== +Should contain a sub-node of EMC table with required properties: +- compatible : should be "nvidia,tegra210-emc-table". +- reg : physical address and length of the location of EMC table. + +Example: + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 { + compatible = "nvidia,tegra210-emc-table"; + reg = <0x0 0x8be00000 0x0 0x10000>; + status = "okay"; + }; + }; + + external-memory-controller@7001b000 { + compatible = "nvidia,tegra210-emc"; + reg = <0x0 0x7001b000 0x0 0x1000>, + <0x0 0x7001e000 0x0 0x1000>, + <0x0 0x7001f000 0x0 0x1000>; + clocks = <&tegra_car TEGRA210_CLK_EMC>, + <&tegra_car TEGRA210_CLK_PLL_M>, + <&tegra_car TEGRA210_CLK_PLL_C>, + <&tegra_car TEGRA210_CLK_PLL_P>, + <&tegra_car TEGRA210_CLK_CLK_M>, + <&tegra_car TEGRA210_CLK_PLL_M_UD>, + <&tegra_car TEGRA210_CLK_PLL_MB_UD>, + <&tegra_car TEGRA210_CLK_PLL_MB>, + <&tegra_car TEGRA210_CLK_PLL_P_UD>; + clock-names = "emc", "pll_m", "pll_c", "pll_p", "clk_m", + "pll_m_ud", "pll_mb_ud", "pll_mb", "pll_p_ud"; + interrupts = <GIC_SPI 78 IRQ_TYPE_LEVEL_HIGH>; + memory-region = <&emc_table>; + nvidia,memory-controller = <&mc>; + };
Signature · 1 line
2.21.0
Re: [PATCH V3 1/8] dt-bindings: memory: tegra: Add external memory controller binding for Tegra210
10.05.2019 11:47, Joseph Lo пишет:
Quoted 44 lines
Add the binding document for the external memory controller (EMC) which communicates with external LPDDR4 devices. It includes the bindings of the EMC node and a sub-node of EMC table which under the reserved memory node. The EMC table contains the data of the rates that EMC supported.
Signed-off-by Joseph Lo <[email protected]>---
v3:
- drop the bindings of EMC table
- add memory-region and reserved-memory node for EMC table--- .../nvidia,tegra210-emc.txt | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+) create mode 100644 Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtDocumentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +23
-0@@ -0,0 +1,55 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Device node +=========== +Required properties : +- compatible : should be "nvidia,tegra210-emc". +- reg : physical base address and length of the controller's registers. +- clocks : phandles of the possible source clocks. +- clock-names : names of the possible source clocks. +- interrupts : Should contain the EMC general interrupt. +- memory-region : phandle to the reserved memory (see + Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt) which + contains a sub-node of EMC table. +- nvidia,memory-controller : phandle of the memory controller. + +Reserved memory node +==================== +Should contain a sub-node of EMC table with required properties: +- compatible : should be "nvidia,tegra210-emc-table". +- reg : physical address and length of the location of EMC table. + +Example:
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt line 33
Quoted 10 lines
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +10
-0+ reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 { + compatible = "nvidia,tegra210-emc-table"; + reg = <0x0 0x8be00000 0x0 0x10000>; + status = "okay"; + };
You essentially moved the v1 binding into obscure and undocumented blob, ignoring previous review comments. This is a very odd move... please explain what is going on.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 1/8] dt-bindings: memory: tegra: Add external memory controller binding for Tegra210
Quoted 51 lines · Dmitry Osipenko
10.05.2019 11:47, Joseph Lo пишет:
Quoted 50 lines
Add the binding document for the external memory controller (EMC) which communicates with external LPDDR4 devices. It includes the bindings of the EMC node and a sub-node of EMC table which under the reserved memory node. The EMC table contains the data of the rates that EMC supported.
Signed-off-by Joseph Lo <[email protected]>---
v3:
- drop the bindings of EMC table
- add memory-region and reserved-memory node for EMC table--- .../nvidia,tegra210-emc.txt | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+)create mode 100644
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtDocumentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +29
-0@@ -0,0 +1,55 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Device node +=========== +Required properties : +- compatible : should be "nvidia,tegra210-emc". +- reg : physical base address and length of the controller's registers. +- clocks : phandles of the possible source clocks. +- clock-names : names of the possible source clocks. +- interrupts : Should contain the EMC general interrupt. +- memory-region : phandle to the reserved memory (see + Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt) which + contains a sub-node of EMC table. +- nvidia,memory-controller : phandle of the memory controller. + +Reserved memory node +==================== +Should contain a sub-node of EMC table with required properties: +- compatible : should be "nvidia,tegra210-emc-table". +- reg : physical address and length of the location of EMC table. + +Example: + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 {
Quoted 9 lines
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt line 33
Quoted 4 lines
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +4
-0+ compatible = "nvidia,tegra210-emc-table"; + reg = <0x0 0x8be00000 0x0 0x10000>; + status = "okay"; + };You essentially moved the v1 binding into obscure and undocumented blob, ignoring previous review comments. This is a very odd move... please explain what is going on.
Discussed with Thierry offline which way we prefer to pass the EMC table to the kernel. Some reasons below we decide to chose this one (via binary blob).
- The EMC table is much bigger than the previous Tegra generations (LPDDR4 v.s. LPDDR2/3). It's harder to settle in the review process. And if there is a new fix of the table in the future, we'll need to go through that again.
- Because it's LPDDR4 we want to support here, to support higher rates, the devices have must be gone through the training process, which is done in the firmware. Which means We already have the table somewhere in the memory and kernel can just re-use that. No need to convert them back to DT and pass to the kernel. This is much easier to maintain in the future if there is something needs to fix.
- With the mechanism above, we don't need to maintain the huge EMC table in the DT file like below.
http://patchwork.ozlabs.org/patch/1063886/
http://patchwork.ozlabs.org/patch/1063889/
And sorry, maybe it's not clear at that moment, but I did mention that we want to go with the new method (via binary blob) in the previous review. Please see http://patchwork.ozlabs.org/patch/1084467/
Thanks,
Joseph
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 1/8] dt-bindings: memory: tegra: Add external memory controller binding for Tegra210
15.05.2019 10:17, Joseph Lo пишет:
Quoted 71 lines · Dmitry Osipenko
Quoted 60 lines
10.05.2019 11:47, Joseph Lo пишет:
Quoted 59 lines
Add the binding document for the external memory controller (EMC) which communicates with external LPDDR4 devices. It includes the bindings of the EMC node and a sub-node of EMC table which under the reserved memory node. The EMC table contains the data of the rates that EMC supported.
Signed-off-by Joseph Lo <[email protected]>---
v3:
- drop the bindings of EMC table
- add memory-region and reserved-memory node for EMC table
---
.../nvidia,tegra210-emc.txt | 55 +++++++++++++++++++1 file changed, 55 insertions(+)create mode 100644
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtdiff --git
a/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtb/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtnew file mode 100644
index 000000000000..d65aeef2329c
---/dev/null
+++b/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtDocumentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +13
-0@@ -0,0 +1,55 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Device node +=========== +Required properties : +- compatible : should be "nvidia,tegra210-emc". +- reg : physical base address and length of the controller's registers. +- clocks : phandles of the possible source clocks. +- clock-names : names of the possible source clocks. +- interrupts : Should contain the EMC general interrupt. +- memory-region : phandle to the reserved memory (see +
Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt) which+ contains a sub-node of EMC table.
+- nvidia,memory-controller : phandle of the memory controller.Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +14
-0+ +Reserved memory node +==================== +Should contain a sub-node of EMC table with required properties: +- compatible : should be "nvidia,tegra210-emc-table". +- reg : physical address and length of the location of EMC table. + +Example: + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 {Quoted 9 lines
Quoted 4 lines
+ compatible = "nvidia,tegra210-emc-table"; + reg = <
0x00x8be000000x00x10000>; + status = "okay";
+ };You essentially moved the v1 binding into obscure and undocumented blob, ignoring previous review comments. This is a very odd move... please explain what is going on.
Quoted 8 lines
Discussed with Thierry offline which way we prefer to pass the EMC table to the kernel. Some reasons below we decide to chose this one (via binary blob).
- The EMC table is much bigger than the previous Tegra generations (LPDDR4 v.s. LPDDR2/3). It's harder to settle in the review process. And if there is a new fix of the table in the future, we'll need to go through that again.
I don't think that this a very good excuse for not documenting the blob's structure.
Quoted 10 lines
- Because it's LPDDR4 we want to support here, to support higher rates, the devices have must be gone through the training process, which is done in the firmware. Which means We already have the table somewhere in the memory and kernel can just re-use that. No need to convert them back to DT and pass to the kernel. This is much easier to maintain in the future if there is something needs to fix.
- With the mechanism above, we don't need to maintain the huge EMC table in the DT file like below.
http://patchwork.ozlabs.org/patch/1063886/
http://patchwork.ozlabs.org/patch/1063889/
The blob's EMC table contains stuff specific to downstream kernel, hence it's a not very re-usable downstream software ABI mixed with HW description that you're bringing into upstream. This is not very welcomed, although I don't see it as a big problem if you'll state that all clearly in the commit message with a solid explanation why it is the best possible option.
Quoted 3 lines
And sorry, maybe it's not clear at that moment, but I did mention that we want to go with the new method (via binary blob) in the previous review. Please see http://patchwork.ozlabs.org/patch/1084467/
Okay. It will be better if the discussion happened publicly, at least I hope that Rob is involved in it.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 1/8] dt-bindings: memory: tegra: Add external memory controller binding for Tegra210
Quoted 76 lines · Dmitry Osipenko
15.05.2019 10:17, Joseph Lo пишет:
Quoted 75 lines · Dmitry Osipenko
Quoted 60 lines
10.05.2019 11:47, Joseph Lo пишет:
Quoted 59 lines
Add the binding document for the external memory controller (EMC) which communicates with external LPDDR4 devices. It includes the bindings of the EMC node and a sub-node of EMC table which under the reserved memory node. The EMC table contains the data of the rates that EMC supported.
Signed-off-by Joseph Lo <[email protected]>---
v3:
- drop the bindings of EMC table
- add memory-region and reserved-memory node for EMC table--- .../nvidia,tegra210-emc.txt | 55 +++++++++++++++++++ 1 file changed, 55 insertions(+)create mode 100644
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtdiff --git
a/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtb/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtnew file mode 100644
index 000000000000..d65aeef2329c
---/dev/null
+++b/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtDocumentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +13
-0@@ -0,0 +1,55 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Device node +=========== +Required properties : +- compatible : should be "nvidia,tegra210-emc". +- reg : physical base address and length of the controller's registers. +- clocks : phandles of the possible source clocks. +- clock-names : names of the possible source clocks. +- interrupts : Should contain the EMC general interrupt. +- memory-region : phandle to the reserved memory (see +
Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt) which+ contains a sub-node of EMC table.
+- nvidia,memory-controller : phandle of the memory controller.Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +14
-0+ +Reserved memory node +==================== +Should contain a sub-node of EMC table with required properties: +- compatible : should be "nvidia,tegra210-emc-table". +- reg : physical address and length of the location of EMC table. + +Example: + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 {Quoted 9 lines
Quoted 4 lines
+ compatible = "nvidia,tegra210-emc-table"; + reg = <
0x00x8be000000x00x10000>; + status = "okay";
+ };You essentially moved the v1 binding into obscure and undocumented blob, ignoring previous review comments. This is a very odd move... please explain what is going on.
Discussed with Thierry offline which way we prefer to pass the EMC table to the kernel. Some reasons below we decide to chose this one (via binary blob).
Quoted 7 lines
Quoted 4 lines
- The EMC table is much bigger than the previous Tegra generations (LPDDR4 v.s. LPDDR2/3). It's harder to settle in the review process. And if there is a new fix of the table in the future, we'll need to go through that again.
I don't think that this a very good excuse for not documenting the blob's structure.
The blob's structure is in patch 4 now that we originally wanted to describe below. Basically, the content is the same.
http://patchwork.ozlabs.org/patch/1084467/
http://patchwork.ozlabs.org/patch/1063879/
Quoted 19 lines
Quoted 11 lines
- Because it's LPDDR4 we want to support here, to support higher rates, the devices have must be gone through the training process, which is done in the firmware. Which means We already have the table somewhere in the memory and kernel can just re-use that. No need to convert them back to DT and pass to the kernel. This is much easier to maintain in the future if there is something needs to fix.
- With the mechanism above, we don't need to maintain the huge EMC table in the DT file like below.
http://patchwork.ozlabs.org/patch/1063886/
http://patchwork.ozlabs.org/patch/1063889/The blob's EMC table contains stuff specific to downstream kernel, hence it's a not very re-usable downstream software ABI mixed with HW description that you're bringing into upstream. This is not very welcomed, although I don't see it as a big problem if you'll state that all clearly in the commit message with a solid explanation why it is the best possible option.
Quoted 7 lines
Quoted 3 lines
And sorry, maybe it's not clear at that moment, but I did mention that we want to go with the new method (via binary blob) in the previous review. Please see http://patchwork.ozlabs.org/patch/1084467/
Okay. It will be better if the discussion happened publicly, at least I hope that Rob is involved in it.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 1/8] dt-bindings: memory: tegra: Add external memory controller binding for Tegra210
16.05.2019 12:01, Joseph Lo пишет:
Quoted 92 lines · Dmitry Osipenko
Quoted 91 lines
15.05.2019 10:17, Joseph Lo пишет:
Quoted 89 lines · Dmitry Osipenko
Quoted 70 lines
10.05.2019 11:47, Joseph Lo пишет:
Quoted 69 lines
Add the binding document for the external memory controller (EMC) which
communicates with external LPDDR4 devices. It includes the bindings of the EMC node and a sub-node of EMC table which under the reserved memory
node. The EMC table contains the data of the rates that EMC supported.Signed-off-by Joseph Lo <[email protected]>---
v3:
- drop the bindings of EMC table
- add memory-region and reserved-memory node for EMC table
---
.../nvidia,tegra210-emc.txt | 55
+++++++++++++++++++1 file changed, 55 insertions(+)create mode 100644
Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtdiff --git
a/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt
b/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtnew file mode 100644
index 000000000000..d65aeef2329c
---/dev/null
+++b/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txtDocumentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +8
-0@@ -0,0 +1,55 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Device node +=========== +Required properties : +- compatible : should be "nvidia,tegra210-emc". +- reg : physical base address and length of the controller'sregisters.
+- clocks : phandles of the possible source clocks. +- clock-names : names of the possible source clocks. +- interrupts : Should contain the EMC general interrupt. +- memory-region : phandle to the reserved memory (see+
Documentation/devicetree/bindings/reserved-memory/reserved-memory.txt) which+ contains a sub-node of EMC table.
+- nvidia,memory-controller : phandle of the memory controller.Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file +15
-0+ +Reserved memory node +==================== +Should contain a sub-node of EMC table with required properties: +- compatible : should be "nvidia,tegra210-emc-table". +- reg : physical address and length of the location of EMC table. + +Example: + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 { + compatible = "nvidia,tegra210-emc-table";Quoted 9 lines
Quoted 3 lines
+ reg = <
0x00x8be000000x00x10000>;
+ status = "okay";
+ };You essentially moved the v1 binding into obscure and undocumented blob,
ignoring previous review comments. This is a very odd move... please explain what is going on.Discussed with Thierry offline which way we prefer to pass the EMC table to the kernel. Some reasons below we decide to chose this one (via binary blob).
- The EMC table is much bigger than the previous Tegra generations (LPDDR4 v.s. LPDDR2/3). It's harder to settle in the review process. And if there is a new fix of the table in the future, we'll need to go through that again.
Quoted 7 lines
Quoted 2 lines
I don't think that this a very good excuse for not documenting the blob's structure.
The blob's structure is in patch 4 now that we originally wanted to describe below. Basically, the content is the same.
http://patchwork.ozlabs.org/patch/1084467/
http://patchwork.ozlabs.org/patch/1063879/
I'm not asking about what exactly it is, but saying that every supported blob structure version should be documented in my opinion, otherwise the documentation is not really useful.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v3 2/8 clk: tegra: Add PLLP_UD and PLLMB_UD for Tegra210
In reply to Joseph LoIntroduce the low jitter path of PLLP and PLLMB which can be used as EMC clock source.
---
v3:
- split to 3 patches from the previous version
--- drivers/clk/tegra/clk-tegra210.c | 11 +++++++++++ include/dt-bindings/clock/tegra210-car.h | 4 ++-- 2 files changed, 13 insertions(+), 2 deletions(-)
drivers/clk/tegra/clk-tegra210.c +11 -0
@@ -3116,6 +3116,17 @@ static void __init tegra210_pll_init(void __iomem *clk_base,clk_register_clkdev (clk,"pll_m_ud" ,NULL ); clks[TEGRA210_CLK_PLL_M_UD ] = clk; +/* PLLMB_UD */ + clk =clk_register_fixed_factor (NULL ,"pll_mb_ud" ,"pll_mb" , +CLK_SET_RATE_PARENT ,1 ,1 ); +clk_register_clkdev (clk,"pll_mb_ud" ,NULL ); + clks[TEGRA210_CLK_PLL_MB_UD ] = clk; + +/* PLLP_UD */ + clk =clk_register_fixed_factor (NULL ,"pll_p_ud" ,"pll_p" , +0 ,1 ,1 ); + clks[TEGRA210_CLK_PLL_P_UD ] = clk; +/* PLLU_VCO */ if (!tegra210_init_pllu ()) { clk = clk_register_fixed_rate(NULL, "pll_u_vco", "pll_ref", 0,
include/dt-bindings/clock/tegra210-car.h +2 -2
@@ -349,8 +349,8 @@#define TEGRA210_CLK_PLL_P_OUT_XUSB 317#define TEGRA210_CLK_XUSB_SSP_SRC 318#define TEGRA210_CLK_PLL_RE_OUT1 319 -/* 320 */ -/* 321 */ +#define TEGRA210_CLK_PLL_MB_UD 320 +#define TEGRA210_CLK_PLL_P_UD 321#define TEGRA210_CLK_ISP 322#define TEGRA210_CLK_PLL_A_OUT_ADSP 323#define TEGRA210_CLK_PLL_A_OUT0_OUT_ADSP 324
Signature · 1 line
2.21.0
PATCH v3 3/8 clk: tegra: Export functions for EMC clock scaling
In reply to Joseph LoExport functions to allow accessing the CAR register required by EMC clock scaling. These functions will be used to access the CAR register as part of the scaling sequence.
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t57478018; bh=emd3R6nSFwL5B+aWA2W+bJqcZ1Jhvwnayz1wGOPSA4M=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=fW7ddx6p6BuGNLGA6jAL5AxsojqeQcOg9fZBqbA1Ze45XU3gt7tiL88s8g7gTftA+ NdruKRXPLS0r4iOgKqEUf3bmoBP0Kf+l0PQcJu55U5v55XnP6cuKrQw2cmbDaw/g2Z a6DZrAIbUZzi3P3b764ZDmUlRD1sHAWWswZwG3kHwBP0TDOXNjAEVcp7NPm868VOvv aJrdb6VblknwjNkE6OV7ktGB1ODge5YSAePDLNAplZBw+BFnogtESwvf0cFcYVbxCG COh/UNKdlJuOM95IgbZiom9I8NiwuS07bA2WzudSgnMKbhNI6VlFgDu5A6JaPt3Irv N4nuUT4+Ln3Fg=
---
v3:
- split to 3 patches from the previous version
--- drivers/clk/tegra/clk-tegra210.c | 36 ++++++++++++++++++++++++++++++++ include/linux/clk/tegra.h | 5 +++++ 2 files changed, 41 insertions(+)
drivers/clk/tegra/clk-tegra210.c +36 -0
@@ -47,6 +47,7 @@#define CLK_SOURCE_LA 0x1f8#define CLK_SOURCE_SDMMC2 0x154#define CLK_SOURCE_SDMMC4 0x164 +#define CLK_SOURCE_EMC_DLL 0x664#define PLLC_BASE 0x80#define PLLC_OUT 0x84
@@ -234,6 +235,10 @@#define RST_DFLL_DVCO 0x2f4#define DVFS_DFLL_RESET_SHIFT 0 +#define CLK_RST_CONTROLLER_CLK_OUT_ENB_X_SET 0x284 +#define CLK_RST_CONTROLLER_CLK_OUT_ENB_X_CLR 0x288 +#define CLK_OUT_ENB_X_CLK_ENB_EMC_DLL BIT(14) +#define CLK_RST_CONTROLLER_RST_DEV_Y_SET 0x2a8#define CLK_RST_CONTROLLER_RST_DEV_Y_CLR 0x2ac
@@ -560,6 +565,37 @@ void tegra210_set_sata_pll_seq_sw(bool state) }EXPORT_SYMBOL_GPL (tegra210_set_sata_pll_seq_sw); +void tegra210_clk_emc_dll_enable (bool flag) +{ +u32 offset = flag ?CLK_RST_CONTROLLER_CLK_OUT_ENB_X_SET : +CLK_RST_CONTROLLER_CLK_OUT_ENB_X_CLR ; + +writel_relaxed (CLK_OUT_ENB_X_CLK_ENB_EMC_DLL , clk_base + offset); +} +EXPORT_SYMBOL_GPL (tegra210_clk_emc_dll_enable); + +void tegra210_clk_emc_dll_update_setting (u32 emc_dll_src_value) +{ +writel_relaxed (emc_dll_src_value, clk_base +CLK_SOURCE_EMC_DLL ); +} +EXPORT_SYMBOL_GPL (tegra210_clk_emc_dll_update_setting); + +void tegra210_clk_emc_update_setting (u32 emc_src_value) +{ +writel_relaxed (emc_src_value, clk_base +CLK_SOURCE_EMC ); +} +EXPORT_SYMBOL_GPL (tegra210_clk_emc_update_setting); + +u32 tegra210_clk_emc_get_setting (void ) +{ +u32 val; + + val =readl_relaxed (clk_base +CLK_SOURCE_EMC ); + +return val; +} +EXPORT_SYMBOL_GPL (tegra210_clk_emc_get_setting); +static void tegra210_generic_mbist_war (struct tegra210_domain_mbist_war *mbist) {u32 val;
include/linux/clk/tegra.h +5 -0
@@ -129,5 +129,10 @@ extern void tegra210_set_sata_pll_seq_sw(bool state);extern void tegra210_put_utmipll_in_iddq (void );extern void tegra210_put_utmipll_out_iddq (void );extern int tegra210_clk_handle_mbist_war (unsigned int id); +extern void tegra210_clk_emc_dll_enable (bool flag); +extern void tegra210_clk_emc_dll_update_setting (u32 emc_dll_src_value); +extern void tegra210_clk_emc_update_setting (u32 emc_src_value); +extern u32 tegra210_clk_emc_get_setting (void ); +#endif /* __LINUX_CLK_TEGRA_H_ */
Signature · 1 line
2.21.0
Re: [PATCH V3 3/8] clk: tegra: Export functions for EMC clock scaling
10.05.2019 11:47, Joseph Lo пишет:
Quoted 4 lines
Export functions to allow accessing the CAR register required by EMC clock scaling. These functions will be used to access the CAR register as part of the scaling sequence.
Quoted 12 lines
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t57478018; bh=emd3R6nSFwL5B+aWA2W+bJqcZ1Jhvwnayz1wGOPSA4M=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=fW7ddx6p6BuGNLGA6jAL5AxsojqeQcOg9fZBqbA1Ze45XU3gt7tiL88s8g7gTftA+ NdruKRXPLS0r4iOgKqEUf3bmoBP0Kf+l0PQcJu55U5v55XnP6cuKrQw2cmbDaw/g2Z a6DZrAIbUZzi3P3b764ZDmUlRD1sHAWWswZwG3kHwBP0TDOXNjAEVcp7NPm868VOvv aJrdb6VblknwjNkE6OV7ktGB1ODge5YSAePDLNAplZBw+BFnogtESwvf0cFcYVbxCG COh/UNKdlJuOM95IgbZiom9I8NiwuS07bA2WzudSgnMKbhNI6VlFgDu5A6JaPt3Irv N4nuUT4+Ln3Fg=
What's that?
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 3/8] clk: tegra: Export functions for EMC clock scaling
Quoted 18 lines · Dmitry Osipenko
10.05.2019 11:47, Joseph Lo пишет:
Quoted 4 lines
Export functions to allow accessing the CAR register required by EMC clock scaling. These functions will be used to access the CAR register as part of the scaling sequence.
Quoted 12 lines
DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t57478018; bh=emd3R6nSFwL5B+aWA2W+bJqcZ1Jhvwnayz1wGOPSA4M=; h=X-PGP-Universal:From:To:CC:Subject:Date:Message-ID:X-Mailer: In-Reply-To:References:MIME-Version:X-NVConfidentiality: Content-Transfer-Encoding:Content-Type; b=fW7ddx6p6BuGNLGA6jAL5AxsojqeQcOg9fZBqbA1Ze45XU3gt7tiL88s8g7gTftA+ NdruKRXPLS0r4iOgKqEUf3bmoBP0Kf+l0PQcJu55U5v55XnP6cuKrQw2cmbDaw/g2Z a6DZrAIbUZzi3P3b764ZDmUlRD1sHAWWswZwG3kHwBP0TDOXNjAEVcp7NPm868VOvv aJrdb6VblknwjNkE6OV7ktGB1ODge5YSAePDLNAplZBw+BFnogtESwvf0cFcYVbxCG COh/UNKdlJuOM95IgbZiom9I8NiwuS07bA2WzudSgnMKbhNI6VlFgDu5A6JaPt3Irv N4nuUT4+Ln3Fg=
Quoted 2 lines
What's that?
Sorry, I don't know how does that come from. I didn't see that in my mail client when receiving this patch.
I did notice this patch was missing in the Tegra Patchwork, but it's okay in the Linux ARM Kernel patchwork.
http://patchwork.ozlabs.org/project/linux-tegra/list/?series=107142
https://patchwork.kernel.org/project/linux-arm-kernel/list/?series=116097
So I guess maybe something wrong when the server handling this patch.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v3 4/8 memory: tegra: Add Tegra210 EMC clock driver
In reply to Joseph LoThis is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
---
v3:
- address almost all the comments from the previous version
- remove the DT parser of EMC table
- The EMC table is passing as a binary blob now.
--- drivers/memory/tegra/Kconfig | 10 + drivers/memory/tegra/Makefile | 1 + drivers/memory/tegra/tegra210-emc.c | 749 ++++++++++++++++++++++++++++ drivers/memory/tegra/tegra210-emc.h | 158 ++++++ 4 files changed, 918 insertions(+) create mode 100644 drivers/memory/tegra/tegra210-emc.c create mode 100644 drivers/memory/tegra/tegra210-emc.h
drivers/memory/tegra/Kconfig +10 -0
@@ -25,3 +25,13 @@ config TEGRA124_EMC Tegra124 chips. The EMC controls the external DRAM on the board. This driver is required to change memory timings / clock rate for external memory. + +config TEGRA210_EMC + bool "NVIDIA Tegra210 External Memory Controller driver" + default y + depends on TEGRA_MC && ARCH_TEGRA_210_SOC + help + This driver is for the External Memory Controller (EMC) found on + Tegra210 chips. The EMC controls the external DRAM on the board. + This driver is required to change memory timings / clock rate for + external memory.
drivers/memory/tegra/Makefile +1 -0
@@ -12,4 +12,5 @@ obj-$(CONFIG_TEGRA_MC) += tegra-mc.o obj-$(CONFIG_TEGRA20_EMC) += tegra20-emc.o obj-$(CONFIG_TEGRA124_EMC) += tegra124-emc.o +obj-$(CONFIG_TEGRA210_EMC) += tegra210-emc.o obj-$(CONFIG_ARCH_TEGRA_186_SOC) += tegra186.o
drivers/memory/tegra/tegra210-emc.c new file +749 -0
749 lines not on this page · raw message
drivers/memory/tegra/tegra210-emc.h new file +158 -0
158 lines not on this page · raw message
Signature · 1 line
2.21.0
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
10.05.2019 11:47, Joseph Lo пишет:
Quoted 356 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
v3:
- address almost all the comments from the previous version
- remove the DT parser of EMC table
- The EMC table is passing as a binary blob now.--- drivers/memory/tegra/Kconfig | 10 + drivers/memory/tegra/Makefile | 1 + drivers/memory/tegra/tegra210-emc.c | 749 ++++++++++++++++++++++++++++ drivers/memory/tegra/tegra210-emc.h | 158 ++++++ 4 files changed, 918 insertions(+) create mode 100644 drivers/memory/tegra/tegra210-emc.c create mode 100644 drivers/memory/tegra/tegra210-emc.hdrivers/memory/tegra/Kconfig +10
-0@@ -25,3 +25,13 @@ config TEGRA124_EMC Tegra124 chips. The EMC controls the external DRAM on the board. This driver is required to change memory timings / clock rate for external memory. + +config TEGRA210_EMC + bool "NVIDIA Tegra210 External Memory Controller driver" + default y + depends on TEGRA_MC && ARCH_TEGRA_210_SOC + help + This driver is for the External Memory Controller (EMC) found on + Tegra210 chips. The EMC controls the external DRAM on the board. + This driver is required to change memory timings / clock rate for + external memory.drivers/memory/tegra/Makefile +1
-0@@ -12,4 +12,5 @@ obj-$(CONFIG_TEGRA_MC) += tegra-mc.o obj-$(CONFIG_TEGRA20_EMC) += tegra20-emc.o obj-$(CONFIG_TEGRA124_EMC) += tegra124-emc.o +obj-$(CONFIG_TEGRA210_EMC) += tegra210-emc.o obj-$(CONFIG_ARCH_TEGRA_186_SOC) += tegra186.odrivers/memory/tegra/tegra210-emc.c new file +289
-0@@ -0,0 +1,749 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2015-2019, NVIDIA CORPORATION. All rights reserved. +*/ + +#include <linux/clk.h> +#include <linux/clk/tegra.h> +#include <linux/clk-provider.h> +#include <linux/debugfs.h> +#include <linux/delay.h> +#include <linux/kernel.h> +#include <linux/of_address.h> +#include <linux/of_platform.h> +#include <soc/tegra/fuse.h> +#include <soc/tegra/mc.h> + +#include "mc.h" +#include "tegra210-emc.h" + +#define CLK_RST_CONTROLLER_CLK_SOURCE_EMC 0x19c +#define EMC_CLK_EMC_2X_CLK_SRC_SHIFT 29 +#define EMC_CLK_EMC_2X_CLK_SRC_MASK \ + (0x7 << EMC_CLK_EMC_2X_CLK_SRC_SHIFT) +#define EMC_CLK_MC_EMC_SAME_FREQ BIT(16) +#define EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT 0 +#define EMC_CLK_EMC_2X_CLK_DIVISOR_MASK \ + (0xff << EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT) + +#define MC_EMEM_ARB_MISC0_EMC_SAME_FREQ BIT(27) + +#define TEGRA_EMC_MAX_FREQS 16 +#define TEGRA210_EMC_SUSPEND_RATE 204000000 + +#define CLK_CHANGE_DELAY 100 +#define TRAINING_TIME 100 + +enum { +TEGRA_EMC_SRC_PLLM , +TEGRA_EMC_SRC_PLLC , +TEGRA_EMC_SRC_PLLP , +TEGRA_EMC_SRC_CLKM , +TEGRA_EMC_SRC_PLLM_UD , +TEGRA_EMC_SRC_PLLMB_UD , +TEGRA_EMC_SRC_PLLMB , +TEGRA_EMC_SRC_PLLP_UD , +TEGRA_EMC_SRC_COUNT , +}; + +struct emc_sel { +struct clk *input; +u32 value; +unsigned long input_rate; + +struct clk *input_b;// second source of PLLM: PLLMB +u32 value_b; +unsigned long input_rate_b; +}; + +struct emc_stats { +u64 time_at_clock[TEGRA_EMC_MAX_FREQS ]; +int last_sel; +u64 last_update; +u64 clkchange_count; +spinlock_t spinlock; +}; +static struct emc_stats emc_stats; + +static struct emc_sel *emc_clk_sel; +static struct clk *emc_src[TEGRA_EMC_SRC_COUNT ]; +static const char *emc_src_names[TEGRA_EMC_SRC_COUNT ] = { + [TEGRA_EMC_SRC_PLLM ] ="pll_m" , + [TEGRA_EMC_SRC_PLLC ] ="pll_c" , + [TEGRA_EMC_SRC_PLLP ] ="pll_p" , + [TEGRA_EMC_SRC_CLKM ] ="clk_m" , + [TEGRA_EMC_SRC_PLLM_UD ] ="pll_m_ud" , + [TEGRA_EMC_SRC_PLLMB_UD ] ="pll_mb_ud" , + [TEGRA_EMC_SRC_PLLMB ] ="pll_mb" , + [TEGRA_EMC_SRC_PLLP_UD ] ="pll_p_ud" , +}; + +static const struct supported_sequence supported_seqs[] = { + { +0 , +NULL , +NULL , +NULL + } +}; +static const struct supported_sequence *seq = supported_seqs; +static DEFINE_SPINLOCK (emc_access_lock); + +static inline struct tegra_emc *clk_hw_to_emc (struct clk_hw *hw) +{ + return container_of(hw, struct tegra_emc, hw); +} + +u32 emc_readl (struct tegra_emc *emc,unsigned long offset) +{ +return readl_relaxed (emc->emc_base[REG_EMC ] + offset); +} + +u32 emc_readl_per_ch (struct tegra_emc *emc,int type, +unsigned long offset) +{ +u32 val =0 ; + +switch (type) { +case REG_EMC : +case REG_EMC0 : + val =readl_relaxed (emc->emc_base[REG_EMC ] + offset); +break ; +case REG_EMC1 : + val =readl_relaxed (emc->emc_base[REG_EMC1 ] + offset); +break ; + } + +return val; +} + +static inline u32 emc_src_val (u32 val) +{ +return (val &EMC_CLK_EMC_2X_CLK_SRC_MASK ) >> +EMC_CLK_EMC_2X_CLK_SRC_SHIFT ; +} + +static inline u32 emc_div_val (u32 val) +{ +return (val &EMC_CLK_EMC_2X_CLK_DIVISOR_MASK ) >> +EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT ; +} + +static void emc_train_func (struct timer_list *tmr) +{ +unsigned long flags; +struct tegra_emc *emc =from_timer (emc, tmr, training_timer); + +if (!emc->current_timing) +return ; + +spin_lock_irqsave (&emc_access_lock, flags); +if (seq->periodic_compensation) + seq->periodic_compensation (emc); +spin_unlock_irqrestore (&emc_access_lock, flags); + +mod_timer (&emc->training_timer, + jiffies +msecs_to_jiffies (emc->timer_period_training)); +} + +static void emc_training_timer_start (struct tegra_emc *emc) +{ +mod_timer (&emc->training_timer, + jiffies +msecs_to_jiffies (emc->timer_period_training)); +} + +static void emc_training_timer_stop (struct tegra_emc *emc) +{ +del_timer (&emc->training_timer); +} + +static void emc_set_clock (struct tegra_emc *emc,u32 clksrc) +{ + seq->set_clock (emc, clksrc); + +if (emc->next_timing->periodic_training) +emc_training_timer_start (emc); +else +emc_training_timer_stop (emc); +} + +static inline unsigned long emc_get_src_clk_rate (void ) +{ +int div; +u32 val; +unsigned long rate; + + val =tegra210_clk_emc_get_setting (); + rate =clk_get_rate (emc_src[emc_src_val (val)]); + div =emc_div_val (val); + div +=2 ; + rate *=2 ; + rate += div -1 ; +do_div (rate, div); + +return rate; +} + +static void emc_last_stats_update (int last_sel) +{ +unsigned long flags; +u64 cur_jiffies =get_jiffies_64 (); + +spin_lock_irqsave (&emc_stats.spinlock, flags); + +if (emc_stats.last_sel <TEGRA_EMC_MAX_FREQS ) + emc_stats.time_at_clock[emc_stats.last_sel] = + emc_stats.time_at_clock[emc_stats.last_sel] + + (cur_jiffies - emc_stats.last_update); + + emc_stats.last_update = cur_jiffies; + +if (last_sel <TEGRA_EMC_MAX_FREQS ) { + emc_stats.clkchange_count++; + emc_stats.last_sel = last_sel; + } + +spin_unlock_irqrestore (&emc_stats.spinlock, flags); +} + +static int emc_table_lookup (struct tegra_emc *emc,unsigned long rate) +{ +int i; + +for (i =0 ; i < emc->emc_table_size; i++) { +if (emc_clk_sel[i].input ==NULL ) +continue ; + +if (emc->emc_table[i].rate == rate) +return i; + } + +return -EINVAL ; +} + +static struct clk *emc_predict_parent (struct tegra_emc *emc, +unsigned long rate) +{ +struct clk *old_parent, *new_parent; +unsigned long parent_rate; +int idx; + + idx =emc_table_lookup (emc, rate /1000 ); +if (idx <0 ) +return ERR_PTR (-EINVAL ); + + parent_rate = emc_clk_sel[idx].input_rate *1000 ; + new_parent = emc_clk_sel[idx].input; + old_parent =clk_get_parent (emc->emc_clk); + +if (parent_rate ==clk_get_rate (old_parent)) +return old_parent; + +if (clk_is_match (new_parent, old_parent)) + new_parent = emc_clk_sel[idx].input_b; + +if (parent_rate !=clk_get_rate (new_parent)) +clk_set_rate (new_parent, parent_rate); + +return new_parent; +} + +static int emc_set_rate (struct tegra_emc *emc,unsigned long rate) +{ +int i; +unsigned long flags; +s64 last_change_delay; +struct clk *parent; + +if (emc->emc_suspend) + rate =TEGRA210_EMC_SUSPEND_RATE ; + +if (rate == emc->current_timing->rate) +return 0 ; + + i =emc_table_lookup (emc, rate /1000 ); + +if (i <0 ) +return i; + +if (rate >204000000 && !emc->emc_table[i].trained) +return -EINVAL ; + + parent =emc_predict_parent (emc, rate); +if (clk_is_match (parent, emc_clk_sel[i].input)) + emc->clk_setting = emc_clk_sel[i].value; +else + emc->clk_setting = emc_clk_sel[i].value_b; + + emc->next_timing = &emc->emc_table[i]; + last_change_delay =ktime_us_delta (ktime_get (), emc->clkchange_time); +if ((last_change_delay >=0 ) && + (last_change_delay < emc->clkchange_delay)) +udelay (emc->clkchange_delay - (int )last_change_delay); + +spin_lock_irqsave (&emc_access_lock, flags); +emc_set_clock (emc, emc->clk_setting); + emc->clkchange_time =ktime_get (); + emc->current_timing = &emc->emc_table[i]; +spin_unlock_irqrestore (&emc_access_lock, flags); +
drivers/memory/tegra/tegra210-emc.c line 299
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+emc_last_stats_update (i); + +return 0 ; +} + +#ifdef CONFIG_DEBUG_FS +static int emc_stats_show (struct seq_file *s,void *data) +{ +int i; +struct tegra_emc *emc = (struct tegra_emc *)s->private;
There is no need for casting of the void*.
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ +if (!emc->emc_table_size || !seq) +return 0 ; + +emc_last_stats_update (TEGRA_EMC_MAX_FREQS ); + +seq_printf (s,"%-10s %-10s\n" ,"rate kHz" ,"time" ); +for (i =0 ; i < emc->emc_table_size; i++) { +if (emc_clk_sel[i].input ==NULL ) +continue ;
drivers/memory/tegra/tegra210-emc.c line 319
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ +seq_printf (s,"%-10u %-10llu\n" , + emc->emc_table[i].rate, +jiffies_64_to_clock_t ( + emc_stats.time_at_clock[i])); + } +seq_printf (s,"%-15s %llu\n" ,"transitions:" , + emc_stats.clkchange_count); +seq_printf (s,"%-15s %llu\n" ,"time-stamp:" , +jiffies_64_to_clock_t (emc_stats.last_update));
Devfreq subsystem has the transition stats too and it is a bit more advanced than what you have here.
cat /sys/class/devfreq/devfreq0/trans_stat
From : To
: 50000000 100000000 150000000 300000000 600000000 time(ms)
* 50000000: 0 4 4 0 46 118096210 100000000: 21 0 0 0 5 15460 150000000: 10 9 0 0 10560 20213940 300000000: 13 6 5058 0 22375 6848690 600000000: 11 7 5517 27452 0 11958990
Total transition : 71098
Hence I'm questioning the necessity of the debug-info duplication.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
Quoted 26 lines · Dmitry Osipenko
10.05.2019 11:47, Joseph Lo пишет:
Quoted 25 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
v3:
- address almost all the comments from the previous version
- remove the DT parser of EMC table
- The EMC table is passing as a binary blob now.
---
snip.
Quoted 34 lines
drivers/memory/tegra/tegra210-emc.c line 299
Quoted 5 lines
drivers/memory/tegra/tegra210-emc.c new file +5
-0+#ifdef CONFIG_DEBUG_FS +static int emc_stats_show (struct seq_file *s,void *data) +{ +int i; +struct tegra_emc *emc = (struct tegra_emc *)s->private;There is no need for casting of the void*.
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ +if (!emc->emc_table_size || !seq) +return 0 ; + +emc_last_stats_update (TEGRA_EMC_MAX_FREQS ); + +seq_printf (s,"%-10s %-10s\n" ,"rate kHz" ,"time" ); +for (i =0 ; i < emc->emc_table_size; i++) { +if (emc_clk_sel[i].input ==NULL ) +continue ;drivers/memory/tegra/tegra210-emc.c line 319
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ +seq_printf (s,"%-10u %-10llu\n" , + emc->emc_table[i].rate, +jiffies_64_to_clock_t ( + emc_stats.time_at_clock[i])); + } +seq_printf (s,"%-15s %llu\n" ,"transitions:" , + emc_stats.clkchange_count); +seq_printf (s,"%-15s %llu\n" ,"time-stamp:" , +jiffies_64_to_clock_t (emc_stats.last_update));Devfreq subsystem has the transition stats too and it is a bit more advanced than what you have here.
cat
/sys/class/devfreq/devfreq0/trans_stat
From : To
: 50000000 100000000 150000000 300000000 600000000 time(ms)
Quoted 9 lines
* 50000000: 0 4 4 0 46 118096210 100000000: 21 0 0 0 5 15460 150000000: 10 9 0 0 10560 20213940 300000000: 13 6 5058 0 22375 6848690 600000000: 11 7 5517 27452 0 11958990Total transition : 71098
Hence I'm questioning the necessity of the debug-info duplication.
Okay, will remove the statistic data in the next version. BTW, I think we will use Interconnect framework for the EMC BW manager for the Tegra chips >= T210.
Thanks,
Joseph
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
In reply to Joseph Lo10.05.2019 11:47, Joseph Lo пишет:
Quoted 20 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
[snip]
Quoted 23 lines
drivers/memory/tegra/tegra210-emc.c new file +23
-0+static int tegra210_emc_probe (struct platform_device *pdev) +{ +int i; +unsigned long table_rate; +unsigned long current_rate; +struct device_node *np; +struct platform_device *mc; +struct tegra_emc *emc; +struct clk_init_data init; +struct clk *clk; +struct resource *r, res; +void *table_addr; + + emc =devm_kzalloc (&pdev->dev,sizeof (*emc),GFP_KERNEL ); +if (!emc) +return -ENOMEM ; + + np =of_parse_phandle (pdev->dev.of_node,"nvidia,memory-controller" ,0 ); +if (!np) { +dev_err (&pdev->dev,"could not get memory controller\n" ); +return -ENOENT ; + } +
drivers/memory/tegra/tegra210-emc.c line 566
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ mc =of_find_device_by_node (np); +of_node_put (np); +if (!mc) +return -ENOENT ; + + emc->mc =platform_get_drvdata (mc); +if (!emc->mc) +return -EPROBE_DEFER ; + + emc->ram_code =tegra_read_ram_code ();
emc->ram_code isn't used anywhere in the code.
I haven't checked other fields. Please remove everything that is unused.
drivers/memory/tegra/tegra210-emc.c line 572
Quoted 6 lines
drivers/memory/tegra/tegra210-emc.c new file +6
-0+ r =platform_get_resource (pdev,IORESOURCE_MEM ,0 ); + emc->emc_base[REG_EMC ] =devm_ioremap_resource (&pdev->dev, r); + r =platform_get_resource (pdev,IORESOURCE_MEM ,1 ); + emc->emc_base[REG_EMC0 ] =devm_ioremap_resource (&pdev->dev, r); + r =platform_get_resource (pdev,IORESOURCE_MEM ,2 ); + emc->emc_base[REG_EMC1 ] =devm_ioremap_resource (&pdev->dev, r);
Use devm_platform_ioremap_resource().
Quoted 43 lines
drivers/memory/tegra/tegra210-emc.c new file +43
-0+for (i =0 ; i <TEGRA_EMC_SRC_COUNT ; i++) { + emc_src[i] =devm_clk_get (&pdev->dev, + emc_src_names[i]); +if (IS_ERR (emc_src[i])) { +dev_err (&pdev->dev,"Can not find EMC source clock\n" ); +return -ENODATA ; + } + } + + np =of_parse_phandle (pdev->dev.of_node,"memory-region" ,0 ); +if (!np) { +dev_err (&pdev->dev,"could not find EMC table\n" ); + goto emc_clk_register; + } + +if (!of_device_is_compatible (np,"nvidia,tegra210-emc-table" ) || + !of_device_is_available (np)) { +dev_err (&pdev->dev,"EMC table is invalid\n" ); + goto emc_clk_register; + } + +of_address_to_resource (np,0 , &res); + table_addr =memremap (res.start,resource_size (&res),MEMREMAP_WB ); +of_node_put (np); +if (!table_addr) { +dev_err (&pdev->dev,"could not map EMC table\n" ); + goto emc_clk_register; + } + emc->emc_table = (struct emc_table *)table_addr; + +for (i =0 ; i <TEGRA_EMC_MAX_FREQS ; i++) +if (emc->emc_table[i].rev !=0 ) + emc->emc_table_size++; +else +break ; + +/* Init EMC rate statistic data */ + emc_stats.clkchange_count =0 ; +spin_lock_init (&emc_stats.spinlock); + emc_stats.last_update =get_jiffies_64 (); + emc_stats.last_sel =TEGRA_EMC_MAX_FREQS ; + +/* Check the supported sequence */
drivers/memory/tegra/tegra210-emc.c line 626
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+while (seq->table_rev) { +if (seq->table_rev == emc->emc_table[0 ].rev) +break ; + seq++; + } +if (!seq->set_clock) { + seq =NULL ; +dev_err (&pdev->dev,"Invalid EMC sequence for table Rev. %d\n" , + emc->emc_table[0 ].rev); + goto emc_clk_register;
Why do you want to register EMC clock if something fails? KMSG will be flooded with errors coming from clk_set_rate.
drivers/memory/tegra/tegra210-emc.c line 637
Quoted 11 lines
drivers/memory/tegra/tegra210-emc.c new file +11
-0+ } + + emc_clk_sel =devm_kcalloc (&pdev->dev, + emc->emc_table_size, +sizeof (struct emc_sel ), +GFP_KERNEL ); + +/* calculate the rate from source clock */ + current_rate =emc_get_src_clk_rate () /1000 ; + +/* validate the table */
Please be consistent and start all of the one-line comments with a lowercase letter.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
Quoted 60 lines · Dmitry Osipenko
10.05.2019 11:47, Joseph Lo пишет:
Quoted 20 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
[snip]
Quoted 23 lines
drivers/memory/tegra/tegra210-emc.c new file +23
-0+static int tegra210_emc_probe (struct platform_device *pdev) +{ +int i; +unsigned long table_rate; +unsigned long current_rate; +struct device_node *np; +struct platform_device *mc; +struct tegra_emc *emc; +struct clk_init_data init; +struct clk *clk; +struct resource *r, res; +void *table_addr; + + emc =devm_kzalloc (&pdev->dev,sizeof (*emc),GFP_KERNEL ); +if (!emc) +return -ENOMEM ; + + np =of_parse_phandle (pdev->dev.of_node,"nvidia,memory-controller" ,0 ); +if (!np) { +dev_err (&pdev->dev,"could not get memory controller\n" ); +return -ENOENT ; + } +drivers/memory/tegra/tegra210-emc.c line 566
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ mc =of_find_device_by_node (np); +of_node_put (np); +if (!mc) +return -ENOENT ; + + emc->mc =platform_get_drvdata (mc); +if (!emc->mc) +return -EPROBE_DEFER ; + + emc->ram_code =tegra_read_ram_code ();
emc->ram_codeisn't used anywhere in the code.
Quoted 1 line
I haven't checked other fields. Please remove everything that is unused.
Good catch, I missed this when clean up the code for V3.
Quoted 58 lines
drivers/memory/tegra/tegra210-emc.c line 572
Quoted 7 lines
drivers/memory/tegra/tegra210-emc.c new file +6
-0+ r =platform_get_resource (pdev,IORESOURCE_MEM ,0 ); + emc->emc_base[REG_EMC ] =devm_ioremap_resource (&pdev->dev, r); + r =platform_get_resource (pdev,IORESOURCE_MEM ,1 ); + emc->emc_base[REG_EMC0 ] =devm_ioremap_resource (&pdev->dev, r); + r =platform_get_resource (pdev,IORESOURCE_MEM ,2 ); + emc->emc_base[REG_EMC1 ] =devm_ioremap_resource (&pdev->dev, r);Use
devm_platform_ioremap_resource().Quoted 48 lines
drivers/memory/tegra/tegra210-emc.c new file +48
-0+for (i =0 ; i <TEGRA_EMC_SRC_COUNT ; i++) { + emc_src[i] =devm_clk_get (&pdev->dev, + emc_src_names[i]); +if (IS_ERR (emc_src[i])) { +dev_err (&pdev->dev,"Can not find EMC source clock\n" ); +return -ENODATA ; + } + } + + np =of_parse_phandle (pdev->dev.of_node,"memory-region" ,0 ); +if (!np) { +dev_err (&pdev->dev,"could not find EMC table\n" ); + goto emc_clk_register; + } + +if (!of_device_is_compatible (np,"nvidia,tegra210-emc-table" ) || + !of_device_is_available (np)) { +dev_err (&pdev->dev,"EMC table is invalid\n" ); + goto emc_clk_register; + } + +of_address_to_resource (np,0 , &res); + table_addr =memremap (res.start,resource_size (&res),MEMREMAP_WB ); +of_node_put (np); +if (!table_addr) { +dev_err (&pdev->dev,"could not map EMC table\n" ); + goto emc_clk_register; + } + emc->emc_table = (struct emc_table *)table_addr; + +for (i =0 ; i <TEGRA_EMC_MAX_FREQS ; i++) +if (emc->emc_table[i].rev !=0 ) + emc->emc_table_size++; +else +break ; + +/* Init EMC rate statistic data */ + emc_stats.clkchange_count =0 ; +spin_lock_init (&emc_stats.spinlock); + emc_stats.last_update =get_jiffies_64 (); + emc_stats.last_sel =TEGRA_EMC_MAX_FREQS ; + +/* Check the supported sequence */ +while (seq->table_rev) { +if (seq->table_rev == emc->emc_table[0 ].rev) +break ; + seq++; + }
Quoted 9 lines
drivers/memory/tegra/tegra210-emc.c line 626
Quoted 5 lines
drivers/memory/tegra/tegra210-emc.c new file +5
-0+if (!seq->set_clock) { + seq =NULL ; +dev_err (&pdev->dev,"Invalid EMC sequence for table Rev. %d\n" , + emc->emc_table[0 ].rev); + goto emc_clk_register;Why do you want to register EMC clock if something fails? KMSG will be flooded with errors coming from
clk_set_rate.
See patch 7 in the series, the legacy EMC clock will be removed later, so we need to register the EMC clock whether the table is ready or not. In that case, I mean if the table is not available, it will still register EMC clock at the rate that boot loader configured before kernel booting. So the MC clock can still work as expected, which is under EMC clock.
And I did test that, couldn't observe any KMSG in that case.
Thanks,
Joseph
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
15.05.2019 11:42, Joseph Lo пишет:
Quoted 134 lines · Dmitry Osipenko
Quoted 61 lines
10.05.2019 11:47, Joseph Lo пишет:
Quoted 20 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
[snip]
Quoted 24 lines
drivers/memory/tegra/tegra210-emc.c new file +18
-0+static int tegra210_emc_probe (struct platform_device *pdev) +{ + int i; + unsigned long table_rate; + unsigned long current_rate; + struct device_node *np; + struct platform_device *mc; + struct tegra_emc *emc; + struct clk_init_data init; + struct clk *clk; + struct resource *r, res; + void *table_addr; + + emc = devm_kzalloc(&pdev->dev, sizeof(*emc), GFP_KERNEL); + if (!emc) + return -ENOMEM; + + np = of_parse_phandle(pdev->dev.of_node,"nvidia,memory-controller", 0);
+ if (!np) {
+dev_err(&pdev->dev, "could not get memory controller\n"); + return-ENOENT;
+ }drivers/memory/tegra/tegra210-emc.c new file +1
-0+drivers/memory/tegra/tegra210-emc.c line 566
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c new file +10
-0+ mc = of_find_device_by_node(np); + of_node_put(np); + if (!mc) + return -ENOENT; + + emc->mc = platform_get_drvdata(mc); + if (!emc->mc) + return -EPROBE_DEFER; + + emc->ram_code = tegra_read_ram_code();
emc->ram_codeisn't used anywhere in the code.Quoted 1 line
I haven't checked other fields. Please remove everything that is unused.
Good catch, I missed this when clean up the code for V3.
Quoted 58 lines
Quoted 7 lines
+ r =
platform_get_resource(pdev, IORESOURCE_MEM, 0); + emc->emc_base[REG_EMC] =devm_ioremap_resource(&pdev->dev, r); + r =platform_get_resource(pdev, IORESOURCE_MEM, 1); + emc->emc_base[REG_EMC0] =devm_ioremap_resource(&pdev->dev, r); + r =platform_get_resource(pdev, IORESOURCE_MEM, 2); + emc->emc_base[REG_EMC1] =devm_ioremap_resource(&pdev->dev, r);Use
devm_platform_ioremap_resource().Quoted 48 lines
+ for (i = 0; i <
TEGRA_EMC_SRC_COUNT; i++) {
+ emc_src[i] = devm_clk_get(&pdev->dev,
+ emc_src_names[i]);
+ if (IS_ERR(emc_src[i])) {
+dev_err(&pdev->dev, "Can not find EMC source clock\n"); + return-ENODATA;
+ }
+ }drivers/memory/tegra/tegra210-emc.c new file +40
-0+ + np = of_parse_phandle(pdev->dev.of_node, "memory-region", 0); + if (!np) { + dev_err(&pdev->dev, "could not find EMC table\n"); + goto emc_clk_register; + } + + if (!of_device_is_compatible(np, "nvidia,tegra210-emc-table") || + !of_device_is_available(np)) { + dev_err(&pdev->dev, "EMC table is invalid\n"); + goto emc_clk_register; + } + + of_address_to_resource(np, 0, &res); + table_addr = memremap(res.start, resource_size(&res), MEMREMAP_WB); + of_node_put(np); + if (!table_addr) { + dev_err(&pdev->dev, "could not map EMC table\n"); + goto emc_clk_register; + } + emc->emc_table = (struct emc_table *)table_addr; + + for (i = 0; i < TEGRA_EMC_MAX_FREQS; i++) + if (emc->emc_table[i].rev != 0) + emc->emc_table_size++; + else + break; + + /* Init EMC rate statistic data */ + emc_stats.clkchange_count = 0; + spin_lock_init(&emc_stats.spinlock); + emc_stats.last_update = get_jiffies_64(); + emc_stats.last_sel = TEGRA_EMC_MAX_FREQS; + + /* Check the supported sequence */ + while (seq->table_rev) { + if (seq->table_rev == emc->emc_table[0].rev) + break; + seq++; + }Quoted 9 lines
Quoted 5 lines
+ if (!seq->set_clock) {
+ seq = NULL;
+ dev_err(&pdev->dev, "Invalid EMC sequence for table Rev. %d\n", + emc->emc_table[0].rev);
+ gotoemc_clk_register;Why do you want to register EMC clock if something fails? KMSG will be flooded with errors coming from
clk_set_rate.
Quoted 7 lines
See patch 7 in the series, the legacy EMC clock will be removed later,
so we need to register the EMC clock whether the table is ready or not> In that case, I mean if the table is not available, it will still register EMC clock at the rate that boot loader configured before kernel
booting. So the MC clock can still work as expected, which is under EMC
clock.And I did test that, couldn't observe any KMSG in that case.
Looks like it kinda should work in the end.
Although it's not good that now MC driver relies on the EMC driver presence. Maybe it's not the best variant with moving the clock stuff into the EMC driver?
What about the backwards compatibility for DT that doesn't have the EMC node?
What if EMC driver is disabled in the kernel's config?
And lastly.. what stops the MC driver to probe before the EMC? Looks like MC driver is already in trouble because it's on arch level and the EMC is on subsys, hence MC will get the orphaned clock and won't initialize hardware properly on probe.
BTW, how are you testing the EMC driver? Is there T210 devfreq patches in works? Or what's the user of the EMC on T210?
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
Quoted 23 lines · Dmitry Osipenko
15.05.2019 11:42, Joseph Lo пишет:
Quoted 22 lines · Dmitry Osipenko
Quoted 21 lines
10.05.2019 11:47, Joseph Lo пишет:
Quoted 20 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
snip.
Quoted 20 lines
Quoted 10 lines
Quoted 9 lines
Quoted 5 lines
+ if (!seq->set_clock) {
+ seq = NULL;
+ dev_err(&pdev->dev, "Invalid EMC sequence for table Rev. %d\n", + emc->emc_table[0].rev);
+ gotoemc_clk_register;Why do you want to register EMC clock if something fails? KMSG will be flooded with errors coming from
clk_set_rate.Quoted 7 lines
See patch 7 in the series, the legacy EMC clock will be removed later,
so we need to register the EMC clock whether the table is ready or not> In that case, I mean if the table is not available, it will still register EMC clock at the rate that boot loader configured before kernel
booting. So the MC clock can still work as expected, which is under EMC
clock.And I did test that, couldn't observe any KMSG in that case.
Looks like it kinda should work in the end.
Quoted 8 lines
Although it's not good that now MC driver relies on the EMC driver presence. Maybe it's not the best variant with moving the clock stuff into the EMC driver?
What about the backwards compatibility for DT that doesn't have the EMC node?
What if EMC driver is disabled in the kernel's config?
The three questions above are actually one problem here. It's not about MC clock, because it's still available after these changes. And MC driver can still get it in the probe function even the EMC driver isn't there.
The problem is that without EMC driver after these changes. The PLLM will have no client under it, which will cause the PLLM to be disabled in the late init call of "clk_disable_unused". So the system will be stuck.
Quoted 5 lines
And lastly.. what stops the MC driver to probe before the EMC? Looks like MC driver is already in trouble because it's on arch level and the EMC is on subsys, hence MC will get the orphaned clock and won't initialize hardware properly on probe.
After this moving, the EMC driver will be always enabled by default. And the DT change is necessary as well. The blob of EMC table is not necessary, because it needs a firmware update. We will update the firmware accordingly after the review settled and release it later.
In case of no EMC table blob, the driver can still be registered, but no scaling function provided.
Quoted 4 lines
BTW, how are you testing the EMC driver? Is there T210 devfreq patches in works? Or what's the user of the EMC on T210?
1. Currently, via debugfs.
2. No, we prefer to use Interconnect framework for that. The evaluation is ongoing.
3. With Interconnect, the devices or peripherals can register on it to request the BW. So we can fine-tune the BW requirements with the latency allowance registers altogether to get better efficiency.
Thanks,
Joseph
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 4/8] memory: tegra: Add Tegra210 EMC clock driver
16.05.2019 10:52, Joseph Lo пишет:
Quoted 56 lines · Dmitry Osipenko
Quoted 25 lines
15.05.2019 11:42, Joseph Lo пишет:
Quoted 24 lines · Dmitry Osipenko
Quoted 23 lines
10.05.2019 11:47, Joseph Lo пишет:
Quoted 22 lines
This is the initial patch for Tegra210 EMC clock driver, which doesn't include the support code and detail sequence for clock scaling yet.
The driver is designed to support LPDDR4 SDRAM. Because of the LPDDR4 devices need to do initial time training before it can be used, the firmware will help to do that at early boot stage. Then, the trained table for the rates we support will pass to the kernel via DT. So the driver can get the trained table for clock scaling support.
For the higher rate support (above 800MHz), the periodic training is needed for the timing compensation. So basically, two methodologies for
clock scaling are supported, one is following the clock changing sequence to update the EMC table to EMC registers and another is if the
rate needs periodic training, then we will start a timer to do that periodically until it scales to the lower rate.Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
snip.
Quoted 29 lines
Quoted 11 lines
Quoted 10 lines
Quoted 6 lines
+ if (!seq->set_clock) {
+ seq = NULL;
+ dev_err(&pdev->dev, "Invalid EMC sequence for table Rev. %d\n",
+ emc->emc_table[0].rev);
+ gotoemc_clk_register;Why do you want to register EMC clock if something fails? KMSG will be flooded with errors coming from
clk_set_rate.Quoted 8 lines
See patch 7 in the series, the legacy EMC clock will be removed later, so we need to register the EMC clock whether the table is ready or not> In that case, I mean if the table is not available, it will still register EMC clock at the rate that boot loader configured before kernel booting. So the MC clock can still work as expected, which is under EMC clock.
And I did test that, couldn't observe any KMSG in that case.
Looks like it kinda should work in the end.
Although it's not good that now MC driver relies on the EMC driver presence. Maybe it's not the best variant with moving the clock stuff into the EMC driver?
What about the backwards compatibility for DT that doesn't have the EMC node?
Quoted 6 lines
Quoted 1 line
What if EMC driver is disabled in the kernel's config?
The three questions above are actually one problem here. It's not about MC clock, because it's still available after these changes. And MC driver can still get it in the probe function even the EMC driver isn't there.
No, these are separate problems. MC driver queries the clock rate during the probe to configure memory arbitration. In your case the clock rate is always zero for MC.
Quoted 3 lines
The problem is that without EMC driver after these changes. The PLLM will have no client under it, which will cause the PLLM to be disabled in the late init call of "
clk_disable_unused". So the system will be stuck.
This and the above are very compelling reasons to *NOT* register the clock from the EMC driver. You shall move all the clock stuff into the clock driver. Please see T124 EMC driver and what is done for the upcoming T30 EMC driver [1] for the example, borrow parts that fit best for T210.
[1] https://patchwork.ozlabs.org/project/linux-tegra/list/?series=102688
Quoted 6 lines
Quoted 5 lines
And lastly.. what stops the MC driver to probe before the EMC? Looks like MC driver is already in trouble because it's on arch level and the EMC is on subsys, hence MC will get the orphaned clock and won't initialize hardware properly on probe.
Quoted 7 lines
After this moving, the EMC driver will be always enabled by default. And the DT change is necessary as well. The blob of EMC table is not necessary, because it needs a firmware update. We will update the firmware accordingly after the review settled and release it later.
In case of no EMC table blob, the driver can still be registered, but no scaling function provided.
Anyone could change the default kernel configuration. Kernel shall boot and work fine with older device-tree's and any custom config after update. You should not break someones established setup without a good reason and you don't have one here.
Quoted 11 lines
Quoted 4 lines
BTW, how are you testing the EMC driver? Is there T210 devfreq patches in works? Or what's the user of the EMC on T210?
1. Currently, via debugfs.
2. No, we prefer to use Interconnect framework for that. The evaluation is ongoing.
3. With Interconnect, the devices or peripherals can register on it to request the BW. So we can fine-tune the BW requirements with the latency allowance registers altogether to get better efficiency.
Devfreq is the driver for the ACTMON hardware unit. This unit tells the driver when memory clock rate need to go higher or lower, depending on overall memory clients activity. Currently the tegra-devfreq driver supports T124 only, it will support T30 starting with v5.3. AFAIK, it shouldn't be difficult to add support for T210 as well.
IIRC, the new Interconnect API is another away of conveying different requirements between devices. All Tegra's have knobs for memory configuration tuning, but there is no real need to change the default good-enough configuration for the time being in upstream.
AFAIK, there is only one memory client that is really very sensitive to available memory bandwidth - Display Controller. The PM QoS memory bandwidth API is more than enough for the easy start and it's all internal to kernel, hence it will be possible to replace the PM API with something more advanced later on by as-needed basis. That's what I'm currently targeting for T20-T124. The PM QoS API could coexist with the Interconnect API (or whatever else) without any troubles, so it won't be a problem if you'll decide to pull into other direction for T210.
AFAIK, the latency allowance config should be similar on all Tegra's starting from T30. Will be awesome if you'll do all the hard job of bringing up the fresh new API for T210, it always easier to follow by example.
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v3 5/8 memory: tegra: Add EMC scaling support code for Tegra210
In reply to Joseph LoThis patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210.
Based on the work of Peter De Schrijver <[email protected]>.
--- drivers/memory/tegra/tegra210-emc.c | 1369 +++++++++++++++++++++++++++ drivers/memory/tegra/tegra210-emc.h | 722 ++++++++++++++ 2 files changed, 2091 insertions(+)
drivers/memory/tegra/tegra210-emc.c +1369 -0
@@ -21,11 +21,27 @@#define EMC_CLK_EMC_2X_CLK_SRC_SHIFT 29#define EMC_CLK_EMC_2X_CLK_SRC_MASK \ (0x7 << EMC_CLK_EMC_2X_CLK_SRC_SHIFT) +#define EMC_CLK_SOURCE_PLLM_LJ 0x4 +#define EMC_CLK_SOURCE_PLLMB_LJ 0x5#define EMC_CLK_MC_EMC_SAME_FREQ BIT(16)#define EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT 0#define EMC_CLK_EMC_2X_CLK_DIVISOR_MASK \ (0xff << EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT) +#define CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL 0x664 +#define DLL_CLK_EMC_DLL_CLK_SRC_SHIFT 29 +#define DLL_CLK_EMC_DLL_CLK_SRC_MASK \ + (0x7 << DLL_CLK_EMC_DLL_CLK_SRC_SHIFT) +#define DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT 10 +#define DLL_CLK_EMC_DLL_DDLL_CLK_SEL_MASK \ + (0x3 << DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT) +#define PLLM_VCOA 0 +#define PLLM_VCOB 1 +#define EMC_DLL_SWITCH_OUT 2 +#define DLL_CLK_EMC_DLL_CLK_DIVISOR_SHIFT 0 +#define DLL_CLK_EMC_DLL_CLK_DIVISOR_MASK \ + (0xff << DLL_CLK_EMC_DLL_CLK_DIVISOR_SHIFT) +#define MC_EMEM_ARB_MISC0_EMC_SAME_FREQ BIT(27)#define TEGRA_EMC_MAX_FREQS 16
@@ -34,7 +50,46 @@#define CLK_CHANGE_DELAY 100#define TRAINING_TIME 100 +#define EMC0_EMC_DATA_BRLSHFT_0_INDEX 2 +#define EMC1_EMC_DATA_BRLSHFT_0_INDEX 3 +#define EMC0_EMC_DATA_BRLSHFT_1_INDEX 4 +#define EMC1_EMC_DATA_BRLSHFT_1_INDEX 5 + +#define TRIM_REG (chan, rank, reg, byte) \ + (((EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte ## _MASK & \ + next_timing->trim_regs[EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## \ + rank ## _ ## reg ## _INDEX]) >> \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte ## _SHIFT) \ + + \ + (((EMC_DATA_BRLSHFT_ ## rank ## _RANK ## rank ## _BYTE ## \ + byte ## _DATA_BRLSHFT_MASK & \ + next_timing->trim_perch_regs[EMC ## chan ## \ + _EMC_DATA_BRLSHFT_ ## rank ## _INDEX]) >> \ + EMC_DATA_BRLSHFT_ ## rank ## _RANK ## rank ## _BYTE ## \ + byte ## _DATA_BRLSHFT_SHIFT) * 64)) + +#define CALC_TEMP (rank, reg, byte1, byte2, n) \ + (((new[n] << EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## \ + reg ## _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte1 ## _SHIFT) & \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte1 ## _MASK) \ + | \ + ((new[n + 1] << EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ##\ + reg ## _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte2 ## _SHIFT) & \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte2 ## _MASK)) +enum { +TEGRA_DRAM_OVER_TEMP_NONE =0 , +TEGRA_DRAM_OVER_TEMP_REFRESH_X2 , +TEGRA_DRAM_OVER_TEMP_REFRESH_X4 , +TEGRA_DRAM_OVER_TEMP_THROTTLE ,/* 4x Refresh + derating. */ +TEGRA_DRAM_OVER_TEMP_MAX , +}; + +enum TEGRA_EMC_SOURCE {TEGRA_EMC_SRC_PLLM ,TEGRA_EMC_SRC_PLLC ,TEGRA_EMC_SRC_PLLP ,
@@ -88,17 +143,499 @@ static const struct supported_sequence supported_seqs[] = { };static const struct supported_sequence *seq = supported_seqs;static DEFINE_SPINLOCK (emc_access_lock); +unsigned long dram_over_temp_state =TEGRA_DRAM_OVER_TEMP_NONE ; + +const struct emc_table_register_offset reg_off = { + .burst_regs_off = { +EMC_RC , +EMC_RFC , +EMC_RFCPB , +EMC_REFCTRL2 , +EMC_RFC_SLR , +EMC_RAS , +EMC_RP , +EMC_R2W , +EMC_W2R , +EMC_R2P , +EMC_W2P , +EMC_R2R , +EMC_TPPD , +EMC_CCDMW , +EMC_RD_RCD , +EMC_WR_RCD , +EMC_RRD , +EMC_REXT , +EMC_WEXT , +EMC_WDV_CHK , +EMC_WDV , +EMC_WSV , +EMC_WEV , +EMC_WDV_MASK , +EMC_WS_DURATION , +EMC_WE_DURATION , +EMC_QUSE , +EMC_QUSE_WIDTH , +EMC_IBDLY , +EMC_OBDLY , +EMC_EINPUT , +EMC_MRW6 , +EMC_EINPUT_DURATION , +EMC_PUTERM_EXTRA , +EMC_PUTERM_WIDTH , +EMC_QRST , +EMC_QSAFE , +EMC_RDV , +EMC_RDV_MASK , +EMC_RDV_EARLY , +EMC_RDV_EARLY_MASK , +EMC_REFRESH , +EMC_BURST_REFRESH_NUM , +EMC_PRE_REFRESH_REQ_CNT , +EMC_PDEX2WR , +EMC_PDEX2RD , +EMC_PCHG2PDEN , +EMC_ACT2PDEN , +EMC_AR2PDEN , +EMC_RW2PDEN , +EMC_CKE2PDEN , +EMC_PDEX2CKE , +EMC_PDEX2MRR , +EMC_TXSR , +EMC_TXSRDLL , +EMC_TCKE , +EMC_TCKESR , +EMC_TPD , +EMC_TFAW , +EMC_TRPAB , +EMC_TCLKSTABLE , +EMC_TCLKSTOP , +EMC_MRW7 , +EMC_TREFBW , +EMC_ODT_WRITE , +EMC_FBIO_CFG5 , +EMC_FBIO_CFG7 , +EMC_CFG_DIG_DLL , +EMC_CFG_DIG_DLL_PERIOD , +EMC_PMACRO_IB_RXRT , +EMC_CFG_PIPE_1 , +EMC_CFG_PIPE_2 , +EMC_PMACRO_QUSE_DDLL_RANK0_4 , +EMC_PMACRO_QUSE_DDLL_RANK0_5 , +EMC_PMACRO_QUSE_DDLL_RANK1_4 , +EMC_PMACRO_QUSE_DDLL_RANK1_5 , +EMC_MRW8 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5 , +EMC_PMACRO_DDLL_LONG_CMD_0 , +EMC_PMACRO_DDLL_LONG_CMD_1 , +EMC_PMACRO_DDLL_LONG_CMD_2 , +EMC_PMACRO_DDLL_LONG_CMD_3 , +EMC_PMACRO_DDLL_LONG_CMD_4 , +EMC_PMACRO_DDLL_SHORT_CMD_0 , +EMC_PMACRO_DDLL_SHORT_CMD_1 , +EMC_PMACRO_DDLL_SHORT_CMD_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3 , +EMC_TXDSRVTTGEN , +EMC_FDPD_CTRL_DQ , +EMC_FDPD_CTRL_CMD , +EMC_FBIO_SPARE , +EMC_ZCAL_INTERVAL , +EMC_ZCAL_WAIT_CNT , +EMC_MRS_WAIT_CNT , +EMC_MRS_WAIT_CNT2 , +EMC_AUTO_CAL_CHANNEL , +EMC_DLL_CFG_0 , +EMC_DLL_CFG_1 , +EMC_PMACRO_AUTOCAL_CFG_COMMON , +EMC_PMACRO_ZCTRL , +EMC_CFG , +EMC_CFG_PIPE , +EMC_DYN_SELF_REF_CONTROL , +EMC_QPOP , +EMC_DQS_BRLSHFT_0 , +EMC_DQS_BRLSHFT_1 , +EMC_CMD_BRLSHFT_2 , +EMC_CMD_BRLSHFT_3 , +EMC_PMACRO_PAD_CFG_CTRL , +EMC_PMACRO_DATA_PAD_RX_CTRL , +EMC_PMACRO_CMD_PAD_RX_CTRL , +EMC_PMACRO_DATA_RX_TERM_MODE , +EMC_PMACRO_CMD_RX_TERM_MODE , +EMC_PMACRO_CMD_PAD_TX_CTRL , +EMC_PMACRO_DATA_PAD_TX_CTRL , +EMC_PMACRO_COMMON_PAD_TX_CTRL , +EMC_PMACRO_VTTGEN_CTRL_0 , +EMC_PMACRO_VTTGEN_CTRL_1 , +EMC_PMACRO_VTTGEN_CTRL_2 , +EMC_PMACRO_BRICK_CTRL_RFU1 , +EMC_PMACRO_CMD_BRICK_CTRL_FDPD , +EMC_PMACRO_BRICK_CTRL_RFU2 , +EMC_PMACRO_DATA_BRICK_CTRL_FDPD , +EMC_PMACRO_BG_BIAS_CTRL_0 , +EMC_CFG_3 , +EMC_PMACRO_TX_PWRD_0 , +EMC_PMACRO_TX_PWRD_1 , +EMC_PMACRO_TX_PWRD_2 , +EMC_PMACRO_TX_PWRD_3 , +EMC_PMACRO_TX_PWRD_4 , +EMC_PMACRO_TX_PWRD_5 , +EMC_CONFIG_SAMPLE_DELAY , +EMC_PMACRO_TX_SEL_CLK_SRC_0 , +EMC_PMACRO_TX_SEL_CLK_SRC_1 , +EMC_PMACRO_TX_SEL_CLK_SRC_2 , +EMC_PMACRO_TX_SEL_CLK_SRC_3 , +EMC_PMACRO_TX_SEL_CLK_SRC_4 , +EMC_PMACRO_TX_SEL_CLK_SRC_5 , +EMC_PMACRO_DDLL_BYPASS , +EMC_PMACRO_DDLL_PWRD_0 , +EMC_PMACRO_DDLL_PWRD_1 , +EMC_PMACRO_DDLL_PWRD_2 , +EMC_PMACRO_CMD_CTRL_0 , +EMC_PMACRO_CMD_CTRL_1 , +EMC_PMACRO_CMD_CTRL_2 , +EMC_TR_TIMING_0 , +EMC_TR_DVFS , +EMC_TR_CTRL_1 , +EMC_TR_RDV , +EMC_TR_QPOP , +EMC_TR_RDV_MASK , +EMC_MRW14 , +EMC_TR_QSAFE , +EMC_TR_QRST , +EMC_TRAINING_CTRL , +EMC_TRAINING_SETTLE , +EMC_TRAINING_VREF_SETTLE , +EMC_TRAINING_CA_FINE_CTRL , +EMC_TRAINING_CA_CTRL_MISC , +EMC_TRAINING_CA_CTRL_MISC1 , +EMC_TRAINING_CA_VREF_CTRL , +EMC_TRAINING_QUSE_CORS_CTRL , +EMC_TRAINING_QUSE_FINE_CTRL , +EMC_TRAINING_QUSE_CTRL_MISC , +EMC_TRAINING_QUSE_VREF_CTRL , +EMC_TRAINING_READ_FINE_CTRL , +EMC_TRAINING_READ_CTRL_MISC , +EMC_TRAINING_READ_VREF_CTRL , +EMC_TRAINING_WRITE_FINE_CTRL , +EMC_TRAINING_WRITE_CTRL_MISC , +EMC_TRAINING_WRITE_VREF_CTRL , +EMC_TRAINING_MPC , +EMC_MRW15 , + }, + .trim_regs_off = { +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2 , +EMC_PMACRO_IB_VREF_DQS_0 , +EMC_PMACRO_IB_VREF_DQS_1 , +EMC_PMACRO_IB_VREF_DQ_0 , +EMC_PMACRO_IB_VREF_DQ_1 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2 , +EMC_PMACRO_QUSE_DDLL_RANK0_0 , +EMC_PMACRO_QUSE_DDLL_RANK0_1 , +EMC_PMACRO_QUSE_DDLL_RANK0_2 , +EMC_PMACRO_QUSE_DDLL_RANK0_3 , +EMC_PMACRO_QUSE_DDLL_RANK1_0 , +EMC_PMACRO_QUSE_DDLL_RANK1_1 , +EMC_PMACRO_QUSE_DDLL_RANK1_2 , +EMC_PMACRO_QUSE_DDLL_RANK1_3 + }, + .burst_mc_regs_off = { +MC_EMEM_ARB_CFG , +MC_EMEM_ARB_OUTSTANDING_REQ , +MC_EMEM_ARB_REFPB_HP_CTRL , +MC_EMEM_ARB_REFPB_BANK_CTRL , +MC_EMEM_ARB_TIMING_RCD , +MC_EMEM_ARB_TIMING_RP , +MC_EMEM_ARB_TIMING_RC , +MC_EMEM_ARB_TIMING_RAS , +MC_EMEM_ARB_TIMING_FAW , +MC_EMEM_ARB_TIMING_RRD , +MC_EMEM_ARB_TIMING_RAP2PRE , +MC_EMEM_ARB_TIMING_WAP2PRE , +MC_EMEM_ARB_TIMING_R2R , +MC_EMEM_ARB_TIMING_W2W , +MC_EMEM_ARB_TIMING_R2W , +MC_EMEM_ARB_TIMING_CCDMW , +MC_EMEM_ARB_TIMING_W2R , +MC_EMEM_ARB_TIMING_RFCPB , +MC_EMEM_ARB_DA_TURNS , +MC_EMEM_ARB_DA_COVERS , +MC_EMEM_ARB_MISC0 , +MC_EMEM_ARB_MISC1 , +MC_EMEM_ARB_MISC2 , +MC_EMEM_ARB_RING1_THROTTLE , +MC_EMEM_ARB_DHYST_CTRL , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7 , + }, + .la_scale_regs_off = { +MC_MLL_MPCORER_PTSA_RATE , +MC_FTOP_PTSA_RATE , +MC_PTSA_GRANT_DECREMENT , +MC_LATENCY_ALLOWANCE_XUSB_0 , +MC_LATENCY_ALLOWANCE_XUSB_1 , +MC_LATENCY_ALLOWANCE_TSEC_0 , +MC_LATENCY_ALLOWANCE_SDMMCA_0 , +MC_LATENCY_ALLOWANCE_SDMMCAA_0 , +MC_LATENCY_ALLOWANCE_SDMMC_0 , +MC_LATENCY_ALLOWANCE_SDMMCAB_0 , +MC_LATENCY_ALLOWANCE_PPCS_0 , +MC_LATENCY_ALLOWANCE_PPCS_1 , +MC_LATENCY_ALLOWANCE_MPCORE_0 , +MC_LATENCY_ALLOWANCE_HC_0 , +MC_LATENCY_ALLOWANCE_HC_1 , +MC_LATENCY_ALLOWANCE_AVPC_0 , +MC_LATENCY_ALLOWANCE_GPU_0 , +MC_LATENCY_ALLOWANCE_GPU2_0 , +MC_LATENCY_ALLOWANCE_NVENC_0 , +MC_LATENCY_ALLOWANCE_NVDEC_0 , +MC_LATENCY_ALLOWANCE_VIC_0 , +MC_LATENCY_ALLOWANCE_VI2_0 , +MC_LATENCY_ALLOWANCE_ISP2_0 , +MC_LATENCY_ALLOWANCE_ISP2_1 , + }, + .burst_regs_per_ch_off = { + { .bank =REG_EMC0 , .offset =EMC_MRW10 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW10 , }, + { .bank =REG_EMC0 , .offset =EMC_MRW11 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW11 , }, + { .bank =REG_EMC0 , .offset =EMC_MRW12 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW12 , }, + { .bank =REG_EMC0 , .offset =EMC_MRW13 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW13 , }, + }, + .trim_regs_per_ch_off = { + { .bank =REG_EMC0 , .offset =EMC_CMD_BRLSHFT_0 , }, + { .bank =REG_EMC1 , .offset =EMC_CMD_BRLSHFT_1 , }, + { .bank =REG_EMC0 , .offset =EMC_DATA_BRLSHFT_0 , }, + { .bank =REG_EMC1 , .offset =EMC_DATA_BRLSHFT_0 , }, + { .bank =REG_EMC0 , .offset =EMC_DATA_BRLSHFT_1 , }, + { .bank =REG_EMC1 , .offset =EMC_DATA_BRLSHFT_1 , }, + { .bank =REG_EMC0 , .offset =EMC_QUSE_BRLSHFT_0 , }, + { .bank =REG_EMC1 , .offset =EMC_QUSE_BRLSHFT_1 , }, + { .bank =REG_EMC0 , .offset =EMC_QUSE_BRLSHFT_2 , }, + { .bank =REG_EMC1 , .offset =EMC_QUSE_BRLSHFT_3 , }, + }, + .vref_regs_per_ch_off = { + { .bank =REG_EMC0 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK0 , }, + { .bank =REG_EMC1 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK0 , }, + { .bank =REG_EMC0 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK1 , }, + { .bank =REG_EMC1 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK1 , }, + }, +};static inline struct tegra_emc *clk_hw_to_emc (struct clk_hw *hw) { return container_of(hw, struct tegra_emc, hw); } +void emc_writel (struct tegra_emc *emc,u32 val,unsigned long offset) +{ +writel_relaxed (val, emc->emc_base[REG_EMC ] + offset); +} +u32 emc_readl (struct tegra_emc *emc,unsigned long offset) {return readl_relaxed (emc->emc_base[REG_EMC ] + offset); } +u32 emc1_readl (struct tegra_emc *emc,unsigned long offset) +{ +return readl_relaxed (emc->emc_base[REG_EMC1 ] + offset); +} + +void emc_writel_per_ch (struct tegra_emc *emc,u32 val,int type, +unsigned long offset) +{ +switch (type) { +case REG_EMC : +case REG_EMC0 : +return writel_relaxed (val, emc->emc_base[REG_EMC ] + offset); +case REG_EMC1 : +return writel_relaxed (val, emc->emc_base[REG_EMC1 ] + offset); + } +} +u32 emc_readl_per_ch (struct tegra_emc *emc,int type,unsigned long offset) {
@@ -117,6 +654,14 @@ u32 emc_readl_per_ch(struct tegra_emc *emc, int type,return val; } +void ccfifo_writel (struct tegra_emc *emc,u32 val,unsigned long addr, +u32 delay) +{ +writel_relaxed (val, emc->emc_base[REG_EMC ] +EMC_CCFIFO_DATA ); +writel_relaxed ((addr &0xffff ) | ((delay &0x7fff ) <<16 ) | (1 <<31 ), + emc->emc_base[REG_EMC ] +EMC_CCFIFO_ADDR ); +} +static inline u32 emc_src_val (u32 val) { return (val & EMC_CLK_EMC_2X_CLK_SRC_MASK) >>
@@ -181,9 +726,833 @@ static inline unsigned long emc_get_src_clk_rate(void) rate += div -1 ;do_div (rate, div); +return rate; } +static void tegra210_change_dll_src (struct tegra_emc *emc, +u32 clksrc) +{ + +u32 out_enb_x; +u32 dll_setting = emc->next_timing->dll_clk_src; +u32 emc_clk_src; +u32 emc_clk_div; + + out_enb_x =0 ; + emc_clk_src = (clksrc &EMC_CLK_EMC_2X_CLK_SRC_MASK ) >> +EMC_CLK_EMC_2X_CLK_SRC_SHIFT ; + emc_clk_div = (clksrc &EMC_CLK_EMC_2X_CLK_DIVISOR_MASK ) >> +EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT ; + + dll_setting &= ~(DLL_CLK_EMC_DLL_CLK_SRC_MASK | +DLL_CLK_EMC_DLL_CLK_DIVISOR_MASK ); + dll_setting |= emc_clk_src <<DLL_CLK_EMC_DLL_CLK_SRC_SHIFT ; + dll_setting |= emc_clk_div <<DLL_CLK_EMC_DLL_CLK_DIVISOR_SHIFT ; + + dll_setting &= ~DLL_CLK_EMC_DLL_DDLL_CLK_SEL_MASK ; +if (emc_clk_src ==EMC_CLK_SOURCE_PLLMB_LJ ) + dll_setting |= (PLLM_VCOB << +DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT ); +else if (emc_clk_src ==EMC_CLK_SOURCE_PLLM_LJ ) + dll_setting |= (PLLM_VCOA << +DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT ); +else + dll_setting |= (EMC_DLL_SWITCH_OUT << +DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT ); + +tegra210_clk_emc_dll_update_setting (dll_setting); + +if (emc->next_timing->clk_out_enb_x_0_clk_enb_emc_dll) +tegra210_clk_emc_dll_enable (true); +else +tegra210_clk_emc_dll_enable (false); +} + +void do_clock_change (struct tegra_emc *emc,u32 clksrc) +{ +int err; + +mc_readl (emc->mc,MC_EMEM_ADR_CFG ); +emc_readl (emc,EMC_INTSTATUS ); + +tegra210_clk_emc_update_setting (clksrc); + + err =wait_for_update (emc,EMC_INTSTATUS , +EMC_INTSTATUS_CLKCHANGE_COMPLETE , true,REG_EMC ); +if (err) { +pr_err ("%s: clock change completion error: %d" , __func__, err); +WARN_ON (1 ); + } +} + +struct emc_table *get_timing_from_freq (struct tegra_emc *emc, +unsigned long rate) +{ +int i; + +for (i =0 ; i < emc->emc_table_size; i++) +if (emc->emc_table[i].rate == rate) +return &emc->emc_table[i]; + +return NULL ; +} + +int wait_for_update (struct tegra_emc *emc,u32 status_reg,u32 bit_mask, +bool updated_state,int chan) +{ +int i, err = -ETIMEDOUT ; +u32 reg; + +for (i =0 ; i <EMC_STATUS_UPDATE_TIMEOUT ; i++) { + reg =emc_readl_per_ch (emc, chan, status_reg); +if (!!(reg & bit_mask) == updated_state) { + err =0 ; + goto done; + } +udelay (1 ); + } + +done: +return err; +} + +void emc_set_shadow_bypass (struct tegra_emc *emc,int set) +{ +u32 emc_dbg =emc_readl (emc,EMC_DBG ); + +if (set) +emc_writel (emc, emc_dbg |EMC_DBG_WRITE_MUX_ACTIVE ,EMC_DBG ); +else +emc_writel (emc, emc_dbg & ~EMC_DBG_WRITE_MUX_ACTIVE ,EMC_DBG ); +} + +u32 get_dll_state (struct emc_table *next_timing) +{ +bool next_dll_enabled; + + next_dll_enabled = !(next_timing->emc_emrs &0x1 ); +if (next_dll_enabled) +return DLL_ON ; +else +return DLL_OFF ; +} + +u32 div_o3 (u32 a,u32 b) +{ +u32 result = a / b; + +if ((b * result) < a) +return result +1 ; +else +return result; +} + +void emc_timing_update (struct tegra_emc *emc,int dual_chan) +{ +int err =0 ; + +emc_writel (emc,0x1 ,EMC_TIMING_CONTROL ); + err |=wait_for_update (emc,EMC_EMC_STATUS , +EMC_EMC_STATUS_TIMING_UPDATE_STALLED , false, +REG_EMC ); +if (dual_chan) + err |=wait_for_update (emc,EMC_EMC_STATUS , +EMC_EMC_STATUS_TIMING_UPDATE_STALLED , + false,REG_EMC1 ); +if (err) { +pr_err ("%s: timing update error: %d" , __func__, err); +WARN_ON (1 ); + } +} + +u32 tegra210_actual_osc_clocks (u32 in) +{ +if (in <0x40 ) +return in *16 ; +else if (in <0x80 ) +return 2048 ; +else if (in <0xc0 ) +return 4096 ; +else +return 8192 ; +} + +void tegra210_start_periodic_compensation (struct tegra_emc *emc) +{ +u32 mpc_req =0x4b ; + +emc_writel (emc, mpc_req,EMC_MPC ); + mpc_req =emc_readl (emc,EMC_MPC ); +} + +u32 tegra210_apply_periodic_compensation_trimmer (struct emc_table *next_timing, +u32 offset) +{ +u32 i, temp =0 ; +u32 next_timing_rate_mhz = next_timing->rate /1000 ; +s32 tree_delta[4 ]; +s32 tree_delta_taps[4 ]; +s32 new[] = { +TRIM_REG (0 ,0 ,0 ,0 ), +TRIM_REG (0 ,0 ,0 ,1 ), +TRIM_REG (0 ,0 ,1 ,2 ), +TRIM_REG (0 ,0 ,1 ,3 ), + +TRIM_REG (1 ,0 ,2 ,4 ), +TRIM_REG (1 ,0 ,2 ,5 ), +TRIM_REG (1 ,0 ,3 ,6 ), +TRIM_REG (1 ,0 ,3 ,7 ), + +TRIM_REG (0 ,1 ,0 ,0 ), +TRIM_REG (0 ,1 ,0 ,1 ), +TRIM_REG (0 ,1 ,1 ,2 ), +TRIM_REG (0 ,1 ,1 ,3 ), + +TRIM_REG (1 ,1 ,2 ,4 ), +TRIM_REG (1 ,1 ,2 ,5 ), +TRIM_REG (1 ,1 ,3 ,6 ), +TRIM_REG (1 ,1 ,3 ,7 ) + }; + +switch (offset) { +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 : +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 : +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 : +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 : +case EMC_DATA_BRLSHFT_0 : + tree_delta[0 ] =128 * + (next_timing->current_dram_clktree[C0D0U0 ] - + next_timing->trained_dram_clktree[C0D0U0 ]); + tree_delta[1 ] =128 * + (next_timing->current_dram_clktree[C0D0U1 ] - + next_timing->trained_dram_clktree[C0D0U1 ]); + tree_delta[2 ] =128 * + (next_timing->current_dram_clktree[C1D0U0 ] - + next_timing->trained_dram_clktree[C1D0U0 ]); + tree_delta[3 ] =128 * + (next_timing->current_dram_clktree[C1D0U1 ] - + next_timing->trained_dram_clktree[C1D0U1 ]); + + tree_delta_taps[0 ] = (tree_delta[0 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + tree_delta_taps[1 ] = (tree_delta[1 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + tree_delta_taps[2 ] = (tree_delta[2 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + tree_delta_taps[3 ] = (tree_delta[3 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + +for (i =0 ; i <4 ; i++) { +if ((tree_delta_taps[i] > next_timing->tree_margin) || + (tree_delta_taps[i] < + (-1 * next_timing->tree_margin))) { + new[i *2 ] = new[i *2 ] + tree_delta_taps[i]; + new[i *2 +1 ] = new[i *2 +1 ] + + tree_delta_taps[i]; + } + } + +if (offset ==EMC_DATA_BRLSHFT_0 ) { +for (i =0 ; i <8 ; i++) + new[i] = new[i] /64 ; + }else { +for (i =0 ; i <8 ; i++) + new[i] = new[i] %64 ; + } +break ; + +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 : +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 : +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 : +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 : +case EMC_DATA_BRLSHFT_1 : + tree_delta[0 ] =128 * + (next_timing->current_dram_clktree[C0D1U0 ] - + next_timing->trained_dram_clktree[C0D1U0 ]); + tree_delta[1 ] =128 * + (next_timing->current_dram_clktree[C0D1U1 ] - + next_timing->trained_dram_clktree[C0D1U1 ]); + tree_delta[2 ] =128 * + (next_timing->current_dram_clktree[C1D1U0 ] - + next_timing->trained_dram_clktree[C1D1U0 ]); + tree_delta[3 ] =128 * + (next_timing->current_dram_clktree[C1D1U1 ] - + next_timing->trained_dram_clktree[C1D1U1 ]); + + tree_delta_taps[0 ] = (tree_delta[0 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + tree_delta_taps[1 ] = (tree_delta[1 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + tree_delta_taps[2 ] = (tree_delta[2 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + tree_delta_taps[3 ] = (tree_delta[3 ] * + (s32 )next_timing_rate_mhz) /1000000 ; + +for (i =0 ; i <4 ; i++) { +if ((tree_delta_taps[i] > next_timing->tree_margin) || + (tree_delta_taps[i] < + (-1 * next_timing->tree_margin))) { + new[8 + i *2 ] = new[8 + i *2 ] + + tree_delta_taps[i]; + new[8 + i *2 +1 ] = new[8 + i *2 +1 ] + + tree_delta_taps[i]; + } + } + +if (offset ==EMC_DATA_BRLSHFT_1 ) { +for (i =0 ; i <8 ; i++) + new[i +8 ] = new[i +8 ] /64 ; + }else { +for (i =0 ; i <8 ; i++) + new[i +8 ] = new[i +8 ] %64 ; + } +break ; + } + +switch (offset) { +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 : + temp =CALC_TEMP (0 ,0 ,0 ,1 ,0 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 : + temp =CALC_TEMP (0 ,1 ,2 ,3 ,2 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 : + temp =CALC_TEMP (0 ,2 ,4 ,5 ,4 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 : + temp =CALC_TEMP (0 ,3 ,6 ,7 ,6 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 : + temp =CALC_TEMP (1 ,0 ,0 ,1 ,8 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 : + temp =CALC_TEMP (1 ,1 ,2 ,3 ,10 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 : + temp =CALC_TEMP (1 ,2 ,4 ,5 ,12 ); +break ; +case EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 : + temp =CALC_TEMP (1 ,3 ,6 ,7 ,14 ); +break ; +case EMC_DATA_BRLSHFT_0 : + temp = ((new[0 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE0_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE0_DATA_BRLSHFT_MASK ) | + ((new[1 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE1_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE1_DATA_BRLSHFT_MASK ) | + ((new[2 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE2_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE2_DATA_BRLSHFT_MASK ) | + ((new[3 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE3_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE3_DATA_BRLSHFT_MASK ) | + ((new[4 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE4_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE4_DATA_BRLSHFT_MASK ) | + ((new[5 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE5_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE5_DATA_BRLSHFT_MASK ) | + ((new[6 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE6_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE6_DATA_BRLSHFT_MASK ) | + ((new[7 ] << +EMC_DATA_BRLSHFT_0_RANK0_BYTE7_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_0_RANK0_BYTE7_DATA_BRLSHFT_MASK ); +break ; +case EMC_DATA_BRLSHFT_1 : + temp = ((new[8 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE0_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE0_DATA_BRLSHFT_MASK ) | + ((new[9 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE1_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE1_DATA_BRLSHFT_MASK ) | + ((new[10 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE2_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE2_DATA_BRLSHFT_MASK ) | + ((new[11 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE3_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE3_DATA_BRLSHFT_MASK ) | + ((new[12 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE4_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE4_DATA_BRLSHFT_MASK ) | + ((new[13 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE5_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE5_DATA_BRLSHFT_MASK ) | + ((new[14 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE6_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE6_DATA_BRLSHFT_MASK ) | + ((new[15 ] << +EMC_DATA_BRLSHFT_1_RANK1_BYTE7_DATA_BRLSHFT_SHIFT ) & +EMC_DATA_BRLSHFT_1_RANK1_BYTE7_DATA_BRLSHFT_MASK ); +break ; +default : +break ; + } + +return temp; +} + +u32 tegra210_dll_prelock (struct tegra_emc *emc,int dvfs_with_training, +u32 clksrc) +{ +u32 emc_dig_dll_status; +u32 dll_locked; +u32 dll_out; +u32 emc_cfg_dig_dll; +u32 emc_dll_cfg_0; +u32 emc_dll_cfg_1; +u32 ddllcal_ctrl_start_trim_val; +u32 dll_en; +u32 dual_channel_lpddr4_case; +u32 dll_priv_updated; + + dual_channel_lpddr4_case = + !!(emc_readl (emc,EMC_FBIO_CFG7 ) &EMC_FBIO_CFG7_CH1_ENABLE ) & + !!(emc_readl (emc,EMC_FBIO_CFG7 ) &EMC_FBIO_CFG7_CH0_ENABLE ); + + emc_dig_dll_status =0 ; + dll_locked =0 ; + dll_out =0 ; + emc_cfg_dig_dll =0 ; + emc_dll_cfg_0 =0 ; + emc_dll_cfg_1 =0 ; + ddllcal_ctrl_start_trim_val =0 ; + dll_en =0 ; + + emc_cfg_dig_dll =emc_readl (emc,EMC_CFG_DIG_DLL ) & + ~EMC_CFG_DIG_DLL_CFG_DLL_LOCK_LIMIT_MASK ; + emc_cfg_dig_dll |= (3 <<EMC_CFG_DIG_DLL_CFG_DLL_LOCK_LIMIT_SHIFT ); + emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_CFG_DLL_EN ; + emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_CFG_DLL_MODE_MASK ; + emc_cfg_dig_dll |= (3 <<EMC_CFG_DIG_DLL_CFG_DLL_MODE_SHIFT ); + emc_cfg_dig_dll |=EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_TRAFFIC ; + emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_CFG_DLL_STALL_RW_UNTIL_LOCK ; + emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_UNTIL_LOCK ; + +emc_writel (emc, emc_cfg_dig_dll,EMC_CFG_DIG_DLL ); +emc_writel (emc,1 ,EMC_TIMING_CONTROL ); + +wait_for_update (emc,EMC_EMC_STATUS , +EMC_EMC_STATUS_TIMING_UPDATE_STALLED ,0 ,REG_EMC ); +if (dual_channel_lpddr4_case) +wait_for_update (emc,EMC_EMC_STATUS , +EMC_EMC_STATUS_TIMING_UPDATE_STALLED , +0 ,REG_EMC1 ); + +do { + emc_cfg_dig_dll =emc_readl (emc,EMC_CFG_DIG_DLL ); + dll_en = emc_cfg_dig_dll &EMC_CFG_DIG_DLL_CFG_DLL_EN ; + }while (dll_en ==1 ); + +if (dual_channel_lpddr4_case) { +do { + emc_cfg_dig_dll =emc1_readl (emc,EMC_CFG_DIG_DLL ); + dll_en = emc_cfg_dig_dll &EMC_CFG_DIG_DLL_CFG_DLL_EN ; + }while (dll_en ==1 ); + } + + emc_dll_cfg_0 = emc->next_timing->burst_regs[EMC_DLL_CFG_0_INDEX ]; + +emc_writel (emc, emc_dll_cfg_0,EMC_DLL_CFG_0 ); + +if (emc->next_timing->rate >=400000 + && emc->next_timing->rate <600000 ) + ddllcal_ctrl_start_trim_val =150 ; +else if (emc->next_timing->rate >=600000 + && emc->next_timing->rate <800000 ) + ddllcal_ctrl_start_trim_val =100 ; +else if (emc->next_timing->rate >=800000 + && emc->next_timing->rate <1000000 ) + ddllcal_ctrl_start_trim_val =70 ; +else if (emc->next_timing->rate >=1000000 + && emc->next_timing->rate <1200000 ) + ddllcal_ctrl_start_trim_val =30 ; +else + ddllcal_ctrl_start_trim_val =20 ; + + emc_dll_cfg_1 =emc_readl (emc,EMC_DLL_CFG_1 ); + emc_dll_cfg_1 &=EMC_DLL_CFG_1_DDLLCAL_CTRL_START_TRIM_MASK ; + emc_dll_cfg_1 |= ddllcal_ctrl_start_trim_val; +emc_writel (emc, emc_dll_cfg_1,EMC_DLL_CFG_1 ); + +tegra210_change_dll_src (emc, clksrc); + + emc_cfg_dig_dll =emc_readl (emc,EMC_CFG_DIG_DLL ); + emc_cfg_dig_dll |=EMC_CFG_DIG_DLL_CFG_DLL_EN ; +emc_writel (emc, emc_cfg_dig_dll,EMC_CFG_DIG_DLL ); + +emc_timing_update (emc, dual_channel_lpddr4_case ? +DUAL_CHANNEL :SINGLE_CHANNEL ); + +do { + emc_cfg_dig_dll =emc_readl (emc,EMC_CFG_DIG_DLL ); + dll_en = emc_cfg_dig_dll &EMC_CFG_DIG_DLL_CFG_DLL_EN ; + }while (dll_en ==0 ); + +if (dual_channel_lpddr4_case) { +do { + emc_cfg_dig_dll =emc1_readl (emc,EMC_CFG_DIG_DLL ); + dll_en = emc_cfg_dig_dll &EMC_CFG_DIG_DLL_CFG_DLL_EN ; + }while (dll_en ==0 ); + } + +do { + emc_dig_dll_status =emc_readl (emc,EMC_DIG_DLL_STATUS ); + dll_locked = emc_dig_dll_status &EMC_DIG_DLL_STATUS_DLL_LOCK ; + dll_priv_updated = emc_dig_dll_status & +EMC_DIG_DLL_STATUS_DLL_PRIV_UPDATED ; + }while (!dll_locked || !dll_priv_updated); + + emc_dig_dll_status =emc_readl (emc,EMC_DIG_DLL_STATUS ); +return emc_dig_dll_status &EMC_DIG_DLL_STATUS_DLL_OUT_MASK ; +} + +u32 tegra210_dvfs_power_ramp_up (struct tegra_emc *emc,u32 clk, +int flip_backward) +{ +u32 pmacro_cmd_pad; +u32 pmacro_dq_pad; +u32 pmacro_rfu1; +u32 pmacro_cfg5; +u32 pmacro_common_tx; +u32 ramp_up_wait =0 ; + +if (flip_backward) { + pmacro_cmd_pad = emc->current_timing->burst_regs[ +EMC_PMACRO_CMD_PAD_TX_CTRL_INDEX ]; + pmacro_dq_pad = emc->current_timing->burst_regs[ +EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX ]; + pmacro_rfu1 = emc->current_timing->burst_regs[ +EMC_PMACRO_BRICK_CTRL_RFU1_INDEX ]; + pmacro_cfg5 = emc->current_timing->burst_regs[ +EMC_FBIO_CFG5_INDEX ]; + pmacro_common_tx = emc->current_timing->burst_regs[ +EMC_PMACRO_COMMON_PAD_TX_CTRL_INDEX ]; + }else { + pmacro_cmd_pad = emc->next_timing->burst_regs[ +EMC_PMACRO_CMD_PAD_TX_CTRL_INDEX ]; + pmacro_dq_pad = emc->next_timing->burst_regs[ +EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX ]; + pmacro_rfu1 = emc->next_timing->burst_regs[ +EMC_PMACRO_BRICK_CTRL_RFU1_INDEX ]; + pmacro_cfg5 = emc->next_timing->burst_regs[ +EMC_FBIO_CFG5_INDEX ]; + pmacro_common_tx = emc->next_timing->burst_regs[ +EMC_PMACRO_COMMON_PAD_TX_CTRL_INDEX ]; + } + pmacro_cmd_pad |=EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_DRVFORCEON ; + +if (clk <1000000 /DVFS_FGCG_MID_SPEED_THRESHOLD ) { +ccfifo_writel (emc, pmacro_common_tx &0xa , +EMC_PMACRO_COMMON_PAD_TX_CTRL ,0 ); +ccfifo_writel (emc, pmacro_common_tx &0xf , +EMC_PMACRO_COMMON_PAD_TX_CTRL , + (100000 / clk) +1 ); + ramp_up_wait +=100000 ; + }else { +ccfifo_writel (emc, pmacro_common_tx |0x8 , +EMC_PMACRO_COMMON_PAD_TX_CTRL ,0 ); + } + +if (clk <1000000 /DVFS_FGCG_HIGH_SPEED_THRESHOLD ) { +if (clk <1000000 /IOBRICK_DCC_THRESHOLD ) { + pmacro_cmd_pad |= +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSP_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSN_TX_E_DCC ; + pmacro_cmd_pad &= + ~(EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_CMD_TX_E_DCC ); +ccfifo_writel (emc, pmacro_cmd_pad, +EMC_PMACRO_CMD_PAD_TX_CTRL , + (100000 / clk) +1 ); + ramp_up_wait +=100000 ; + + pmacro_dq_pad |= +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSP_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSN_TX_E_DCC ; + pmacro_dq_pad &= + ~(EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_CMD_TX_E_DCC ); +ccfifo_writel (emc, pmacro_dq_pad, +EMC_PMACRO_DATA_PAD_TX_CTRL ,0 ); +ccfifo_writel (emc, pmacro_rfu1 &0xfe40fe40 , +EMC_PMACRO_BRICK_CTRL_RFU1 ,0 ); + }else { +ccfifo_writel (emc, pmacro_rfu1 &0xfe40fe40 , +EMC_PMACRO_BRICK_CTRL_RFU1 , + (100000 / clk) +1 ); + ramp_up_wait +=100000 ; + } + +ccfifo_writel (emc, pmacro_rfu1 &0xfeedfeed , +EMC_PMACRO_BRICK_CTRL_RFU1 , (100000 / clk) +1 ); + ramp_up_wait +=100000 ; + +if (clk <1000000 /IOBRICK_DCC_THRESHOLD ) { + pmacro_cmd_pad |= +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSP_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSN_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_CMD_TX_E_DCC ; +ccfifo_writel (emc, pmacro_cmd_pad, +EMC_PMACRO_CMD_PAD_TX_CTRL , + (100000 / clk) +1 ); + ramp_up_wait +=100000 ; + + pmacro_dq_pad |= +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSP_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSN_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_CMD_TX_E_DCC ; +ccfifo_writel (emc, pmacro_dq_pad, +EMC_PMACRO_DATA_PAD_TX_CTRL ,0 ); +ccfifo_writel (emc, pmacro_rfu1, +EMC_PMACRO_BRICK_CTRL_RFU1 ,0 ); + }else { +ccfifo_writel (emc, pmacro_rfu1, +EMC_PMACRO_BRICK_CTRL_RFU1 , + (100000 / clk) +1 ); + ramp_up_wait +=100000 ; + } + +ccfifo_writel (emc, pmacro_cfg5 & ~EMC_FBIO_CFG5_CMD_TX_DIS , +EMC_FBIO_CFG5 , (100000 / clk) +10 ); + ramp_up_wait +=100000 + (10 * clk); + }else if (clk <1000000 /DVFS_FGCG_MID_SPEED_THRESHOLD ) { +ccfifo_writel (emc, pmacro_rfu1 |0x06000600 , +EMC_PMACRO_BRICK_CTRL_RFU1 , (100000 / clk) +1 ); +ccfifo_writel (emc, pmacro_cfg5 & ~EMC_FBIO_CFG5_CMD_TX_DIS , +EMC_FBIO_CFG5 , (100000 / clk) +10 ); + ramp_up_wait +=100000 +10 * clk; + }else { +ccfifo_writel (emc, pmacro_rfu1 |0x00000600 , +EMC_PMACRO_BRICK_CTRL_RFU1 ,0 ); +ccfifo_writel (emc, pmacro_cfg5 & ~EMC_FBIO_CFG5_CMD_TX_DIS , +EMC_FBIO_CFG5 ,12 ); + ramp_up_wait +=12 * clk; + } + + pmacro_cmd_pad &= ~EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_DRVFORCEON ; +ccfifo_writel (emc, pmacro_cmd_pad,EMC_PMACRO_CMD_PAD_TX_CTRL ,5 ); + +return ramp_up_wait; +} + +u32 tegra210_dvfs_power_ramp_down (struct tegra_emc *emc,u32 clk, +int flip_backward) +{ +u32 ramp_down_wait =0 ; +u32 pmacro_cmd_pad; +u32 pmacro_dq_pad; +u32 pmacro_rfu1; +u32 pmacro_cfg5; +u32 pmacro_common_tx; +u32 seq_wait; + +if (flip_backward) { + pmacro_cmd_pad = emc->next_timing->burst_regs[ +EMC_PMACRO_CMD_PAD_TX_CTRL_INDEX ]; + pmacro_dq_pad = emc->next_timing->burst_regs[ +EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX ]; + pmacro_rfu1 = emc->next_timing->burst_regs[ +EMC_PMACRO_BRICK_CTRL_RFU1_INDEX ]; + pmacro_cfg5 = emc->next_timing->burst_regs[ +EMC_FBIO_CFG5_INDEX ]; + pmacro_common_tx = emc->next_timing->burst_regs[ +EMC_PMACRO_COMMON_PAD_TX_CTRL_INDEX ]; + }else { + pmacro_cmd_pad = emc->current_timing->burst_regs[ +EMC_PMACRO_CMD_PAD_TX_CTRL_INDEX ]; + pmacro_dq_pad = emc->current_timing->burst_regs[ +EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX ]; + pmacro_rfu1 = emc->current_timing->burst_regs[ +EMC_PMACRO_BRICK_CTRL_RFU1_INDEX ]; + pmacro_cfg5 = emc->current_timing->burst_regs[ +EMC_FBIO_CFG5_INDEX ]; + pmacro_common_tx = emc->current_timing->burst_regs[ +EMC_PMACRO_COMMON_PAD_TX_CTRL_INDEX ]; + } + + pmacro_cmd_pad |=EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_DRVFORCEON ; + +ccfifo_writel (emc, pmacro_cmd_pad,EMC_PMACRO_CMD_PAD_TX_CTRL ,0 ); +ccfifo_writel (emc, pmacro_cfg5 |EMC_FBIO_CFG5_CMD_TX_DIS , +EMC_FBIO_CFG5 ,12 ); + ramp_down_wait =12 * clk; + + seq_wait = (100000 / clk) +1 ; + +if (clk < (1000000 /DVFS_FGCG_HIGH_SPEED_THRESHOLD )) { +if (clk < (1000000 /IOBRICK_DCC_THRESHOLD )) { + pmacro_cmd_pad &= + ~(EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_CMD_TX_E_DCC ); + pmacro_cmd_pad |= +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSP_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSN_TX_E_DCC ; +ccfifo_writel (emc, pmacro_cmd_pad, +EMC_PMACRO_CMD_PAD_TX_CTRL , seq_wait); + ramp_down_wait +=100000 ; + + pmacro_dq_pad &= + ~(EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_CMD_TX_E_DCC ); + pmacro_dq_pad |= +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSP_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSN_TX_E_DCC ; +ccfifo_writel (emc, pmacro_dq_pad, +EMC_PMACRO_DATA_PAD_TX_CTRL ,0 ); +ccfifo_writel (emc, pmacro_rfu1 & ~0x01120112 , +EMC_PMACRO_BRICK_CTRL_RFU1 ,0 ); + }else { +ccfifo_writel (emc, pmacro_rfu1 & ~0x01120112 , +EMC_PMACRO_BRICK_CTRL_RFU1 , seq_wait); + ramp_down_wait +=100000 ; + } + +ccfifo_writel (emc, pmacro_rfu1 & ~0x01bf01bf , +EMC_PMACRO_BRICK_CTRL_RFU1 , seq_wait); + ramp_down_wait +=100000 ; + +if (clk < (1000000 /IOBRICK_DCC_THRESHOLD )) { + pmacro_cmd_pad &= + ~(EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_CMD_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSP_TX_E_DCC | +EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSN_TX_E_DCC ); +ccfifo_writel (emc, pmacro_cmd_pad, +EMC_PMACRO_CMD_PAD_TX_CTRL , seq_wait); + ramp_down_wait +=100000 ; + + pmacro_dq_pad &= + ~(EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_CMD_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSP_TX_E_DCC | +EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSN_TX_E_DCC ); +ccfifo_writel (emc, pmacro_dq_pad, +EMC_PMACRO_DATA_PAD_TX_CTRL ,0 ); +ccfifo_writel (emc, pmacro_rfu1 & ~0x07ff07ff , +EMC_PMACRO_BRICK_CTRL_RFU1 ,0 ); + }else { +ccfifo_writel (emc, pmacro_rfu1 & ~0x07ff07ff , +EMC_PMACRO_BRICK_CTRL_RFU1 , seq_wait); + ramp_down_wait +=100000 ; + } + }else { +ccfifo_writel (emc, pmacro_rfu1 & ~0xffff07ff , +EMC_PMACRO_BRICK_CTRL_RFU1 , seq_wait +19 ); + ramp_down_wait +=100000 + (20 * clk); + } + +if (clk < (1000000 /DVFS_FGCG_MID_SPEED_THRESHOLD )) { + ramp_down_wait +=100000 ; +ccfifo_writel (emc, pmacro_common_tx & ~0x5 , +EMC_PMACRO_COMMON_PAD_TX_CTRL , seq_wait); + ramp_down_wait +=100000 ; +ccfifo_writel (emc, pmacro_common_tx & ~0xf , +EMC_PMACRO_COMMON_PAD_TX_CTRL , seq_wait); + ramp_down_wait +=100000 ; +ccfifo_writel (emc,0 ,0 , seq_wait); + ramp_down_wait +=100000 ; + }else { +ccfifo_writel (emc, pmacro_common_tx & ~0xf , +EMC_PMACRO_COMMON_PAD_TX_CTRL , seq_wait); + } + +return ramp_down_wait; +} + +void tegra210_reset_dram_clktree_values (struct emc_table *table) +{ + table->current_dram_clktree[C0D0U0 ] = + table->trained_dram_clktree[C0D0U0 ]; + table->current_dram_clktree[C0D0U1 ] = + table->trained_dram_clktree[C0D0U1 ]; + table->current_dram_clktree[C1D0U0 ] = + table->trained_dram_clktree[C1D0U0 ]; + table->current_dram_clktree[C1D0U1 ] = + table->trained_dram_clktree[C1D0U1 ]; + table->current_dram_clktree[C1D1U0 ] = + table->trained_dram_clktree[C1D1U0 ]; + table->current_dram_clktree[C1D1U1 ] = + table->trained_dram_clktree[C1D1U1 ]; +} + +static void update_dll_control (struct tegra_emc *emc,u32 emc_cfg_dig_dll, +int channel_mode,bool updated_state) +{ +emc_writel (emc, emc_cfg_dig_dll,EMC_CFG_DIG_DLL ); +emc_timing_update (emc, channel_mode); + +wait_for_update (emc,EMC_CFG_DIG_DLL ,EMC_CFG_DIG_DLL_CFG_DLL_EN , + updated_state,REG_EMC ); +if (channel_mode ==DUAL_CHANNEL ) +wait_for_update (emc,EMC_CFG_DIG_DLL , +EMC_CFG_DIG_DLL_CFG_DLL_EN , + updated_state,REG_EMC1 ); +} + +void tegra210_dll_disable (struct tegra_emc *emc,int channel_mode) +{ +u32 emc_cfg_dig_dll; + + emc_cfg_dig_dll =emc_readl (emc,EMC_CFG_DIG_DLL ); + emc_cfg_dig_dll &= ~EMC_CFG_DIG_DLL_CFG_DLL_EN ; + +update_dll_control (emc, emc_cfg_dig_dll, channel_mode, false); +} + +void tegra210_dll_enable (struct tegra_emc *emc,int channel_mode) +{ +u32 emc_cfg_dig_dll; + + emc_cfg_dig_dll =emc_readl (emc,EMC_CFG_DIG_DLL ); + emc_cfg_dig_dll |=EMC_CFG_DIG_DLL_CFG_DLL_EN ; + +update_dll_control (emc, emc_cfg_dig_dll, channel_mode, true); +} + +void set_over_temp_timing (struct tegra_emc *emc,struct emc_table *timing, +unsigned long state) +{ +#define REFRESH_X2 1 +#define REFRESH_X4 2 +#define REFRESH_SPEEDUP (val, speedup) \ + (val = ((val) & 0xFFFF0000) | (((val) & 0xFFFF) >> (speedup))) + +u32 ref = timing->burst_regs[EMC_REFRESH_INDEX ]; +u32 pre_ref = timing->burst_regs[EMC_PRE_REFRESH_REQ_CNT_INDEX ]; +u32 dsr_cntrl = timing->burst_regs[EMC_DYN_SELF_REF_CONTROL_INDEX ]; + +switch (state) { +case TEGRA_DRAM_OVER_TEMP_NONE : +case TEGRA_DRAM_OVER_TEMP_THROTTLE : +break ; +case TEGRA_DRAM_OVER_TEMP_REFRESH_X2 : +REFRESH_SPEEDUP (ref,REFRESH_X2 ); +REFRESH_SPEEDUP (pre_ref,REFRESH_X2 ); +REFRESH_SPEEDUP (dsr_cntrl,REFRESH_X2 ); +break ; +case TEGRA_DRAM_OVER_TEMP_REFRESH_X4 : +REFRESH_SPEEDUP (ref,REFRESH_X4 ); +REFRESH_SPEEDUP (pre_ref,REFRESH_X4 ); +REFRESH_SPEEDUP (dsr_cntrl,REFRESH_X4 ); +break ; +default : +WARN (1 ,"%s: Failed to set dram over temp state %lu\n" , + __func__, state); +return ; + } + +emc_writel (emc, ref, reg_off.burst_regs_off[EMC_REFRESH_INDEX ]); +emc_writel (emc, pre_ref, + reg_off.burst_regs_off[EMC_PRE_REFRESH_REQ_CNT_INDEX ]); +emc_writel (emc, dsr_cntrl, + reg_off.burst_regs_off[EMC_DYN_SELF_REF_CONTROL_INDEX ]); +} +static void emc_last_stats_update (int last_sel) {unsigned long flags;
drivers/memory/tegra/tegra210-emc.h +722 -0
742 lines not on this page · raw message
Signature · 1 line
2.21.0
Re: [PATCH V3 5/8] memory: tegra: Add EMC scaling support code for Tegra210
10.05.2019 11:47, Joseph Lo пишет:
Quoted 674 lines
This patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>--- drivers/memory/tegra/tegra210-emc.c | 1369 +++++++++++++++++++++++++++ drivers/memory/tegra/tegra210-emc.h | 722 ++++++++++++++ 2 files changed, 2091 insertions(+)drivers/memory/tegra/tegra210-emc.c +607
-0@@ -21,11 +21,27 @@#define EMC_CLK_EMC_2X_CLK_SRC_SHIFT 29#define EMC_CLK_EMC_2X_CLK_SRC_MASK \ (0x7 << EMC_CLK_EMC_2X_CLK_SRC_SHIFT) +#define EMC_CLK_SOURCE_PLLM_LJ 0x4 +#define EMC_CLK_SOURCE_PLLMB_LJ 0x5#define EMC_CLK_MC_EMC_SAME_FREQ BIT(16)#define EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT 0#define EMC_CLK_EMC_2X_CLK_DIVISOR_MASK \ (0xff << EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT) +#define CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL 0x664 +#define DLL_CLK_EMC_DLL_CLK_SRC_SHIFT 29 +#define DLL_CLK_EMC_DLL_CLK_SRC_MASK \ + (0x7 << DLL_CLK_EMC_DLL_CLK_SRC_SHIFT) +#define DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT 10 +#define DLL_CLK_EMC_DLL_DDLL_CLK_SEL_MASK \ + (0x3 << DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT) +#define PLLM_VCOA 0 +#define PLLM_VCOB 1 +#define EMC_DLL_SWITCH_OUT 2 +#define DLL_CLK_EMC_DLL_CLK_DIVISOR_SHIFT 0 +#define DLL_CLK_EMC_DLL_CLK_DIVISOR_MASK \ + (0xff << DLL_CLK_EMC_DLL_CLK_DIVISOR_SHIFT) +#define MC_EMEM_ARB_MISC0_EMC_SAME_FREQ BIT(27)#define TEGRA_EMC_MAX_FREQS 16@@ -34,7 +50,46 @@#define CLK_CHANGE_DELAY 100#define TRAINING_TIME 100 +#define EMC0_EMC_DATA_BRLSHFT_0_INDEX 2 +#define EMC1_EMC_DATA_BRLSHFT_0_INDEX 3 +#define EMC0_EMC_DATA_BRLSHFT_1_INDEX 4 +#define EMC1_EMC_DATA_BRLSHFT_1_INDEX 5 + +#define TRIM_REG (chan, rank, reg, byte) \ + (((EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte ## _MASK & \ + next_timing->trim_regs[EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## \ + rank ## _ ## reg ## _INDEX]) >> \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte ## _SHIFT) \ + + \ + (((EMC_DATA_BRLSHFT_ ## rank ## _RANK ## rank ## _BYTE ## \ + byte ## _DATA_BRLSHFT_MASK & \ + next_timing->trim_perch_regs[EMC ## chan ## \ + _EMC_DATA_BRLSHFT_ ## rank ## _INDEX]) >> \ + EMC_DATA_BRLSHFT_ ## rank ## _RANK ## rank ## _BYTE ## \ + byte ## _DATA_BRLSHFT_SHIFT) * 64)) + +#define CALC_TEMP (rank, reg, byte1, byte2, n) \ + (((new[n] << EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## \ + reg ## _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte1 ## _SHIFT) & \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte1 ## _MASK) \ + | \ + ((new[n + 1] << EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ##\ + reg ## _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte2 ## _SHIFT) & \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK ## rank ## _ ## reg ## \ + _OB_DDLL_LONG_DQ_RANK ## rank ## _BYTE ## byte2 ## _MASK)) +enum { +TEGRA_DRAM_OVER_TEMP_NONE =0 , +TEGRA_DRAM_OVER_TEMP_REFRESH_X2 , +TEGRA_DRAM_OVER_TEMP_REFRESH_X4 , +TEGRA_DRAM_OVER_TEMP_THROTTLE ,/* 4x Refresh + derating. */ +TEGRA_DRAM_OVER_TEMP_MAX , +}; + +enum TEGRA_EMC_SOURCE {TEGRA_EMC_SRC_PLLM ,TEGRA_EMC_SRC_PLLC ,TEGRA_EMC_SRC_PLLP ,@@ -88,17 +143,499 @@ static const struct supported_sequence supported_seqs[] = { };static const struct supported_sequence *seq = supported_seqs;static DEFINE_SPINLOCK (emc_access_lock); +unsigned long dram_over_temp_state =TEGRA_DRAM_OVER_TEMP_NONE ; + +const struct emc_table_register_offset reg_off = { + .burst_regs_off = { +EMC_RC , +EMC_RFC , +EMC_RFCPB , +EMC_REFCTRL2 , +EMC_RFC_SLR , +EMC_RAS , +EMC_RP , +EMC_R2W , +EMC_W2R , +EMC_R2P , +EMC_W2P , +EMC_R2R , +EMC_TPPD , +EMC_CCDMW , +EMC_RD_RCD , +EMC_WR_RCD , +EMC_RRD , +EMC_REXT , +EMC_WEXT , +EMC_WDV_CHK , +EMC_WDV , +EMC_WSV , +EMC_WEV , +EMC_WDV_MASK , +EMC_WS_DURATION , +EMC_WE_DURATION , +EMC_QUSE , +EMC_QUSE_WIDTH , +EMC_IBDLY , +EMC_OBDLY , +EMC_EINPUT , +EMC_MRW6 , +EMC_EINPUT_DURATION , +EMC_PUTERM_EXTRA , +EMC_PUTERM_WIDTH , +EMC_QRST , +EMC_QSAFE , +EMC_RDV , +EMC_RDV_MASK , +EMC_RDV_EARLY , +EMC_RDV_EARLY_MASK , +EMC_REFRESH , +EMC_BURST_REFRESH_NUM , +EMC_PRE_REFRESH_REQ_CNT , +EMC_PDEX2WR , +EMC_PDEX2RD , +EMC_PCHG2PDEN , +EMC_ACT2PDEN , +EMC_AR2PDEN , +EMC_RW2PDEN , +EMC_CKE2PDEN , +EMC_PDEX2CKE , +EMC_PDEX2MRR , +EMC_TXSR , +EMC_TXSRDLL , +EMC_TCKE , +EMC_TCKESR , +EMC_TPD , +EMC_TFAW , +EMC_TRPAB , +EMC_TCLKSTABLE , +EMC_TCLKSTOP , +EMC_MRW7 , +EMC_TREFBW , +EMC_ODT_WRITE , +EMC_FBIO_CFG5 , +EMC_FBIO_CFG7 , +EMC_CFG_DIG_DLL , +EMC_CFG_DIG_DLL_PERIOD , +EMC_PMACRO_IB_RXRT , +EMC_CFG_PIPE_1 , +EMC_CFG_PIPE_2 , +EMC_PMACRO_QUSE_DDLL_RANK0_4 , +EMC_PMACRO_QUSE_DDLL_RANK0_5 , +EMC_PMACRO_QUSE_DDLL_RANK1_4 , +EMC_PMACRO_QUSE_DDLL_RANK1_5 , +EMC_MRW8 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4 , +EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5 , +EMC_PMACRO_DDLL_LONG_CMD_0 , +EMC_PMACRO_DDLL_LONG_CMD_1 , +EMC_PMACRO_DDLL_LONG_CMD_2 , +EMC_PMACRO_DDLL_LONG_CMD_3 , +EMC_PMACRO_DDLL_LONG_CMD_4 , +EMC_PMACRO_DDLL_SHORT_CMD_0 , +EMC_PMACRO_DDLL_SHORT_CMD_1 , +EMC_PMACRO_DDLL_SHORT_CMD_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3 , +EMC_TXDSRVTTGEN , +EMC_FDPD_CTRL_DQ , +EMC_FDPD_CTRL_CMD , +EMC_FBIO_SPARE , +EMC_ZCAL_INTERVAL , +EMC_ZCAL_WAIT_CNT , +EMC_MRS_WAIT_CNT , +EMC_MRS_WAIT_CNT2 , +EMC_AUTO_CAL_CHANNEL , +EMC_DLL_CFG_0 , +EMC_DLL_CFG_1 , +EMC_PMACRO_AUTOCAL_CFG_COMMON , +EMC_PMACRO_ZCTRL , +EMC_CFG , +EMC_CFG_PIPE , +EMC_DYN_SELF_REF_CONTROL , +EMC_QPOP , +EMC_DQS_BRLSHFT_0 , +EMC_DQS_BRLSHFT_1 , +EMC_CMD_BRLSHFT_2 , +EMC_CMD_BRLSHFT_3 , +EMC_PMACRO_PAD_CFG_CTRL , +EMC_PMACRO_DATA_PAD_RX_CTRL , +EMC_PMACRO_CMD_PAD_RX_CTRL , +EMC_PMACRO_DATA_RX_TERM_MODE , +EMC_PMACRO_CMD_RX_TERM_MODE , +EMC_PMACRO_CMD_PAD_TX_CTRL , +EMC_PMACRO_DATA_PAD_TX_CTRL , +EMC_PMACRO_COMMON_PAD_TX_CTRL , +EMC_PMACRO_VTTGEN_CTRL_0 , +EMC_PMACRO_VTTGEN_CTRL_1 , +EMC_PMACRO_VTTGEN_CTRL_2 , +EMC_PMACRO_BRICK_CTRL_RFU1 , +EMC_PMACRO_CMD_BRICK_CTRL_FDPD , +EMC_PMACRO_BRICK_CTRL_RFU2 , +EMC_PMACRO_DATA_BRICK_CTRL_FDPD , +EMC_PMACRO_BG_BIAS_CTRL_0 , +EMC_CFG_3 , +EMC_PMACRO_TX_PWRD_0 , +EMC_PMACRO_TX_PWRD_1 , +EMC_PMACRO_TX_PWRD_2 , +EMC_PMACRO_TX_PWRD_3 , +EMC_PMACRO_TX_PWRD_4 , +EMC_PMACRO_TX_PWRD_5 , +EMC_CONFIG_SAMPLE_DELAY , +EMC_PMACRO_TX_SEL_CLK_SRC_0 , +EMC_PMACRO_TX_SEL_CLK_SRC_1 , +EMC_PMACRO_TX_SEL_CLK_SRC_2 , +EMC_PMACRO_TX_SEL_CLK_SRC_3 , +EMC_PMACRO_TX_SEL_CLK_SRC_4 , +EMC_PMACRO_TX_SEL_CLK_SRC_5 , +EMC_PMACRO_DDLL_BYPASS , +EMC_PMACRO_DDLL_PWRD_0 , +EMC_PMACRO_DDLL_PWRD_1 , +EMC_PMACRO_DDLL_PWRD_2 , +EMC_PMACRO_CMD_CTRL_0 , +EMC_PMACRO_CMD_CTRL_1 , +EMC_PMACRO_CMD_CTRL_2 , +EMC_TR_TIMING_0 , +EMC_TR_DVFS , +EMC_TR_CTRL_1 , +EMC_TR_RDV , +EMC_TR_QPOP , +EMC_TR_RDV_MASK , +EMC_MRW14 , +EMC_TR_QSAFE , +EMC_TR_QRST , +EMC_TRAINING_CTRL , +EMC_TRAINING_SETTLE , +EMC_TRAINING_VREF_SETTLE , +EMC_TRAINING_CA_FINE_CTRL , +EMC_TRAINING_CA_CTRL_MISC , +EMC_TRAINING_CA_CTRL_MISC1 , +EMC_TRAINING_CA_VREF_CTRL , +EMC_TRAINING_QUSE_CORS_CTRL , +EMC_TRAINING_QUSE_FINE_CTRL , +EMC_TRAINING_QUSE_CTRL_MISC , +EMC_TRAINING_QUSE_VREF_CTRL , +EMC_TRAINING_READ_FINE_CTRL , +EMC_TRAINING_READ_CTRL_MISC , +EMC_TRAINING_READ_VREF_CTRL , +EMC_TRAINING_WRITE_FINE_CTRL , +EMC_TRAINING_WRITE_CTRL_MISC , +EMC_TRAINING_WRITE_VREF_CTRL , +EMC_TRAINING_MPC , +EMC_MRW15 , + }, + .trim_regs_off = { +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2 , +EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1 , +EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2 , +EMC_PMACRO_IB_VREF_DQS_0 , +EMC_PMACRO_IB_VREF_DQS_1 , +EMC_PMACRO_IB_VREF_DQ_0 , +EMC_PMACRO_IB_VREF_DQ_1 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 , +EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1 , +EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2 , +EMC_PMACRO_QUSE_DDLL_RANK0_0 , +EMC_PMACRO_QUSE_DDLL_RANK0_1 , +EMC_PMACRO_QUSE_DDLL_RANK0_2 , +EMC_PMACRO_QUSE_DDLL_RANK0_3 , +EMC_PMACRO_QUSE_DDLL_RANK1_0 , +EMC_PMACRO_QUSE_DDLL_RANK1_1 , +EMC_PMACRO_QUSE_DDLL_RANK1_2 , +EMC_PMACRO_QUSE_DDLL_RANK1_3 + }, + .burst_mc_regs_off = { +MC_EMEM_ARB_CFG , +MC_EMEM_ARB_OUTSTANDING_REQ , +MC_EMEM_ARB_REFPB_HP_CTRL , +MC_EMEM_ARB_REFPB_BANK_CTRL , +MC_EMEM_ARB_TIMING_RCD , +MC_EMEM_ARB_TIMING_RP , +MC_EMEM_ARB_TIMING_RC , +MC_EMEM_ARB_TIMING_RAS , +MC_EMEM_ARB_TIMING_FAW , +MC_EMEM_ARB_TIMING_RRD , +MC_EMEM_ARB_TIMING_RAP2PRE , +MC_EMEM_ARB_TIMING_WAP2PRE , +MC_EMEM_ARB_TIMING_R2R , +MC_EMEM_ARB_TIMING_W2W , +MC_EMEM_ARB_TIMING_R2W , +MC_EMEM_ARB_TIMING_CCDMW , +MC_EMEM_ARB_TIMING_W2R , +MC_EMEM_ARB_TIMING_RFCPB , +MC_EMEM_ARB_DA_TURNS , +MC_EMEM_ARB_DA_COVERS , +MC_EMEM_ARB_MISC0 , +MC_EMEM_ARB_MISC1 , +MC_EMEM_ARB_MISC2 , +MC_EMEM_ARB_RING1_THROTTLE , +MC_EMEM_ARB_DHYST_CTRL , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6 , +MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7 , + }, + .la_scale_regs_off = { +MC_MLL_MPCORER_PTSA_RATE , +MC_FTOP_PTSA_RATE , +MC_PTSA_GRANT_DECREMENT , +MC_LATENCY_ALLOWANCE_XUSB_0 , +MC_LATENCY_ALLOWANCE_XUSB_1 , +MC_LATENCY_ALLOWANCE_TSEC_0 , +MC_LATENCY_ALLOWANCE_SDMMCA_0 , +MC_LATENCY_ALLOWANCE_SDMMCAA_0 , +MC_LATENCY_ALLOWANCE_SDMMC_0 , +MC_LATENCY_ALLOWANCE_SDMMCAB_0 , +MC_LATENCY_ALLOWANCE_PPCS_0 , +MC_LATENCY_ALLOWANCE_PPCS_1 , +MC_LATENCY_ALLOWANCE_MPCORE_0 , +MC_LATENCY_ALLOWANCE_HC_0 , +MC_LATENCY_ALLOWANCE_HC_1 , +MC_LATENCY_ALLOWANCE_AVPC_0 , +MC_LATENCY_ALLOWANCE_GPU_0 , +MC_LATENCY_ALLOWANCE_GPU2_0 , +MC_LATENCY_ALLOWANCE_NVENC_0 , +MC_LATENCY_ALLOWANCE_NVDEC_0 , +MC_LATENCY_ALLOWANCE_VIC_0 , +MC_LATENCY_ALLOWANCE_VI2_0 , +MC_LATENCY_ALLOWANCE_ISP2_0 , +MC_LATENCY_ALLOWANCE_ISP2_1 , + }, + .burst_regs_per_ch_off = { + { .bank =REG_EMC0 , .offset =EMC_MRW10 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW10 , }, + { .bank =REG_EMC0 , .offset =EMC_MRW11 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW11 , }, + { .bank =REG_EMC0 , .offset =EMC_MRW12 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW12 , }, + { .bank =REG_EMC0 , .offset =EMC_MRW13 , }, + { .bank =REG_EMC1 , .offset =EMC_MRW13 , }, + }, + .trim_regs_per_ch_off = { + { .bank =REG_EMC0 , .offset =EMC_CMD_BRLSHFT_0 , }, + { .bank =REG_EMC1 , .offset =EMC_CMD_BRLSHFT_1 , }, + { .bank =REG_EMC0 , .offset =EMC_DATA_BRLSHFT_0 , }, + { .bank =REG_EMC1 , .offset =EMC_DATA_BRLSHFT_0 , }, + { .bank =REG_EMC0 , .offset =EMC_DATA_BRLSHFT_1 , }, + { .bank =REG_EMC1 , .offset =EMC_DATA_BRLSHFT_1 , }, + { .bank =REG_EMC0 , .offset =EMC_QUSE_BRLSHFT_0 , }, + { .bank =REG_EMC1 , .offset =EMC_QUSE_BRLSHFT_1 , }, + { .bank =REG_EMC0 , .offset =EMC_QUSE_BRLSHFT_2 , }, + { .bank =REG_EMC1 , .offset =EMC_QUSE_BRLSHFT_3 , }, + }, + .vref_regs_per_ch_off = { + { .bank =REG_EMC0 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK0 , }, + { .bank =REG_EMC1 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK0 , }, + { .bank =REG_EMC0 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK1 , }, + { .bank =REG_EMC1 , + .offset =EMC_TRAINING_OPT_DQS_IB_VREF_RANK1 , }, + }, +};static inline struct tegra_emc *clk_hw_to_emc (struct clk_hw *hw) { return container_of(hw, struct tegra_emc, hw); } +void emc_writel (struct tegra_emc *emc,u32 val,unsigned long offset) +{ +writel_relaxed (val, emc->emc_base[REG_EMC ] + offset); +} +u32 emc_readl (struct tegra_emc *emc,unsigned long offset) {return readl_relaxed (emc->emc_base[REG_EMC ] + offset); } +u32 emc1_readl (struct tegra_emc *emc,unsigned long offset) +{ +return readl_relaxed (emc->emc_base[REG_EMC1 ] + offset); +} + +void emc_writel_per_ch (struct tegra_emc *emc,u32 val,int type, +unsigned long offset) +{ +switch (type) { +case REG_EMC : +case REG_EMC0 : +return writel_relaxed (val, emc->emc_base[REG_EMC ] + offset); +case REG_EMC1 : +return writel_relaxed (val, emc->emc_base[REG_EMC1 ] + offset); + } +} +u32 emc_readl_per_ch (struct tegra_emc *emc,int type,unsigned long offset) {@@ -117,6 +654,14 @@ u32 emc_readl_per_ch(struct tegra_emc *emc, int type,return val; } +void ccfifo_writel (struct tegra_emc *emc,u32 val,unsigned long addr, +u32 delay) +{ +writel_relaxed (val, emc->emc_base[REG_EMC ] +EMC_CCFIFO_DATA ); +writel_relaxed ((addr &0xffff ) | ((delay &0x7fff ) <<16 ) | (1 <<31 ), + emc->emc_base[REG_EMC ] +EMC_CCFIFO_ADDR ); +} +static inline u32 emc_src_val (u32 val) { return (val & EMC_CLK_EMC_2X_CLK_SRC_MASK) >>@@ -181,9 +726,833 @@ static inline unsigned long emc_get_src_clk_rate(void) rate += div -1 ;do_div (rate, div); +return rate; } +static void tegra210_change_dll_src (struct tegra_emc *emc, +u32 clksrc) +{ + +u32 out_enb_x; +u32 dll_setting = emc->next_timing->dll_clk_src; +u32 emc_clk_src; +u32 emc_clk_div; + + out_enb_x =0 ; + emc_clk_src = (clksrc &EMC_CLK_EMC_2X_CLK_SRC_MASK ) >> +EMC_CLK_EMC_2X_CLK_SRC_SHIFT ; + emc_clk_div = (clksrc &EMC_CLK_EMC_2X_CLK_DIVISOR_MASK ) >> +EMC_CLK_EMC_2X_CLK_DIVISOR_SHIFT ; + + dll_setting &= ~(DLL_CLK_EMC_DLL_CLK_SRC_MASK | +DLL_CLK_EMC_DLL_CLK_DIVISOR_MASK ); + dll_setting |= emc_clk_src <<DLL_CLK_EMC_DLL_CLK_SRC_SHIFT ; + dll_setting |= emc_clk_div <<DLL_CLK_EMC_DLL_CLK_DIVISOR_SHIFT ; + + dll_setting &= ~DLL_CLK_EMC_DLL_DDLL_CLK_SEL_MASK ; +if (emc_clk_src ==EMC_CLK_SOURCE_PLLMB_LJ ) + dll_setting |= (PLLM_VCOB << +DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT ); +else if (emc_clk_src ==EMC_CLK_SOURCE_PLLM_LJ ) + dll_setting |= (PLLM_VCOA << +DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT ); +else + dll_setting |= (EMC_DLL_SWITCH_OUT << +DLL_CLK_EMC_DLL_DDLL_CLK_SEL_SHIFT ); + +tegra210_clk_emc_dll_update_setting (dll_setting); + +if (emc->next_timing->clk_out_enb_x_0_clk_enb_emc_dll) +tegra210_clk_emc_dll_enable (true); +else +tegra210_clk_emc_dll_enable (false); +} + +void do_clock_change (struct tegra_emc *emc,u32 clksrc) +{ +int err; + +mc_readl (emc->mc,MC_EMEM_ADR_CFG ); +emc_readl (emc,EMC_INTSTATUS ); + +tegra210_clk_emc_update_setting (clksrc); + + err =wait_for_update (emc,EMC_INTSTATUS , +EMC_INTSTATUS_CLKCHANGE_COMPLETE , true,REG_EMC ); +if (err) { +pr_err ("%s: clock change completion error: %d" , __func__, err); +WARN_ON (1 ); + } +} + +struct emc_table *get_timing_from_freq (struct tegra_emc *emc, +unsigned long rate) +{ +int i; +
drivers/memory/tegra/tegra210-emc.c static inline unsigned long emc_get_src_clk_rate(void) · line 803
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c +10
-0+for (i =0 ; i < emc->emc_table_size; i++) +if (emc->emc_table[i].rate == rate) +return &emc->emc_table[i]; + +return NULL ; +} + +int wait_for_update (struct tegra_emc *emc,u32 status_reg,u32 bit_mask, +bool updated_state,int chan) +{
This and all other global functions have very generic names. Either squash it all into a single source file and make all functions static, or change the names to something more unique.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 5/8] memory: tegra: Add EMC scaling support code for Tegra210
Quoted 8 lines · Dmitry Osipenko
10.05.2019 11:47, Joseph Lo пишет:
Quoted 7 lines
This patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
snip.
Quoted 28 lines
Quoted 28 lines
drivers/memory/tegra/tegra210-emc.c +28
-0+void do_clock_change (struct tegra_emc *emc,u32 clksrc) +{ +int err; + +mc_readl (emc->mc,MC_EMEM_ADR_CFG ); +emc_readl (emc,EMC_INTSTATUS ); + +tegra210_clk_emc_update_setting (clksrc); + + err =wait_for_update (emc,EMC_INTSTATUS , +EMC_INTSTATUS_CLKCHANGE_COMPLETE , true,REG_EMC ); +if (err) { +pr_err ("%s: clock change completion error: %d" , __func__, err); +WARN_ON (1 ); + } +} + +struct emc_table *get_timing_from_freq (struct tegra_emc *emc, +unsigned long rate) +{ +int i; + +for (i =0 ; i < emc->emc_table_size; i++) +if (emc->emc_table[i].rate == rate) +return &emc->emc_table[i]; + +return NULL ; +}
Quoted 9 lines
drivers/memory/tegra/tegra210-emc.c static inline unsigned long emc_get_src_clk_rate(void) · line 803
Quoted 4 lines
drivers/memory/tegra/tegra210-emc.c +4
-0+ +int wait_for_update (struct tegra_emc *emc,u32 status_reg,u32 bit_mask, +bool updated_state,int chan) +{This and all other global functions have very generic names. Either squash it all into a single source file and make all functions static, or change the names to something more unique.
Okay, will fix it.
Thanks,
Joseph
_______________________________________________
linux-arm-kernel mailing list
[email protected]
http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 5/8] memory: tegra: Add EMC scaling support code for Tegra210
In reply to Joseph Lo10.05.2019 11:47, Joseph Lo пишет:
Quoted 7 lines
This patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
...
drivers/memory/tegra/tegra210-emc.h enum { · line 728
Quoted 11 lines
drivers/memory/tegra/tegra210-emc.h +10
-0+struct per_ch_regs { +u32 bank; +u32 offset; +}; + +struct emc_table_register_offset { +u32 burst_regs_off[BURST_REGS_SIZE ]; +u32 trim_regs_off[TRIM_REGS_SIZE ]; +u32 burst_mc_regs_off[BURST_MC_REGS_SIZE ]; +u32 la_scale_regs_off[BURST_UP_DOWN_REGS_SIZE ];
Looks like u16 should be enough for all of the offsets.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 5/8] memory: tegra: Add EMC scaling support code for Tegra210
In reply to Joseph Lo10.05.2019 11:47, Joseph Lo пишет:
drivers/memory/tegra/tegra210-emc.h struct supported_sequence { · line 863
Quoted 12 lines
This patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
drivers/memory/tegra/tegra210-emc.h +4
-0+int tegra_emc_dt_parse_pdata (struct platform_device *pdev, +struct emc_table **tables, +struct emc_table **derated_tables, +int *num_entries);
There is no definition for this function. Again, please clean up the code properly.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
Re: [PATCH V3 5/8] memory: tegra: Add EMC scaling support code for Tegra210
In reply to Joseph Lo10.05.2019 11:47, Joseph Lo пишет:
Quoted 14 lines
This patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210.
Based on the work of Peter De Schrijver <[email protected]>.
Signed-off-by Joseph Lo <[email protected]>---
drivers/memory/tegra/tegra210-emc.c +6
-0+ +void do_clock_change (struct tegra_emc *emc,u32 clksrc) +{ +int err; + +mc_readl (emc->mc,MC_EMEM_ADR_CFG );
drivers/memory/tegra/tegra210-emc.c static inline unsigned long emc_get_src_clk_rate(void) · line 786
Quoted 10 lines
drivers/memory/tegra/tegra210-emc.c +10
-0+emc_readl (emc,EMC_INTSTATUS ); + +tegra210_clk_emc_update_setting (clksrc); + + err =wait_for_update (emc,EMC_INTSTATUS , +EMC_INTSTATUS_CLKCHANGE_COMPLETE , true,REG_EMC ); +if (err) { +pr_err ("%s: clock change completion error: %d" , __func__, err); +WARN_ON (1 ); + }
Ether WARN(err, ...) or dev_warn, or just dev_err.
Signature · 6 lines
Dmitry _______________________________________________ linux-arm-kernel mailing list [email protected] http://lists.infradead.org/mailman/listinfo/linux-arm-kernel
PATCH v3 6/8 memory: tegra: Add EMC scaling sequence code for Tegra210
In reply to Joseph LoThis patch includes the sequence for clock tuning and the dynamic training mechanism for the clock above 800MHz.
And historically there have been different sequences to change the EMC clock. The sequence to be used is specified in the EMC table. However, for the currently supported upstreaming platform, only the most recent sequence is used. So only support that in this patch.
Based on the work of Peter De Schrijver <[email protected]>.
--- drivers/memory/tegra/Makefile | 2 +- drivers/memory/tegra/tegra210-emc-cc-r21021.c | 1953 +++++++++++++++++ drivers/memory/tegra/tegra210-emc.c | 5 + drivers/memory/tegra/tegra210-emc.h | 157 ++ 4 files changed, 2116 insertions(+), 1 deletion(-) create mode 100644 drivers/memory/tegra/tegra210-emc-cc-r21021.c
drivers/memory/tegra/Makefile +1 -1
@@ -12,5 +12,5 @@ obj-$(CONFIG_TEGRA_MC) += tegra-mc.o obj-$(CONFIG_TEGRA20_EMC) += tegra20-emc.o obj-$(CONFIG_TEGRA124_EMC) += tegra124-emc.o -obj-$(CONFIG_TEGRA210_EMC) += tegra210-emc.o +obj-$(CONFIG_TEGRA210_EMC) += tegra210-emc.o tegra210-emc-cc-r21021.o obj-$(CONFIG_ARCH_TEGRA_186_SOC) += tegra186.o
drivers/memory/tegra/tegra210-emc-cc-r21021.c new file +1953 -0
1,953 lines not on this page · raw message
drivers/memory/tegra/tegra210-emc.c +5 -0
@@ -134,6 +134,11 @@ static const char *emc_src_names[TEGRA_EMC_SRC_COUNT] = { };static const struct supported_sequence supported_seqs[] = { + { +0x7 , + emc_set_clock_r21021, + __do_periodic_emc_compensation_r21021, + }, {0 ,NULL ,
drivers/memory/tegra/tegra210-emc.h +157 -0
292 lines not on this page · raw message
Signature · 1 line
2.21.0
PATCH v3 7/8 clk: tegra: Remove the old emc_mux clock for Tegra210
In reply to Joseph LoRemove the old emc_mux clock and don't use the common EMC clock definition. This will be replaced by a new clock defined in the EMC driver.
---
v3:
- split to 3 patches from the previous version
--- drivers/clk/tegra/clk-tegra210.c | 38 ++++++++++++++++++-------------- 1 file changed, 22 insertions(+), 16 deletions(-)
drivers/clk/tegra/clk-tegra210.c +22 -16
@@ -324,12 +324,6 @@ static unsigned long tegra210_input_freq[] = { [8] = 12000000, }; -static const char *mux_pllmcp_clkm[] = { -"pll_m" ,"pll_c" ,"pll_p" ,"clk_m" ,"pll_m_ud" ,"pll_mb" ,"pll_mb" , -"pll_p" , -}; -#define mux_pllmcp_clkm_idx NULL -#define PLL_ENABLE (1 << 30)#define PLLCX_MISC1_IDDQ (1 << 27)
@@ -2346,7 +2340,6 @@ static struct tegra_clk tegra210_clks[tegra_clk_max] __initdata = { [tegra_clk_i2c2] = { .dt_id = TEGRA210_CLK_I2C2, .present = true }, [tegra_clk_uartc_8] = { .dt_id = TEGRA210_CLK_UARTC, .present = true }, [tegra_clk_mipi_cal] = { .dt_id = TEGRA210_CLK_MIPI_CAL, .present = true }, - [tegra_clk_emc] = { .dt_id = TEGRA210_CLK_EMC, .present = true }, [tegra_clk_usb2] = { .dt_id = TEGRA210_CLK_USB2, .present = true }, [tegra_clk_bsev] = { .dt_id = TEGRA210_CLK_BSEV, .present = true }, [tegra_clk_uartd_8] = { .dt_id = TEGRA210_CLK_UARTD, .present = true },
@@ -2957,6 +2950,26 @@ static int tegra210_init_pllu(void)return 0 ; } +static const struct clk_div_table mc_div_table_tegra210[] = { + { .val =0 , .div =2 }, + { .val =1 , .div =4 }, + { .val =2 , .div =1 }, + { .val =3 , .div =2 }, + { .val =0 , .div =0 }, +}; + +static void tegra_clk_register_mc_tegra210 (const char *name, +const char *parent_name) +{ +struct clk *clk; + + clk =clk_register_divider_table (NULL , name, parent_name,0 , + clk_base +CLK_SOURCE_EMC , +15 ,2 ,CLK_DIVIDER_READ_ONLY , + mc_div_table_tegra210, &emc_lock); + clks[TEGRA210_CLK_MC ] = clk; +} +static const char *const sor1_out_parents[] = {/* * Bit 0 of the mux selects sor1_pad_clkout, irrespective of bit 1, so
@@ -3040,15 +3053,8 @@ static __init void tegra210_periph_clk_init(void __iomem *clk_base, CLK_SOURCE_LA, 0); clks[TEGRA210_CLK_LA ] = clk; -/* emc mux */ - clk =clk_register_mux (NULL ,"emc_mux" , mux_pllmcp_clkm, -ARRAY_SIZE (mux_pllmcp_clkm),0 , - clk_base +CLK_SOURCE_EMC , -29 ,3 ,0 , &emc_lock); - - clk =tegra_clk_register_mc ("mc" ,"emc_mux" , clk_base +CLK_SOURCE_EMC , - &emc_lock); - clks[TEGRA210_CLK_MC ] = clk; +/* mc */ +tegra_clk_register_mc_tegra210 ("mc" ,"emc" );/* cml0 */ clk = clk_register_gate(NULL, "cml0", "pll_e", 0, clk_base + PLLE_AUX,
Signature · 1 line
2.21.0
PATCH v3 8/8 arm64: tegra: Add external memory controller node for Tegra210
In reply to Joseph LoAdd external memory controller (EMC) node for Tegra210
--- arch/arm64/boot/dts/nvidia/tegra210.dtsi | 33 ++++++++++++++++++++++++ 1 file changed, 33 insertions(+)
arch/arm64/boot/dts/nvidia/tegra210.dtsi +33 -0
@@ -872,6 +872,27 @@ #iommu-cells = <1>; }; + external-memory-controller@7001b000 { + compatible = "nvidia,tegra210-emc"; + reg = <0x0 0x7001b000 0x0 0x1000>, + <0x0 0x7001e000 0x0 0x1000>, + <0x0 0x7001f000 0x0 0x1000>; + clocks = <&tegra_car TEGRA210_CLK_EMC>, + <&tegra_car TEGRA210_CLK_PLL_M>, + <&tegra_car TEGRA210_CLK_PLL_C>, + <&tegra_car TEGRA210_CLK_PLL_P>, + <&tegra_car TEGRA210_CLK_CLK_M>, + <&tegra_car TEGRA210_CLK_PLL_M_UD>, + <&tegra_car TEGRA210_CLK_PLL_MB_UD>, + <&tegra_car TEGRA210_CLK_PLL_MB>, + <&tegra_car TEGRA210_CLK_PLL_P_UD>; + clock-names = "emc", "pll_m", "pll_c", "pll_p", "clk_m", + "pll_m_ud", "pll_mb_ud", "pll_mb", "pll_p_ud"; + interrupts = <GIC_SPI 78 IRQ_TYPE_LEVEL_HIGH>; + memory-region = <&emc_table>; + nvidia,memory-controller = <&mc>; + }; + sata@70020000 { compatible = "nvidia,tegra210-ahci"; reg = <0x0 0x70027000 0x0 0x2000>, /* AHCI */
@@ -1431,6 +1452,18 @@ }; }; + reserved-memory { + #address-cells = <2>; + #size-cells = <2>; + ranges; + + emc_table: emc-table@8be00000 { + compatible = "nvidia,tegra210-emc-table"; + reg = <0x0 0x8be00000 0x0 0x10000>; + status = "disabled"; + }; + }; + timer { compatible = "arm,armv8-timer"; interrupts = <GIC_PPI 13
Signature · 1 line
2.21.0