x86: Add Intel Quark Memory Reference Code (MRC) support
Subsystems (3)
RFC PATCH 5/9 x86: quark: Add System Memory Controller support
In reply to Simon GlassHi Simon,
Quoted 33 lines · Simon Glass
Hi Bin,
Quoted 13 lines · Bin Meng
The codes are actually doing the memory initialization stuff.
Signed-off-by Bin Meng <[email protected]>---
The most ugly codes I've ever seen ...
There are 252 warnings and 127 checks in this patch, which are:check:
arch/x86/cpu/quark/smc.c,1609: Alignment should match open parenthesis
warning:arch/x86/cpu/quark/smc.c,1610: line over 80 characters
warning:arch/x86/cpu/quark/smc.c,1633: Too many leading tabs - consider code refactoring
...Quoted 7 lines
Fixing 'Too many leading tabs ...' will be very dangerous, as I don't have all the details on how Intel's MRC codes are actually written to play with the hardware. Trying to refactor them may lead to a non-working MRC codes. For the 'line over 80 characters' issue, we have to leave them as is now due to the 'Too many leading tabs ...'. If I am trying to fix the 'Alignment should match open parenthesis' issue, I may end up adding more 'line over 80 characters' issues, so we have to bear with it. Sigh.
Understood. Will try to limit my comments.
Quoted 7 lines
arch/x86/cpu/quark/smc.c | 2764 ++++++++++++++++++++++++++++++++++++++++++++++ arch/x86/cpu/quark/smc.h | 446 ++++++++ 2 files changed, 3210 insertions(+) create mode 100644 arch/x86/cpu/quark/smc.c create mode 100644 arch/x86/cpu/quark/smc.h
Quoted 12 lines
arch/x86/cpu/quark/smc.c line 6
Quoted 12 lines
arch/x86/cpu/quark/smc.c new file +6
-0@@ -0,0 +1,2764 @@ +/* +* Copyright (C) 2013, Intel Corporation +* Copyright (C) 2015, Bin Meng <[email protected]> +* +* Ported from Intel released Quark UEFI BIOS +* QuarkSocPkg/QuarkNorthCluster/MemoryInit/Pei/
Removed the ending / in v2.
Quoted 165 lines
Quoted 165 lines
arch/x86/cpu/quark/smc.c new file +165
-0+* +* SPDX-License-Identifier: Intel +*/ + +#include <common.h> +#include <pci.h> +#include <asm/arch/device.h> +#include <asm/arch/mrc.h> +#include <asm/arch/msg_port.h> +#include "mrc_util.h" +#include "hte.h" +#include "smc.h" + +/* t_rfc values (in picoseconds) per density */ +static const uint32_t t_rfc[5 ] = { +90000 ,/* 512Mb */ +110000 ,/* 1Gb */ +160000 ,/* 2Gb */ +300000 ,/* 4Gb */ +350000 ,/* 8Gb */ +}; + +/* t_ck clock period in picoseconds per speed index 800, 1066, 1333 */ +static const uint32_t t_ck[3 ] = { +2500 , +1875 , +1500 +}; + +/* Global variables */ +static const uint16_t ddr_wclk[] = {193 ,158 }; +static const uint16_t ddr_wctl[] = {1 ,217 }; +static const uint16_t ddr_wcmd[] = {1 ,220 }; + +#ifdef BACKUP_RCVN +static const uint16_t ddr_rcvn[] = {129 ,498 }; +#endif + +#ifdef BACKUP_WDQS +static const uint16_t ddr_wdqs[] = {65 ,289 }; +#endif + +#ifdef BACKUP_RDQS +static const uint8_t ddr_rdqs[] = {32 ,24 }; +#endif + +#ifdef BACKUP_WDQ +static const uint16_t ddr_wdq[] = {32 ,257 }; +#endif + +/* Stop self refresh driven by MCU */ +void clear_self_refresh (struct mrc_params *mrc_params) +{ +ENTERFN (); + +/* clear the PMSTS Channel Self Refresh bits */ +mrc_write_mask (MEM_CTLR ,PMSTS ,BIT0 ,BIT0 ); + +LEAVEFN (); +} + +/* It will initialise timing registers in the MCU (DTR0..DTR4) */ +void prog_ddr_timing_control (struct mrc_params *mrc_params) +{ +uint8_t tcl, wl; +uint8_t trp, trcd, tras, twr, twtr, trrd, trtp, tfaw; +uint32_t tck; +u32 dtr0, dtr1, dtr2, dtr3, dtr4; +u32 tmp1, tmp2; + +ENTERFN (); + +/* mcu_init starts */ +mrc_post_code (0x02 ,0x00 ); + + dtr0 =msg_port_read (MEM_CTLR ,DTR0 ); + dtr1 =msg_port_read (MEM_CTLR ,DTR1 ); + dtr2 =msg_port_read (MEM_CTLR ,DTR2 ); + dtr3 =msg_port_read (MEM_CTLR ,DTR3 ); + dtr4 =msg_port_read (MEM_CTLR ,DTR4 ); + + tck = t_ck[mrc_params->ddr_speed];/* Clock in picoseconds */ + tcl = mrc_params->params.cl;/* CAS latency in clocks */ + trp = tcl;/* Per CAT MRC */ + trcd = tcl;/* Per CAT MRC */ + tras =MCEIL (mrc_params->params.ras, tck); + +/* Per JEDEC: tWR=15000ps DDR2/3 from 800-1600 */ + twr =MCEIL (15000 , tck); + + twtr =MCEIL (mrc_params->params.wtr, tck); + trrd =MCEIL (mrc_params->params.rrd, tck); + trtp =4 ;/* Valid for 800 and 1066, use 5 for 1333 */ + tfaw =MCEIL (mrc_params->params.faw, tck); + + wl =5 + mrc_params->ddr_speed; + + dtr0 &= ~(BIT0 |BIT1 ); + dtr0 |= mrc_params->ddr_speed; + dtr0 &= ~(BIT12 |BIT13 |BIT14 ); + tmp1 = tcl -5 ; + dtr0 |= ((tcl -5 ) <<12 ); + dtr0 &= ~(BIT4 |BIT5 |BIT6 |BIT7 ); + dtr0 |= ((trp -5 ) <<4 );/* 5 bit DRAM Clock */ + dtr0 &= ~(BIT8 |BIT9 |BIT10 |BIT11 ); + dtr0 |= ((trcd -5 ) <<8 );/* 5 bit DRAM Clock */ + + dtr1 &= ~(BIT0 |BIT1 |BIT2 ); + tmp2 = wl -3 ; + dtr1 |= (wl -3 ); + dtr1 &= ~(BIT8 |BIT9 |BIT10 |BIT11 ); + dtr1 |= ((wl +4 + twr -14 ) <<8 );/* Change to tWTP */ + dtr1 &= ~(BIT28 |BIT29 |BIT30 ); + dtr1 |= ((MMAX (trtp,4 ) -3 ) <<28 );/* 4 bit DRAM Clock */ + dtr1 &= ~(BIT24 |BIT25 ); + dtr1 |= ((trrd -4 ) <<24 );/* 4 bit DRAM Clock */ + dtr1 &= ~(BIT4 |BIT5 ); + dtr1 |= (1 <<4 ); + dtr1 &= ~(BIT20 |BIT21 |BIT22 |BIT23 ); + dtr1 |= ((tras -14 ) <<20 );/* 6 bit DRAM Clock */ + dtr1 &= ~(BIT16 |BIT17 |BIT18 |BIT19 ); + dtr1 |= ((((tfaw +1 ) >>1 ) -5 ) <<16 );/* 4 bit DRAM Clock */ +/* Set 4 Clock CAS to CAS delay (multi-burst) */ + dtr1 &= ~(BIT12 |BIT13 ); + + dtr2 &= ~(BIT0 |BIT1 |BIT2 ); + dtr2 |=1 ; + dtr2 &= ~(BIT8 |BIT9 |BIT10 ); + dtr2 |= (2 <<8 ); + dtr2 &= ~(BIT16 |BIT17 |BIT18 |BIT19 ); + dtr2 |= (2 <<16 ); + + dtr3 &= ~(BIT0 |BIT1 |BIT2 ); + dtr3 |=2 ; + dtr3 &= ~(BIT4 |BIT5 |BIT6 ); + dtr3 |= (2 <<4 ); + + dtr3 &= ~(BIT8 |BIT9 |BIT10 |BIT11 ); +if (mrc_params->ddr_speed ==DDRFREQ_800 ) { +/* Extended RW delay (+1) */ + dtr3 |= ((tcl -5 +1 ) <<8 ); + }else if (mrc_params->ddr_speed ==DDRFREQ_1066 ) { +/* Extended RW delay (+1) */ + dtr3 |= ((tcl -5 +1 ) <<8 ); + } + + dtr3 &= ~(BIT13 |BIT14 |BIT15 |BIT16 ); + dtr3 |= ((4 + wl + twtr -11 ) <<13 ); + + dtr3 &= ~(BIT22 |BIT23 ); +if (mrc_params->ddr_speed ==DDRFREQ_800 ) + dtr3 |= ((MMAX (0 ,1 -1 )) <<22 ); +else + dtr3 |= ((MMAX (0 ,2 -1 )) <<22 ); + + dtr4 &= ~(BIT0 |BIT1 ); + dtr4 |=1 ; + dtr4 &= ~(BIT4 |BIT5 |BIT6 ); + dtr4 |= (1 <<4 ); + dtr4 &= ~(BIT8 |BIT9 |BIT10 ); + dtr4 |= ((1 + tmp1 - tmp2 +2 ) <<8 ); + dtr4 &= ~(BIT12 |BIT13 |BIT14 ); + dtr4 |= ((1 + tmp1 - tmp2 +2 ) <<12 ); + dtr4 &= ~(BIT15 |BIT16 ); +
Quoted 8 lines
arch/x86/cpu/quark/smc.c line 176
Quoted 5 lines
arch/x86/cpu/quark/smc.c new file +5
-0+msg_port_write (MEM_CTLR ,DTR0 , dtr0); +msg_port_write (MEM_CTLR ,DTR1 , dtr1); +msg_port_write (MEM_CTLR ,DTR2 , dtr2); +msg_port_write (MEM_CTLR ,DTR3 , dtr3); +msg_port_write (MEM_CTLR ,DTR4 , dtr4);This bit stuff is a mess. It obscures the meaning IMO and we would be much better off with proper named #defines. What can we do here?
I agree it is a mess. To me DDR memory intialization itself is a black magic, with complicated hardware technology so we get ugly software codes in accompany with :( The MRC codes is a collection of analog electronics that are more similar to radio oscillators than to digital circuits appear to be a digital domain memory controller... These register fields are pure DDR timing numbers. I cannot find a better way of doing that, thus leave this unchanged in v2.
Quoted 134 lines
Quoted 121 lines
arch/x86/cpu/quark/smc.c new file +121
-0+ +LEAVEFN (); +} + +/* Configure MCU before jedec init sequence */ +void prog_decode_before_jedec (struct mrc_params *mrc_params) +{ +u32 drp; +u32 drfc; +u32 dcal; +u32 dsch; +u32 dpmc0; + +ENTERFN (); + +/* Disable power saving features */ + dpmc0 =msg_port_read (MEM_CTLR ,DPMC0 ); + dpmc0 |= (BIT24 |BIT25 ); + dpmc0 &= ~(BIT16 |BIT17 |BIT18 ); + dpmc0 &= ~BIT23 ; +msg_port_write (MEM_CTLR ,DPMC0 , dpmc0); + +/* Disable out of order transactions */ + dsch =msg_port_read (MEM_CTLR ,DSCH ); + dsch |= (BIT8 |BIT12 ); +msg_port_write (MEM_CTLR ,DSCH , dsch); + +/* Disable issuing the REF command */ + drfc =msg_port_read (MEM_CTLR ,DRFC ); + drfc &= ~(BIT12 |BIT13 |BIT14 ); +msg_port_write (MEM_CTLR ,DRFC , drfc); + +/* Disable ZQ calibration short */ + dcal =msg_port_read (MEM_CTLR ,DCAL ); + dcal &= ~(BIT8 |BIT9 |BIT10 ); + dcal &= ~(BIT12 |BIT13 ); +msg_port_write (MEM_CTLR ,DCAL , dcal); + +/* +* Training performed in address mode 0, rank population has limited +* impact, however simulator complains if enabled non-existing rank. +*/ + drp =0 ; +if (mrc_params->rank_enables &1 ) + drp |=BIT0 ; +if (mrc_params->rank_enables &2 ) + drp |=BIT1 ; +msg_port_write (MEM_CTLR ,DRP , drp); + +LEAVEFN (); +} + +/* +* After Cold Reset, BIOS should set COLDWAKE bit to 1 before +* sending the WAKE message to the Dunit. +* +* For Standby Exit, or any other mode in which the DRAM is in +* SR, this bit must be set to 0. +*/ +void perform_ddr_reset (struct mrc_params *mrc_params) +{ +ENTERFN (); + +/* Set COLDWAKE bit before sending the WAKE message */ +mrc_write_mask (MEM_CTLR ,DRMC ,BIT16 ,BIT16 ); + +/* Send wake command to DUNIT (MUST be done before JEDEC) */ +dram_wake_command (); + +/* Set default value */ +msg_port_write (MEM_CTLR ,DRMC , + (mrc_params->rd_odt_value ==0 ?BIT12 :0 )); + +LEAVEFN (); +} + + +/* +* This function performs some initialization on the DDRIO unit. +* This function is dependent on BOARD_ID, DDR_SPEED, and CHANNEL_ENABLES. +*/ +void ddrphy_init (struct mrc_params *mrc_params) +{ +uint32_t temp; +uint8_t ch;/* channel counter */ +uint8_t rk;/* rank counter */ +uint8_t bl_grp;/* byte lane group counter (2 BLs per module) */ +uint8_t bl_divisor =1 ;/* byte lane divisor */ +/* For DDR3 --> 0 == 800, 1 == 1066, 2 == 1333 */ +uint8_t speed = mrc_params->ddr_speed & (BIT1 |BIT0 ); +uint8_t cas; +uint8_t cwl; + +ENTERFN (); + + cas = mrc_params->params.cl; + cwl =5 + mrc_params->ddr_speed; + +/* ddrphy_init starts */ +mrc_post_code (0x03 ,0x00 ); + +/* +* HSD#231531 +* Make sure IOBUFACT is deasserted before initializing the DDR PHY +* +* HSD#234845 +* Make sure WRPTRENABLE is deasserted before initializing the DDR PHY +*/ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* Deassert DDRPHY Initialization Complete */ +mrc_alt_write_mask (DDRPHY , + (CMDPMCONFIG0 + (ch *DDRIOCCC_CH_OFFSET )), + ~BIT20 ,BIT20 );/* SPID_INIT_COMPLETE=0 */ +/* Deassert IOBUFACT */ +mrc_alt_write_mask (DDRPHY , + (CMDCFGREG0 + (ch *DDRIOCCC_CH_OFFSET )), + ~BIT2 ,BIT2 );/* IOBUFACTRST_N=0 */ +/* Disable WRPTR */ + mrc_alt_write_mask(DDRPHY, + (CMDPTRREG + (ch * DDRIOCCC_CH_OFFSET)),arch/x86/cpu/quark/smc.c line 307
Quoted 10 lines
arch/x86/cpu/quark/smc.c new file +10
-0+ ~BIT0, BIT0); /* WRPTRENABLE=0 */ + } + } + +/* Put PHY in reset */ +mrc_alt_write_mask (DDRPHY ,MASTERRSTN ,0 ,BIT0 ); + +/* Initialize DQ01, DQ23, CMD, CLK-CTL, COMP modules */ + +/* STEP0 */ Can you put each step in its own static function?
Quoted 6 lines
for (ch = 0; ch <
NUM_CHANNELS; ch++)step0(ch); for (ch = 0; ch < NUM_CHANNELS; ch++) step1(ch);etc.
I am afraid it is not that simple. We need pass lots of variable to these static functions as parameters. I feel it does no good, instead creating possiblity of breaking the MRC, thus I left it unchanged.
Quoted 1,082 lines
Quoted 1,082 lines
arch/x86/cpu/quark/smc.c new file +1082
-0+mrc_post_code (0x03 ,0x10 ); +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* DQ01-DQ23 */ +for (bl_grp =0 ; + bl_grp < ((NUM_BYTE_LANES / bl_divisor)/2 ); + bl_grp++) { +/* Analog MUX select - IO2xCLKSEL */ +mrc_alt_write_mask (DDRPHY , + (DQOBSCKEBBCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + ((bl_grp) ? (0x00 ) : (BIT22 )), (BIT22 )); + +/* ODT Strength */ +switch (mrc_params->rd_odt_value) { +case 1 : + temp =0x3 ; +break ;/* 60 ohm */ +case 2 : + temp =0x3 ; +break ;/* 120 ohm */ +case 3 : + temp =0x3 ; +break ;/* 180 ohm */ +default : + temp =0x3 ; +break ;/* 120 ohm */ + } + +/* ODT strength */ +mrc_alt_write_mask (DDRPHY , + (B0RXIOBUFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (temp <<5 ), (BIT6 |BIT5 )); +/* ODT strength */ +mrc_alt_write_mask (DDRPHY , + (B1RXIOBUFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (temp <<5 ), (BIT6 |BIT5 )); + +/* Dynamic ODT/DIFFAMP */ + temp = (((cas) <<24 ) | ((cas) <<16 ) | + ((cas) <<8 ) | ((cas) <<0 )); +switch (speed) { +case 0 : + temp -=0x01010101 ; +break ;/* 800 */ +case 1 : + temp -=0x02020202 ; +break ;/* 1066 */ +case 2 : + temp -=0x03030303 ; +break ;/* 1333 */ +case 3 : + temp -=0x04040404 ; +break ;/* 1600 */ + } + +/* Launch Time: ODT, DIFFAMP, ODT, DIFFAMP */ +mrc_alt_write_mask (DDRPHY , + (B01LATCTL1 + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + temp, + (BIT28 |BIT27 |BIT26 |BIT25 |BIT24 | +BIT20 |BIT19 |BIT18 |BIT17 |BIT16 | +BIT12 |BIT11 |BIT10 |BIT9 |BIT8 | +BIT4 |BIT3 |BIT2 |BIT1 |BIT0 )); +switch (speed) { +/* HSD#234715 */ +case 0 : + temp = ((0x06 <<16 ) | (0x07 <<8 )); +break ;/* 800 */ +case 1 : + temp = ((0x07 <<16 ) | (0x08 <<8 )); +break ;/* 1066 */ +case 2 : + temp = ((0x09 <<16 ) | (0x0A <<8 )); +break ;/* 1333 */ +case 3 : + temp = ((0x0A <<16 ) | (0x0B <<8 )); +break ;/* 1600 */ + } + +/* On Duration: ODT, DIFFAMP */ +mrc_alt_write_mask (DDRPHY , + (B0ONDURCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + temp, + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT13 |BIT12 |BIT11 |BIT10 | +BIT9 |BIT8 )); +/* On Duration: ODT, DIFFAMP */ +mrc_alt_write_mask (DDRPHY , + (B1ONDURCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + temp, + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT13 |BIT12 |BIT11 |BIT10 | +BIT9 |BIT8 )); + +switch (mrc_params->rd_odt_value) { +case 0 : +/* override DIFFAMP=on, ODT=off */ + temp = ((0x3F <<16 ) | (0x3f <<10 )); +break ; +default : +/* override DIFFAMP=on, ODT=on */ + temp = ((0x3F <<16 ) | (0x2A <<10 )); +break ; + } + +/* Override: DIFFAMP, ODT */ +mrc_alt_write_mask (DDRPHY , + (B0OVRCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + temp, + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT15 |BIT14 |BIT13 |BIT12 | +BIT11 |BIT10 )); +/* Override: DIFFAMP, ODT */ +mrc_alt_write_mask (DDRPHY , + (B1OVRCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + temp, + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT15 |BIT14 |BIT13 |BIT12 | +BIT11 |BIT10 )); + +/* DLL Setup */ + +/* 1xCLK Domain Timings: tEDP,RCVEN,WDQS (PO) */ +mrc_alt_write_mask (DDRPHY , + (B0LATCTL0 + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (((cas +7 ) <<16 ) | ((cas -4 ) <<8 ) | + ((cwl -2 ) <<0 )), + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT12 |BIT11 |BIT10 |BIT9 | +BIT8 |BIT4 |BIT3 |BIT2 |BIT1 | +BIT0 )); +mrc_alt_write_mask (DDRPHY , + (B1LATCTL0 + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (((cas +7 ) <<16 ) | ((cas -4 ) <<8 ) | + ((cwl -2 ) <<0 )), + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT12 |BIT11 |BIT10 |BIT9 | +BIT8 |BIT4 |BIT3 |BIT2 |BIT1 | +BIT0 )); + +/* RCVEN Bypass (PO) */ +mrc_alt_write_mask (DDRPHY , + (B0RXIOBUFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + ((0x0 <<7 ) | (0x0 <<0 )), + (BIT7 |BIT0 )); +mrc_alt_write_mask (DDRPHY , + (B1RXIOBUFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + ((0x0 <<7 ) | (0x0 <<0 )), + (BIT7 |BIT0 )); + +/* TX */ +mrc_alt_write_mask (DDRPHY , + (DQCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (BIT16 ), (BIT16 )); +mrc_alt_write_mask (DDRPHY , + (B01PTRCTL1 + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (BIT8 ), (BIT8 )); + +/* RX (PO) */ +/* Internal Vref Code, Enable#, Ext_or_Int (1=Ext) */ +mrc_alt_write_mask (DDRPHY , + (B0VREFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + ((0x03 <<2 ) | (0x0 <<1 ) | (0x0 <<0 )), + (BIT7 |BIT6 |BIT5 |BIT4 |BIT3 | +BIT2 |BIT1 |BIT0 )); +/* Internal Vref Code, Enable#, Ext_or_Int (1=Ext) */ +mrc_alt_write_mask (DDRPHY , + (B1VREFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + ((0x03 <<2 ) | (0x0 <<1 ) | (0x0 <<0 )), + (BIT7 |BIT6 |BIT5 |BIT4 |BIT3 | +BIT2 |BIT1 |BIT0 )); +/* Per-Bit De-Skew Enable */ +mrc_alt_write_mask (DDRPHY , + (B0RXIOBUFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (0 ), (BIT4 )); +/* Per-Bit De-Skew Enable */ +mrc_alt_write_mask (DDRPHY , + (B1RXIOBUFCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (0 ), (BIT4 )); + } + +/* CLKEBB */ +mrc_alt_write_mask (DDRPHY , + (CMDOBSCKEBBCTL + (ch *DDRIOCCC_CH_OFFSET )), +0 , (BIT23 )); + +/* Enable tristate control of cmd/address bus */ +mrc_alt_write_mask (DDRPHY , + (CMDCFGREG0 + (ch *DDRIOCCC_CH_OFFSET )), +0 , (BIT1 |BIT0 )); + +/* ODT RCOMP */ +mrc_alt_write_mask (DDRPHY , + (CMDRCOMPODT + (ch *DDRIOCCC_CH_OFFSET )), + ((0x03 <<5 ) | (0x03 <<0 )), + (BIT9 |BIT8 |BIT7 |BIT6 |BIT5 |BIT4 | +BIT3 |BIT2 |BIT1 |BIT0 )); + +/* CMDPM* registers must be programmed in this order */ + +/* Turn On Delays: SFR (regulator), MPLL */ +mrc_alt_write_mask (DDRPHY , + (CMDPMDLYREG4 + (ch *DDRIOCCC_CH_OFFSET )), + ((0xFFFFU <<16 ) | (0xFFFF <<0 )), +0xFFFFFFFF ); +/* +* Delays: ASSERT_IOBUFACT_to_ALLON0_for_PM_MSG_3, +* VREG (MDLL) Turn On, ALLON0_to_DEASSERT_IOBUFACT +* for_PM_MSG_gt0, MDLL Turn On +*/ +mrc_alt_write_mask (DDRPHY , + (CMDPMDLYREG3 + (ch *DDRIOCCC_CH_OFFSET )), + ((0xFU <<28 ) | (0xFFF <<16 ) | (0xF <<12 ) | + (0x616 <<0 )),0xFFFFFFFF ); +/* MPLL Divider Reset Delays */ +mrc_alt_write_mask (DDRPHY , + (CMDPMDLYREG2 + (ch *DDRIOCCC_CH_OFFSET )), + ((0xFFU <<24 ) | (0xFF <<16 ) | (0xFF <<8 ) | + (0xFF <<0 )),0xFFFFFFFF ); +/* Turn Off Delays: VREG, Staggered MDLL, MDLL, PI */ +mrc_alt_write_mask (DDRPHY , + (CMDPMDLYREG1 + (ch *DDRIOCCC_CH_OFFSET )), + ((0xFFU <<24 ) | (0xFF <<16 ) | (0xFF <<8 ) | + (0xFF <<0 )),0xFFFFFFFF ); +/* Turn On Delays: MPLL, Staggered MDLL, PI, IOBUFACT */ +mrc_alt_write_mask (DDRPHY , + (CMDPMDLYREG0 + (ch *DDRIOCCC_CH_OFFSET )), + ((0xFFU <<24 ) | (0xFF <<16 ) | (0xFF <<8 ) | + (0xFF <<0 )),0xFFFFFFFF ); +/* Allow PUnit signals */ +mrc_alt_write_mask (DDRPHY , + (CMDPMCONFIG0 + (ch *DDRIOCCC_CH_OFFSET )), + ((0x6 <<8 ) |BIT6 | (0x4 <<0 )), + (BIT31 |BIT30 |BIT29 |BIT28 |BIT27 |BIT26 | +BIT25 |BIT24 |BIT23 |BIT22 |BIT21 |BIT11 | +BIT10 |BIT9 |BIT8 |BIT6 |BIT3 |BIT2 | +BIT1 |BIT0 )); +/* DLL_VREG Bias Trim, VREF Tuning for DLL_VREG */ +mrc_alt_write_mask (DDRPHY , + (CMDMDLLCTL + (ch *DDRIOCCC_CH_OFFSET )), + ((0x3 <<4 ) | (0x7 <<0 )), + (BIT6 |BIT5 |BIT4 |BIT3 |BIT2 |BIT1 | +BIT0 )); + +/* CLK-CTL */ +mrc_alt_write_mask (DDRPHY , + (CCOBSCKEBBCTL + (ch *DDRIOCCC_CH_OFFSET )), +0 ,BIT24 );/* CLKEBB */ +/* Buffer Enable: CS,CKE,ODT,CLK */ +mrc_alt_write_mask (DDRPHY , + (CCCFGREG0 + (ch *DDRIOCCC_CH_OFFSET )), + ((0x0 <<16 ) | (0x0 <<12 ) | (0x0 <<8 ) | + (0xF <<4 ) |BIT0 ), + (BIT19 |BIT18 |BIT17 |BIT16 |BIT15 |BIT14 | +BIT13 |BIT12 |BIT11 |BIT10 |BIT9 |BIT8 | +BIT7 |BIT6 |BIT5 |BIT4 |BIT0 )); +/* ODT RCOMP */ +mrc_alt_write_mask (DDRPHY , + (CCRCOMPODT + (ch *DDRIOCCC_CH_OFFSET )), + ((0x03 <<8 ) | (0x03 <<0 )), + (BIT12 |BIT11 |BIT10 |BIT9 |BIT8 |BIT4 | +BIT3 |BIT2 |BIT1 |BIT0 )); +/* DLL_VREG Bias Trim, VREF Tuning for DLL_VREG */ +mrc_alt_write_mask (DDRPHY , + (CCMDLLCTL + (ch *DDRIOCCC_CH_OFFSET )), + ((0x3 <<4 ) | (0x7 <<0 )), + (BIT6 |BIT5 |BIT4 |BIT3 |BIT2 |BIT1 | +BIT0 )); + +/* +* COMP (RON channel specific) +* - DQ/DQS/DM RON: 32 Ohm +* - CTRL/CMD RON: 27 Ohm +* - CLK RON: 26 Ohm +*/ +/* RCOMP Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (DQVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x08 <<24 ) | (0x03 <<16 )), + (BIT29 |BIT28 |BIT27 |BIT26 |BIT25 | +BIT24 |BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 )); +/* RCOMP Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (CMDVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x0C <<24 ) | (0x03 <<16 )), + (BIT29 |BIT28 |BIT27 |BIT26 |BIT25 | +BIT24 |BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 )); +/* RCOMP Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (CLKVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x0F <<24 ) | (0x03 <<16 )), + (BIT29 |BIT28 |BIT27 |BIT26 |BIT25 | +BIT24 |BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 )); +/* RCOMP Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (DQSVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x08 <<24 ) | (0x03 <<16 )), + (BIT29 |BIT28 |BIT27 |BIT26 |BIT25 | +BIT24 |BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 )); +/* RCOMP Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (CTLVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x0C <<24 ) | (0x03 <<16 )), + (BIT29 |BIT28 |BIT27 |BIT26 |BIT25 | +BIT24 |BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 )); + +/* DQS Swapped Input Enable */ +mrc_alt_write_mask (DDRPHY , + (COMPEN1CH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT19 |BIT17 ), + (BIT31 |BIT30 |BIT19 |BIT17 | +BIT15 |BIT14 )); + +/* ODT VREF = 1.5 x 274/360+274 = 0.65V (code of ~50) */ +/* ODT Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (DQVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x32 <<8 ) | (0x03 <<0 )), + (BIT13 |BIT12 |BIT11 |BIT10 |BIT9 |BIT8 | +BIT5 |BIT4 |BIT3 |BIT2 |BIT1 |BIT0 )); +/* ODT Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (DQSVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x32 <<8 ) | (0x03 <<0 )), + (BIT13 |BIT12 |BIT11 |BIT10 |BIT9 |BIT8 | +BIT5 |BIT4 |BIT3 |BIT2 |BIT1 |BIT0 )); +/* ODT Vref PU/PD */ +mrc_alt_write_mask (DDRPHY , + (CLKVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x0E <<8 ) | (0x05 <<0 )), + (BIT13 |BIT12 |BIT11 |BIT10 |BIT9 |BIT8 | +BIT5 |BIT4 |BIT3 |BIT2 |BIT1 |BIT0 )); + +/* +* Slew rate settings are frequency specific, +* numbers below are for 800Mhz (speed == 0) +* - DQ/DQS/DM/CLK SR: 4V/ns, +* - CTRL/CMD SR: 1.5V/ns +*/ + temp = (0x0E <<16 ) | (0x0E <<12 ) | (0x08 <<8 ) | + (0x0B <<4 ) | (0x0B <<0 ); +/* DCOMP Delay Select: CTL,CMD,CLK,DQS,DQ */ +mrc_alt_write_mask (DDRPHY , + (DLYSELCH0 + (ch *DDRCOMP_CH_OFFSET )), + temp, + (BIT19 |BIT18 |BIT17 |BIT16 |BIT15 | +BIT14 |BIT13 |BIT12 |BIT11 |BIT10 | +BIT9 |BIT8 |BIT7 |BIT6 |BIT5 |BIT4 | +BIT3 |BIT2 |BIT1 |BIT0 )); +/* TCO Vref CLK,DQS,DQ */ +mrc_alt_write_mask (DDRPHY , + (TCOVREFCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x05 <<16 ) | (0x05 <<8 ) | (0x05 <<0 )), + (BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT13 |BIT12 |BIT11 |BIT10 | +BIT9 |BIT8 |BIT5 |BIT4 |BIT3 |BIT2 | +BIT1 |BIT0 )); +/* ODTCOMP CMD/CTL PU/PD */ +mrc_alt_write_mask (DDRPHY , + (CCBUFODTCH0 + (ch *DDRCOMP_CH_OFFSET )), + ((0x03 <<8 ) | (0x03 <<0 )), + (BIT12 |BIT11 |BIT10 |BIT9 |BIT8 | +BIT4 |BIT3 |BIT2 |BIT1 |BIT0 )); +/* COMP */ +mrc_alt_write_mask (DDRPHY , + (COMPEN0CH0 + (ch *DDRCOMP_CH_OFFSET )), +0 , (BIT31 |BIT30 |BIT8 )); + +#ifdef BACKUP_COMPS +/* DQ COMP Overrides */ +/* RCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQDRVPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* RCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQDRVPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQDLYPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x10 <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQDLYPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x10 <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* ODTCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQODTPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* ODTCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQODTPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* TCOCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQTCOPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 ), (BIT31 )); +/* TCOCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQTCOPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 ), (BIT31 )); + +/* DQS COMP Overrides */ +/* RCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQSDRVPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* RCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQSDRVPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQSDLYPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x10 <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQSDLYPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x10 <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* ODTCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQSODTPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* ODTCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQSODTPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* TCOCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQSTCOPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 ), (BIT31 )); +/* TCOCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQSTCOPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 ), (BIT31 )); + +/* CLK COMP Overrides */ +/* RCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CLKDRVPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0C <<16 )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* RCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CLKDRVPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0C <<16 )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CLKDLYPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x07 <<16 )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CLKDLYPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x07 <<16 )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* ODTCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CLKODTPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0B <<16 )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* ODTCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CLKODTPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0B <<16 )), + (BIT31 | (0x0B <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* TCOCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CLKTCOPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 ), (BIT31 )); +/* TCOCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CLKTCOPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 ), (BIT31 )); + +/* CMD COMP Overrides */ +/* RCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CMDDRVPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0D <<16 )), + (BIT31 |BIT21 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* RCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CMDDRVPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0D <<16 )), + (BIT31 |BIT21 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CMDDLYPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CMDDLYPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); + +/* CTL COMP Overrides */ +/* RCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CTLDRVPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0D <<16 )), + (BIT31 |BIT21 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* RCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CTLDRVPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0D <<16 )), + (BIT31 |BIT21 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CTLDLYPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* DCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CTLDLYPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x0A <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +#else +/* DQ TCOCOMP Overrides */ +/* TCOCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQTCOPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x1F <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* TCOCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQTCOPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x1F <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); + +/* DQS TCOCOMP Overrides */ +/* TCOCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (DQSTCOPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x1F <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* TCOCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (DQSTCOPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x1F <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); + +/* CLK TCOCOMP Overrides */ +/* TCOCOMP PU */ +mrc_alt_write_mask (DDRPHY , + (CLKTCOPUCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x1F <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +/* TCOCOMP PD */ +mrc_alt_write_mask (DDRPHY , + (CLKTCOPDCTLCH0 + (ch *DDRCOMP_CH_OFFSET )), + (BIT31 | (0x1F <<16 )), + (BIT31 |BIT20 |BIT19 | +BIT18 |BIT17 |BIT16 )); +#endif + +/* program STATIC delays */ +#ifdef BACKUP_WCMD +set_wcmd (ch, ddr_wcmd[PLATFORM_ID ]); +#else +set_wcmd (ch, ddr_wclk[PLATFORM_ID ] +HALF_CLK ); +#endif + +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 <<rk)) { +set_wclk (ch, rk, ddr_wclk[PLATFORM_ID ]); +#ifdef BACKUP_WCTL +set_wctl (ch, rk, ddr_wctl[PLATFORM_ID ]); +#else +set_wctl (ch, rk, ddr_wclk[PLATFORM_ID ] +HALF_CLK ); +#endif + } + } + } + } + +/* COMP (non channel specific) */ +/* RCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQANADRVPUCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQANADRVPDCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CMDANADRVPUCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CMDANADRVPDCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANADRVPUCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANADRVPDCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANADRVPUCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANADRVPDCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CTLANADRVPUCTL ), (BIT30 ), (BIT30 )); +/* RCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CTLANADRVPDCTL ), (BIT30 ), (BIT30 )); +/* ODT: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQANAODTPUCTL ), (BIT30 ), (BIT30 )); +/* ODT: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQANAODTPDCTL ), (BIT30 ), (BIT30 )); +/* ODT: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANAODTPUCTL ), (BIT30 ), (BIT30 )); +/* ODT: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANAODTPDCTL ), (BIT30 ), (BIT30 )); +/* ODT: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANAODTPUCTL ), (BIT30 ), (BIT30 )); +/* ODT: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANAODTPDCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQANADLYPUCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQANADLYPDCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CMDANADLYPUCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CMDANADLYPDCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANADLYPUCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANADLYPDCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANADLYPUCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANADLYPDCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CTLANADLYPUCTL ), (BIT30 ), (BIT30 )); +/* DCOMP: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CTLANADLYPDCTL ), (BIT30 ), (BIT30 )); +/* TCO: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQANATCOPUCTL ), (BIT30 ), (BIT30 )); +/* TCO: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQANATCOPDCTL ), (BIT30 ), (BIT30 )); +/* TCO: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANATCOPUCTL ), (BIT30 ), (BIT30 )); +/* TCO: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (CLKANATCOPDCTL ), (BIT30 ), (BIT30 )); +/* TCO: Dither PU Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANATCOPUCTL ), (BIT30 ), (BIT30 )); +/* TCO: Dither PD Enable */ +mrc_alt_write_mask (DDRPHY , (DQSANATCOPDCTL ), (BIT30 ), (BIT30 )); +/* TCOCOMP: Pulse Count */ +mrc_alt_write_mask (DDRPHY , (TCOCNTCTRL ), (0x1 <<0 ), (BIT1 |BIT0 )); +/* ODT: CMD/CTL PD/PU */ +mrc_alt_write_mask (DDRPHY , + (CHNLBUFSTATIC ), ((0x03 <<24 )|(0x03 <<16 )), + (BIT28 |BIT27 |BIT26 |BIT25 |BIT24 | +BIT20 |BIT19 |BIT18 |BIT17 |BIT16 )); +/* Set 1us counter */ +mrc_alt_write_mask (DDRPHY , + (MSCNTR ), (0x64 <<0 ), + (BIT7 |BIT6 |BIT5 |BIT4 |BIT3 |BIT2 |BIT1 |BIT0 )); +mrc_alt_write_mask (DDRPHY , + (LATCH1CTL ), (0x1 <<28 ), + (BIT30 |BIT29 |BIT28 )); + +/* Release PHY from reset */ +mrc_alt_write_mask (DDRPHY ,MASTERRSTN ,BIT0 ,BIT0 ); + +/* STEP1 */ +mrc_post_code (0x03 ,0x11 ); + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* DQ01-DQ23 */ +for (bl_grp =0 ; + bl_grp < ((NUM_BYTE_LANES / bl_divisor) /2 ); + bl_grp++) { +mrc_alt_write_mask (DDRPHY , + (DQMDLLCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (BIT13 ), + (BIT13 ));/* Enable VREG */ +delay_n (3 ); + } + +/* ECC */ +mrc_alt_write_mask (DDRPHY , (ECCMDLLCTL ), + (BIT13 ), (BIT13 ));/* Enable VREG */ +delay_n (3 ); +/* CMD */ +mrc_alt_write_mask (DDRPHY , + (CMDMDLLCTL + (ch *DDRIOCCC_CH_OFFSET )), + (BIT13 ), (BIT13 ));/* Enable VREG */ +delay_n (3 ); +/* CLK-CTL */ +mrc_alt_write_mask (DDRPHY , + (CCMDLLCTL + (ch *DDRIOCCC_CH_OFFSET )), + (BIT13 ), (BIT13 ));/* Enable VREG */ +delay_n (3 ); + } + } + +/* STEP2 */ +mrc_post_code (0x03 ,0x12 ); +delay_n (200 ); + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* DQ01-DQ23 */ +for (bl_grp =0 ; + bl_grp < ((NUM_BYTE_LANES / bl_divisor) /2 ); + bl_grp++) { +mrc_alt_write_mask (DDRPHY , + (DQMDLLCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (BIT17 ), + (BIT17 ));/* Enable MCDLL */ +delay_n (50 ); + } + +/* ECC */ +mrc_alt_write_mask (DDRPHY , (ECCMDLLCTL ), + (BIT17 ), (BIT17 ));/* Enable MCDLL */ +delay_n (50 ); +/* CMD */ +mrc_alt_write_mask (DDRPHY , + (CMDMDLLCTL + (ch *DDRIOCCC_CH_OFFSET )), + (BIT18 ), (BIT18 ));/* Enable MCDLL */ +delay_n (50 ); +/* CLK-CTL */ +mrc_alt_write_mask (DDRPHY , + (CCMDLLCTL + (ch *DDRIOCCC_CH_OFFSET )), + (BIT18 ), (BIT18 ));/* Enable MCDLL */ +delay_n (50 ); + } + } + +/* STEP3: */ +mrc_post_code (0x03 ,0x13 ); +delay_n (100 ); + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* DQ01-DQ23 */ +for (bl_grp =0 ; + bl_grp < ((NUM_BYTE_LANES / bl_divisor) /2 ); + bl_grp++) { +#ifdef FORCE_16BIT_DDRIO + temp = ((bl_grp) && + (mrc_params->channel_width ==X16 )) ? + ((0x1 <<12 ) | (0x1 <<8 ) | + (0xF <<4 ) | (0xF <<0 )) : + ((0xF <<12 ) | (0xF <<8 ) | + (0xF <<4 ) | (0xF <<0 )); +#else + temp = ((0xF <<12 ) | (0xF <<8 ) | + (0xF <<4 ) | (0xF <<0 )); +#endif +/* Enable TXDLL */ +mrc_alt_write_mask (DDRPHY , + (DQDLLTXCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + temp,0xFFFF ); +delay_n (3 ); +/* Enable RXDLL */ +mrc_alt_write_mask (DDRPHY , + (DQDLLRXCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (BIT3 |BIT2 |BIT1 |BIT0 ), + (BIT3 |BIT2 |BIT1 |BIT0 )); +delay_n (3 ); +/* Enable RXDLL Overrides BL0 */ +mrc_alt_write_mask (DDRPHY , + (B0OVRCTL + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (BIT3 |BIT2 |BIT1 |BIT0 ), + (BIT3 |BIT2 |BIT1 |BIT0 )); + } + +/* ECC */ + temp = ((0xF <<12 ) | (0xF <<8 ) | + (0xF <<4 ) | (0xF <<0 )); +mrc_alt_write_mask (DDRPHY , (ECCDLLTXCTL ), + temp,0xFFFF ); +delay_n (3 ); + +/* CMD (PO) */ +mrc_alt_write_mask (DDRPHY , + (CMDDLLTXCTL + (ch *DDRIOCCC_CH_OFFSET )), + temp,0xFFFF ); +delay_n (3 ); + } + } + +/* STEP4 */ +mrc_post_code (0x03 ,0x14 ); + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* Host To Memory Clock Alignment (HMC) for 800/1066 */ +for (bl_grp =0 ; + bl_grp < ((NUM_BYTE_LANES / bl_divisor) /2 ); + bl_grp++) { +/* CLK_ALIGN_MOD_ID */ +mrc_alt_write_mask (DDRPHY , + (DQCLKALIGNREG2 + + (bl_grp *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), + (bl_grp) ? (0x3 ) : (0x1 ), + (BIT3 |BIT2 |BIT1 |BIT0 )); + } + +mrc_alt_write_mask (DDRPHY , + (ECCCLKALIGNREG2 + (ch *DDRIODQ_CH_OFFSET )), +0x2 , + (BIT3 |BIT2 |BIT1 |BIT0 )); +mrc_alt_write_mask (DDRPHY , + (CMDCLKALIGNREG2 + (ch *DDRIODQ_CH_OFFSET )), +0x0 , + (BIT3 |BIT2 |BIT1 |BIT0 )); +mrc_alt_write_mask (DDRPHY , + (CCCLKALIGNREG2 + (ch *DDRIODQ_CH_OFFSET )), +0x2 , + (BIT3 |BIT2 |BIT1 |BIT0 )); +mrc_alt_write_mask (DDRPHY , + (CMDCLKALIGNREG0 + (ch *DDRIOCCC_CH_OFFSET )), + (0x2 <<4 ), (BIT5 |BIT4 )); +/* +* NUM_SAMPLES, MAX_SAMPLES, +* MACRO_PI_STEP, MICRO_PI_STEP +*/ +mrc_alt_write_mask (DDRPHY , + (CMDCLKALIGNREG1 + (ch *DDRIOCCC_CH_OFFSET )), + ((0x18 <<16 ) | (0x10 <<8 ) | + (0x8 <<2 ) | (0x1 <<0 )), + (BIT22 |BIT21 |BIT20 |BIT19 |BIT18 |BIT17 | +BIT16 |BIT14 |BIT13 |BIT12 |BIT11 |BIT10 | +BIT9 |BIT8 |BIT7 |BIT6 |BIT5 |BIT4 |BIT3 | +BIT2 |BIT1 |BIT0 )); +/* TOTAL_NUM_MODULES, FIRST_U_PARTITION */ +mrc_alt_write_mask (DDRPHY , + (CMDCLKALIGNREG2 + (ch *DDRIOCCC_CH_OFFSET )), + ((0x10 <<16 ) | (0x4 <<8 ) | (0x2 <<4 )), + (BIT20 |BIT19 |BIT18 |BIT17 |BIT16 | +BIT11 |BIT10 |BIT9 |BIT8 |BIT7 |BIT6 | +BIT5 |BIT4 )); +#ifdef HMC_TEST +/* START_CLK_ALIGN=1 */ +mrc_alt_write_mask (DDRPHY , + (CMDCLKALIGNREG0 + (ch *DDRIOCCC_CH_OFFSET )), +BIT24 ,BIT24 ); +while (msg_port_alt_read (DDRPHY , + (CMDCLKALIGNREG0 + (ch *DDRIOCCC_CH_OFFSET ))) & +BIT24 ) + ;/* wait for START_CLK_ALIGN=0 */ +#endif + +/* Set RD/WR Pointer Seperation & COUNTEN & FIFOPTREN */ +mrc_alt_write_mask (DDRPHY , + (CMDPTRREG + (ch *DDRIOCCC_CH_OFFSET )), +BIT0 ,BIT0 );/* WRPTRENABLE=1 */ + +/* COMP initial */ +/* enable bypass for CLK buffer (PO) */ +mrc_alt_write_mask (DDRPHY , + (COMPEN0CH0 + (ch *DDRCOMP_CH_OFFSET )), +BIT5 ,BIT5 ); +/* Initial COMP Enable */ +mrc_alt_write_mask (DDRPHY , (CMPCTRL ), + (BIT0 ), (BIT0 )); +/* wait for Initial COMP Enable = 0 */ +while (msg_port_alt_read (DDRPHY , (CMPCTRL )) &BIT0 ) + ; +/* disable bypass for CLK buffer (PO) */ +mrc_alt_write_mask (DDRPHY , + (COMPEN0CH0 + (ch *DDRCOMP_CH_OFFSET )), + ~BIT5 ,BIT5 ); + +/* IOBUFACT */ + +/* STEP4a */ +mrc_alt_write_mask (DDRPHY , + (CMDCFGREG0 + (ch *DDRIOCCC_CH_OFFSET )), +BIT2 ,BIT2 );/* IOBUFACTRST_N=1 */ + +/* DDRPHY initialisation complete */ +mrc_alt_write_mask (DDRPHY , + (CMDPMCONFIG0 + (ch *DDRIOCCC_CH_OFFSET )), +BIT20 ,BIT20 );/* SPID_INIT_COMPLETE=1 */ + } + } + +LEAVEFN (); +} + +/* This function performs JEDEC initialisation on all enabled channels */ +void perform_jedec_init (struct mrc_params *mrc_params) +{ +uint8_t twr, wl, rank; +uint32_t tck; +u32 dtr0; +u32 drp; +u32 drmc; +u32 mrs0_cmd =0 ; +u32 emrs1_cmd =0 ; +u32 emrs2_cmd =0 ; +u32 emrs3_cmd =0 ; + +ENTERFN (); + +/* jedec_init starts */ +mrc_post_code (0x04 ,0x00 ); + +/* DDR3_RESET_SET=0, DDR3_RESET_RESET=1 */ +mrc_alt_write_mask (DDRPHY ,CCDDR3RESETCTL ,BIT1 , (BIT8 |BIT1 )); + +/* Assert RESET# for 200us */ +delay_u (200 ); + +/* DDR3_RESET_SET=1, DDR3_RESET_RESET=0 */ +mrc_alt_write_mask (DDRPHY ,CCDDR3RESETCTL ,BIT8 , (BIT8 |BIT1 )); + + dtr0 =msg_port_read (MEM_CTLR ,DTR0 ); + +/* +* Set CKEVAL for populated ranks +* then send NOP to each rank (#4550197) +*/ + + drp =msg_port_read (MEM_CTLR ,DRP ); + drp &=0x3 ; + + drmc =msg_port_read (MEM_CTLR ,DRMC ); + drmc &=0xFFFFFFFC ; + drmc |= (BIT4 | drp); + +msg_port_write (MEM_CTLR ,DRMC , drmc); + +for (rank =0 ; rank <NUM_RANKS ; rank++) { +/* Skip to next populated rank */ +if ((mrc_params->rank_enables & (1 << rank)) ==0 ) +continue ; + +dram_init_command (DCMD_NOP (rank)); + } + +msg_port_write (MEM_CTLR ,DRMC , + (mrc_params->rd_odt_value ==0 ?BIT12 :0 )); + +/* +* setup for emrs 2 +* BIT[15:11] --> Always "0" +* BIT[10:09] --> Rtt_WR: want "Dynamic ODT Off" (0) +* BIT[08] --> Always "0" +* BIT[07] --> SRT: use sr_temp_range +* BIT[06] --> ASR: want "Manual SR Reference" (0) +* BIT[05:03] --> CWL: use oem_tCWL +* BIT[02:00] --> PASR: want "Full Array" (0) +*/ + emrs2_cmd |= (2 <<3 ); + wl =5 + mrc_params->ddr_speed; + emrs2_cmd |= ((wl -5 ) <<9 ); + emrs2_cmd |= (mrc_params->sr_temp_range <<13 ); + +/* +* setup for emrs 3 +* BIT[15:03] --> Always "0" +* BIT[02] --> MPR: want "Normal Operation" (0) +* BIT[01:00] --> MPR_Loc: want "Predefined Pattern" (0) +*/ + emrs3_cmd |= (3 <<3 ); + +/* +* setup for emrs 1 +* BIT[15:13] --> Always "0" +* BIT[12:12] --> Qoff: want "Output Buffer Enabled" (0) +* BIT[11:11] --> TDQS: want "Disabled" (0) +* BIT[10:10] --> Always "0" +* BIT[09,06,02] --> Rtt_nom: use rtt_nom_value +* BIT[08] --> Always "0" +* BIT[07] --> WR_LVL: want "Disabled" (0) +* BIT[05,01] --> DIC: use ron_value +* BIT[04:03] --> AL: additive latency want "0" (0) +* BIT[00] --> DLL: want "Enable" (0) +* +* (BIT5|BIT1) set Ron value +* 00 --> RZQ/6 (40ohm) +* 01 --> RZQ/7 (34ohm) +* 1* --> RESERVED +* +* (BIT9|BIT6|BIT2) set Rtt_nom value +* 000 --> Disabled +* 001 --> RZQ/4 ( 60ohm)
Quoted 9 lines
arch/x86/cpu/quark/smc.c line 1393
Quoted 4 lines
arch/x86/cpu/quark/smc.c new file +4
-0+* 010 --> RZQ/2 (120ohm) +* 011 --> RZQ/6 ( 40ohm) +* 1** --> RESERVED +*/ Why oh why not just have #defines for these? It seems like the original author knew they should be created but never made the step of actually doing it.
Again, undocumented in the Intel datasheet. I suspect it is something in the JEDEC DDR spec though. Did not change this in v2.
Quoted 646 lines
Quoted 646 lines
arch/x86/cpu/quark/smc.c new file +646
-0+ emrs1_cmd |= (1 <<3 ); + emrs1_cmd &= ~BIT6 ; + +if (mrc_params->ron_value ==0 ) + emrs1_cmd |=BIT7 ; +else + emrs1_cmd &= ~BIT7 ; + +if (mrc_params->rtt_nom_value ==0 ) + emrs1_cmd |= (DDR3_EMRS1_RTTNOM_40 <<6 ); +else if (mrc_params->rtt_nom_value ==1 ) + emrs1_cmd |= (DDR3_EMRS1_RTTNOM_60 <<6 ); +else if (mrc_params->rtt_nom_value ==2 ) + emrs1_cmd |= (DDR3_EMRS1_RTTNOM_120 <<6 ); + +/* save MRS1 value (excluding control fields) */ + mrc_params->mrs1 = emrs1_cmd >>6 ; + +/* +* setup for mrs 0 +* BIT[15:13] --> Always "0" +* BIT[12] --> PPD: for Quark (1) +* BIT[11:09] --> WR: use oem_tWR +* BIT[08] --> DLL: want "Reset" (1, self clearing) +* BIT[07] --> MODE: want "Normal" (0) +* BIT[06:04,02] --> CL: use oem_tCAS +* BIT[03] --> RD_BURST_TYPE: want "Interleave" (1) +* BIT[01:00] --> BL: want "8 Fixed" (0) +* WR: +* 0 --> 16 +* 1 --> 5 +* 2 --> 6 +* 3 --> 7 +* 4 --> 8 +* 5 --> 10 +* 6 --> 12 +* 7 --> 14 +* CL: +* BIT[02:02] "0" if oem_tCAS <= 11 (1866?) +* BIT[06:04] use oem_tCAS-4 +*/ + mrs0_cmd |=BIT14 ; + mrs0_cmd |=BIT18 ; + mrs0_cmd |= ((((dtr0 >>12 ) &7 ) +1 ) <<10 ); + + tck = t_ck[mrc_params->ddr_speed]; +/* Per JEDEC: tWR=15000ps DDR2/3 from 800-1600 */ + twr =MCEIL (15000 , tck); + mrs0_cmd |= ((twr -4 ) <<15 ); + +for (rank =0 ; rank <NUM_RANKS ; rank++) { +/* Skip to next populated rank */ +if ((mrc_params->rank_enables & (1 << rank)) ==0 ) +continue ; + + emrs2_cmd |= (rank <<22 ); +dram_init_command (emrs2_cmd); + + emrs3_cmd |= (rank <<22 ); +dram_init_command (emrs3_cmd); + + emrs1_cmd |= (rank <<22 ); +dram_init_command (emrs1_cmd); + + mrs0_cmd |= (rank <<22 ); +dram_init_command (mrs0_cmd); + +dram_init_command (DCMD_ZQCL (rank)); + } + +LEAVEFN (); +} + +/* +* Dunit Initialisation Complete +* +* Indicates that initialisation of the Dunit has completed. +* +* Memory accesses are permitted and maintenance operation begins. +* Until this bit is set to a 1, the memory controller will not accept +* DRAM requests from the MEMORY_MANAGER or HTE. +*/ +void set_ddr_init_complete (struct mrc_params *mrc_params) +{ +u32 dco; + +ENTERFN (); + + dco =msg_port_read (MEM_CTLR ,DCO ); + dco &= ~BIT28 ; + dco |=BIT31 ; +msg_port_write (MEM_CTLR ,DCO , dco); + +LEAVEFN (); +} + +/* +* This function will retrieve relevant timing data +* +* This data will be used on subsequent boots to speed up boot times +* and is required for Suspend To RAM capabilities. +*/ +void restore_timings (struct mrc_params *mrc_params) +{ +uint8_t ch, rk, bl; +const struct mrc_timings *mt = &mrc_params->timings; + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +for (bl =0 ; bl <NUM_BYTE_LANES ; bl++) { +set_rcvn (ch, rk, bl, mt->rcvn[ch][rk][bl]); +set_rdqs (ch, rk, bl, mt->rdqs[ch][rk][bl]); +set_wdqs (ch, rk, bl, mt->wdqs[ch][rk][bl]); +set_wdq (ch, rk, bl, mt->wdq[ch][rk][bl]); +if (rk ==0 ) { +/* VREF (RANK0 only) */ +set_vref (ch, bl, mt->vref[ch][bl]); + } + } +set_wctl (ch, rk, mt->wctl[ch][rk]); + } +set_wcmd (ch, mt->wcmd[ch]); + } +} + +/* +* Configure default settings normally set as part of read training +* +* Some defaults have to be set earlier as they may affect earlier +* training steps. +*/ +void default_timings (struct mrc_params *mrc_params) +{ +uint8_t ch, rk, bl; + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +for (bl =0 ; bl <NUM_BYTE_LANES ; bl++) { +set_rdqs (ch, rk, bl,24 ); +if (rk ==0 ) { +/* VREF (RANK0 only) */ +set_vref (ch, bl,32 ); + } + } + } + } +} + +/* +* This function will perform our RCVEN Calibration Algorithm. +* We will only use the 2xCLK domain timings to perform RCVEN Calibration. +* All byte lanes will be calibrated "simultaneously" per channel per rank. +*/ +void rcvn_cal (struct mrc_params *mrc_params) +{ +uint8_t ch;/* channel counter */ +uint8_t rk;/* rank counter */ +uint8_t bl;/* byte lane counter */ +uint8_t bl_divisor = (mrc_params->channel_width ==X16 ) ?2 :1 ; + +#ifdef R2R_SHARING +/* used to find placement for rank2rank sharing configs */ +uint32_t final_delay[NUM_CHANNELS ][NUM_BYTE_LANES ]; +#ifndef BACKUP_RCVN +/* used to find placement for rank2rank sharing configs */ +uint32_t num_ranks_enabled =0 ; +#endif +#endif + +#ifdef BACKUP_RCVN +#else +uint32_t temp; +/* absolute PI value to be programmed on the byte lane */ +uint32_t delay[NUM_BYTE_LANES ]; +u32 dtr1, dtr1_save; +#endif + +ENTERFN (); + +/* rcvn_cal starts */ +mrc_post_code (0x05 ,0x00 ); + +#ifndef BACKUP_RCVN +/* need separate burst to sample DQS preamble */ + dtr1 =msg_port_read (MEM_CTLR ,DTR1 ); + dtr1_save = dtr1; + dtr1 |=BIT12 ; +msg_port_write (MEM_CTLR ,DTR1 , dtr1); +#endif + +#ifdef R2R_SHARING +/* need to set "final_delay[][]" elements to "0" */ +memset ((void *)(final_delay),0x00 , (size_t )sizeof (final_delay)); +#endif + +/* loop through each enabled channel */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* perform RCVEN Calibration on a per rank basis */ +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +/* +* POST_CODE here indicates the current +* channel and rank being calibrated +*/ +mrc_post_code (0x05 , (0x10 + ((ch <<4 ) | rk))); + +#ifdef BACKUP_RCVN +/* et hard-coded timing values */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) +set_rcvn (ch, rk, bl, ddr_rcvn[PLATFORM_ID ]); +#else +/* enable FIFORST */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl +=2 ) { +mrc_alt_write_mask (DDRPHY , + (B01PTRCTL1 + + ((bl >>1 ) *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), +0 ,BIT8 ); + } +/* initialize the starting delay to 128 PI (cas +1 CLK) */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +/* 1x CLK domain timing is cas-4 */ + delay[bl] = (4 +1 ) *FULL_CLK ; + +set_rcvn (ch, rk, bl, delay[bl]); + } + +/* now find the rising edge */ +find_rising_edge (mrc_params, delay, ch, rk, true); + +/* Now increase delay by 32 PI (1/4 CLK) to place in center of high pulse */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { + delay[bl] +=QRTR_CLK ; +set_rcvn (ch, rk, bl, delay[bl]); + } +/* Now decrement delay by 128 PI (1 CLK) until we sample a "0" */ +do { + temp =sample_dqs (mrc_params, ch, rk, true); +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +if (temp & (1 << bl)) { +if (delay[bl] >=FULL_CLK ) { + delay[bl] -=FULL_CLK ; +set_rcvn (ch, rk, bl, delay[bl]); + }else { +/* not enough delay */ +training_message (ch, rk, bl); +mrc_post_code (0xEE ,0x50 ); + } + } + } + }while (temp &0xFF ); + +#ifdef R2R_SHARING +/* increment "num_ranks_enabled" */ + num_ranks_enabled++; +/* Finally increment delay by 32 PI (1/4 CLK) to place in center of preamble */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { + delay[bl] +=QRTR_CLK ; +/* add "delay[]" values to "final_delay[][]" for rolling average */ + final_delay[ch][bl] += delay[bl]; +/* set timing based on rolling average values */ +set_rcvn (ch, rk, bl, ((final_delay[ch][bl]) / num_ranks_enabled)); + } +#else +/* Finally increment delay by 32 PI (1/4 CLK) to place in center of preamble */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { + delay[bl] +=QRTR_CLK ; +set_rcvn (ch, rk, bl, delay[bl]); + } +#endif + +/* disable FIFORST */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl +=2 ) { +mrc_alt_write_mask (DDRPHY , + (B01PTRCTL1 + + ((bl >>1 ) *DDRIODQ_BL_OFFSET ) + + (ch *DDRIODQ_CH_OFFSET )), +BIT8 ,BIT8 ); + } +#endif + } + } + } + } + +#ifndef BACKUP_RCVN +/* restore original */ +msg_port_write (MEM_CTLR ,DTR1 , dtr1_save); +#endif + +LEAVEFN (); +} + +/* +* This function will perform the Write Levelling algorithm +* (align WCLK and WDQS). +* +* This algorithm will act on each rank in each channel separately. +*/ +void wr_level (struct mrc_params *mrc_params) +{ +uint8_t ch;/* channel counter */ +uint8_t rk;/* rank counter */ +uint8_t bl;/* byte lane counter */ +uint8_t bl_divisor = (mrc_params->channel_width ==X16 ) ?2 :1 ; + +#ifdef R2R_SHARING +/* used to find placement for rank2rank sharing configs */ +uint32_t final_delay[NUM_CHANNELS ][NUM_BYTE_LANES ]; +#ifndef BACKUP_WDQS +/* used to find placement for rank2rank sharing configs */ +uint32_t num_ranks_enabled =0 ; +#endif +#endif + +#ifdef BACKUP_WDQS +#else +/* determines stop condition for CRS_WR_LVL */ +bool all_edges_found; +/* absolute PI value to be programmed on the byte lane */ +uint32_t delay[NUM_BYTE_LANES ]; +/* +* static makes it so the data is loaded in the heap once by shadow(), +* where non-static copies the data onto the stack every time this +* function is called +*/ +uint32_t address;/* address to be checked during COARSE_WR_LVL */ +u32 dtr4, dtr4_save; +#endif + +ENTERFN (); + +/* wr_level starts */ +mrc_post_code (0x06 ,0x00 ); + +#ifdef R2R_SHARING +/* need to set "final_delay[][]" elements to "0" */ +memset ((void *)(final_delay),0x00 , (size_t )sizeof (final_delay)); +#endif + +/* loop through each enabled channel */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +/* perform WRITE LEVELING algorithm on a per rank basis */ +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +/* +* POST_CODE here indicates the current +* rank and channel being calibrated +*/ +mrc_post_code (0x06 , (0x10 + ((ch <<4 ) | rk))); + +#ifdef BACKUP_WDQS +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +set_wdqs (ch, rk, bl, ddr_wdqs[PLATFORM_ID ]); +set_wdq (ch, rk, bl, (ddr_wdqs[PLATFORM_ID ] -QRTR_CLK )); + } +#else +/* +* perform a single PRECHARGE_ALL command to +* make DRAM state machine go to IDLE state +*/ +dram_init_command (DCMD_PREA (rk)); + +/* +* enable Write Levelling Mode +* (EMRS1 w/ Write Levelling Mode Enable) +*/ +dram_init_command (DCMD_MRS1 (rk,0x0082 )); + +/* +* set ODT DRAM Full Time Termination +* disable in MCU +*/ + + dtr4 =msg_port_read (MEM_CTLR ,DTR4 ); + dtr4_save = dtr4; + dtr4 |=BIT15 ; +msg_port_write (MEM_CTLR ,DTR4 , dtr4); + +for (bl =0 ; bl < ((NUM_BYTE_LANES / bl_divisor) /2 ); bl++) { +/* +* Enable Sandy Bridge Mode (WDQ Tri-State) & +* Ensure 5 WDQS pulses during Write Leveling +*/ +mrc_alt_write_mask (DDRPHY , +DQCTL + (DDRIODQ_BL_OFFSET * bl) + (DDRIODQ_CH_OFFSET * ch), + (BIT28 |BIT8 |BIT6 |BIT4 |BIT2 ), + (BIT28 |BIT9 |BIT8 |BIT7 |BIT6 |BIT5 |BIT4 |BIT3 |BIT2 )); + } + +/* Write Leveling Mode enabled in IO */ +mrc_alt_write_mask (DDRPHY , +CCDDR3RESETCTL + (DDRIOCCC_CH_OFFSET * ch), +BIT16 ,BIT16 ); + +/* Initialize the starting delay to WCLK */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +/* +* CLK0 --> RK0 +* CLK1 --> RK1 +*/ + delay[bl] =get_wclk (ch, rk); + +set_wdqs (ch, rk, bl, delay[bl]); + } + +/* now find the rising edge */ +find_rising_edge (mrc_params, delay, ch, rk, false); + +/* disable Write Levelling Mode */ +mrc_alt_write_mask (DDRPHY , +CCDDR3RESETCTL + (DDRIOCCC_CH_OFFSET * ch), +0 ,BIT16 ); + +for (bl =0 ; bl < ((NUM_BYTE_LANES / bl_divisor) /2 ); bl++) { +/* Disable Sandy Bridge Mode & Ensure 4 WDQS pulses during normal operation */ +mrc_alt_write_mask (DDRPHY , +DQCTL + (DDRIODQ_BL_OFFSET * bl) + (DDRIODQ_CH_OFFSET * ch), + (BIT8 |BIT6 |BIT4 |BIT2 ), + (BIT28 |BIT9 |BIT8 |BIT7 |BIT6 |BIT5 |BIT4 |BIT3 |BIT2 )); + } + +/* restore original DTR4 */ +msg_port_write (MEM_CTLR ,DTR4 , dtr4_save); + +/* +* restore original value +* (Write Levelling Mode Disable) +*/ +dram_init_command (DCMD_MRS1 (rk, mrc_params->mrs1)); + +/* +* perform a single PRECHARGE_ALL command to +* make DRAM state machine go to IDLE state +*/ +dram_init_command (DCMD_PREA (rk)); + +mrc_post_code (0x06 , (0x30 + ((ch <<4 ) | rk))); + +/* +* COARSE WRITE LEVEL: +* check that we're on the correct clock edge +*/ + +/* hte reconfiguration request */ + mrc_params->hte_setup =1 ; + +/* start CRS_WR_LVL with WDQS = WDQS + 128 PI */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { + delay[bl] =get_wdqs (ch, rk, bl) +FULL_CLK ; +set_wdqs (ch, rk, bl, delay[bl]); +/* +* program WDQ timings based on WDQS +* (WDQ = WDQS - 32 PI) +*/ +set_wdq (ch, rk, bl, (delay[bl] -QRTR_CLK )); + } + +/* get an address in the targeted channel/rank */ + address =get_addr (ch, rk); +do { +uint32_t coarse_result =0x00 ; +uint32_t coarse_result_mask =byte_lane_mask (mrc_params); +/* assume pass */ + all_edges_found = true; + + mrc_params->hte_setup =1 ; + coarse_result =check_rw_coarse (mrc_params, address); + +/* check for failures and margin the byte lane back 128 PI (1 CLK) */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +if (coarse_result & (coarse_result_mask << bl)) { + all_edges_found = false; + delay[bl] -=FULL_CLK ; +set_wdqs (ch, rk, bl, delay[bl]); +/* program WDQ timings based on WDQS (WDQ = WDQS - 32 PI) */ +set_wdq (ch, rk, bl, (delay[bl] -QRTR_CLK )); + } + } + }while (!all_edges_found); + +#ifdef R2R_SHARING +/* increment "num_ranks_enabled" */ + num_ranks_enabled++; +/* accumulate "final_delay[][]" values from "delay[]" values for rolling average */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { + final_delay[ch][bl] += delay[bl]; +set_wdqs (ch, rk, bl, ((final_delay[ch][bl]) / num_ranks_enabled)); +/* program WDQ timings based on WDQS (WDQ = WDQS - 32 PI) */ +set_wdq (ch, rk, bl, ((final_delay[ch][bl]) / num_ranks_enabled) -QRTR_CLK ); + } +#endif +#endif + } + } + } + } + +LEAVEFN (); +} + +void prog_page_ctrl (struct mrc_params *mrc_params) +{ +u32 dpmc0; + +ENTERFN (); + + dpmc0 =msg_port_read (MEM_CTLR ,DPMC0 ); + dpmc0 &= ~(BIT16 |BIT17 |BIT18 ); + dpmc0 |= (4 <<16 ); + dpmc0 |=BIT21 ; +msg_port_write (MEM_CTLR ,DPMC0 , dpmc0); +} + +/* +* This function will perform the READ TRAINING Algorithm on all +* channels/ranks/byte_lanes simultaneously to minimize execution time. +* +* The idea here is to train the VREF and RDQS (and eventually RDQ) values +* to achieve maximum READ margins. The algorithm will first determine the +* X coordinate (RDQS setting). This is done by collapsing the VREF eye +* until we find a minimum required RDQS eye for VREF_MIN and VREF_MAX. +* Then we take the averages of the RDQS eye at VREF_MIN and VREF_MAX, +* then average those; this will be the final X coordinate. The algorithm +* will then determine the Y coordinate (VREF setting). This is done by +* collapsing the RDQS eye until we find a minimum required VREF eye for +* RDQS_MIN and RDQS_MAX. Then we take the averages of the VREF eye at +* RDQS_MIN and RDQS_MAX, then average those; this will be the final Y +* coordinate. +* +* NOTE: this algorithm assumes the eye curves have a one-to-one relationship, +* meaning for each X the curve has only one Y and vice-a-versa. +*/ +void rd_train (struct mrc_params *mrc_params) +{ +uint8_t ch;/* channel counter */ +uint8_t rk;/* rank counter */ +uint8_t bl;/* byte lane counter */ +uint8_t bl_divisor = (mrc_params->channel_width ==X16 ) ?2 :1 ; +#ifdef BACKUP_RDQS +#else +uint8_t side_x;/* tracks LEFT/RIGHT approach vectors */ +uint8_t side_y;/* tracks BOTTOM/TOP approach vectors */ +/* X coordinate data (passing RDQS values) for approach vectors */ +uint8_t x_coordinate[2 ][2 ][NUM_CHANNELS ][NUM_RANKS ][NUM_BYTE_LANES ]; +/* Y coordinate data (passing VREF values) for approach vectors */ +uint8_t y_coordinate[2 ][2 ][NUM_CHANNELS ][NUM_BYTE_LANES ]; +/* centered X (RDQS) */ +uint8_t x_center[NUM_CHANNELS ][NUM_RANKS ][NUM_BYTE_LANES ]; +/* centered Y (VREF) */ +uint8_t y_center[NUM_CHANNELS ][NUM_BYTE_LANES ]; +uint32_t address;/* target address for check_bls_ex() */ +uint32_t result;/* result of check_bls_ex() */ +uint32_t bl_mask;/* byte lane mask for result checking */ +#ifdef R2R_SHARING +/* used to find placement for rank2rank sharing configs */ +uint32_t final_delay[NUM_CHANNELS ][NUM_BYTE_LANES ]; +/* used to find placement for rank2rank sharing configs */ +uint32_t num_ranks_enabled =0 ; +#endif +#endif + +/* rd_train starts */ +mrc_post_code (0x07 ,0x00 ); + +ENTERFN (); + +#ifdef BACKUP_RDQS +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +for (bl =0 ; + bl < (NUM_BYTE_LANES / bl_divisor); + bl++) { +set_rdqs (ch, rk, bl, ddr_rdqs[PLATFORM_ID ]); + } + } + } + } + } +#else +/* initialise x/y_coordinate arrays */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +for (bl =0 ; + bl < (NUM_BYTE_LANES / bl_divisor); + bl++) { +/* x_coordinate */ + x_coordinate[L ][B ][ch][rk][bl] =RDQS_MIN ; + x_coordinate[R ][B ][ch][rk][bl] =RDQS_MAX ; + x_coordinate[L ][T ][ch][rk][bl] =RDQS_MIN ; + x_coordinate[R ][T ][ch][rk][bl] =RDQS_MAX ; +/* y_coordinate */ + y_coordinate[L ][B ][ch][bl] =VREF_MIN ; + y_coordinate[R ][B ][ch][bl] =VREF_MIN ; + y_coordinate[L ][T ][ch][bl] =VREF_MAX ; + y_coordinate[R ][T ][ch][bl] =VREF_MAX ; + } + } + } + } + } + +/* initialize other variables */ + bl_mask =byte_lane_mask (mrc_params); + address =get_addr (0 ,0 ); + +#ifdef R2R_SHARING +/* need to set "final_delay[][]" elements to "0" */ +memset ((void *)(final_delay),0x00 , (size_t )sizeof (final_delay)); +#endif + +/* look for passing coordinates */ +for (side_y =B ; side_y <=T ; side_y++) { +for (side_x =L ; side_x <=R ; side_x++) { +mrc_post_code (0x07 , (0x10 + (side_y *2 ) + (side_x))); + +/* find passing values */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (0x1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & + (0x1 << rk)) { +/* set x/y_coordinate search starting settings */ +for (bl =0 ; + bl < (NUM_BYTE_LANES / bl_divisor); + bl++) { +set_rdqs (ch, rk, bl, + x_coordinate[side_x][side_y][ch][rk][bl]); +set_vref (ch, bl, + y_coordinate[side_x][side_y][ch][bl]); + } + +/* get an address in the target channel/rank */ + address =get_addr (ch, rk); + +/* request HTE reconfiguration */ + mrc_params->hte_setup =1 ; + +/* test the settings */ + do {
Quoted 8 lines
arch/x86/cpu/quark/smc.c line 2045
Quoted 6 lines
arch/x86/cpu/quark/smc.c new file +6
-0+/* result[07:00] == failing byte lane (MAX 8) */ + result =check_bls_ex (mrc_params, address); + +/* check for failures */ +if (result &0xFF ) { +/* at least 1 byte lane failed */ I'm pretty sure this block can go in a function
And I don't know how to name that function with a proper name. Sigh ... Did not change in v2.
Quoted 723 lines
Quoted 723 lines
arch/x86/cpu/quark/smc.c new file +719
-0+for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +if (result & + (bl_mask << bl)) { +/* adjust the RDQS values accordingly */ +if (side_x ==L ) + x_coordinate[L ][side_y][ch][rk][bl] +=RDQS_STEP ; +else + x_coordinate[R ][side_y][ch][rk][bl] -=RDQS_STEP ; + +/* check that we haven't closed the RDQS_EYE too much */ +if ((x_coordinate[L ][side_y][ch][rk][bl] > (RDQS_MAX -MIN_RDQS_EYE )) || + (x_coordinate[R ][side_y][ch][rk][bl] < (RDQS_MIN +MIN_RDQS_EYE )) || + (x_coordinate[L ][side_y][ch][rk][bl] == + x_coordinate[R ][side_y][ch][rk][bl])) { +/* +* not enough RDQS margin available at this VREF +* update VREF values accordingly +*/ +if (side_y ==B ) + y_coordinate[side_x][B ][ch][bl] +=VREF_STEP ; +else + y_coordinate[side_x][T ][ch][bl] -=VREF_STEP ; + +/* check that we haven't closed the VREF_EYE too much */ +if ((y_coordinate[side_x][B ][ch][bl] > (VREF_MAX -MIN_VREF_EYE )) || + (y_coordinate[side_x][T ][ch][bl] < (VREF_MIN +MIN_VREF_EYE )) || + (y_coordinate[side_x][B ][ch][bl] == y_coordinate[side_x][T ][ch][bl])) { +/* VREF_EYE collapsed below MIN_VREF_EYE */ +training_message (ch, rk, bl); +mrc_post_code (0xEE , (0x70 + (side_y *2 ) + (side_x))); + }else { +/* update the VREF setting */ +set_vref (ch, bl, y_coordinate[side_x][side_y][ch][bl]); +/* reset the X coordinate to begin the search at the new VREF */ + x_coordinate[side_x][side_y][ch][rk][bl] = + (side_x ==L ) ? (RDQS_MIN ) : (RDQS_MAX ); + } + } + +/* update the RDQS setting */ +set_rdqs (ch, rk, bl, x_coordinate[side_x][side_y][ch][rk][bl]); + } + } + } + }while (result &0xFF ); + } + } + } + } + } + } + +mrc_post_code (0x07 ,0x20 ); + +/* find final RDQS (X coordinate) & final VREF (Y coordinate) */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +uint32_t temp1; +uint32_t temp2; + +/* x_coordinate */ +DPF (D_INFO , +"RDQS T/B eye rank%d lane%d : %d-%d %d-%d\n" , + rk, bl, + x_coordinate[L ][T ][ch][rk][bl], + x_coordinate[R ][T ][ch][rk][bl], + x_coordinate[L ][B ][ch][rk][bl], + x_coordinate[R ][B ][ch][rk][bl]); + +/* average the TOP side LEFT & RIGHT values */ + temp1 = (x_coordinate[R ][T ][ch][rk][bl] + x_coordinate[L ][T ][ch][rk][bl]) /2 ; +/* average the BOTTOM side LEFT & RIGHT values */ + temp2 = (x_coordinate[R ][B ][ch][rk][bl] + x_coordinate[L ][B ][ch][rk][bl]) /2 ; +/* average the above averages */ + x_center[ch][rk][bl] = (uint8_t ) ((temp1 + temp2) /2 ); + +/* y_coordinate */ +DPF (D_INFO , +"VREF R/L eye lane%d : %d-%d %d-%d\n" , + bl, + y_coordinate[R ][B ][ch][bl], + y_coordinate[R ][T ][ch][bl], + y_coordinate[L ][B ][ch][bl], + y_coordinate[L ][T ][ch][bl]); + +/* average the RIGHT side TOP & BOTTOM values */ + temp1 = (y_coordinate[R ][T ][ch][bl] + y_coordinate[R ][B ][ch][bl]) /2 ; +/* average the LEFT side TOP & BOTTOM values */ + temp2 = (y_coordinate[L ][T ][ch][bl] + y_coordinate[L ][B ][ch][bl]) /2 ; +/* average the above averages */ + y_center[ch][bl] = (uint8_t ) ((temp1 + temp2) /2 ); + } + } + } + } + } + +#ifdef RX_EYE_CHECK +/* perform an eye check */ +for (side_y =B ; side_y <=T ; side_y++) { +for (side_x =L ; side_x <=R ; side_x++) { +mrc_post_code (0x07 , (0x30 + (side_y *2 ) + (side_x))); + +/* update the settings for the eye check */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +if (side_x ==L ) +set_rdqs (ch, rk, bl, (x_center[ch][rk][bl] - (MIN_RDQS_EYE /2 ))); +else +set_rdqs (ch, rk, bl, (x_center[ch][rk][bl] + (MIN_RDQS_EYE /2 ))); + +if (side_y ==B ) +set_vref (ch, bl, (y_center[ch][bl] - (MIN_VREF_EYE /2 ))); +else +set_vref (ch, bl, (y_center[ch][bl] + (MIN_VREF_EYE /2 ))); + } + } + } + } + } + +/* request HTE reconfiguration */ + mrc_params->hte_setup =1 ; + +/* check the eye */ +if (check_bls_ex (mrc_params, address) &0xFF ) { +/* one or more byte lanes failed */ +mrc_post_code (0xEE , (0x74 + (side_x *2 ) + (side_y))); + } + } + } +#endif + +mrc_post_code (0x07 ,0x40 ); + +/* set final placements */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +#ifdef R2R_SHARING +/* increment "num_ranks_enabled" */ + num_ranks_enabled++; +#endif +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +/* x_coordinate */ +#ifdef R2R_SHARING + final_delay[ch][bl] += x_center[ch][rk][bl]; +set_rdqs (ch, rk, bl, ((final_delay[ch][bl]) / num_ranks_enabled)); +#else +set_rdqs (ch, rk, bl, x_center[ch][rk][bl]); +#endif +/* y_coordinate */ +set_vref (ch, bl, y_center[ch][bl]); + } + } + } + } + } +#endif + +LEAVEFN (); +} + +/* +* This function will perform the WRITE TRAINING Algorithm on all +* channels/ranks/byte_lanes simultaneously to minimize execution time. +* +* The idea here is to train the WDQ timings to achieve maximum WRITE margins. +* The algorithm will start with WDQ at the current WDQ setting (tracks WDQS +* in WR_LVL) +/- 32 PIs (+/- 1/4 CLK) and collapse the eye until all data +* patterns pass. This is because WDQS will be aligned to WCLK by the +* Write Leveling algorithm and WDQ will only ever have a 1/2 CLK window +* of validity. +*/ +void wr_train (struct mrc_params *mrc_params) +{ +uint8_t ch;/* channel counter */ +uint8_t rk;/* rank counter */ +uint8_t bl;/* byte lane counter */ +uint8_t bl_divisor = (mrc_params->channel_width ==X16 ) ?2 :1 ; +#ifdef BACKUP_WDQ +#else +uint8_t side;/* LEFT/RIGHT side indicator (0=L, 1=R) */ +uint32_t temp;/* temporary DWORD */ +/* 2 arrays, for L & R side passing delays */ +uint32_t delay[2 ][NUM_CHANNELS ][NUM_RANKS ][NUM_BYTE_LANES ]; +uint32_t address;/* target address for check_bls_ex() */ +uint32_t result;/* result of check_bls_ex() */ +uint32_t bl_mask;/* byte lane mask for result checking */ +#ifdef R2R_SHARING +/* used to find placement for rank2rank sharing configs */ +uint32_t final_delay[NUM_CHANNELS ][NUM_BYTE_LANES ]; +/* used to find placement for rank2rank sharing configs */ +uint32_t num_ranks_enabled =0 ; +#endif +#endif + +/* wr_train starts */ +mrc_post_code (0x08 ,0x00 ); + +ENTERFN (); + +#ifdef BACKUP_WDQ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +for (bl =0 ; + bl < (NUM_BYTE_LANES / bl_divisor); + bl++) { +set_wdq (ch, rk, bl, ddr_wdq[PLATFORM_ID ]); + } + } + } + } + } +#else +/* initialise "delay" */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +for (bl =0 ; + bl < (NUM_BYTE_LANES / bl_divisor); + bl++) { +/* +* want to start with +* WDQ = (WDQS - QRTR_CLK) +* +/- QRTR_CLK +*/ + temp =get_wdqs (ch, rk, bl) -QRTR_CLK ; + delay[L ][ch][rk][bl] = temp -QRTR_CLK ; + delay[R ][ch][rk][bl] = temp +QRTR_CLK ; + } + } + } + } + } + +/* initialise other variables */ + bl_mask =byte_lane_mask (mrc_params); + address =get_addr (0 ,0 ); + +#ifdef R2R_SHARING +/* need to set "final_delay[][]" elements to "0" */ +memset ((void *)(final_delay),0x00 , (size_t )sizeof (final_delay)); +#endif + +/* +* start algorithm on the LEFT side and train each channel/bl +* until no failures are observed, then repeat for the RIGHT side. +*/ +for (side =L ; side <=R ; side++) { +mrc_post_code (0x08 , (0x10 + (side))); + +/* set starting values */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & + (1 << rk)) { +for (bl =0 ; + bl < (NUM_BYTE_LANES / bl_divisor); + bl++) { +set_wdq (ch, rk, bl, delay[side][ch][rk][bl]); + } + } + } + } + } + +/* find passing values */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & + (1 << rk)) { +/* get an address in the target channel/rank */ + address =get_addr (ch, rk); + +/* request HTE reconfiguration */ + mrc_params->hte_setup =1 ; + +/* check the settings */ +do { +/* result[07:00] == failing byte lane (MAX 8) */ + result =check_bls_ex (mrc_params, address); +/* check for failures */ +if (result &0xFF ) { +/* at least 1 byte lane failed */ +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +if (result & + (bl_mask << bl)) { +if (side ==L ) + delay[L ][ch][rk][bl] +=WDQ_STEP ; +else + delay[R ][ch][rk][bl] -=WDQ_STEP ; + +/* check for algorithm failure */ +if (delay[L ][ch][rk][bl] != delay[R ][ch][rk][bl]) { +/* +* margin available +* update delay setting +*/ +set_wdq (ch, rk, bl, + delay[side][ch][rk][bl]); + }else { +/* +* no margin available +* notify the user and halt +*/ +training_message (ch, rk, bl); +mrc_post_code (0xEE , (0x80 + side)); + } + } + } + } +/* stop when all byte lanes pass */ + }while (result &0xFF ); + } + } + } + } + } + +/* program WDQ to the middle of passing window */ +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +if (mrc_params->channel_enables & (1 << ch)) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +if (mrc_params->rank_enables & (1 << rk)) { +#ifdef R2R_SHARING +/* increment "num_ranks_enabled" */ + num_ranks_enabled++; +#endif +for (bl =0 ; bl < (NUM_BYTE_LANES / bl_divisor); bl++) { +DPF (D_INFO , +"WDQ eye rank%d lane%d : %d-%d\n" , + rk, bl, + delay[L ][ch][rk][bl], + delay[R ][ch][rk][bl]); + + temp = (delay[R ][ch][rk][bl] + delay[L ][ch][rk][bl]) /2 ; + +#ifdef R2R_SHARING + final_delay[ch][bl] += temp; +set_wdq (ch, rk, bl, + ((final_delay[ch][bl]) / num_ranks_enabled)); +#else +set_wdq (ch, rk, bl, temp); +#endif + } + } + } + } + } +#endif + +LEAVEFN (); +} + +/* +* This function will store relevant timing data +* +* This data will be used on subsequent boots to speed up boot times +* and is required for Suspend To RAM capabilities. +*/ +void store_timings (struct mrc_params *mrc_params) +{ +uint8_t ch, rk, bl; +struct mrc_timings *mt = &mrc_params->timings; + +for (ch =0 ; ch <NUM_CHANNELS ; ch++) { +for (rk =0 ; rk <NUM_RANKS ; rk++) { +for (bl =0 ; bl <NUM_BYTE_LANES ; bl++) { + mt->rcvn[ch][rk][bl] =get_rcvn (ch, rk, bl); + mt->rdqs[ch][rk][bl] =get_rdqs (ch, rk, bl); + mt->wdqs[ch][rk][bl] =get_wdqs (ch, rk, bl); + mt->wdq[ch][rk][bl] =get_wdq (ch, rk, bl); + +if (rk ==0 ) + mt->vref[ch][bl] =get_vref (ch, bl); + } + + mt->wctl[ch][rk] =get_wctl (ch, rk); + } + + mt->wcmd[ch] =get_wcmd (ch); + } + +/* need to save for a case of changing frequency after warm reset */ + mt->ddr_speed = mrc_params->ddr_speed; +} + +/* +* The purpose of this function is to ensure the SEC comes out of reset +* and IA initiates the SEC enabling Memory Scrambling. +*/ +void enable_scrambling (struct mrc_params *mrc_params) +{ +uint32_t lfsr =0 ; +uint8_t i; + +if (mrc_params->scrambling_enables ==0 ) +return ; + +ENTERFN (); + +/* 32 bit seed is always stored in BIOS NVM */ + lfsr = mrc_params->timings.scrambler_seed; + +if (mrc_params->boot_mode ==BM_COLD ) { +/* +* factory value is 0 and in first boot, +* a clock based seed is loaded. +*/ +if (lfsr ==0 ) { +/* +* get seed from system clock +* and make sure it is not all 1's +*/ + lfsr =rdtsc () &0x0FFFFFFF ; + }else { +/* +* Need to replace scrambler +* +* get next 32bit LFSR 16 times which is the last +* part of the previous scrambler vector +*/ +for (i =0 ; i <16 ; i++) +lfsr32 (&lfsr); + } + +/* save new seed */ + mrc_params->timings.scrambler_seed = lfsr; + } + +/* +* In warm boot or S3 exit, we have the previous seed. +* In cold boot, we have the last 32bit LFSR which is the new seed. +*/ +lfsr32 (&lfsr);/* shift to next value */ +msg_port_write (MEM_CTLR ,SCRMSEED , (lfsr &0x0003FFFF )); + +for (i =0 ; i <2 ; i++) +msg_port_write (MEM_CTLR ,SCRMLO + i, (lfsr &0xAAAAAAAA )); + +LEAVEFN (); +} + +/* +* Configure MCU Power Management Control Register +* and Scheduler Control Register +*/ +void prog_ddr_control (struct mrc_params *mrc_params) +{ +u32 dsch; +u32 dpmc0; + +ENTERFN (); + + dsch =msg_port_read (MEM_CTLR ,DSCH ); + dsch &= ~(BIT8 |BIT9 |BIT12 ); +msg_port_write (MEM_CTLR ,DSCH , dsch); + + dpmc0 =msg_port_read (MEM_CTLR ,DPMC0 ); + dpmc0 &= ~BIT25 ; + dpmc0 |= (mrc_params->power_down_disable <<25 ); + dpmc0 &= ~BIT24 ; + dpmc0 &= ~(BIT16 |BIT17 |BIT18 ); + dpmc0 |= (4 <<16 ); + dpmc0 |=BIT21 ; +msg_port_write (MEM_CTLR ,DPMC0 , dpmc0); + +/* CMDTRIST = 2h - CMD/ADDR are tristated when no valid command */ +mrc_write_mask (MEM_CTLR ,DPMC1 ,2 <<4 ,BIT4 |BIT5 ); + +LEAVEFN (); +} + +/* +* After training complete configure MCU Rank Population Register +* specifying: ranks enabled, device width, density, address mode +*/ +void prog_dra_drb (struct mrc_params *mrc_params) +{ +u32 drp; +u32 dco; +u8 density = mrc_params->params.density; + +ENTERFN (); + + dco =msg_port_read (MEM_CTLR ,DCO ); + dco &= ~BIT31 ; +msg_port_write (MEM_CTLR ,DCO , dco); + + drp =0 ; +if (mrc_params->rank_enables &1 ) + drp |=BIT0 ; +if (mrc_params->rank_enables &2 ) + drp |=BIT1 ; +if (mrc_params->dram_width ==X16 ) { + drp |= (1 <<4 ); + drp |= (1 <<9 ); + } + +/* +* Density encoding in struct dram_params: 0=512Mb, 1=Gb, 2=2Gb, 3=4Gb +* has to be mapped RANKDENSx encoding (0=1Gb) +*/ +if (density ==0 ) + density =4 ; + + drp |= ((density -1 ) <<6 ); + drp |= ((density -1 ) <<11 ); + +/* Address mode can be overwritten if ECC enabled */ + drp |= (mrc_params->address_mode <<14 ); + +msg_port_write (MEM_CTLR ,DRP , drp); + + dco &= ~BIT28 ; + dco |=BIT31 ; +msg_port_write (MEM_CTLR ,DCO , dco); + +LEAVEFN (); +} + +/* Send DRAM wake command */ +void perform_wake (struct mrc_params *mrc_params) +{ +ENTERFN (); + +dram_wake_command (); + +LEAVEFN (); +} + +/* +* Configure refresh rate and short ZQ calibration interval +* Activate dynamic self refresh +*/ +void change_refresh_period (struct mrc_params *mrc_params) +{ +u32 drfc; +u32 dcal; +u32 dpmc0; + +ENTERFN (); + + drfc =msg_port_read (MEM_CTLR ,DRFC ); + drfc &= ~(BIT12 |BIT13 |BIT14 ); + drfc |= (mrc_params->refresh_rate <<12 ); + drfc |=BIT21 ; +msg_port_write (MEM_CTLR ,DRFC , drfc); + + dcal =msg_port_read (MEM_CTLR ,DCAL ); + dcal &= ~(BIT8 |BIT9 |BIT10 ); + dcal |= (3 <<8 );/* 63ms */ +msg_port_write (MEM_CTLR ,DCAL , dcal); + + dpmc0 =msg_port_read (MEM_CTLR ,DPMC0 ); + dpmc0 |= (BIT23 |BIT29 ); +msg_port_write (MEM_CTLR ,DPMC0 , dpmc0); + +LEAVEFN (); +} + +/* +* Configure DDRPHY for Auto-Refresh, Periodic Compensations, +* Dynamic Diff-Amp, ZQSPERIOD, Auto-Precharge, CKE Power-Down +*/ +void set_auto_refresh (struct mrc_params *mrc_params) +{ +uint32_t channel; +uint32_t rank; +uint32_t bl; +uint32_t bl_divisor =1 ; +uint32_t temp; + +ENTERFN (); + +/* +* Enable Auto-Refresh, Periodic Compensations, Dynamic Diff-Amp, +* ZQSPERIOD, Auto-Precharge, CKE Power-Down +*/ +for (channel =0 ; channel <NUM_CHANNELS ; channel++) { +if (mrc_params->channel_enables & (1 << channel)) { +/* Enable Periodic RCOMPS */ +mrc_alt_write_mask (DDRPHY ,CMPCTRL ,BIT1 ,BIT1 ); + +/* Enable Dynamic DiffAmp & Set Read ODT Value */ +switch (mrc_params->rd_odt_value) { +case 0 : + temp =0x3F ;/* OFF */ +break ; +default : + temp =0x00 ;/* Auto */ +break ; + } + +for (bl =0 ; bl < ((NUM_BYTE_LANES / bl_divisor) /2 ); bl++) { +/* Override: DIFFAMP, ODT */ +mrc_alt_write_mask (DDRPHY , + (B0OVRCTL + (bl *DDRIODQ_BL_OFFSET ) + + (channel *DDRIODQ_CH_OFFSET )), + (0x00 <<16 ) | (temp <<10 ), + (BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 |BIT15 |BIT14 | +BIT13 |BIT12 |BIT11 |BIT10 )); + +/* Override: DIFFAMP, ODT */ +mrc_alt_write_mask (DDRPHY , + (B1OVRCTL + (bl *DDRIODQ_BL_OFFSET ) + + (channel *DDRIODQ_CH_OFFSET )), + (0x00 <<16 ) | (temp <<10 ), + (BIT21 |BIT20 |BIT19 |BIT18 | +BIT17 |BIT16 |BIT15 |BIT14 | +BIT13 |BIT12 |BIT11 |BIT10 )); + } + +/* Issue ZQCS command */ +for (rank =0 ; rank <NUM_RANKS ; rank++) { +if (mrc_params->rank_enables & (1 << rank)) +dram_init_command (DCMD_ZQCS (rank)); + } + } + } + +clear_pointers (); + +LEAVEFN (); +} + +/* +* Depending on configuration enables ECC support +* +* Available memory size is decreased, and updated with 0s +* in order to clear error status. Address mode 2 forced. +*/ +void ecc_enable (struct mrc_params *mrc_params) +{ +u32 drp; +u32 dsch; +u32 ecc_ctrl; + +if (mrc_params->ecc_enables ==0 ) +return ; + +ENTERFN (); + +/* Configuration required in ECC mode */ + drp =msg_port_read (MEM_CTLR ,DRP ); + drp &= ~(BIT14 |BIT15 ); + drp |=BIT15 ; + drp |=BIT13 ; +msg_port_write (MEM_CTLR ,DRP , drp); + +/* Disable new request bypass */ + dsch =msg_port_read (MEM_CTLR ,DSCH ); + dsch |=BIT12 ; +msg_port_write (MEM_CTLR ,DSCH , dsch); + +/* Enable ECC */ + ecc_ctrl = (BIT0 |BIT1 |BIT17 ); +msg_port_write (MEM_CTLR ,DECCCTRL , ecc_ctrl); + +/* Assume 8 bank memory, one bank is gone for ECC */ + mrc_params->mem_size -= mrc_params->mem_size /8 ; + +/* For S3 resume memory content has to be preserved */ +if (mrc_params->boot_mode !=BM_S3 ) { +select_hte (); +hte_mem_init (mrc_params,MRC_MEM_INIT ); +select_mem_mgr (); + } + +LEAVEFN (); +} + +/* +* Execute memory test +* if error detected it is indicated in mrc_params->status +*/ +void memory_test (struct mrc_params *mrc_params) +{ +uint32_t result =0 ; + +ENTERFN (); + +select_hte (); + result =hte_mem_init (mrc_params,MRC_MEM_TEST ); +select_mem_mgr (); + +DPF (D_INFO ,"Memory test result %x\n" , result); + mrc_params->status = ((result ==0 ) ?MRC_SUCCESS :MRC_E_MEMTEST ); +LEAVEFN (); +} + +/* Lock MCU registers at the end of initialization sequence */ +void lock_registers (struct mrc_params *mrc_params) +{ +u32 dco; + +ENTERFN (); + + dco =msg_port_read (MEM_CTLR ,DCO ); + dco &= ~(BIT28 |BIT29 ); + dco |= (BIT0 |BIT8 ); +msg_port_write (MEM_CTLR ,DCO , dco); + +LEAVEFN (); +}arch/x86/cpu/quark/smc.h new file +0
-1--- /dev/null
Quoted 8 lines
arch/x86/cpu/quark/smc.h line 6
Quoted 8 lines
+++
b/arch/x86/cpu/quark/smc.harch/x86/cpu/quark/smc.h new file +6
-0@@ -0,0 +1,446 @@ +/* +* Copyright (C) 2013, Intel Corporation +* Copyright (C) 2015, Bin Meng <[email protected]> +* +* Ported from Intel released Quark UEFI BIOS +* QuarkSocPkg/QuarkNorthCluster/MemoryInit/Pei/
Removed the ending / in v2.
Quoted 45 lines
Quoted 45 lines
arch/x86/cpu/quark/smc.h new file +45
-0+* +* SPDX-License-Identifier: Intel +*/ + +#ifndef _SMC_H_ +#define _SMC_H_ + +/* System Memory Controller Register Defines */ + +/* Memory Controller Message Bus Registers Offsets */ +#define DRP 0x00 +#define DTR0 0x01 +#define DTR1 0x02 +#define DTR2 0x03 +#define DTR3 0x04 +#define DTR4 0x05 +#define DPMC0 0x06 +#define DPMC1 0x07 +#define DRFC 0x08 +#define DSCH 0x09 +#define DCAL 0x0A +#define DRMC 0x0B +#define PMSTS 0x0C +#define DCO 0x0F +#define DSTAT 0x20 +#define SSKPD0 0x4A +#define SSKPD1 0x4B +#define DECCCTRL 0x60 +#define DECCSTAT 0x61 +#define DECCSBECNT 0x62 +#define DECCSBECA 0x68 +#define DECCSBECS 0x69 +#define DECCDBECA 0x6A +#define DECCDBECS 0x6B +#define DFUSESTAT 0x70 +#define SCRMSEED 0x80 +#define SCRMLO 0x81 +#define SCRMHI 0x82 + +/* DRAM init command */ +#define DCMD_MRS1 (rnk, dat) (0 | ((rnk) << 22) | (1 << 3) | ((dat) << 6)) +#define DCMD_REF (rnk) (1 | ((rnk) << 22)) +#define DCMD_PRE (rnk) (2 | ((rnk) << 22)) +#define DCMD_PREA (rnk) (2 | ((rnk) << 22) | (BIT10 << 6)) +#define DCMD_ACT (rnk, row) (3 | ((rnk) << 22) | ((row) << 6))
Quoted 8 lines
arch/x86/cpu/quark/smc.h line 56
Quoted 5 lines
arch/x86/cpu/quark/smc.h new file +5
-0+#define DCMD_WR (rnk, col) (4 | ((rnk) << 22) | ((col) << 6)) +#define DCMD_RD (rnk, col) (5 | ((rnk) << 22) | ((col) << 6)) +#define DCMD_ZQCS (rnk) (6 | ((rnk) << 22)) +#define DCMD_ZQCL (rnk) (6 | ((rnk) << 22) | (BIT10 << 6)) +#define DCMD_NOP (rnk) (7 | ((rnk) << 22))We should have a #define for the 22 and a #define for the 6, and probably an enum for the 0, 1, 2, .. 7.
Acutally I have no idea about this DCMD macro group. They are undocumented in the Intel datasheet. I suspect it is something in the JEDEC DDR spec though. Did not change this in v2.
Quoted 8 lines
Then the C code should ideally do:
ENUM_NAME| (rnk <<DCMD_XXX_SHIFT) | (col <<DCMD_SHFIT)instead of
DCMD_RD(rnk, col)
Quoted 12 lines
arch/x86/cpu/quark/smc.h line 66
Quoted 10 lines
arch/x86/cpu/quark/smc.h new file +10
-0+ +#define DDR3_EMRS1_DIC_40 (0) +#define DDR3_EMRS1_DIC_34 (1) + +#define DDR3_EMRS1_RTTNOM_0 (0) +#define DDR3_EMRS1_RTTNOM_60 (BIT2) +#define DDR3_EMRS1_RTTNOM_120 (BIT6) +#define DDR3_EMRS1_RTTNOM_40 (BIT6 | BIT2) +#define DDR3_EMRS1_RTTNOM_20 (BIT9) +#define DDR3_EMRS1_RTTNOM_30 (BIT9 | BIT2)Let's right out the value here
Fixed
Quoted 4 lines
arch/x86/cpu/quark/smc.h line 68
Quoted 2 lines
arch/x86/cpu/quark/smc.h new file +2
-0+ +#define DDR3_EMRS2_RTTWR_60 (BIT9)(1 << 9)
Fixed
Quoted 3 lines
arch/x86/cpu/quark/smc.h line 69
Quoted 1 line
arch/x86/cpu/quark/smc.h new file +1
-0+#define DDR3_EMRS2_RTTWR_120 (BIT10)(1 << 10)
Fixed
Quoted 5 lines
Quoted 5 lines
arch/x86/cpu/quark/smc.h new file +5
-0+ +/* BEGIN DDRIO Registers */ + +/* DDR IOs & COMPs */ +#define DDRIODQ_BL_OFFSET 0x0800
Quoted 8 lines
arch/x86/cpu/quark/smc.h line 80
Quoted 6 lines
arch/x86/cpu/quark/smc.h new file +6
-0+#define DDRIODQ_CH_OFFSET ((NUM_BYTE_LANES / 2) * DDRIODQ_BL_OFFSET) +#define DDRIOCCC_CH_OFFSET 0x0800 +#define DDRCOMP_CH_OFFSET 0x0100 + +/* CH0-BL01-DQ */ +#define DQOBSCKEBBCTL 0x0000Are these accessed through the
msg_port? If not, we could use a struct.
They are all accessed via msg port, and undocumented!!
Quoted 358 lines
Quoted 358 lines
arch/x86/cpu/quark/smc.h new file +358
-0+#define DQDLLTXCTL 0x0004 +#define DQDLLRXCTL 0x0008 +#define DQMDLLCTL 0x000C +#define B0RXIOBUFCTL 0x0010 +#define B0VREFCTL 0x0014 +#define B0RXOFFSET1 0x0018 +#define B0RXOFFSET0 0x001C +#define B1RXIOBUFCTL 0x0020 +#define B1VREFCTL 0x0024 +#define B1RXOFFSET1 0x0028 +#define B1RXOFFSET0 0x002C +#define DQDFTCTL 0x0030 +#define DQTRAINSTS 0x0034 +#define B1DLLPICODER0 0x0038 +#define B0DLLPICODER0 0x003C +#define B1DLLPICODER1 0x0040 +#define B0DLLPICODER1 0x0044 +#define B1DLLPICODER2 0x0048 +#define B0DLLPICODER2 0x004C +#define B1DLLPICODER3 0x0050 +#define B0DLLPICODER3 0x0054 +#define B1RXDQSPICODE 0x0058 +#define B0RXDQSPICODE 0x005C +#define B1RXDQPICODER32 0x0060 +#define B1RXDQPICODER10 0x0064 +#define B0RXDQPICODER32 0x0068 +#define B0RXDQPICODER10 0x006C +#define B01PTRCTL0 0x0070 +#define B01PTRCTL1 0x0074 +#define B01DBCTL0 0x0078 +#define B01DBCTL1 0x007C +#define B0LATCTL0 0x0080 +#define B1LATCTL0 0x0084 +#define B01LATCTL1 0x0088 +#define B0ONDURCTL 0x008C +#define B1ONDURCTL 0x0090 +#define B0OVRCTL 0x0094 +#define B1OVRCTL 0x0098 +#define DQCTL 0x009C +#define B0RK2RKCHGPTRCTRL 0x00A0 +#define B1RK2RKCHGPTRCTRL 0x00A4 +#define DQRK2RKCTL 0x00A8 +#define DQRK2RKPTRCTL 0x00AC +#define B0RK2RKLAT 0x00B0 +#define B1RK2RKLAT 0x00B4 +#define DQCLKALIGNREG0 0x00B8 +#define DQCLKALIGNREG1 0x00BC +#define DQCLKALIGNREG2 0x00C0 +#define DQCLKALIGNSTS0 0x00C4 +#define DQCLKALIGNSTS1 0x00C8 +#define DQCLKGATE 0x00CC +#define B0COMPSLV1 0x00D0 +#define B1COMPSLV1 0x00D4 +#define B0COMPSLV2 0x00D8 +#define B1COMPSLV2 0x00DC +#define B0COMPSLV3 0x00E0 +#define B1COMPSLV3 0x00E4 +#define DQVISALANECR0TOP 0x00E8 +#define DQVISALANECR1TOP 0x00EC +#define DQVISACONTROLCRTOP 0x00F0 +#define DQVISALANECR0BL 0x00F4 +#define DQVISALANECR1BL 0x00F8 +#define DQVISACONTROLCRBL 0x00FC +#define DQTIMINGCTRL 0x010C + +/* CH0-ECC */ +#define ECCDLLTXCTL 0x2004 +#define ECCDLLRXCTL 0x2008 +#define ECCMDLLCTL 0x200C +#define ECCB1DLLPICODER0 0x2038 +#define ECCB1DLLPICODER1 0x2040 +#define ECCB1DLLPICODER2 0x2048 +#define ECCB1DLLPICODER3 0x2050 +#define ECCB01DBCTL0 0x2078 +#define ECCB01DBCTL1 0x207C +#define ECCCLKALIGNREG0 0x20B8 +#define ECCCLKALIGNREG1 0x20BC +#define ECCCLKALIGNREG2 0x20C0 + +/* CH0-CMD */ +#define CMDOBSCKEBBCTL 0x4800 +#define CMDDLLTXCTL 0x4808 +#define CMDDLLRXCTL 0x480C +#define CMDMDLLCTL 0x4810 +#define CMDRCOMPODT 0x4814 +#define CMDDLLPICODER0 0x4820 +#define CMDDLLPICODER1 0x4824 +#define CMDCFGREG0 0x4840 +#define CMDPTRREG 0x4844 +#define CMDCLKALIGNREG0 0x4850 +#define CMDCLKALIGNREG1 0x4854 +#define CMDCLKALIGNREG2 0x4858 +#define CMDPMCONFIG0 0x485C +#define CMDPMDLYREG0 0x4860 +#define CMDPMDLYREG1 0x4864 +#define CMDPMDLYREG2 0x4868 +#define CMDPMDLYREG3 0x486C +#define CMDPMDLYREG4 0x4870 +#define CMDCLKALIGNSTS0 0x4874 +#define CMDCLKALIGNSTS1 0x4878 +#define CMDPMSTS0 0x487C +#define CMDPMSTS1 0x4880 +#define CMDCOMPSLV 0x4884 +#define CMDBONUS0 0x488C +#define CMDBONUS1 0x4890 +#define CMDVISALANECR0 0x4894 +#define CMDVISALANECR1 0x4898 +#define CMDVISACONTROLCR 0x489C +#define CMDCLKGATE 0x48A0 +#define CMDTIMINGCTRL 0x48A4 + +/* CH0-CLK-CTL */ +#define CCOBSCKEBBCTL 0x5800 +#define CCRCOMPIO 0x5804 +#define CCDLLTXCTL 0x5808 +#define CCDLLRXCTL 0x580C +#define CCMDLLCTL 0x5810 +#define CCRCOMPODT 0x5814 +#define CCDLLPICODER0 0x5820 +#define CCDLLPICODER1 0x5824 +#define CCDDR3RESETCTL 0x5830 +#define CCCFGREG0 0x5838 +#define CCCFGREG1 0x5840 +#define CCPTRREG 0x5844 +#define CCCLKALIGNREG0 0x5850 +#define CCCLKALIGNREG1 0x5854 +#define CCCLKALIGNREG2 0x5858 +#define CCPMCONFIG0 0x585C +#define CCPMDLYREG0 0x5860 +#define CCPMDLYREG1 0x5864 +#define CCPMDLYREG2 0x5868 +#define CCPMDLYREG3 0x586C +#define CCPMDLYREG4 0x5870 +#define CCCLKALIGNSTS0 0x5874 +#define CCCLKALIGNSTS1 0x5878 +#define CCPMSTS0 0x587C +#define CCPMSTS1 0x5880 +#define CCCOMPSLV1 0x5884 +#define CCCOMPSLV2 0x5888 +#define CCCOMPSLV3 0x588C +#define CCBONUS0 0x5894 +#define CCBONUS1 0x5898 +#define CCVISALANECR0 0x589C +#define CCVISALANECR1 0x58A0 +#define CCVISACONTROLCR 0x58A4 +#define CCCLKGATE 0x58A8 +#define CCTIMINGCTL 0x58AC + +/* COMP */ +#define CMPCTRL 0x6800 +#define SOFTRSTCNTL 0x6804 +#define MSCNTR 0x6808 +#define NMSCNTRL 0x680C +#define LATCH1CTL 0x6814 +#define COMPVISALANECR0 0x681CLines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Quoted 8 lines
arch/x86/cpu/quark/smc.h
Quoted 6 lines
arch/x86/cpu/quark/smc.h new file +6
-0Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
Function comments should go here.
They are only used internally in MRC.
Quoted 8 lines
Quoted 5 lines
arch/x86/cpu/quark/smc.h new file +2
-1Lines of this file are not shown. View the raw message.
The rest of this diff is not shown. View the raw message.
1.8.2.1
Regards,
Simon
Regards,
Bin
Part of the diff is not shown here. View the raw message.
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
In reply to Bin MengTurn on the Memory Reference code build in the quark Makefile.
---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)
arch/x86/cpu/quark/Makefile +1 -0
@@ -5,4 +5,5 @@ # obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.o
Signature · 1 line
1.8.2.1
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
Hi Bin,
Quoted 13 lines · Bin Meng
Turn on the Memory Reference code build in the quark
Makefile.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)arch/x86/cpu/quark/Makefile +0
-0
arch/x86/cpu/quark/Makefile line 9
Quoted 5 lines
arch/x86/cpu/quark/Makefile +1
-0@@ -5,4 +5,5 @@ # obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.o
Would prefer that you do this as you add each file (i.e. in the patch that adds the file).
Regards,
Simon
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
Hi Simon,
Quoted 18 lines · Simon Glass
Hi Bin,
Quoted 15 lines · Bin Meng
Turn on the Memory Reference code build in the quark
Makefile.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)arch/x86/cpu/quark/Makefile +0
-0@@ -5,4 +5,5 @@ #
Quoted 7 lines
arch/x86/cpu/quark/Makefile line 9
Quoted 3 lines
arch/x86/cpu/quark/Makefile +1
-0obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.oWould prefer that you do this as you add each file (i.e. in the patch that adds the file).
OK, will squash this one to previous commits.
Regards,
Bin
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
Hi Simon,
Quoted 29 lines · Bin Meng
Hi Simon,
Quoted 18 lines · Simon Glass
Hi Bin,
Quoted 15 lines · Bin Meng
Turn on the Memory Reference code build in the quark
Makefile.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)arch/x86/cpu/quark/Makefile +0
-0@@ -5,4 +5,5 @@ #Quoted 7 lines
arch/x86/cpu/quark/Makefile line 9
Quoted 3 lines
arch/x86/cpu/quark/Makefile +1
-0obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.oWould prefer that you do this as you add each file (i.e. in the patch that adds the file).
Quoted 1 line
OK, will squash this one to previous commits.
Sorry I was replying too fast. Looks that I cannot add each file to Makefile each time, because it will not build until the 3rd patch is in place to provide all header files needed.
Regards,
Bin
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
Hello Bin,
Quoted 32 lines · Bin Meng
Hi Simon,
Quoted 29 lines · Bin Meng
Hi Simon,
Quoted 25 lines · Simon Glass
Hi Bin,
Quoted 13 lines · Bin Meng
Turn on the Memory Reference code build in the quark
Makefile.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)arch/x86/cpu/quark/Makefile +0
-0arch/x86/cpu/quark/Makefile line 9
Quoted 5 lines
arch/x86/cpu/quark/Makefile +1
-0@@ -5,4 +5,5 @@ # obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.oWould prefer that you do this as you add each file (i.e. in the patch that adds the file).
Quoted 5 lines
Quoted 1 line
OK, will squash this one to previous commits.
Sorry I was replying too fast. Looks that I cannot add each file to
Makefileeach time, because it will not build until the 3rd patch is in place to provide all header files needed.
Can't you reorder the patches so that things build properly at each addition? IF you can't, then there is a cross-dependency, and the cross-dependent patches (and only these!) should be made into a single patch.
Quoted 2 lines
Regards,
Bin
Amicalement,
Signature · 1 line
Albert.
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
Hi Albert,
Quoted 37 lines · Albert ARIBAUD
Hello Bin,
Quoted 34 lines · Bin Meng
Hi Simon,
Quoted 30 lines · Bin Meng
Hi Simon,
Quoted 18 lines · Simon Glass
Hi Bin,
Quoted 15 lines · Bin Meng
Turn on the Memory Reference code build in the quark
Makefile.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)arch/x86/cpu/quark/Makefile +0
-0@@ -5,4 +5,5 @@ #Quoted 7 lines
arch/x86/cpu/quark/Makefile line 9
Quoted 3 lines
arch/x86/cpu/quark/Makefile +1
-0obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.oWould prefer that you do this as you add each file (i.e. in the patch that adds the file).
OK, will squash this one to previous commits.
Quoted 9 lines
Quoted 3 lines
Sorry I was replying too fast. Looks that I cannot add each file to
Makefileeach time, because it will not build until the 3rd patch is in place to provide all header files needed.Can't you reorder the patches so that things build properly at each addition? IF you can't, then there is a cross-dependency, and the cross-dependent patches (and only these!) should be made into a single patch.
I wanted to put them all together as a single patch before, but there is a 100KB email limit on this mailing list. So each patch was created like this, a <xxx.c> with its header <xxx.h>. Yes, I could just put all header files into one patch. Then add each <xxx.c> as a single patch and enable the build. Anyway, so far this patch series does not break any bisectability.
Regards,
Bin
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
Quoted 51 lines · Bin Meng
Hi Albert,
Quoted 37 lines · Albert ARIBAUD
Hello Bin,
Quoted 34 lines · Bin Meng
Hi Simon,
Quoted 30 lines · Bin Meng
Hi Simon,
Quoted 18 lines · Simon Glass
Hi Bin,
Quoted 15 lines · Bin Meng
Turn on the Memory Reference code build in the quark
Makefile.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/Makefile | 1 + 1 file changed, 1 insertion(+)arch/x86/cpu/quark/Makefile +0
-0@@ -5,4 +5,5 @@ #Quoted 7 lines
arch/x86/cpu/quark/Makefile line 9
Quoted 3 lines
arch/x86/cpu/quark/Makefile +1
-0obj-y += car.o dram.o msg_port.o quark.o +obj-y += mrc.o mrc_util.o hte.o smc.o obj-$(CONFIG_PCI) += pci.oWould prefer that you do this as you add each file (i.e. in the patch that adds the file).
OK, will squash this one to previous commits.
Quoted 9 lines
Quoted 3 lines
Sorry I was replying too fast. Looks that I cannot add each file to
Makefileeach time, because it will not build until the 3rd patch is in place to provide all header files needed.Can't you reorder the patches so that things build properly at each addition? IF you can't, then there is a cross-dependency, and the cross-dependent patches (and only these!) should be made into a single patch.
Quoted 6 lines
I wanted to put them all together as a single patch before, but there is a 100KB email limit on this mailing list. So each patch was created like this, a <
xxx.c> with its header <xxx.h>. Yes, I could just put all header files into one patch. Then add each <xxx.c> as a single patch and enable the build. Anyway, so far this patch series does not break any bisectability.
I'm happy enough with this.
RFC PATCH 6/9 x86: quark: Enable the Memory Reference Code build
[snip]
Quoted 3 lines
I'm happy enough with this.
Acked-by Simon Glass <[email protected]>
Applied to u-boot-x86, thanks!
RFC PATCH 7/9 fdtdec: Add compatible id and string for Intel Quark MRC
In reply to Bin MengAdd COMPAT_INTEL_QRK_MRC and "intel,quark-mrc" so that fdtdec can decode Intel Quark MRC node.
---
include/fdtdec.h | 1 + lib/fdtdec.c | 1 + 2 files changed, 2 insertions(+)
include/fdtdec.h +1 -0
@@ -174,6 +174,7 @@ enum fdt_compat_id {COMPAT_INTEL_GMA ,/* Intel Graphics Media Accelerator */ COMPAT_AMS_AS3722 ,/* AMS AS3722 PMIC */ COMPAT_INTEL_ICH_SPI ,/* Intel ICH7/9 SPI controller */ +COMPAT_INTEL_QRK_MRC ,/* Intel Quark MRC */ COMPAT_COUNT, };
lib/fdtdec.c +1 -0
@@ -84,6 +84,7 @@ static const char * const compat_names[COMPAT_COUNT] = {COMPAT (INTEL_GMA ,"intel,gma" ),COMPAT (AMS_AS3722 ,"ams,as3722" ),COMPAT (INTEL_ICH_SPI ,"intel,ich-spi" ), + COMPAT(INTEL_QRK_MRC, "intel,quark-mrc"), };const char *fdtdec_get_compatible (enum fdt_compat_id id)
Signature · 1 line
1.8.2.1
RFC PATCH 7/9 fdtdec: Add compatible id and string for Intel Quark MRC
Quoted 9 lines · Bin Meng
Add
COMPAT_INTEL_QRK_MRCand "intel,quark-mrc" so that fdtdec can decode Intel Quark MRC node.Signed-off-by Bin Meng <[email protected]>---
include/fdtdec.h | 1 + lib/fdtdec.c | 1 + 2 files changed, 2 insertions(+)
RFC PATCH 8/9 dt-bindings: Add Intel Quark MRC bindings
In reply to Bin MengAdd standard dt-bindings macros to be used by Intel Quark MRC node.
---
include/dt-bindings/mrc/quark.h | 83 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 include/dt-bindings/mrc/quark.h
include/dt-bindings/mrc/quark.h new file +83 -0
@@ -0,0 +1,83 @@ +/* +* Copyright (C) 2015, Bin Meng <[email protected]> +* +* SPDX-License-Identifier: GPL-2.0+ +* +* Intel Quark MRC bindings include several properties +* as part of an Intel Quark MRC node. In most cases, +* the value of these properties uses the standard values +* defined in this header. +*/ + +#ifndef _DT_BINDINGS_QRK_MRC_H_ +#define _DT_BINDINGS_QRK_MRC_H_ + +/* MRC platform data flags */ +#define MRC_FLAG_ECC_EN 0x00000001 +#define MRC_FLAG_SCRAMBLE_EN 0x00000002 +#define MRC_FLAG_MEMTEST_EN 0x00000004 +/* 0b DDR "fly-by" topology else 1b DDR "tree" topology */ +#define MRC_FLAG_TOP_TREE_EN 0x00000008 +/* If set ODR signal is asserted to DRAM devices on writes */ +#define MRC_FLAG_WR_ODT_EN 0x00000010 + +/* DRAM width */ +#define DRAM_WIDTH_X8 0 +#define DRAM_WIDTH_X16 1 +#define DRAM_WIDTH_X32 2 + +/* DRAM speed */ +#define DRAM_FREQ_800 0 +#define DRAM_FREQ_1066 1 + +/* DRAM type */ +#define DRAM_TYPE_DDR3 0 +#define DRAM_TYPE_DDR3L 1 + +/* DRAM rank mask */ +#define DRAM_RANK (n) (1 << (n)) + +/* DRAM channel mask */ +#define DRAM_CHANNEL (n) (1 << (n)) + +/* DRAM channel width */ +#define DRAM_CHANNEL_WIDTH_X8 0 +#define DRAM_CHANNEL_WIDTH_X16 1 +#define DRAM_CHANNEL_WIDTH_X32 2 + +/* DRAM address mode */ +#define DRAM_ADDR_MODE0 0 +#define DRAM_ADDR_MODE1 1 +#define DRAM_ADDR_MODE2 2 + +/* DRAM refresh rate */ +#define DRAM_REFRESH_RATE_195US 1 +#define DRAM_REFRESH_RATE_39US 2 +#define DRAM_REFRESH_RATE_785US 3 + +/* DRAM SR temprature range */ +#define DRAM_SRT_RANGE_NORMAL 0 +#define DRAM_SRT_RANGE_EXTENDED 1 + +/* DRAM ron value */ +#define DRAM_RON_34OHM 0 +#define DRAM_RON_40OHM 1 + +/* DRAM rtt nom value */ +#define DRAM_RTT_NOM_40OHM 0 +#define DRAM_RTT_NOM_60OHM 1 +#define DRAM_RTT_NOM_120OHM 2 + +/* DRAM rd odt value */ +#define DRAM_RD_ODT_OFF 0 +#define DRAM_RD_ODT_60OHM 1 +#define DRAM_RD_ODT_120OHM 2 +#define DRAM_RD_ODT_180OHM 3 + +/* DRAM density */ +#define DRAM_DENSITY_512M 0 +#define DRAM_DENSITY_1G 1 +#define DRAM_DENSITY_2G 2 +#define DRAM_DENSITY_4G 3 + +#endif /* _DT_BINDINGS_QRK_MRC_H_ */
Signature · 1 line
1.8.2.1
RFC PATCH 8/9 dt-bindings: Add Intel Quark MRC bindings
Quoted 8 lines · Bin Meng
Add standard dt-bindings macros to be used by Intel Quark MRC node.
Signed-off-by Bin Meng <[email protected]>---
include/dt-bindings/mrc/quark.h | 83 +++++++++++++++++++++++++++++++++++++++++ 1 file changed, 83 insertions(+) create mode 100644 include/dt-bindings/mrc/quark.h
RFC PATCH 9/9 x86: quark: Call MRC in dram_init()
In reply to Bin MengNow that we have added Quark MRC codes, call MRC in dram_init() so that DRAM can be initialized on a Quark based board.
---
arch/x86/cpu/quark/dram.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++- arch/x86/dts/galileo.dts | 25 ++++++++++++ 2 files changed, 120 insertions(+), 2 deletions(-)
arch/x86/cpu/quark/dram.c +95 -2
@@ -5,15 +5,108 @@*/ #include <common.h> +#include <errno.h> +#include <fdtdec.h> #include <asm/post.h> +#include <asm/arch/mrc.h> #include <asm/arch/quark.h> DECLARE_GLOBAL_DATA_PTR ; +static int mrc_configure_params (struct mrc_params *mrc_params) +{ +const void *blob = gd->fdt_blob; +int node; +int mrc_flags; + + node =fdtdec_next_compatible (blob,0 ,COMPAT_INTEL_QRK_MRC ); +if (node <0 ) { +debug ("%s: Cannot find MRC node\n" , __func__); +return -EINVAL ; + } + +/* +* TODO: +* +* We need support fast boot (MRC cache) in the future. +* +* Set boot mode to cold boot for now +*/ + mrc_params->boot_mode =BM_COLD ; + +/* +* TODO: +* +* We need determine ECC by pin strap state +* +* Disable ECC by default for now +*/ + mrc_params->ecc_enables =0 ; + + mrc_flags =fdtdec_get_int (blob, node,"flags" ,0 ); +if (mrc_flags &MRC_FLAG_SCRAMBLE_EN ) + mrc_params->scrambling_enables =1 ; +else + mrc_params->scrambling_enables =0 ; + + mrc_params->dram_width =fdtdec_get_int (blob, node,"dram-width" ,0 ); + mrc_params->ddr_speed =fdtdec_get_int (blob, node,"dram-speed" ,0 ); + mrc_params->ddr_type =fdtdec_get_int (blob, node,"dram-type" ,0 ); + + mrc_params->rank_enables =fdtdec_get_int (blob, node,"rank-mask" ,0 ); + mrc_params->channel_enables =fdtdec_get_int (blob, node, +"chan-mask" ,0 ); + mrc_params->channel_width =fdtdec_get_int (blob, node, +"chan-width" ,0 ); + mrc_params->address_mode =fdtdec_get_int (blob, node,"addr-mode" ,0 ); + + mrc_params->refresh_rate =fdtdec_get_int (blob, node, +"refresh-rate" ,0 ); + mrc_params->sr_temp_range =fdtdec_get_int (blob, node, +"sr-temp-range" ,0 ); + mrc_params->ron_value =fdtdec_get_int (blob, node, +"ron-value" ,0 ); + mrc_params->rtt_nom_value =fdtdec_get_int (blob, node, +"rtt-nom-value" ,0 ); + mrc_params->rd_odt_value =fdtdec_get_int (blob, node, +"rd-odt-value" ,0 ); + + mrc_params->params.density =fdtdec_get_int (blob, node, +"dram-density" ,0 ); + mrc_params->params.cl =fdtdec_get_int (blob, node,"dram-cl" ,0 ); + mrc_params->params.ras =fdtdec_get_int (blob, node,"dram-ras" ,0 ); + mrc_params->params.wtr =fdtdec_get_int (blob, node,"dram-wtr" ,0 ); + mrc_params->params.rrd =fdtdec_get_int (blob, node,"dram-rrd" ,0 ); + mrc_params->params.faw =fdtdec_get_int (blob, node,"dram-faw" ,0 ); + +debug ("MRC dram_width %d\n" , mrc_params->dram_width); +debug ("MRC rank_enables %d\n" , mrc_params->rank_enables); +debug ("MRC ddr_speed %d\n" , mrc_params->ddr_speed); +debug ("MRC flags: %s\n" , + (mrc_params->scrambling_enables) ?"SCRAMBLE_EN" :"" ); + +debug ("MRC density=%d tCL=%d tRAS=%d tWTR=%d tRRD=%d tFAW=%d\n" , + mrc_params->params.density, mrc_params->params.cl, + mrc_params->params.ras, mrc_params->params.wtr, + mrc_params->params.rrd, mrc_params->params.faw); + +return 0 ; +} +int dram_init (void ) { -/* hardcode the DRAM size for now */ - gd->ram_size =DRAM_MAX_SIZE ; +struct mrc_params mrc_params; +int ret; + +memset (&mrc_params,0 ,sizeof (struct mrc_params )); + ret =mrc_configure_params (&mrc_params); +if (ret) +return ret; + +/* Call MRC */ +mrc (&mrc_params); + + gd->ram_size = mrc_params.mem_size;post_code (POST_DRAM );return 0 ;
arch/x86/dts/galileo.dts +25 -0
@@ -6,6 +6,8 @@ /dts-v1/; +#include <dt-bindings/mrc/quark.h> + /include/ "skeleton.dtsi" / {
@@ -20,6 +22,29 @@ stdout-path = &pciuart0; }; + mrc { + compatible = "intel,quark-mrc"; + flags = <MRC_FLAG_SCRAMBLE_EN>; + dram-width = <DRAM_WIDTH_X8>; + dram-speed = <DRAM_FREQ_800>; + dram-type = <DRAM_TYPE_DDR3>; + rank-mask = <DRAM_RANK(0)>; + chan-mask = <DRAM_CHANNEL(0)>; + chan-width = <DRAM_CHANNEL_WIDTH_X16>; + addr-mode = <DRAM_ADDR_MODE0>; + refresh-rate = <DRAM_REFRESH_RATE_785US>; + sr-temp-range = <DRAM_SRT_RANGE_NORMAL>; + ron-value = <DRAM_RON_34OHM>; + rtt-nom-value = <DRAM_RTT_NOM_120OHM>; + rd-odt-value = <DRAM_RD_ODT_OFF>; + dram-density = <DRAM_DENSITY_1G>; + dram-cl = <6>; + dram-ras = <0x0000927c>; + dram-wtr = <0x00002710>; + dram-rrd = <0x00002710>; + dram-faw = <0x00009c40>; + }; + pci { #address-cells = <3>; #size-cells = <2>;
Signature · 1 line
1.8.2.1
RFC PATCH 9/9 x86: quark: Call MRC in dram_init()
Hi Bin,
Quoted 110 lines · Bin Meng
Now that we have added Quark MRC codes, call MRC in
dram_init()so that DRAM can be initialized on a Quark based board.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/dram.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++- arch/x86/dts/galileo.dts | 25 ++++++++++++ 2 files changed, 120 insertions(+), 2 deletions(-)arch/x86/cpu/quark/dram.c +83
-1@@ -5,15 +5,108 @@*/ #include <common.h> +#include <errno.h> +#include <fdtdec.h> #include <asm/post.h> +#include <asm/arch/mrc.h> #include <asm/arch/quark.h> DECLARE_GLOBAL_DATA_PTR ; +static int mrc_configure_params (struct mrc_params *mrc_params) +{ +const void *blob = gd->fdt_blob; +int node; +int mrc_flags; + + node =fdtdec_next_compatible (blob,0 ,COMPAT_INTEL_QRK_MRC ); +if (node <0 ) { +debug ("%s: Cannot find MRC node\n" , __func__); +return -EINVAL ; + } + +/* +* TODO: +* +* We need support fast boot (MRC cache) in the future. +* +* Set boot mode to cold boot for now +*/ + mrc_params->boot_mode =BM_COLD ; + +/* +* TODO: +* +* We need determine ECC by pin strap state +* +* Disable ECC by default for now +*/ + mrc_params->ecc_enables =0 ; + + mrc_flags =fdtdec_get_int (blob, node,"flags" ,0 ); +if (mrc_flags &MRC_FLAG_SCRAMBLE_EN ) + mrc_params->scrambling_enables =1 ; +else + mrc_params->scrambling_enables =0 ; + + mrc_params->dram_width =fdtdec_get_int (blob, node,"dram-width" ,0 ); + mrc_params->ddr_speed =fdtdec_get_int (blob, node,"dram-speed" ,0 ); + mrc_params->ddr_type =fdtdec_get_int (blob, node,"dram-type" ,0 ); + + mrc_params->rank_enables =fdtdec_get_int (blob, node,"rank-mask" ,0 ); + mrc_params->channel_enables =fdtdec_get_int (blob, node, +"chan-mask" ,0 ); + mrc_params->channel_width =fdtdec_get_int (blob, node, +"chan-width" ,0 ); + mrc_params->address_mode =fdtdec_get_int (blob, node,"addr-mode" ,0 ); + + mrc_params->refresh_rate =fdtdec_get_int (blob, node, +"refresh-rate" ,0 ); + mrc_params->sr_temp_range =fdtdec_get_int (blob, node, +"sr-temp-range" ,0 ); + mrc_params->ron_value =fdtdec_get_int (blob, node, +"ron-value" ,0 ); + mrc_params->rtt_nom_value =fdtdec_get_int (blob, node, +"rtt-nom-value" ,0 ); + mrc_params->rd_odt_value =fdtdec_get_int (blob, node, +"rd-odt-value" ,0 ); + + mrc_params->params.density =fdtdec_get_int (blob, node, +"dram-density" ,0 ); + mrc_params->params.cl =fdtdec_get_int (blob, node,"dram-cl" ,0 ); + mrc_params->params.ras =fdtdec_get_int (blob, node,"dram-ras" ,0 ); + mrc_params->params.wtr =fdtdec_get_int (blob, node,"dram-wtr" ,0 ); + mrc_params->params.rrd =fdtdec_get_int (blob, node,"dram-rrd" ,0 ); + mrc_params->params.faw =fdtdec_get_int (blob, node,"dram-faw" ,0 ); + +debug ("MRC dram_width %d\n" , mrc_params->dram_width); +debug ("MRC rank_enables %d\n" , mrc_params->rank_enables); +debug ("MRC ddr_speed %d\n" , mrc_params->ddr_speed); +debug ("MRC flags: %s\n" , + (mrc_params->scrambling_enables) ?"SCRAMBLE_EN" :"" ); + +debug ("MRC density=%d tCL=%d tRAS=%d tWTR=%d tRRD=%d tFAW=%d\n" , + mrc_params->params.density, mrc_params->params.cl, + mrc_params->params.ras, mrc_params->params.wtr, + mrc_params->params.rrd, mrc_params->params.faw); + +return 0 ; +} +int dram_init (void ) { -/* hardcode the DRAM size for now */
arch/x86/cpu/quark/dram.c line 106
Quoted 10 lines
arch/x86/cpu/quark/dram.c +9
-1- gd->ram_size =DRAM_MAX_SIZE ; +struct mrc_params mrc_params; +int ret; + +memset (&mrc_params,0 ,sizeof (struct mrc_params )); + ret =mrc_configure_params (&mrc_params); +if (ret) +return ret; + +/* Call MRC */
How about something like:
/* Set up the SDRAM by calling the memory reference code */
arch/x86/cpu/quark/dram.c line 107
Quoted 1 line
arch/x86/cpu/quark/dram.c +1
-0+mrc (&mrc_params);
Can this fail?
Quoted 49 lines
arch/x86/cpu/quark/dram.c +2
-0+ + gd->ram_size = mrc_params.mem_size;post_code (POST_DRAM );return 0 ;arch/x86/dts/galileo.dts +25
-1@@ -6,6 +6,8 @@ /dts-v1/; +#include <dt-bindings/mrc/quark.h> + /include/ "skeleton.dtsi" / {@@ -20,6 +22,29 @@ stdout-path = &pciuart0; }; + mrc { + compatible = "intel,quark-mrc"; + flags = <MRC_FLAG_SCRAMBLE_EN>; + dram-width = <DRAM_WIDTH_X8>; + dram-speed = <DRAM_FREQ_800>; + dram-type = <DRAM_TYPE_DDR3>; + rank-mask = <DRAM_RANK(0)>; + chan-mask = <DRAM_CHANNEL(0)>; + chan-width = <DRAM_CHANNEL_WIDTH_X16>; + addr-mode = <DRAM_ADDR_MODE0>; + refresh-rate = <DRAM_REFRESH_RATE_785US>; + sr-temp-range = <DRAM_SRT_RANGE_NORMAL>; + ron-value = <DRAM_RON_34OHM>; + rtt-nom-value = <DRAM_RTT_NOM_120OHM>; + rd-odt-value = <DRAM_RD_ODT_OFF>; + dram-density = <DRAM_DENSITY_1G>; + dram-cl = <6>; + dram-ras = <0x0000927c>; + dram-wtr = <0x00002710>; + dram-rrd = <0x00002710>; + dram-faw = <0x00009c40>; + }; + pci { #address-cells = <3>; #size-cells = <2>; --
Quoted 2 lines
1.8.2.1
Regards,
Simon
RFC PATCH 9/9 x86: quark: Call MRC in dram_init()
Hi Simon,
Quoted 126 lines · Simon Glass
Hi Bin,
Quoted 110 lines · Bin Meng
Now that we have added Quark MRC codes, call MRC in
dram_init()so that DRAM can be initialized on a Quark based board.Signed-off-by Bin Meng <[email protected]>---
arch/x86/cpu/quark/dram.c | 97 ++++++++++++++++++++++++++++++++++++++++++++++- arch/x86/dts/galileo.dts | 25 ++++++++++++ 2 files changed, 120 insertions(+), 2 deletions(-)arch/x86/cpu/quark/dram.c +83
-1@@ -5,15 +5,108 @@*/ #include <common.h> +#include <errno.h> +#include <fdtdec.h> #include <asm/post.h> +#include <asm/arch/mrc.h> #include <asm/arch/quark.h> DECLARE_GLOBAL_DATA_PTR ; +static int mrc_configure_params (struct mrc_params *mrc_params) +{ +const void *blob = gd->fdt_blob; +int node; +int mrc_flags; + + node =fdtdec_next_compatible (blob,0 ,COMPAT_INTEL_QRK_MRC ); +if (node <0 ) { +debug ("%s: Cannot find MRC node\n" , __func__); +return -EINVAL ; + } + +/* +* TODO: +* +* We need support fast boot (MRC cache) in the future. +* +* Set boot mode to cold boot for now +*/ + mrc_params->boot_mode =BM_COLD ; + +/* +* TODO: +* +* We need determine ECC by pin strap state +* +* Disable ECC by default for now +*/ + mrc_params->ecc_enables =0 ; + + mrc_flags =fdtdec_get_int (blob, node,"flags" ,0 ); +if (mrc_flags &MRC_FLAG_SCRAMBLE_EN ) + mrc_params->scrambling_enables =1 ; +else + mrc_params->scrambling_enables =0 ; + + mrc_params->dram_width =fdtdec_get_int (blob, node,"dram-width" ,0 ); + mrc_params->ddr_speed =fdtdec_get_int (blob, node,"dram-speed" ,0 ); + mrc_params->ddr_type =fdtdec_get_int (blob, node,"dram-type" ,0 ); + + mrc_params->rank_enables =fdtdec_get_int (blob, node,"rank-mask" ,0 ); + mrc_params->channel_enables =fdtdec_get_int (blob, node, +"chan-mask" ,0 ); + mrc_params->channel_width =fdtdec_get_int (blob, node, +"chan-width" ,0 ); + mrc_params->address_mode =fdtdec_get_int (blob, node,"addr-mode" ,0 ); + + mrc_params->refresh_rate =fdtdec_get_int (blob, node, +"refresh-rate" ,0 ); + mrc_params->sr_temp_range =fdtdec_get_int (blob, node, +"sr-temp-range" ,0 ); + mrc_params->ron_value =fdtdec_get_int (blob, node, +"ron-value" ,0 ); + mrc_params->rtt_nom_value =fdtdec_get_int (blob, node, +"rtt-nom-value" ,0 ); + mrc_params->rd_odt_value =fdtdec_get_int (blob, node, +"rd-odt-value" ,0 ); + + mrc_params->params.density =fdtdec_get_int (blob, node, +"dram-density" ,0 ); + mrc_params->params.cl =fdtdec_get_int (blob, node,"dram-cl" ,0 ); + mrc_params->params.ras =fdtdec_get_int (blob, node,"dram-ras" ,0 ); + mrc_params->params.wtr =fdtdec_get_int (blob, node,"dram-wtr" ,0 ); + mrc_params->params.rrd =fdtdec_get_int (blob, node,"dram-rrd" ,0 ); + mrc_params->params.faw =fdtdec_get_int (blob, node,"dram-faw" ,0 ); + +debug ("MRC dram_width %d\n" , mrc_params->dram_width); +debug ("MRC rank_enables %d\n" , mrc_params->rank_enables); +debug ("MRC ddr_speed %d\n" , mrc_params->ddr_speed); +debug ("MRC flags: %s\n" , + (mrc_params->scrambling_enables) ?"SCRAMBLE_EN" :"" ); + +debug ("MRC density=%d tCL=%d tRAS=%d tWTR=%d tRRD=%d tFAW=%d\n" , + mrc_params->params.density, mrc_params->params.cl, + mrc_params->params.ras, mrc_params->params.wtr, + mrc_params->params.rrd, mrc_params->params.faw); + +return 0 ; +} +int dram_init (void ) { -/* hardcode the DRAM size for now */ arch/x86/cpu/quark/dram.c line 106
Quoted 10 lines
arch/x86/cpu/quark/dram.c +9
-1- gd->ram_size =DRAM_MAX_SIZE ; +struct mrc_params mrc_params; +int ret; + +memset (&mrc_params,0 ,sizeof (struct mrc_params )); + ret =mrc_configure_params (&mrc_params); +if (ret) +return ret; + +/* Call MRC */ How about something like:
Quoted 2 lines
/* Set up the SDRAM by calling the memory reference code */
OK.
Quoted 4 lines
arch/x86/cpu/quark/dram.c line 107
Quoted 1 line
arch/x86/cpu/quark/dram.c +1
-0+mrc (&mrc_params);Can this fail?
Probably. mrc() itself is a function returning void. If you check the 'struct mrc_params', there is a 'status' member which is assigned after memory_test() which is supposed to indicate memory is initialized correctly or not. However during my debug, when the memory is not initialized correctly (some mistakes during the port) and U-Boot hangs at relocating fdt, the output message showed that the status is 0, which I don't understand. The original Intel codes do not check this status after calling MRC, but I think I can add a check here.
[snip]
Regards,
Bin