From patchwork Mon Mar 25 07:45:16 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063879 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="ZDw4Hv6d"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRBp4GWHz9sSg for ; Mon, 25 Mar 2019 18:45:38 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729849AbfCYHpg (ORCPT ); Mon, 25 Mar 2019 03:45:36 -0400 Received: from hqemgate14.nvidia.com ([216.228.121.143]:19782 "EHLO hqemgate14.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729720AbfCYHpg (ORCPT ); Mon, 25 Mar 2019 03:45:36 -0400 Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by hqemgate14.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:37 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate102.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:34 -0700 X-PGP-Universal: processed; by hqpgpgate102.nvidia.com on Mon, 25 Mar 2019 00:45:34 -0700 Received: from HQMAIL107.nvidia.com (172.20.187.13) by HQMAIL105.nvidia.com (172.20.187.12) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:34 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL107.nvidia.com (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:34 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:33 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , Rob Herring , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 1/8] dt-bindings: memory: tegra: Add Tegra210 EMC bindings Date: Mon, 25 Mar 2019 15:45:16 +0800 Message-ID: <20190325074523.26456-2-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499937; bh=ZHiGK8Y8cp6BHCDDoxVPH3jhIEc9OqWFw2X1FftmZ9E=; 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=ZDw4Hv6d+x4g6547ugWqTmR0N0UMtAsJWC7VQhilwe8Zhells4Gha1k43Lnpq5QcV uQ+qDlOxRWsKjnbKBE9oOKvUDtWWtAvNixVLZkRds6Yd+B+/1ganGdMpvk1dd/+QKb 5SAi9AR1eLU1908OuxXT6zz5f0/R9EG0H+bhhRIHe6R2+ICnJsMWlyRYQxzupSBrwa h9yzjBlBY+iVa7DVjHNMcliCHfFDHd6u6DIyjNHSrmINELPOvj3OGrHxRr2ESMtzZn PneczkPrqMSyS8E88XrbNF+QFSNVzq7mMjQyxFDjxwcadF5sDQGvSAOgUKz7zIPO7J GSgAUFBooirVQ== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org 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 the EMC table of different rates. To support high rates for LPDDR4, the EMC table must be trained before it can be used for runtime clock switching. It has been done by firmware and merged to the table that Linux kernel uses. For backward compatibility with the devices that had been launched on the market, like Shield and Jetson platforms, the bindings in the EMC table should remain the same. So the firmware can recognize them and merge the trained EMC table for the kernel. Based on the work of Peter De Schrijver . Signed-off-by: Joseph Lo --- .../nvidia,tegra210-emc.txt | 605 ++++++++++++++++++ 1 file changed, 605 insertions(+) create mode 100644 Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt diff --git a/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt b/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt new file mode 100644 index 000000000000..1f6b6df6d37b --- /dev/null +++ b/Documentation/devicetree/bindings/memory-controllers/nvidia,tegra210-emc.txt @@ -0,0 +1,605 @@ +NVIDIA Tegra210 SoC EMC (external memory controller) +==================================================== + +Required properties : +- compatible : should be "nvidia,tegra21-emc", "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 +- #address-cells : should be 1 +- #size-cells : should be 0 +- nvidia,memory-controller : phandle of the memory controller. +- nvidia,use-ram-code : boolean, indicates whether we should use RAM_CODE in + the register to find matching emc-table nodes + +The node should contain a "emc-table" subnode for each supported RAM type +(see field RAM_CODE in register APB_MISC_PP_STRAPPING_OPT_A), with its unit +address being its RAM_CODE. + +Required properties for "emc-table" nodes : +- nvidia,ram-code : Should contain the value of RAM_CODE this timing set is + used for. + +Each "emc-table" node should contain a "emc-table" subnode for every supported +EMC clock rate. The "emc-table" subnodes should have the clock rate in +kilohertz as their unit address. + +Required properties for "emc-table" nodes : +- compatible : "nvidia,tegra21-emc-table", "nvidia,tegra210-emc-table" +- nvidia,revision : revision of the parameter set used for this node. All + nodes in the same "emc-table" should have the same revision +- nvidia,dvfs-version : string for the DVFS version of this table +- clock-frequency : frequency in kilohertz +- nvidia,emc-min-mv : minimum voltage in millivolt for this rate +- nvidia,gk20a-min-mv : minimum GPU voltage in millivolt for this rate +- nvidia,source : name of clock source to be used for this rate +- nvidia,src-sel-reg : value of EMC CAR register to be used for this rate +- nvidia,needs-training : 1 if needs training at boot, 0 otherwise +- nvidia,trained : 1 if initial training has been done by firmware, 0 otherwise +- nvidia,periodic_training : 1 if needs periodic training, 0 otherwise +- nvidia,trained_dram_clktree_c0d0u0 : training data word +- nvidia,trained_dram_clktree_c0d0u1 : training data word +- nvidia,trained_dram_clktree_c0d1u0 : training data word +- nvidia,trained_dram_clktree_c0d1u1 : training data word +- nvidia,trained_dram_clktree_c1d0u0 : training data word +- nvidia,trained_dram_clktree_c1d0u1 : training data word +- nvidia,trained_dram_clktree_c1d1u0 : training data word +- nvidia,trained_dram_clktree_c1d1u1 : training data word +- nvidia,current_dram_clktree_c0d0u0 : training data word +- nvidia,current_dram_clktree_c0d0u1 : training data word +- nvidia,current_dram_clktree_c0d1u0 : training data word +- nvidia,current_dram_clktree_c0d1u1 : training data word +- nvidia,current_dram_clktree_c1d0u0 : training data word +- nvidia,current_dram_clktree_c1d0u1 : training data word +- nvidia,current_dram_clktree_c1d1u0 : training data word +- nvidia,current_dram_clktree_c1d1u1 : training data word +- nvidia,run_clocks : training data +- nvidia,tree_margin : training data +- nvidia,burst-regs-num : number of values in nvidia,emc-registers +- nvidia,burst-regs-per-ch-num : number of values in + nvidia,emc-burst-regs-per-ch +- nvidia,trim-regs-num : number of values in nvidia,emc-trim-regs +- nvidia,trim-regs-per-ch-num : number of values in nvidia,emc-trim-regs-per-ch +- nvidia,burst-mc-regs-num : number of values in nvidia,emc-burst-mc-regs +- nvidia,la-scale-regs-num : number of values in nvidia,emc-la-scale-regs +- nvidia,vref-regs-num : number of values in nvidia,emc-vref-regs +- nvidia,dram-timing-regs-num : number of values in nvidia,emc-dram-timing-regs +- nvidia,min-mrs-wait : value of the EMC_MRS register +- nvidia,emc-mrw : value of the EMC_MRW register +- nvidia,emc-mrw2 : value of the EMC_MRW2 register +- nvidia,emc-mrw3 : value of the EMC_MRW3 register +- nvidia,emc-mrw4 : value of the EMC_MRW4 register +- nvidia,emc-mrw9 : value of the EMC_MRW4 register +- nvidia,emc-mrs : value of the EMC_MRS register +- nvidia,emc-emrs : value of the EMC_EMRS register +- nvidia,emc-emrs2 : value of the EMC_EMRS2 register +- nvidia,emc-auto-cal-config : value of the EMC_AUTO_CAL_CONFIG register +- nvidia,emc-auto-cal-config2 : value of the EMC_AUTO_CAL_CONFIG2 register +- nvidia,emc-auto-cal-config3 : value of the EMC_AUTO_CAL_CONFIG3 register +- nvidia,emc-auto-cal-config4 : value of the EMC_AUTO_CAL_CONFIG4 register +- nvidia,emc-auto-cal-config5 : value of the EMC_AUTO_CAL_CONFIG5 register +- nvidia,emc-auto-cal-config6 : value of the EMC_AUTO_CAL_CONFIG6 register +- nvidia,emc-auto-cal-config7 : value of the EMC_AUTO_CAL_CONFIG7 register +- nvidia,emc-auto-cal-config8 : value of the EMC_AUTO_CAL_CONFIG8 register +- nvidia,emc-cfg-2 : value of the EMC_CFG_2 register +- nvidia,emc-sel-dpd-ctrl : value of the EMC_SEL_DPD_CTRL register +- nvidia,emc-fdpd-ctrl-cmd-no-ramp : value of the EMC_FDPD_CTRL_CMD_NO_RAMP + register +- nvidia,dll-clk-src : value of the CLK_RST_CONTROLLER_CLK_SOURCE_EMC_DLL + register +- nvidia,clk-out-enb-x-0-clk-enb-emc-dll : boolean, enable EMC_DLL in the + CLK_RST_CONTROLLER_CLK_OUT_ENB_X_SET, + or clear in the + CLK_RST_CONTROLLER_CLK_OUT_ENB_X_CLR +- nvidia,emc-clock-latency-change : clock latency value in micro seconds +- nvidia,ptfv : control data for periodic training +- nvidia,emc-registers : +- nvidia,emc-shadow-regs-ca-train : +- nvidia,emc-shadow-regs-quse-train : +- nvidia,emc-shadow-regs-rdwr-train : + values for the following registers (See TRM 18.10.2 for register descriptions) + 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 +- nvidia,emc-burst-regs-per-ch : values for the following registers (See TRM + 18.10.2 for register descriptions) the array + containts 2 values for each register, one per + channel. + EMC_MRW10 + EMC_MRW11 + EMC_MRW12 + EMC_MRW13 +- nvidia,emc-trim-regs : values for the following registers (See TRM 18.10.2 + for register descriptions) + 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 +- nvidia,emc-trim-regs-per-ch : values for the following registers (See TRM + 18.10.2 for register descriptions) + EMC_CMD_BRLSHFT_0 + EMC_CMD_BRLSHFT_1 + EMC_DATA_BRLSHFT_0 (channel 0) + EMC_DATA_BRLSHFT_0 (channel 1) + EMC_DATA_BRLSHFT_1 (channel 0) + EMC_DATA_BRLSHFT_1 (channel 1) + EMC_QUSE_BRLSHFT_0 + EMC_QUSE_BRLSHFT_1 + EMC_QUSE_BRLSHFT_2 + EMC_QUSE_BRLSHFT_3 +- nvidia,emc-vref-regs : values for the following registers (See TRM 18.10.2 + for register descriptions) the array containts 2 + values for each register, one per channel. + EMC_TRAINING_OPT_DQS_IB_VREF_RANK0 + EMC_TRAINING_OPT_DQS_IB_VREF_RANK1 +- nvidia,emc-dram-timing-regs : DRAM timing values. These are not written to + registers but used during the sequence. + T_RP : row pre-charge delay + T_FC_LPDDR4 : frequency change time + T_RFC : refresh cycle time + T_PDEX : power down exit delay + RL : mode register read latency +- nvidia,emc-training-mod-regs : +- nvidia,emc-save-restore-mod-regs : + deprecated, keep for for backward compatibility +- nvidia,emc-burst-mc-regs : values for the following registers + (See TRM 18.10.1 for register descriptions) + 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 +- nvidia,emc-la-scale-regs : values for the following registers + (See TRM 18.10.1 for register descriptions) + 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 + +Example: + external-memory-controller@7001b000 { + compatible = "nvidia,tegra21-emc", "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"; + #address-cells = <1>; + #size-cells = <0>; + + nvidia,memory-controller = <&mc>; + nvidia,use-ram-code; + + emc-table@0 { + nvidia,ram-code = <0>; + emc-table@40800 { + compatible = "nvidia,tegra21-emc-table"; + ... + }; + emc-table@204000 { + ... + }; + ... + }; + + emc-table@1 { + nvidia,ram-code = <1>; + emc-table@40800 { + compatible = "nvidia,tegra21-emc-table"; + ... + }; + emc-table@204000 { + ... + }; + ... + }; + }; From patchwork Mon Mar 25 07:45:17 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063880 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="CgYxVSPS"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRBr0gScz9sSd for ; Mon, 25 Mar 2019 18:45:40 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729866AbfCYHpj (ORCPT ); Mon, 25 Mar 2019 03:45:39 -0400 Received: from hqemgate16.nvidia.com ([216.228.121.65]:16688 "EHLO hqemgate16.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729720AbfCYHpj (ORCPT ); Mon, 25 Mar 2019 03:45:39 -0400 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:35 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:37 -0700 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 25 Mar 2019 00:45:37 -0700 Received: from HQMAIL106.nvidia.com (172.18.146.12) by HQMAIL107.nvidia.com (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:36 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL106.nvidia.com (172.18.146.12) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:36 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:36 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , Rob Herring , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 2/8] clk: tegra: clock changes for emc scaling support on Tegra210 Date: Mon, 25 Mar 2019 15:45:17 +0800 Message-ID: <20190325074523.26456-3-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499935; bh=BzDDDA23/Zn1WOx9ldzLxdKFuZzancCCO7uLbaA7/l0=; 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=CgYxVSPSxjmZJE0KI3PE0RihrGxlviBfy6L0DHdyV/CCmHZsfSuCRxtacTvJ0lG2u KzZif0eE+XAsOvYtij5QtohTFUmjPdYKPL8W4w8Sq1/BcyHtbPLDVFF2XfBnOXDDcO /KB2JeNvpjTRsRBHzQKViBrQbWC7BrplVuE5fmFDfjvH7bl7jhJ5O3VyKlmlvmhshA NHYGj2BluQ8zO7s/HcztUgIEKgQVTmHBuRxi+9K/ldlDqpqKhTnBqLcxo+Et0lZJrD 3flV/5oarpIH1Kb9/rklSPhXyAc1pFyiH2rC2djm0gXHgSZ6/G6DrvfWSFuQnPCjlg R/xuVoiRzB2Fw== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org 1) Introduce low jitter paths for pllp and pll_mb used by the EMC driver. 2) Remove 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. 3) Export functions to allow accessing the CAR register required for EMC clock scaling. These functions will be used to access the CAR register as part of the scaling sequence. Based on the work of Peter De Schrijver . Signed-off-by: Joseph Lo --- drivers/clk/tegra/clk-tegra210.c | 112 +++++++++++++++++++---- include/dt-bindings/clock/tegra210-car.h | 4 +- include/linux/clk/tegra.h | 5 + 3 files changed, 103 insertions(+), 18 deletions(-) diff --git a/drivers/clk/tegra/clk-tegra210.c b/drivers/clk/tegra/clk-tegra210.c index 7545af763d7a..e17b5279ea69 100644 --- a/drivers/clk/tegra/clk-tegra210.c +++ b/drivers/clk/tegra/clk-tegra210.c @@ -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 @@ -319,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) @@ -2310,7 +2309,7 @@ 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_emc] = { .dt_id = TEGRA210_CLK_EMC, .present = false }, [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 }, @@ -2921,6 +2920,82 @@ static int tegra210_init_pllu(void) return 0; } +void tegra210_clk_emc_dll_enable(bool flag) +{ + unsigned long flags = 0; + u32 offset = flag ? CLK_RST_CONTROLLER_CLK_OUT_ENB_X_SET : + CLK_RST_CONTROLLER_CLK_OUT_ENB_X_CLR; + + spin_lock_irqsave(&emc_lock, flags); + + writel_relaxed(CLK_OUT_ENB_X_CLK_ENB_EMC_DLL, clk_base + offset); + readl(clk_base + offset); + + spin_unlock_irqrestore(&emc_lock, flags); +} +EXPORT_SYMBOL_GPL(tegra210_clk_emc_dll_enable); + +void tegra210_clk_emc_dll_update_setting(u32 emc_dll_src_value) +{ + unsigned long flags = 0; + + spin_lock_irqsave(&emc_lock, flags); + + writel_relaxed(emc_dll_src_value, clk_base + CLK_SOURCE_EMC_DLL); + readl(clk_base + CLK_SOURCE_EMC_DLL); + + spin_unlock_irqrestore(&emc_lock, flags); +} +EXPORT_SYMBOL_GPL(tegra210_clk_emc_dll_update_setting); + +void tegra210_clk_emc_update_setting(u32 emc_src_value) +{ + unsigned long flags = 0; + + spin_lock_irqsave(&emc_lock, flags); + + writel_relaxed(emc_src_value, clk_base + CLK_SOURCE_EMC); + readl(clk_base + CLK_SOURCE_EMC); + + spin_unlock_irqrestore(&emc_lock, flags); +} +EXPORT_SYMBOL_GPL(tegra210_clk_emc_update_setting); + +u32 tegra210_clk_emc_get_setting(void) +{ + unsigned long flags = 0; + u32 val; + + spin_lock_irqsave(&emc_lock, flags); + + val = readl_relaxed(clk_base + CLK_SOURCE_EMC); + + spin_unlock_irqrestore(&emc_lock, flags); + + return val; +} +EXPORT_SYMBOL_GPL(tegra210_clk_emc_get_setting); + +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 @@ -3004,15 +3079,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, @@ -3116,6 +3184,18 @@ 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, diff --git a/include/dt-bindings/clock/tegra210-car.h b/include/dt-bindings/clock/tegra210-car.h index 6b77e721f6b1..832a89788525 100644 --- a/include/dt-bindings/clock/tegra210-car.h +++ b/include/dt-bindings/clock/tegra210-car.h @@ -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 diff --git a/include/linux/clk/tegra.h b/include/linux/clk/tegra.h index afb9edfa5d58..7018afb1990e 100644 --- a/include/linux/clk/tegra.h +++ b/include/linux/clk/tegra.h @@ -130,4 +130,9 @@ 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); +void tegra210_clk_emc_dll_enable(bool flag); +void tegra210_clk_emc_dll_update_setting(u32 emc_dll_src_value); +void tegra210_clk_emc_update_setting(u32 emc_src_value); +u32 tegra210_clk_emc_get_setting(void); + #endif /* __LINUX_CLK_TEGRA_H_ */ From patchwork Mon Mar 25 07:45:18 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063885 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="r36n0Er9"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRCB5szxz9sSd for ; Mon, 25 Mar 2019 18:45:58 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729866AbfCYHp6 (ORCPT ); Mon, 25 Mar 2019 03:45:58 -0400 Received: from hqemgate16.nvidia.com ([216.228.121.65]:16691 "EHLO hqemgate16.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729720AbfCYHp6 (ORCPT ); Mon, 25 Mar 2019 03:45:58 -0400 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:39 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:40 -0700 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 25 Mar 2019 00:45:40 -0700 Received: from HQMAIL110.nvidia.com (172.18.146.15) by HQMAIL108.nvidia.com (172.18.146.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:40 +0000 Received: from HQMAIL108.nvidia.com (172.18.146.13) by hqmail110.nvidia.com (172.18.146.15) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:39 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL108.nvidia.com (172.18.146.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:39 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:38 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , "Rob Herring" , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 3/8] memory: tegra: Add Tegra210 EMC clock driver Date: Mon, 25 Mar 2019 15:45:18 +0800 Message-ID: <20190325074523.26456-4-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499939; bh=OcsTGCyAcWXPCnlHG/6/cx1Qmkxmd0v90iAnqz13UEY=; 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=r36n0Er9fZmF6ARP3ZX8Aso0jbBltSwGy1Ntib4Wc7tPqO91PJ58XJhXteSCAMxvc bZpw2a6zLrGtTS6ezLJKsbQHliuUC8xdLSDrjnCrsiaq7KyzegcZR6Zva2Nq0NWOlG k7HB7qdtzG01piHaqUPkbMYUgBrDQaAuhwf2AagMUVRSr/jV8E+AKrZ/rEfy9rd0b+ EFB+B27ieCIBcpTQiwvjy6GxQ1ABZoaHCEA3YAkFkm4UJkj9FCm7bf71sOkEHCVbKW +N7YlfqHdtpFmoBj2iXrSM+x2DTZCAAE7oUcxLkXXxKSnQJ2XHqTZbN7ksGDt6DUAk jakWzQ7tQ9jvA== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org 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 SDRAMs. 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. The trained table for the rates that we will support in the kernel will be merged to the kernel DTB. 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 support, 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 leaves the rate that doesn't need that. Based on the work of Peter De Schrijver . Signed-off-by: Joseph Lo --- drivers/memory/tegra/Kconfig | 10 + drivers/memory/tegra/Makefile | 1 + drivers/memory/tegra/tegra210-dt-parse.c | 340 +++++++ drivers/memory/tegra/tegra210-emc-reg.h | 1083 ++++++++++++++++++++++ drivers/memory/tegra/tegra210-emc.c | 886 ++++++++++++++++++ 5 files changed, 2320 insertions(+) create mode 100644 drivers/memory/tegra/tegra210-dt-parse.c create mode 100644 drivers/memory/tegra/tegra210-emc-reg.h create mode 100644 drivers/memory/tegra/tegra210-emc.c diff --git a/drivers/memory/tegra/Kconfig b/drivers/memory/tegra/Kconfig index 34e0b70f5c5f..614e9b370183 100644 --- a/drivers/memory/tegra/Kconfig +++ b/drivers/memory/tegra/Kconfig @@ -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. diff --git a/drivers/memory/tegra/Makefile b/drivers/memory/tegra/Makefile index 3971a6b7c487..36a835620bbd 100644 --- a/drivers/memory/tegra/Makefile +++ b/drivers/memory/tegra/Makefile @@ -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 tegra210-dt-parse.o obj-$(CONFIG_ARCH_TEGRA_186_SOC) += tegra186.o diff --git a/drivers/memory/tegra/tegra210-dt-parse.c b/drivers/memory/tegra/tegra210-dt-parse.c new file mode 100644 index 000000000000..6a3a3a28ac64 --- /dev/null +++ b/drivers/memory/tegra/tegra210-dt-parse.c @@ -0,0 +1,340 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2013-2019, NVIDIA CORPORATION. All rights reserved. + */ + +#include +#include +#include +#include +#include + +#include "tegra210-emc-reg.h" + +static struct device_node *tegra_emc_ramcode_devnode( + struct device_node *np) +{ + struct device_node *iter; + u32 reg; + + for_each_child_of_node(np, iter) { + if (of_property_read_u32(iter, "nvidia,ram-code", ®)) + continue; + if (reg == tegra_read_ram_code()) + return of_node_get(iter); + } + + return NULL; +} + +static void *tegra_emc_dt_parse_pdata_comp(const char *emc_mode, + const char *comp, + void *pdata, + struct device_node *tnp, + struct platform_device *pdev, + int num_tables, int *table_count) +{ +#define PNE_U32(node, entry, tbl_entry) \ + do { \ + int __ret__; \ + u32 __tmp__; \ + \ + __ret__ = of_property_read_u32((node), (entry), &__tmp__); \ + if (__ret__) { \ + dev_err(&pdev->dev, "Failed to parse %s in %s: %d\n", \ + (entry), (node)->full_name, __ret__); \ + continue; \ + } \ + \ + tables[i].tbl_entry = __tmp__; \ + } while (0) + +#define PNE_U32_ARRAY(node, entry, tbl_entry, length) \ + do { \ + int __ret__; \ + \ + __ret__ = of_property_read_u32_array((node), (entry), \ + (tbl_entry), (length)); \ + if (__ret__) { \ + dev_err(&pdev->dev, "Failed to parse %s in %s: %d\n", \ + (entry), (node)->full_name, __ret__); \ + continue; \ + } \ + } while (0) + + int i = 0, ret = 0; + struct device_node *iter; + struct emc_table *tables; + + tables = devm_kzalloc(&pdev->dev, sizeof(*tables) * num_tables, + GFP_KERNEL); + + if (!tables) { + of_node_put(tnp); + return tables; + } + + for_each_child_of_node(tnp, iter) { + if (of_device_is_compatible(iter, comp)) { + const char *source_name; + const char *dvfs_ver; + + ret = of_property_read_string(iter, "nvidia,source", + &source_name); + if (ret) { + dev_err(&pdev->dev, "no source name in %s\n", + iter->full_name); + continue; + } + strlcpy(tables[i].clock_src, source_name, + sizeof(tables[i].clock_src)); + + ret = of_property_read_string(iter, + "nvidia,dvfs-version", + &dvfs_ver); + if (ret) { + dev_err(&pdev->dev, "no dvfs version in %s\n", + iter->full_name); + continue; + } + strlcpy(tables[i].dvfs_ver, dvfs_ver, + sizeof(tables[i].dvfs_ver)); + + PNE_U32(iter, "nvidia,revision", rev); + PNE_U32(iter, "clock-frequency", rate); + PNE_U32(iter, "nvidia,emc-min-mv", min_volt); + PNE_U32(iter, "nvidia,gk20a-min-mv", gpu_min_volt); + PNE_U32(iter, "nvidia,src-sel-reg", clk_src_emc); + PNE_U32(iter, "nvidia,burst-regs-num", num_burst); + PNE_U32(iter, "nvidia,emc-cfg-2", emc_cfg_2); + PNE_U32(iter, "nvidia,emc-sel-dpd-ctrl", + emc_sel_dpd_ctrl); + PNE_U32(iter, "nvidia,emc-auto-cal-config", + emc_auto_cal_config); + PNE_U32(iter, "nvidia,emc-auto-cal-config2", + emc_auto_cal_config2); + PNE_U32(iter, "nvidia,emc-auto-cal-config3", + emc_auto_cal_config3); + PNE_U32(iter, "nvidia,emc-clock-latency-change", + latency); + PNE_U32_ARRAY(iter, "nvidia,emc-registers", + tables[i].burst_regs, + tables[i].num_burst); + + PNE_U32(iter, "nvidia,needs-training", needs_training); + PNE_U32(iter, "nvidia,trained", trained); + if (tables[i].rev < 0x6) + goto skip_periodic_training_params; + PNE_U32(iter, "nvidia,periodic_training", + periodic_training); + PNE_U32(iter, "nvidia,trained_dram_clktree_c0d0u0", + trained_dram_clktree_c0d0u0); + PNE_U32(iter, "nvidia,trained_dram_clktree_c0d0u1", + trained_dram_clktree_c0d0u1); + PNE_U32(iter, "nvidia,trained_dram_clktree_c0d1u0", + trained_dram_clktree_c0d1u0); + PNE_U32(iter, "nvidia,trained_dram_clktree_c0d1u1", + trained_dram_clktree_c0d1u1); + PNE_U32(iter, "nvidia,trained_dram_clktree_c1d0u0", + trained_dram_clktree_c1d0u0); + PNE_U32(iter, "nvidia,trained_dram_clktree_c1d0u1", + trained_dram_clktree_c1d0u1); + PNE_U32(iter, "nvidia,trained_dram_clktree_c1d1u0", + trained_dram_clktree_c1d1u0); + PNE_U32(iter, "nvidia,trained_dram_clktree_c1d1u1", + trained_dram_clktree_c1d1u1); + PNE_U32(iter, "nvidia,current_dram_clktree_c0d0u0", + current_dram_clktree_c0d0u0); + PNE_U32(iter, "nvidia,current_dram_clktree_c0d0u1", + current_dram_clktree_c0d0u1); + PNE_U32(iter, "nvidia,current_dram_clktree_c0d1u0", + current_dram_clktree_c0d1u0); + PNE_U32(iter, "nvidia,current_dram_clktree_c0d1u1", + current_dram_clktree_c0d1u1); + PNE_U32(iter, "nvidia,current_dram_clktree_c1d0u0", + current_dram_clktree_c1d0u0); + PNE_U32(iter, "nvidia,current_dram_clktree_c1d0u1", + current_dram_clktree_c1d0u1); + PNE_U32(iter, "nvidia,current_dram_clktree_c1d1u0", + current_dram_clktree_c1d1u0); + PNE_U32(iter, "nvidia,current_dram_clktree_c1d1u1", + current_dram_clktree_c1d1u1); + PNE_U32(iter, "nvidia,run_clocks", run_clocks); + PNE_U32(iter, "nvidia,tree_margin", tree_margin); + +skip_periodic_training_params: + PNE_U32(iter, "nvidia,burst-regs-per-ch-num", + num_burst_per_ch); + PNE_U32(iter, "nvidia,trim-regs-num", num_trim); + PNE_U32(iter, "nvidia,trim-regs-per-ch-num", + num_trim_per_ch); + PNE_U32(iter, "nvidia,burst-mc-regs-num", + num_mc_regs); + PNE_U32(iter, "nvidia,la-scale-regs-num", + num_up_down); + PNE_U32(iter, "nvidia,vref-regs-num", vref_num); + PNE_U32(iter, "nvidia,dram-timing-regs-num", + dram_timing_num); + PNE_U32(iter, "nvidia,min-mrs-wait", min_mrs_wait); + PNE_U32(iter, "nvidia,emc-mrw", emc_mrw); + PNE_U32(iter, "nvidia,emc-mrw2", emc_mrw2); + PNE_U32(iter, "nvidia,emc-mrw3", emc_mrw3); + PNE_U32(iter, "nvidia,emc-mrw4", emc_mrw4); + PNE_U32(iter, "nvidia,emc-mrw9", emc_mrw9); + PNE_U32(iter, "nvidia,emc-mrs", emc_mrs); + PNE_U32(iter, "nvidia,emc-emrs", emc_emrs); + PNE_U32(iter, "nvidia,emc-emrs2", emc_emrs2); + PNE_U32(iter, "nvidia,emc-auto-cal-config4", + emc_auto_cal_config4); + PNE_U32(iter, "nvidia,emc-auto-cal-config5", + emc_auto_cal_config5); + PNE_U32(iter, "nvidia,emc-auto-cal-config6", + emc_auto_cal_config6); + PNE_U32(iter, "nvidia,emc-auto-cal-config7", + emc_auto_cal_config7); + PNE_U32(iter, "nvidia,emc-auto-cal-config8", + emc_auto_cal_config8); + PNE_U32(iter, "nvidia,emc-fdpd-ctrl-cmd-no-ramp", + emc_fdpd_ctrl_cmd_no_ramp); + PNE_U32(iter, "nvidia,dll-clk-src", dll_clk_src); + PNE_U32(iter, "nvidia,clk-out-enb-x-0-clk-enb-emc-dll", + clk_out_enb_x_0_clk_enb_emc_dll); + + if (tables[i].rev >= 0x7) + PNE_U32_ARRAY(iter, "nvidia,ptfv", + tables[i].ptfv_list, + sizeof(tables[i].ptfv_list) + / sizeof(u32)); + + PNE_U32_ARRAY(iter, "nvidia,emc-burst-regs-per-ch", + tables[i].burst_reg_per_ch, + tables[i].num_burst_per_ch); + PNE_U32_ARRAY(iter, "nvidia,emc-shadow-regs-ca-train", + tables[i].shadow_regs_ca_train, + tables[i].num_burst); + PNE_U32_ARRAY(iter, "nvidia,emc-shadow-regs-quse-train", + tables[i].shadow_regs_quse_train, + tables[i].num_burst); + PNE_U32_ARRAY(iter, "nvidia,emc-shadow-regs-rdwr-train", + tables[i].shadow_regs_rdwr_train, + tables[i].num_burst); + PNE_U32_ARRAY(iter, "nvidia,emc-trim-regs", + tables[i].trim_regs, + tables[i].num_trim); + PNE_U32_ARRAY(iter, "nvidia,emc-trim-regs-per-ch", + tables[i].trim_perch_regs, + tables[i].num_trim_per_ch); + PNE_U32_ARRAY(iter, "nvidia,emc-vref-regs", + tables[i].vref_perch_regs, + tables[i].vref_num); + PNE_U32_ARRAY(iter, "nvidia,emc-dram-timing-regs", + tables[i].dram_timings, + tables[i].dram_timing_num); + PNE_U32_ARRAY(iter, "nvidia,emc-burst-mc-regs", + tables[i].burst_mc_regs, + tables[i].num_mc_regs); + PNE_U32_ARRAY(iter, "nvidia,emc-la-scale-regs", + tables[i].la_scale_regs, + tables[i].num_up_down); + i++; + } + } + + *table_count = i; + + return tables; +} + +static const struct of_device_id emc_table_match[] = { + { + .compatible = "nvidia,tegra210-emc-table", + .data = "nvidia,tegra210-emc-table-derated", + }, + { + .compatible = "nvidia,tegra21-emc-table", + .data = "nvidia,tegra21-emc-table-derated", + }, + { }, +}; + +int tegra_emc_dt_parse_pdata(struct platform_device *pdev, + struct emc_table **tables, + struct emc_table **derated_tables, + int *num_entries) +{ + struct device_node *np = pdev->dev.of_node; + struct device_node *tnp, *iter; + int num_tables, table_count; + u32 tegra_bct_strapping; + const char *emc_mode = "nvidia,emc-mode-0"; + struct tegra21_emc_pdata *pdata = NULL; + const char *comp = NULL; + const char *comp_derated = NULL; + + if (!np) { + dev_err(&pdev->dev, + "Unable to find external-memory-controller node\n"); + return -ENODEV; + } + + tegra_bct_strapping = tegra_read_ram_code(); + + if (of_find_property(np, "nvidia,use-ram-code", NULL)) { + tnp = tegra_emc_ramcode_devnode(np); + + if (!tnp) { + dev_warn(&pdev->dev, + "can't find emc table for ram-code 0x%02x\n", + tegra_bct_strapping); + return -ENODEV; + } + } else + tnp = of_node_get(np); + + num_tables = 0; + for_each_child_of_node(tnp, iter) { + if (!comp) { + const struct of_device_id *m = + of_match_node(emc_table_match, iter); + if (m) { + comp = m->compatible; + comp_derated = m->data; + num_tables++; + } + continue; + } + if (of_device_is_compatible(iter, comp)) + num_tables++; + } + + if (!num_tables) { + *tables = NULL; + goto out; + } + + *tables = tegra_emc_dt_parse_pdata_comp(emc_mode, comp, pdata, tnp, + pdev, num_tables, &table_count); + *num_entries = table_count; + + /* populate the derated tables */ + num_tables = 0; + for_each_child_of_node(tnp, iter) { + if (of_device_is_compatible(iter, comp_derated)) + num_tables++; + } + + if (!num_tables) { + *derated_tables = NULL; + goto out; + } + + *derated_tables = tegra_emc_dt_parse_pdata_comp(emc_mode, + comp_derated, + pdata, tnp, pdev, + num_tables, + &table_count); + +out: + of_node_put(tnp); + return 0; +} diff --git a/drivers/memory/tegra/tegra210-emc-reg.h b/drivers/memory/tegra/tegra210-emc-reg.h new file mode 100644 index 000000000000..84fcc85f3b6d --- /dev/null +++ b/drivers/memory/tegra/tegra210-emc-reg.h @@ -0,0 +1,1083 @@ +/* SPDX-License-Identifier: GPL-2.0 */ +/* + * Copyright (c) 2015-2019, NVIDIA CORPORATION. All rights reserved. + */ + +#ifndef _TEGRA210_EMC_REG_H +#define _TEGRA210_EMC_REG_H + +#include +#include +#include + +#include "mc.h" + +#define MC_EMEM_ARB_CFG 0x90 +#define MC_EMEM_ARB_OUTSTANDING_REQ 0x94 +#define MC_EMEM_ARB_TIMING_RCD 0x98 +#define MC_EMEM_ARB_TIMING_RP 0x9c +#define MC_EMEM_ARB_TIMING_RC 0xa0 +#define MC_EMEM_ARB_TIMING_RAS 0xa4 +#define MC_EMEM_ARB_TIMING_FAW 0xa8 +#define MC_EMEM_ARB_TIMING_RRD 0xac +#define MC_EMEM_ARB_TIMING_RAP2PRE 0xb0 +#define MC_EMEM_ARB_TIMING_WAP2PRE 0xb4 +#define MC_EMEM_ARB_TIMING_R2R 0xb8 +#define MC_EMEM_ARB_TIMING_W2W 0xbc +#define MC_EMEM_ARB_TIMING_R2W 0xc0 +#define MC_EMEM_ARB_TIMING_W2R 0xc4 +#define MC_EMEM_ARB_MISC2 0xc8 +#define MC_EMEM_ARB_DA_TURNS 0xd0 +#define MC_EMEM_ARB_DA_COVERS 0xd4 +#define MC_EMEM_ARB_MISC0 0xd8 +#define MC_EMEM_ARB_MISC0_EMC_SAME_FREQ BIT(27) +#define MC_EMEM_ARB_MISC1 0xdc +#define MC_EMEM_ARB_RING1_THROTTLE 0xe0 +#define MC_LATENCY_ALLOWANCE_AVPC_0 0x2e4 +#define MC_LATENCY_ALLOWANCE_HC_0 0x310 +#define MC_LATENCY_ALLOWANCE_HC_1 0x314 +#define MC_LATENCY_ALLOWANCE_MPCORE_0 0x320 +#define MC_LATENCY_ALLOWANCE_NVENC_0 0x328 +#define MC_LATENCY_ALLOWANCE_PPCS_0 0x344 +#define MC_LATENCY_ALLOWANCE_PPCS_1 0x348 +#define MC_LATENCY_ALLOWANCE_ISP2_0 0x370 +#define MC_LATENCY_ALLOWANCE_ISP2_1 0x374 +#define MC_LATENCY_ALLOWANCE_XUSB_0 0x37c +#define MC_LATENCY_ALLOWANCE_XUSB_1 0x380 +#define MC_LATENCY_ALLOWANCE_TSEC_0 0x390 +#define MC_LATENCY_ALLOWANCE_VIC_0 0x394 +#define MC_LATENCY_ALLOWANCE_VI2_0 0x398 +#define MC_LATENCY_ALLOWANCE_GPU_0 0x3ac +#define MC_LATENCY_ALLOWANCE_SDMMCA_0 0x3b8 +#define MC_LATENCY_ALLOWANCE_SDMMCAA_0 0x3bc +#define MC_LATENCY_ALLOWANCE_SDMMC_0 0x3c0 +#define MC_LATENCY_ALLOWANCE_SDMMCAB_0 0x3c4 +#define MC_LATENCY_ALLOWANCE_GPU2_0 0x3e8 +#define MC_LATENCY_ALLOWANCE_NVDEC_0 0x3d8 +#define MC_MLL_MPCORER_PTSA_RATE 0x44c +#define MC_FTOP_PTSA_RATE 0x50c +#define MC_EMEM_ARB_TIMING_RFCPB 0x6c0 +#define MC_EMEM_ARB_TIMING_CCDMW 0x6c4 +#define MC_EMEM_ARB_REFPB_HP_CTRL 0x6f0 +#define MC_EMEM_ARB_REFPB_BANK_CTRL 0x6f4 +#define MC_PTSA_GRANT_DECREMENT 0x960 +#define MC_EMEM_ARB_DHYST_CTRL 0xbcc +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0 0xbd0 +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1 0xbd4 +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2 0xbd8 +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3 0xbdc +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4 0xbe0 +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5 0xbe4 +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6 0xbe8 +#define MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7 0xbec + +#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 EMC_CFG 0xc +#define EMC_RC 0x2c +#define EMC_RFC 0x30 +#define EMC_RAS 0x34 +#define EMC_RP 0x38 +#define EMC_R2W 0x3c +#define EMC_W2R 0x40 +#define EMC_R2P 0x44 +#define EMC_W2P 0x48 +#define EMC_RD_RCD 0x4c +#define EMC_WR_RCD 0x50 +#define EMC_RRD 0x54 +#define EMC_REXT 0x58 +#define EMC_WDV 0x5c +#define EMC_QUSE 0x60 +#define EMC_QRST 0x64 +#define EMC_QSAFE 0x68 +#define EMC_RDV 0x6c +#define EMC_REFRESH 0x70 +#define EMC_BURST_REFRESH_NUM 0x74 +#define EMC_PDEX2WR 0x78 +#define EMC_PDEX2RD 0x7c +#define EMC_PCHG2PDEN 0x80 +#define EMC_ACT2PDEN 0x84 +#define EMC_AR2PDEN 0x88 +#define EMC_RW2PDEN 0x8c +#define EMC_TXSR 0x90 +#define EMC_TCKE 0x94 +#define EMC_TFAW 0x98 +#define EMC_TRPAB 0x9c +#define EMC_TCLKSTABLE 0xa0 +#define EMC_TCLKSTOP 0xa4 +#define EMC_TREFBW 0xa8 +#define EMC_TPPD 0xac +#define EMC_ODT_WRITE 0xb0 +#define EMC_PDEX2MRR 0xb4 +#define EMC_WEXT 0xb8 +#define EMC_RFC_SLR 0xc0 +#define EMC_MRS_WAIT_CNT2 0xc4 +#define EMC_MRS_WAIT_CNT 0xc8 +#define EMC_FBIO_SPARE 0x100 +#define EMC_FBIO_CFG5 0x104 +#define EMC_FBIO_CFG5_DRAM_TYPE_SHIFT 0 +#define EMC_FBIO_CFG5_DRAM_TYPE_MASK \ + (0x3 << EMC_FBIO_CFG5_DRAM_TYPE_SHIFT) +#define EMC_PDEX2CKE 0x118 +#define EMC_CKE2PDEN 0x11c +#define EMC_R2R 0x144 +#define EMC_EINPUT 0x14c +#define EMC_EINPUT_DURATION 0x150 +#define EMC_PUTERM_EXTRA 0x154 +#define EMC_TCKESR 0x158 +#define EMC_TPD 0x15c +#define EMC_CFG_DIG_DLL 0x2bc +#define EMC_CFG_DIG_DLL_PERIOD 0x2c0 +#define EMC_RDV_MASK 0x2cc +#define EMC_WDV_MASK 0x2d0 +#define EMC_RDV_EARLY_MASK 0x2d4 +#define EMC_RDV_EARLY 0x2d8 +#define EMC_ZCAL_INTERVAL 0x2e0 +#define EMC_ZCAL_WAIT_CNT 0x2e4 +#define EMC_FDPD_CTRL_DQ 0x310 +#define EMC_FDPD_CTRL_CMD 0x314 +#define EMC_PMACRO_CMD_BRICK_CTRL_FDPD 0x318 +#define EMC_PMACRO_DATA_BRICK_CTRL_FDPD 0x31c +#define EMC_PMACRO_BRICK_CTRL_RFU1 0x330 +#define EMC_PMACRO_BRICK_CTRL_RFU2 0x334 +#define EMC_TR_TIMING_0 0x3b4 +#define EMC_TR_CTRL_1 0x3bc +#define EMC_TR_RDV 0x3c4 +#define EMC_PRE_REFRESH_REQ_CNT 0x3dc +#define EMC_DYN_SELF_REF_CONTROL 0x3e0 +#define EMC_TXSRDLL 0x3e4 +#define EMC_TR_QPOP 0x3f4 +#define EMC_TR_RDV_MASK 0x3f8 +#define EMC_TR_QSAFE 0x3fc +#define EMC_TR_QRST 0x400 +#define EMC_TR_DVFS 0x460 +#define EMC_AUTO_CAL_CHANNEL 0x464 +#define EMC_IBDLY 0x468 +#define EMC_OBDLY 0x46c +#define EMC_TXDSRVTTGEN 0x480 +#define EMC_WE_DURATION 0x48c +#define EMC_WS_DURATION 0x490 +#define EMC_WEV 0x494 +#define EMC_WSV 0x498 +#define EMC_CFG_3 0x49c +#define EMC_MRW6 0x4a4 +#define EMC_MRW7 0x4a8 +#define EMC_MRW8 0x4ac +#define EMC_MRW10 0x4b4 +#define EMC_MRW11 0x4b8 +#define EMC_MRW12 0x4bc +#define EMC_MRW13 0x4c0 +#define EMC_MRW14 0x4c4 +#define EMC_MRW15 0x4d0 +#define EMC_WDV_CHK 0x4e0 +#define EMC_CFG_PIPE_2 0x554 +#define EMC_CFG_PIPE_1 0x55c +#define EMC_CFG_PIPE 0x560 +#define EMC_QPOP 0x564 +#define EMC_QUSE_WIDTH 0x568 +#define EMC_PUTERM_WIDTH 0x56c +#define EMC_REFCTRL2 0x580 +#define EMC_FBIO_CFG7 0x584 +#define EMC_DATA_BRLSHFT_0 0x588 +#define EMC_DATA_BRLSHFT_1 0x58c +#define EMC_RFCPB 0x590 +#define EMC_DQS_BRLSHFT_0 0x594 +#define EMC_DQS_BRLSHFT_1 0x598 +#define EMC_CMD_BRLSHFT_0 0x59c +#define EMC_CMD_BRLSHFT_1 0x5a0 +#define EMC_CMD_BRLSHFT_2 0x5a4 +#define EMC_CMD_BRLSHFT_3 0x5a8 +#define EMC_QUSE_BRLSHFT_0 0x5ac +#define EMC_QUSE_BRLSHFT_1 0x5b8 +#define EMC_QUSE_BRLSHFT_2 0x5bc +#define EMC_CCDMW 0x5c0 +#define EMC_QUSE_BRLSHFT_3 0x5c4 +#define EMC_DLL_CFG_0 0x5e4 +#define EMC_DLL_CFG_1 0x5e8 +#define EMC_CONFIG_SAMPLE_DELAY 0x5f0 +#define EMC_PMACRO_QUSE_DDLL_RANK0_0 0x600 +#define EMC_PMACRO_QUSE_DDLL_RANK0_1 0x604 +#define EMC_PMACRO_QUSE_DDLL_RANK0_2 0x608 +#define EMC_PMACRO_QUSE_DDLL_RANK0_3 0x60c +#define EMC_PMACRO_QUSE_DDLL_RANK0_4 0x610 +#define EMC_PMACRO_QUSE_DDLL_RANK0_5 0x614 +#define EMC_PMACRO_QUSE_DDLL_RANK1_0 0x620 +#define EMC_PMACRO_QUSE_DDLL_RANK1_1 0x624 +#define EMC_PMACRO_QUSE_DDLL_RANK1_2 0x628 +#define EMC_PMACRO_QUSE_DDLL_RANK1_3 0x62c +#define EMC_PMACRO_QUSE_DDLL_RANK1_4 0x630 +#define EMC_PMACRO_QUSE_DDLL_RANK1_5 0x634 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 0x640 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 0x644 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 0x648 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 0x64c +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4 0x650 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5 0x654 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 0x660 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 0x664 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 0x668 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 0x66c +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4 0x670 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5 0x674 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0 0x680 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1 0x684 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2 0x688 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3 0x68c +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4 0x690 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5 0x694 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0 0x6a0 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1 0x6a4 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2 0x6a8 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3 0x6ac +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4 0x6b0 +#define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5 0x6b4 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0 0x6c0 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1 0x6c4 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2 0x6c8 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3 0x6cc +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0 0x6e0 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1 0x6e4 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2 0x6e8 +#define EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3 0x6ec +#define EMC_PMACRO_TX_PWRD_0 0x720 +#define EMC_PMACRO_TX_PWRD_1 0x724 +#define EMC_PMACRO_TX_PWRD_2 0x728 +#define EMC_PMACRO_TX_PWRD_3 0x72c +#define EMC_PMACRO_TX_PWRD_4 0x730 +#define EMC_PMACRO_TX_PWRD_5 0x734 +#define EMC_PMACRO_TX_SEL_CLK_SRC_0 0x740 +#define EMC_PMACRO_TX_SEL_CLK_SRC_1 0x744 +#define EMC_PMACRO_TX_SEL_CLK_SRC_3 0x74c +#define EMC_PMACRO_TX_SEL_CLK_SRC_2 0x748 +#define EMC_PMACRO_TX_SEL_CLK_SRC_4 0x750 +#define EMC_PMACRO_TX_SEL_CLK_SRC_5 0x754 +#define EMC_PMACRO_DDLL_BYPASS 0x760 +#define EMC_PMACRO_DDLL_PWRD_0 0x770 +#define EMC_PMACRO_DDLL_PWRD_1 0x774 +#define EMC_PMACRO_DDLL_PWRD_2 0x778 +#define EMC_PMACRO_CMD_CTRL_0 0x780 +#define EMC_PMACRO_CMD_CTRL_1 0x784 +#define EMC_PMACRO_CMD_CTRL_2 0x788 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0 0x800 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1 0x804 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2 0x808 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3 0x80c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0 0x810 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1 0x814 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2 0x818 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3 0x81c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0 0x820 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1 0x824 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2 0x828 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3 0x82c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0 0x830 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1 0x834 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2 0x838 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3 0x83c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0 0x840 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1 0x844 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2 0x848 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3 0x84c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0 0x850 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1 0x854 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2 0x858 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3 0x85c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0 0x860 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1 0x864 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2 0x868 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3 0x86c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0 0x870 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1 0x874 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2 0x878 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3 0x87c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0 0x880 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1 0x884 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2 0x888 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3 0x88c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0 0x890 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1 0x894 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2 0x898 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3 0x89c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0 0x8a0 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1 0x8a4 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2 0x8a8 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3 0x8ac +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0 0x8b0 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1 0x8b4 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2 0x8b8 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3 0x8bc +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0 0x900 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1 0x904 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2 0x908 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3 0x90c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0 0x910 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1 0x914 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2 0x918 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3 0x91c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0 0x920 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1 0x924 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2 0x928 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3 0x92c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0 0x930 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1 0x934 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2 0x938 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3 0x93c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0 0x940 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1 0x944 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2 0x948 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3 0x94c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0 0x950 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1 0x954 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2 0x958 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3 0x95c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0 0x960 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1 0x964 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2 0x968 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3 0x96c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0 0x970 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1 0x974 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2 0x978 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3 0x97c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0 0x980 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1 0x984 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2 0x988 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3 0x98c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0 0x990 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1 0x994 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2 0x998 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3 0x99c +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0 0x9a0 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1 0x9a4 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2 0x9a8 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3 0x9ac +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0 0x9b0 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1 0x9b4 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2 0x9b8 +#define EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3 0x9bc +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0 0xa00 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1 0xa04 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2 0xa08 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0 0xa10 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1 0xa14 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2 0xa18 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0 0xa20 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1 0xa24 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2 0xa28 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0 0xa30 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1 0xa34 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2 0xa38 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0 0xa40 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1 0xa44 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2 0xa48 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0 0xa50 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1 0xa54 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2 0xa58 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0 0xa60 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1 0xa64 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2 0xa68 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0 0xa70 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1 0xa74 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2 0xa78 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0 0xb00 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1 0xb04 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2 0xb08 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0 0xb10 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1 0xb14 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2 0xb18 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0 0xb20 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1 0xb24 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2 0xb28 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0 0xb30 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1 0xb34 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2 0xb38 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0 0xb40 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1 0xb44 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2 0xb48 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0 0xb50 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1 0xb54 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2 0xb58 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0 0xb60 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1 0xb64 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2 0xb68 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0 0xb70 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1 0xb74 +#define EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2 0xb78 +#define EMC_PMACRO_IB_VREF_DQ_0 0xbe0 +#define EMC_PMACRO_IB_VREF_DQ_1 0xbe4 +#define EMC_PMACRO_IB_VREF_DQS_0 0xbf0 +#define EMC_PMACRO_IB_VREF_DQS_1 0xbf4 +#define EMC_PMACRO_DDLL_LONG_CMD_0 0xc00 +#define EMC_PMACRO_DDLL_LONG_CMD_1 0xc04 +#define EMC_PMACRO_DDLL_LONG_CMD_2 0xc08 +#define EMC_PMACRO_DDLL_LONG_CMD_3 0xc0c +#define EMC_PMACRO_DDLL_LONG_CMD_4 0xc10 +#define EMC_PMACRO_DDLL_LONG_CMD_5 0xc14 +#define EMC_PMACRO_DDLL_SHORT_CMD_0 0xc20 +#define EMC_PMACRO_DDLL_SHORT_CMD_1 0xc24 +#define EMC_PMACRO_DDLL_SHORT_CMD_2 0xc28 +#define EMC_PMACRO_VTTGEN_CTRL_0 0xc34 +#define EMC_PMACRO_VTTGEN_CTRL_1 0xc38 +#define EMC_PMACRO_BG_BIAS_CTRL_0 0xc3c +#define EMC_PMACRO_PAD_CFG_CTRL 0xc40 +#define EMC_PMACRO_ZCTRL 0xc44 +#define EMC_PMACRO_CMD_PAD_RX_CTRL 0xc50 +#define EMC_PMACRO_DATA_PAD_RX_CTRL 0xc54 +#define EMC_PMACRO_CMD_RX_TERM_MODE 0xc58 +#define EMC_PMACRO_DATA_RX_TERM_MODE 0xc5c +#define EMC_PMACRO_CMD_PAD_TX_CTRL 0xc60 +#define EMC_PMACRO_DATA_PAD_TX_CTRL 0xc64 +#define EMC_PMACRO_COMMON_PAD_TX_CTRL 0xc68 +#define EMC_PMACRO_AUTOCAL_CFG_COMMON 0xc78 +#define EMC_PMACRO_VTTGEN_CTRL_2 0xcf0 +#define EMC_PMACRO_IB_RXRT 0xcf4 +#define EMC_TRAINING_CTRL 0xe04 +#define EMC_TRAINING_QUSE_CORS_CTRL 0xe0c +#define EMC_TRAINING_QUSE_FINE_CTRL 0xe10 +#define EMC_TRAINING_QUSE_CTRL_MISC 0xe14 +#define EMC_TRAINING_WRITE_FINE_CTRL 0xe18 +#define EMC_TRAINING_WRITE_CTRL_MISC 0xe1c +#define EMC_TRAINING_WRITE_VREF_CTRL 0xe20 +#define EMC_TRAINING_READ_FINE_CTRL 0xe24 +#define EMC_TRAINING_READ_CTRL_MISC 0xe28 +#define EMC_TRAINING_READ_VREF_CTRL 0xe2c +#define EMC_TRAINING_CA_FINE_CTRL 0xe30 +#define EMC_TRAINING_CA_CTRL_MISC 0xe34 +#define EMC_TRAINING_CA_CTRL_MISC1 0xe38 +#define EMC_TRAINING_CA_VREF_CTRL 0xe3c +#define EMC_TRAINING_SETTLE 0xe44 +#define EMC_TRAINING_MPC 0xe5c +#define EMC_TRAINING_VREF_SETTLE 0xe6c +#define EMC_TRAINING_QUSE_VREF_CTRL 0xed0 +#define EMC_TRAINING_OPT_DQS_IB_VREF_RANK0 0xed4 +#define EMC_TRAINING_OPT_DQS_IB_VREF_RANK1 0xed8 + +#define EMC_COPY_TABLE_PARAM_PERIODIC_FIELDS BIT(0) +#define EMC_COPY_TABLE_PARAM_TRIM_REGS BIT(1) + +enum { + REG_MC, + REG_EMC, + REG_EMC0, + REG_EMC1, +}; + +#define BURST_REGS_PER_CH_LIST \ +{ \ + DEFINE_REG(REG_EMC0, EMC_MRW10), \ + DEFINE_REG(REG_EMC1, EMC_MRW10), \ + DEFINE_REG(REG_EMC0, EMC_MRW11), \ + DEFINE_REG(REG_EMC1, EMC_MRW11), \ + DEFINE_REG(REG_EMC0, EMC_MRW12), \ + DEFINE_REG(REG_EMC1, EMC_MRW12), \ + DEFINE_REG(REG_EMC0, EMC_MRW13), \ + DEFINE_REG(REG_EMC1, EMC_MRW13), \ +} + +#define BURST_REGS_LIST \ +{ \ + DEFINE_REG(REG_EMC, EMC_RC), \ + DEFINE_REG(REG_EMC, EMC_RFC), \ + DEFINE_REG(REG_EMC, EMC_RFCPB), \ + DEFINE_REG(REG_EMC, EMC_REFCTRL2), \ + DEFINE_REG(REG_EMC, EMC_RFC_SLR), \ + DEFINE_REG(REG_EMC, EMC_RAS), \ + DEFINE_REG(REG_EMC, EMC_RP), \ + DEFINE_REG(REG_EMC, EMC_R2W), \ + DEFINE_REG(REG_EMC, EMC_W2R), \ + DEFINE_REG(REG_EMC, EMC_R2P), \ + DEFINE_REG(REG_EMC, EMC_W2P), \ + DEFINE_REG(REG_EMC, EMC_R2R), \ + DEFINE_REG(REG_EMC, EMC_TPPD), \ + DEFINE_REG(REG_EMC, EMC_CCDMW), \ + DEFINE_REG(REG_EMC, EMC_RD_RCD), \ + DEFINE_REG(REG_EMC, EMC_WR_RCD), \ + DEFINE_REG(REG_EMC, EMC_RRD), \ + DEFINE_REG(REG_EMC, EMC_REXT), \ + DEFINE_REG(REG_EMC, EMC_WEXT), \ + DEFINE_REG(REG_EMC, EMC_WDV_CHK), \ + DEFINE_REG(REG_EMC, EMC_WDV), \ + DEFINE_REG(REG_EMC, EMC_WSV), \ + DEFINE_REG(REG_EMC, EMC_WEV), \ + DEFINE_REG(REG_EMC, EMC_WDV_MASK), \ + DEFINE_REG(REG_EMC, EMC_WS_DURATION), \ + DEFINE_REG(REG_EMC, EMC_WE_DURATION), \ + DEFINE_REG(REG_EMC, EMC_QUSE), \ + DEFINE_REG(REG_EMC, EMC_QUSE_WIDTH), \ + DEFINE_REG(REG_EMC, EMC_IBDLY), \ + DEFINE_REG(REG_EMC, EMC_OBDLY), \ + DEFINE_REG(REG_EMC, EMC_EINPUT), \ + DEFINE_REG(REG_EMC, EMC_MRW6), \ + DEFINE_REG(REG_EMC, EMC_EINPUT_DURATION), \ + DEFINE_REG(REG_EMC, EMC_PUTERM_EXTRA), \ + DEFINE_REG(REG_EMC, EMC_PUTERM_WIDTH), \ + DEFINE_REG(REG_EMC, EMC_QRST), \ + DEFINE_REG(REG_EMC, EMC_QSAFE), \ + DEFINE_REG(REG_EMC, EMC_RDV), \ + DEFINE_REG(REG_EMC, EMC_RDV_MASK), \ + DEFINE_REG(REG_EMC, EMC_RDV_EARLY), \ + DEFINE_REG(REG_EMC, EMC_RDV_EARLY_MASK), \ + DEFINE_REG(REG_EMC, EMC_REFRESH), \ + DEFINE_REG(REG_EMC, EMC_BURST_REFRESH_NUM), \ + DEFINE_REG(REG_EMC, EMC_PRE_REFRESH_REQ_CNT), \ + DEFINE_REG(REG_EMC, EMC_PDEX2WR), \ + DEFINE_REG(REG_EMC, EMC_PDEX2RD), \ + DEFINE_REG(REG_EMC, EMC_PCHG2PDEN), \ + DEFINE_REG(REG_EMC, EMC_ACT2PDEN), \ + DEFINE_REG(REG_EMC, EMC_AR2PDEN), \ + DEFINE_REG(REG_EMC, EMC_RW2PDEN), \ + DEFINE_REG(REG_EMC, EMC_CKE2PDEN), \ + DEFINE_REG(REG_EMC, EMC_PDEX2CKE), \ + DEFINE_REG(REG_EMC, EMC_PDEX2MRR), \ + DEFINE_REG(REG_EMC, EMC_TXSR), \ + DEFINE_REG(REG_EMC, EMC_TXSRDLL), \ + DEFINE_REG(REG_EMC, EMC_TCKE), \ + DEFINE_REG(REG_EMC, EMC_TCKESR), \ + DEFINE_REG(REG_EMC, EMC_TPD), \ + DEFINE_REG(REG_EMC, EMC_TFAW), \ + DEFINE_REG(REG_EMC, EMC_TRPAB), \ + DEFINE_REG(REG_EMC, EMC_TCLKSTABLE), \ + DEFINE_REG(REG_EMC, EMC_TCLKSTOP), \ + DEFINE_REG(REG_EMC, EMC_MRW7), \ + DEFINE_REG(REG_EMC, EMC_TREFBW), \ + DEFINE_REG(REG_EMC, EMC_ODT_WRITE), \ + DEFINE_REG(REG_EMC, EMC_FBIO_CFG5), \ + DEFINE_REG(REG_EMC, EMC_FBIO_CFG7), \ + DEFINE_REG(REG_EMC, EMC_CFG_DIG_DLL), \ + DEFINE_REG(REG_EMC, EMC_CFG_DIG_DLL_PERIOD), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_RXRT), \ + DEFINE_REG(REG_EMC, EMC_CFG_PIPE_1), \ + DEFINE_REG(REG_EMC, EMC_CFG_PIPE_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK0_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK0_5), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK1_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK1_5), \ + DEFINE_REG(REG_EMC, EMC_MRW8), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_5), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQS_RANK1_5), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_LONG_CMD_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_LONG_CMD_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_LONG_CMD_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_LONG_CMD_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_LONG_CMD_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_SHORT_CMD_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_SHORT_CMD_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_SHORT_CMD_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD2_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_CMD3_3), \ + DEFINE_REG(REG_EMC, EMC_TXDSRVTTGEN), \ + DEFINE_REG(REG_EMC, EMC_FDPD_CTRL_DQ), \ + DEFINE_REG(REG_EMC, EMC_FDPD_CTRL_CMD), \ + DEFINE_REG(REG_EMC, EMC_FBIO_SPARE), \ + DEFINE_REG(REG_EMC, EMC_ZCAL_INTERVAL), \ + DEFINE_REG(REG_EMC, EMC_ZCAL_WAIT_CNT), \ + DEFINE_REG(REG_EMC, EMC_MRS_WAIT_CNT), \ + DEFINE_REG(REG_EMC, EMC_MRS_WAIT_CNT2), \ + DEFINE_REG(REG_EMC, EMC_AUTO_CAL_CHANNEL), \ + DEFINE_REG(REG_EMC, EMC_DLL_CFG_0), \ + DEFINE_REG(REG_EMC, EMC_DLL_CFG_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_AUTOCAL_CFG_COMMON), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_ZCTRL), \ + DEFINE_REG(REG_EMC, EMC_CFG), \ + DEFINE_REG(REG_EMC, EMC_CFG_PIPE), \ + DEFINE_REG(REG_EMC, EMC_DYN_SELF_REF_CONTROL), \ + DEFINE_REG(REG_EMC, EMC_QPOP), \ + DEFINE_REG(REG_EMC, EMC_DQS_BRLSHFT_0), \ + DEFINE_REG(REG_EMC, EMC_DQS_BRLSHFT_1), \ + DEFINE_REG(REG_EMC, EMC_CMD_BRLSHFT_2), \ + DEFINE_REG(REG_EMC, EMC_CMD_BRLSHFT_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_PAD_CFG_CTRL), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DATA_PAD_RX_CTRL), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_PAD_RX_CTRL), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DATA_RX_TERM_MODE), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_RX_TERM_MODE), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_PAD_TX_CTRL), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DATA_PAD_TX_CTRL), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_COMMON_PAD_TX_CTRL), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_VTTGEN_CTRL_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_VTTGEN_CTRL_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_VTTGEN_CTRL_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_BRICK_CTRL_RFU1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_BRICK_CTRL_FDPD), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_BRICK_CTRL_RFU2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DATA_BRICK_CTRL_FDPD), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_BG_BIAS_CTRL_0), \ + DEFINE_REG(REG_EMC, EMC_CFG_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_PWRD_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_PWRD_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_PWRD_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_PWRD_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_PWRD_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_PWRD_5), \ + DEFINE_REG(REG_EMC, EMC_CONFIG_SAMPLE_DELAY), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_SEL_CLK_SRC_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_SEL_CLK_SRC_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_SEL_CLK_SRC_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_SEL_CLK_SRC_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_SEL_CLK_SRC_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_TX_SEL_CLK_SRC_5), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_BYPASS), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_PWRD_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_PWRD_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_DDLL_PWRD_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_CTRL_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_CTRL_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_CMD_CTRL_2), \ + DEFINE_REG(REG_EMC, EMC_TR_TIMING_0), \ + DEFINE_REG(REG_EMC, EMC_TR_DVFS), \ + DEFINE_REG(REG_EMC, EMC_TR_CTRL_1), \ + DEFINE_REG(REG_EMC, EMC_TR_RDV), \ + DEFINE_REG(REG_EMC, EMC_TR_QPOP), \ + DEFINE_REG(REG_EMC, EMC_TR_RDV_MASK), \ + DEFINE_REG(REG_EMC, EMC_MRW14), \ + DEFINE_REG(REG_EMC, EMC_TR_QSAFE), \ + DEFINE_REG(REG_EMC, EMC_TR_QRST), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_SETTLE), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_VREF_SETTLE), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_CA_FINE_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_CA_CTRL_MISC), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_CA_CTRL_MISC1), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_CA_VREF_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_QUSE_CORS_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_QUSE_FINE_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_QUSE_CTRL_MISC), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_QUSE_VREF_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_READ_FINE_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_READ_CTRL_MISC), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_READ_VREF_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_WRITE_FINE_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_WRITE_CTRL_MISC), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_WRITE_VREF_CTRL), \ + DEFINE_REG(REG_EMC, EMC_TRAINING_MPC), \ + DEFINE_REG(REG_EMC, EMC_MRW15), \ +} + +#define TRIM_REGS_PER_CH_LIST \ +{ \ + DEFINE_REG(REG_EMC0, EMC_CMD_BRLSHFT_0), \ + DEFINE_REG(REG_EMC1, EMC_CMD_BRLSHFT_1), \ + DEFINE_REG(REG_EMC0, EMC_DATA_BRLSHFT_0), \ + DEFINE_REG(REG_EMC1, EMC_DATA_BRLSHFT_0), \ + DEFINE_REG(REG_EMC0, EMC_DATA_BRLSHFT_1), \ + DEFINE_REG(REG_EMC1, EMC_DATA_BRLSHFT_1), \ + DEFINE_REG(REG_EMC0, EMC_QUSE_BRLSHFT_0), \ + DEFINE_REG(REG_EMC1, EMC_QUSE_BRLSHFT_1), \ + DEFINE_REG(REG_EMC0, EMC_QUSE_BRLSHFT_2), \ + DEFINE_REG(REG_EMC1, EMC_QUSE_BRLSHFT_3), \ +} + +#define TRIM_REGS_LIST \ +{ \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_LONG_DQS_RANK1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE2_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE3_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE4_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE5_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE6_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK0_BYTE7_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE2_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE3_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE4_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE5_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE6_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_DDLL_SHORT_DQ_RANK1_BYTE7_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_VREF_DQS_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_VREF_DQS_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_VREF_DQ_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_IB_VREF_DQ_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE2_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE3_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE4_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE5_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE6_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_BYTE7_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD2_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK0_CMD3_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE2_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE3_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE4_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE5_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE6_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_OB_DDLL_SHORT_DQ_RANK1_BYTE7_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK0_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK0_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK0_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK0_3), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK1_0), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK1_1), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK1_2), \ + DEFINE_REG(REG_EMC, EMC_PMACRO_QUSE_DDLL_RANK1_3), \ +} + +#define BURST_MC_REGS_LIST \ +{ \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_CFG), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_OUTSTANDING_REQ), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_REFPB_HP_CTRL), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_REFPB_BANK_CTRL), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RCD), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RP), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RC), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RAS), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_FAW), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RRD), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RAP2PRE), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_WAP2PRE), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_R2R), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_W2W), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_R2W), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_CCDMW), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_W2R), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_TIMING_RFCPB), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DA_TURNS), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DA_COVERS), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_MISC0), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_MISC1), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_MISC2), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_RING1_THROTTLE), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_CTRL), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_0), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_1), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_2), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_3), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_4), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_5), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_6), \ + DEFINE_REG(REG_MC, MC_EMEM_ARB_DHYST_TIMEOUT_UTIL_7), \ +} + +#define BURST_UP_DOWN_REGS_LIST \ +{ \ + DEFINE_REG(REG_MC, MC_MLL_MPCORER_PTSA_RATE), \ + DEFINE_REG(REG_MC, MC_FTOP_PTSA_RATE), \ + DEFINE_REG(REG_MC, MC_PTSA_GRANT_DECREMENT), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_XUSB_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_XUSB_1), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_TSEC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_SDMMCA_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_SDMMCAA_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_SDMMC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_SDMMCAB_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_PPCS_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_PPCS_1), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_MPCORE_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_HC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_HC_1), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_AVPC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_GPU_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_GPU2_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_NVENC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_NVDEC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_VIC_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_VI2_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_ISP2_0), \ + DEFINE_REG(REG_MC, MC_LATENCY_ALLOWANCE_ISP2_1), \ +} + +#define VREF_REGS_PER_CH_LIST \ +{ \ + DEFINE_REG(REG_EMC0, EMC_TRAINING_OPT_DQS_IB_VREF_RANK0), \ + DEFINE_REG(REG_EMC1, EMC_TRAINING_OPT_DQS_IB_VREF_RANK0), \ + DEFINE_REG(REG_EMC0, EMC_TRAINING_OPT_DQS_IB_VREF_RANK1), \ + DEFINE_REG(REG_EMC1, EMC_TRAINING_OPT_DQS_IB_VREF_RANK1), \ +} + +#define DEFINE_REG(type, reg) reg##_INDEX +enum BURST_REGS_LIST; +enum TRIM_REGS_LIST; +enum BURST_MC_REGS_LIST; +enum BURST_UP_DOWN_REGS_LIST; +#undef DEFINE_REG + +#define DEFINE_REG(type, reg) type##_##reg##_INDEX +enum BURST_REGS_PER_CH_LIST; +enum TRIM_REGS_PER_CH_LIST; +enum VREF_REGS_PER_CH_LIST; +#undef DEFINE_REG + +enum { + DRAM_TYPE_DDR3 = 0, + DRAM_TYPE_LPDDR4 = 1, + DRAM_TYPE_LPDDR2 = 2, + DRAM_TYPE_DDR2 = 3, +}; + +struct emc_table { + u32 rev; + char dvfs_ver[60]; + u32 rate; + u32 min_volt; + u32 gpu_min_volt; + char clock_src[32]; + u32 clk_src_emc; + u32 needs_training; + u32 training_parttern; + u32 trained; + + u32 periodic_training; + u32 trained_dram_clktree_c0d0u0; + u32 trained_dram_clktree_c0d0u1; + u32 trained_dram_clktree_c0d1u0; + u32 trained_dram_clktree_c0d1u1; + u32 trained_dram_clktree_c1d0u0; + u32 trained_dram_clktree_c1d0u1; + u32 trained_dram_clktree_c1d1u0; + u32 trained_dram_clktree_c1d1u1; + u32 current_dram_clktree_c0d0u0; + u32 current_dram_clktree_c0d0u1; + u32 current_dram_clktree_c0d1u0; + u32 current_dram_clktree_c0d1u1; + u32 current_dram_clktree_c1d0u0; + u32 current_dram_clktree_c1d0u1; + u32 current_dram_clktree_c1d1u0; + u32 current_dram_clktree_c1d1u1; + u32 run_clocks; + u32 tree_margin; + + u32 num_burst; + u32 num_burst_per_ch; + u32 num_trim; + u32 num_trim_per_ch; + u32 num_mc_regs; + u32 num_up_down; + u32 vref_num; + u32 training_mod_num; + u32 dram_timing_num; + + u32 ptfv_list[12]; + + u32 burst_regs[221]; + u32 burst_reg_per_ch[8]; + u32 shadow_regs_ca_train[221]; + u32 shadow_regs_quse_train[221]; + u32 shadow_regs_rdwr_train[221]; + + u32 trim_regs[138]; + u32 trim_perch_regs[10]; + + u32 vref_perch_regs[4]; + + u32 dram_timings[5]; + u32 training_mod_regs[20]; + u32 save_restore_mod_regs[12]; + u32 burst_mc_regs[33]; + u32 la_scale_regs[24]; + + u32 min_mrs_wait; + u32 emc_mrw; + u32 emc_mrw2; + u32 emc_mrw3; + u32 emc_mrw4; + u32 emc_mrw9; + u32 emc_mrs; + u32 emc_emrs; + u32 emc_emrs2; + u32 emc_auto_cal_config; + u32 emc_auto_cal_config2; + u32 emc_auto_cal_config3; + u32 emc_auto_cal_config4; + u32 emc_auto_cal_config5; + u32 emc_auto_cal_config6; + u32 emc_auto_cal_config7; + u32 emc_auto_cal_config8; + u32 emc_cfg_2; + u32 emc_sel_dpd_ctrl; + u32 emc_fdpd_ctrl_cmd_no_ramp; + u32 dll_clk_src; + u32 clk_out_enb_x_0_clk_enb_emc_dll; + u32 latency; +}; + +struct tegra_emc { + struct clk_hw hw; + struct clk *emc_clk; + struct device *dev; + + struct tegra_mc *mc; + + void __iomem *emc_base; + void __iomem *emc0_base; + void __iomem *emc1_base; + + struct emc_table *current_timing; + struct emc_table *next_timing; + struct emc_table start_timing; + + struct emc_table *emc_table; + struct emc_table *emc_table_normal; + struct emc_table *emc_table_derated; + + unsigned int emc_table_size; + + int dram_dev_num; + u32 dram_type; + u32 ram_code; + u32 clk_setting; +}; +#define to_emc(_hw) container_of(_hw, struct tegra_emc, hw) + +struct supported_sequence { + u8 table_rev; + void (*set_clock)(struct tegra_emc *emc, u32 clksrc); + u32 (*periodic_compensation)(struct tegra_emc *emc); + char *seq_rev; +}; + +int tegra_emc_dt_parse_pdata(struct platform_device *pdev, + struct emc_table **tables, + struct emc_table **derated_tables, + int *num_entries); + +#endif diff --git a/drivers/memory/tegra/tegra210-emc.c b/drivers/memory/tegra/tegra210-emc.c new file mode 100644 index 000000000000..0c20bcd0e6de --- /dev/null +++ b/drivers/memory/tegra/tegra210-emc.c @@ -0,0 +1,886 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2015-2019, NVIDIA CORPORATION. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "mc.h" +#include "tegra210-emc-reg.h" + +#define TEGRA_EMC_TABLE_MAX_SIZE 16 +#define TEGRA210_EMC_SUSPEND_RATE 204000000 + +enum TEGRA_EMC_SOURCE { + 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; + u32 value_b; + unsigned long input_rate_b; +}; + +struct emc_stats { + u64 time_at_clock[TEGRA_EMC_TABLE_MAX_SIZE]; + int last_sel; + u64 last_update; + u64 clkchange_count; + spinlock_t spinlock; +}; + +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 struct emc_stats emc_stats; +static struct supported_sequence supported_seqs[] = { + { + 0, + NULL, + NULL, + NULL + } +}; +static struct supported_sequence *seq; +static struct tegra_emc *tegra_emc; +static DEFINE_SPINLOCK(emc_access_lock); +static ktime_t clkchange_time; +static int clkchange_delay = 100; + +static void emc_train(struct timer_list *tmr); +DEFINE_TIMER(emc_training_timer, emc_train); +static u32 timer_period_training = 100; + +#define DEFINE_REG(type, reg) (reg) +u32 burst_regs_per_ch_off[] = BURST_REGS_PER_CH_LIST; +u32 burst_regs_off[] = BURST_REGS_LIST; +u32 burst_mc_regs_off[] = BURST_MC_REGS_LIST; +u32 la_scale_regs_off[] = BURST_UP_DOWN_REGS_LIST; +u32 trim_regs_per_ch_off[] = TRIM_REGS_PER_CH_LIST; +u32 trim_regs_off[] = TRIM_REGS_LIST; +u32 vref_regs_per_ch_off[] = VREF_REGS_PER_CH_LIST; +#undef DEFINE_REG + +#define DEFINE_REG(type, reg) (type) +u32 burst_regs_per_ch_type[] = BURST_REGS_PER_CH_LIST; +u32 trim_regs_per_ch_type[] = TRIM_REGS_PER_CH_LIST; +u32 vref_regs_per_ch_type[] = VREF_REGS_PER_CH_LIST; +#undef DEFINE_REG + +#ifdef CONFIG_PM_SLEEP +static bool emc_suspend; +static unsigned long emc_resume_rate; +#endif + +inline u32 emc_readl(struct tegra_emc *emc, unsigned long offset) +{ + return readl(emc->emc_base + offset); +} + +inline 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(emc->emc_base + offset); + break; + case REG_EMC1: + val = readl(emc->emc1_base + 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(struct timer_list *tmr) +{ + unsigned long flags; + struct tegra_emc *emc = tegra_emc; + + 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(timer_period_training)); +} + +static void emc_training_timer_start(void) +{ + mod_timer(&emc_training_timer, + jiffies + msecs_to_jiffies(timer_period_training)); +} + +static void emc_training_timer_stop(void) +{ + 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(); + else + emc_training_timer_stop(); +} + +static inline void emc_get_timing(struct tegra_emc *emc, + struct emc_table *timing) +{ + int i, div; + u32 val; + unsigned long rate; + + for (i = 0; i < timing->num_burst; i++) { + if (burst_regs_off[i]) + timing->burst_regs[i] = emc_readl(emc, + burst_regs_off[i]); + else + timing->burst_regs[i] = 0; + } + + for (i = 0; i < timing->num_burst_per_ch; i++) + timing->burst_reg_per_ch[i] = emc_readl_per_ch(emc, + burst_regs_per_ch_type[i], burst_regs_per_ch_off[i]); + + for (i = 0; i < timing->num_trim; i++) + timing->trim_regs[i] = emc_readl(emc, trim_regs_off[i]); + + for (i = 0; i < timing->num_trim_per_ch; i++) + timing->trim_perch_regs[i] = emc_readl_per_ch(emc, + trim_regs_per_ch_type[i], trim_regs_per_ch_off[i]); + + for (i = 0; i < timing->vref_num; i++) + timing->vref_perch_regs[i] = emc_readl_per_ch(emc, + vref_regs_per_ch_type[i], vref_regs_per_ch_off[i]); + + for (i = 0; i < timing->num_mc_regs; i++) + timing->burst_mc_regs[i] = mc_readl(emc->mc, + burst_mc_regs_off[i]); + + for (i = 0; i < timing->num_up_down; i++) + timing->la_scale_regs[i] = mc_readl(emc->mc, + la_scale_regs_off[i]); + + 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); + timing->rate = rate / 1000; +} + +static void __emc_copy_table_params(struct emc_table *src, + struct emc_table *dst, int flags) +{ + int i; + + if (flags & EMC_COPY_TABLE_PARAM_PERIODIC_FIELDS) { + dst->trained_dram_clktree_c0d0u0 = + src->trained_dram_clktree_c0d0u0; + dst->trained_dram_clktree_c0d0u1 = + src->trained_dram_clktree_c0d0u1; + dst->trained_dram_clktree_c0d1u0 = + src->trained_dram_clktree_c0d1u0; + dst->trained_dram_clktree_c0d1u1 = + src->trained_dram_clktree_c0d1u1; + dst->trained_dram_clktree_c1d0u0 = + src->trained_dram_clktree_c1d0u0; + dst->trained_dram_clktree_c1d0u1 = + src->trained_dram_clktree_c1d0u1; + dst->trained_dram_clktree_c1d1u0 = + src->trained_dram_clktree_c1d1u0; + dst->trained_dram_clktree_c1d1u1 = + src->trained_dram_clktree_c1d1u1; + dst->current_dram_clktree_c0d0u0 = + src->current_dram_clktree_c0d0u0; + dst->current_dram_clktree_c0d0u1 = + src->current_dram_clktree_c0d0u1; + dst->current_dram_clktree_c0d1u0 = + src->current_dram_clktree_c0d1u0; + dst->current_dram_clktree_c0d1u1 = + src->current_dram_clktree_c0d1u1; + dst->current_dram_clktree_c1d0u0 = + src->current_dram_clktree_c1d0u0; + dst->current_dram_clktree_c1d0u1 = + src->current_dram_clktree_c1d0u1; + dst->current_dram_clktree_c1d1u0 = + src->current_dram_clktree_c1d1u0; + dst->current_dram_clktree_c1d1u1 = + src->current_dram_clktree_c1d1u1; + } + + if (flags & EMC_COPY_TABLE_PARAM_TRIM_REGS) { + for (i = 0; i < src->num_trim_per_ch; i++) + dst->trim_perch_regs[i] = src->trim_perch_regs[i]; + + for (i = 0; i < src->num_trim; i++) + dst->trim_regs[i] = src->trim_regs[i]; + + for (i = 0; i < src->num_burst_per_ch; i++) + dst->burst_reg_per_ch[i] = src->burst_reg_per_ch[i]; + + dst->trained = src->trained; + } +} + +static void emc_copy_table_params(struct emc_table *src, + struct emc_table *dst, + int table_size, + int flags) +{ + int i; + + for (i = 0; i < table_size; i++) + __emc_copy_table_params(&src[i], &dst[i], flags); +} + +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_TABLE_MAX_SIZE) + 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_TABLE_MAX_SIZE) { + 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_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(), clkchange_time); + if ((last_change_delay >= 0) && (last_change_delay < clkchange_delay)) + udelay(clkchange_delay - (int)last_change_delay); + + spin_lock_irqsave(&emc_access_lock, flags); + emc_set_clock(emc, emc->clk_setting); + clkchange_time = ktime_get(); + emc->current_timing = &emc->emc_table[i]; + spin_unlock_irqrestore(&emc_access_lock, flags); + + 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; + + if (!emc->emc_table_size || !seq) + return 0; + + emc_last_stats_update(TEGRA_EMC_TABLE_MAX_SIZE); + + 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; + + 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)); + + return 0; +} + +static int emc_stats_open(struct inode *inode, struct file *file) +{ + return single_open(file, emc_stats_show, inode->i_private); +} + +static const struct file_operations emc_stats_fops = { + .open = emc_stats_open, + .read = seq_read, + .llseek = seq_lseek, + .release = single_release, +}; + +static int debug_emc_get_rate(void *data, u64 *val) +{ + struct clk *c = data; + + *val = clk_get_rate(c); + + return 0; +} + +static int debug_emc_set_rate(void *data, u64 val) +{ + struct clk *c = data; + + return clk_set_rate(c, val); +} +DEFINE_SIMPLE_ATTRIBUTE(emc_rate_fops, debug_emc_get_rate, + debug_emc_set_rate, "%llu\n"); + +static int tegra_emc_debug_init(struct tegra_emc *emc) +{ + struct dentry *emc_debugfs_root; + + emc_debugfs_root = debugfs_create_dir("tegra_emc", NULL); + if (!emc_debugfs_root) + return -ENOMEM; + + if (!debugfs_create_file("stats", 0444, emc_debugfs_root, emc, + &emc_stats_fops)) + goto err_out; + + if (!debugfs_create_file("rate", 0644, emc_debugfs_root, emc->emc_clk, + &emc_rate_fops)) + goto err_out; + + return 0; + +err_out: + debugfs_remove_recursive(emc_debugfs_root); + return -ENOMEM; +} +#endif /* CONFIG_DEBUG_FS */ + +static u8 clk_emc_get_parent(struct clk_hw *hw) +{ + struct tegra_emc *emc = to_emc(hw); + + if (!emc->clk_setting) + emc->clk_setting = tegra210_clk_emc_get_setting(); + + return emc_src_val(emc->clk_setting); +} + +static unsigned long clk_emc_recalc_rate(struct clk_hw *hw, + unsigned long parent_rate) +{ + struct tegra_emc *emc = to_emc(hw); + + if (!emc->emc_table_size || !seq) { + u32 emc_setting = tegra210_clk_emc_get_setting(); + + return clk_get_rate(emc_src[emc_src_val(emc_setting)]); + } + + return emc->current_timing->rate * 1000; +} + +static long clk_emc_round_rate(struct clk_hw *hw, unsigned long rate, + unsigned long *prate) +{ + struct tegra_emc *emc = to_emc(hw); + int i; + + if (!emc->emc_table_size || !seq) { + u32 emc_setting = tegra210_clk_emc_get_setting(); + + return clk_get_rate(emc_src[emc_src_val(emc_setting)]); + } + + if (emc_suspend) + return TEGRA210_EMC_SUSPEND_RATE; + + rate /= 1000; + + for (i = 0; i < emc->emc_table_size; i++) { + if (emc->emc_table[i].rate >= rate) + return emc->emc_table[i].rate * 1000; + } + + return emc->emc_table[i - 1].rate * 1000; +} + +static int clk_emc_set_rate(struct clk_hw *hw, unsigned long rate, + unsigned long parent_rate) +{ + struct tegra_emc *emc = to_emc(hw); + struct clk *old_parent, *new_parent; + int ret = -EINVAL; + + if (!emc->emc_table_size || !seq) + return ret; + + if (emc_suspend) + rate = TEGRA210_EMC_SUSPEND_RATE; + + old_parent = clk_get_parent(hw->clk); + new_parent = emc_predict_parent(emc, rate); + if (IS_ERR(new_parent)) + goto out; + + if (!clk_is_match(new_parent, old_parent)) + clk_prepare_enable(new_parent); + + ret = emc_set_rate(emc, rate); + if (ret) { + if (new_parent != old_parent) + clk_disable_unprepare(new_parent); + goto out; + } + + if (!clk_is_match(new_parent, old_parent)) { + clk_hw_reparent(hw, __clk_get_hw(new_parent)); + clk_disable_unprepare(old_parent); + } + +out: + return ret; +} + +static const struct clk_ops tegra_clk_emc_ops = { + .get_parent = clk_emc_get_parent, + .recalc_rate = clk_emc_recalc_rate, + .round_rate = clk_emc_round_rate, + .set_rate = clk_emc_set_rate, +}; + +static int find_matching_input(struct emc_table *table, struct emc_sel *sel) +{ + u32 div_value; + u32 src_value; + unsigned long input_rate = 0; + struct clk *input_clk; + + div_value = emc_div_val(table->clk_src_emc); + src_value = emc_src_val(table->clk_src_emc); + + if (div_value & 0x1) { + pr_warn("Tegra EMC: invalid odd divider for EMC rate %u\n", + table->rate); + return -EINVAL; + } + + if (!(table->clk_src_emc & EMC_CLK_MC_EMC_SAME_FREQ) != + !(MC_EMEM_ARB_MISC0_EMC_SAME_FREQ & + table->burst_regs[MC_EMEM_ARB_MISC0_INDEX])) { + pr_warn("Tegra EMC: ambiguous EMC to MC ratio for rate %u\n", + table->rate); + return -EINVAL; + } + + input_clk = emc_src[src_value]; + if (input_clk == emc_src[TEGRA_EMC_SRC_PLLM] + || input_clk == emc_src[TEGRA_EMC_SRC_PLLM_UD]) { + input_rate = table->rate * (1 + div_value / 2); + } else { + input_rate = clk_get_rate(input_clk) / 1000; + if (input_rate != (table->rate * (1 + div_value / 2))) { + pr_warn("Tegra EMC: rate %u doesn't match input\n", + table->rate); + return -EINVAL; + } + } + + sel->input = input_clk; + sel->input_rate = input_rate; + sel->value = table->clk_src_emc; + sel->input_b = input_clk; + sel->input_rate_b = input_rate; + sel->value_b = table->clk_src_emc; + + if (input_clk == emc_src[TEGRA_EMC_SRC_PLLM]) { + sel->input_b = emc_src[TEGRA_EMC_SRC_PLLMB]; + sel->value_b = table->clk_src_emc & + ~EMC_CLK_EMC_2X_CLK_SRC_MASK; + sel->value_b |= TEGRA_EMC_SRC_PLLMB << + EMC_CLK_EMC_2X_CLK_SRC_SHIFT; + } + + if (input_clk == emc_src[TEGRA_EMC_SRC_PLLM_UD]) { + sel->input_b = emc_src[TEGRA_EMC_SRC_PLLMB_UD]; + sel->value_b = table->clk_src_emc & + ~EMC_CLK_EMC_2X_CLK_SRC_MASK; + sel->value_b |= TEGRA_EMC_SRC_PLLMB_UD << + EMC_CLK_EMC_2X_CLK_SRC_SHIFT; + } + + return 0; +} + +static int tegra210_emc_probe(struct platform_device *pdev) +{ + int i, div; + 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; + u32 emc_setting; + + 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; + } + + 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(); + r = platform_get_resource(pdev, IORESOURCE_MEM, 0); + emc->emc_base = devm_ioremap_resource(&pdev->dev, r); + r = platform_get_resource(pdev, IORESOURCE_MEM, 1); + emc->emc0_base = devm_ioremap_resource(&pdev->dev, r); + r = platform_get_resource(pdev, IORESOURCE_MEM, 2); + emc->emc1_base = devm_ioremap_resource(&pdev->dev, r); + + 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; + } + } + + /* 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_TABLE_MAX_SIZE; + + emc->dram_type = (emc_readl(emc, EMC_FBIO_CFG5) & + EMC_FBIO_CFG5_DRAM_TYPE_MASK) >> + EMC_FBIO_CFG5_DRAM_TYPE_SHIFT; + if (emc->dram_type != DRAM_TYPE_DDR3 && + emc->dram_type != DRAM_TYPE_LPDDR2 && + emc->dram_type != DRAM_TYPE_LPDDR4) { + dev_err(&pdev->dev, "DRAM not supported\n"); + return -ENODATA; + } + + emc->dram_dev_num = tegra_mc_get_emem_device_count(emc->mc); + + tegra_emc_dt_parse_pdata(pdev, &emc->emc_table_normal, + &emc->emc_table_derated, + &emc->emc_table_size); + if (!emc->emc_table_size || + emc->emc_table_size > TEGRA_EMC_TABLE_MAX_SIZE) { + dev_err(&pdev->dev, "Invalid table size %d\n", + emc->emc_table_size); + goto emc_clk_register; + } + emc->emc_table = emc->emc_table_normal; + + /* + * Copy trained trimmers from the normal table to the derated + * table for LP4. Bootloader trains only the normal table. + * Trimmers are the same for derated and normal tables. + */ + if (emc->emc_table_derated && emc->dram_type == DRAM_TYPE_LPDDR4) + emc_copy_table_params(emc->emc_table_normal, + emc->emc_table_derated, + emc->emc_table_size, + EMC_COPY_TABLE_PARAM_PERIODIC_FIELDS | + EMC_COPY_TABLE_PARAM_TRIM_REGS); + + seq = supported_seqs; + 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; + } + + emc_clk_sel = devm_kcalloc(&pdev->dev, + emc->emc_table_size, + sizeof(struct emc_sel), + GFP_KERNEL); + if (!emc_clk_sel) { + dev_err(&pdev->dev, "Memory allocation failed\n"); + return -ENOMEM; + } + + /* calculate the rate from source clock */ + emc_setting = tegra210_clk_emc_get_setting(); + current_rate = clk_get_rate(emc_src[emc_src_val(emc_setting)]); + div = emc_div_val(emc_setting); + div += 2; + current_rate *= 2; + current_rate += div - 1; + do_div(current_rate, div); + current_rate /= 1000; + + for (i = 0; i < emc->emc_table_size; i++) { + table_rate = emc->emc_table[i].rate; + if (!table_rate) + continue; + + if (i && ((table_rate <= emc->emc_table[i-1].rate) || + (emc->emc_table[i].min_volt < + emc->emc_table[i-1].min_volt))) + continue; + + if (emc->emc_table[i].rev != emc->emc_table[0].rev) + continue; + + if (find_matching_input(&emc->emc_table[i], &emc_clk_sel[i])) + continue; + + if (table_rate == current_rate) + emc_stats.last_sel = i; + } + + dev_info(&pdev->dev, "validated EMC DFS table\n"); + + /* Update the start_timing base on the settings from firmware */ + emc->start_timing.num_burst = emc->emc_table[0].num_burst; + emc->start_timing.num_burst_per_ch = + emc->emc_table[0].num_burst_per_ch; + emc->start_timing.num_trim = emc->emc_table[0].num_trim; + emc->start_timing.num_trim_per_ch = + emc->emc_table[0].num_trim_per_ch; + emc->start_timing.num_mc_regs = emc->emc_table[0].num_mc_regs; + emc->start_timing.num_up_down = emc->emc_table[0].num_up_down; + emc->start_timing.vref_num = emc->emc_table[0].vref_num; + + emc_get_timing(emc, &emc->start_timing); + emc->current_timing = &emc->start_timing; + emc->clk_setting = emc_setting; + +emc_clk_register: + init.name = "emc"; + init.ops = &tegra_clk_emc_ops; + init.flags = CLK_IS_CRITICAL | CLK_GET_RATE_NOCACHE; + init.parent_names = emc_src_names; + init.num_parents = ARRAY_SIZE(emc_src_names); + emc->hw.init = &init; + + clk = clk_register(&pdev->dev, &emc->hw); + if (IS_ERR(clk)) + return PTR_ERR(clk); + emc->emc_clk = clk; + emc->dev = &pdev->dev; + tegra_emc = emc; + dev_set_drvdata(emc->dev, emc); + + if (emc->emc_table_size && seq) { + for (i = 0; i < emc->emc_table_size; i++) { + table_rate = emc->emc_table[i].rate * 1000; + if (clk_set_rate(clk, table_rate)) + dev_info(&pdev->dev, + "rate: %lu validation fail\n", + table_rate); + + dev_info(&pdev->dev, "rate: %lu validation success\n", + table_rate); + } + } + + if (IS_ENABLED(CONFIG_DEBUG_FS)) + tegra_emc_debug_init(emc); + + return 0; +} + +#ifdef CONFIG_PM_SLEEP +static int tegra210_emc_suspend(struct device *dev) +{ + struct tegra_emc *emc = dev_get_drvdata(dev); + + if (!IS_ERR(emc->emc_clk)) { + emc_suspend = true; + emc_resume_rate = clk_get_rate(emc->emc_clk); + clk_set_rate(emc->emc_clk, TEGRA210_EMC_SUSPEND_RATE); + + pr_debug("%s at rate %lu\n", __func__, + clk_get_rate(emc->emc_clk)); + } + + return 0; +} + +static int tegra210_emc_resume(struct device *dev) +{ + struct tegra_emc *emc = dev_get_drvdata(dev); + + if (!IS_ERR(emc->emc_clk)) { + emc_suspend = false; + clk_set_rate(emc->emc_clk, emc_resume_rate); + + pr_debug("%s at rate %lu\n", __func__, + clk_get_rate(emc->emc_clk)); + } + + return 0; +} + +static const struct dev_pm_ops tegra210_emc_pm_ops = { + SET_SYSTEM_SLEEP_PM_OPS(tegra210_emc_suspend, tegra210_emc_resume) +}; +#endif + +static const struct of_device_id tegra210_emc_of_match[] = { + { .compatible = "nvidia,tegra210-emc", }, + { }, +}; + +static struct platform_driver tegra210_emc_driver = { + .driver = { + .name = "tegra210-emc", + .of_match_table = tegra210_emc_of_match, + .pm = &tegra210_emc_pm_ops, + }, + .probe = tegra210_emc_probe, +}; + +static int __init tegra210_emc_init(void) +{ + return platform_driver_register(&tegra210_emc_driver); +} +subsys_initcall(tegra210_emc_init); From patchwork Mon Mar 25 07:45:19 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063884 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="YT2vaUYk"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRC25B47z9sSd for ; Mon, 25 Mar 2019 18:45:50 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729876AbfCYHpu (ORCPT ); Mon, 25 Mar 2019 03:45:50 -0400 Received: from hqemgate14.nvidia.com ([216.228.121.143]:19787 "EHLO hqemgate14.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729867AbfCYHpu (ORCPT ); Mon, 25 Mar 2019 03:45:50 -0400 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate14.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:46 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:43 -0700 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 25 Mar 2019 00:45:43 -0700 Received: from HQMAIL109.nvidia.com (172.20.187.15) by HQMAIL105.nvidia.com (172.20.187.12) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:43 +0000 Received: from HQMAIL103.nvidia.com (172.20.187.11) by HQMAIL109.nvidia.com (172.20.187.15) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:42 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL103.nvidia.com (172.20.187.11) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:42 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:41 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , "Rob Herring" , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 4/8] memory: tegra: add EMC scaling support code for Tegra210 Date: Mon, 25 Mar 2019 15:45:19 +0800 Message-ID: <20190325074523.26456-5-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499946; bh=NO5MUr6g0XSurOjfVpPn/zJhK0H7VQLh/s1fG+QtHqA=; 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=YT2vaUYkB8s70x+CT1RkSpbuFwofJkFqjaQROelKbQrmCH9JfBd7zNsgYnzmZdD2E jOm1O2r30qvpxXidMdX8RIzWT/FBy5+tzEdHE5p9oESwkGxLiQ11+jrDffKovgnZJl VxB7iL58o9YGYZd5HunbUJ/G1AwiZA/2QPFkAM/o+JOtqQzEV7o3G0pgr3TtQPFMUj tscMLkymp+Y66vPNTBnhI3dnL2Xp3lgIta1xPsJpFDG9Pz3Xh/Q2jhB3eSL++K/l4r FLsG819WgMM8Nqpk4wHN0UBx804LCj/pnySL4AitfwnSlpZzkj+aOwcvUEnGWKWGmZ JYTcD2N4fIWgA== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org This patch adds the required APIs and variables for the EMC scaling sequence code on Tegra210. Based on the work of Peter De Schrijver . Signed-off-by: Joseph Lo --- drivers/memory/tegra/tegra210-emc-reg.h | 265 +++++++ drivers/memory/tegra/tegra210-emc.c | 923 ++++++++++++++++++++++++ 2 files changed, 1188 insertions(+) diff --git a/drivers/memory/tegra/tegra210-emc-reg.h b/drivers/memory/tegra/tegra210-emc-reg.h index 84fcc85f3b6d..31a69e718dbc 100644 --- a/drivers/memory/tegra/tegra210-emc-reg.h +++ b/drivers/memory/tegra/tegra210-emc-reg.h @@ -12,6 +12,13 @@ #include "mc.h" +#define DVFS_FGCG_HIGH_SPEED_THRESHOLD 1000 +#define IOBRICK_DCC_THRESHOLD 2400 +#define DVFS_FGCG_MID_SPEED_THRESHOLD 600 + +#define EMC_STATUS_UPDATE_TIMEOUT 1000 + +#define MC_EMEM_ADR_CFG 0x54 #define MC_EMEM_ARB_CFG 0x90 #define MC_EMEM_ARB_OUTSTANDING_REQ 0x94 #define MC_EMEM_ARB_TIMING_RCD 0x98 @@ -75,12 +82,33 @@ #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 EMC_INTSTATUS 0x0 +#define EMC_INTSTATUS_CLKCHANGE_COMPLETE BIT(4) +#define EMC_DBG 0x8 +#define EMC_DBG_WRITE_MUX_ACTIVE BIT(1) #define EMC_CFG 0xc +#define EMC_TIMING_CONTROL 0x28 #define EMC_RC 0x2c #define EMC_RFC 0x30 #define EMC_RAS 0x34 @@ -125,16 +153,40 @@ #define EMC_FBIO_CFG5_DRAM_TYPE_SHIFT 0 #define EMC_FBIO_CFG5_DRAM_TYPE_MASK \ (0x3 << EMC_FBIO_CFG5_DRAM_TYPE_SHIFT) +#define EMC_FBIO_CFG5_CMD_TX_DIS BIT(8) + #define EMC_PDEX2CKE 0x118 #define EMC_CKE2PDEN 0x11c +#define EMC_MPC 0x128 #define EMC_R2R 0x144 #define EMC_EINPUT 0x14c #define EMC_EINPUT_DURATION 0x150 #define EMC_PUTERM_EXTRA 0x154 #define EMC_TCKESR 0x158 #define EMC_TPD 0x15c +#define EMC_EMC_STATUS 0x2b4 +#define EMC_EMC_STATUS_TIMING_UPDATE_STALLED BIT(23) #define EMC_CFG_DIG_DLL 0x2bc +#define EMC_CFG_DIG_DLL_CFG_DLL_EN BIT(0) +#define EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_UNTIL_LOCK BIT(1) +#define EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_TRAFFIC BIT(3) +#define EMC_CFG_DIG_DLL_CFG_DLL_STALL_RW_UNTIL_LOCK BIT(4) +#define EMC_CFG_DIG_DLL_CFG_DLL_MODE_SHIFT 6 +#define EMC_CFG_DIG_DLL_CFG_DLL_MODE_MASK \ + (0x3 << EMC_CFG_DIG_DLL_CFG_DLL_MODE_SHIFT) +#define EMC_CFG_DIG_DLL_CFG_DLL_LOCK_LIMIT_SHIFT 8 +#define EMC_CFG_DIG_DLL_CFG_DLL_LOCK_LIMIT_MASK \ + (0x7 << EMC_CFG_DIG_DLL_CFG_DLL_LOCK_LIMIT_SHIFT) + #define EMC_CFG_DIG_DLL_PERIOD 0x2c0 +#define EMC_DIG_DLL_STATUS 0x2c4 +#define EMC_DIG_DLL_STATUS_DLL_LOCK BIT(15) +#define EMC_DIG_DLL_STATUS_DLL_PRIV_UPDATED BIT(17) +#define EMC_DIG_DLL_STATUS_DLL_OUT_SHIFT 0 +#define EMC_DIG_DLL_STATUS_DLL_OUT_MASK \ + (0x7ff << EMC_DIG_DLL_STATUS_DLL_OUT_SHIFT) + +#define EMC_CFG_DIG_DLL_1 0x2c8 #define EMC_RDV_MASK 0x2cc #define EMC_WDV_MASK 0x2d0 #define EMC_RDV_EARLY_MASK 0x2d4 @@ -153,6 +205,8 @@ #define EMC_PRE_REFRESH_REQ_CNT 0x3dc #define EMC_DYN_SELF_REF_CONTROL 0x3e0 #define EMC_TXSRDLL 0x3e4 +#define EMC_CCFIFO_ADDR 0x3e8 +#define EMC_CCFIFO_DATA 0x3ec #define EMC_TR_QPOP 0x3f4 #define EMC_TR_RDV_MASK 0x3f8 #define EMC_TR_QSAFE 0x3fc @@ -185,8 +239,60 @@ #define EMC_PUTERM_WIDTH 0x56c #define EMC_REFCTRL2 0x580 #define EMC_FBIO_CFG7 0x584 +#define EMC_FBIO_CFG7_CH0_ENABLE BIT(1) +#define EMC_FBIO_CFG7_CH1_ENABLE BIT(2) #define EMC_DATA_BRLSHFT_0 0x588 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE7_DATA_BRLSHFT_SHIFT 21 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE7_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE7_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE6_DATA_BRLSHFT_SHIFT 18 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE6_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE6_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE5_DATA_BRLSHFT_SHIFT 15 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE5_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE5_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE4_DATA_BRLSHFT_SHIFT 12 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE4_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE4_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE3_DATA_BRLSHFT_SHIFT 9 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE3_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE3_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE2_DATA_BRLSHFT_SHIFT 6 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE2_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE2_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE1_DATA_BRLSHFT_SHIFT 3 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE1_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE1_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE0_DATA_BRLSHFT_SHIFT 0 +#define EMC_DATA_BRLSHFT_0_RANK0_BYTE0_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_0_RANK0_BYTE0_DATA_BRLSHFT_SHIFT) + #define EMC_DATA_BRLSHFT_1 0x58c +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE7_DATA_BRLSHFT_SHIFT 21 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE7_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE7_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE6_DATA_BRLSHFT_SHIFT 18 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE6_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE6_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE5_DATA_BRLSHFT_SHIFT 15 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE5_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE5_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE4_DATA_BRLSHFT_SHIFT 12 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE4_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE4_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE3_DATA_BRLSHFT_SHIFT 9 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE3_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE3_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE2_DATA_BRLSHFT_SHIFT 6 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE2_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE2_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE1_DATA_BRLSHFT_SHIFT 3 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE1_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE1_DATA_BRLSHFT_SHIFT) +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE0_DATA_BRLSHFT_SHIFT 0 +#define EMC_DATA_BRLSHFT_1_RANK1_BYTE0_DATA_BRLSHFT_MASK \ + (0x7 << EMC_DATA_BRLSHFT_1_RANK1_BYTE0_DATA_BRLSHFT_SHIFT) + #define EMC_RFCPB 0x590 #define EMC_DQS_BRLSHFT_0 0x594 #define EMC_DQS_BRLSHFT_1 0x598 @@ -201,6 +307,10 @@ #define EMC_QUSE_BRLSHFT_3 0x5c4 #define EMC_DLL_CFG_0 0x5e4 #define EMC_DLL_CFG_1 0x5e8 +#define EMC_DLL_CFG_1_DDLLCAL_CTRL_START_TRIM_SHIFT 10 +#define EMC_DLL_CFG_1_DDLLCAL_CTRL_START_TRIM_MASK \ + (0x7ff << EMC_DLL_CFG_1_DDLLCAL_CTRL_START_TRIM_SHIFT) + #define EMC_CONFIG_SAMPLE_DELAY 0x5f0 #define EMC_PMACRO_QUSE_DDLL_RANK0_0 0x600 #define EMC_PMACRO_QUSE_DDLL_RANK0_1 0x604 @@ -215,15 +325,103 @@ #define EMC_PMACRO_QUSE_DDLL_RANK1_4 0x630 #define EMC_PMACRO_QUSE_DDLL_RANK1_5 0x634 #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 0x640 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_OB_DDLL_LONG_DQ_RANK0_BYTE1_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_OB_DDLL_LONG_DQ_RANK0_BYTE1_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_OB_DDLL_LONG_DQ_RANK0_BYTE1_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_OB_DDLL_LONG_DQ_RANK0_BYTE0_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_OB_DDLL_LONG_DQ_RANK0_BYTE0_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0_OB_DDLL_LONG_DQ_RANK0_BYTE0_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 0x644 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_OB_DDLL_LONG_DQ_RANK0_BYTE3_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_OB_DDLL_LONG_DQ_RANK0_BYTE3_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_OB_DDLL_LONG_DQ_RANK0_BYTE3_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_OB_DDLL_LONG_DQ_RANK0_BYTE2_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_OB_DDLL_LONG_DQ_RANK0_BYTE2_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1_OB_DDLL_LONG_DQ_RANK0_BYTE2_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 0x648 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_OB_DDLL_LONG_DQ_RANK0_BYTE5_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_OB_DDLL_LONG_DQ_RANK0_BYTE5_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_OB_DDLL_LONG_DQ_RANK0_BYTE5_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_OB_DDLL_LONG_DQ_RANK0_BYTE4_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_OB_DDLL_LONG_DQ_RANK0_BYTE4_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2_OB_DDLL_LONG_DQ_RANK0_BYTE4_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 0x64c +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_OB_DDLL_LONG_DQ_RANK0_BYTE7_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_OB_DDLL_LONG_DQ_RANK0_BYTE7_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_OB_DDLL_LONG_DQ_RANK0_BYTE7_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_OB_DDLL_LONG_DQ_RANK0_BYTE6_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_OB_DDLL_LONG_DQ_RANK0_BYTE6_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3_OB_DDLL_LONG_DQ_RANK0_BYTE6_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_4 0x650 #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_5 0x654 #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 0x660 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_OB_DDLL_LONG_DQ_RANK1_BYTE1_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_OB_DDLL_LONG_DQ_RANK1_BYTE1_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_OB_DDLL_LONG_DQ_RANK1_BYTE1_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_OB_DDLL_LONG_DQ_RANK1_BYTE0_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_OB_DDLL_LONG_DQ_RANK1_BYTE0_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0_OB_DDLL_LONG_DQ_RANK1_BYTE0_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 0x664 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_OB_DDLL_LONG_DQ_RANK1_BYTE3_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_OB_DDLL_LONG_DQ_RANK1_BYTE3_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_OB_DDLL_LONG_DQ_RANK1_BYTE3_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_OB_DDLL_LONG_DQ_RANK1_BYTE2_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_OB_DDLL_LONG_DQ_RANK1_BYTE2_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1_OB_DDLL_LONG_DQ_RANK1_BYTE2_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 0x668 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_OB_DDLL_LONG_DQ_RANK1_BYTE5_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_OB_DDLL_LONG_DQ_RANK1_BYTE5_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_OB_DDLL_LONG_DQ_RANK1_BYTE5_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_OB_DDLL_LONG_DQ_RANK1_BYTE4_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_OB_DDLL_LONG_DQ_RANK1_BYTE4_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2_OB_DDLL_LONG_DQ_RANK1_BYTE4_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 0x66c +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_OB_DDLL_LONG_DQ_RANK1_BYTE7_SHIFT \ + 16 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_OB_DDLL_LONG_DQ_RANK1_BYTE7_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_OB_DDLL_LONG_DQ_RANK1_BYTE7_SHIFT) +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_OB_DDLL_LONG_DQ_RANK1_BYTE6_SHIFT \ + 0 +#define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_OB_DDLL_LONG_DQ_RANK1_BYTE6_MASK \ + (0x3ff << \ + EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3_OB_DDLL_LONG_DQ_RANK1_BYTE6_SHIFT) + #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_4 0x670 #define EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_5 0x674 #define EMC_PMACRO_OB_DDLL_LONG_DQS_RANK0_0 0x680 @@ -432,7 +630,18 @@ #define EMC_PMACRO_CMD_RX_TERM_MODE 0xc58 #define EMC_PMACRO_DATA_RX_TERM_MODE 0xc5c #define EMC_PMACRO_CMD_PAD_TX_CTRL 0xc60 +#define EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_E_DCC BIT(1) +#define EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSP_TX_E_DCC BIT(9) +#define EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQSN_TX_E_DCC BIT(16) +#define EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_CMD_TX_E_DCC BIT(24) +#define EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_DRVFORCEON BIT(26) + #define EMC_PMACRO_DATA_PAD_TX_CTRL 0xc64 +#define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_TX_E_DCC BIT(1) +#define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSP_TX_E_DCC BIT(9) +#define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSN_TX_E_DCC BIT(16) +#define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_CMD_TX_E_DCC BIT(24) + #define EMC_PMACRO_COMMON_PAD_TX_CTRL 0xc68 #define EMC_PMACRO_AUTOCAL_CFG_COMMON 0xc78 #define EMC_PMACRO_VTTGEN_CTRL_2 0xcf0 @@ -954,6 +1163,16 @@ enum { DRAM_TYPE_DDR2 = 3, }; +enum { + SINGLE_CHANNEL = 0, + DUAL_CHANNEL +}; + +enum { + DLL_OFF, + DLL_ON +}; + struct emc_table { u32 rev; char dvfs_ver[60]; @@ -1075,9 +1294,55 @@ struct supported_sequence { char *seq_rev; }; +extern u32 burst_mc_regs_off[]; +extern u32 burst_regs_off[]; +extern u32 burst_regs_per_ch_off[]; +extern u32 burst_regs_per_ch_type[]; +extern unsigned long dram_over_temp_state; +extern u32 la_scale_regs_off[]; +extern u32 trim_regs_off[]; +extern u32 trim_regs_per_ch_off[]; +extern u32 trim_regs_per_ch_type[]; +extern u32 vref_regs_per_ch_off[]; +extern u32 vref_regs_per_ch_type[]; + +void ccfifo_writel(struct tegra_emc *emc, u32 val, unsigned long addr, + u32 delay); +u32 div_o3(u32 a, u32 b); +void emc_writel(struct tegra_emc *emc, u32 val, unsigned long offset); +u32 emc_readl(struct tegra_emc *emc, unsigned long offset); +void emc_writel_per_ch(struct tegra_emc *emc, u32 val, int type, + unsigned long offset); +u32 emc1_readl(struct tegra_emc *emc, unsigned long offset); + +void do_clock_change(struct tegra_emc *emc, u32 clksrc); +void emc_set_shadow_bypass(struct tegra_emc *emc, int set); +void emc_timing_update(struct tegra_emc *emc, int dual_chan); +u32 get_dll_state(struct emc_table *next_timing); +struct emc_table *get_timing_from_freq(struct tegra_emc *emc, + unsigned long rate); +void set_over_temp_timing(struct tegra_emc *emc, struct emc_table *timing, + unsigned long state); int tegra_emc_dt_parse_pdata(struct platform_device *pdev, struct emc_table **tables, struct emc_table **derated_tables, int *num_entries); +u32 tegra210_actual_osc_clocks(u32 in); +u32 tegra210_apply_periodic_compensation_trimmer(struct emc_table *next_timing, + u32 offset); +void tegra210_dll_disable(struct tegra_emc *emc, int channel_mode); +void tegra210_dll_enable(struct tegra_emc *emc, int channel_mode); +u32 tegra210_dll_prelock(struct tegra_emc *emc, int dvfs_with_training, + u32 clksrc); +u32 tegra210_dvfs_power_ramp_down(struct tegra_emc *emc, u32 clk, + int flip_backward); +u32 tegra210_dvfs_power_ramp_up(struct tegra_emc *emc, u32 clk, + int flip_backward); +void tegra210_update_emc_alt_timing(struct tegra_emc *emc, + struct emc_table *current_timing); +void tegra210_reset_dram_clktree_values(struct emc_table *table); +void tegra210_start_periodic_compensation(struct tegra_emc *emc); +int wait_for_update(struct tegra_emc *emc, u32 status_reg, u32 bit_mask, + bool updated_state, int chan); #endif diff --git a/drivers/memory/tegra/tegra210-emc.c b/drivers/memory/tegra/tegra210-emc.c index 0c20bcd0e6de..26d0de0ab319 100644 --- a/drivers/memory/tegra/tegra210-emc.c +++ b/drivers/memory/tegra/tegra210-emc.c @@ -20,6 +20,37 @@ #define TEGRA_EMC_TABLE_MAX_SIZE 16 #define TEGRA210_EMC_SUSPEND_RATE 204000000 +#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_EMC_SOURCE { TEGRA_EMC_SRC_PLLM, TEGRA_EMC_SRC_PLLC, @@ -32,6 +63,14 @@ enum TEGRA_EMC_SOURCE { TEGRA_EMC_SRC_COUNT, }; +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, +}; + struct emc_sel { struct clk *input; u32 value; @@ -76,6 +115,7 @@ static struct tegra_emc *tegra_emc; static DEFINE_SPINLOCK(emc_access_lock); static ktime_t clkchange_time; static int clkchange_delay = 100; +unsigned long dram_over_temp_state = TEGRA_DRAM_OVER_TEMP_NONE; static void emc_train(struct timer_list *tmr); DEFINE_TIMER(emc_training_timer, emc_train); @@ -102,11 +142,33 @@ static bool emc_suspend; static unsigned long emc_resume_rate; #endif +inline void emc_writel(struct tegra_emc *emc, u32 val, unsigned long offset) +{ + writel(val, emc->emc_base + offset); +} + inline u32 emc_readl(struct tegra_emc *emc, unsigned long offset) { return readl(emc->emc_base + offset); } +inline u32 emc1_readl(struct tegra_emc *emc, unsigned long offset) +{ + return readl(emc->emc1_base + offset); +} + +inline 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(val, emc->emc_base + offset); + case REG_EMC1: + return writel(val, emc->emc1_base + offset); + } +} + inline u32 emc_readl_per_ch(struct tegra_emc *emc, int type, unsigned long offset) { @@ -125,6 +187,14 @@ inline u32 emc_readl_per_ch(struct tegra_emc *emc, int type, return val; } +inline void ccfifo_writel(struct tegra_emc *emc, u32 val, unsigned long addr, + u32 delay) +{ + writel(val, emc->emc_base + EMC_CCFIFO_DATA); + writel((addr & 0xffff) | ((delay & 0x7fff) << 16) | (1 << 31), + emc->emc_base + EMC_CCFIFO_ADDR); +} + static inline u32 emc_src_val(u32 val) { return (val & EMC_CLK_EMC_2X_CLK_SRC_MASK) >> @@ -175,6 +245,16 @@ static void emc_set_clock(struct tegra_emc *emc, u32 clksrc) emc_training_timer_stop(); } +static struct emc_table *emc_get_table(struct tegra_emc *emc, + unsigned long over_temp_state) +{ + if ((over_temp_state == TEGRA_DRAM_OVER_TEMP_THROTTLE) && + (emc->emc_table_derated != NULL)) + return emc->emc_table_derated; + else + return emc->emc_table_normal; +} + static inline void emc_get_timing(struct tegra_emc *emc, struct emc_table *timing) { @@ -223,6 +303,142 @@ static inline void emc_get_timing(struct tegra_emc *emc, timing->rate = rate / 1000; } +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); + } +} + static void __emc_copy_table_params(struct emc_table *src, struct emc_table *dst, int flags) { @@ -277,6 +493,29 @@ static void __emc_copy_table_params(struct emc_table *src, } } +void tegra210_update_emc_alt_timing(struct tegra_emc *emc, + struct emc_table *current_timing) +{ + struct emc_table *current_table, *alt_timing; + int i; + + if (!emc->emc_table_derated) + return; + + current_table = emc_get_table(emc, dram_over_temp_state); + i = current_timing - current_table; + + WARN_ON(i < 0); + + if (dram_over_temp_state == TEGRA_DRAM_OVER_TEMP_THROTTLE) + alt_timing = &emc->emc_table_normal[i]; + else + alt_timing = &emc->emc_table_derated[i]; + + __emc_copy_table_params(current_timing, alt_timing, + EMC_COPY_TABLE_PARAM_PERIODIC_FIELDS); +} + static void emc_copy_table_params(struct emc_table *src, struct emc_table *dst, int table_size, @@ -288,6 +527,690 @@ static void emc_copy_table_params(struct emc_table *src, __emc_copy_table_params(&src[i], &dst[i], flags); } +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) +{ + #define __RESET_CLKTREE(TBL, C, D, U) \ + (TBL->current_dram_clktree_c ## C ## d ## D ## u ## U = \ + TBL->trained_dram_clktree_c ## C ## d ## D ## u ## U) + + __RESET_CLKTREE(table, 0, 0, 0); + __RESET_CLKTREE(table, 0, 0, 1); + __RESET_CLKTREE(table, 1, 0, 0); + __RESET_CLKTREE(table, 1, 0, 1); + __RESET_CLKTREE(table, 1, 1, 0); + __RESET_CLKTREE(table, 1, 1, 1); +} + +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, burst_regs_off[EMC_REFRESH_INDEX]); + emc_writel(emc, pre_ref, burst_regs_off[EMC_PRE_REFRESH_REQ_CNT_INDEX]); + emc_writel(emc, dsr_cntrl, + burst_regs_off[EMC_DYN_SELF_REF_CONTROL_INDEX]); +} + static void emc_last_stats_update(int last_sel) { unsigned long flags; From patchwork Mon Mar 25 07:45:20 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063888 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="mSNpmRCk"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRLB0wYHz9sSq for ; Mon, 25 Mar 2019 18:52:02 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729875AbfCYHwB (ORCPT ); Mon, 25 Mar 2019 03:52:01 -0400 Received: from hqemgate16.nvidia.com ([216.228.121.65]:16705 "EHLO hqemgate16.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729868AbfCYHwA (ORCPT ); Mon, 25 Mar 2019 03:52:00 -0400 Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by hqemgate16.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:44 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate102.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:46 -0700 X-PGP-Universal: processed; by hqpgpgate102.nvidia.com on Mon, 25 Mar 2019 00:45:46 -0700 Received: from HQMAIL102.nvidia.com (172.18.146.10) by HQMAIL104.nvidia.com (172.18.146.11) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:45 +0000 Received: from HQMAIL107.nvidia.com (172.20.187.13) by HQMAIL102.nvidia.com (172.18.146.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:45 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL107.nvidia.com (172.20.187.13) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:45 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:44 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , "Rob Herring" , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 5/8] memory: tegra: Add EMC scaling sequence code for Tegra210 Date: Mon, 25 Mar 2019 15:45:20 +0800 Message-ID: <20190325074523.26456-6-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499944; bh=LSs56IceIEA/+DaEzuSD8j/dONtBx1tPw6yUwgb6rSs=; 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=mSNpmRCk1xeee6PfJcnPbjtFukxrFjKS6aMosv4mvNmvEeH4MkTpoyGYAuYqRWYEY y5I3zKcx+tYvpoN1CuXUkwzY9/0ro/EL9eN3glC6AOb+M7wXUui30gKpDZw/Kl110B dsgrw03scvsquZCbw/q1Z3LW8CcOzYsg2DGNG04bKibgVW4YwRx5FpqhHrSYtDU7XM q1sjIXi8ExXwcBtqSkx/p/pV9myxL1PYxeS9csT9aJ5J17OdDRt8mALzNUYTbaZuRc YfNPsYbKyYq2auJ8JtBJTiWnkYoVK6X8Wkvl+XKYR04kMxT60vzlNdGNFrGsJgZzR3 s20Z9Mxc9VpbA== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org This patch includes the sequence for controlling the rate changing for EMC frequency and the dynamic training mechanism when the rate reaches the higher rates of EMC rate. And historically there have been different sequences to change the EMC clock. The sequence to be used is specified in the scaling data. 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 . Signed-off-by: Joseph Lo --- drivers/memory/tegra/Makefile | 2 +- drivers/memory/tegra/tegra210-emc-cc-r21021.c | 1962 +++++++++++++++++ drivers/memory/tegra/tegra210-emc-reg.h | 134 ++ drivers/memory/tegra/tegra210-emc.c | 5 + 4 files changed, 2102 insertions(+), 1 deletion(-) create mode 100644 drivers/memory/tegra/tegra210-emc-cc-r21021.c diff --git a/drivers/memory/tegra/Makefile b/drivers/memory/tegra/Makefile index 36a835620bbd..dcc245b2ef45 100644 --- a/drivers/memory/tegra/Makefile +++ b/drivers/memory/tegra/Makefile @@ -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 tegra210-dt-parse.o +obj-$(CONFIG_TEGRA210_EMC) += tegra210-emc.o tegra210-dt-parse.o tegra210-emc-cc-r21021.o obj-$(CONFIG_ARCH_TEGRA_186_SOC) += tegra186.o diff --git a/drivers/memory/tegra/tegra210-emc-cc-r21021.c b/drivers/memory/tegra/tegra210-emc-cc-r21021.c new file mode 100644 index 000000000000..f577a8c3aa95 --- /dev/null +++ b/drivers/memory/tegra/tegra210-emc-cc-r21021.c @@ -0,0 +1,1962 @@ +// SPDX-License-Identifier: GPL-2.0 +/* + * Copyright (c) 2014-2019, NVIDIA CORPORATION. All rights reserved. + */ + +#include +#include +#include +#include +#include +#include + +#include "mc.h" +#include "tegra210-emc-reg.h" + +#define DVFS_CLOCK_CHANGE_VERSION 21021 +#define EMC_PRELOCK_VERSION 2101 + +#define emc_cc_dbg(t, ...) pr_debug(__VA_ARGS__) + +/* + * Enable flags for specifying verbosity. + */ +#define INFO (1 << 0) +#define STEPS (1 << 1) +#define SUB_STEPS (1 << 2) +#define PRELOCK (1 << 3) +#define PRELOCK_STEPS (1 << 4) +#define ACTIVE_EN (1 << 5) +#define PRAMP_UP (1 << 6) +#define PRAMP_DN (1 << 7) +#define EMA_WRITES (1 << 10) +#define EMA_UPDATES (1 << 11) +#define PER_TRAIN (1 << 16) +#define CC_PRINT (1 << 17) +#define CCFIFO (1 << 29) +#define REGS (1 << 30) +#define REG_LISTS (1 << 31) + +enum { + DVFS_SEQUENCE = 1, + WRITE_TRAINING_SEQUENCE = 2, + PERIODIC_TRAINING_SEQUENCE = 3, + DVFS_PT1 = 10, + DVFS_UPDATE = 11, + TRAINING_PT1 = 12, + TRAINING_UPDATE = 13, + PERIODIC_TRAINING_UPDATE = 14 +}; + +/* + * PTFV defines - basically just indexes into the per table PTFV array. + */ +#define PTFV_DQSOSC_MOVAVG_C0D0U0_INDEX 0 +#define PTFV_DQSOSC_MOVAVG_C0D0U1_INDEX 1 +#define PTFV_DQSOSC_MOVAVG_C0D1U0_INDEX 2 +#define PTFV_DQSOSC_MOVAVG_C0D1U1_INDEX 3 +#define PTFV_DQSOSC_MOVAVG_C1D0U0_INDEX 4 +#define PTFV_DQSOSC_MOVAVG_C1D0U1_INDEX 5 +#define PTFV_DQSOSC_MOVAVG_C1D1U0_INDEX 6 +#define PTFV_DQSOSC_MOVAVG_C1D1U1_INDEX 7 +#define PTFV_DVFS_SAMPLES_INDEX 9 +#define PTFV_MOVAVG_WEIGHT_INDEX 10 +#define PTFV_CONFIG_CTRL_INDEX 11 + +#define PTFV_CONFIG_CTRL_USE_PREVIOUS_EMA (1 << 0) + +/* + * Do arithmetic in fixed point. + */ +#define MOVAVG_PRECISION_FACTOR 100 + +/* + * The division portion of the average operation. + */ +#define __AVERAGE_PTFV(dev) \ + ({ next_timing->ptfv_list[PTFV_DQSOSC_MOVAVG_ ## dev ## _INDEX] = \ + next_timing->ptfv_list[PTFV_DQSOSC_MOVAVG_ ## dev ## _INDEX] / \ + next_timing->ptfv_list[PTFV_DVFS_SAMPLES_INDEX]; }) + +/* + * Convert val to fixed point and add it to the temporary average. + */ +#define __INCREMENT_PTFV(dev, val) \ + ({ next_timing->ptfv_list[PTFV_DQSOSC_MOVAVG_ ## dev ## _INDEX] += \ + ((val) * MOVAVG_PRECISION_FACTOR); }) + +/* + * Convert a moving average back to integral form and return the value. + */ +#define __MOVAVG_AC(timing, dev) \ + ((timing)->ptfv_list[PTFV_DQSOSC_MOVAVG_ ## dev ## _INDEX] / \ + MOVAVG_PRECISION_FACTOR) + +/* Weighted update. */ +#define __WEIGHTED_UPDATE_PTFV(dev, nval) \ + do { \ + int w = PTFV_MOVAVG_WEIGHT_INDEX; \ + int dqs = PTFV_DQSOSC_MOVAVG_ ## dev ## _INDEX; \ + \ + next_timing->ptfv_list[dqs] = \ + ((nval * MOVAVG_PRECISION_FACTOR) + \ + (next_timing->ptfv_list[dqs] * \ + next_timing->ptfv_list[w])) / \ + (next_timing->ptfv_list[w] + 1); \ + \ + emc_cc_dbg(EMA_UPDATES, "%s: (s=%u) EMA: %u\n", \ + __stringify(dev), nval, \ + next_timing->ptfv_list[dqs]); \ + } while (0) + +/* Access a particular average. */ +#define __MOVAVG(timing, dev) \ + ((timing)->ptfv_list[PTFV_DQSOSC_MOVAVG_ ## dev ## _INDEX]) + +static u32 update_clock_tree_delay(struct tegra_emc *emc, + u32 dram_dev_num, u32 channel_mode, int type) +{ + u32 mrr_req = 0, mrr_data = 0; + u32 temp0_0 = 0, temp0_1 = 0, temp1_0 = 0, temp1_1 = 0; + s32 tdel = 0, tmdel = 0, adel = 0; + u32 cval = 0; + struct emc_table *last_timing = emc->current_timing; + struct emc_table *next_timing = emc->next_timing; + u32 last_timing_rate_mhz = last_timing->rate / 1000; + u32 next_timing_rate_mhz = next_timing->rate / 1000; + int dvfs_pt1 = type == DVFS_PT1; + int dvfs_update = type == DVFS_UPDATE; + int periodic_training_update = type == PERIODIC_TRAINING_UPDATE; + + /* + * Dev0 MSB. + */ + if (dvfs_pt1 || periodic_training_update) { + mrr_req = (2 << EMC_MRR_DEV_SEL_SHIFT) | + (19 << EMC_MRR_MA_SHIFT); + emc_writel(emc, mrr_req, EMC_MRR); + + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, REG_EMC), + "Timed out waiting for MRR 19 (ch=0)\n"); + if (channel_mode == DUAL_CHANNEL) + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, + REG_EMC1), + "Timed out waiting for MRR 19 (ch=1)\n"); + + mrr_data = (emc_readl(emc, EMC_MRR) & EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + + temp0_0 = (mrr_data & 0xff) << 8; + temp0_1 = mrr_data & 0xff00; + + if (channel_mode == DUAL_CHANNEL) { + mrr_data = (emc1_readl(emc, EMC_MRR) & + EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + temp1_0 = (mrr_data & 0xff) << 8; + temp1_1 = mrr_data & 0xff00; + } + + /* + * Dev0 LSB. + */ + mrr_req = (mrr_req & ~EMC_MRR_MA_MASK) | + (18 << EMC_MRR_MA_SHIFT); + emc_writel(emc, mrr_req, EMC_MRR); + + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, REG_EMC), + "Timed out waiting for MRR 18 (ch=0)\n"); + if (channel_mode == DUAL_CHANNEL) + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, + REG_EMC1), + "Timed out waiting for MRR 18 (ch=1)\n"); + + mrr_data = (emc_readl(emc, EMC_MRR) & EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + + temp0_0 |= mrr_data & 0xff; + temp0_1 |= (mrr_data & 0xff00) >> 8; + + if (channel_mode == DUAL_CHANNEL) { + mrr_data = (emc1_readl(emc, EMC_MRR) & + EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + temp1_0 |= (mrr_data & 0xff); + temp1_1 |= (mrr_data & 0xff00) >> 8; + } + } + + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp0_0); + + if (dvfs_pt1) + __INCREMENT_PTFV(C0D0U0, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C0D0U0); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C0D0U0, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c0d0u0 - + __MOVAVG_AC(next_timing, C0D0U0); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + adel = tmdel; + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c0d0u0 = + __MOVAVG_AC(next_timing, C0D0U0); + } + + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp0_1); + + if (dvfs_pt1) + __INCREMENT_PTFV(C0D0U1, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C0D0U1); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C0D0U1, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c0d0u1 - + __MOVAVG_AC(next_timing, C0D0U1); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c0d0u1 = + __MOVAVG_AC(next_timing, C0D0U1); + } + + if (channel_mode == DUAL_CHANNEL) { + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp1_0); + if (dvfs_pt1) + __INCREMENT_PTFV(C1D0U0, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C1D0U0); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C1D0U0, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c1d0u0 - + __MOVAVG_AC(next_timing, C1D0U0); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c1d0u0 = + __MOVAVG_AC(next_timing, C1D0U0); + } + + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp1_1); + if (dvfs_pt1) + __INCREMENT_PTFV(C1D0U1, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C1D0U1); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C1D0U1, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c1d0u1 - + __MOVAVG_AC(next_timing, C1D0U1); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c1d0u1 = + __MOVAVG_AC(next_timing, C1D0U1); + } + } + + if (emc->dram_dev_num != TWO_RANK) + goto done; + + /* + * Dev1 MSB. + */ + if (dvfs_pt1 || periodic_training_update) { + mrr_req = (1 << EMC_MRR_DEV_SEL_SHIFT) | + (19 << EMC_MRR_MA_SHIFT); + emc_writel(emc, mrr_req, EMC_MRR); + + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, REG_EMC), + "Timed out waiting for MRR 19 (ch=0)\n"); + if (channel_mode == DUAL_CHANNEL) + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, + REG_EMC1), + "Timed out waiting for MRR 19 (ch=1)\n"); + + mrr_data = (emc_readl(emc, EMC_MRR) & EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + + temp0_0 = (mrr_data & 0xff) << 8; + temp0_1 = mrr_data & 0xff00; + + if (channel_mode == DUAL_CHANNEL) { + mrr_data = (emc1_readl(emc, EMC_MRR) & + EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + temp1_0 = (mrr_data & 0xff) << 8; + temp1_1 = mrr_data & 0xff00; + } + + /* + * Dev1 LSB. + */ + mrr_req = (mrr_req & ~EMC_MRR_MA_MASK) | + (18 << EMC_MRR_MA_SHIFT); + emc_writel(emc, mrr_req, EMC_MRR); + + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, REG_EMC), + "Timed out waiting for MRR 18 (ch=0)\n"); + if (channel_mode == DUAL_CHANNEL) + WARN(wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_MRR_DIVLD, 1, + REG_EMC1), + "Timed out waiting for MRR 18 (ch=1)\n"); + + mrr_data = (emc_readl(emc, EMC_MRR) & EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + + temp0_0 |= mrr_data & 0xff; + temp0_1 |= (mrr_data & 0xff00) >> 8; + + if (channel_mode == DUAL_CHANNEL) { + mrr_data = (emc1_readl(emc, EMC_MRR) & + EMC_MRR_DATA_MASK) << + EMC_MRR_DATA_SHIFT; + temp1_0 |= (mrr_data & 0xff); + temp1_1 |= (mrr_data & 0xff00) >> 8; + } + } + + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp0_0); + + if (dvfs_pt1) + __INCREMENT_PTFV(C0D1U0, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C0D1U0); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C0D1U0, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c0d1u0 - + __MOVAVG_AC(next_timing, C0D1U0); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c0d1u0 = + __MOVAVG_AC(next_timing, C0D1U0); + } + + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp0_1); + + if (dvfs_pt1) + __INCREMENT_PTFV(C0D1U1, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C0D1U1); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C0D1U1, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c0d1u1 - + __MOVAVG_AC(next_timing, C0D1U1); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c0d1u1 = + __MOVAVG_AC(next_timing, C0D1U1); + } + + if (channel_mode == DUAL_CHANNEL) { + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp1_0); + + if (dvfs_pt1) + __INCREMENT_PTFV(C1D1U0, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C1D1U0); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C1D1U0, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c1d1u0 - + __MOVAVG_AC(next_timing, C1D1U0); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c1d1u0 = + __MOVAVG_AC(next_timing, C1D1U0); + } + + if (dvfs_pt1 || periodic_training_update) + cval = (1000000 * tegra210_actual_osc_clocks( + last_timing->run_clocks)) / + (last_timing_rate_mhz * 2 * temp1_1); + + if (dvfs_pt1) + __INCREMENT_PTFV(C1D1U1, cval); + else if (dvfs_update) + __AVERAGE_PTFV(C1D1U1); + else if (periodic_training_update) + __WEIGHTED_UPDATE_PTFV(C1D1U1, cval); + + if (dvfs_update || periodic_training_update) { + tdel = next_timing->current_dram_clktree_c1d1u1 - + __MOVAVG_AC(next_timing, C1D1U1); + tmdel = (tdel < 0) ? -1 * tdel : tdel; + if (tmdel > adel) + adel = tmdel; + + if (tmdel * 128 * next_timing_rate_mhz / 1000000 > + next_timing->tree_margin) + next_timing->current_dram_clktree_c1d1u1 = + __MOVAVG_AC(next_timing, C1D1U1); + } + } + +done: + return adel; +} + +static u32 periodic_compensation_handler(struct tegra_emc *emc, u32 type, + u32 dram_dev_num, + u32 channel_mode, + struct emc_table *last_timing, + struct emc_table *next_timing) +{ +#define __COPY_EMA(nt, lt, dev) \ + ({ __MOVAVG(nt, dev) = __MOVAVG(lt, dev) * \ + (nt)->ptfv_list[PTFV_DVFS_SAMPLES_INDEX]; }) + + u32 i; + u32 adel = 0; + u32 samples = next_timing->ptfv_list[PTFV_DVFS_SAMPLES_INDEX]; + u32 delay = 2 + + (1000 * tegra210_actual_osc_clocks(last_timing->run_clocks) / + last_timing->rate); + + if (!next_timing->periodic_training) + return 0; + + if (type == DVFS_SEQUENCE) { + if (last_timing->periodic_training && + (next_timing->ptfv_list[PTFV_CONFIG_CTRL_INDEX] & + PTFV_CONFIG_CTRL_USE_PREVIOUS_EMA)) { + /* + * If the previous frequency was using periodic + * calibration then we can reuse the previous + * frequencies EMA data. + */ + __COPY_EMA(next_timing, last_timing, C0D0U0); + __COPY_EMA(next_timing, last_timing, C0D0U1); + __COPY_EMA(next_timing, last_timing, C1D0U0); + __COPY_EMA(next_timing, last_timing, C1D0U1); + __COPY_EMA(next_timing, last_timing, C0D1U0); + __COPY_EMA(next_timing, last_timing, C0D1U1); + __COPY_EMA(next_timing, last_timing, C1D1U0); + __COPY_EMA(next_timing, last_timing, C1D1U1); + } else { + /* Reset the EMA.*/ + __MOVAVG(next_timing, C0D0U0) = 0; + __MOVAVG(next_timing, C0D0U1) = 0; + __MOVAVG(next_timing, C1D0U0) = 0; + __MOVAVG(next_timing, C1D0U1) = 0; + __MOVAVG(next_timing, C0D1U0) = 0; + __MOVAVG(next_timing, C0D1U1) = 0; + __MOVAVG(next_timing, C1D1U0) = 0; + __MOVAVG(next_timing, C1D1U1) = 0; + + for (i = 0; i < samples; i++) { + tegra210_start_periodic_compensation(emc); + udelay(delay); + + /* + * Generate next sample of data. + */ + adel = update_clock_tree_delay(emc, + emc->dram_dev_num, + channel_mode, + DVFS_PT1); + } + } + + /* + * Seems like it should be part of the + * 'if (last_timing->periodic_training)' conditional + * since is already done for the else clause. + */ + adel = update_clock_tree_delay(emc, + emc->dram_dev_num, + channel_mode, + DVFS_UPDATE); + } + + if (type == PERIODIC_TRAINING_SEQUENCE) { + tegra210_start_periodic_compensation(emc); + udelay(delay); + + adel = update_clock_tree_delay(emc, + emc->dram_dev_num, + channel_mode, + PERIODIC_TRAINING_UPDATE); + } + + return adel; +} + +u32 __do_periodic_emc_compensation_r21021(struct tegra_emc *emc) +{ + u32 dram_dev_num; + u32 channel_mode; + u32 emc_cfg, emc_cfg_o; + u32 emc_dbg_o; + u32 del, i; + u32 list[] = { + 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_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_DATA_BRLSHFT_0, + EMC_DATA_BRLSHFT_1 + }; + u32 items = ARRAY_SIZE(list); + u32 emc_cfg_update; + struct emc_table *current_timing = emc->current_timing; + + if (current_timing->periodic_training) { + channel_mode = + !!(current_timing->burst_regs[EMC_FBIO_CFG7_INDEX] & + (1 << 2)); + dram_dev_num = 1 + (mc_readl(emc->mc, MC_EMEM_ADR_CFG) & 0x1); + + emc_cc_dbg(PER_TRAIN, "Periodic training starting\n"); + + emc_dbg_o = emc_readl(emc, EMC_DBG); + emc_cfg_o = emc_readl(emc, EMC_CFG); + emc_cfg = emc_cfg_o & ~(EMC_CFG_DYN_SELF_REF | + EMC_CFG_DRAM_ACPD | + EMC_CFG_DRAM_CLKSTOP_PD | + EMC_CFG_DRAM_CLKSTOP_PD); + + + /* + * 1. Power optimizations should be off. + */ + emc_writel(emc, emc_cfg, EMC_CFG); + + /* Does emc_timing_update() for above changes. */ + tegra210_dll_disable(emc, channel_mode); + + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_POWERDOWN_MASK, 0, + REG_EMC); + if (channel_mode) + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_POWERDOWN_MASK, + 0, REG_EMC1); + + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_MASK, 0, + REG_EMC); + if (channel_mode) + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_MASK, 0, + REG_EMC1); + + emc_cfg_update = emc_readl(emc, EMC_CFG_UPDATE); + emc_writel(emc, (emc_cfg_update & + ~EMC_CFG_UPDATE_UPDATE_DLL_IN_UPDATE_MASK) | + (2 << EMC_CFG_UPDATE_UPDATE_DLL_IN_UPDATE_SHIFT), + EMC_CFG_UPDATE); + + /* + * 2. osc kick off - this assumes training and dvfs have set + * correct MR23. + */ + tegra210_start_periodic_compensation(emc); + + /* + * 3. Let dram capture its clock tree delays. + */ + udelay((tegra210_actual_osc_clocks(current_timing->run_clocks) * + 1000) / + current_timing->rate + 1); + + /* + * 4. Check delta wrt previous values (save value if margin + * exceeds what is set in table). + */ + del = periodic_compensation_handler(emc, + PERIODIC_TRAINING_SEQUENCE, + dram_dev_num, + channel_mode, + current_timing, + current_timing); + + /* + * 5. Apply compensation w.r.t. trained values (if clock tree + * has drifted more than the set margin). + */ + if (current_timing->tree_margin < + ((del * 128 * (current_timing->rate / 1000)) / 1000000)) { + for (i = 0; i < items; i++) { + u32 tmp = + tegra210_apply_periodic_compensation_trimmer( + current_timing, list[i]); + + emc_cc_dbg(EMA_WRITES, "0x%08x <= 0x%08x\n", + list[i], tmp); + emc_writel(emc, tmp, list[i]); + } + } + + emc_writel(emc, emc_cfg_o, EMC_CFG); + + /* + * 6. Timing update actally applies the new trimmers. + */ + emc_timing_update(emc, channel_mode); + + /* 6.1. Restore the UPDATE_DLL_IN_UPDATE field. */ + emc_writel(emc, emc_cfg_update, EMC_CFG_UPDATE); + + /* 6.2. Restore the DLL. */ + tegra210_dll_enable(emc, channel_mode); + + /* + * 7. Copy over the periodic training registers that we updated + * here to the corresponding derated/non-derated table. + */ + tegra210_update_emc_alt_timing(emc, current_timing); + } + + return 0; +} + +/* + * Do the clock change sequence. + */ +void emc_set_clock_r21021(struct tegra_emc *emc, u32 clksrc) +{ + /* + * This is the timing table for the source frequency. It does _not_ + * necessarily correspond to the actual timing values in the EMC at the + * moment. If the boot BCT differs from the table then this can happen. + * However, we need it for accessing the dram_timings (which are not + * really registers) array for the current frequency. + */ + struct emc_table *fake_timing; + struct emc_table *last_timing = emc->current_timing; + struct emc_table *next_timing = emc->next_timing; + + u32 i, tmp; + + u32 cya_allow_ref_cc = 0, ref_b4_sref_en = 0, cya_issue_pc_ref = 0; + + u32 zqcal_before_cc_cutoff = 2400; /* In picoseconds */ + u32 ref_delay_mult; + u32 ref_delay; + s32 zq_latch_dvfs_wait_time; + s32 tZQCAL_lpddr4_fc_adj; + /* Scaled by x1000 */ + u32 tFC_lpddr4 = 1000 * next_timing->dram_timings[T_FC_LPDDR4]; + u32 tZQCAL_lpddr4 = 1000000; + + u32 dram_type, dram_dev_num, shared_zq_resistor; + u32 channel_mode; + u32 is_lpddr3; + + u32 emc_cfg, emc_sel_dpd_ctrl, emc_cfg_reg; + + u32 emc_dbg; + u32 emc_zcal_interval; + u32 emc_zcal_wait_cnt_old; + u32 emc_zcal_wait_cnt_new; + u32 emc_dbg_active; + u32 zq_op; + u32 zcal_wait_time_clocks; + u32 zcal_wait_time_ps; + + u32 emc_auto_cal_config; + u32 auto_cal_en; + + u32 mr13_catr_enable; + + u32 ramp_up_wait = 0, ramp_down_wait = 0; + + /* In picoseconds. */ + u32 source_clock_period; + u32 destination_clock_period; + + u32 emc_dbg_o; + u32 emc_cfg_pipe_clk_o; + u32 emc_pin_o; + + u32 mr13_flip_fspwr; + u32 mr13_flip_fspop; + + u32 opt_zcal_en_cc; + u32 opt_do_sw_qrst = 1; + u32 opt_dvfs_mode; + u32 opt_dll_mode; + u32 opt_cc_short_zcal = 1; + u32 opt_short_zcal = 1; + u32 save_restore_clkstop_pd = 1; + + u32 prelock_dll_en = 0, dll_out; + + int next_push, next_dq_e_ivref, next_dqs_e_ivref; + + u32 opt_war_200024907; + u32 zq_wait_long; + u32 zq_wait_short; + + u32 bg_regulator_switch_complete_wait_clks; + u32 bg_regulator_mode_change; + u32 enable_bglp_regulator; + u32 enable_bg_regulator; + + u32 tRTM; + u32 RP_war; + u32 R2P_war; + u32 TRPab_war; + s32 nRTP; + u32 deltaTWATM; + u32 W2P_war; + u32 tRPST; + + u32 mrw_req; + u32 adel = 0, compensate_trimmer_applicable = 0; + u32 next_timing_rate_mhz = next_timing->rate / 1000; + + static u32 fsp_for_next_freq; + + emc_cc_dbg(INFO, "Running clock change.\n"); + + fake_timing = get_timing_from_freq(emc, last_timing->rate); + + fsp_for_next_freq = !fsp_for_next_freq; + + dram_type = emc_readl(emc, EMC_FBIO_CFG5) & + EMC_FBIO_CFG5_DRAM_TYPE_MASK >> + EMC_FBIO_CFG5_DRAM_TYPE_SHIFT; + shared_zq_resistor = last_timing->burst_regs[EMC_ZCAL_WAIT_CNT_INDEX] & + 1 << 31; + channel_mode = !!(last_timing->burst_regs[EMC_FBIO_CFG7_INDEX] & + 1 << 2); + opt_zcal_en_cc = (next_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX] && + !last_timing->burst_regs[EMC_ZCAL_INTERVAL_INDEX]) || + dram_type == DRAM_TYPE_LPDDR4; + opt_dll_mode = (dram_type == DRAM_TYPE_DDR3) ? + get_dll_state(next_timing) : DLL_OFF; + is_lpddr3 = (dram_type == DRAM_TYPE_LPDDR2) && + next_timing->burst_regs[EMC_FBIO_CFG5_INDEX] & + 1 << 25; + opt_war_200024907 = (dram_type == DRAM_TYPE_LPDDR4); + opt_dvfs_mode = MAN_SR; + dram_dev_num = (mc_readl(emc->mc, MC_EMEM_ADR_CFG) & 0x1) + 1; + + emc_cfg_reg = emc_readl(emc, EMC_CFG); + emc_auto_cal_config = emc_readl(emc, EMC_AUTO_CAL_CONFIG); + + source_clock_period = 1000000000 / last_timing->rate; + destination_clock_period = 1000000000 / next_timing->rate; + + tZQCAL_lpddr4_fc_adj = (destination_clock_period > + zqcal_before_cc_cutoff) ? + tZQCAL_lpddr4 / destination_clock_period : + (tZQCAL_lpddr4 - tFC_lpddr4) / destination_clock_period; + emc_dbg_o = emc_readl(emc, EMC_DBG); + emc_pin_o = emc_readl(emc, EMC_PIN); + emc_cfg_pipe_clk_o = emc_readl(emc, EMC_CFG_PIPE_CLK); + emc_dbg = emc_dbg_o; + + emc_cfg = next_timing->burst_regs[EMC_CFG_INDEX]; + emc_cfg &= ~(EMC_CFG_DYN_SELF_REF | EMC_CFG_DRAM_ACPD | + EMC_CFG_DRAM_CLKSTOP_SR | EMC_CFG_DRAM_CLKSTOP_PD); + emc_sel_dpd_ctrl = next_timing->emc_sel_dpd_ctrl; + emc_sel_dpd_ctrl &= ~(EMC_SEL_DPD_CTRL_CLK_SEL_DPD_EN | + EMC_SEL_DPD_CTRL_CA_SEL_DPD_EN | + EMC_SEL_DPD_CTRL_RESET_SEL_DPD_EN | + EMC_SEL_DPD_CTRL_ODT_SEL_DPD_EN | + EMC_SEL_DPD_CTRL_DATA_SEL_DPD_EN); + + emc_cc_dbg(INFO, "Clock change version: %d\n", + DVFS_CLOCK_CHANGE_VERSION); + emc_cc_dbg(INFO, "DRAM type = %d\n", emc->dram_type); + emc_cc_dbg(INFO, "DRAM dev #: %d\n", dram_dev_num); + emc_cc_dbg(INFO, "Next EMC clksrc: 0x%08x\n", clksrc); + emc_cc_dbg(INFO, "DLL clksrc: 0x%08x\n", next_timing->dll_clk_src); + emc_cc_dbg(INFO, "last rate: %u, next rate %u\n", last_timing->rate, + next_timing->rate); + emc_cc_dbg(INFO, "last period: %u, next period: %u\n", + source_clock_period, destination_clock_period); + emc_cc_dbg(INFO, " shared_zq_resistor: %d\n", !!shared_zq_resistor); + emc_cc_dbg(INFO, " channel_mode: %d\n", channel_mode); + emc_cc_dbg(INFO, " opt_dll_mode: %d\n", opt_dll_mode); + + /* + * Step 1: + * Pre DVFS SW sequence. + */ + emc_cc_dbg(STEPS, "Step 1\n"); + emc_cc_dbg(STEPS, "Step 1.1: Disable DLL temporarily.\n"); + tmp = emc_readl(emc, EMC_CFG_DIG_DLL); + tmp &= ~EMC_CFG_DIG_DLL_CFG_DLL_EN; + emc_writel(emc, tmp, 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, 0, REG_EMC); + if (channel_mode) + wait_for_update(emc, EMC_CFG_DIG_DLL, + EMC_CFG_DIG_DLL_CFG_DLL_EN, 0, REG_EMC1); + + emc_cc_dbg(STEPS, "Step 1.2: Disable AUTOCAL temporarily.\n"); + emc_auto_cal_config = next_timing->emc_auto_cal_config; + auto_cal_en = emc_auto_cal_config & EMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE; + emc_auto_cal_config &= ~EMC_AUTO_CAL_CONFIG_AUTO_CAL_START; + emc_auto_cal_config |= EMC_AUTO_CAL_CONFIG_AUTO_CAL_MEASURE_STALL; + emc_auto_cal_config |= EMC_AUTO_CAL_CONFIG_AUTO_CAL_UPDATE_STALL; + emc_auto_cal_config |= auto_cal_en; + emc_writel(emc, emc_auto_cal_config, EMC_AUTO_CAL_CONFIG); + emc_readl(emc, EMC_AUTO_CAL_CONFIG); /* Flush write. */ + + emc_cc_dbg(STEPS, "Step 1.3: Disable other power features.\n"); + emc_set_shadow_bypass(emc, ACTIVE); + emc_writel(emc, emc_cfg, EMC_CFG); + emc_writel(emc, emc_sel_dpd_ctrl, EMC_SEL_DPD_CTRL); + emc_set_shadow_bypass(emc, ASSEMBLY); + + if (next_timing->periodic_training) { + tegra210_reset_dram_clktree_values(next_timing); + + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_POWERDOWN_MASK, 0, + REG_EMC); + if (channel_mode) + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_POWERDOWN_MASK, + 0, REG_EMC1); + + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_MASK, 0, + REG_EMC); + if (channel_mode) + wait_for_update(emc, EMC_EMC_STATUS, + EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_MASK, 0, + REG_EMC1); + + tegra210_start_periodic_compensation(emc); + + udelay(((1000 * + tegra210_actual_osc_clocks(last_timing->run_clocks)) / + last_timing->rate) + 2); + adel = periodic_compensation_handler(emc, DVFS_SEQUENCE, + dram_dev_num, + channel_mode, + fake_timing, next_timing); + compensate_trimmer_applicable = + next_timing->periodic_training && + ((adel * 128 * next_timing_rate_mhz) / 1000000) > + next_timing->tree_margin; + } + + emc_writel(emc, EMC_INTSTATUS_CLKCHANGE_COMPLETE, EMC_INTSTATUS); + emc_set_shadow_bypass(emc, ACTIVE); + emc_writel(emc, emc_cfg, EMC_CFG); + emc_writel(emc, emc_sel_dpd_ctrl, EMC_SEL_DPD_CTRL); + emc_writel(emc, emc_cfg_pipe_clk_o | EMC_CFG_PIPE_CLK_CLK_ALWAYS_ON, + EMC_CFG_PIPE_CLK); + emc_writel(emc, next_timing->emc_fdpd_ctrl_cmd_no_ramp & + ~EMC_FDPD_CTRL_CMD_NO_RAMP_CMD_DPD_NO_RAMP_ENABLE, + EMC_FDPD_CTRL_CMD_NO_RAMP); + + bg_regulator_mode_change = + ((next_timing->burst_regs[EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + EMC_PMACRO_BG_BIAS_CTRL_0_BGLP_E_PWRD) ^ + (last_timing->burst_regs[EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + EMC_PMACRO_BG_BIAS_CTRL_0_BGLP_E_PWRD)) || + ((next_timing->burst_regs[EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + EMC_PMACRO_BG_BIAS_CTRL_0_BG_E_PWRD) ^ + (last_timing->burst_regs[EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + EMC_PMACRO_BG_BIAS_CTRL_0_BG_E_PWRD)); + enable_bglp_regulator = + (next_timing->burst_regs[EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + EMC_PMACRO_BG_BIAS_CTRL_0_BGLP_E_PWRD) == 0; + enable_bg_regulator = + (next_timing->burst_regs[EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + EMC_PMACRO_BG_BIAS_CTRL_0_BG_E_PWRD) == 0; + + if (bg_regulator_mode_change) { + if (enable_bg_regulator) + emc_writel(emc, last_timing->burst_regs + [EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + ~EMC_PMACRO_BG_BIAS_CTRL_0_BG_E_PWRD, + EMC_PMACRO_BG_BIAS_CTRL_0); + else + emc_writel(emc, last_timing->burst_regs + [EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + ~EMC_PMACRO_BG_BIAS_CTRL_0_BGLP_E_PWRD, + EMC_PMACRO_BG_BIAS_CTRL_0); + } + + /* Check if we need to turn on VREF generator. */ + if ((((last_timing->burst_regs[EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX] & + EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_E_IVREF) == 0) && + ((next_timing->burst_regs[EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX] & + EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_E_IVREF) == 1)) || + (((last_timing->burst_regs[EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX] & + EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQS_E_IVREF) == 0) && + ((next_timing->burst_regs[EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX] & + EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQS_E_IVREF) == 1))) { + u32 pad_tx_ctrl = + next_timing->burst_regs[EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX]; + u32 last_pad_tx_ctrl = + last_timing->burst_regs[EMC_PMACRO_DATA_PAD_TX_CTRL_INDEX]; + + next_dqs_e_ivref = pad_tx_ctrl & + EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQS_E_IVREF; + next_dq_e_ivref = pad_tx_ctrl & + EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_E_IVREF; + next_push = (last_pad_tx_ctrl & + ~EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_E_IVREF & + ~EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQS_E_IVREF) | + next_dq_e_ivref | next_dqs_e_ivref; + emc_writel(emc, next_push, EMC_PMACRO_DATA_PAD_TX_CTRL); + udelay(1); + } else if (bg_regulator_mode_change) { + udelay(1); + } + + emc_set_shadow_bypass(emc, ASSEMBLY); + + /* + * Step 2: + * Prelock the DLL. + */ + emc_cc_dbg(STEPS, "Step 2\n"); + if (next_timing->burst_regs[EMC_CFG_DIG_DLL_INDEX] & + EMC_CFG_DIG_DLL_CFG_DLL_EN) { + emc_cc_dbg(INFO, "Prelock enabled for target frequency.\n"); + dll_out = tegra210_dll_prelock(emc, 0, clksrc); + emc_cc_dbg(INFO, "DLL out: 0x%03x\n", dll_out); + prelock_dll_en = 1; + } else { + emc_cc_dbg(INFO, "Disabling DLL for target frequency.\n"); + tegra210_dll_disable(emc, channel_mode); + } + + /* + * Step 3: + * Prepare autocal for the clock change. + */ + emc_cc_dbg(STEPS, "Step 3\n"); + emc_set_shadow_bypass(emc, ACTIVE); + emc_writel(emc, next_timing->emc_auto_cal_config2, + EMC_AUTO_CAL_CONFIG2); + emc_writel(emc, next_timing->emc_auto_cal_config3, + EMC_AUTO_CAL_CONFIG3); + emc_writel(emc, next_timing->emc_auto_cal_config4, + EMC_AUTO_CAL_CONFIG4); + emc_writel(emc, next_timing->emc_auto_cal_config5, + EMC_AUTO_CAL_CONFIG5); + emc_writel(emc, next_timing->emc_auto_cal_config6, + EMC_AUTO_CAL_CONFIG6); + emc_writel(emc, next_timing->emc_auto_cal_config7, + EMC_AUTO_CAL_CONFIG7); + emc_writel(emc, next_timing->emc_auto_cal_config8, + EMC_AUTO_CAL_CONFIG8); + emc_set_shadow_bypass(emc, ASSEMBLY); + + emc_auto_cal_config |= (EMC_AUTO_CAL_CONFIG_AUTO_CAL_COMPUTE_START | + auto_cal_en); + emc_writel(emc, emc_auto_cal_config, EMC_AUTO_CAL_CONFIG); + + /* + * Step 4: + * Update EMC_CFG. (??) + */ + emc_cc_dbg(STEPS, "Step 4\n"); + if (source_clock_period > 50000 && dram_type == DRAM_TYPE_LPDDR4) + ccfifo_writel(emc, 1, EMC_SELF_REF, 0); + else + emc_writel(emc, next_timing->emc_cfg_2, EMC_CFG_2); + + /* + * Step 5: + * Prepare reference variables for ZQCAL regs. + */ + emc_cc_dbg(STEPS, "Step 5\n"); + emc_zcal_interval = 0; + emc_zcal_wait_cnt_old = + last_timing->burst_regs[EMC_ZCAL_WAIT_CNT_INDEX]; + emc_zcal_wait_cnt_new = + next_timing->burst_regs[EMC_ZCAL_WAIT_CNT_INDEX]; + emc_zcal_wait_cnt_old &= ~EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_MASK; + emc_zcal_wait_cnt_new &= ~EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_MASK; + + if (dram_type == DRAM_TYPE_LPDDR4) + zq_wait_long = max((u32)1, + div_o3(1000000, destination_clock_period)); + else if (dram_type == DRAM_TYPE_LPDDR2 || is_lpddr3) + zq_wait_long = max(next_timing->min_mrs_wait, + div_o3(360000, destination_clock_period)) + + 4; + else if (dram_type == DRAM_TYPE_DDR3) + zq_wait_long = max((u32)256, + div_o3(320000, destination_clock_period) + + 2); + else + zq_wait_long = 0; + + if (dram_type == DRAM_TYPE_LPDDR2 || is_lpddr3) + zq_wait_short = max(max(next_timing->min_mrs_wait, (u32)6), + div_o3(90000, destination_clock_period)) + + 4; + else if (dram_type == DRAM_TYPE_DDR3) + zq_wait_short = max((u32)64, + div_o3(80000, destination_clock_period)) + + 2; + else + zq_wait_short = 0; + + /* + * Step 6: + * Training code - removed. + */ + emc_cc_dbg(STEPS, "Step 6\n"); + + /* + * Step 7: + * Program FSP reference registers and send MRWs to new FSPWR. + */ + emc_cc_dbg(STEPS, "Step 7\n"); + emc_cc_dbg(SUB_STEPS, "Step 7.1: Bug 200024907 - Patch RP R2P"); + if (opt_war_200024907) { + nRTP = 16; + if (source_clock_period >= 1000000/1866) /* 535.91 ps */ + nRTP = 14; + if (source_clock_period >= 1000000/1600) /* 625.00 ps */ + nRTP = 12; + if (source_clock_period >= 1000000/1333) /* 750.19 ps */ + nRTP = 10; + if (source_clock_period >= 1000000/1066) /* 938.09 ps */ + nRTP = 8; + + deltaTWATM = max_t(u32, div_o3(7500, source_clock_period), 8); + + /* + * Originally there was a + .5 in the tRPST calculation. + * However since we can't do FP in the kernel and the tRTM + * computation was in a floating point ceiling function, adding + * one to tRTP should be ok. There is no other source of non + * integer values, so the result was always going to be + * something for the form: f_ceil(N + .5) = N + 1; + */ + tRPST = ((last_timing->emc_mrw & 0x80) >> 7); + tRTM = fake_timing->dram_timings[RL] + + div_o3(3600, source_clock_period) + + max_t(u32, div_o3(7500, source_clock_period), 8) + + tRPST + 1 + nRTP; + + emc_cc_dbg(INFO, "tRTM = %u, EMC_RP = %u\n", tRTM, + next_timing->burst_regs[EMC_RP_INDEX]); + + if (last_timing->burst_regs[EMC_RP_INDEX] < tRTM) { + if (tRTM > (last_timing->burst_regs[EMC_R2P_INDEX] + + last_timing->burst_regs[EMC_RP_INDEX])) { + R2P_war = tRTM - + last_timing->burst_regs[EMC_RP_INDEX]; + RP_war = last_timing->burst_regs[EMC_RP_INDEX]; + TRPab_war = last_timing->burst_regs[ + EMC_TRPAB_INDEX]; + if (R2P_war > 63) { + RP_war = R2P_war + + last_timing->burst_regs[ + EMC_RP_INDEX] - 63; + if (TRPab_war < RP_war) + TRPab_war = RP_war; + R2P_war = 63; + } + } else { + R2P_war = last_timing->burst_regs[ + EMC_R2P_INDEX]; + RP_war = last_timing->burst_regs[EMC_RP_INDEX]; + TRPab_war = last_timing->burst_regs[ + EMC_TRPAB_INDEX]; + } + + if (RP_war < deltaTWATM) { + W2P_war = last_timing->burst_regs[EMC_W2P_INDEX] + + deltaTWATM - RP_war; + if (W2P_war > 63) { + RP_war = RP_war + W2P_war - 63; + if (TRPab_war < RP_war) + TRPab_war = RP_war; + W2P_war = 63; + } + } else { + W2P_war = last_timing->burst_regs[ + EMC_W2P_INDEX]; + } + + if ((last_timing->burst_regs[EMC_W2P_INDEX] ^ + W2P_war) || + (last_timing->burst_regs[EMC_R2P_INDEX] ^ + R2P_war) || + (last_timing->burst_regs[EMC_RP_INDEX] ^ + RP_war) || + (last_timing->burst_regs[EMC_TRPAB_INDEX] ^ + TRPab_war)) { + emc_writel(emc, RP_war, EMC_RP); + emc_writel(emc, R2P_war, EMC_R2P); + emc_writel(emc, W2P_war, EMC_W2P); + emc_writel(emc, TRPab_war, EMC_TRPAB); + } + emc_timing_update(emc, DUAL_CHANNEL); + } else { + emc_cc_dbg(INFO, "Skipped WAR\n"); + } + } + + if (!fsp_for_next_freq) { + mr13_flip_fspwr = (next_timing->emc_mrw3 & 0xffffff3f) | 0x80; + mr13_flip_fspop = (next_timing->emc_mrw3 & 0xffffff3f) | 0x00; + } else { + mr13_flip_fspwr = (next_timing->emc_mrw3 & 0xffffff3f) | 0x40; + mr13_flip_fspop = (next_timing->emc_mrw3 & 0xffffff3f) | 0xc0; + } + + mr13_catr_enable = (mr13_flip_fspwr & 0xFFFFFFFE) | 0x01; + if (dram_dev_num == TWO_RANK) + mr13_catr_enable = (mr13_catr_enable & 0x3fffffff) | 0x80000000; + + if (dram_type == DRAM_TYPE_LPDDR4) { + emc_writel(emc, mr13_flip_fspwr, EMC_MRW3); + emc_writel(emc, next_timing->emc_mrw, EMC_MRW); + emc_writel(emc, next_timing->emc_mrw2, EMC_MRW2); + } + + /* + * Step 8: + * Program the shadow registers. + */ + emc_cc_dbg(STEPS, "Step 8\n"); + emc_cc_dbg(SUB_STEPS, "Writing burst_regs\n"); + for (i = 0; i < next_timing->num_burst; i++) { + u32 var; + u32 wval; + + if (!burst_regs_off[i]) + continue; + + var = burst_regs_off[i]; + wval = next_timing->burst_regs[i]; + + if (dram_type != DRAM_TYPE_LPDDR4 && + (var == EMC_MRW6 || var == EMC_MRW7 || + var == EMC_MRW8 || var == EMC_MRW9 || + var == EMC_MRW10 || var == EMC_MRW11 || + var == EMC_MRW12 || var == EMC_MRW13 || + var == EMC_MRW14 || var == EMC_MRW15 || + var == EMC_TRAINING_CTRL)) + continue; + + /* Pain... And suffering. */ + if (var == EMC_CFG) { + wval &= ~EMC_CFG_DRAM_ACPD; + wval &= ~EMC_CFG_DYN_SELF_REF; + if (dram_type == DRAM_TYPE_LPDDR4) { + wval &= ~EMC_CFG_DRAM_CLKSTOP_SR; + wval &= ~EMC_CFG_DRAM_CLKSTOP_PD; + } + } else if (var == EMC_MRS_WAIT_CNT && + dram_type == DRAM_TYPE_LPDDR2 && + opt_zcal_en_cc && !opt_cc_short_zcal && + opt_short_zcal) { + wval = (wval & ~(EMC_MRS_WAIT_CNT_SHORT_WAIT_MASK << + EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT)) | + ((zq_wait_long & EMC_MRS_WAIT_CNT_SHORT_WAIT_MASK) << + EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT); + } else if (var == EMC_ZCAL_WAIT_CNT && + dram_type == DRAM_TYPE_DDR3 && opt_zcal_en_cc && + !opt_cc_short_zcal && opt_short_zcal) { + wval = (wval & ~(EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_MASK << + EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_SHIFT)) + | ((zq_wait_long & + EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_MASK) << + EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT); + } else if (var == EMC_ZCAL_INTERVAL && opt_zcal_en_cc) { + wval = 0; /* EMC_ZCAL_INTERVAL reset value. */ + } else if (var == EMC_PMACRO_AUTOCAL_CFG_COMMON) { + wval |= EMC_PMACRO_AUTOCAL_CFG_COMMON_E_CAL_BYPASS_DVFS; + } else if (var == EMC_PMACRO_DATA_PAD_TX_CTRL) { + wval &= + ~(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); + } else if (var == EMC_PMACRO_CMD_PAD_TX_CTRL) { + wval |= EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_DRVFORCEON; + wval &= ~(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); + } else if (var == EMC_PMACRO_BRICK_CTRL_RFU1) { + wval &= 0xf800f800; + } else if (var == EMC_PMACRO_COMMON_PAD_TX_CTRL) { + wval &= 0xfffffff0; + } + + emc_writel(emc, wval, var); + } + + /* SW addition: do EMC refresh adjustment here. */ + set_over_temp_timing(emc, next_timing, dram_over_temp_state); + + if (dram_type == DRAM_TYPE_LPDDR4) { + mrw_req = (23 << EMC_MRW_MRW_MA_SHIFT) | + (next_timing->run_clocks & EMC_MRW_MRW_OP_MASK); + emc_writel(emc, mrw_req, EMC_MRW); + } + + /* Per channel burst registers. */ + emc_cc_dbg(SUB_STEPS, "Writing burst_regs_per_ch\n"); + for (i = 0; i < next_timing->num_burst_per_ch; i++) { + if (!burst_regs_per_ch_off[i]) + continue; + + if (dram_type != DRAM_TYPE_LPDDR4 && + (burst_regs_per_ch_off[i] == EMC_MRW6 || + burst_regs_per_ch_off[i] == EMC_MRW7 || + burst_regs_per_ch_off[i] == EMC_MRW8 || + burst_regs_per_ch_off[i] == EMC_MRW9 || + burst_regs_per_ch_off[i] == EMC_MRW10 || + burst_regs_per_ch_off[i] == EMC_MRW11 || + burst_regs_per_ch_off[i] == EMC_MRW12 || + burst_regs_per_ch_off[i] == EMC_MRW13 || + burst_regs_per_ch_off[i] == EMC_MRW14 || + burst_regs_per_ch_off[i] == EMC_MRW15)) + continue; + + /* Filter out second channel if not in DUAL_CHANNEL mode. */ + if (channel_mode != DUAL_CHANNEL && + burst_regs_per_ch_type[i] >= REG_EMC1) + continue; + + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, next_timing->burst_reg_per_ch[i], + burst_regs_per_ch_off[i]); + emc_writel_per_ch(emc, next_timing->burst_reg_per_ch[i], + burst_regs_per_ch_type[i], + burst_regs_per_ch_off[i]); + } + + /* Vref regs. */ + emc_cc_dbg(SUB_STEPS, "Writing vref_regs\n"); + for (i = 0; i < next_timing->vref_num; i++) { + if (!vref_regs_per_ch_off[i]) + continue; + + if (channel_mode != DUAL_CHANNEL && + vref_regs_per_ch_type[i] >= REG_EMC1) + continue; + + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, next_timing->vref_perch_regs[i], + vref_regs_per_ch_off[i]); + emc_writel_per_ch(emc, next_timing->vref_perch_regs[i], + vref_regs_per_ch_type[i], + vref_regs_per_ch_off[i]); + } + + /* Trimmers. */ + emc_cc_dbg(SUB_STEPS, "Writing trim_regs\n"); + for (i = 0; i < next_timing->num_trim; i++) { + u64 trim_reg; + + if (!trim_regs_off[i]) + continue; + + trim_reg = trim_regs_off[i]; + if (compensate_trimmer_applicable && + (trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 || + trim_reg == EMC_DATA_BRLSHFT_0 || + trim_reg == EMC_DATA_BRLSHFT_1)) { + u32 reg = tegra210_apply_periodic_compensation_trimmer( + next_timing, trim_reg); + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", i, reg, + trim_regs_off[i]); + emc_cc_dbg(EMA_WRITES, "0x%08x <= 0x%08x\n", + (u32)(u64)trim_regs_off[i], reg); + emc_writel(emc, reg, trim_regs_off[i]); + } else { + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, next_timing->trim_regs[i], + trim_regs_off[i]); + emc_writel(emc, next_timing->trim_regs[i], + trim_regs_off[i]); + } + } + + /* Per channel trimmers. */ + emc_cc_dbg(SUB_STEPS, "Writing trim_regs_per_ch\n"); + for (i = 0; i < next_timing->num_trim_per_ch; i++) { + u32 trim_reg; + + if (!trim_regs_per_ch_off[i]) + continue; + + if (channel_mode != DUAL_CHANNEL && + trim_regs_per_ch_type[i] >= REG_EMC1) + continue; + + trim_reg = trim_regs_per_ch_off[i]; + if (compensate_trimmer_applicable && + (trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_0 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_1 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_2 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK0_3 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_0 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_1 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_2 || + trim_reg == EMC_PMACRO_OB_DDLL_LONG_DQ_RANK1_3 || + trim_reg == EMC_DATA_BRLSHFT_0 || + trim_reg == EMC_DATA_BRLSHFT_1)) { + u32 reg = + tegra210_apply_periodic_compensation_trimmer( + next_timing, trim_reg); + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, reg, trim_regs_per_ch_off[i]); + emc_cc_dbg(EMA_WRITES, "0x%08x <= 0x%08x\n", + trim_regs_per_ch_off[i], reg); + emc_writel_per_ch(emc, reg, trim_regs_per_ch_type[i], + trim_regs_per_ch_off[i]); + } else { + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, next_timing->trim_perch_regs[i], + trim_regs_per_ch_off[i]); + emc_writel_per_ch(emc, next_timing->trim_perch_regs[i], + trim_regs_per_ch_type[i], + trim_regs_per_ch_off[i]); + } + } + + emc_cc_dbg(SUB_STEPS, "Writing burst_mc_regs\n"); + for (i = 0; i < next_timing->num_mc_regs; i++) { + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, next_timing->burst_mc_regs[i], + burst_mc_regs_off[i]); + mc_writel(emc->mc, next_timing->burst_mc_regs[i], + burst_mc_regs_off[i]); + } + + /* Registers to be programmed on the faster clock. */ + if (next_timing->rate < last_timing->rate) { + emc_cc_dbg(SUB_STEPS, "Writing la_scale_regs\n"); + for (i = 0; i < next_timing->num_up_down; i++) { + emc_cc_dbg(REG_LISTS, "(%u) 0x%08x => 0x%08x\n", + i, next_timing->la_scale_regs[i], + la_scale_regs_off[i]); + mc_writel(emc->mc, next_timing->la_scale_regs[i], + la_scale_regs_off[i]); + } + } + + /* Flush all the burst register writes. */ + wmb(); + + /* + * Step 9: + * LPDDR4 section A. + */ + emc_cc_dbg(STEPS, "Step 9\n"); + if (dram_type == DRAM_TYPE_LPDDR4) { + emc_writel(emc, emc_zcal_interval, EMC_ZCAL_INTERVAL); + emc_writel(emc, emc_zcal_wait_cnt_new, EMC_ZCAL_WAIT_CNT); + + emc_dbg |= (EMC_DBG_WRITE_MUX_ACTIVE | + EMC_DBG_WRITE_ACTIVE_ONLY); + + emc_writel(emc, emc_dbg, EMC_DBG); + emc_writel(emc, emc_zcal_interval, EMC_ZCAL_INTERVAL); + emc_writel(emc, emc_dbg_o, EMC_DBG); + } + + /* + * Step 10: + * LPDDR4 and DDR3 common section. + */ + emc_cc_dbg(STEPS, "Step 10\n"); + if (opt_dvfs_mode == MAN_SR || dram_type == DRAM_TYPE_LPDDR4) { + if (dram_type == DRAM_TYPE_LPDDR4) + ccfifo_writel(emc, 0x101, EMC_SELF_REF, 0); + else + ccfifo_writel(emc, 0x1, EMC_SELF_REF, 0); + + if (dram_type == DRAM_TYPE_LPDDR4 && + destination_clock_period <= zqcal_before_cc_cutoff) { + ccfifo_writel(emc, mr13_flip_fspwr ^ 0x40, EMC_MRW3, 0); + ccfifo_writel(emc, + (next_timing->burst_regs[EMC_MRW6_INDEX] & + 0xFFFF3F3F) | + (last_timing->burst_regs[EMC_MRW6_INDEX] & + 0x0000C0C0), EMC_MRW6, 0); + ccfifo_writel(emc, + (next_timing->burst_regs[EMC_MRW14_INDEX] + & 0xFFFF0707) | + (last_timing->burst_regs[EMC_MRW14_INDEX] + & 0x00003838), EMC_MRW14, 0); + + if (dram_dev_num == TWO_RANK) { + ccfifo_writel(emc, + (next_timing->burst_regs[EMC_MRW7_INDEX] & + 0xFFFF3F3F) | + (last_timing->burst_regs[EMC_MRW7_INDEX] & + 0x0000C0C0), EMC_MRW7, 0); + ccfifo_writel(emc, + (next_timing->burst_regs[EMC_MRW15_INDEX] & + 0xFFFF0707) | + (last_timing->burst_regs[EMC_MRW15_INDEX] & + 0x00003838), EMC_MRW15, 0); + } + + if (opt_zcal_en_cc) { + if (dram_dev_num == ONE_RANK) + ccfifo_writel(emc, + 2UL << EMC_ZQ_CAL_DEV_SEL_SHIFT + | EMC_ZQ_CAL_ZQ_CAL_CMD, + EMC_ZQ_CAL, 0); + else if (shared_zq_resistor) + ccfifo_writel(emc, + 2UL << EMC_ZQ_CAL_DEV_SEL_SHIFT + | EMC_ZQ_CAL_ZQ_CAL_CMD, + EMC_ZQ_CAL, 0); + else + ccfifo_writel(emc, + EMC_ZQ_CAL_ZQ_CAL_CMD, + EMC_ZQ_CAL, 0); + } + } + } + + emc_dbg = emc_dbg_o; + if (dram_type == DRAM_TYPE_LPDDR4) { + ccfifo_writel(emc, mr13_flip_fspop | 0x8, EMC_MRW3, + (1000 * fake_timing->dram_timings[T_RP]) / + source_clock_period); + ccfifo_writel(emc, 0, 0, tFC_lpddr4 / source_clock_period); + } + + if (dram_type == DRAM_TYPE_LPDDR4 || opt_dvfs_mode != MAN_SR) { + u32 t = 30 + (cya_allow_ref_cc ? + (4000 * fake_timing->dram_timings[T_RFC]) + + ((1000 * fake_timing->dram_timings[T_RP]) / + source_clock_period) : 0); + + ccfifo_writel(emc, emc_pin_o & ~(EMC_PIN_PIN_CKE_PER_DEV | + EMC_PIN_PIN_CKEB | EMC_PIN_PIN_CKE), + EMC_PIN, t); + } + + ref_delay_mult = 1; + ref_b4_sref_en = 0; + cya_issue_pc_ref = 0; + + ref_delay_mult += ref_b4_sref_en ? 1 : 0; + ref_delay_mult += cya_allow_ref_cc ? 1 : 0; + ref_delay_mult += cya_issue_pc_ref ? 1 : 0; + ref_delay = ref_delay_mult * + ((1000 * fake_timing->dram_timings[T_RP] / + source_clock_period) + + (1000 * fake_timing->dram_timings[T_RFC] / + source_clock_period)) + 20; + + /* + * Step 11: + * Ramp down. + */ + emc_cc_dbg(STEPS, "Step 11\n"); + ccfifo_writel(emc, 0x0, EMC_CFG_SYNC, + dram_type == DRAM_TYPE_LPDDR4 ? 0 : ref_delay); + + emc_dbg_active = emc_dbg | (EMC_DBG_WRITE_MUX_ACTIVE | + EMC_DBG_WRITE_ACTIVE_ONLY); + ccfifo_writel(emc, emc_dbg_active, EMC_DBG, 0); + + ramp_down_wait = tegra210_dvfs_power_ramp_down(emc, + source_clock_period, 0); + + /* + * Step 12: + * And finally - trigger the clock change. + */ + emc_cc_dbg(STEPS, "Step 12\n"); + ccfifo_writel(emc, 1, EMC_STALL_THEN_EXE_AFTER_CLKCHANGE, 0); + emc_dbg_active &= ~EMC_DBG_WRITE_ACTIVE_ONLY; + ccfifo_writel(emc, emc_dbg_active, EMC_DBG, 0); + + /* + * Step 13: + * Ramp up. + */ + emc_cc_dbg(STEPS, "Step 13\n"); + ramp_up_wait = tegra210_dvfs_power_ramp_up(emc, + destination_clock_period, 0); + ccfifo_writel(emc, emc_dbg, EMC_DBG, 0); + + /* + * Step 14: + * Bringup CKE pins. + */ + emc_cc_dbg(STEPS, "Step 14\n"); + if (dram_type == DRAM_TYPE_LPDDR4) { + u32 r = emc_pin_o | EMC_PIN_PIN_CKE; + + if (dram_dev_num == TWO_RANK) + ccfifo_writel(emc, r | EMC_PIN_PIN_CKEB | + EMC_PIN_PIN_CKE_PER_DEV, EMC_PIN, 0); + else + ccfifo_writel(emc, r & ~(EMC_PIN_PIN_CKEB | + EMC_PIN_PIN_CKE_PER_DEV), EMC_PIN, 0); + } + + /* + * Step 15: (two step 15s ??) + * Calculate zqlatch wait time; has dependency on ramping times. + */ + emc_cc_dbg(STEPS, "Step 15\n"); + + if (destination_clock_period <= zqcal_before_cc_cutoff) { + s32 t = (s32)(ramp_up_wait + ramp_down_wait) / + (s32)destination_clock_period; + zq_latch_dvfs_wait_time = (s32)tZQCAL_lpddr4_fc_adj - t; + } else { + zq_latch_dvfs_wait_time = tZQCAL_lpddr4_fc_adj - + div_o3(1000 * next_timing->dram_timings[T_PDEX], + destination_clock_period); + } + + emc_cc_dbg(INFO, "tZQCAL_lpddr4_fc_adj = %u\n", tZQCAL_lpddr4_fc_adj); + emc_cc_dbg(INFO, "destination_clock_period = %u\n", + destination_clock_period); + emc_cc_dbg(INFO, "next_timing->dram_timings[T_PDEX] = %u\n", + next_timing->dram_timings[T_PDEX]); + emc_cc_dbg(INFO, "zq_latch_dvfs_wait_time = %d\n", + max_t(s32, 0, zq_latch_dvfs_wait_time)); + + if (dram_type == DRAM_TYPE_LPDDR4 && opt_zcal_en_cc) { + if (dram_dev_num == ONE_RANK) { + if (destination_clock_period > zqcal_before_cc_cutoff) + ccfifo_writel(emc, + 2UL << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_CAL_CMD, EMC_ZQ_CAL, + div_o3(1000 * + next_timing->dram_timings + [T_PDEX], + destination_clock_period)); + + ccfifo_writel(emc, (mr13_flip_fspop & 0xFFFFFFF7) | + 0x0C000000, EMC_MRW3, + div_o3(1000 * + next_timing->dram_timings[T_PDEX], + destination_clock_period)); + ccfifo_writel(emc, 0, EMC_SELF_REF, 0); + ccfifo_writel(emc, 0, EMC_REF, 0); + ccfifo_writel(emc, 2UL << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_LATCH_CMD, + EMC_ZQ_CAL, + max_t(s32, 0, zq_latch_dvfs_wait_time)); + } else if (shared_zq_resistor) { + if (destination_clock_period > zqcal_before_cc_cutoff) + ccfifo_writel(emc, + 2UL << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_CAL_CMD, EMC_ZQ_CAL, + div_o3(1000 * + next_timing->dram_timings + [T_PDEX], + destination_clock_period)); + + ccfifo_writel(emc, 2UL << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_LATCH_CMD, EMC_ZQ_CAL, + max_t(s32, 0, zq_latch_dvfs_wait_time) + + div_o3(1000 * + next_timing->dram_timings[T_PDEX], + destination_clock_period)); + ccfifo_writel(emc, 1UL << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_LATCH_CMD, + EMC_ZQ_CAL, 0); + + ccfifo_writel(emc, (mr13_flip_fspop & 0xfffffff7) | + 0x0c000000, EMC_MRW3, 0); + ccfifo_writel(emc, 0, EMC_SELF_REF, 0); + ccfifo_writel(emc, 0, EMC_REF, 0); + + ccfifo_writel(emc, 1UL << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_LATCH_CMD, EMC_ZQ_CAL, + tZQCAL_lpddr4 / destination_clock_period); + } else { + if (destination_clock_period > zqcal_before_cc_cutoff) + ccfifo_writel(emc, EMC_ZQ_CAL_ZQ_CAL_CMD, + EMC_ZQ_CAL, + div_o3(1000 * + next_timing->dram_timings + [T_PDEX], + destination_clock_period)); + + ccfifo_writel(emc, (mr13_flip_fspop & 0xfffffff7) | + 0x0c000000, EMC_MRW3, + div_o3(1000 * + next_timing->dram_timings[T_PDEX], + destination_clock_period)); + ccfifo_writel(emc, 0, EMC_SELF_REF, 0); + ccfifo_writel(emc, 0, EMC_REF, 0); + + ccfifo_writel(emc, EMC_ZQ_CAL_ZQ_LATCH_CMD, EMC_ZQ_CAL, + max_t(s32, 0, zq_latch_dvfs_wait_time)); + } + } + + /* WAR: delay for zqlatch */ + ccfifo_writel(emc, 0, 0, 10); + + /* + * Step 16: + * LPDDR4 Conditional Training Kickoff. Removed. + */ + + /* + * Step 17: + * MANSR exit self refresh. + */ + emc_cc_dbg(STEPS, "Step 17\n"); + if (opt_dvfs_mode == MAN_SR && dram_type != DRAM_TYPE_LPDDR4) + ccfifo_writel(emc, 0, EMC_SELF_REF, 0); + + /* + * Step 18: + * Send MRWs to LPDDR3/DDR3. + */ + emc_cc_dbg(STEPS, "Step 18\n"); + if (dram_type == DRAM_TYPE_LPDDR2) { + ccfifo_writel(emc, next_timing->emc_mrw2, EMC_MRW2, 0); + ccfifo_writel(emc, next_timing->emc_mrw, EMC_MRW, 0); + if (is_lpddr3) + ccfifo_writel(emc, next_timing->emc_mrw4, EMC_MRW4, 0); + } else if (dram_type == DRAM_TYPE_DDR3) { + if (opt_dll_mode == DLL_ON) + ccfifo_writel(emc, next_timing->emc_emrs & + ~EMC_EMRS_USE_EMRS_LONG_CNT, EMC_EMRS, 0); + ccfifo_writel(emc, next_timing->emc_emrs2 & + ~EMC_EMRS2_USE_EMRS2_LONG_CNT, EMC_EMRS2, 0); + ccfifo_writel(emc, next_timing->emc_mrs | + EMC_EMRS_USE_EMRS_LONG_CNT, EMC_MRS, 0); + } + + /* + * Step 19: + * ZQCAL for LPDDR3/DDR3 + */ + emc_cc_dbg(STEPS, "Step 19\n"); + if (opt_zcal_en_cc) { + if (dram_type == DRAM_TYPE_LPDDR2) { + u32 r; + + zq_op = opt_cc_short_zcal ? 0x56 : 0xAB; + zcal_wait_time_ps = opt_cc_short_zcal ? 90000 : 360000; + zcal_wait_time_clocks = div_o3(zcal_wait_time_ps, + destination_clock_period); + r = zcal_wait_time_clocks << + EMC_MRS_WAIT_CNT2_MRS_EXT2_WAIT_CNT_SHIFT | + zcal_wait_time_clocks << + EMC_MRS_WAIT_CNT2_MRS_EXT1_WAIT_CNT_SHIFT; + ccfifo_writel(emc, r, EMC_MRS_WAIT_CNT2, 0); + ccfifo_writel(emc, 2 << EMC_MRW_MRW_DEV_SELECTN_SHIFT | + EMC_MRW_USE_MRW_EXT_CNT | + 10 << EMC_MRW_MRW_MA_SHIFT | + zq_op << EMC_MRW_MRW_OP_SHIFT, + EMC_MRW, 0); + if (dram_dev_num == TWO_RANK) { + r = 1 << EMC_MRW_MRW_DEV_SELECTN_SHIFT | + EMC_MRW_USE_MRW_EXT_CNT | + 10 << EMC_MRW_MRW_MA_SHIFT | + zq_op << EMC_MRW_MRW_OP_SHIFT; + ccfifo_writel(emc, r, EMC_MRW, 0); + } + } else if (dram_type == DRAM_TYPE_DDR3) { + zq_op = opt_cc_short_zcal ? 0 : EMC_ZQ_CAL_LONG; + ccfifo_writel(emc, zq_op | 2 << + EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_CAL_CMD, EMC_ZQ_CAL, 0); + if (dram_dev_num == TWO_RANK) + ccfifo_writel(emc, zq_op | + 1 << EMC_ZQ_CAL_DEV_SEL_SHIFT | + EMC_ZQ_CAL_ZQ_CAL_CMD, + EMC_ZQ_CAL, 0); + } + } + + if (bg_regulator_mode_change) { + emc_set_shadow_bypass(emc, ACTIVE); + bg_regulator_switch_complete_wait_clks = + ramp_up_wait > 1250000 ? 0 : + (1250000 - ramp_up_wait) / destination_clock_period; + ccfifo_writel(emc, next_timing->burst_regs + [EMC_PMACRO_BG_BIAS_CTRL_0_INDEX], + EMC_PMACRO_BG_BIAS_CTRL_0, + bg_regulator_switch_complete_wait_clks); + emc_set_shadow_bypass(emc, ASSEMBLY); + } + + /* + * Step 20: + * Issue ref and optional QRST. + */ + emc_cc_dbg(STEPS, "Step 20\n"); + if (dram_type != DRAM_TYPE_LPDDR4) + ccfifo_writel(emc, 0, EMC_REF, 0); + + if (opt_do_sw_qrst) { + ccfifo_writel(emc, 1, EMC_ISSUE_QRST, 0); + ccfifo_writel(emc, 0, EMC_ISSUE_QRST, 2); + } + + /* + * Step 21: + * Restore ZCAL and ZCAL interval. + */ + emc_cc_dbg(STEPS, "Step 21\n"); + if (save_restore_clkstop_pd || opt_zcal_en_cc) { + ccfifo_writel(emc, emc_dbg_o | EMC_DBG_WRITE_MUX_ACTIVE, + EMC_DBG, 0); + if (opt_zcal_en_cc && dram_type != DRAM_TYPE_LPDDR4) + ccfifo_writel(emc, next_timing->burst_regs[ + EMC_ZCAL_INTERVAL_INDEX], + EMC_ZCAL_INTERVAL, 0); + + if (save_restore_clkstop_pd) + ccfifo_writel(emc, + next_timing->burst_regs[EMC_CFG_INDEX] & + ~EMC_CFG_DYN_SELF_REF, EMC_CFG, 0); + ccfifo_writel(emc, emc_dbg_o, EMC_DBG, 0); + } + + /* + * Step 22: + * Restore EMC_CFG_PIPE_CLK. + */ + emc_cc_dbg(STEPS, "Step 22\n"); + ccfifo_writel(emc, emc_cfg_pipe_clk_o, EMC_CFG_PIPE_CLK, 0); + + if (bg_regulator_mode_change) { + if (enable_bg_regulator) + emc_writel(emc, next_timing->burst_regs[ + EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + ~EMC_PMACRO_BG_BIAS_CTRL_0_BGLP_E_PWRD, + EMC_PMACRO_BG_BIAS_CTRL_0); + else + emc_writel(emc, next_timing->burst_regs[ + EMC_PMACRO_BG_BIAS_CTRL_0_INDEX] & + ~EMC_PMACRO_BG_BIAS_CTRL_0_BG_E_PWRD, + EMC_PMACRO_BG_BIAS_CTRL_0); + } + + /* + * Step 23: + */ + emc_cc_dbg(STEPS, "Step 23\n"); + + tmp = emc_readl(emc, EMC_CFG_DIG_DLL); + tmp |= EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_TRAFFIC; + tmp &= ~EMC_CFG_DIG_DLL_CFG_DLL_STALL_RW_UNTIL_LOCK; + tmp &= ~EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_UNTIL_LOCK; + tmp &= ~EMC_CFG_DIG_DLL_CFG_DLL_EN; + tmp = (tmp & ~EMC_CFG_DIG_DLL_CFG_DLL_MODE_MASK) | + (2 << EMC_CFG_DIG_DLL_CFG_DLL_MODE_SHIFT); + emc_writel(emc, tmp, EMC_CFG_DIG_DLL); + + do_clock_change(emc, clksrc); + + /* + * Step 24: + * Save training results. Removed. + */ + + /* + * Step 25: + * Program MC updown registers. + */ + emc_cc_dbg(STEPS, "Step 25\n"); + + if (next_timing->rate > last_timing->rate) { + for (i = 0; i < next_timing->num_up_down; i++) + mc_writel(emc->mc, next_timing->la_scale_regs[i], + la_scale_regs_off[i]); + emc_timing_update(emc, channel_mode); + } + + /* + * Step 26: + * Restore ZCAL registers. + */ + emc_cc_dbg(STEPS, "Step 26\n"); + if (dram_type == DRAM_TYPE_LPDDR4) { + emc_set_shadow_bypass(emc, ACTIVE); + emc_writel(emc, next_timing->burst_regs[ + EMC_ZCAL_WAIT_CNT_INDEX], EMC_ZCAL_WAIT_CNT); + emc_writel(emc, next_timing->burst_regs[ + EMC_ZCAL_INTERVAL_INDEX], EMC_ZCAL_INTERVAL); + emc_set_shadow_bypass(emc, ASSEMBLY); + } + + if (dram_type != DRAM_TYPE_LPDDR4 && + opt_zcal_en_cc && !opt_short_zcal && opt_cc_short_zcal) { + udelay(2); + + emc_set_shadow_bypass(emc, ACTIVE); + if (dram_type == DRAM_TYPE_LPDDR2) + emc_writel(emc, next_timing->burst_regs[ + EMC_MRS_WAIT_CNT_INDEX], EMC_MRS_WAIT_CNT); + else if (dram_type == DRAM_TYPE_DDR3) + emc_writel(emc, next_timing->burst_regs[ + EMC_ZCAL_WAIT_CNT_INDEX], EMC_ZCAL_WAIT_CNT); + emc_set_shadow_bypass(emc, ASSEMBLY); + } + + /* + * Step 27: + * Restore EMC_CFG, FDPD registers. + */ + emc_cc_dbg(STEPS, "Step 27\n"); + emc_set_shadow_bypass(emc, ACTIVE); + emc_writel(emc, next_timing->burst_regs[EMC_CFG_INDEX], EMC_CFG); + emc_set_shadow_bypass(emc, ASSEMBLY); + emc_writel(emc, next_timing->emc_fdpd_ctrl_cmd_no_ramp, + EMC_FDPD_CTRL_CMD_NO_RAMP); + emc_writel(emc, next_timing->emc_sel_dpd_ctrl, EMC_SEL_DPD_CTRL); + + /* + * Step 28: + * Training recover. Removed. + */ + emc_cc_dbg(STEPS, "Step 28\n"); + + emc_set_shadow_bypass(emc, ACTIVE); + emc_writel(emc, + next_timing->burst_regs[EMC_PMACRO_AUTOCAL_CFG_COMMON_INDEX], + EMC_PMACRO_AUTOCAL_CFG_COMMON); + emc_set_shadow_bypass(emc, ASSEMBLY); + + /* + * Step 29: + * Power fix WAR. + */ + emc_cc_dbg(STEPS, "Step 29\n"); + emc_writel(emc, EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE0 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE1 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE2 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE3 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE4 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE5 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE6 | + EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE7, + EMC_PMACRO_CFG_PM_GLOBAL_0); + emc_writel(emc, EMC_PMACRO_TRAINING_CTRL_0_CH0_TRAINING_E_WRPTR, + EMC_PMACRO_TRAINING_CTRL_0); + emc_writel(emc, EMC_PMACRO_TRAINING_CTRL_1_CH1_TRAINING_E_WRPTR, + EMC_PMACRO_TRAINING_CTRL_1); + emc_writel(emc, 0, EMC_PMACRO_CFG_PM_GLOBAL_0); + + /* + * Step 30: + * Re-enable autocal. + */ + emc_cc_dbg(STEPS, "Step 30: Re-enable DLL and AUTOCAL\n"); + if (next_timing->burst_regs[EMC_CFG_DIG_DLL_INDEX] & + EMC_CFG_DIG_DLL_CFG_DLL_EN) { + tmp = emc_readl(emc, EMC_CFG_DIG_DLL); + tmp |= EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_TRAFFIC; + tmp |= EMC_CFG_DIG_DLL_CFG_DLL_EN; + tmp &= ~EMC_CFG_DIG_DLL_CFG_DLL_STALL_RW_UNTIL_LOCK; + tmp &= ~EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_UNTIL_LOCK; + tmp = (tmp & ~EMC_CFG_DIG_DLL_CFG_DLL_MODE_MASK) | + (2 << EMC_CFG_DIG_DLL_CFG_DLL_MODE_SHIFT); + emc_writel(emc, tmp, EMC_CFG_DIG_DLL); + emc_timing_update(emc, channel_mode); + } + + emc_auto_cal_config = next_timing->emc_auto_cal_config; + emc_writel(emc, emc_auto_cal_config, EMC_AUTO_CAL_CONFIG); + + /* + * Step 31: + * Restore FSP to account for switch back. Only needed in training. + */ + emc_cc_dbg(STEPS, "Step 31\n"); + + /* Step 32: + * [SW] Update the alternative timing (derated vs normal) table with + * the periodic training values computed during the clock change + * pre-amble. + */ + emc_cc_dbg(STEPS, "Step 32: Update alt timing\n"); + tegra210_update_emc_alt_timing(emc, next_timing); + + /* Done! Yay. */ +} diff --git a/drivers/memory/tegra/tegra210-emc-reg.h b/drivers/memory/tegra/tegra210-emc-reg.h index 31a69e718dbc..b474b0810e52 100644 --- a/drivers/memory/tegra/tegra210-emc-reg.h +++ b/drivers/memory/tegra/tegra210-emc-reg.h @@ -107,7 +107,16 @@ #define EMC_INTSTATUS_CLKCHANGE_COMPLETE BIT(4) #define EMC_DBG 0x8 #define EMC_DBG_WRITE_MUX_ACTIVE BIT(1) +#define EMC_DBG_WRITE_ACTIVE_ONLY BIT(30) #define EMC_CFG 0xc +#define EMC_CFG_DRAM_CLKSTOP_PD BIT(31) +#define EMC_CFG_DRAM_CLKSTOP_SR BIT(30) +#define EMC_CFG_DRAM_ACPD BIT(29) +#define EMC_CFG_DYN_SELF_REF BIT(28) +#define EMC_PIN 0x24 +#define EMC_PIN_PIN_CKE BIT(0) +#define EMC_PIN_PIN_CKEB BIT(1) +#define EMC_PIN_PIN_CKE_PER_DEV BIT(2) #define EMC_TIMING_CONTROL 0x28 #define EMC_RC 0x2c #define EMC_RFC 0x30 @@ -147,7 +156,35 @@ #define EMC_WEXT 0xb8 #define EMC_RFC_SLR 0xc0 #define EMC_MRS_WAIT_CNT2 0xc4 +#define EMC_MRS_WAIT_CNT2_MRS_EXT2_WAIT_CNT_SHIFT 16 +#define EMC_MRS_WAIT_CNT2_MRS_EXT1_WAIT_CNT_SHIFT 0 #define EMC_MRS_WAIT_CNT 0xc8 +#define EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT 0 +#define EMC_MRS_WAIT_CNT_SHORT_WAIT_MASK \ + (0x3FF << EMC_MRS_WAIT_CNT_SHORT_WAIT_SHIFT) + +#define EMC_MRS 0xcc +#define EMC_EMRS 0xd0 +#define EMC_EMRS_USE_EMRS_LONG_CNT BIT(26) +#define EMC_REF 0xd4 +#define EMC_SELF_REF 0xe0 +#define EMC_MRW 0xe8 +#define EMC_MRW_MRW_OP_SHIFT 0 +#define EMC_MRW_MRW_OP_MASK \ + (0xff << EMC_MRW_MRW_OP_SHIFT) +#define EMC_MRW_MRW_MA_SHIFT 16 +#define EMC_MRW_USE_MRW_EXT_CNT 27 +#define EMC_MRW_MRW_DEV_SELECTN_SHIFT 30 + +#define EMC_MRR 0xec +#define EMC_MRR_DEV_SEL_SHIFT 30 +#define EMC_MRR_MA_SHIFT 16 +#define EMC_MRR_MA_MASK \ + (0xff << EMC_MRR_MA_SHIFT) +#define EMC_MRR_DATA_SHIFT 0 +#define EMC_MRR_DATA_MASK \ + (0xffff << EMC_MRR_DATA_SHIFT) + #define EMC_FBIO_SPARE 0x100 #define EMC_FBIO_CFG5 0x104 #define EMC_FBIO_CFG5_DRAM_TYPE_SHIFT 0 @@ -158,14 +195,34 @@ #define EMC_PDEX2CKE 0x118 #define EMC_CKE2PDEN 0x11c #define EMC_MPC 0x128 +#define EMC_EMRS2 0x12c +#define EMC_EMRS2_USE_EMRS2_LONG_CNT BIT(26) +#define EMC_MRW2 0x134 +#define EMC_MRW3 0x138 +#define EMC_MRW4 0x13c #define EMC_R2R 0x144 #define EMC_EINPUT 0x14c #define EMC_EINPUT_DURATION 0x150 #define EMC_PUTERM_EXTRA 0x154 #define EMC_TCKESR 0x158 #define EMC_TPD 0x15c +#define EMC_AUTO_CAL_CONFIG 0x2a4 +#define EMC_AUTO_CAL_CONFIG_AUTO_CAL_COMPUTE_START BIT(0) +#define EMC_AUTO_CAL_CONFIG_AUTO_CAL_MEASURE_STALL BIT(9) +#define EMC_AUTO_CAL_CONFIG_AUTO_CAL_UPDATE_STALL BIT(10) +#define EMC_AUTO_CAL_CONFIG_AUTO_CAL_ENABLE BIT(29) +#define EMC_AUTO_CAL_CONFIG_AUTO_CAL_START BIT(31) #define EMC_EMC_STATUS 0x2b4 +#define EMC_EMC_STATUS_MRR_DIVLD BIT(20) #define EMC_EMC_STATUS_TIMING_UPDATE_STALLED BIT(23) +#define EMC_EMC_STATUS_DRAM_IN_POWERDOWN_SHIFT 4 +#define EMC_EMC_STATUS_DRAM_IN_POWERDOWN_MASK \ + (0x3 << EMC_EMC_STATUS_DRAM_IN_POWERDOWN_SHIFT) +#define EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_SHIFT 8 +#define EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_MASK \ + (0x3 << EMC_EMC_STATUS_DRAM_IN_SELF_REFRESH_SHIFT) + +#define EMC_CFG_2 0x2b8 #define EMC_CFG_DIG_DLL 0x2bc #define EMC_CFG_DIG_DLL_CFG_DLL_EN BIT(0) #define EMC_CFG_DIG_DLL_CFG_DLL_STALL_ALL_UNTIL_LOCK BIT(1) @@ -191,8 +248,17 @@ #define EMC_WDV_MASK 0x2d0 #define EMC_RDV_EARLY_MASK 0x2d4 #define EMC_RDV_EARLY 0x2d8 +#define EMC_AUTO_CAL_CONFIG8 0x2dc #define EMC_ZCAL_INTERVAL 0x2e0 #define EMC_ZCAL_WAIT_CNT 0x2e4 +#define EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_MASK 0x7ff +#define EMC_ZCAL_WAIT_CNT_ZCAL_WAIT_CNT_SHIFT 0 + +#define EMC_ZQ_CAL 0x2ec +#define EMC_ZQ_CAL_DEV_SEL_SHIFT 30 +#define EMC_ZQ_CAL_LONG BIT(4) +#define EMC_ZQ_CAL_ZQ_LATCH_CMD BIT(1) +#define EMC_ZQ_CAL_ZQ_CAL_CMD BIT(0) #define EMC_FDPD_CTRL_DQ 0x310 #define EMC_FDPD_CTRL_CMD 0x314 #define EMC_PMACRO_CMD_BRICK_CTRL_FDPD 0x318 @@ -202,6 +268,13 @@ #define EMC_TR_TIMING_0 0x3b4 #define EMC_TR_CTRL_1 0x3bc #define EMC_TR_RDV 0x3c4 +#define EMC_STALL_THEN_EXE_AFTER_CLKCHANGE 0x3cc +#define EMC_SEL_DPD_CTRL 0x3d8 +#define EMC_SEL_DPD_CTRL_DATA_SEL_DPD_EN BIT(8) +#define EMC_SEL_DPD_CTRL_ODT_SEL_DPD_EN BIT(5) +#define EMC_SEL_DPD_CTRL_RESET_SEL_DPD_EN BIT(4) +#define EMC_SEL_DPD_CTRL_CA_SEL_DPD_EN BIT(3) +#define EMC_SEL_DPD_CTRL_CLK_SEL_DPD_EN BIT(2) #define EMC_PRE_REFRESH_REQ_CNT 0x3dc #define EMC_DYN_SELF_REF_CONTROL 0x3e0 #define EMC_TXSRDLL 0x3e4 @@ -211,6 +284,9 @@ #define EMC_TR_RDV_MASK 0x3f8 #define EMC_TR_QSAFE 0x3fc #define EMC_TR_QRST 0x400 +#define EMC_ISSUE_QRST 0x428 +#define EMC_AUTO_CAL_CONFIG2 0x458 +#define EMC_AUTO_CAL_CONFIG3 0x45c #define EMC_TR_DVFS 0x460 #define EMC_AUTO_CAL_CHANNEL 0x464 #define EMC_IBDLY 0x468 @@ -224,19 +300,26 @@ #define EMC_MRW6 0x4a4 #define EMC_MRW7 0x4a8 #define EMC_MRW8 0x4ac +#define EMC_MRW9 0x4b0 #define EMC_MRW10 0x4b4 #define EMC_MRW11 0x4b8 #define EMC_MRW12 0x4bc #define EMC_MRW13 0x4c0 #define EMC_MRW14 0x4c4 #define EMC_MRW15 0x4d0 +#define EMC_CFG_SYNC 0x4d4 +#define EMC_FDPD_CTRL_CMD_NO_RAMP 0x4d8 +#define EMC_FDPD_CTRL_CMD_NO_RAMP_CMD_DPD_NO_RAMP_ENABLE BIT(0) #define EMC_WDV_CHK 0x4e0 #define EMC_CFG_PIPE_2 0x554 +#define EMC_CFG_PIPE_CLK 0x558 +#define EMC_CFG_PIPE_CLK_CLK_ALWAYS_ON BIT(0) #define EMC_CFG_PIPE_1 0x55c #define EMC_CFG_PIPE 0x560 #define EMC_QPOP 0x564 #define EMC_QUSE_WIDTH 0x568 #define EMC_PUTERM_WIDTH 0x56c +#define EMC_AUTO_CAL_CONFIG7 0x574 #define EMC_REFCTRL2 0x580 #define EMC_FBIO_CFG7 0x584 #define EMC_FBIO_CFG7_CH0_ENABLE BIT(1) @@ -301,10 +384,13 @@ #define EMC_CMD_BRLSHFT_2 0x5a4 #define EMC_CMD_BRLSHFT_3 0x5a8 #define EMC_QUSE_BRLSHFT_0 0x5ac +#define EMC_AUTO_CAL_CONFIG4 0x5b0 +#define EMC_AUTO_CAL_CONFIG5 0x5b4 #define EMC_QUSE_BRLSHFT_1 0x5b8 #define EMC_QUSE_BRLSHFT_2 0x5bc #define EMC_CCDMW 0x5c0 #define EMC_QUSE_BRLSHFT_3 0x5c4 +#define EMC_AUTO_CAL_CONFIG6 0x5cc #define EMC_DLL_CFG_0 0x5e4 #define EMC_DLL_CFG_1 0x5e8 #define EMC_DLL_CFG_1_DDLLCAL_CTRL_START_TRIM_SHIFT 10 @@ -312,6 +398,11 @@ (0x7ff << EMC_DLL_CFG_1_DDLLCAL_CTRL_START_TRIM_SHIFT) #define EMC_CONFIG_SAMPLE_DELAY 0x5f0 +#define EMC_CFG_UPDATE 0x5f4 +#define EMC_CFG_UPDATE_UPDATE_DLL_IN_UPDATE_SHIFT 9 +#define EMC_CFG_UPDATE_UPDATE_DLL_IN_UPDATE_MASK \ + (0x3 << EMC_CFG_UPDATE_UPDATE_DLL_IN_UPDATE_SHIFT) + #define EMC_PMACRO_QUSE_DDLL_RANK0_0 0x600 #define EMC_PMACRO_QUSE_DDLL_RANK0_1 0x604 #define EMC_PMACRO_QUSE_DDLL_RANK0_2 0x608 @@ -620,9 +711,20 @@ #define EMC_PMACRO_DDLL_SHORT_CMD_0 0xc20 #define EMC_PMACRO_DDLL_SHORT_CMD_1 0xc24 #define EMC_PMACRO_DDLL_SHORT_CMD_2 0xc28 +#define EMC_PMACRO_CFG_PM_GLOBAL_0 0xc30 +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE0 BIT(16) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE1 BIT(17) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE2 BIT(18) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE3 BIT(19) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE4 BIT(20) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE5 BIT(21) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE6 BIT(22) +#define EMC_PMACRO_CFG_PM_GLOBAL_0_DISABLE_CFG_BYTE7 BIT(23) #define EMC_PMACRO_VTTGEN_CTRL_0 0xc34 #define EMC_PMACRO_VTTGEN_CTRL_1 0xc38 #define EMC_PMACRO_BG_BIAS_CTRL_0 0xc3c +#define EMC_PMACRO_BG_BIAS_CTRL_0_BG_E_PWRD BIT(0) +#define EMC_PMACRO_BG_BIAS_CTRL_0_BGLP_E_PWRD BIT(2) #define EMC_PMACRO_PAD_CFG_CTRL 0xc40 #define EMC_PMACRO_ZCTRL 0xc44 #define EMC_PMACRO_CMD_PAD_RX_CTRL 0xc50 @@ -637,15 +739,22 @@ #define EMC_PMACRO_CMD_PAD_TX_CTRL_CMD_DQ_TX_DRVFORCEON BIT(26) #define EMC_PMACRO_DATA_PAD_TX_CTRL 0xc64 +#define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_E_IVREF BIT(0) #define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQ_TX_E_DCC BIT(1) +#define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQS_E_IVREF BIT(8) #define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSP_TX_E_DCC BIT(9) #define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_DQSN_TX_E_DCC BIT(16) #define EMC_PMACRO_DATA_PAD_TX_CTRL_DATA_CMD_TX_E_DCC BIT(24) #define EMC_PMACRO_COMMON_PAD_TX_CTRL 0xc68 #define EMC_PMACRO_AUTOCAL_CFG_COMMON 0xc78 +#define EMC_PMACRO_AUTOCAL_CFG_COMMON_E_CAL_BYPASS_DVFS BIT(16) #define EMC_PMACRO_VTTGEN_CTRL_2 0xcf0 #define EMC_PMACRO_IB_RXRT 0xcf4 +#define EMC_PMACRO_TRAINING_CTRL_0 0xcf8 +#define EMC_PMACRO_TRAINING_CTRL_0_CH0_TRAINING_E_WRPTR BIT(3) +#define EMC_PMACRO_TRAINING_CTRL_1 0xcfc +#define EMC_PMACRO_TRAINING_CTRL_1_CH1_TRAINING_E_WRPTR BIT(3) #define EMC_TRAINING_CTRL 0xe04 #define EMC_TRAINING_QUSE_CORS_CTRL 0xe0c #define EMC_TRAINING_QUSE_FINE_CTRL 0xe10 @@ -1173,6 +1282,29 @@ enum { DLL_ON }; +enum { + ONE_RANK = 1, + TWO_RANK = 2 +}; + +enum { + T_RP = 0, + T_FC_LPDDR4, + T_RFC, + T_PDEX, + RL +}; + +enum { + AUTO_PD = 0, + MAN_SR = 2 +}; + +enum { + ASSEMBLY = 0, + ACTIVE +}; + struct emc_table { u32 rev; char dvfs_ver[60]; @@ -1315,7 +1447,9 @@ void emc_writel_per_ch(struct tegra_emc *emc, u32 val, int type, unsigned long offset); u32 emc1_readl(struct tegra_emc *emc, unsigned long offset); +u32 __do_periodic_emc_compensation_r21021(struct tegra_emc *emc); void do_clock_change(struct tegra_emc *emc, u32 clksrc); +void emc_set_clock_r21021(struct tegra_emc *emc, u32 clksrc); void emc_set_shadow_bypass(struct tegra_emc *emc, int set); void emc_timing_update(struct tegra_emc *emc, int dual_chan); u32 get_dll_state(struct emc_table *next_timing); diff --git a/drivers/memory/tegra/tegra210-emc.c b/drivers/memory/tegra/tegra210-emc.c index 26d0de0ab319..9afab67b1a3d 100644 --- a/drivers/memory/tegra/tegra210-emc.c +++ b/drivers/memory/tegra/tegra210-emc.c @@ -103,6 +103,11 @@ static const char *emc_src_names[TEGRA_EMC_SRC_COUNT] = { }; static struct emc_stats emc_stats; static struct supported_sequence supported_seqs[] = { + { + 0x7, + emc_set_clock_r21021, + __do_periodic_emc_compensation_r21021, + }, { 0, NULL, From patchwork Mon Mar 25 07:45:21 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063883 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="ZAkcJyRh"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRC13P3tz9sSd for ; Mon, 25 Mar 2019 18:45:49 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729880AbfCYHpt (ORCPT ); Mon, 25 Mar 2019 03:45:49 -0400 Received: from hqemgate15.nvidia.com ([216.228.121.64]:9009 "EHLO hqemgate15.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729876AbfCYHpt (ORCPT ); Mon, 25 Mar 2019 03:45:49 -0400 Received: from hqpgpgate102.nvidia.com (Not Verified[216.228.121.13]) by hqemgate15.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:44 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate102.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:48 -0700 X-PGP-Universal: processed; by hqpgpgate102.nvidia.com on Mon, 25 Mar 2019 00:45:48 -0700 Received: from HQMAIL103.nvidia.com (172.20.187.11) by HQMAIL105.nvidia.com (172.20.187.12) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:48 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL103.nvidia.com (172.20.187.11) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:48 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:47 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , Rob Herring , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 6/8] arm64: tegra: Add external memory controller node for Tegra210 Date: Mon, 25 Mar 2019 15:45:21 +0800 Message-ID: <20190325074523.26456-7-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499944; bh=o0pvGJcXGTHfYZxtTQ8xjq1nY2BEd0cHhCJR+j/R800=; 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=ZAkcJyRhM2BgV7aYZpn3UHk7HAXlFM1jvR7P1ERdpy1bCYhMowFrbWNHp5huc1OOp BZpVNgSCw+xC2uHAge3QbgRWQhMkfUW1c/k2USKOBX/f/ECqyZ+t+It+YwBNy251fq 9w2iZ7oT9aKzinwN73vcyrrHQpahPNPm1FbZ0ofpVIC6yumPVAnqt+f4uiq/I5VtxO 6zhoYz+Rme83kHgL/tqEZtw+z1Tn90Dv65OGNitOWSXKsLDfCNg5qbMWkGdxHMWxwW 8voxBLbGdqaX1lRPzNbOlVgY8biuS/gqUJdRIteOArulq3sJQhnP8i6sNBC9MMUlXy /MlOlr1B3ABrw== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org Add external memory controller (EMC) node for Tegra210 Signed-off-by: Joseph Lo --- arch/arm64/boot/dts/nvidia/tegra210.dtsi | 23 +++++++++++++++++++++++ 1 file changed, 23 insertions(+) diff --git a/arch/arm64/boot/dts/nvidia/tegra210.dtsi b/arch/arm64/boot/dts/nvidia/tegra210.dtsi index bc71ef8f9a09..f9c01de2843e 100644 --- a/arch/arm64/boot/dts/nvidia/tegra210.dtsi +++ b/arch/arm64/boot/dts/nvidia/tegra210.dtsi @@ -872,6 +872,29 @@ #iommu-cells = <1>; }; + external-memory-controller@7001b000 { + compatible = "nvidia,tegra21-emc", "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"; + #address-cells = <1>; + #size-cells = <0>; + + nvidia,memory-controller = <&mc>; + nvidia,use-ram-code; + }; + sata@70020000 { compatible = "nvidia,tegra210-ahci"; reg = <0x0 0x70027000 0x0 0x2000>, /* AHCI */ From patchwork Mon Mar 25 07:45:22 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063886 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="IIXi2PUO"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRFx4P56z9sSg for ; Mon, 25 Mar 2019 18:48:21 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729908AbfCYHsT (ORCPT ); Mon, 25 Mar 2019 03:48:19 -0400 Received: from hqemgate15.nvidia.com ([216.228.121.64]:9021 "EHLO hqemgate15.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729867AbfCYHsS (ORCPT ); Mon, 25 Mar 2019 03:48:18 -0400 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate15.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:48 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:51 -0700 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 25 Mar 2019 00:45:51 -0700 Received: from HQMAIL109.nvidia.com (172.20.187.15) by HQMAIL104.nvidia.com (172.18.146.11) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:51 +0000 Received: from HQMAIL104.nvidia.com (172.18.146.11) by HQMAIL109.nvidia.com (172.20.187.15) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:50 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL104.nvidia.com (172.18.146.11) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:50 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:49 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , "Rob Herring" , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 7/8] arm64: tegra: Add EMC table of ram code 0 for Tegra210 Shield platform Date: Mon, 25 Mar 2019 15:45:22 +0800 Message-ID: <20190325074523.26456-8-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499948; bh=s9lkTGeDBTvhoQetQ2fQC70OCZtd/9H8qmgFxWi6oXQ=; 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=IIXi2PUO0cTYtAZTJgErlNPbnYhNBzGVptcn0a+B6FVoDyzXADnAzpDfriIHZHsjZ ZWwm97ZjsoSTFt+gHdiE+H+vfhTTnW14Iooo6rzrdi1prM5N7J29CAtYUGyfrQHxJ0 HzgMOBGIun1r3nSmt4WLV09SZ4tPXlIS8ptYmW6XcI9Mtg59W13adPunO5/4awgnkN 2TswUY4B8F+nhfZg4Ka39lJsoetZzSQJE24cRDkWTkUWA/h3oKvvbBk4O8lcOarEna lCsTApRRQwblN7LR5+Dfn2a1LCKPcW+saqddrJ9suCp5Ii04QHg6NR2pWIgUsdA9Yn LfkjJKMZnbw5Q== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org Add EMC table of ram code 0 and revision number 7 for Tegra210 Shield platform. Signed-off-by: Joseph Lo --- .../boot/dts/nvidia/tegra210-p2894-emc.dtsi | 12428 ++++++++++++++++ .../arm64/boot/dts/nvidia/tegra210-p2894.dtsi | 1 + 2 files changed, 12429 insertions(+) create mode 100644 arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi diff --git a/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi b/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi new file mode 100644 index 000000000000..78e253cfbe86 --- /dev/null +++ b/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi @@ -0,0 +1,12428 @@ +// SPDX-License-Identifier: GPL-2.0 +/ { + external-memory-controller@7001b000 { + emc-table@0 { + nvidia,ram-code = <0>; + emc-table@40800 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_40800_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <40800>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x40188012>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000003>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x08010004>; + nvidia,emc-mrw2 = <0x08020000>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x40188012>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x00005172>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x000000a0 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000000 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x08161414 + 0x00000011 + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x000000a0 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000001 + 0x0000001f + 0x00000013 + 0x00000003 + 0x00000015 + 0x08161414 + 0x0000000b + 0x00010001 + 0x00019080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x00000009 + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000005 + 0x08037171 + 0x00000008 + 0x00000001 + 0x80000000 + 0x00010002 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x000000a0 + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000001 + 0x0000001f + 0x0000001d + 0x00000013 + 0x0000001f + 0x08161414 + 0x0000001b + 0x00010002 + 0x00009080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000d + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x30000002 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x000000a0 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000001 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x08161414 + 0x00000011 + 0x00010001 + 0x0000b080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000049 + 0x00000104 + 0x000000b4 + 0x0000007a + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x40020001 + 0x80000013 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000002 + 0x00000000 + 0x00000001 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000002 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000000 + 0x02020001 + 0x00030201 + 0x72c30303 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000006 + 0x0080001a + 0x00000076 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff003d + 0x00ff00ff + 0x00ff003d + 0x00ff0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ff + 0x000000ff + 0x00ff0004 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x000000ff + 0x000000ff + 0x00ff00ff + >; + }; + emc-table@68000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_68000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <68000>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x4018800a>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000005>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x08010004>; + nvidia,emc-mrw2 = <0x08020000>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x4018800a>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x000029e0>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000010a + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000000 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x08161414 + 0x00000011 + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000010a + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000001 + 0x0000001f + 0x00000014 + 0x00000004 + 0x00000016 + 0x08161414 + 0x0000000c + 0x00010001 + 0x00019080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x00000009 + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000003 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000005 + 0x08037171 + 0x00000009 + 0x00000001 + 0x80000000 + 0x00010002 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000010a + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000001 + 0x0000001f + 0x0000001d + 0x00000013 + 0x0000001f + 0x08161414 + 0x0000001b + 0x00010002 + 0x00009080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000d + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x30000002 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000010a + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000001 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x08161414 + 0x00000011 + 0x00010001 + 0x0000b080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x0000002c + 0x00000104 + 0x000000b4 + 0x00000049 + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0xf0000001 + 0x80000024 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000002 + 0x00000000 + 0x00000001 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000002 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000001 + 0x02020001 + 0x00030201 + 0x72630303 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000009 + 0x0080001a + 0x000000c4 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff0025 + 0x00ff00ff + 0x00ff0025 + 0x00ff0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ff + 0x000000ff + 0x00ff0004 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x000000ff + 0x000000ff + 0x00ff00ff + >; + }; + emc-table@102000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_102000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <102000>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x40188006>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000007>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x08010004>; + nvidia,emc-mrw2 = <0x08020000>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x40188006>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x00001aea>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000003 + 0x08037171 + 0x0000000b + 0x00000000 + 0x0000000a + 0x00010000 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000018e + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000000 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x08161414 + 0x00000011 + 0x00010000 + 0x00009080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000003 + 0x08037171 + 0x0000000b + 0x00000000 + 0x0000000a + 0x00010000 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000018e + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000001 + 0x0000001f + 0x00000015 + 0x00000005 + 0x00000017 + 0x08161414 + 0x0000000d + 0x00010000 + 0x00019080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x00000009 + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000003 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000004 + 0x08037171 + 0x0000000a + 0x00000001 + 0x80000000 + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000018e + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000001 + 0x0000001f + 0x0000001d + 0x00000013 + 0x0000001f + 0x08161414 + 0x0000001b + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000d + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x30000002 + 0x00000003 + 0x08037171 + 0x0000000b + 0x00000000 + 0x0000000a + 0x00010000 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000018e + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000001 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x08161414 + 0x00000011 + 0x00010000 + 0x0000b080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x0000001d + 0x00000104 + 0x000000b4 + 0x00000031 + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x50000001 + 0x80000033 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000002 + 0x00000000 + 0x00000001 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000002 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000002 + 0x02020001 + 0x00030201 + 0x72030303 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x0000000e + 0x0080001a + 0x00000126 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff0018 + 0x00ff00ff + 0x00ff0018 + 0x00fe0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ff + 0x000000ff + 0x00ff0004 + 0x00ff00ff + 0x00ff00ff + 0x00ff00da + 0x00ff00ff + 0x00ff00ff + 0x000000ff + 0x000000ff + 0x00ff00ff + >; + }; + emc-table@204000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_204000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <204000>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x40188002>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x0000000d>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x08010004>; + nvidia,emc-mrw2 = <0x08020000>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x40188002>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x00000d5c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000b + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000002 + 0x08037171 + 0x0000000d + 0x00000000 + 0x0000000b + 0x00010000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000031c + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000000 + 0x00000000 + 0x00000014 + 0x0000000a + 0x00000016 + 0x08161414 + 0x00000012 + 0x00010000 + 0x00009080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000b + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000002 + 0x08037171 + 0x0000000d + 0x00000000 + 0x0000000b + 0x00010000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000031c + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000001 + 0x0000001f + 0x00000018 + 0x00000008 + 0x0000001a + 0x08161414 + 0x00000010 + 0x00010000 + 0x00019080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x0000000c + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000003 + 0x00000002 + 0x10000000 + 0x00000000 + 0x00000003 + 0x08037171 + 0x0000000b + 0x00000001 + 0x80000000 + 0x00040000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000031c + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000001 + 0x0000001f + 0x0000001e + 0x00000014 + 0x00000020 + 0x08161414 + 0x0000001c + 0x00040000 + 0x00009080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000e + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000013 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000006 + 0x30000000 + 0x30000002 + 0x00000002 + 0x08037171 + 0x0000000d + 0x00000000 + 0x0000000b + 0x00040000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0x48037171 + 0x0000031c + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000001 + 0x00000000 + 0x00000014 + 0x0000000a + 0x00000016 + 0x08161414 + 0x00000012 + 0x00040000 + 0x0000b080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000018 + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x08000001 + 0x8000004c + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000003 + 0x00000001 + 0x00000002 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000002 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000004 + 0x02020001 + 0x00030201 + 0x71c30504 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x0000001b + 0x0080001a + 0x0000024c + 0x00ff00b2 + 0x00ff00da + 0x00ff009d + 0x00ff00ff + 0x00ff000c + 0x00ff00ff + 0x00ff000c + 0x007f0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ad + 0x000000ff + 0x00ff0004 + 0x00ff00c6 + 0x00ff00c6 + 0x00ff006d + 0x00ff00ff + 0x00ff00e2 + 0x000000ff + 0x00000080 + 0x00ff00ff + >; + }; + emc-table@408000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_408000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <408000>; + nvidia,emc-min-mv = <812>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_ud"; + nvidia,src-sel-reg = <0xe0188000>; + nvidia,needs-training = <0x00000010>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x0000001a>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000001b>; + nvidia,emc-mrw = <0x08010014>; + nvidia,emc-mrw2 = <0x08020009>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0xe0188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x000006d6>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000013 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000c + 0x00000006 + 0x00000000 + 0x30000000 + 0x00000007 + 0x08037171 + 0x0000000f + 0x00000007 + 0x0000000b + 0x00010004 + 0x00000019 + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0x48037171 + 0x00000638 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x000000be + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050035 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000000 + 0x00000000 + 0x00000021 + 0x00000011 + 0x00000023 + 0x08161414 + 0x00000019 + 0x00010004 + 0x00009080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000013 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000c + 0x00000006 + 0x00000000 + 0x30000000 + 0x00000007 + 0x08037171 + 0x0000000f + 0x00000007 + 0x0000000b + 0x00010004 + 0x00000019 + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0x48037171 + 0x00000638 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x00000055 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000001 + 0x0000001f + 0x00000023 + 0x0000000d + 0x00000025 + 0x08161414 + 0x00000015 + 0x00010004 + 0x00019080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000012 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x0000000e + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000a + 0x00000002 + 0x10000006 + 0x30000000 + 0x00000008 + 0x08037171 + 0x0000000d + 0x00000001 + 0x80000000 + 0x00050001 + 0x0000001b + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0x48037171 + 0x00000638 + 0x00000000 + 0x9160400d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x000000be + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x05058035 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000001 + 0x0000001f + 0x0000002b + 0x0000001b + 0x0000002d + 0x08161414 + 0x00000025 + 0x00050001 + 0x00009080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000013 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000c + 0x00000006 + 0x10000005 + 0x30000000 + 0x00000007 + 0x08037171 + 0x0000000f + 0x00000007 + 0x0000000b + 0x00050000 + 0x00000019 + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0x48037171 + 0x00000638 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x000000be + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050035 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000001 + 0x00000000 + 0x00000021 + 0x00000011 + 0x00000023 + 0x08161414 + 0x00000019 + 0x00050000 + 0x0000b080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00200021 + 0x00210023 + 0x00210022 + 0x00210024 + 0x00020002 + 0x00020002 + 0x00200021 + 0x00210023 + 0x00210022 + 0x00210024 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x0000000c + 0x0000000c + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x01000003 + 0x8000007f + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000001 + 0x00000006 + 0x00000003 + 0x00000004 + 0x00000001 + 0x00000002 + 0x00000007 + 0x00000002 + 0x00000006 + 0x00000006 + 0x00000008 + 0x00000005 + 0x00000009 + 0x02030301 + 0x00040203 + 0x71a40a07 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000035 + 0x0080001a + 0x00000498 + 0x00ff0059 + 0x00ff006d + 0x00ff004f + 0x00ff00af + 0x00ff0006 + 0x00ff00af + 0x00ff0006 + 0x00400049 + 0x00ff0080 + 0x00ff0004 + 0x00080057 + 0x000000ff + 0x00ff0004 + 0x00ff0063 + 0x00ff0063 + 0x00ff0036 + 0x00ff00ff + 0x00ff0071 + 0x000000ff + 0x00000040 + 0x00ff00ff + >; + }; + emc-table@665600 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_665600_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <665600>; + nvidia,emc-min-mv = <825>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x00000010>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x0000002a>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000001f>; + nvidia,emc-mrw = <0x08010024>; + nvidia,emc-mrw2 = <0x08020012>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x000004ce>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000006 + 0x00000000 + 0x30000000 + 0x0000000a + 0x08037171 + 0x00000011 + 0x0000000c + 0x0000000b + 0x00010007 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0x48037171 + 0x00000a24 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050033 + 0x05050000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000000 + 0x00000000 + 0x00000026 + 0x00000016 + 0x00000028 + 0x08161414 + 0x0000001e + 0x00010007 + 0x00009080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000006 + 0x00000000 + 0x30000000 + 0x0000000a + 0x08037171 + 0x00000011 + 0x0000000c + 0x0000000b + 0x00010007 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0x48037171 + 0x00000a24 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000001 + 0x0000001f + 0x00000029 + 0x00000013 + 0x0000002b + 0x08161414 + 0x0000001b + 0x00010007 + 0x00019080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000016 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x0000000f + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x0000000f + 0x00000002 + 0x1000000b + 0x30000000 + 0x0000000b + 0x08037171 + 0x00000010 + 0x00000001 + 0x80000000 + 0x00050004 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0x48037171 + 0x00000a24 + 0x00000000 + 0x9160400d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x05058033 + 0x05050000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000001 + 0x0000001f + 0x00000030 + 0x00000020 + 0x00000032 + 0x08161414 + 0x00000028 + 0x00050004 + 0x00009080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x00000014 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000006 + 0x1000000a + 0x30000000 + 0x0000000a + 0x08037171 + 0x00000011 + 0x0000000c + 0x0000000b + 0x00050003 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0x48037171 + 0x00000a24 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050033 + 0x05050000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000001 + 0x00000000 + 0x00000026 + 0x00000016 + 0x00000028 + 0x08161414 + 0x0000001e + 0x00050003 + 0x0000b080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x00250025 + 0x00250025 + 0x00250025 + 0x00250025 + 0x00250025 + 0x00250025 + 0x00250025 + 0x00250025 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x2b2b2b2b + 0x2b2b2b2b + 0x001f0021 + 0x00220026 + 0x00210024 + 0x00230026 + 0x00040004 + 0x00040004 + 0x001f0021 + 0x00220026 + 0x00210024 + 0x00230026 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000010 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x00000005 + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000002 + 0x00000009 + 0x00000005 + 0x00000006 + 0x00000001 + 0x00000002 + 0x00000009 + 0x00000002 + 0x00000006 + 0x00000007 + 0x00000008 + 0x00000006 + 0x0000000e + 0x03030301 + 0x00060304 + 0x71a50f0a + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000057 + 0x0080001a + 0x0000077e + 0x00ff003d + 0x00ff0043 + 0x00ff0041 + 0x00ff0090 + 0x00ff0005 + 0x00ff0090 + 0x00ff0005 + 0x00340049 + 0x00ff0080 + 0x00ff0004 + 0x00080035 + 0x000000ff + 0x00ff0004 + 0x00ff003d + 0x00ff003d + 0x00ff0029 + 0x00ff00d8 + 0x00ff0045 + 0x000000ff + 0x0000002c + 0x00ff00ff + >; + }; + emc-table@800000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_800000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <800000>; + nvidia,emc-min-mv = <825>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000000d0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000033>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000001f>; + nvidia,emc-mrw = <0x08010024>; + nvidia,emc-mrw2 = <0x08020012>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x000004b0>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000007 + 0x1000000a + 0x30000000 + 0x00000009 + 0x08037171 + 0x00000013 + 0x0000000c + 0x0000000c + 0x00050002 + 0x00000020 + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0x48037171 + 0x00000c30 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000000 + 0x00000000 + 0x00000027 + 0x00000017 + 0x00000029 + 0x08161414 + 0x00000020 + 0x00050002 + 0x00009080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000007 + 0x1000000a + 0x30000000 + 0x00000009 + 0x08037171 + 0x00000013 + 0x0000000c + 0x0000000c + 0x00050002 + 0x00000020 + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0x48037171 + 0x00000c30 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000001 + 0x0000001f + 0x0000002d + 0x00000017 + 0x0000002f + 0x08161414 + 0x00000020 + 0x00050002 + 0x00019080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000016 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000010 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x0000000f + 0x00000002 + 0x1000000b + 0x30000000 + 0x0000000a + 0x08037171 + 0x00000011 + 0x00000001 + 0x80000000 + 0x00050003 + 0x0000001f + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0x48037171 + 0x00000c30 + 0x00000000 + 0x9160400d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000001 + 0x0000001f + 0x00000031 + 0x00000021 + 0x00000033 + 0x08161414 + 0x00000029 + 0x00050003 + 0x00009080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000007 + 0x1000000a + 0x30000000 + 0x00000009 + 0x08037171 + 0x00000013 + 0x0000000c + 0x0000000c + 0x00050002 + 0x00000020 + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0x48037171 + 0x00000c30 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000001 + 0x00000000 + 0x00000027 + 0x00000017 + 0x00000029 + 0x08161414 + 0x00000020 + 0x00050002 + 0x0000b080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x11111111 + 0x11111111 + 0x001f0022 + 0x00220027 + 0x00220025 + 0x00230028 + 0x00050004 + 0x00050005 + 0x001f0022 + 0x00220027 + 0x00220025 + 0x00230028 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000010 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x00000006 + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000002 + 0x00000003 + 0x0000000c + 0x00000007 + 0x00000007 + 0x00000001 + 0x00000002 + 0x00000008 + 0x00000007 + 0x00000006 + 0x00000007 + 0x00000008 + 0x00000006 + 0x00000011 + 0x03030303 + 0x00070406 + 0x7186120d + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000068 + 0x0080001a + 0x00000902 + 0x00ff003d + 0x00ff0038 + 0x00ff0041 + 0x00ff0090 + 0x00ff0005 + 0x00ff0090 + 0x00ff0005 + 0x00340049 + 0x00ff0080 + 0x00ff0004 + 0x0008002c + 0x000000ff + 0x00ff0004 + 0x00ff0032 + 0x00ff0032 + 0x00ff0022 + 0x00ff00b4 + 0x00ff003a + 0x000000ff + 0x0000002c + 0x00ff00ff + >; + }; + emc-table@1065600 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_1065600_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <1065600>; + nvidia,emc-min-mv = <837>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000000f0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000001>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000040>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000025>; + nvidia,emc-mrw = <0x08010034>; + nvidia,emc-mrw2 = <0x0802001b>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e4848>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110825>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x0000049c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x00000020 + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x00000016 + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000018 + 0x00000008 + 0x10000011 + 0x10000000 + 0x0000000d + 0x0803f1f1 + 0x00000017 + 0x00000013 + 0x0000000d + 0x00050006 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0x4803f1f1 + 0x0000103c + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000000 + 0x00000000 + 0x0000002f + 0x0000001f + 0x00000031 + 0x08161414 + 0x00000027 + 0x00050006 + 0x00009080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e4848 + 0x8c0e4848 + 0x4c0e4848 + 0x4c0e4848 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x00000020 + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x00000016 + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000018 + 0x00000008 + 0x10000011 + 0x10000000 + 0x0000000d + 0x0803f1f1 + 0x00000017 + 0x00000013 + 0x0000000d + 0x00050006 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0x4803f1f1 + 0x0000103c + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000001 + 0x0000001f + 0x00000034 + 0x0000001e + 0x00000036 + 0x08161414 + 0x00000026 + 0x00050006 + 0x00019080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x0000001f + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x0000000f + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000016 + 0x00000002 + 0x10000012 + 0x10000000 + 0x0000000e + 0x0803f1f1 + 0x00000015 + 0x00000001 + 0x80000000 + 0x00050007 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0x4803f1f1 + 0x0000103c + 0x00000000 + 0x9160400d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000001 + 0x0000001f + 0x00000039 + 0x00000029 + 0x0000003b + 0x08161414 + 0x00000031 + 0x00050007 + 0x00009080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x00000020 + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x00000016 + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000018 + 0x00000008 + 0x10000011 + 0x10000000 + 0x0000000d + 0x0803f1f1 + 0x00000017 + 0x00000013 + 0x0000000d + 0x00050006 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0x4803f1f1 + 0x0000103c + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000001 + 0x00000000 + 0x0000002f + 0x0000001f + 0x00000031 + 0x08161414 + 0x00000027 + 0x00050006 + 0x0000b080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x11111111 + 0x11111111 + 0x001f0023 + 0x0023002a + 0x00220027 + 0x0025002a + 0x00060006 + 0x00060006 + 0x001f0023 + 0x0023002a + 0x00220027 + 0x0025002a + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000016 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x00000008 + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000003 + 0x00000004 + 0x00000010 + 0x0000000a + 0x0000000a + 0x00000002 + 0x00000002 + 0x0000000a + 0x00000007 + 0x00000006 + 0x00000009 + 0x00000008 + 0x00000007 + 0x00000017 + 0x03040303 + 0x00090508 + 0x71881811 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x0000008b + 0x0080001a + 0x00000bff + 0x00c0003d + 0x00c00038 + 0x00c00041 + 0x00c00090 + 0x00c00005 + 0x00c00090 + 0x00c00005 + 0x00340049 + 0x00c00080 + 0x00c00004 + 0x00080021 + 0x000000c0 + 0x00c00004 + 0x00c00026 + 0x00c00026 + 0x00c00019 + 0x00c00095 + 0x00c0002b + 0x000000c0 + 0x0000002c + 0x00c000c0 + >; + }; + emc-table@1331200 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_1331200_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <1331200>; + nvidia,emc-min-mv = <850>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000002f0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000001>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000040>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000002b>; + nvidia,emc-mrw = <0x08010044>; + nvidia,emc-mrw2 = <0x08020024>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e4848>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x0011082d>; + nvidia,emc-sel-dpd-ctrl = <0x00040000>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x0000044c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000027 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000018 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001f + 0x00000008 + 0x10000017 + 0x10000000 + 0x00000011 + 0x0803f1f1 + 0x0000001a + 0x0000001a + 0x0000000d + 0x00060009 + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0x4803f1f1 + 0x00001448 + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000000 + 0x00000000 + 0x00000036 + 0x00000026 + 0x00000038 + 0x08161414 + 0x0000002e + 0x00060009 + 0x00009080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0x480c7272 + 0x480c7272 + 0x8c0e4848 + 0x8c0e4848 + 0x4c0e4848 + 0x4c0e4848 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000027 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000018 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001f + 0x00000008 + 0x10000017 + 0x10000000 + 0x00000011 + 0x0803f1f1 + 0x0000001a + 0x0000001a + 0x0000000d + 0x00060009 + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0x4803f1f1 + 0x00001448 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000001 + 0x0000001f + 0x0000003a + 0x00000024 + 0x0000003c + 0x08161414 + 0x0000002c + 0x00060009 + 0x00019080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000026 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000012 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001e + 0x00000002 + 0x10000019 + 0x10000000 + 0x00000013 + 0x0803f1f1 + 0x00000018 + 0x00000001 + 0x80000000 + 0x0006000b + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0x4803f1f1 + 0x00001448 + 0x00000000 + 0x9160400d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000001 + 0x0000001f + 0x00000040 + 0x00000030 + 0x00000042 + 0x08161414 + 0x00000038 + 0x0006000b + 0x00009080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000027 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000018 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001f + 0x00000008 + 0x10000017 + 0x10000000 + 0x00000011 + 0x0803f1f1 + 0x0000001a + 0x0000001a + 0x0000000d + 0x00060009 + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0x4803f1f1 + 0x00001448 + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000001 + 0x00000000 + 0x00000036 + 0x00000026 + 0x00000038 + 0x08161414 + 0x0000002e + 0x00060009 + 0x0000b080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x11111111 + 0x11111111 + 0x001e0023 + 0x0024002c + 0x00230029 + 0x0026002d + 0x00080008 + 0x00080008 + 0x001e0023 + 0x0024002c + 0x00230029 + 0x0026002d + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x0000001c + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x0000000a + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000004 + 0x00000005 + 0x00000013 + 0x0000000c + 0x0000000d + 0x00000003 + 0x00000003 + 0x0000000c + 0x00000007 + 0x00000007 + 0x0000000b + 0x00000008 + 0x00000008 + 0x0000001d + 0x04050303 + 0x000b0709 + 0x718a1e14 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x000000ad + 0x0080001a + 0x00000efc + 0x0099003d + 0x00990038 + 0x00990041 + 0x00990090 + 0x00990005 + 0x00990090 + 0x00990005 + 0x00340049 + 0x00990080 + 0x00990004 + 0x0008001b + 0x00000099 + 0x00990004 + 0x0099001e + 0x0099001e + 0x00990018 + 0x00990095 + 0x00990023 + 0x00000099 + 0x0000002c + 0x00990099 + >; + }; + emc-table@1600000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "03_1600000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <1600000>; + nvidia,emc-min-mv = <887>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000002f0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000001>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000040>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000002f>; + nvidia,emc-mrw = <0x08010054>; + nvidia,emc-mrw2 = <0x0802002d>; + nvidia,emc-mrw3 = <0x080d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x0c0e4848>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040000>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x0000049c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x0000002a + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000017 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000024 + 0x00000009 + 0x1000001c + 0x10000002 + 0x00000014 + 0x0803f1f1 + 0x0000001d + 0x0000001f + 0x0000000e + 0x0006000c + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0x4803f1f1 + 0x00001860 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000000 + 0x00000000 + 0x0000003c + 0x0000002c + 0x0000003e + 0x08161414 + 0x00000034 + 0x0006000c + 0x00009080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c4848 + 0x880c4848 + 0x480c4848 + 0x480c4848 + 0x8c0e4848 + 0x8c0e4848 + 0x4c0e4848 + 0x4c0e4848 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x0000002a + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000017 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000024 + 0x00000009 + 0x1000001c + 0x10000002 + 0x00000014 + 0x0803f1f1 + 0x0000001d + 0x0000001f + 0x0000000e + 0x0006000c + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0x4803f1f1 + 0x00001860 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000001 + 0x0000001f + 0x00000042 + 0x0000002c + 0x00000044 + 0x08161414 + 0x00000034 + 0x0006000c + 0x00019080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x00000029 + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000011 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000023 + 0x00000002 + 0x1000001e + 0x10000002 + 0x00000016 + 0x0803f1f1 + 0x0000001b + 0x00000001 + 0x80000000 + 0x0006000e + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0x4803f1f1 + 0x00001860 + 0x00000000 + 0x9960400d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000001 + 0x0000001f + 0x00000046 + 0x00000036 + 0x00000048 + 0x08161414 + 0x0000003e + 0x0006000e + 0x00009080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x0000002a + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000017 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000024 + 0x00000009 + 0x1000001c + 0x10000002 + 0x00000014 + 0x0803f1f1 + 0x0000001d + 0x0000001f + 0x0000000e + 0x0006000c + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0x4803f1f1 + 0x00001860 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x080b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x10000000 + 0x08000000 + 0x08000000 + 0x00000000 + 0x00000000 + 0x00001000 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000001 + 0x00000000 + 0x0000003c + 0x0000002c + 0x0000003e + 0x08161414 + 0x00000034 + 0x0006000c + 0x0000b080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0x48161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0d0d0d0d + 0x0d0d0d0d + 0x11111111 + 0x11111111 + 0x001e0024 + 0x0024002f + 0x0024002b + 0x00270030 + 0x000a0009 + 0x000a000a + 0x001e0024 + 0x0024002f + 0x0024002b + 0x00270030 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000020 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x80000001 + 0x80000001 + 0x80000001 + 0x80000001 + 0x80000001 + 0x80000001 + 0x80000001 + 0x80000001 + 0x00000004 + 0x00000004 + 0x00000004 + 0x00000004 + >; + nvidia,emc-burst-mc-regs = < + 0x0000000c + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000006 + 0x00000007 + 0x00000018 + 0x0000000f + 0x0000000f + 0x00000003 + 0x00000003 + 0x0000000d + 0x00000007 + 0x00000007 + 0x0000000c + 0x00000008 + 0x00000009 + 0x00000023 + 0x04060303 + 0x000d080c + 0x718c2419 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x000000d0 + 0x0080001a + 0x00001203 + 0x0080003d + 0x00800038 + 0x00800041 + 0x00800090 + 0x00800005 + 0x00800090 + 0x00800005 + 0x00340049 + 0x00800080 + 0x00800004 + 0x00080016 + 0x00000080 + 0x00800004 + 0x00800019 + 0x00800019 + 0x00800018 + 0x00800095 + 0x0080001d + 0x00000080 + 0x0000002c + 0x00800080 + >; + }; + }; + }; +}; diff --git a/arch/arm64/boot/dts/nvidia/tegra210-p2894.dtsi b/arch/arm64/boot/dts/nvidia/tegra210-p2894.dtsi index b759d689122d..1e11e2428dbc 100644 --- a/arch/arm64/boot/dts/nvidia/tegra210-p2894.dtsi +++ b/arch/arm64/boot/dts/nvidia/tegra210-p2894.dtsi @@ -5,6 +5,7 @@ #include #include #include "tegra210.dtsi" +#include "tegra210-p2894-emc.dtsi" / { aliases { From patchwork Mon Mar 25 07:45:23 2019 Content-Type: text/plain; charset="utf-8" MIME-Version: 1.0 Content-Transfer-Encoding: 7bit X-Patchwork-Submitter: Joseph Lo X-Patchwork-Id: 1063889 Return-Path: X-Original-To: incoming@patchwork.ozlabs.org Delivered-To: patchwork-incoming@bilbo.ozlabs.org Authentication-Results: ozlabs.org; spf=none (mailfrom) smtp.mailfrom=vger.kernel.org (client-ip=209.132.180.67; helo=vger.kernel.org; envelope-from=linux-tegra-owner@vger.kernel.org; receiver=) Authentication-Results: ozlabs.org; dmarc=pass (p=none dis=none) header.from=nvidia.com Authentication-Results: ozlabs.org; dkim=pass (2048-bit key; unprotected) header.d=nvidia.com header.i=@nvidia.com header.b="rQRjbNkD"; dkim-atps=neutral Received: from vger.kernel.org (vger.kernel.org [209.132.180.67]) by ozlabs.org (Postfix) with ESMTP id 44SRLs0GZqz9sSg for ; Mon, 25 Mar 2019 18:52:37 +1100 (AEDT) Received: (majordomo@vger.kernel.org) by vger.kernel.org via listexpand id S1729819AbfCYHwg (ORCPT ); Mon, 25 Mar 2019 03:52:36 -0400 Received: from hqemgate15.nvidia.com ([216.228.121.64]:9039 "EHLO hqemgate15.nvidia.com" rhost-flags-OK-OK-OK-OK) by vger.kernel.org with ESMTP id S1729888AbfCYHwg (ORCPT ); Mon, 25 Mar 2019 03:52:36 -0400 Received: from hqpgpgate101.nvidia.com (Not Verified[216.228.121.13]) by hqemgate15.nvidia.com (using TLS: TLSv1.2, DES-CBC3-SHA) id ; Mon, 25 Mar 2019 00:45:51 -0700 Received: from hqmail.nvidia.com ([172.20.161.6]) by hqpgpgate101.nvidia.com (PGP Universal service); Mon, 25 Mar 2019 00:45:55 -0700 X-PGP-Universal: processed; by hqpgpgate101.nvidia.com on Mon, 25 Mar 2019 00:45:55 -0700 Received: from HQMAIL111.nvidia.com (172.20.187.18) by HQMAIL105.nvidia.com (172.20.187.12) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:54 +0000 Received: from HQMAIL101.nvidia.com (172.20.187.10) by HQMAIL111.nvidia.com (172.20.187.18) with Microsoft SMTP Server (TLS) id 15.0.1473.3; Mon, 25 Mar 2019 07:45:54 +0000 Received: from hqnvemgw02.nvidia.com (172.16.227.111) by HQMAIL101.nvidia.com (172.20.187.10) with Microsoft SMTP Server (TLS) id 15.0.1473.3 via Frontend Transport; Mon, 25 Mar 2019 07:45:54 +0000 Received: from josephl-linux.nvidia.com (Not Verified[10.19.108.132]) by hqnvemgw02.nvidia.com with Trustwave SEG (v7, 5, 8, 10121) id ; Mon, 25 Mar 2019 00:45:52 -0700 From: Joseph Lo To: Thierry Reding , Peter De Schrijver , Jonathan Hunter , "Rob Herring" , Stephen Boyd CC: , , , , Joseph Lo Subject: [PATCH 8/8] arm64: tegra: Add EMC table of ram code 1 for Tegra210 Shield platform Date: Mon, 25 Mar 2019 15:45:23 +0800 Message-ID: <20190325074523.26456-9-josephl@nvidia.com> X-Mailer: git-send-email 2.21.0 In-Reply-To: <20190325074523.26456-1-josephl@nvidia.com> References: <20190325074523.26456-1-josephl@nvidia.com> MIME-Version: 1.0 X-NVConfidentiality: public DKIM-Signature: v=1; a=rsa-sha256; c=relaxed/relaxed; d=nvidia.com; s=n1; t=1553499951; bh=2xk7+7/+M5cH0iwnpfM8/RNmhsdTuKgC+De+qNbGoa0=; 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=rQRjbNkDLbVUnXemWVqkFXJQdTFcmJmVLD5g96wbek0WV/CG0FGW+mupoOSSJGdyT wfc5Ozi+fDmBL6bh+qyA5u8Ms4y8Hf5rjefPqoq4NNI5BPsCdoum8rF9wddvsdGE9J 3i+ZJNYPeXUIJwRtKJkUzrfDsv+RCls6x9lanRnqHPC7LDqMrTs1gC8tdrJdhrseXz EwzioXigOISlcRuqg0j6cIvvvxnQjg9CSVRErrIlkCYyH6lusIf9/iiHa99chrX8wu ntSLDiibWkWc7AGQ0e/+HBveV8vZhTO/UszCHNXW7fhkZyQFQzh2cSTbs3TlbnJqkQ kLR2TbtDwmCXA== Sender: linux-tegra-owner@vger.kernel.org Precedence: bulk List-ID: X-Mailing-List: linux-tegra@vger.kernel.org Add EMC table of ram code 1 and revision number 7 for Tegra210 Shield platform. Signed-off-by: Joseph Lo --- .../boot/dts/nvidia/tegra210-p2894-emc.dtsi | 12423 ++++++++++++++++ 1 file changed, 12423 insertions(+) diff --git a/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi b/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi index 78e253cfbe86..2bf480bde5a3 100644 --- a/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi +++ b/arch/arm64/boot/dts/nvidia/tegra210-p2894-emc.dtsi @@ -12424,5 +12424,12428 @@ >; }; }; + emc-table@1 { + nvidia,ram-code = <1>; + emc-table@40800 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_40800_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <40800>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x40188012>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000003>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x88010004>; + nvidia,emc-mrw2 = <0x88020000>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x40188012>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x00005172>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x000000a0 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000000 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x88161414 + 0x00000011 + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x000000a0 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000001 + 0x0000001f + 0x00000013 + 0x00000003 + 0x00000015 + 0x88161414 + 0x0000000b + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x00000009 + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000005 + 0x88037171 + 0x00000008 + 0x00000001 + 0x80000000 + 0x00010002 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x000000a0 + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000001 + 0x0000001f + 0x0000001d + 0x00000013 + 0x0000001f + 0x88161414 + 0x0000001b + 0x00010002 + 0x00009080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000c + 0x00000008 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000d + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x30000002 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x0000009a + 0x00000000 + 0x00000026 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000008 + 0x00000008 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x000000a0 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090029 + 0x00290015 + 0x000b000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000023a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118600b + 0x00000001 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x88161414 + 0x00000011 + 0x00010001 + 0x0000b080 + 0x07070404 + 0x00040014 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000049 + 0x00000104 + 0x000000b4 + 0x0000007a + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x40020001 + 0x80000013 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000002 + 0x00000000 + 0x00000001 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000001 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000000 + 0x02020000 + 0x00030201 + 0x72c30303 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000006 + 0x0080001a + 0x00000076 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff003d + 0x00ff00ff + 0x00ff003d + 0x00ff0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ff + 0x000000ff + 0x00ff0004 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x000000ff + 0x000000ff + 0x00ff00ff + >; + }; + emc-table@68000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_68000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <68000>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x4018800a>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000005>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x88010004>; + nvidia,emc-mrw2 = <0x88020000>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x4018800a>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x000029e0>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000010a + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000000 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x88161414 + 0x00000011 + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000010a + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000001 + 0x0000001f + 0x00000014 + 0x00000004 + 0x00000016 + 0x88161414 + 0x0000000c + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x00000009 + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000003 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000005 + 0x88037171 + 0x00000009 + 0x00000001 + 0x80000000 + 0x00010002 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000010a + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000001 + 0x0000001f + 0x0000001d + 0x00000013 + 0x0000001f + 0x88161414 + 0x0000001b + 0x00010002 + 0x00009080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000c + 0x0000000d + 0x00000007 + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000d + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x30000002 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000000 + 0x0000000a + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000101 + 0x00000000 + 0x00000040 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x0000000d + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000010a + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090044 + 0x00440015 + 0x0011000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000309 + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186011 + 0x00000001 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x88161414 + 0x00000011 + 0x00010001 + 0x0000b080 + 0x07070404 + 0x00040022 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x0000002c + 0x00000104 + 0x000000b4 + 0x00000049 + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0xf0000001 + 0x80000024 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000002 + 0x00000000 + 0x00000001 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000001 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000001 + 0x02020000 + 0x00030201 + 0x72630303 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000009 + 0x0080001a + 0x000000c4 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff0025 + 0x00ff00ff + 0x00ff0025 + 0x00ff0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ff + 0x000000ff + 0x00ff0004 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x000000ff + 0x000000ff + 0x00ff00ff + >; + }; + emc-table@102000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_102000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <102000>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x40188006>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000007>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x88010004>; + nvidia,emc-mrw2 = <0x88020000>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x40188006>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x00001aea>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000003 + 0x88037171 + 0x0000000b + 0x00000000 + 0x0000000a + 0x00010000 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000018e + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000000 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x88161414 + 0x00000011 + 0x00010000 + 0x00009080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x00000000 + 0x00000003 + 0x88037171 + 0x0000000b + 0x00000000 + 0x0000000a + 0x00010000 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000018e + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000001 + 0x0000001f + 0x00000015 + 0x00000005 + 0x00000017 + 0x88161414 + 0x0000000d + 0x00010000 + 0x00009080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x00000009 + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000003 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000004 + 0x88037171 + 0x0000000a + 0x00000001 + 0x80000000 + 0x00010001 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000018e + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000001 + 0x0000001f + 0x0000001d + 0x00000013 + 0x0000001f + 0x88161414 + 0x0000001b + 0x00010001 + 0x00009080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000c + 0x00000013 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000008 + 0x00000004 + 0x0000000d + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000005 + 0x00000000 + 0x30000002 + 0x00000003 + 0x88037171 + 0x0000000b + 0x00000000 + 0x0000000a + 0x00010000 + 0x00000011 + 0x00000013 + 0x00000015 + 0x00000011 + 0x00000013 + 0x00000182 + 0x00000000 + 0x00000060 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000011 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000014 + 0x00000014 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000008 + 0x00000004 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000018e + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00090066 + 0x00660015 + 0x001a000a + 0xc1e00302 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x8000040b + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00100404 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118601a + 0x00000001 + 0x00000000 + 0x00000013 + 0x00000009 + 0x00000015 + 0x88161414 + 0x00000011 + 0x00010000 + 0x0000b080 + 0x07070404 + 0x00040032 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x0000001d + 0x00000104 + 0x000000b4 + 0x00000031 + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x50000001 + 0x80000033 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000002 + 0x00000000 + 0x00000001 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000001 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000002 + 0x02020000 + 0x00030201 + 0x72030303 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x0000000e + 0x0080001a + 0x00000126 + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff00ff + 0x00ff0018 + 0x00ff00ff + 0x00ff0018 + 0x00fe0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ff + 0x000000ff + 0x00ff0004 + 0x00ff00ff + 0x00ff00ff + 0x00ff00da + 0x00ff00ff + 0x00ff00ff + 0x000000ff + 0x000000ff + 0x00ff00ff + >; + }; + emc-table@204000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_204000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <204000>; + nvidia,emc-min-mv = <800>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_out0"; + nvidia,src-sel-reg = <0x40188002>; + nvidia,needs-training = <0x00000000>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x0000000d>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000015>; + nvidia,emc-mrw = <0x88010004>; + nvidia,emc-mrw2 = <0x88020000>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110805>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x40188002>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x00000d5c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000b + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000002 + 0x88037171 + 0x0000000d + 0x00000000 + 0x0000000b + 0x00010000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000031c + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000000 + 0x00000000 + 0x00000014 + 0x0000000a + 0x00000016 + 0x88161414 + 0x00000012 + 0x00010000 + 0x00009080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000b + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000003 + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000002 + 0x88037171 + 0x0000000d + 0x00000000 + 0x0000000b + 0x00010000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000031c + 0x00000000 + 0x9960a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x00000055 + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000001 + 0x0000001f + 0x00000018 + 0x00000008 + 0x0000001a + 0x88161414 + 0x00000010 + 0x00010000 + 0x00009080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000a + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x0000000c + 0x00000000 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000003 + 0x00000002 + 0x10000000 + 0x00000000 + 0x00000003 + 0x88037171 + 0x0000000b + 0x00000001 + 0x80000000 + 0x00040000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000031c + 0x00000000 + 0x9160400d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00058037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000001 + 0x0000001f + 0x0000001e + 0x00000014 + 0x00000020 + 0x88161414 + 0x0000001c + 0x00040000 + 0x00009080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x0000000d + 0x00000025 + 0x00000013 + 0x00000000 + 0x00000000 + 0x00000009 + 0x00000004 + 0x0000000e + 0x0000000d + 0x00000008 + 0x0000000b + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000006 + 0x00000006 + 0x00000006 + 0x00000013 + 0x00000013 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000000 + 0x00000004 + 0x00000008 + 0x0000000d + 0x00000005 + 0x00000006 + 0x30000000 + 0x30000002 + 0x00000002 + 0x88037171 + 0x0000000d + 0x00000000 + 0x0000000b + 0x00040000 + 0x00000012 + 0x00000014 + 0x00000016 + 0x00000012 + 0x00000014 + 0x00000304 + 0x00000000 + 0x000000c1 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000012 + 0x00000005 + 0x00000002 + 0x0000000d + 0x00000027 + 0x00000027 + 0x00000005 + 0x00000005 + 0x00000004 + 0x00000009 + 0x00000005 + 0x00000003 + 0x00000009 + 0xc8037171 + 0x0000031c + 0x00000000 + 0x9160a00d + 0x00003bbf + 0x002c00a0 + 0x00008000 + 0x000000be + 0x0fff0fff + 0x0fff0fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00100010 + 0x00100010 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x0028002c + 0x002a002b + 0x002d002d + 0x00270028 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000900cc + 0x00cc0015 + 0x0033000a + 0xc1e00303 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x0fff0fff + 0x80000713 + 0x0000000a + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00050037 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffefff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186033 + 0x00000001 + 0x00000000 + 0x00000014 + 0x0000000a + 0x00000016 + 0x88161414 + 0x00000012 + 0x00040000 + 0x0000b080 + 0x07070404 + 0x00040065 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x01200120 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00249249 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000018 + 0x00000006 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x08000001 + 0x8000004c + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000000 + 0x00000003 + 0x00000001 + 0x00000002 + 0x00000001 + 0x00000002 + 0x00000005 + 0x00000001 + 0x00000001 + 0x00000004 + 0x00000008 + 0x00000005 + 0x00000004 + 0x02020000 + 0x00030201 + 0x71c30504 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x0000001b + 0x0080001a + 0x0000024c + 0x00ff00b2 + 0x00ff00da + 0x00ff009d + 0x00ff00ff + 0x00ff000c + 0x00ff00ff + 0x00ff000c + 0x007f0049 + 0x00ff0080 + 0x00ff0004 + 0x000800ad + 0x000000ff + 0x00ff0004 + 0x00ff00c6 + 0x00ff00c6 + 0x00ff006d + 0x00ff00ff + 0x00ff00e2 + 0x000000ff + 0x00000080 + 0x00ff00ff + >; + }; + emc-table@408000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_408000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <408000>; + nvidia,emc-min-mv = <812>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllp_ud"; + nvidia,src-sel-reg = <0xe0188000>; + nvidia,needs-training = <0x00000010>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x0000001a>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000001b>; + nvidia,emc-mrw = <0x88010014>; + nvidia,emc-mrw2 = <0x88020009>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0xe0188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000001>; + nvidia,emc-clock-latency-change = <0x000006d6>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000013 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000c + 0x00000006 + 0x00000000 + 0x30000000 + 0x00000007 + 0x88037171 + 0x0000000f + 0x00000007 + 0x0000000b + 0x00010004 + 0x00000019 + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0xc8037171 + 0x00000638 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x000000be + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050035 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000000 + 0x00000000 + 0x00000021 + 0x00000011 + 0x00000023 + 0x88161414 + 0x00000019 + 0x00010004 + 0x00009080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000013 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000c + 0x00000006 + 0x00000000 + 0x30000000 + 0x00000007 + 0x88037171 + 0x0000000f + 0x00000007 + 0x0000000b + 0x00010004 + 0x00000019 + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0xc8037171 + 0x00000638 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x00000055 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000001 + 0x0000001f + 0x00000023 + 0x0000000d + 0x00000025 + 0x88161414 + 0x00000015 + 0x00010004 + 0x00009080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000012 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x0000000e + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000a + 0x00000002 + 0x10000006 + 0x30000000 + 0x00000008 + 0x88037171 + 0x0000000d + 0x00000001 + 0x80000000 + 0x00050001 + 0x0000001b + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0xc8037171 + 0x00000638 + 0x00000000 + 0x9160400d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x000000be + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x05058035 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000001 + 0x0000001f + 0x0000002b + 0x0000001b + 0x0000002d + 0x88161414 + 0x00000025 + 0x00050001 + 0x00009080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000019 + 0x0000004a + 0x00000025 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000008 + 0x00000013 + 0x0000000f + 0x00000008 + 0x00000011 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000008 + 0x00000008 + 0x00000006 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000006 + 0x00000004 + 0x00000002 + 0x00000006 + 0x00000008 + 0x0000000d + 0x0000000c + 0x00000006 + 0x10000005 + 0x30000000 + 0x00000007 + 0x88037171 + 0x0000000f + 0x00000007 + 0x0000000b + 0x00050000 + 0x00000019 + 0x00000021 + 0x00000023 + 0x0000001f + 0x00000021 + 0x00000607 + 0x00000000 + 0x00000181 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000018 + 0x00000005 + 0x00000002 + 0x00000011 + 0x0000004d + 0x0000004d + 0x00000005 + 0x00000007 + 0x00000004 + 0x00000011 + 0x00000009 + 0x00000003 + 0x0000000a + 0xc8037171 + 0x00000638 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc01c03bb + 0x00008000 + 0x000000be + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00020002 + 0x00020002 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00000001 + 0x00020004 + 0x00010003 + 0x00030005 + 0x00000000 + 0x00000000 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00020002 + 0x00000002 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x000e0198 + 0x0198001b + 0x0066000a + 0xc1e00304 + 0x1f13412f + 0x00010014 + 0x00000804 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x80000d22 + 0x00000011 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050035 + 0x00000000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x00000008 + 0x00030808 + 0x00015c00 + 0x00101010 + 0x00001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186066 + 0x00000001 + 0x00000000 + 0x00000021 + 0x00000011 + 0x00000023 + 0x88161414 + 0x00000019 + 0x00050000 + 0x0000b080 + 0x07070404 + 0x000400cb + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00100010 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x28282828 + 0x28282828 + 0x00200021 + 0x00210023 + 0x00210022 + 0x00210024 + 0x00020002 + 0x00020002 + 0x00200021 + 0x00210023 + 0x00210022 + 0x00210024 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x0000000c + 0x0000000c + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x01000003 + 0x8000007f + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000001 + 0x00000006 + 0x00000003 + 0x00000004 + 0x00000001 + 0x00000002 + 0x00000007 + 0x00000001 + 0x00000001 + 0x00000006 + 0x00000008 + 0x00000005 + 0x00000009 + 0x02030000 + 0x00040203 + 0x71a40a07 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000035 + 0x0080001a + 0x00000498 + 0x00ff0059 + 0x00ff006d + 0x00ff004f + 0x00ff00af + 0x00ff0006 + 0x00ff00af + 0x00ff0006 + 0x00400049 + 0x00ff0080 + 0x00ff0004 + 0x00080057 + 0x000000ff + 0x00ff0004 + 0x00ff0063 + 0x00ff0063 + 0x00ff0036 + 0x00ff00ff + 0x00ff0071 + 0x000000ff + 0x00000040 + 0x00ff00ff + >; + }; + emc-table@665600 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_665600_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <665600>; + nvidia,emc-min-mv = <825>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x00000010>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x0000002a>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000001f>; + nvidia,emc-mrw = <0x88010024>; + nvidia,emc-mrw2 = <0x88020012>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x000004ce>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000006 + 0x00000000 + 0x30000000 + 0x0000000a + 0x88037171 + 0x00000011 + 0x0000000c + 0x0000000b + 0x00010007 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0xc8037171 + 0x00000a24 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050033 + 0x05050000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000000 + 0x00000000 + 0x00000026 + 0x00000016 + 0x00000028 + 0x88161414 + 0x0000001e + 0x00010007 + 0x00009080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x00000004 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000006 + 0x00000000 + 0x30000000 + 0x0000000a + 0x88037171 + 0x00000011 + 0x0000000c + 0x0000000b + 0x00010007 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0xc8037171 + 0x00000a24 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05058033 + 0x05050000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000001 + 0x0000001f + 0x00000029 + 0x00000013 + 0x0000002b + 0x88161414 + 0x0000001b + 0x00010007 + 0x00009080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000016 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x0000000f + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x0000000f + 0x00000002 + 0x1000000b + 0x30000000 + 0x0000000b + 0x88037171 + 0x00000010 + 0x00000001 + 0x80000000 + 0x00050004 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0xc8037171 + 0x00000a24 + 0x00000000 + 0x9160400d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x05058033 + 0x05050000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000001 + 0x0000001f + 0x00000030 + 0x00000020 + 0x00000032 + 0x88161414 + 0x00000028 + 0x00050004 + 0x00009080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000028 + 0x00000078 + 0x0000003c + 0x00000000 + 0x00000000 + 0x0000001c + 0x0000000c + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000c + 0x0000000c + 0x00000007 + 0x00000014 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000006 + 0x1000000a + 0x30000000 + 0x0000000a + 0x88037171 + 0x00000011 + 0x0000000c + 0x0000000b + 0x00050003 + 0x0000001e + 0x00000026 + 0x00000028 + 0x00000024 + 0x00000026 + 0x000009e4 + 0x00000000 + 0x00000279 + 0x00000008 + 0x00000008 + 0x00000003 + 0x00000003 + 0x00000003 + 0x0000001f + 0x00000006 + 0x00000002 + 0x00000015 + 0x0000007d + 0x0000007d + 0x00000006 + 0x0000000a + 0x00000005 + 0x0000001b + 0x0000000e + 0x00000003 + 0x0000000c + 0xc8037171 + 0x00000a24 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00b02bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00040004 + 0x00040004 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040008 + 0x00020006 + 0x00050009 + 0x00000000 + 0x00000000 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00040004 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0015029a + 0x029a001f + 0x00a7000a + 0xc1e00305 + 0x1f13412f + 0x00010014 + 0x00000806 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800014c9 + 0x00000016 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x05050033 + 0x05050000 + 0x00000010 + 0x00003000 + 0x0a000000 + 0x02000111 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe2ff + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860a7 + 0x00000001 + 0x00000000 + 0x00000026 + 0x00000016 + 0x00000028 + 0x88161414 + 0x0000001e + 0x00050003 + 0x0000b080 + 0x07070404 + 0x0004014c + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x14141414 + 0x14141414 + 0x2e2e2e2e + 0x2e2e2e2e + 0x001f0021 + 0x00220026 + 0x00210024 + 0x00230026 + 0x00040004 + 0x00040004 + 0x001f0021 + 0x00220026 + 0x00210024 + 0x00230026 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000010 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x00000005 + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000001 + 0x00000002 + 0x00000009 + 0x00000005 + 0x00000006 + 0x00000001 + 0x00000002 + 0x00000009 + 0x00000001 + 0x00000001 + 0x00000007 + 0x00000008 + 0x00000006 + 0x0000000e + 0x03030000 + 0x00060304 + 0x71a50f0a + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000057 + 0x0080001a + 0x0000077e + 0x00ff003d + 0x00ff0043 + 0x00ff0041 + 0x00ff0090 + 0x00ff0005 + 0x00ff0090 + 0x00ff0005 + 0x00340049 + 0x00ff0080 + 0x00ff0004 + 0x00080035 + 0x000000ff + 0x00ff0004 + 0x00ff003d + 0x00ff003d + 0x00ff0029 + 0x00ff00d8 + 0x00ff0045 + 0x000000ff + 0x0000002c + 0x00ff00ff + >; + }; + emc-table@800000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_800000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <800000>; + nvidia,emc-min-mv = <825>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000000d0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000033>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000001f>; + nvidia,emc-mrw = <0x88010024>; + nvidia,emc-mrw2 = <0x88020012>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e7272>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x000004b0>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000007 + 0x1000000a + 0x30000000 + 0x00000009 + 0x88037171 + 0x00000013 + 0x0000000c + 0x0000000c + 0x00050002 + 0x00000020 + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0xc8037171 + 0x00000c30 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000000 + 0x00000000 + 0x00000027 + 0x00000017 + 0x00000029 + 0x88161414 + 0x00000020 + 0x00050002 + 0x00009080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e7272 + 0x8c0e7272 + 0x4c0e7272 + 0x4c0e7272 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000007 + 0x1000000a + 0x30000000 + 0x00000009 + 0x88037171 + 0x00000013 + 0x0000000c + 0x0000000c + 0x00050002 + 0x00000020 + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0xc8037171 + 0x00000c30 + 0x00000000 + 0x9960a00d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000001 + 0x0000001f + 0x0000002d + 0x00000017 + 0x0000002f + 0x88161414 + 0x00000020 + 0x00050002 + 0x00009080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000016 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000010 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x0000000f + 0x00000002 + 0x1000000b + 0x30000000 + 0x0000000a + 0x88037171 + 0x00000011 + 0x00000001 + 0x80000000 + 0x00050003 + 0x0000001f + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0xc8037171 + 0x00000c30 + 0x00000000 + 0x9160400d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000001 + 0x0000001f + 0x00000031 + 0x00000021 + 0x00000033 + 0x88161414 + 0x00000029 + 0x00050003 + 0x00009080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000030 + 0x00000090 + 0x00000048 + 0x00000000 + 0x00000000 + 0x00000022 + 0x0000000f + 0x00000017 + 0x00000011 + 0x00000008 + 0x00000019 + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000000f + 0x0000000f + 0x00000008 + 0x00000015 + 0x00000013 + 0x00000006 + 0x00000008 + 0x00000006 + 0x00000004 + 0x00000008 + 0x00000008 + 0x0000000d + 0x00000011 + 0x00000007 + 0x1000000a + 0x30000000 + 0x00000009 + 0x88037171 + 0x00000013 + 0x0000000c + 0x0000000c + 0x00050002 + 0x00000020 + 0x00000027 + 0x00000029 + 0x00000025 + 0x00000027 + 0x00000bf0 + 0x00000000 + 0x000002fc + 0x00000009 + 0x00000009 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000021 + 0x00000007 + 0x00000002 + 0x00000019 + 0x00000096 + 0x00000096 + 0x00000007 + 0x0000000c + 0x00000006 + 0x00000020 + 0x00000011 + 0x00000003 + 0x0000000d + 0xc8037171 + 0x00000c30 + 0x00000000 + 0x9160a00d + 0x00003bbf + 0xc00702bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0000 + 0x00050004 + 0x00050005 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00010003 + 0x00040009 + 0x00030007 + 0x0007000b + 0x00000000 + 0x00000000 + 0x00040004 + 0x00050005 + 0x00050005 + 0x00050005 + 0x00000004 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00190320 + 0x0320001f + 0x00c8000c + 0xc1e00306 + 0x1f13412f + 0x00000014 + 0x00000807 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800018c8 + 0x00000017 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x011860c8 + 0x00000001 + 0x00000000 + 0x00000027 + 0x00000017 + 0x00000029 + 0x88161414 + 0x00000020 + 0x00050002 + 0x0000b080 + 0x07070404 + 0x00040190 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00107240 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x11111111 + 0x11111111 + 0x001f0022 + 0x00220027 + 0x00220025 + 0x00230028 + 0x00050004 + 0x00050005 + 0x001f0022 + 0x00220027 + 0x00220025 + 0x00230028 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000010 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x00000006 + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000002 + 0x00000003 + 0x0000000c + 0x00000007 + 0x00000007 + 0x00000001 + 0x00000002 + 0x00000008 + 0x00000001 + 0x00000001 + 0x00000007 + 0x00000008 + 0x00000006 + 0x00000011 + 0x03030000 + 0x00070406 + 0x7186120d + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x00000068 + 0x0080001a + 0x00000902 + 0x00ff003d + 0x00ff0038 + 0x00ff0041 + 0x00ff0090 + 0x00ff0005 + 0x00ff0090 + 0x00ff0005 + 0x00340049 + 0x00ff0080 + 0x00ff0004 + 0x0008002c + 0x000000ff + 0x00ff0004 + 0x00ff0032 + 0x00ff0032 + 0x00ff0022 + 0x00ff00b4 + 0x00ff003a + 0x000000ff + 0x0000002c + 0x00ff00ff + >; + }; + emc-table@1065600 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_1065600_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <1065600>; + nvidia,emc-min-mv = <837>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000000f0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000001>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000040>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x00000025>; + nvidia,emc-mrw = <0x88010034>; + nvidia,emc-mrw2 = <0x8802001b>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e4848>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110825>; + nvidia,emc-sel-dpd-ctrl = <0x00040008>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x0000049c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x00000020 + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x00000016 + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000018 + 0x00000008 + 0x10000011 + 0x10000000 + 0x0000000d + 0x8803f1f1 + 0x00000017 + 0x00000013 + 0x0000000d + 0x00050006 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0xc803f1f1 + 0x0000103c + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000000 + 0x00000000 + 0x0000002f + 0x0000001f + 0x00000031 + 0x88161414 + 0x00000027 + 0x00050006 + 0x00009080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e4848 + 0x8c0e4848 + 0x4c0e4848 + 0x4c0e4848 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x00000020 + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x00000016 + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000018 + 0x00000008 + 0x10000011 + 0x10000000 + 0x0000000d + 0x8803f1f1 + 0x00000017 + 0x00000013 + 0x0000000d + 0x00050006 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0xc803f1f1 + 0x0000103c + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000001 + 0x0000001f + 0x00000034 + 0x0000001e + 0x00000036 + 0x88161414 + 0x00000026 + 0x00050006 + 0x00009080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x0000001f + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x0000000f + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000016 + 0x00000002 + 0x10000012 + 0x10000000 + 0x0000000e + 0x8803f1f1 + 0x00000015 + 0x00000001 + 0x80000000 + 0x00050007 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0xc803f1f1 + 0x0000103c + 0x00000000 + 0x9160400d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000001 + 0x0000001f + 0x00000039 + 0x00000029 + 0x0000003b + 0x88161414 + 0x00000031 + 0x00050007 + 0x00009080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000040 + 0x000000c0 + 0x00000060 + 0x00000000 + 0x00000000 + 0x0000002d + 0x00000014 + 0x00000020 + 0x00000016 + 0x00000008 + 0x0000001f + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000014 + 0x00000014 + 0x0000000b + 0x00000016 + 0x00000013 + 0x00000006 + 0x0000000a + 0x00000008 + 0x00000006 + 0x0000000a + 0x00000008 + 0x0000000d + 0x00000018 + 0x00000008 + 0x10000011 + 0x10000000 + 0x0000000d + 0x8803f1f1 + 0x00000017 + 0x00000013 + 0x0000000d + 0x00050006 + 0x00000027 + 0x0000002f + 0x00000031 + 0x0000002d + 0x0000002f + 0x00000ffc + 0x00000000 + 0x000003ff + 0x0000000c + 0x0000000c + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000029 + 0x0000000a + 0x00000002 + 0x00000021 + 0x000000c8 + 0x000000c8 + 0x00000009 + 0x00000010 + 0x00000008 + 0x0000002b + 0x00000017 + 0x00000003 + 0x00000010 + 0xc803f1f1 + 0x0000103c + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00101bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00060006 + 0x00060006 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00020005 + 0x0006000c + 0x00040009 + 0x0009000e + 0x00000000 + 0x00000000 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00060006 + 0x00000006 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x0021042a + 0x042a0025 + 0x010b000f + 0xc1e00307 + 0x1f13612f + 0x00000014 + 0x00000809 + 0x00000550 + 0xf3200000 + 0x00000000 + 0x800020ab + 0x0000001f + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x0a000000 + 0x02000101 + 0x0000000f + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1e001600 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefffe210 + 0xc0c0c0c0 + 0xc0c0c0c0 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118610b + 0x00000001 + 0x00000000 + 0x0000002f + 0x0000001f + 0x00000031 + 0x88161414 + 0x00000027 + 0x00050006 + 0x0000b080 + 0x07070404 + 0x00040214 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f081300 + 0x00105800 + 0x1114fc00 + 0x07000300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x11111111 + 0x11111111 + 0x001f0023 + 0x0023002a + 0x00220027 + 0x0025002a + 0x00060006 + 0x00060006 + 0x001f0023 + 0x0023002a + 0x00220027 + 0x0025002a + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000016 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x00000008 + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000003 + 0x00000004 + 0x00000010 + 0x0000000a + 0x0000000a + 0x00000002 + 0x00000002 + 0x0000000a + 0x00000001 + 0x00000001 + 0x00000009 + 0x00000008 + 0x00000007 + 0x00000017 + 0x03040000 + 0x00090508 + 0x71881811 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x0000008b + 0x0080001a + 0x00000bff + 0x00c0003d + 0x00c00038 + 0x00c00041 + 0x00c00090 + 0x00c00005 + 0x00c00090 + 0x00c00005 + 0x00340049 + 0x00c00080 + 0x00c00004 + 0x00080021 + 0x000000c0 + 0x00c00004 + 0x00c00026 + 0x00c00026 + 0x00c00019 + 0x00c00095 + 0x00c0002b + 0x000000c0 + 0x0000002c + 0x00c000c0 + >; + }; + emc-table@1331200 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_1331200_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <1331200>; + nvidia,emc-min-mv = <850>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000002f0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000001>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000040>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000002b>; + nvidia,emc-mrw = <0x88010044>; + nvidia,emc-mrw2 = <0x88020024>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e4848>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x0011082d>; + nvidia,emc-sel-dpd-ctrl = <0x00040000>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x0000044c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000027 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000018 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001f + 0x00000008 + 0x10000017 + 0x10000000 + 0x00000011 + 0x8803f1f1 + 0x0000001a + 0x0000001a + 0x0000000d + 0x00060009 + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0xc803f1f1 + 0x00001448 + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000000 + 0x00000000 + 0x00000036 + 0x00000026 + 0x00000038 + 0x88161414 + 0x0000002e + 0x00060009 + 0x00009080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c7272 + 0x880c7272 + 0xc80c7272 + 0xc80c7272 + 0x8c0e4848 + 0x8c0e4848 + 0x4c0e4848 + 0x4c0e4848 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000027 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000018 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001f + 0x00000008 + 0x10000017 + 0x10000000 + 0x00000011 + 0x8803f1f1 + 0x0000001a + 0x0000001a + 0x0000000d + 0x00060009 + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0xc803f1f1 + 0x00001448 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000001 + 0x0000001f + 0x0000003a + 0x00000024 + 0x0000003c + 0x88161414 + 0x0000002c + 0x00060009 + 0x00009080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000026 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000012 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001e + 0x00000002 + 0x10000019 + 0x10000000 + 0x00000013 + 0x8803f1f1 + 0x00000018 + 0x00000001 + 0x80000000 + 0x0006000b + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0xc803f1f1 + 0x00001448 + 0x00000000 + 0x9160400d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000001 + 0x0000001f + 0x00000040 + 0x00000030 + 0x00000042 + 0x88161414 + 0x00000038 + 0x0006000b + 0x00009080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000050 + 0x000000f0 + 0x00000078 + 0x00000000 + 0x00000000 + 0x00000038 + 0x00000018 + 0x00000027 + 0x0000001b + 0x0000000a + 0x00000025 + 0x00000000 + 0x00000004 + 0x00000020 + 0x00000018 + 0x00000018 + 0x0000000e + 0x00000018 + 0x00000016 + 0x00000006 + 0x0000000c + 0x0000000a + 0x00000008 + 0x0000000c + 0x00000008 + 0x0000000d + 0x0000001f + 0x00000008 + 0x10000017 + 0x10000000 + 0x00000011 + 0x8803f1f1 + 0x0000001a + 0x0000001a + 0x0000000d + 0x00060009 + 0x0000002e + 0x00000036 + 0x00000038 + 0x00000034 + 0x00000036 + 0x00001408 + 0x00000000 + 0x00000502 + 0x0000000e + 0x0000000e + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000030 + 0x0000000c + 0x00000002 + 0x00000027 + 0x000000fa + 0x000000fa + 0x0000000b + 0x00000014 + 0x0000000a + 0x00000036 + 0x0000001c + 0x00000003 + 0x00000012 + 0xc803f1f1 + 0x00001448 + 0x00000000 + 0x9160a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b0606 + 0x00080008 + 0x00080008 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00020006 + 0x00080010 + 0x0005000c + 0x000b0012 + 0x00000000 + 0x00000000 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00080008 + 0x00000008 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00290534 + 0x0534002b + 0x014d0013 + 0xc1e00308 + 0x1f13612f + 0x00000014 + 0x0000080b + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000288f + 0x00000026 + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x0118614d + 0x00000001 + 0x00000000 + 0x00000036 + 0x00000026 + 0x00000038 + 0x88161414 + 0x0000002e + 0x00060009 + 0x0000b080 + 0x07070404 + 0x00040299 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00107240 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x11111111 + 0x11111111 + 0x11111111 + 0x11111111 + 0x001e0023 + 0x0024002c + 0x00230029 + 0x0026002d + 0x00080008 + 0x00080008 + 0x001e0023 + 0x0024002c + 0x00230029 + 0x0026002d + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x0000001c + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-burst-mc-regs = < + 0x0000000a + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000004 + 0x00000005 + 0x00000013 + 0x0000000c + 0x0000000d + 0x00000003 + 0x00000003 + 0x0000000c + 0x00000001 + 0x00000001 + 0x0000000b + 0x00000008 + 0x00000008 + 0x0000001d + 0x04050000 + 0x000b0709 + 0x718a1e14 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x000000ad + 0x0080001a + 0x00000efc + 0x0099003d + 0x00990038 + 0x00990041 + 0x00990090 + 0x00990005 + 0x00990090 + 0x00990005 + 0x00340049 + 0x00990080 + 0x00990004 + 0x0008001b + 0x00000099 + 0x00990004 + 0x0099001e + 0x0099001e + 0x00990018 + 0x00990095 + 0x00990023 + 0x00000099 + 0x0000002c + 0x00990099 + >; + }; + emc-table@1600000 { + compatible = "nvidia,tegra21-emc-table"; + nvidia,revision = <0x07>; + nvidia,dvfs-version = "02_1600000_NoCfgVersion_V9.8.4_V1.6"; + clock-frequency = <1600000>; + nvidia,emc-min-mv = <887>; + nvidia,gk20a-min-mv = <1100>; + nvidia,source = "pllm_ud"; + nvidia,src-sel-reg = <0x80188000>; + nvidia,needs-training = <0x000002f0>; + nvidia,training_pattern = <0x00000000>; + nvidia,trained = <0x00000000>; + nvidia,periodic_training = <0x00000001>; + nvidia,trained_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,trained_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c0d1u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d0u1 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u0 = <0x00000000>; + nvidia,current_dram_clktree_c1d1u1 = <0x00000000>; + nvidia,run_clocks = <0x00000040>; + nvidia,tree_margin = <0x00000001>; + nvidia,burst-regs-num = <221>; + nvidia,burst-regs-per-ch-num = <8>; + nvidia,trim-regs-num = <138>; + nvidia,trim-regs-per-ch-num = <10>; + nvidia,burst-mc-regs-num = <33>; + nvidia,la-scale-regs-num = <24>; + nvidia,vref-regs-num = <4>; + nvidia,training-mod-regs-num = <20>; + nvidia,dram-timing-regs-num = <5>; + nvidia,min-mrs-wait = <0x0000002f>; + nvidia,emc-mrw = <0x88010054>; + nvidia,emc-mrw2 = <0x8802002d>; + nvidia,emc-mrw3 = <0x880d0000>; + nvidia,emc-mrw4 = <0xc0000000>; + nvidia,emc-mrw9 = <0x8c0e4848>; + nvidia,emc-mrs = <0x00000000>; + nvidia,emc-emrs = <0x00000000>; + nvidia,emc-emrs2 = <0x00000000>; + nvidia,emc-auto-cal-config = <0xa01a51d8>; + nvidia,emc-auto-cal-config2 = <0x05500000>; + nvidia,emc-auto-cal-config3 = <0x00770000>; + nvidia,emc-auto-cal-config4 = <0x00770000>; + nvidia,emc-auto-cal-config5 = <0x00770000>; + nvidia,emc-auto-cal-config6 = <0x00770000>; + nvidia,emc-auto-cal-config7 = <0x00770000>; + nvidia,emc-auto-cal-config8 = <0x00770404>; + nvidia,emc-cfg-2 = <0x00110835>; + nvidia,emc-sel-dpd-ctrl = <0x00040000>; + nvidia,emc-fdpd-ctrl-cmd-no-ramp = <0x00000001>; + nvidia,dll-clk-src = <0x80188000>; + nvidia,clk-out-enb-x-0-clk-enb-emc-dll = <0x00000000>; + nvidia,emc-clock-latency-change = <0x0000049c>; + nvidia,ptfv = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0000000a + 0x0000000a + 0x0000000a + 0x00000001 + >; + nvidia,emc-registers = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x0000002a + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000017 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000024 + 0x00000009 + 0x1000001c + 0x10000002 + 0x00000014 + 0x8803f1f1 + 0x0000001d + 0x0000001f + 0x0000000e + 0x0006000c + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0xc803f1f1 + 0x00001860 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000000 + 0x00000000 + 0x0000003c + 0x0000002c + 0x0000003e + 0x88161414 + 0x00000034 + 0x0006000c + 0x00009080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-burst-regs-per-ch = < + 0x880c4848 + 0x880c4848 + 0xc80c4848 + 0xc80c4848 + 0x8c0e4848 + 0x8c0e4848 + 0x4c0e4848 + 0x4c0e4848 + >; + nvidia,emc-shadow-regs-ca-train = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x0000002a + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000017 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000024 + 0x00000009 + 0x1000001c + 0x10000002 + 0x00000014 + 0x8803f1f1 + 0x0000001d + 0x0000001f + 0x0000000e + 0x0006000c + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0xc803f1f1 + 0x00001860 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00008033 + 0x00000000 + 0x00000000 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000001 + 0x0000001f + 0x00000042 + 0x0000002c + 0x00000044 + 0x88161414 + 0x00000034 + 0x0006000c + 0x00009080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-quse-train = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x00000029 + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000011 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000023 + 0x00000002 + 0x1000001e + 0x10000002 + 0x00000016 + 0x8803f1f1 + 0x0000001b + 0x00000001 + 0x80000000 + 0x0006000e + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0xc803f1f1 + 0x00001860 + 0x00000000 + 0x9960400d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x30020000 + 0x00008033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000001 + 0x0000001f + 0x00000046 + 0x00000036 + 0x00000048 + 0x88161414 + 0x0000003e + 0x0006000e + 0x00009080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-shadow-regs-rdwr-train = < + 0x00000060 + 0x00000120 + 0x00000090 + 0x00000000 + 0x00000000 + 0x00000044 + 0x0000001d + 0x0000002a + 0x0000001f + 0x0000000c + 0x0000002d + 0x00000000 + 0x00000004 + 0x00000020 + 0x0000001d + 0x0000001d + 0x00000010 + 0x00000017 + 0x00000016 + 0x00000006 + 0x0000000e + 0x0000000c + 0x0000000a + 0x0000000e + 0x00000008 + 0x0000000d + 0x00000024 + 0x00000009 + 0x1000001c + 0x10000002 + 0x00000014 + 0x8803f1f1 + 0x0000001d + 0x0000001f + 0x0000000e + 0x0006000c + 0x00000034 + 0x0000003c + 0x0000003e + 0x0000003a + 0x0000003c + 0x00001820 + 0x00000000 + 0x00000608 + 0x00000010 + 0x00000010 + 0x00000003 + 0x00000003 + 0x00000003 + 0x00000037 + 0x0000000e + 0x00000002 + 0x0000002e + 0x0000012c + 0x0000012c + 0x0000000d + 0x00000018 + 0x0000000c + 0x00000040 + 0x00000022 + 0x00000003 + 0x00000014 + 0xc803f1f1 + 0x00001860 + 0x00000000 + 0x9960a00d + 0x00003bff + 0xc00001bb + 0x00008000 + 0x0000005f + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x880b6666 + 0x000a0009 + 0x000a000a + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00030007 + 0x00090013 + 0x0007000e + 0x000e0016 + 0x00000000 + 0x00000000 + 0x00090009 + 0x000a000a + 0x000a000a + 0x000a000a + 0x00000009 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x8020221f + 0x0220f40f + 0x00000012 + 0x00064000 + 0x00310640 + 0x0640002f + 0x01900017 + 0xc1e0030a + 0x1f13612f + 0x00000014 + 0x0000080d + 0x00000550 + 0xf3200000 + 0x00000000 + 0x8000308c + 0x0000002c + 0x00000000 + 0x00000000 + 0x00000012 + 0x00000012 + 0x00020000 + 0x00000033 + 0x00000000 + 0x00000011 + 0x00003000 + 0x02000000 + 0x02000101 + 0x00000007 + 0x00030808 + 0x00015c00 + 0x00102020 + 0x1fff1fff + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000034 + 0x00000040 + 0x18000800 + 0x08000800 + 0x08000800 + 0x08000800 + 0x00400080 + 0x08801004 + 0x00000020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0xefff2210 + 0x00000000 + 0x00000000 + 0xdcdcdcdc + 0x0a0a0a0a + 0x0a0a0a0a + 0x0a0a0a0a + 0x01186190 + 0x00000001 + 0x00000000 + 0x0000003c + 0x0000002c + 0x0000003e + 0x88161414 + 0x00000034 + 0x0006000c + 0x0000b080 + 0x07070404 + 0x00040320 + 0x0513801f + 0x1f101100 + 0x00000014 + 0x00103200 + 0x01124000 + 0x01125b6a + 0x0f081000 + 0x00105800 + 0x1110fc00 + 0x0f085300 + 0x00105800 + 0x1114fc00 + 0x07004300 + 0x00103200 + 0x55553c5a + 0xc8161414 + >; + nvidia,emc-trim-regs = < + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00200020 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x0e0e0e0e + 0x0e0e0e0e + 0x11111111 + 0x11111111 + 0x001e0024 + 0x0024002f + 0x0024002b + 0x00270030 + 0x000a0009 + 0x000a000a + 0x001e0024 + 0x0024002f + 0x0024002b + 0x00270030 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-trim-regs-per-ch = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-vref-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-dram-timing-regs = < + 0x00000012 + 0x00000104 + 0x000000b4 + 0x00000007 + 0x00000020 + >; + nvidia,emc-training-mod-regs = < + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + 0x00000000 + >; + nvidia,emc-save-restore-mod-regs = < + 0x80000002 + 0x80000002 + 0x80000002 + 0x80000002 + 0x80000002 + 0x80000002 + 0x80000002 + 0x80000002 + 0x00000004 + 0x00000004 + 0x00000004 + 0x00000004 + >; + nvidia,emc-burst-mc-regs = < + 0x0000000c + 0x80000080 + 0x000a1020 + 0x80001028 + 0x00000006 + 0x00000007 + 0x00000018 + 0x0000000f + 0x0000000f + 0x00000003 + 0x00000003 + 0x0000000d + 0x00000001 + 0x00000001 + 0x0000000c + 0x00000008 + 0x00000009 + 0x00000023 + 0x04060000 + 0x000d080c + 0x718c2419 + 0x70000f0f + 0x00000000 + 0x001f0000 + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + 0x0080001a + >; + nvidia,emc-la-scale-regs = < + 0x000000d0 + 0x0080001a + 0x00001203 + 0x0080003d + 0x00800038 + 0x00800041 + 0x00800090 + 0x00800005 + 0x00800090 + 0x00800005 + 0x00340049 + 0x00800080 + 0x00800004 + 0x00080016 + 0x00000080 + 0x00800004 + 0x00800019 + 0x00800019 + 0x00800018 + 0x00800095 + 0x0080001d + 0x00000080 + 0x0000002c + 0x00800080 + >; + }; + }; }; };