arch/arm/mach-rk2928/ddr.c

   1 /*
   2  * arch/arm/mach-rk2928/ddr.c-- for ddr3&ddr2
   3  *
   4  * Function Driver for DDR controller
   5  *
   6  * Copyright (C) 2012 Fuzhou Rockchip Electronics Co.,Ltd
   7  * Author:
   8  * hcy@rock-chips.com
   9  * yk@rock-chips.com
  10  * typ@rock-chips.com
  11  *
  12  * v1.00
  13  */
  14
  15 #include <linux/kernel.h>
  16 #include <linux/io.h>
  17 #include <linux/module.h>
  18 #include <linux/clk.h>
  19
  20 #include <asm/cacheflush.h>
  21 #include <asm/tlbflush.h>
  22
  23 #include <mach/sram.h>
  24 #include <mach/ddr.h>
  25
  26 typedef uint32_t uint32 ;
  27
  28
  29 #define DDR3_DDR2_DLL_DISABLE_FREQ    (300)  // ¿ÅÁ£dll disableµÄÆµÂÊ
  30 #define DDR3_DDR2_ODT_DISABLE_FREQ    (333)  //¿ÅÁ£odt disableµÄÆµÂÊ
  31 #define SR_IDLE                       (0x1)   //unit:32*DDR clk cycle, and 0 for disable auto self-refresh
  32 #define PD_IDLE                       (0x40)  //unit:DDR clk cycle, and 0 for disable auto power-down
  33 #define PHY_ODT_DISABLE_FREQ          (333)  //¶¨ÒåÖ÷¿Ø¶Ëodt disableµÄÆµÂÊ
  34 #define PHY_DLL_DISABLE_FREQ          (266)  //¶¨ÒåÖ÷¿Ø¶Ëdll bypassµÄÆµÂÊ
  35
  36 //#define PMU_BASE_ADDR           RK30_PMU_BASE //??RK 2928 PMUÔÚÄÄÀï
  37 #define SDRAMC_BASE_ADDR        RK2928_DDR_PCTL_BASE
  38 #define DDR_PHY_BASE            RK2928_DDR_PHY_BASE
  39 #define CRU_BASE_ADDR           RK2928_CRU_BASE
  40 #define REG_FILE_BASE_ADDR      RK2928_GRF_BASE
  41 #define SysSrv_DdrConf          (RK2928_CPU_AXI_BUS_BASE+0x08)
  42 #define SysSrv_DdrTiming        (RK2928_CPU_AXI_BUS_BASE+0x0c)
  43 #define SysSrv_DdrMode          (RK2928_CPU_AXI_BUS_BASE+0x10)
  44 #define SysSrv_ReadLatency      (RK2928_CPU_AXI_BUS_BASE+0x14)
  45
  46 #define ddr_print(x...) printk( "DDR DEBUG: " x )
  47
  48
  49 /***********************************
  50  * DDR3 define
  51  ***********************************/
  52 //mr0 for ddr3
  53 #define DDR3_BL8          (0)
  54 #define DDR3_BC4_8        (1)
  55 #define DDR3_BC4          (2)
  56 #define DDR3_CL(n)        (((((n)-4)&0x7)<<4)|((((n)-4)&0x8)>>1))
  57 #define DDR3_WR(n)        (((n)&0x7)<<9)
  58 #define DDR3_DLL_RESET    (1<<8)
  59 #define DDR3_DLL_DeRESET  (0<<8)
  60
  61 //mr1 for ddr3
  62 #define DDR3_DLL_ENABLE    (0)
  63 #define DDR3_DLL_DISABLE   (1)
  64 #define DDR3_MR1_AL(n)  (((n)&0x7)<<3)
  65
  66 #define DDR3_DS_40            (0)
  67 #define DDR3_DS_34            (1<<1)
  68 #define DDR3_Rtt_Nom_DIS      (0)
  69 #define DDR3_Rtt_Nom_60       (1<<2)
  70 #define DDR3_Rtt_Nom_120      (1<<6)
  71 #define DDR3_Rtt_Nom_40       ((1<<2)|(1<<6))
  72
  73 //mr2 for ddr3
  74 #define DDR3_MR2_CWL(n) ((((n)-5)&0x7)<<3)
  75 #define DDR3_Rtt_WR_DIS       (0)
  76 #define DDR3_Rtt_WR_60        (1<<9)
  77 #define DDR3_Rtt_WR_120       (2<<9)
  78
  79 /***********************************
  80  * DDR2 define
  81  ***********************************/
  82 //MR;                     //Mode Register
  83 #define DDR2_BL4           (2)
  84 #define DDR2_BL8           (3)
  85 #define DDR2_CL(n)         (((n)&0x7)<<4)
  86 #define DDR2_WR(n)        ((((n)-1)&0x7)<<9)
  87 #define DDR2_DLL_RESET    (1<<8)
  88 #define DDR2_DLL_DeRESET  (0<<8)
  89
  90 //EMR;                    //Extended Mode Register
  91 #define DDR2_DLL_ENABLE    (0)
  92 #define DDR2_DLL_DISABLE   (1)
  93
  94 #define DDR2_STR_FULL     (0)
  95 #define DDR2_STR_REDUCE   (1<<1)
  96 #define DDR2_AL(n)        (((n)&0x7)<<3)
  97 #define DDR2_Rtt_Nom_DIS      (0)
  98 #define DDR2_Rtt_Nom_150      (0x40)
  99 #define DDR2_Rtt_Nom_75       (0x4)
 100 #define DDR2_Rtt_Nom_50       (0x44)
 101
 102
 103 #define DDR_PLL_REFDIV  (1)
 104 #define FBDIV(n)        ((0xFFF<<16) | (n&0xfff))
 105 #define REFDIV(n)       ((0x3F<<16) | (n&0x3f))
 106 #define POSTDIV1(n)     ((0x7<<(12+16)) | ((n&0x7)<<12))
 107 #define POSTDIV2(n)     ((0x7<<(6+16)) | ((n&0x7)<<6))
 108
 109 #define PLL_LOCK_STATUS  (0x1<<10)
 110  //CRU Registers
 111 typedef volatile struct tagCRU_STRUCT
 112 {
 113     uint32 CRU_PLL_CON[4][4];           //cru_pll_con[][4] reserved
 114     uint32 CRU_MODE_CON;
 115     uint32 CRU_CLKSEL_CON[35];
 116     uint32 CRU_CLKGATE_CON[10];
 117     uint32 reserved2[(0x100-0xf8)/4];
 118     uint32 CRU_GLB_SRST_FST_VALUE;
 119     uint32 CRU_GLB_SRST_SND_VALUE;
 120     uint32 reserved3[(0x110-0x108)/4];
 121     uint32 CRU_SOFTRST_CON[9];
 122     uint32 CRU_MISC_CON;
 123     uint32 reserved4[(0x140-0x138)/4];
 124     uint32 CRU_GLB_CNT_TH;
 125 } CRU_REG, *pCRU_REG;
 126
 127 #define pCRU_Reg ((pCRU_REG)CRU_BASE_ADDR)
 128
 129 typedef struct tagGPIO_LH
 130 {
 131     uint32 GPIOL;
 132     uint32 GPIOH;
 133 }GPIO_LH_T;
 134
 135 typedef struct tagGPIO_IOMUX
 136 {
 137     uint32 GPIOA_IOMUX;
 138     uint32 GPIOB_IOMUX;
 139     uint32 GPIOC_IOMUX;
 140     uint32 GPIOD_IOMUX;
 141 }GPIO_IOMUX_T;
 142
 143 //GRF_OS_REG1   ddr message
 144 #define DDR_RANK_COUNT   (11)
 145 #define DDR_COL_COUNT    (9)
 146 #define DDR_BANK_COUNT   (8)
 147 #define DDR_ROW_COUNT    (6)
 148 /********************************
 149 GRF ¼Ä´æÆ÷ÖÐGRF_OS_REG1 ´æddr rank£¬typeµÈÐÅÏ¢
 150 GRF_SOC_CON2¼Ä´æÆ÷ÖÐ¿ØÖÆc_sysreqÐÅºÅÏòpctl·¢ËÍ½øÈëlow power ÇëÇó
 151 GRF_DDRC_STAT ¿É²éÑ¯pctlÊÇ·ñ½ÓÊÜÇëÇó ½øÈëlow power
 152 ********************************/
 153 //REG FILE registers
 154 #if defined (CONFIG_ARCH_RK3026)
 155 typedef volatile struct tagREG_FILE
 156 {
 157     uint32 reserved0[(0xa8-0x0)/4];
 158     GPIO_IOMUX_T GRF_GPIO_IOMUX[4]; // 0x00a8
 159     uint32 reserved1[(0x100-0xe8)/4];
 160     uint32 GRF_GPIO_DS;             //0x110
 161     uint32 reserved2[(0x118-0x104)/4];
 162     GPIO_LH_T GRF_GPIO_PULL[4];     // 0x118
 163     uint32 reserved3[(0x140-0x138)/4];
 164     uint32 GRF_SOC_CON[3];          // 0x140
 165     uint32 GRF_SOC_STATUS0;
 166     uint32 GRF_LVDS_CON0;
 167     uint32 reserved4[(0x15c-0x154)/4];
 168     uint32 GRF_DMAC1_CON[3];        //0x15c
 169     uint32 reserved5[(0x17c-0x168)/4];
 170     uint32 GRF_UOC0_CON0;         //0x17c
 171     uint32 reserved6[(0x190-0x180)/4];
 172     uint32 GRF_UOC1_CON0;         //0x190
 173     uint32 GRF_UOC1_COM1;
 174     uint32 reserved7;
 175     uint32 GRF_DDRC_STAT;
 176     uint32 GRF_UOC_CON;
 177     uint32 reserved8;
 178     uint32 GRF_CPU_CON[6];
 179     uint32 GRF_CPU_STATUS[2];
 180     uint32 GRF_OS_REG[8];
 181     uint32 reserved9[(0x200-0x1e8)/4];
 182     uint32 GRF_DLL_CON[4];          //0X200
 183     uint32 GRF_DLL_STATUS;
 184     uint32 reserved10[(0x220-0x214)/4];
 185     uint32 GRF_DFI_WRNUM;           //0X220
 186     uint32 GRF_DFI_RDNUM;
 187     uint32 GRF_DFI_ACTNUM;
 188     uint32 GRF_DFI_TIMERVAL;
 189     uint32 GRF_NIF_FIFO[4];
 190     uint32 reserved11[(0x280-0x240)/4];
 191     uint32 GRF_USBPHY0_CON[8];
 192     uint32 GRF_USBPHY1_CON[8];
 193     uint32 reserved12[(0x300-0x2c0)/4];
 194     uint32 GRF_CHIP_TAG;
 195 } REG_FILE, *pREG_FILE;
 196
 197 #else
 198 typedef volatile struct tagREG_FILE
 199 {
 200     uint32 reserved1[(0xa8-0x0)/4];     //42
 201     uint32 GRF_GPIO_IOMUX[16];      //ÆäÖÐ 12£¬13reserved
 202     uint32 reserved2[(0x118-0xe8)/4];   //12
 203     GPIO_LH_T GRF_GPIO_PULL[4];
 204     uint32 reserved3[(0x140-0x138)/4];  // 2
 205     uint32 GRF_SOC_CON[3];
 206     uint32 GRF_SOC_STATUS0;
 207     uint32 GRF_LCDS_CON0;
 208     uint32 reserved4[(0x15c-0x154)/4];  // 2
 209     uint32 GRF_DMAC1_CON[3];
 210     uint32 reserved5[(0x16c-0x168)/4];  // 1
 211     uint32 GRF_UOC0_CON[5];
 212     uint32 GRF_UOC1_CON[6];
 213     uint32 reserved6[(0x19c-0x198)/4];  // 1
 214     uint32 GRF_DDRC_STAT;
 215     uint32 reserved7[(0x1c8-0x1a0)/4];  //10
 216     uint32 GRF_OS_REG[4];
 217 } REG_FILE, *pREG_FILE;
 218 #endif
 219
 220 #define pGRF_Reg ((pREG_FILE)REG_FILE_BASE_ADDR)
 221
 222 //SCTL
 223 #define INIT_STATE                     (0)
 224 #define CFG_STATE                      (1)
 225 #define GO_STATE                       (2)
 226 #define SLEEP_STATE                    (3)
 227 #define WAKEUP_STATE                   (4)
 228
 229 //STAT
 230 #define Init_mem                       (0)
 231 #define Config                         (1)
 232 #define Config_req                     (2)
 233 #define Access                         (3)
 234 #define Access_req                     (4)
 235 #define Low_power                      (5)
 236 #define Low_power_entry_req            (6)
 237 #define Low_power_exit_req             (7)
 238
 239 //MCFG
 240 #define mddr_lpddr2_clk_stop_idle(n)   ((n)<<24)
 241 #define pd_idle(n)                     ((n)<<8)
 242 #define mddr_en                        (2<<22)
 243 #define lpddr2_en                      (3<<22)
 244 #define ddr2_en                        (0<<5)
 245 #define ddr3_en                        (1<<5)
 246 #define lpddr2_s2                      (0<<6)
 247 #define lpddr2_s4                      (1<<6)
 248 #define mddr_lpddr2_bl_2               (0<<20)
 249 #define mddr_lpddr2_bl_4               (1<<20)
 250 #define mddr_lpddr2_bl_8               (2<<20)
 251 #define mddr_lpddr2_bl_16              (3<<20)
 252 #define ddr2_ddr3_bl_4                 (0)
 253 #define ddr2_ddr3_bl_8                 (1)
 254 #define tfaw_cfg(n)                    (((n)-4)<<18)
 255 #define pd_exit_slow                   (0<<17)
 256 #define pd_exit_fast                   (1<<17)
 257 #define pd_type(n)                     ((n)<<16)
 258 #define two_t_en(n)                    ((n)<<3)
 259 #define bl8int_en(n)                   ((n)<<2)
 260 #define cke_or_en(n)                   ((n)<<1)
 261
 262 //POWCTL
 263 #define power_up_start                 (1<<0)
 264
 265 //POWSTAT
 266 #define power_up_done                  (1<<0)
 267
 268 //DFISTSTAT0
 269 #define dfi_init_complete              (1<<0)
 270
 271 //CMDTSTAT
 272 #define cmd_tstat                      (1<<0)
 273
 274 //CMDTSTATEN
 275 #define cmd_tstat_en                   (1<<1)
 276
 277 //MCMD
 278 #define Deselect_cmd                   (0)
 279 #define PREA_cmd                       (1)
 280 #define REF_cmd                        (2)
 281 #define MRS_cmd                        (3)
 282 #define ZQCS_cmd                       (4)
 283 #define ZQCL_cmd                       (5)
 284 #define RSTL_cmd                       (6)
 285 #define MRR_cmd                        (8)
 286 #define DPDE_cmd                       (9)
 287
 288 #define lpddr2_op(n)                   ((n)<<12)
 289 #define lpddr2_ma(n)                   ((n)<<4)
 290
 291 #define bank_addr(n)                   ((n)<<17)
 292 #define cmd_addr(n)                    ((n)<<4)
 293
 294 #define start_cmd                      (1u<<31)
 295
 296 typedef union STAT_Tag
 297 {
 298     uint32 d32;
 299     struct
 300     {
 301         unsigned ctl_stat : 3;
 302         unsigned reserved3 : 1;
 303         unsigned lp_trig : 3;
 304         unsigned reserved7_31 : 25;
 305     }b;
 306 }STAT_T;
 307
 308 typedef union SCFG_Tag
 309 {
 310     uint32 d32;
 311     struct
 312     {
 313         unsigned hw_low_power_en : 1;
 314         unsigned reserved1_5 : 5;
 315         unsigned nfifo_nif1_dis : 1;
 316         unsigned reserved7 : 1;
 317         unsigned bbflags_timing : 4;
 318         unsigned reserved12_31 : 20;
 319     } b;
 320 }SCFG_T;
 321
 322 /* DDR Controller register struct */
 323 typedef volatile struct DDR_REG_Tag
 324 {
 325     //Operational State, Control, and Status Registers
 326     SCFG_T SCFG;                   //State Configuration Register
 327     volatile uint32 SCTL;                   //State Control Register
 328     STAT_T STAT;                   //State Status Register
 329     volatile uint32 INTRSTAT;               //Interrupt Status Register
 330     uint32 reserved0[(0x40-0x10)/4];
 331     //Initailization Control and Status Registers
 332     volatile uint32 MCMD;                   //Memory Command Register
 333     volatile uint32 POWCTL;                 //Power Up Control Registers
 334     volatile uint32 POWSTAT;                //Power Up Status Register
 335     volatile uint32 CMDTSTAT;               //Command Timing Status Register
 336     volatile uint32 CMDTSTATEN;             //Command Timing Status Enable Register
 337     uint32 reserved1[(0x60-0x54)/4];
 338     volatile uint32 MRRCFG0;                //MRR Configuration 0 Register
 339     volatile uint32 MRRSTAT0;               //MRR Status 0 Register
 340     volatile uint32 MRRSTAT1;               //MRR Status 1 Register
 341     uint32 reserved2[(0x7c-0x6c)/4];
 342     //Memory Control and Status Registers
 343     volatile uint32 MCFG1;                  //Memory Configuration 1 Register
 344     volatile uint32 MCFG;                   //Memory Configuration Register
 345     volatile uint32 PPCFG;                  //Partially Populated Memories Configuration Register
 346     volatile uint32 MSTAT;                  //Memory Status Register
 347     volatile uint32 LPDDR2ZQCFG;            //LPDDR2 ZQ Configuration Register
 348     uint32 reserved3;
 349     //DTU Control and Status Registers
 350     volatile uint32 DTUPDES;                //DTU Status Register
 351     volatile uint32 DTUNA;                  //DTU Number of Random Addresses Created Register
 352     volatile uint32 DTUNE;                  //DTU Number of Errors Register
 353     volatile uint32 DTUPRD0;                //DTU Parallel Read 0
 354     volatile uint32 DTUPRD1;                //DTU Parallel Read 1
 355     volatile uint32 DTUPRD2;                //DTU Parallel Read 2
 356     volatile uint32 DTUPRD3;                //DTU Parallel Read 3
 357     volatile uint32 DTUAWDT;                //DTU Address Width
 358     uint32 reserved4[(0xc0-0xb4)/4];
 359     //Memory Timing Registers
 360     volatile uint32 TOGCNT1U;               //Toggle Counter 1U Register
 361     volatile uint32 TINIT;                  //t_init Timing Register
 362     volatile uint32 TRSTH;                  //Reset High Time Register
 363     volatile uint32 TOGCNT100N;             //Toggle Counter 100N Register
 364     volatile uint32 TREFI;                  //t_refi Timing Register
 365     volatile uint32 TMRD;                   //t_mrd Timing Register
 366     volatile uint32 TRFC;                   //t_rfc Timing Register
 367     volatile uint32 TRP;                    //t_rp Timing Register
 368     volatile uint32 TRTW;                   //t_rtw Timing Register
 369     volatile uint32 TAL;                    //AL Latency Register
 370     volatile uint32 TCL;                    //CL Timing Register
 371     volatile uint32 TCWL;                   //CWL Register
 372     volatile uint32 TRAS;                   //t_ras Timing Register
 373     volatile uint32 TRC;                    //t_rc Timing Register
 374     volatile uint32 TRCD;                   //t_rcd Timing Register
 375     volatile uint32 TRRD;                   //t_rrd Timing Register
 376     volatile uint32 TRTP;                   //t_rtp Timing Register
 377     volatile uint32 TWR;                    //t_wr Timing Register
 378     volatile uint32 TWTR;                   //t_wtr Timing Register
 379     volatile uint32 TEXSR;                  //t_exsr Timing Register
 380     volatile uint32 TXP;                    //t_xp Timing Register
 381     volatile uint32 TXPDLL;                 //t_xpdll Timing Register
 382     volatile uint32 TZQCS;                  //t_zqcs Timing Register
 383     volatile uint32 TZQCSI;                 //t_zqcsi Timing Register
 384     volatile uint32 TDQS;                   //t_dqs Timing Register
 385     volatile uint32 TCKSRE;                 //t_cksre Timing Register
 386     volatile uint32 TCKSRX;                 //t_cksrx Timing Register
 387     volatile uint32 TCKE;                   //t_cke Timing Register
 388     volatile uint32 TMOD;                   //t_mod Timing Register
 389     volatile uint32 TRSTL;                  //Reset Low Timing Register
 390     volatile uint32 TZQCL;                  //t_zqcl Timing Register
 391     volatile uint32 TMRR;                   //t_mrr Timing Register
 392     volatile uint32 TCKESR;                 //t_ckesr Timing Register
 393     volatile uint32 TDPD;                   //t_dpd Timing Register
 394     uint32 reserved5[(0x180-0x148)/4];
 395     //ECC Configuration, Control, and Status Registers
 396     volatile uint32 ECCCFG;                   //ECC Configuration Register
 397     volatile uint32 ECCTST;                   //ECC Test Register
 398     volatile uint32 ECCCLR;                   //ECC Clear Register
 399     volatile uint32 ECCLOG;                   //ECC Log Register
 400     uint32 reserved6[(0x200-0x190)/4];
 401     //DTU Control and Status Registers
 402     volatile uint32 DTUWACTL;                 //DTU Write Address Control Register
 403     volatile uint32 DTURACTL;                 //DTU Read Address Control Register
 404     volatile uint32 DTUCFG;                   //DTU Configuration Control Register
 405     volatile uint32 DTUECTL;                  //DTU Execute Control Register
 406     volatile uint32 DTUWD0;                   //DTU Write Data 0
 407     volatile uint32 DTUWD1;                   //DTU Write Data 1
 408     volatile uint32 DTUWD2;                   //DTU Write Data 2
 409     volatile uint32 DTUWD3;                   //DTU Write Data 3
 410     volatile uint32 DTUWDM;                   //DTU Write Data Mask
 411     volatile uint32 DTURD0;                   //DTU Read Data 0
 412     volatile uint32 DTURD1;                   //DTU Read Data 1
 413     volatile uint32 DTURD2;                   //DTU Read Data 2
 414     volatile uint32 DTURD3;                   //DTU Read Data 3
 415     volatile uint32 DTULFSRWD;                //DTU LFSR Seed for Write Data Generation
 416     volatile uint32 DTULFSRRD;                //DTU LFSR Seed for Read Data Generation
 417     volatile uint32 DTUEAF;                   //DTU Error Address FIFO
 418     //DFI Control Registers
 419     volatile uint32 DFITCTRLDELAY;            //DFI tctrl_delay Register
 420     volatile uint32 DFIODTCFG;                //DFI ODT Configuration Register
 421     volatile uint32 DFIODTCFG1;               //DFI ODT Configuration 1 Register
 422     volatile uint32 DFIODTRANKMAP;            //DFI ODT Rank Mapping Register
 423     //DFI Write Data Registers
 424     volatile uint32 DFITPHYWRDATA;            //DFI tphy_wrdata Register
 425     volatile uint32 DFITPHYWRLAT;             //DFI tphy_wrlat Register
 426     uint32 reserved7[(0x260-0x258)/4];
 427     volatile uint32 DFITRDDATAEN;             //DFI trddata_en Register
 428     volatile uint32 DFITPHYRDLAT;             //DFI tphy_rddata Register
 429     uint32 reserved8[(0x270-0x268)/4];
 430     //DFI Update Registers
 431     volatile uint32 DFITPHYUPDTYPE0;          //DFI tphyupd_type0 Register
 432     volatile uint32 DFITPHYUPDTYPE1;          //DFI tphyupd_type1 Register
 433     volatile uint32 DFITPHYUPDTYPE2;          //DFI tphyupd_type2 Register
 434     volatile uint32 DFITPHYUPDTYPE3;          //DFI tphyupd_type3 Register
 435     volatile uint32 DFITCTRLUPDMIN;           //DFI tctrlupd_min Register
 436     volatile uint32 DFITCTRLUPDMAX;           //DFI tctrlupd_max Register
 437     volatile uint32 DFITCTRLUPDDLY;           //DFI tctrlupd_dly Register
 438     uint32 reserved9;
 439     volatile uint32 DFIUPDCFG;                //DFI Update Configuration Register
 440     volatile uint32 DFITREFMSKI;              //DFI Masked Refresh Interval Register
 441     volatile uint32 DFITCTRLUPDI;             //DFI tctrlupd_interval Register
 442     uint32 reserved10[(0x2ac-0x29c)/4];
 443     volatile uint32 DFITRCFG0;                //DFI Training Configuration 0 Register
 444     volatile uint32 DFITRSTAT0;               //DFI Training Status 0 Register
 445     volatile uint32 DFITRWRLVLEN;             //DFI Training dfi_wrlvl_en Register
 446     volatile uint32 DFITRRDLVLEN;             //DFI Training dfi_rdlvl_en Register
 447     volatile uint32 DFITRRDLVLGATEEN;         //DFI Training dfi_rdlvl_gate_en Register
 448     //DFI Status Registers
 449     volatile uint32 DFISTSTAT0;               //DFI Status Status 0 Register
 450     volatile uint32 DFISTCFG0;                //DFI Status Configuration 0 Register
 451     volatile uint32 DFISTCFG1;                //DFI Status configuration 1 Register
 452     uint32 reserved11;
 453     volatile uint32 DFITDRAMCLKEN;            //DFI tdram_clk_enalbe Register
 454     volatile uint32 DFITDRAMCLKDIS;           //DFI tdram_clk_disalbe Register
 455     volatile uint32 DFISTCFG2;                //DFI Status configuration 2 Register
 456     volatile uint32 DFISTPARCLR;              //DFI Status Parity Clear Register
 457     volatile uint32 DFISTPARLOG;              //DFI Status Parity Log Register
 458     uint32 reserved12[(0x2f0-0x2e4)/4];
 459     //DFI Low Power Registers
 460     volatile uint32 DFILPCFG0;                //DFI Low Power Configuration 0 Register
 461     uint32 reserved13[(0x300-0x2f4)/4];
 462     //DFI Training 2 Registers
 463     volatile uint32 DFITRWRLVLRESP0;          //DFI Training dif_wrlvl_resp Status 0 Register
 464     volatile uint32 DFITRWRLVLRESP1;          //DFI Training dif_wrlvl_resp Status 1 Register
 465     volatile uint32 DFITRWRLVLRESP2;          //DFI Training dif_wrlvl_resp Status 2 Register
 466     volatile uint32 DFITRRDLVLRESP0;          //DFI Training dif_rdlvl_resp Status 0 Register
 467     volatile uint32 DFITRRDLVLRESP1;          //DFI Training dif_rdlvl_resp Status 1 Register
 468     volatile uint32 DFITRRDLVLRESP2;          //DFI Training dif_rdlvl_resp Status 2 Register
 469     volatile uint32 DFITRWRLVLDELAY0;         //DFI Training dif_wrlvl_delay Configuration 0 Register
 470     volatile uint32 DFITRWRLVLDELAY1;         //DFI Training dif_wrlvl_delay Configuration 1 Register
 471     volatile uint32 DFITRWRLVLDELAY2;         //DFI Training dif_wrlvl_delay Configuration 2 Register
 472     volatile uint32 DFITRRDLVLDELAY0;         //DFI Training dif_rdlvl_delay Configuration 0 Register
 473     volatile uint32 DFITRRDLVLDELAY1;         //DFI Training dif_rdlvl_delay Configuration 1 Register
 474     volatile uint32 DFITRRDLVLDELAY2;         //DFI Training dif_rdlvl_delay Configuration 2 Register
 475     volatile uint32 DFITRRDLVLGATEDELAY0;     //DFI Training dif_rdlvl_gate_delay Configuration 0 Register
 476     volatile uint32 DFITRRDLVLGATEDELAY1;     //DFI Training dif_rdlvl_gate_delay Configuration 1 Register
 477     volatile uint32 DFITRRDLVLGATEDELAY2;     //DFI Training dif_rdlvl_gate_delay Configuration 2 Register
 478     volatile uint32 DFITRCMD;                 //DFI Training Command Register
 479     uint32 reserved14[(0x3f8-0x340)/4];
 480     //IP Status Registers
 481     volatile uint32 IPVR;                     //IP Version Register
 482     volatile uint32 IPTR;                     //IP Type Register
 483 }DDR_REG_T, *pDDR_REG_T;
 484
 485 #define pDDR_Reg ((pDDR_REG_T)SDRAMC_BASE_ADDR)
 486
 487 //PHY_REG2
 488 #define PHY_AUTO_CALIBRATION (1<<0)
 489 #define PHY_SW_CALIBRATION   (1<<1)
 490 #define PHY_MEM_TYPE         (6)
 491
 492 //PHY_REG22,25,26,27,28
 493 #if defined (CONFIG_ARCH_RK3026)            //RK3028A /rk3026
 494 #define PHY_RON_DISABLE     (0)
 495 #define PHY_RON_309ohm      (1)
 496 #define PHY_RON_155ohm      (2)
 497 #define PHY_RON_103ohm      (3)
 498 #define PHY_RON_77ohm       (4)
 499 #define PHY_RON_63ohm       (5)
 500 #define PHY_RON_52ohm       (6)
 501 #define PHY_RON_45ohm       (7)
 502 //#define PHY_RON_77ohm       (8)
 503 #define PHY_RON_62ohm       (9)
 504 //#define PHY_RON_52ohm       (10)
 505 #define PHY_RON_44ohm       (11)
 506 #define PHY_RON_39ohm       (12)
 507 #define PHY_RON_34ohm       (13)
 508 #define PHY_RON_31ohm       (14)
 509 #define PHY_RON_28ohm       (15)
 510
 511 #define PHY_RTT_DISABLE     (0)
 512 #define PHY_RTT_816ohm      (1)
 513 #define PHY_RTT_431ohm      (2)
 514 #define PHY_RTT_287ohm      (3)
 515 #define PHY_RTT_216ohm      (4)
 516 #define PHY_RTT_172ohm      (5)
 517 #define PHY_RTT_145ohm      (6)
 518 #define PHY_RTT_124ohm      (7)
 519 #define PHY_RTT_215ohm      (8)
 520 //#define PHY_RTT_172ohm      (9)
 521 #define PHY_RTT_144ohm      (10)
 522 #define PHY_RTT_123ohm      (11)
 523 #define PHY_RTT_108ohm      (12)
 524 #define PHY_RTT_96ohm       (13)
 525 #define PHY_RTT_86ohm       (14)
 526 #define PHY_RTT_78ohm       (15)
 527
 528 #else                   //RK292x
 529 #define PHY_RON_DISABLE     (0)
 530 #define PHY_RON_138O        (1)
 531 //#define PHY_RON_69O         (2)
 532 //#define PHY_RON_46O         (3)
 533 #define PHY_RON_69O         (4)
 534 #define PHY_RON_46O         (5)
 535 #define PHY_RON_34O         (6)
 536 #define PHY_RON_28O         (7)
 537
 538 #define PHY_RTT_DISABLE     (0)
 539 #define PHY_RTT_212O        (1)
 540 #define PHY_RTT_106O        (4)
 541 #define PHY_RTT_71O         (5)
 542 #define PHY_RTT_53O         (6)
 543 #define PHY_RTT_42O         (7)
 544 #endif
 545
 546 /* DDR PHY register struct */
 547 typedef volatile struct DDRPHY_REG_Tag
 548 {
 549     volatile uint32 PHY_REG1;               //PHY soft reset Register
 550     volatile uint32 PHY_REG3;               //Burst type select Register
 551     volatile uint32 PHY_REG2;               //PHY DQS squelch calibration Register
 552     uint32 reserved1[(0x38-0x0a)/4];
 553     volatile uint32 PHY_REG4a;              //CL,AL set register
 554     volatile uint32 PHY_REG4b;              //dqs gata delay select bypass mode register
 555     uint32 reserved2[(0x54-0x40)/4];
 556     volatile uint32 PHY_REG16;              //
 557     uint32 reserved3[(0x5c-0x58)/4];
 558     volatile uint32 PHY_REG18;              //0x5c
 559     volatile uint32 PHY_REG19;
 560     uint32 reserved4[(0x68-0x64)/4];
 561     volatile uint32 PHY_REG21;              //0x68
 562     uint32 reserved5[(0x70-0x6c)/4];
 563     volatile uint32 PHY_REG22;              //0x70
 564     uint32 reserved6[(0x80-0x74)/4];
 565     volatile uint32 PHY_REG25;              //0x80
 566     volatile uint32 PHY_REG26;
 567     volatile uint32 PHY_REG27;
 568     volatile uint32 PHY_REG28;
 569     uint32 reserved7[(0xd4-0x90)/4];
 570     volatile uint32 PHY_REG6;               //0xd4
 571     volatile uint32 PHY_REG7;
 572     uint32 reserved8[(0xe0-0xdc)/4];
 573     volatile uint32 PHY_REG8;               //0xe0
 574     volatile uint32 PHY_REG0e4;             //use for DQS ODT off
 575     uint32 reserved9[(0x114-0xe8)/4];
 576     volatile uint32 PHY_REG9;               //0x114
 577     volatile uint32 PHY_REG10;
 578     uint32 reserved10[(0x120-0x11c)/4];
 579     volatile uint32 PHY_REG11;              //0x120
 580     volatile uint32 PHY_REG124;             //use for DQS ODT off
 581     uint32 reserved11[(0x1c0-0x128)/4];
 582     volatile uint32 PHY_REG29;              //0x1c0
 583     uint32 reserved12[(0x264-0x1c4)/4];
 584         volatile uint32 PHY_REG264;             //use for phy soft reset
 585         uint32 reserved13[(0x2b0-0x268)/4];
 586     volatile uint32 PHY_REG2a;              //0x2b0
 587     uint32 reserved14[(0x2c4-0x2b4)/4];
 588 //    volatile uint32 PHY_TX_DeSkew[24];        //0x2c4-0x320
 589     volatile uint32 PHY_REG30;
 590     volatile uint32 PHY_REG31;
 591     volatile uint32 PHY_REG32;
 592     volatile uint32 PHY_REG33;
 593     volatile uint32 PHY_REG34;
 594     volatile uint32 PHY_REG35;
 595     volatile uint32 PHY_REG36;
 596     volatile uint32 PHY_REG37;
 597     volatile uint32 PHY_REG38;
 598     volatile uint32 PHY_REG39;
 599     volatile uint32 PHY_REG40;
 600     volatile uint32 PHY_REG41;
 601     volatile uint32 PHY_REG42;
 602     volatile uint32 PHY_REG43;
 603     volatile uint32 PHY_REG44;
 604     volatile uint32 PHY_REG45;
 605     volatile uint32 PHY_REG46;
 606     volatile uint32 PHY_REG47;
 607     volatile uint32 PHY_REG48;
 608     volatile uint32 PHY_REG49;
 609     volatile uint32 PHY_REG50;
 610     volatile uint32 PHY_REG51;
 611     volatile uint32 PHY_REG52;
 612     volatile uint32 PHY_REG53;
 613     uint32 reserved15[(0x328-0x324)/4];
 614 //    volatile uint32 PHY_RX_DeSkew[11];      //0x328-0x350
 615     volatile uint32 PHY_REG54;
 616     volatile uint32 PHY_REG55;
 617     volatile uint32 PHY_REG56;
 618     volatile uint32 PHY_REG57;
 619     volatile uint32 PHY_REG58;
 620     volatile uint32 PHY_REG59;
 621     volatile uint32 PHY_REG5a;
 622     volatile uint32 PHY_REG5b;
 623     volatile uint32 PHY_REG5c;
 624     volatile uint32 PHY_REG5d;
 625     volatile uint32 PHY_REG5e;
 626     uint32 reserved16[(0x3c4-0x354)/4];
 627     volatile uint32 PHY_REG5f;              //0x3c4
 628     uint32 reserved17[(0x3e0-0x3c8)/4];
 629     volatile uint32 PHY_REG60;
 630     volatile uint32 PHY_REG61;
 631     volatile uint32 PHY_REG62;
 632 }DDRPHY_REG_T, *pDDRPHY_REG_T;
 633
 634 #define pPHY_Reg ((pDDRPHY_REG_T)DDR_PHY_BASE)
 635
 636 typedef enum DRAM_TYPE_Tag
 637 {
 638     LPDDR = 0,
 639     DDR,
 640     DDR2,
 641     DDR3,
 642     LPDDR2_S2,
 643     LPDDR2_S4,
 644
 645     DRAM_MAX
 646 }DRAM_TYPE;
 647
 648
 649 typedef struct PCTRL_TIMING_Tag
 650 {
 651     uint32 ddrFreq;
 652     //Memory Timing Registers
 653     uint32 togcnt1u;               //Toggle Counter 1U Register
 654     uint32 tinit;                  //t_init Timing Register
 655     uint32 trsth;                  //Reset High Time Register
 656     uint32 togcnt100n;             //Toggle Counter 100N Register
 657     uint32 trefi;                  //t_refi Timing Register
 658     uint32 tmrd;                   //t_mrd Timing Register
 659     uint32 trfc;                   //t_rfc Timing Register
 660     uint32 trp;                    //t_rp Timing Register
 661     uint32 trtw;                   //t_rtw Timing Register
 662     uint32 tal;                    //AL Latency Register
 663     uint32 tcl;                    //CL Timing Register
 664     uint32 tcwl;                   //CWL Register
 665     uint32 tras;                   //t_ras Timing Register
 666     uint32 trc;                    //t_rc Timing Register
 667     uint32 trcd;                   //t_rcd Timing Register
 668     uint32 trrd;                   //t_rrd Timing Register
 669     uint32 trtp;                   //t_rtp Timing Register
 670     uint32 twr;                    //t_wr Timing Register
 671     uint32 twtr;                   //t_wtr Timing Register
 672     uint32 texsr;                  //t_exsr Timing Register
 673     uint32 txp;                    //t_xp Timing Register
 674     uint32 txpdll;                 //t_xpdll Timing Register
 675     uint32 tzqcs;                  //t_zqcs Timing Register
 676     uint32 tzqcsi;                 //t_zqcsi Timing Register
 677     uint32 tdqs;                   //t_dqs Timing Register
 678     uint32 tcksre;                 //t_cksre Timing Register
 679     uint32 tcksrx;                 //t_cksrx Timing Register
 680     uint32 tcke;                   //t_cke Timing Register
 681     uint32 tmod;                   //t_mod Timing Register
 682     uint32 trstl;                  //Reset Low Timing Register
 683     uint32 tzqcl;                  //t_zqcl Timing Register
 684     uint32 tmrr;                   //t_mrr Timing Register
 685     uint32 tckesr;                 //t_ckesr Timing Register
 686     uint32 tdpd;                   //t_dpd Timing Register
 687 }PCTL_TIMING_T;
 688
 689
 690 typedef union NOC_TIMING_Tag
 691 {
 692     uint32 d32;
 693     struct
 694     {
 695         unsigned ActToAct : 6;
 696         unsigned RdToMiss : 6;
 697         unsigned WrToMiss : 6;
 698         unsigned BurstLen : 3;
 699         unsigned RdToWr : 5;
 700         unsigned WrToRd : 5;
 701         unsigned BwRatio : 1;
 702     } b;
 703 }NOC_TIMING_T;
 704
 705 typedef struct PCTL_REG_Tag
 706 {
 707     uint32 SCFG;
 708     uint32 CMDTSTATEN;
 709     uint32 MCFG1;
 710     uint32 MCFG;
 711     PCTL_TIMING_T pctl_timing;
 712     //DFI Control Registers
 713     uint32 DFITCTRLDELAY;
 714     uint32 DFIODTCFG;
 715     uint32 DFIODTCFG1;
 716     uint32 DFIODTRANKMAP;
 717     //DFI Write Data Registers
 718     uint32 DFITPHYWRDATA;
 719     uint32 DFITPHYWRLAT;
 720     //DFI Read Data Registers
 721     uint32 DFITRDDATAEN;
 722     uint32 DFITPHYRDLAT;
 723     //DFI Update Registers
 724     uint32 DFITPHYUPDTYPE0;
 725     uint32 DFITPHYUPDTYPE1;
 726     uint32 DFITPHYUPDTYPE2;
 727     uint32 DFITPHYUPDTYPE3;
 728     uint32 DFITCTRLUPDMIN;
 729     uint32 DFITCTRLUPDMAX;
 730     uint32 DFITCTRLUPDDLY;
 731     uint32 DFIUPDCFG;
 732     uint32 DFITREFMSKI;
 733     uint32 DFITCTRLUPDI;
 734     //DFI Status Registers
 735     uint32 DFISTCFG0;
 736     uint32 DFISTCFG1;
 737     uint32 DFITDRAMCLKEN;
 738     uint32 DFITDRAMCLKDIS;
 739     uint32 DFISTCFG2;
 740     //DFI Low Power Register
 741     uint32 DFILPCFG0;
 742 }PCTL_REG_T;
 743
 744 typedef struct BACKUP_REG_Tag
 745 {
 746     PCTL_REG_T pctl;
 747     uint32 DdrConf;
 748     NOC_TIMING_T noc_timing;
 749     uint32 DdrMode;
 750     uint32 ReadLatency;
 751     uint32 ddrMR[4];
 752 }BACKUP_REG_T;
 753
 754 __sramdata BACKUP_REG_T ddr_reg;
 755
 756
 757 uint32_t __sramdata ddr3_cl_cwl[22][4]={
 758 /*   0~330           330~400         400~533        speed
 759 * tCK  >3             2.5~3          1.875~2.5     1.875~1.5
 760 *    cl<<16, cwl    cl<<16, cwl     cl<<16, cwl              */
 761     {((5<<16)|5),   ((5<<16)|5),    0          ,   0}, //DDR3_800D
 762     {((5<<16)|5),   ((6<<16)|5),    0          ,   0}, //DDR3_800E
 763
 764     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   0}, //DDR3_1066E
 765     {((5<<16)|5),   ((6<<16)|5),    ((7<<16)|6),   0}, //DDR3_1066F
 766     {((5<<16)|5),   ((6<<16)|5),    ((8<<16)|6),   0}, //DDR3_1066G
 767
 768     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   ((7<<16)|7)}, //DDR3_1333F
 769     {((5<<16)|5),   ((5<<16)|5),    ((7<<16)|6),   ((8<<16)|7)}, //DDR3_1333G
 770     {((5<<16)|5),   ((6<<16)|5),    ((7<<16)|6),   ((9<<16)|7)}, //DDR3_1333H
 771     {((5<<16)|5),   ((6<<16)|5),    ((8<<16)|6),   ((10<<16)|7)}, //DDR3_1333J
 772
 773     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   ((7<<16)|7)}, //DDR3_1600G
 774     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   ((8<<16)|7)}, //DDR3_1600H
 775     {((5<<16)|5),   ((5<<16)|5),    ((7<<16)|6),   ((9<<16)|7)}, //DDR3_1600J
 776     {((5<<16)|5),   ((6<<16)|5),    ((7<<16)|6),   ((10<<16)|7)}, //DDR3_1600K
 777
 778     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   ((8<<16)|7)}, //DDR3_1866J
 779     {((5<<16)|5),   ((5<<16)|5),    ((7<<16)|6),   ((8<<16)|7)}, //DDR3_1866K
 780     {((6<<16)|5),   ((6<<16)|5),    ((7<<16)|6),   ((9<<16)|7)}, //DDR3_1866L
 781     {((6<<16)|5),   ((6<<16)|5),    ((8<<16)|6),   ((10<<16)|7)}, //DDR3_1866M
 782
 783     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   ((7<<16)|7)}, //DDR3_2133K
 784     {((5<<16)|5),   ((5<<16)|5),    ((6<<16)|6),   ((8<<16)|7)}, //DDR3_2133L
 785     {((5<<16)|5),   ((5<<16)|5),    ((7<<16)|6),   ((9<<16)|7)}, //DDR3_2133M
 786     {((6<<16)|5),   ((6<<16)|5),    ((7<<16)|6),   ((9<<16)|7)},  //DDR3_2133N
 787
 788     {((6<<16)|5),   ((6<<16)|5),    ((8<<16)|6),   ((10<<16)|7)} //DDR3_DEFAULT
 789
 790 };
 791 uint32_t __sramdata ddr3_tRC_tFAW[22]={
 792 /**    tRC    tFAW   */
 793     ((50<<16)|50), //DDR3_800D
 794     ((53<<16)|50), //DDR3_800E
 795
 796     ((49<<16)|50), //DDR3_1066E
 797     ((51<<16)|50), //DDR3_1066F
 798     ((53<<16)|50), //DDR3_1066G
 799
 800     ((47<<16)|45), //DDR3_1333F
 801     ((48<<16)|45), //DDR3_1333G
 802     ((50<<16)|45), //DDR3_1333H
 803     ((51<<16)|45), //DDR3_1333J
 804
 805     ((45<<16)|40), //DDR3_1600G
 806     ((47<<16)|40), //DDR3_1600H
 807     ((48<<16)|40), //DDR3_1600J
 808     ((49<<16)|40), //DDR3_1600K
 809
 810     ((45<<16)|35), //DDR3_1866J
 811     ((46<<16)|35), //DDR3_1866K
 812     ((47<<16)|35), //DDR3_1866L
 813     ((48<<16)|35), //DDR3_1866M
 814
 815     ((44<<16)|35), //DDR3_2133K
 816     ((45<<16)|35), //DDR3_2133L
 817     ((46<<16)|35), //DDR3_2133M
 818     ((47<<16)|35), //DDR3_2133N
 819
 820     ((53<<16)|50)  //DDR3_DEFAULT
 821 };
 822
 823 __sramdata uint32_t mem_type;    //0:DDR3  1:DDR2  ;ÓëInno PHY µÄPHY_REG2 ÀïÉèÖÃµÄÖµÏàÒ»ÖÂ
 824 static __sramdata uint32_t ddr_speed_bin;    // used for ddr3 only
 825 static __sramdata uint32_t ddr_capability_per_die;  // one chip cs capability
 826 static __sramdata uint32_t ddr_freq;
 827 static __sramdata uint32_t ddr_sr_idle;
 828 static __sramdata uint32_t ddr_dll_status;  // ¼ÇÂ¼ddr dllµÄ×´Ì¬£¬ÔÚselfrefresh exitÊ±Ñ¡ÔñÊÇ·ñ½øÐÐdll reset
 829
 830 /****************************************************************************
 831 Internal sram us delay function
 832 Cpu highest frequency is 1.6 GHz
 833 1 cycle = 1/1.6 ns
 834 1 us = 1000 ns = 1000 * 1.6 cycles = 1600 cycles
 835 *****************************************************************************/
 836 static __sramdata uint32_t loops_per_us;
 837
 838 #define LPJ_100MHZ  999456UL
 839
 840 /*----------------------------------------------------------------------
 841 Name    : void __sramlocalfunc ddr_delayus(uint32_t us)
 842 Desc    : ddr ÑÓÊ±º¯Êý
 843 Params  : uint32_t us  --ÑÓÊ±Ê±¼ä
 844 Return  : void
 845 Notes   : loops_per_us ÎªÈ«¾Ö±äÁ¿ ÐèÒª¸ù¾Ýarm freq¶ø¶¨
 846 ----------------------------------------------------------------------*/
 847
 848 /*static*/ void __sramlocalfunc ddr_delayus(uint32_t us)
 849 {
 850     uint32_t count;
 851
 852     count = loops_per_us*us;
 853     while(count--)  // 3 cycles
 854         barrier();
 855 }
 856
 857 /*----------------------------------------------------------------------
 858 Name    : __sramfunc void ddr_copy(uint32 *pDest, uint32 *pSrc, uint32 words)
 859 Desc    : ddr ¿½±´¼Ä´æÆ÷º¯Êý
 860 Params  : pDest ->Ä¿±ê¼Ä´æÆ÷Ê×µØÖ·
 861           pSrc  ->Ô´±ê¼Ä´æÆ÷Ê×µØÖ·
 862           words ->¿½±´³¤¶È
 863 Return  : void
 864 Notes   :
 865 ----------------------------------------------------------------------*/
 866
 867 __sramfunc void ddr_copy(uint32 *pDest, uint32 *pSrc, uint32 words)
 868 {
 869     uint32 i;
 870
 871     for(i=0; i<words; i++)
 872     {
 873         pDest[i] = pSrc[i];
 874     }
 875 }
 876
 877 /*----------------------------------------------------------------------
 878 Name    : uint32 ddr_get_row(void)
 879 Desc    : »ñÈ¡ddr row ÐÅÏ¢
 880 Params  : void
 881 Return  : row Êý
 882 Notes   :
 883 ----------------------------------------------------------------------*/
 884 uint32 ddr_get_row(void)
 885 {
 886     return (13+((pGRF_Reg->GRF_OS_REG[1] >> DDR_ROW_COUNT) & 0x3));
 887 }
 888
 889 /*----------------------------------------------------------------------
 890 Name    : uint32 ddr_get_bank(void)
 891 Desc    : »ñÈ¡ddr bank ÐÅÏ¢
 892 Params  : void
 893 Return  : bank Êý
 894 Notes   :
 895 ----------------------------------------------------------------------*/
 896 uint32 ddr_get_bank(void)
 897 {
 898      return (((pGRF_Reg->GRF_OS_REG[1] >> DDR_BANK_COUNT) & 0x1)? 2:3);
 899 }
 900
 901 /*----------------------------------------------------------------------
 902 Name    : uint32 ddr_get_col(void)
 903 Desc    : »ñÈ¡ddr col ÐÅÏ¢
 904 Params  : void
 905 Return  : col Êý
 906 Notes   :
 907 ----------------------------------------------------------------------*/
 908 uint32 ddr_get_col(void)
 909 {
 910     return (9 + ((pGRF_Reg->GRF_OS_REG[1]>>DDR_COL_COUNT)&0x3));
 911 }
 912
 913 /*----------------------------------------------------------------------
 914 Name    : __sramfunc void ddr_move_to_Lowpower_state(void)
 915 Desc    : pctl ½øÈë lowpower state
 916 Params  : void
 917 Return  : void
 918 Notes   :
 919 ----------------------------------------------------------------------*/
 920 __sramfunc void ddr_move_to_Lowpower_state(void)
 921 {
 922     volatile uint32 value;
 923
 924     while(1)
 925     {
 926         value = pDDR_Reg->STAT.b.ctl_stat;
 927         if(value == Low_power)
 928         {
 929             break;
 930         }
 931         switch(value)
 932         {
 933             case Init_mem:
 934                 pDDR_Reg->SCTL = CFG_STATE;
 935                 dsb();
 936                 while((pDDR_Reg->STAT.b.ctl_stat) != Config);
 937             case Config:
 938                 pDDR_Reg->SCTL = GO_STATE;
 939                 dsb();
 940                 while((pDDR_Reg->STAT.b.ctl_stat) != Access);
 941             case Access:
 942                 pDDR_Reg->SCTL = SLEEP_STATE;
 943                 dsb();
 944                 while((pDDR_Reg->STAT.b.ctl_stat) != Low_power);
 945                 break;
 946             default:  //Transitional state
 947                 break;
 948         }
 949     }
 950 }
 951
 952 /*----------------------------------------------------------------------
 953 Name    : __sramfunc void ddr_move_to_Access_state(void)
 954 Desc    : pctl ½øÈë Access state
 955 Params  : void
 956 Return  : void
 957 Notes   :
 958 ----------------------------------------------------------------------*/
 959 __sramfunc void ddr_move_to_Access_state(void)
 960 {
 961     volatile uint32 value;
 962
 963     //set auto self-refresh idle
 964     pDDR_Reg->MCFG1=(pDDR_Reg->MCFG1&0xffffff00)|ddr_sr_idle | (1<<31);
 965
 966     while(1)
 967     {
 968         value = pDDR_Reg->STAT.b.ctl_stat;
 969         if((value == Access)
 970            || ((pDDR_Reg->STAT.b.lp_trig == 1) && ((pDDR_Reg->STAT.b.ctl_stat) == Low_power)))
 971         {
 972             break;
 973         }
 974         switch(value)
 975         {
 976             case Low_power:
 977                 pDDR_Reg->SCTL = WAKEUP_STATE;
 978                 dsb();
 979                 while((pDDR_Reg->STAT.b.ctl_stat) != Access);
 980                 break;
 981             case Init_mem:
 982                 pDDR_Reg->SCTL = CFG_STATE;
 983                 dsb();
 984                 while((pDDR_Reg->STAT.b.ctl_stat) != Config);
 985             case Config:
 986                 pDDR_Reg->SCTL = GO_STATE;
 987                 dsb();
 988                 while(!(((pDDR_Reg->STAT.b.ctl_stat) == Access)
 989                       || ((pDDR_Reg->STAT.b.lp_trig == 1) && ((pDDR_Reg->STAT.b.ctl_stat) == Low_power))));
 990                 break;
 991             default:  //Transitional state
 992                 break;
 993         }
 994     }
 995     pGRF_Reg->GRF_SOC_CON[2] = (1<<16 | 0);//de_hw_wakeup :enable auto sr if sr_idle != 0
 996 }
 997
 998 /*----------------------------------------------------------------------
 999 Name    : __sramfunc void ddr_move_to_Config_state(void)
1000 Desc    : pctl ½øÈë config state
1001 Params  : void
1002 Return  : void
1003 Notes   :
1004 ----------------------------------------------------------------------*/
1005 __sramfunc void ddr_move_to_Config_state(void)
1006 {
1007     volatile uint32 value;
1008     pGRF_Reg->GRF_SOC_CON[2] = (1<<16 | 1); //hw_wakeup :disable auto sr
1009     while(1)
1010     {
1011         value = pDDR_Reg->STAT.b.ctl_stat;
1012         if(value == Config)
1013         {
1014             break;
1015         }
1016         switch(value)
1017         {
1018             case Low_power:
1019                 pDDR_Reg->SCTL = WAKEUP_STATE;
1020                 dsb();
1021             case Access:
1022             case Init_mem:
1023                 pDDR_Reg->SCTL = CFG_STATE;
1024                 dsb();
1025                 break;
1026             default:  //Transitional state
1027                 break;
1028         }
1029     }
1030 }
1031
1032 /*----------------------------------------------------------------------
1033 Name    : void __sramlocalfunc ddr_send_command(uint32 rank, uint32 cmd, uint32 arg)
1034 Desc    : Í¨¹ýÐ´ pctl MCMD¼Ä´æÆ÷Ïòddr·¢ËÍÃüÁî
1035 Params  : rank ->ddr rank Êý
1036           cmd  ->·¢ËÍÃüÁîÀàÐÍ
1037           arg  ->·¢ËÍµÄÊý¾Ý
1038 Return  : void
1039 Notes   : arg°üÀ¨bank_addrºÍcmd_addr
1040 ----------------------------------------------------------------------*/
1041 void __sramlocalfunc ddr_send_command(uint32 rank, uint32 cmd, uint32 arg)
1042 {
1043     pDDR_Reg->MCMD = (start_cmd | (rank<<20) | arg | cmd);
1044     dsb();
1045     while(pDDR_Reg->MCMD & start_cmd);
1046 }
1047
1048 __sramdata uint32 copy_data[8]={0xffffffff,0x00000000,0x55555555,0xAAAAAAAA,
1049                                 0xEEEEEEEE,0x11111111,0x22222222,0xDDDDDDDD};/**/
1050
1051 /*----------------------------------------------------------------------
1052 Name    : uint32_t __sramlocalfunc ddr_data_training(void)
1053 Desc    : ¶Ôddr×ödata training
1054 Params  : void
1055 Return  : void
1056 Notes   : Ã»ÓÐ×ödata trainingÐ£Ñé
1057 ----------------------------------------------------------------------*/
1058 uint32_t __sramlocalfunc ddr_data_training(void)
1059 {
1060     uint32 value, cs;
1061     value = pDDR_Reg->TREFI;
1062     pDDR_Reg->TREFI = 0;
1063     cs = (pGRF_Reg->GRF_OS_REG[1] >> DDR_RANK_COUNT) & 0x1;
1064     cs = cs + (1 << cs);                               //case 0:1rank cs=1; case 1:2rank cs =3;
1065     // trigger DTT
1066     pPHY_Reg->PHY_REG2 = ((pPHY_Reg->PHY_REG2 & (~0x1)) | PHY_AUTO_CALIBRATION);
1067     // wait echo byte DTDONE
1068     ddr_delayus(6);
1069     // stop DTT
1070     while((pPHY_Reg->PHY_REG62 & 0x3)!=0x3);
1071     pPHY_Reg->PHY_REG2 = (pPHY_Reg->PHY_REG2 & (~0x1));
1072     // send some auto refresh to complement the lost while DTT
1073     ddr_send_command(cs, REF_cmd, 0);
1074     ddr_send_command(cs, REF_cmd, 0);
1075     ddr_send_command(cs, REF_cmd, 0);
1076     ddr_send_command(cs, REF_cmd, 0);
1077
1078     // resume auto refresh
1079     pDDR_Reg->TREFI = value;
1080
1081     return(0);
1082 }
1083
1084 /*----------------------------------------------------------------------
1085 Name    : void __sramlocalfunc ddr_set_dll_bypass(uint32 freq)
1086 Desc    : ÉèÖÃPHY dll ¹¤×÷Ä£Ê½
1087 Params  : freq -> ddr¹¤×÷ÆµÂÊ
1088 Return  : void
1089 Notes   :
1090 ----------------------------------------------------------------------*/
1091 void __sramlocalfunc ddr_set_dll_bypass(uint32 freq)
1092 {
1093     if(freq <= PHY_DLL_DISABLE_FREQ)
1094     {
1095         pPHY_Reg->PHY_REG2a = 0x1F;         //set cmd,left right dll bypass
1096         pPHY_Reg->PHY_REG19 = 0x08;         //cmd slave dll
1097         pPHY_Reg->PHY_REG6 = 0x18;          //left TX DQ DLL
1098         pPHY_Reg->PHY_REG7 = 0x00;          //left TX DQS DLL
1099         pPHY_Reg->PHY_REG9 = 0x18;          //right TX DQ DLL
1100         pPHY_Reg->PHY_REG10 = 0x00;         //right TX DQS DLL
1101
1102     }
1103     else
1104     {
1105         pPHY_Reg->PHY_REG2a = 0x03;         //set cmd,left right dll bypass
1106         pPHY_Reg->PHY_REG19 = 0x08;         //cmd slave dll
1107         pPHY_Reg->PHY_REG6 = 0x0c;          //left TX DQ DLL
1108         pPHY_Reg->PHY_REG7 = 0x00;          //left TX DQS DLL
1109         pPHY_Reg->PHY_REG9 = 0x0c;          //right TX DQ DLL
1110         pPHY_Reg->PHY_REG10 = 0x00;         //right TX DQS DLL
1111     }
1112     dsb();
1113     //ÆäËûÓëdllÏà¹ØµÄ¼Ä´æÆ÷ÓÐ:REG8(RX DQS),REG11(RX DQS),REG18(CMD),REG21(CK) ±£³ÖÄ¬ÈÏÖµ
1114 }
1115
1116
1117 static __sramdata uint32_t clkFbDiv;
1118 static __sramdata uint32_t clkPostDiv1;
1119 static __sramdata uint32_t clkPostDiv2;
1120
1121 /*****************************************
1122 REFDIV   FBDIV     POSTDIV1/POSTDIV2      FOUTPOSTDIV           freq Step        FOUTPOSRDIV            finally use
1123 ==================================================================================================================
1124 1        17 - 66   4                      100MHz - 400MHz          6MHz          200MHz  <= 300MHz             <= 150MHz
1125 1        17 - 66   3                      133MHz - 533MHz          8MHz
1126 1        17 - 66   2                      200MHz - 800MHz          12MHz         300MHz  <= 600MHz      150MHz <= 300MHz
1127 1        17 - 66   1                      400MHz - 1600MHz         24MHz         600MHz  <= 1200MHz     300MHz <= 600MHz
1128 ******************************************/
1129 //for minimum jitter operation, the highest VCO and FREF frequencies should be used.
1130 /*----------------------------------------------------------------------
1131 Name    : uint32_t __sramlocalfunc ddr_set_pll(uint32_t nMHz, uint32_t set)
1132 Desc    : ÉèÖÃddr pll
1133 Params  : nMHZ -> ddr¹¤×÷ÆµÂÊ
1134           set  ->0»ñÈ¡ÉèÖÃµÄÆµÂÊÐÅÏ¢
1135                  1ÉèÖÃddr pll
1136 Return  : ÉèÖÃµÄÆµÂÊÖµ
1137 Notes   : ÔÚ±äÆµÊ±ÐèÒªÏÈset=0µ÷ÓÃÒ»´Îddr_set_pll£¬ÔÙset=1 µ÷ÓÃddr_set_pll
1138 ----------------------------------------------------------------------*/
1139 uint32_t __sramlocalfunc ddr_set_pll(uint32_t nMHz, uint32_t set)
1140 {
1141     uint32_t ret = 0;
1142     int delay = 1000;
1143     uint32_t pll_id=1;  //DPLL
1144
1145     if(nMHz == 24)
1146     {
1147         ret = 24;
1148         goto out;
1149     }
1150 #if defined (CONFIG_ARCH_RK3026)   //RK3028A  RK3026
1151     if(!set)
1152     {
1153         if(nMHz <= 150) //Êµ¼ÊÊä³öÆµÂÊ<300
1154         {
1155             clkPostDiv1 = 6;
1156         }
1157         else if(nMHz <=200)
1158         {
1159             clkPostDiv1 = 4;
1160         }
1161         else if(nMHz <= 300)
1162         {
1163             clkPostDiv1 = 3;
1164         }
1165         else if(nMHz <=450)
1166         {
1167             clkPostDiv1 = 2;
1168         }
1169         else
1170         {
1171             clkPostDiv1 = 1;
1172         }
1173         clkPostDiv2 = 1;
1174         clkFbDiv = (nMHz * 2 * DDR_PLL_REFDIV * clkPostDiv1 * clkPostDiv2)/24;//×îºóËÍÈëddrµÄÊÇÔÙ¾¹ý2·ÖÆµ
1175         ret = (24 * clkFbDiv)/(2 * DDR_PLL_REFDIV * clkPostDiv1 * clkPostDiv2);
1176     }
1177 #else   //RK2928  2926
1178     if(!set)
1179     {
1180         if(nMHz <= 150)
1181         {
1182             clkPostDiv1 = 4;
1183         }
1184         else if(nMHz <= 300)
1185         {
1186             clkPostDiv1 = 2;
1187         }
1188         else
1189         {
1190             clkPostDiv1 = 1;
1191         }
1192         clkPostDiv2 = 1;
1193         clkFbDiv = (nMHz * 2 * DDR_PLL_REFDIV * clkPostDiv1 * clkPostDiv2)/24;//×îºóËÍÈëddrµÄÊÇÔÙ¾¹ý2·ÖÆµ
1194         ret = (24 * clkFbDiv)/(2 * DDR_PLL_REFDIV * clkPostDiv1 * clkPostDiv2);
1195     }
1196 #endif
1197     else
1198     {
1199         pCRU_Reg->CRU_MODE_CON = (0x1<<((pll_id*4) +  16)) | (0x0<<(pll_id*4));            //PLL slow-mode
1200
1201         pCRU_Reg->CRU_PLL_CON[pll_id][0] = FBDIV(clkFbDiv) | POSTDIV1(clkPostDiv1);
1202         pCRU_Reg->CRU_PLL_CON[pll_id][1] = REFDIV(DDR_PLL_REFDIV) | POSTDIV2(clkPostDiv2) | (0x10001<<12);//interger mode
1203
1204         ddr_delayus(1);
1205
1206         while (delay > 0)
1207         {
1208             ddr_delayus(1);
1209                 if (pCRU_Reg->CRU_PLL_CON[pll_id][1] & (PLL_LOCK_STATUS))        // wait for pll locked
1210                         break;
1211                 delay--;
1212         }
1213
1214         pCRU_Reg->CRU_CLKSEL_CON[26] = ((0x3<<16) | 0x0);           //clk_ddr_src:clk_ddrphy = 1:1
1215         pCRU_Reg->CRU_MODE_CON = (0x1<<((pll_id*4) +  16))  | (0x1<<(pll_id*4));            //PLL normal
1216     }
1217 out:
1218     return ret;
1219 }
1220
1221 /*----------------------------------------------------------------------
1222 Name    : uint32_t ddr_get_parameter(uint32_t nMHz)
1223 Desc    : »ñÈ¡ÅäÖÃ²ÎÊý
1224 Params  : nMHZ -> ddr¹¤×÷ÆµÂÊ
1225 Return  : 0 ³É¹¦
1226           -1 Ê§°Ü
1227           -4 ÆµÂÊÖµ³¬¹ý¿ÅÁ£×î´óÆµÂÊ
1228 Notes   :
1229 ----------------------------------------------------------------------*/
1230 uint32_t ddr_get_parameter(uint32_t nMHz)
1231 {
1232     uint32_t tmp;
1233     uint32_t ret = 0;
1234     uint32_t al;
1235     uint32_t bl;
1236     uint32_t cl;
1237     uint32_t cwl;
1238     PCTL_TIMING_T *p_pctl_timing=&(ddr_reg.pctl.pctl_timing);
1239     NOC_TIMING_T  *p_noc_timing=&(ddr_reg.noc_timing);
1240
1241     p_pctl_timing->togcnt1u = nMHz;
1242     p_pctl_timing->togcnt100n = nMHz/10;
1243     p_pctl_timing->tinit = 200;
1244     p_pctl_timing->trsth = 500;
1245
1246     if(mem_type == DDR3)
1247     {
1248         if(ddr_speed_bin > DDR3_DEFAULT)
1249         {
1250             ret = -1;
1251             goto out;
1252         }
1253
1254         #define DDR3_tREFI_7_8_us    (78)
1255         #define DDR3_tMRD            (4)
1256         #define DDR3_tRFC_512Mb      (90)
1257         #define DDR3_tRFC_1Gb        (110)
1258         #define DDR3_tRFC_2Gb        (160)
1259         #define DDR3_tRFC_4Gb        (300)
1260         #define DDR3_tRFC_8Gb        (350)
1261         #define DDR3_tRTW            (2)   //register min valid value
1262         #define DDR3_tRAS            (37)
1263         #define DDR3_tRRD            (10)
1264         #define DDR3_tRTP            (7)
1265         #define DDR3_tWR             (15)
1266         #define DDR3_tWTR            (7)
1267         #define DDR3_tXP             (7)
1268         #define DDR3_tXPDLL          (24)
1269         #define DDR3_tZQCS           (80)
1270         #define DDR3_tZQCSI          (10000)
1271         #define DDR3_tDQS            (1)
1272         #define DDR3_tCKSRE          (10)
1273         #define DDR3_tCKE_400MHz     (7)
1274         #define DDR3_tCKE_533MHz     (6)
1275         #define DDR3_tMOD            (15)
1276         #define DDR3_tRSTL           (100)
1277         #define DDR3_tZQCL           (320)
1278         #define DDR3_tDLLK           (512)
1279
1280         al = 0;
1281         bl = 8;
1282         if(nMHz <= 330)
1283         {
1284             tmp = 0;
1285         }
1286         else if(nMHz<=400)
1287         {
1288             tmp = 1;
1289         }
1290         else if(nMHz<=533)
1291         {
1292             tmp = 2;
1293         }
1294         else //666MHz
1295         {
1296             tmp = 3;
1297         }
1298         if(nMHz < DDR3_DDR2_DLL_DISABLE_FREQ)       //when dll bypss cl = cwl = 6;
1299         {
1300             cl = 6;
1301             cwl = 6;
1302         }
1303         else
1304         {
1305             cl = ddr3_cl_cwl[ddr_speed_bin][tmp] >> 16;
1306             cwl = ddr3_cl_cwl[ddr_speed_bin][tmp] & 0x0ff;
1307         }
1308         if(cl == 0)
1309         {
1310             ret = -4; //³¬¹ý¿ÅÁ£µÄ×î´óÆµÂÊ
1311         }
1312         if(nMHz <= DDR3_DDR2_ODT_DISABLE_FREQ)
1313         {
1314             ddr_reg.ddrMR[1] = DDR3_DS_40 | DDR3_Rtt_Nom_DIS;
1315         }
1316         else
1317         {
1318             ddr_reg.ddrMR[1] = DDR3_DS_40 | DDR3_Rtt_Nom_120;
1319         }
1320         ddr_reg.ddrMR[2] = DDR3_MR2_CWL(cwl) /* | DDR3_Rtt_WR_60 */;
1321         ddr_reg.ddrMR[3] = 0;
1322         /**************************************************
1323          * PCTL Timing
1324          **************************************************/
1325         /*
1326          * tREFI, average periodic refresh interval, 7.8us
1327          */
1328         p_pctl_timing->trefi = DDR3_tREFI_7_8_us;
1329         /*
1330          * tMRD, 4 tCK
1331          */
1332         p_pctl_timing->tmrd = DDR3_tMRD & 0x7;
1333         /*
1334          * tRFC, 90ns(512Mb),110ns(1Gb),160ns(2Gb),300ns(4Gb),350ns(8Gb)
1335          */
1336         if(ddr_capability_per_die <= 0x4000000)         // 512Mb 90ns
1337         {
1338             tmp = DDR3_tRFC_512Mb;
1339         }
1340         else if(ddr_capability_per_die <= 0x8000000)    // 1Gb 110ns
1341         {
1342             tmp = DDR3_tRFC_1Gb;
1343         }
1344         else if(ddr_capability_per_die <= 0x10000000)   // 2Gb 160ns
1345         {
1346             tmp = DDR3_tRFC_2Gb;
1347         }
1348         else if(ddr_capability_per_die <= 0x20000000)   // 4Gb 300ns
1349         {
1350             tmp = DDR3_tRFC_4Gb;
1351         }
1352         else    // 8Gb  350ns
1353         {
1354             tmp = DDR3_tRFC_8Gb;
1355         }
1356         p_pctl_timing->trfc = (tmp*nMHz+999)/1000;
1357         /*
1358          * tXSR, =tDLLK=512 tCK
1359          */
1360         p_pctl_timing->texsr = DDR3_tDLLK;
1361         /*
1362          * tRP=CL
1363          */
1364         p_pctl_timing->trp = cl;
1365         /*
1366          * WrToMiss=WL*tCK + tWR + tRP + tRCD
1367          */
1368         p_noc_timing->b.WrToMiss = ((cwl+((DDR3_tWR*nMHz+999)/1000)+cl+cl)&0x3F);
1369         /*
1370          * tRC=tRAS+tRP
1371          */
1372         p_pctl_timing->trc = ((((ddr3_tRC_tFAW[ddr_speed_bin]>>16)*nMHz+999)/1000)&0x3F);
1373         p_noc_timing->b.ActToAct = ((((ddr3_tRC_tFAW[ddr_speed_bin]>>16)*nMHz+999)/1000)&0x3F);
1374
1375         p_pctl_timing->trtw = (cl+2-cwl);//DDR3_tRTW;
1376         p_noc_timing->b.RdToWr = ((cl+2-cwl)&0x1F);
1377         p_pctl_timing->tal = al;
1378         p_pctl_timing->tcl = cl;
1379         p_pctl_timing->tcwl = cwl;
1380         /*
1381          * tRAS, 37.5ns(400MHz)     37.5ns(533MHz)
1382          */
1383         p_pctl_timing->tras = (((DDR3_tRAS*nMHz+(nMHz>>1)+999)/1000)&0x3F);
1384         /*
1385          * tRCD=CL
1386          */
1387         p_pctl_timing->trcd = cl;
1388         /*
1389          * tRRD = max(4nCK, 7.5ns), DDR3-1066(1K), DDR3-1333(2K), DDR3-1600(2K)
1390          *        max(4nCK, 10ns), DDR3-800(1K,2K), DDR3-1066(2K)
1391          *        max(4nCK, 6ns), DDR3-1333(1K), DDR3-1600(1K)
1392          *
1393          */
1394         tmp = ((DDR3_tRRD*nMHz+999)/1000);
1395         if(tmp < 4)
1396         {
1397             tmp = 4;
1398         }
1399         p_pctl_timing->trrd = (tmp&0xF);
1400         /*
1401          * tRTP, max(4 tCK,7.5ns)
1402          */
1403         tmp = ((DDR3_tRTP*nMHz+(nMHz>>1)+999)/1000);
1404         if(tmp < 4)
1405         {
1406             tmp = 4;
1407         }
1408         p_pctl_timing->trtp = tmp&0xF;
1409         /*
1410          * RdToMiss=tRTP+tRP + tRCD - (BL/2 * tCK)
1411          */
1412         p_noc_timing->b.RdToMiss = ((tmp+cl+cl-(bl>>1))&0x3F);
1413         /*
1414          * tWR, 15ns
1415          */
1416         tmp = ((DDR3_tWR*nMHz+999)/1000);
1417         p_pctl_timing->twr = tmp&0x1F;
1418         if(tmp<9)
1419             tmp = tmp - 4;
1420         else
1421             tmp = tmp>>1;
1422         ddr_reg.ddrMR[0] = DDR3_BL8 | DDR3_CL(cl) | DDR3_WR(tmp);
1423
1424         /*
1425          * tWTR, max(4 tCK,7.5ns)
1426          */
1427         tmp = ((DDR3_tWTR*nMHz+(nMHz>>1)+999)/1000);
1428         if(tmp < 4)
1429         {
1430             tmp = 4;
1431         }
1432         p_pctl_timing->twtr = tmp&0xF;
1433         p_noc_timing->b.WrToRd = ((tmp+cwl)&0x1F);
1434         /*
1435          * tXP, max(3 tCK, 7.5ns)(<933MHz)
1436          */
1437         tmp = ((DDR3_tXP*nMHz+(nMHz>>1)+999)/1000);
1438         if(tmp < 3)
1439         {
1440             tmp = 3;
1441         }
1442         p_pctl_timing->txp = tmp&0x7;
1443         /*
1444          * tXPDLL, max(10 tCK,24ns)
1445          */
1446         tmp = ((DDR3_tXPDLL*nMHz+999)/1000);
1447         if(tmp < 10)
1448         {
1449             tmp = 10;
1450         }
1451         p_pctl_timing->txpdll = tmp & 0x3F;
1452         /*
1453          * tZQCS, max(64 tCK, 80ns)
1454          */
1455         tmp = ((DDR3_tZQCS*nMHz+999)/1000);
1456         if(tmp < 64)
1457         {
1458             tmp = 64;
1459         }
1460         p_pctl_timing->tzqcs = tmp&0x7F;
1461         /*
1462          * tZQCSI,
1463          */
1464         p_pctl_timing->tzqcsi = DDR3_tZQCSI;
1465         /*
1466          * tDQS,
1467          */
1468         p_pctl_timing->tdqs = DDR3_tDQS;
1469         /*
1470          * tCKSRE, max(5 tCK, 10ns)
1471          */
1472         tmp = ((DDR3_tCKSRE*nMHz+999)/1000);
1473         if(tmp < 5)
1474         {
1475             tmp = 5;
1476         }
1477         p_pctl_timing->tcksre = tmp & 0x1F;
1478         /*
1479          * tCKSRX, max(5 tCK, 10ns)
1480          */
1481         p_pctl_timing->tcksrx = tmp & 0x1F;
1482         /*
1483          * tCKE, max(3 tCK,7.5ns)(400MHz) max(3 tCK,5.625ns)(533MHz)
1484          */
1485         if(nMHz>=533)
1486         {
1487             tmp = ((DDR3_tCKE_533MHz*nMHz+999)/1000);
1488         }
1489         else
1490         {
1491             tmp = ((DDR3_tCKE_400MHz*nMHz+(nMHz>>1)+999)/1000);
1492         }
1493         if(tmp < 3)
1494         {
1495             tmp = 3;
1496         }
1497         p_pctl_timing->tcke = tmp & 0x7;
1498         /*
1499          * tCKESR, =tCKE + 1tCK
1500          */
1501         p_pctl_timing->tckesr = (tmp+1)&0xF;
1502         /*
1503          * tMOD, max(12 tCK,15ns)
1504          */
1505         tmp = ((DDR3_tMOD*nMHz+999)/1000);
1506         if(tmp < 12)
1507         {
1508             tmp = 12;
1509         }
1510         p_pctl_timing->tmod = tmp&0x1F;
1511         /*
1512          * tRSTL, 100ns
1513          */
1514         p_pctl_timing->trstl = ((DDR3_tRSTL*nMHz+999)/1000)&0x7F;
1515         /*
1516          * tZQCL, max(256 tCK, 320ns)
1517          */
1518         tmp = ((DDR3_tZQCL*nMHz+999)/1000);
1519         if(tmp < 256)
1520         {
1521             tmp = 256;
1522         }
1523         p_pctl_timing->tzqcl = tmp&0x3FF;
1524         /*
1525          * tMRR, 0 tCK
1526          */
1527         p_pctl_timing->tmrr = 0;
1528         /*
1529          * tDPD, 0
1530          */
1531         p_pctl_timing->tdpd = 0;
1532
1533         /**************************************************
1534          * NOC Timing
1535          **************************************************/
1536         p_noc_timing->b.BurstLen = ((bl>>1)&0x7);
1537     }
1538     else if(mem_type == DDR2)
1539     {
1540         #define DDR2_tREFI_7_8_us     (78)
1541         #define DDR2_tMRD             (2)
1542         #define DDR2_tRFC_256Mb       (75)
1543         #define DDR2_tRFC_512Mb       (105)
1544         #define DDR2_tRFC_1Gb         (128)
1545         #define DDR2_tRFC_2Gb         (195)
1546         #define DDR2_tRFC_4Gb         (328)
1547         #define DDR2_tRAS             (45)
1548         #define DDR2_tRTW             (2)  //register min valid value
1549         #define DDR2_tRRD             (10)
1550         #define DDR2_tRTP             (7)
1551         #define DDR2_tWR              (15)
1552         #define DDR2_tWTR_LITTLE_200MHz   (10)
1553         #define DDR2_tWTR_GREAT_200MHz    (7)
1554         #define DDR2_tDQS             (1)
1555         #define DDR2_tCKSRE           (1)
1556         #define DDR2_tCKSRX           (1)
1557         #define DDR2_tCKE             (3)
1558         #define DDR2_tCKESR           DDR2_tCKE
1559         #define DDR2_tMOD             (12)
1560         #define DDR2_tFAW_333MHz      (50)
1561         #define DDR2_tFAW_400MHz      (45)
1562         #define DDR2_tDLLK            (200)
1563
1564         al = 0;
1565         bl = 4;
1566         if(nMHz <= 266)
1567         {
1568             cl =  4;
1569         }
1570         else if((nMHz > 266) && (nMHz <= 333))
1571         {
1572             cl =  5;
1573         }
1574         else if((nMHz > 333) && (nMHz <= 400))
1575         {
1576             cl =  6;
1577         }
1578         else // > 400MHz
1579         {
1580             cl =  7;
1581         }
1582         cwl = cl -1;
1583         if(nMHz <= DDR3_DDR2_ODT_DISABLE_FREQ)
1584         {
1585             ddr_reg.ddrMR[1] = DDR2_STR_REDUCE | DDR2_Rtt_Nom_DIS;
1586         }
1587         else
1588         {
1589             ddr_reg.ddrMR[1] = DDR2_STR_REDUCE | DDR2_Rtt_Nom_75;
1590         }
1591         ddr_reg.ddrMR[2] = 0;
1592         ddr_reg.ddrMR[3] = 0;
1593         /**************************************************
1594          * PCTL Timing
1595          **************************************************/
1596         /*
1597          * tREFI, average periodic refresh interval, 7.8us
1598          */
1599         p_pctl_timing->trefi = DDR2_tREFI_7_8_us;
1600         /*
1601          * tMRD, 2 tCK
1602          */
1603         p_pctl_timing->tmrd = DDR2_tMRD & 0x7;
1604         /*
1605          * tRFC, 75ns(256Mb) 105ns(512Mb) 127.5ns(1Gb) 195ns(2Gb) 327.5ns(4Gb)
1606          */
1607         if(ddr_capability_per_die <= 0x2000000)  // 256Mb
1608         {
1609             tmp = DDR2_tRFC_256Mb;
1610         }
1611         else if(ddr_capability_per_die <= 0x4000000) // 512Mb
1612         {
1613             tmp = DDR2_tRFC_512Mb;
1614         }
1615         else if(ddr_capability_per_die <= 0x8000000)  // 1Gb
1616         {
1617             tmp = DDR2_tRFC_1Gb;
1618         }
1619         else if(ddr_capability_per_die <= 0x10000000)  // 2Gb
1620         {
1621             tmp = DDR2_tRFC_2Gb;
1622         }
1623         else  // 4Gb
1624         {
1625             tmp = DDR2_tRFC_4Gb;
1626         }
1627         p_pctl_timing->trfc = (tmp*nMHz+999)/1000;
1628         /*
1629          * tXSR, max(tRFC+10,200 tCK)
1630          */
1631         tmp = (((tmp+10)*nMHz+999)/1000);
1632         if(tmp<200)
1633         {
1634             tmp = 200;
1635         }
1636         p_pctl_timing->texsr = tmp&0x3FF;
1637         /*
1638          * tRP=CL  DDR2 8bank need to add 1 additional cycles for PREA
1639          */
1640         if(ddr_get_bank() == 8)
1641         {
1642             p_pctl_timing->trp = (1<<16) | cl;
1643         }
1644         else
1645         {
1646             p_pctl_timing->trp = cl;
1647         }
1648         /*
1649          * WrToMiss=WL*tCK + tWR + tRP + tRCD
1650          */
1651         p_noc_timing->b.WrToMiss = ((cwl+((DDR2_tWR*nMHz+999)/1000)+cl+cl)&0x3F);
1652         /*
1653          * tRAS, 45ns
1654          */
1655         tmp=((DDR2_tRAS*nMHz+999)/1000);
1656         p_pctl_timing->tras = (tmp&0x3F);
1657         /*
1658          * tRC=tRAS+tRP
1659          */
1660         p_pctl_timing->trc = ((tmp+cl)&0x3F);
1661         p_noc_timing->b.ActToAct = ((tmp+cl)&0x3F);
1662
1663         p_pctl_timing->trtw = (cl+2-cwl);//DDR2_tRTW;
1664         p_noc_timing->b.RdToWr = ((cl+2-cwl)&0x1F);
1665         p_pctl_timing->tal = al;
1666         p_pctl_timing->tcl = cl;
1667         p_pctl_timing->tcwl = cwl;
1668         /*
1669          * tRCD=CL
1670          */
1671         p_pctl_timing->trcd = cl;
1672         /*
1673          * tRRD = 10ns(2KB page)
1674          *
1675          */
1676         p_pctl_timing->trrd = (((DDR2_tRRD*nMHz+999)/1000)&0xF);
1677         /*
1678          * tRTP, 7.5ns
1679          */
1680         tmp = ((DDR2_tRTP*nMHz+(nMHz>>1)+999)/1000);
1681         p_pctl_timing->trtp = tmp&0xF;
1682         /*
1683          * RdToMiss=tRTP+tRP + tRCD - (BL/2 * tCK)
1684          */
1685         p_noc_timing->b.RdToMiss = ((tmp+cl+cl-(bl>>1))&0x3F);
1686         /*
1687          * tWR, 15ns
1688          */
1689         tmp = ((DDR2_tWR*nMHz+999)/1000);
1690         p_pctl_timing->twr = tmp&0x1F;
1691         /*
1692          * tWTR, 10ns(200MHz) 7.5ns(>200MHz)
1693          */
1694         if(nMHz<=200)
1695         {
1696             tmp = ((DDR2_tWTR_LITTLE_200MHz*nMHz+999)/1000);
1697         }
1698         else
1699         {
1700             tmp = ((DDR2_tWTR_GREAT_200MHz*nMHz+(nMHz>>1)+999)/1000);
1701         }
1702         p_pctl_timing->twtr = tmp&0xF;
1703         p_noc_timing->b.WrToRd = ((tmp+cwl)&0x1F);
1704         /*
1705          * tXP, 6-AL(200MHz)         6-AL(266MHz)         7-AL(333MHz)         8-AL(400MHz)        10-AL(533MHz)
1706          */
1707         if(nMHz<=266)
1708         {
1709             tmp = 6-al;
1710         }
1711         else if(nMHz<=333)
1712         {
1713             tmp = 7-al;
1714         }
1715         else if(nMHz<=400)
1716         {
1717             tmp = 8-al;
1718         }
1719         else
1720         {
1721             tmp = 10-al;
1722         }
1723         p_pctl_timing->txp = tmp&0x7;
1724         /*
1725          * tXPDLL, =tXP
1726          */
1727         p_pctl_timing->txpdll = tmp & 0x3F;
1728         /*
1729          * tZQCS, 0
1730          */
1731         p_pctl_timing->tzqcs = 0;
1732         /*
1733          * tZQCSI,
1734          */
1735         p_pctl_timing->tzqcsi = 0;
1736         /*
1737          * tDQS,
1738          */
1739         p_pctl_timing->tdqs = DDR2_tDQS;
1740         /*
1741          * tCKSRE, 1 tCK
1742          */
1743         p_pctl_timing->tcksre = DDR2_tCKSRE & 0x1F;
1744         /*
1745          * tCKSRX, no such timing
1746          */
1747         p_pctl_timing->tcksrx = DDR2_tCKSRX & 0x1F;
1748         /*
1749          * tCKE, 3 tCK
1750          */
1751         p_pctl_timing->tcke = DDR2_tCKE & 0x7;
1752         /*
1753          * tCKESR, =tCKE
1754          */
1755         p_pctl_timing->tckesr = DDR2_tCKESR&0xF;
1756         /*
1757          * tMOD, 12ns
1758          */
1759         p_pctl_timing->tmod = ((DDR2_tMOD*nMHz+999)/1000)&0x1F;
1760         /*
1761          * tRSTL, 0
1762          */
1763         p_pctl_timing->trstl = 0;
1764         /*
1765          * tZQCL, 0
1766          */
1767         p_pctl_timing->tzqcl = 0;
1768         /*
1769          * tMRR, 0 tCK
1770          */
1771         p_pctl_timing->tmrr = 0;
1772         /*
1773          * tDPD, 0
1774          */
1775         p_pctl_timing->tdpd = 0;
1776
1777         /**************************************************
1778          * NOC Timing
1779          **************************************************/
1780         p_noc_timing->b.BurstLen = ((bl>>1)&0x7);
1781     }
1782
1783 out:
1784     return ret;
1785 }
1786
1787 /*----------------------------------------------------------------------
1788 Name    : uint32_t __sramlocalfunc ddr_update_timing(void)
1789 Desc    : ¸üÐÂpctl phy Ïà¹Øtiming¼Ä´æÆ÷
1790 Params  : void
1791 Return  : 0 ³É¹¦
1792 Notes   :
1793 ----------------------------------------------------------------------*/
1794 uint32_t __sramlocalfunc ddr_update_timing(void)
1795 {
1796     PCTL_TIMING_T *p_pctl_timing = &(ddr_reg.pctl.pctl_timing);
1797     NOC_TIMING_T  *p_noc_timing = &(ddr_reg.noc_timing);
1798
1799     ddr_copy((uint32_t *)&(pDDR_Reg->TOGCNT1U), (uint32_t*)&(p_pctl_timing->togcnt1u), 34);
1800     pPHY_Reg->PHY_REG3 = (0x12 << 1) | (ddr2_ddr3_bl_8);   //0x12Îª±£ÁôÎ»µÄÄ¬ÈÏÖµ£¬ÒÔÄ¬ÈÏÖµ»ØÐ´
1801     pPHY_Reg->PHY_REG4a = ((p_pctl_timing->tcl << 4) | (p_pctl_timing->tal));
1802     *(volatile uint32_t *)SysSrv_DdrTiming = p_noc_timing->d32;
1803     // Update PCTL BL
1804     if(mem_type == DDR3)
1805     {
1806         pDDR_Reg->MCFG = (pDDR_Reg->MCFG & (~(0x1|(0x3<<18)|(0x1<<17)|(0x1<<16)))) | ddr2_ddr3_bl_8 | tfaw_cfg(5)|pd_exit_slow|pd_type(1);
1807         pDDR_Reg->DFITRDDATAEN   = (pDDR_Reg->TAL + pDDR_Reg->TCL)-3;  //trdata_en = rl-3
1808         pDDR_Reg->DFITPHYWRLAT   = pDDR_Reg->TCWL-1;
1809     }
1810     else if(mem_type == DDR2)
1811     {
1812         pDDR_Reg->MCFG = (pDDR_Reg->MCFG & (~(0x1|(0x3<<18)|(0x1<<17)|(0x1<<16)))) | ddr2_ddr3_bl_8 | tfaw_cfg(5)|pd_exit_fast|pd_type(1);
1813     }
1814     return 0;
1815 }
1816
1817 /*----------------------------------------------------------------------
1818 Name    : uint32_t __sramlocalfunc ddr_update_mr(void)
1819 Desc    : ¸üÐÂ¿ÅÁ£MR¼Ä´æÆ÷
1820 Params  : void
1821 Return  : void
1822 Notes   :
1823 ----------------------------------------------------------------------*/
1824 uint32_t __sramlocalfunc ddr_update_mr(void)
1825 {
1826     uint32_t cs;
1827
1828     cs = (pGRF_Reg->GRF_OS_REG[1] >> DDR_RANK_COUNT) & 0x1;
1829     cs = cs + (1 << cs);                               //case 0:1rank cs=1; case 1:2rank cs =3;
1830     if(ddr_freq > DDR3_DDR2_DLL_DISABLE_FREQ)
1831     {
1832         if(ddr_dll_status == DDR3_DLL_DISABLE)  // off -> on
1833         {
1834             ddr_send_command(cs, MRS_cmd, bank_addr(0x1) | cmd_addr((ddr_reg.ddrMR[1])));  //DLL enable
1835             ddr_send_command(cs, MRS_cmd, bank_addr(0x0) | cmd_addr(((ddr_reg.ddrMR[0]))| DDR3_DLL_RESET));  //DLL reset
1836             ddr_delayus(2);  //at least 200 DDR cycle
1837             ddr_send_command(cs, MRS_cmd, bank_addr(0x0) | cmd_addr((ddr_reg.ddrMR[0])));
1838             ddr_dll_status = DDR3_DLL_ENABLE;
1839         }
1840         else // on -> on
1841         {
1842             ddr_send_command(cs, MRS_cmd, bank_addr(0x1) | cmd_addr((ddr_reg.ddrMR[1])));
1843             ddr_send_command(cs, MRS_cmd, bank_addr(0x0) | cmd_addr((ddr_reg.ddrMR[0])));
1844         }
1845     }
1846     else
1847     {
1848         ddr_send_command(cs, MRS_cmd, bank_addr(0x1) | cmd_addr(((ddr_reg.ddrMR[1])) | DDR3_DLL_DISABLE));  //DLL disable
1849         ddr_send_command(cs, MRS_cmd, bank_addr(0x0) | cmd_addr((ddr_reg.ddrMR[0])));
1850         ddr_dll_status = DDR3_DLL_DISABLE;
1851     }
1852     ddr_send_command(cs, MRS_cmd, bank_addr(0x2) | cmd_addr((ddr_reg.ddrMR[2])));
1853
1854     return 0;
1855 }
1856
1857 /*----------------------------------------------------------------------
1858 Name    : void __sramlocalfunc ddr_update_odt(void)
1859 Desc    : update PHY odt & PHY driver impedance
1860 Params  : void
1861 Return  : void
1862 Notes   :
1863 ----------------------------------------------------------------------*/
1864 void __sramlocalfunc ddr_update_odt(void)
1865 {
1866     uint32_t tmp;
1867
1868     //adjust DRV and ODT
1869     if(ddr_freq <= PHY_ODT_DISABLE_FREQ)
1870     {
1871         pPHY_Reg->PHY_REG27 = PHY_RTT_DISABLE;  //dynamic RTT disable, Left 8bit ODT
1872         pPHY_Reg->PHY_REG28 = PHY_RTT_DISABLE;  //Right 8bit ODT
1873         pPHY_Reg->PHY_REG0e4 = (0x0E & 0xc)|0x1;//off DQS ODT  bit[1:0]=2'b01
1874         pPHY_Reg->PHY_REG124 = (0x0E & 0xc)|0x1;//off DQS ODT  bit[1:0]=2'b01
1875     }
1876 #if defined (CONFIG_ARCH_RK3026)    //RK3028A   RK3026
1877     else
1878     {
1879         pPHY_Reg->PHY_REG27 = ((PHY_RTT_215ohm<<4) | PHY_RTT_215ohm);
1880         pPHY_Reg->PHY_REG28 = ((PHY_RTT_215ohm<<4) | PHY_RTT_215ohm);
1881         pPHY_Reg->PHY_REG0e4 = 0x0E;           //on DQS ODT default:0x0E
1882         pPHY_Reg->PHY_REG124 = 0x0E;           //on DQS ODT default:0x0E
1883     }
1884     tmp = ((PHY_RON_45ohm<<4) | PHY_RON_45ohm);
1885 #else                   //RK2928  R2926
1886     else
1887     {
1888         pPHY_Reg->PHY_REG27 = ((PHY_RTT_212O<<3) | PHY_RTT_212O);
1889         pPHY_Reg->PHY_REG28 = ((PHY_RTT_212O<<3) | PHY_RTT_212O);
1890         pPHY_Reg->PHY_REG0e4 = 0x0E;           //on DQS ODT default:0x0E
1891         pPHY_Reg->PHY_REG124 = 0x0E;           //on DQS ODT default:0x0E
1892     }
1893     tmp = ((PHY_RON_46O<<3) | PHY_RON_46O);
1894 #endif
1895
1896     pPHY_Reg->PHY_REG16 = tmp;  //CMD driver strength
1897     pPHY_Reg->PHY_REG22 = tmp;  //CK driver strength
1898     pPHY_Reg->PHY_REG25 = tmp;  //Left 8bit DQ driver strength
1899     pPHY_Reg->PHY_REG26 = tmp;  //Right 8bit DQ driver strength
1900     dsb();
1901 }
1902
1903 /*----------------------------------------------------------------------
1904 Name    : __sramfunc void ddr_adjust_config(uint32_t dram_type)
1905 Desc    :
1906 Params  : dram_type ->¿ÅÁ£ÀàÐÍ
1907 Return  : void
1908 Notes   :
1909 ----------------------------------------------------------------------*/
1910 __sramfunc void ddr_adjust_config(uint32_t dram_type)
1911 {
1912 //    uint32 value;
1913     unsigned long save_sp;
1914     uint32 i;
1915     volatile uint32 n;
1916     volatile unsigned int * temp=(volatile unsigned int *)SRAM_CODE_OFFSET;
1917
1918     //get data training address before idle port
1919 //    value = ddr_get_datatraing_addr();    //Inno PHY ²»ÐèÒªtraining address
1920
1921     /** 1. Make sure there is no host access */
1922     flush_cache_all();
1923     outer_flush_all();
1924     flush_tlb_all();
1925     DDR_SAVE_SP(save_sp);
1926
1927     for(i=0;i<2;i++)        //8KB SRAM
1928     {
1929         n=temp[1024*i];
1930         barrier();
1931     }
1932     n= pDDR_Reg->SCFG.d32;
1933     n= pPHY_Reg->PHY_REG1;
1934     n= pCRU_Reg->CRU_PLL_CON[0][0];
1935     n= *(volatile uint32_t *)SysSrv_DdrConf;
1936     dsb();
1937
1938     //enter config state
1939     ddr_move_to_Config_state();
1940 //    pDDR_Reg->DFIODTCFG = ((1<<3) | (1<<11));  //loaderÖÐÂ©ÁË³õÊ¼»¯
1941     //set auto power down idle
1942     pDDR_Reg->MCFG=(pDDR_Reg->MCFG&0xffff00ff)|(PD_IDLE<<8);
1943
1944     //enable the hardware low-power interface
1945     pDDR_Reg->SCFG.b.hw_low_power_en = 1;
1946
1947     ddr_update_odt();
1948
1949     //enter access state
1950     ddr_move_to_Access_state();
1951
1952     DDR_RESTORE_SP(save_sp);
1953 }
1954
1955 /*----------------------------------------------------------------------
1956 Name    : void __sramlocalfunc ddr_selfrefresh_enter(uint32 nMHz)
1957 Desc    : ½øÈë×ÔË¢ÐÂ
1958 Params  : nMHz ->ddrÆµÂÊ
1959 Return  : void
1960 Notes   :
1961 ----------------------------------------------------------------------*/
1962 void __sramlocalfunc ddr_selfrefresh_enter(uint32 nMHz)
1963 {
1964     ddr_move_to_Config_state();
1965     ddr_move_to_Lowpower_state();
1966         pPHY_Reg->PHY_REG264 &= ~(1<<1);
1967     pPHY_Reg->PHY_REG1 = (pPHY_Reg->PHY_REG1 & (~(0x3<<2)));     //phy soft reset
1968     dsb();
1969     pCRU_Reg->CRU_CLKGATE_CON[0] = ((0x1<<2)<<16) | (1<<2);  //disable DDR PHY clock
1970     ddr_delayus(1);
1971 }
1972
1973 uint32 dtt_buffer[8];
1974
1975 /*----------------------------------------------------------------------
1976 Name    : void ddr_dtt_check(void)
1977 Desc    : data training check
1978 Params  : void
1979 Return  : void
1980 Notes   :
1981 ----------------------------------------------------------------------*/
1982 void ddr_dtt_check(void)
1983 {
1984     uint32 i;
1985     for(i=0;i<8;i++)
1986     {
1987         dtt_buffer[i] = copy_data[i];
1988     }
1989     dsb();
1990     flush_cache_all();
1991     outer_flush_all();
1992     for(i=0;i<8;i++)
1993     {
1994         if(dtt_buffer[i] != copy_data[i])
1995         {
1996             sram_printascii("DTT failed!\n");
1997             break;
1998         }
1999         dtt_buffer[i] = 0;
2000     }
2001
2002 }
2003
2004 /*----------------------------------------------------------------------
2005 Name    : void __sramlocalfunc ddr_selfrefresh_exit(void)
2006 Desc    : ÍË³ö×ÔË¢ÐÂ
2007 Params  : void
2008 Return  : void
2009 Notes   :
2010 ----------------------------------------------------------------------*/
2011 void __sramlocalfunc ddr_selfrefresh_exit(void)
2012 {
2013     pCRU_Reg->CRU_CLKGATE_CON[0] = ((0x1<<2)<<16) | (0<<2);  //enable DDR PHY clock
2014     dsb();
2015     ddr_delayus(1);
2016         pPHY_Reg->PHY_REG1 = (pPHY_Reg->PHY_REG1 | (0x3 << 2)); //phy soft de-reset
2017         pPHY_Reg->PHY_REG264 |= (1<<1);
2018         dsb();
2019     ddr_move_to_Config_state();
2020     ddr_data_training();
2021     ddr_move_to_Access_state();
2022     ddr_dtt_check();
2023 }
2024
2025 /*----------------------------------------------------------------------
2026 Name    : void __sramlocalfunc ddr_change_freq_in(uint32 freq_slew)
2027 Desc    : ÉèÖÃddr pllÇ°µÄtiming¼°mr²ÎÊýµ÷Õû
2028 Params  : freq_slew :±äÆµÐ±ÂÊ 1ÉýÆ½  0½µÆµ
2029 Return  : void
2030 Notes   :
2031 ----------------------------------------------------------------------*/
2032 void __sramlocalfunc ddr_change_freq_in(uint32 freq_slew)
2033 {
2034     uint32 value_100n, value_1u;
2035
2036     if(freq_slew == 1)
2037     {
2038         value_100n = ddr_reg.pctl.pctl_timing.togcnt100n;
2039         value_1u = ddr_reg.pctl.pctl_timing.togcnt1u;
2040         ddr_reg.pctl.pctl_timing.togcnt1u = pDDR_Reg->TOGCNT1U;
2041         ddr_reg.pctl.pctl_timing.togcnt100n = pDDR_Reg->TOGCNT100N;
2042         ddr_update_timing();
2043         ddr_update_mr();
2044         ddr_reg.pctl.pctl_timing.togcnt100n = value_100n;
2045         ddr_reg.pctl.pctl_timing.togcnt1u = value_1u;
2046     }
2047     else
2048     {
2049         pDDR_Reg->TOGCNT100N = ddr_reg.pctl.pctl_timing.togcnt100n;
2050         pDDR_Reg->TOGCNT1U = ddr_reg.pctl.pctl_timing.togcnt1u;
2051     }
2052
2053     pDDR_Reg->TZQCSI = 0;
2054
2055 }
2056
2057 /*----------------------------------------------------------------------
2058 Name    : void __sramlocalfunc ddr_change_freq_out(uint32 freq_slew)
2059 Desc    : ÉèÖÃddr pllºóµÄtiming¼°mr²ÎÊýµ÷Õû
2060 Params  : freq_slew :±äÆµÐ±ÂÊ 1ÉýÆ½  0½µÆµ
2061 Return  : void
2062 Notes   :
2063 ----------------------------------------------------------------------*/
2064 void __sramlocalfunc ddr_change_freq_out(uint32 freq_slew)
2065 {
2066     if(freq_slew == 1)
2067     {
2068         pDDR_Reg->TOGCNT100N = ddr_reg.pctl.pctl_timing.togcnt100n;
2069         pDDR_Reg->TOGCNT1U = ddr_reg.pctl.pctl_timing.togcnt1u;
2070         pDDR_Reg->TZQCSI = ddr_reg.pctl.pctl_timing.tzqcsi;
2071     }
2072     else
2073     {
2074         ddr_update_timing();
2075         ddr_update_mr();
2076     }
2077     ddr_data_training();
2078 }
2079
2080 static uint32 save_sp;
2081 /*----------------------------------------------------------------------
2082 Name    : uint32_t __sramfunc ddr_change_freq(uint32_t nMHz)
2083 Desc    : ddr±äÆµ
2084 Params  : nMHz -> ±äÆµµÄÆµÂÊÖµ
2085 Return  : ÆµÂÊÖµ
2086 Notes   :
2087 ----------------------------------------------------------------------*/
2088 uint32_t __sramfunc ddr_change_freq(uint32_t nMHz)
2089 {
2090     uint32_t ret;
2091     u32 i;
2092     volatile u32 n;
2093     unsigned long flags;
2094     volatile unsigned int * temp=(volatile unsigned int *)SRAM_CODE_OFFSET;
2095     uint32_t regvalue0 = pCRU_Reg->CRU_PLL_CON[0][0];
2096     uint32_t regvalue1 = pCRU_Reg->CRU_PLL_CON[0][1];
2097     uint32_t freq;
2098         uint32 freq_slew;
2099
2100      // freq = (fin*fbdiv/(refdiv * postdiv1 * postdiv2))
2101      if((pCRU_Reg->CRU_MODE_CON & 1) == 1)             // CPLL Normal mode
2102      {
2103          freq = 24*(regvalue0&0xfff)
2104                 /((regvalue1&0x3f)*((regvalue0>>12)&0x7)*((regvalue1>>6)&0x7));
2105      }
2106      else
2107      {
2108         freq = 24;
2109      }
2110     loops_per_us = LPJ_100MHZ*freq / 1000000;
2111
2112     ret=ddr_set_pll(nMHz,0);
2113     if(ret == ddr_freq)
2114     {
2115         goto out;
2116     }
2117     else
2118     {
2119         freq_slew = (ret>ddr_freq)? 1 : -1;
2120     }
2121     ddr_get_parameter(ret);
2122     /** 1. Make sure there is no host access */
2123     local_irq_save(flags);
2124         local_fiq_disable();
2125     flush_cache_all();
2126         outer_flush_all();
2127         flush_tlb_all();
2128         DDR_SAVE_SP(save_sp);
2129         for(i=0;i<2;i++)    //8KB SRAM
2130         {
2131             n=temp[1024*i];
2132         barrier();
2133         }
2134     n= pDDR_Reg->SCFG.d32;
2135     n= pPHY_Reg->PHY_REG1;
2136     n= pCRU_Reg->CRU_PLL_CON[0][0];
2137     n= *(volatile uint32_t *)SysSrv_DdrConf;
2138     n= pGRF_Reg->GRF_SOC_STATUS0;
2139     dsb();
2140     ddr_move_to_Config_state();
2141     ddr_freq = ret;
2142     ddr_change_freq_in(freq_slew);
2143     ddr_move_to_Lowpower_state();
2144     pPHY_Reg->PHY_REG264 &= ~(1<<1);
2145     pPHY_Reg->PHY_REG1 = (pPHY_Reg->PHY_REG1 & (~(0x3<<2)));     //phy soft reset
2146     dsb();
2147     /** 3. change frequence  */
2148     ddr_set_pll(ret,1);
2149     ddr_set_dll_bypass(ddr_freq);    //set phy dll mode;
2150         pPHY_Reg->PHY_REG1 = (pPHY_Reg->PHY_REG1 | (0x3 << 2)); //phy soft de-reset
2151         pPHY_Reg->PHY_REG264 |= (1<<1);
2152         dsb();
2153         ddr_update_odt();
2154     ddr_move_to_Config_state();
2155     ddr_change_freq_out(freq_slew);
2156     ddr_move_to_Access_state();
2157     ddr_dtt_check();
2158     /** 5. Issues a Mode Exit command   */
2159     DDR_RESTORE_SP(save_sp);
2160     local_fiq_enable();
2161     local_irq_restore(flags);
2162 //    clk_set_rate(clk_get(NULL, "ddr_pll"), 0);
2163 out:
2164     return ret;
2165 }
2166
2167
2168 EXPORT_SYMBOL(ddr_change_freq);
2169
2170 /*----------------------------------------------------------------------
2171 Name    : void ddr_set_auto_self_refresh(bool en)
2172 Desc    : ÉèÖÃ½øÈë selfrefesh µÄÖÜÆÚÊý
2173 Params  : en -> Ê¹ÄÜauto selfrefresh
2174 Return  : ÆµÂÊÖµ
2175 Notes   : ÖÜÆÚÊýÎª1*32 cycle
2176 ----------------------------------------------------------------------*/
2177 void ddr_set_auto_self_refresh(bool en)
2178 {
2179     //set auto self-refresh idle
2180     ddr_sr_idle = en ? SR_IDLE : 0;
2181 }
2182
2183 EXPORT_SYMBOL(ddr_set_auto_self_refresh);
2184
2185 /*----------------------------------------------------------------------
2186 Name    : void __sramfunc ddr_suspend(void)
2187 Desc    : ½øÈëddr suspend
2188 Params  : void
2189 Return  : void
2190 Notes   :
2191 ----------------------------------------------------------------------*/
2192 void __sramfunc ddr_suspend(void)
2193 {
2194     u32 i;
2195     volatile u32 n;
2196     volatile unsigned int * temp=(volatile unsigned int *)SRAM_CODE_OFFSET;
2197     /** 1. Make sure there is no host access */
2198     flush_cache_all();
2199     outer_flush_all();
2200 //    flush_tlb_all();
2201
2202     for(i=0;i<2;i++)  //sram size = 8KB
2203     {
2204         n=temp[1024*i];
2205         barrier();
2206     }
2207     n= pDDR_Reg->SCFG.d32;
2208     n= pPHY_Reg->PHY_REG1;
2209     n= pCRU_Reg->CRU_PLL_CON[0][0];
2210     n= *(volatile uint32_t *)SysSrv_DdrConf;
2211     n= pGRF_Reg->GRF_SOC_STATUS0;
2212     dsb();
2213     ddr_selfrefresh_enter(0);
2214     pCRU_Reg->CRU_MODE_CON = (0x1<<((1*4) +  16)) | (0x0<<(1*4));   //PLL slow-mode
2215     dsb();
2216     ddr_delayus(1);
2217     pCRU_Reg->CRU_PLL_CON[1][1] = ((0x1<<13)<<16) | (0x1<<13);         //PLL power-down
2218     dsb();
2219     ddr_delayus(1);
2220
2221 }
2222 EXPORT_SYMBOL(ddr_suspend);
2223
2224 /*----------------------------------------------------------------------
2225 Name    : void __sramfunc ddr_resume(void)
2226 Desc    : ddr resume
2227 Params  : void
2228 Return  : void
2229 Notes   :
2230 ----------------------------------------------------------------------*/
2231 void __sramfunc ddr_resume(void)
2232 {
2233     int delay=1000;
2234
2235     pCRU_Reg->CRU_PLL_CON[1][1] = ((0x1<<13)<<16) | (0x0<<13);         //PLL no power-down
2236     dsb();
2237     while (delay > 0)
2238     {
2239             ddr_delayus(1);
2240                 if (pCRU_Reg->CRU_PLL_CON[1][1] & (0x1<<10))
2241                         break;
2242                 delay--;
2243         }
2244
2245     pCRU_Reg->CRU_MODE_CON = (0x1<<((1*4) +  16))  | (0x1<<(1*4));   //PLL normal
2246     dsb();
2247
2248     ddr_selfrefresh_exit();
2249 }
2250 EXPORT_SYMBOL(ddr_resume);
2251
2252 /*----------------------------------------------------------------------
2253 Name    : uint32 ddr_get_cap(void)
2254 Desc    : »ñÈ¡ÈÝÁ¿£¬·µ»Ø×Ö½ÚÊý
2255 Params  : void
2256 Return  : ¿ÅÁ£ÈÝÁ¿
2257 Notes   :
2258 ----------------------------------------------------------------------*/
2259 uint32 ddr_get_cap(void)
2260 {
2261     uint32 value;
2262     uint32 cs, bank, row, col;
2263     value = pGRF_Reg->GRF_OS_REG[1];
2264     bank = (((value >> DDR_BANK_COUNT) & 0x1)? 2:3);
2265     row = (13+((value >> DDR_ROW_COUNT) & 0x3));
2266     col = (9 + ((value >> DDR_COL_COUNT)&0x3));
2267     cs = (1 + ((value >> DDR_RANK_COUNT)&0x1));
2268     return ((1 << (row + col + bank + 1))*cs);
2269 }
2270 EXPORT_SYMBOL(ddr_get_cap);
2271
2272 /*----------------------------------------------------------------------
2273 Name    : void ddr_reg_save(void)
2274 Desc    : ±£´æ¿ØÖÆÆ÷¼Ä´æÆ÷Öµ
2275 Params  : void
2276 Return  : void
2277 Notes   :
2278 ----------------------------------------------------------------------*/
2279 void ddr_reg_save(void)
2280 {
2281     //PCTLR
2282     ddr_reg.pctl.SCFG = pDDR_Reg->SCFG.d32;
2283     ddr_reg.pctl.CMDTSTATEN = pDDR_Reg->CMDTSTATEN;
2284     ddr_reg.pctl.MCFG1 = pDDR_Reg->MCFG1;
2285     ddr_reg.pctl.MCFG = pDDR_Reg->MCFG;
2286     ddr_reg.pctl.pctl_timing.ddrFreq = ddr_freq;
2287     ddr_reg.pctl.DFITCTRLDELAY = pDDR_Reg->DFITCTRLDELAY;
2288     ddr_reg.pctl.DFIODTCFG = pDDR_Reg->DFIODTCFG;
2289     ddr_reg.pctl.DFIODTCFG1 = pDDR_Reg->DFIODTCFG1;
2290     ddr_reg.pctl.DFIODTRANKMAP = pDDR_Reg->DFIODTRANKMAP;
2291     ddr_reg.pctl.DFITPHYWRDATA = pDDR_Reg->DFITPHYWRDATA;
2292     ddr_reg.pctl.DFITPHYWRLAT = pDDR_Reg->DFITPHYWRLAT;
2293     ddr_reg.pctl.DFITRDDATAEN = pDDR_Reg->DFITRDDATAEN;
2294     ddr_reg.pctl.DFITPHYRDLAT = pDDR_Reg->DFITPHYRDLAT;
2295     ddr_reg.pctl.DFITPHYUPDTYPE0 = pDDR_Reg->DFITPHYUPDTYPE0;
2296     ddr_reg.pctl.DFITPHYUPDTYPE1 = pDDR_Reg->DFITPHYUPDTYPE1;
2297     ddr_reg.pctl.DFITPHYUPDTYPE2 = pDDR_Reg->DFITPHYUPDTYPE2;
2298     ddr_reg.pctl.DFITPHYUPDTYPE3 = pDDR_Reg->DFITPHYUPDTYPE3;
2299     ddr_reg.pctl.DFITCTRLUPDMIN = pDDR_Reg->DFITCTRLUPDMIN;
2300     ddr_reg.pctl.DFITCTRLUPDMAX = pDDR_Reg->DFITCTRLUPDMAX;
2301     ddr_reg.pctl.DFITCTRLUPDDLY = pDDR_Reg->DFITCTRLUPDDLY;
2302
2303     ddr_reg.pctl.DFIUPDCFG = pDDR_Reg->DFIUPDCFG;
2304     ddr_reg.pctl.DFITREFMSKI = pDDR_Reg->DFITREFMSKI;
2305     ddr_reg.pctl.DFITCTRLUPDI = pDDR_Reg->DFITCTRLUPDI;
2306     ddr_reg.pctl.DFISTCFG0 = pDDR_Reg->DFISTCFG0;
2307     ddr_reg.pctl.DFISTCFG1 = pDDR_Reg->DFISTCFG1;
2308     ddr_reg.pctl.DFITDRAMCLKEN = pDDR_Reg->DFITDRAMCLKEN;
2309     ddr_reg.pctl.DFITDRAMCLKDIS = pDDR_Reg->DFITDRAMCLKDIS;
2310     ddr_reg.pctl.DFISTCFG2 = pDDR_Reg->DFISTCFG2;
2311     ddr_reg.pctl.DFILPCFG0 = pDDR_Reg->DFILPCFG0;
2312
2313     //NOC
2314     ddr_reg.DdrConf = *(volatile uint32_t *)SysSrv_DdrConf;
2315     ddr_reg.DdrMode = *(volatile uint32_t *)SysSrv_DdrMode;
2316     ddr_reg.ReadLatency = *(volatile uint32_t *)SysSrv_ReadLatency;
2317 }
2318 EXPORT_SYMBOL(ddr_reg_save);
2319 /*
2320 __attribute__((aligned(4))) __sramdata uint32 ddr_reg_resume[] =
2321 {
2322 #include "ddr_reg_resume.inc"
2323 };
2324 */
2325
2326 /*----------------------------------------------------------------------
2327 Name    : int ddr_init(uint32_t dram_speed_bin, uint32_t freq)
2328 Desc    : ddr  ³õÊ¼»¯º¯Êý
2329 Params  : dram_speed_bin ->ddr¿ÅÁ£ÀàÐÍ
2330           freq ->ÆµÂÊÖµ
2331 Return  : 0 ³É¹¦
2332 Notes   :
2333 ----------------------------------------------------------------------*/
2334 int ddr_init(uint32_t dram_speed_bin, uint32_t freq)
2335 {
2336     volatile uint32_t value = 0;
2337     uint32_t cs,die=1;
2338     uint32_t calStatusLeft, calStatusRight;
2339
2340     ddr_print("version 1.00 20130731 \n");
2341     cs = (1 << (((pGRF_Reg->GRF_OS_REG[1]) >> DDR_RANK_COUNT)&0x1));    //case 0:1rank ; case 1:2rank ;
2342     mem_type = ((pGRF_Reg->GRF_OS_REG[1] >> 13) &0x7);
2343     ddr_speed_bin = dram_speed_bin;
2344     ddr_freq = 0;
2345     ddr_sr_idle = 0;
2346     ddr_dll_status = DDR3_DLL_DISABLE;
2347
2348     switch(mem_type)
2349     {
2350         case DDR3:
2351             die = 1;
2352             break;
2353                 case DDR2:
2354                         die = 1;
2355                         break;
2356         default:
2357             ddr_print("ddr type error type=%d\n",mem_type);
2358             break;
2359     }
2360
2361
2362     //get capability per chip, not total size, used for calculate tRFC
2363     ddr_capability_per_die = ddr_get_cap()/(cs * die);
2364     ddr_print("%d CS, ROW=%d, Bank=%d, COL=%d, Total Capability=%dMB\n",
2365                                                                     cs, \
2366                                                                     ddr_get_row(), \
2367                                                                     (0x1<<(ddr_get_bank())), \
2368                                                                     ddr_get_col(), \
2369                                                                     (ddr_get_cap()>>20));
2370     ddr_adjust_config(mem_type);
2371     if(freq != 0)
2372         value=ddr_change_freq(freq);
2373     else
2374         value=ddr_change_freq(clk_get_rate(clk_get(NULL, "ddr"))/1000000);
2375
2376     clk_set_rate(clk_get(NULL, "ddr"), 0);
2377     ddr_print("init success!!! freq=%dMHz\n", clk_get_rate(clk_get(NULL, "ddr"))/1000000);
2378
2379     calStatusLeft = pPHY_Reg->PHY_REG60;
2380     calStatusRight = pPHY_Reg->PHY_REG61;
2381
2382
2383     ddr_print("left channel:Dllsel=%x, Ophsel=%x, Cycsel=%x\n",\
2384                                     (calStatusRight >> 5) & 0x07,\
2385                                     (calStatusRight >> 3) & 0x03,\
2386                                     calStatusRight  & 0x07);
2387     ddr_print("right channel:Dllsel=%x, Ophsel=%x, Cycsel=%x\n",\
2388                                     (calStatusLeft >> 5) & 0x07,\
2389                                     (calStatusLeft >> 3) & 0x03,\
2390                                     calStatusLeft  & 0x07);
2391
2392     ddr_print("DRV Pull-Up=0x%x, DRV Pull-Dwn=0x%x\n", (pPHY_Reg->PHY_REG25>>3)&0x7, pPHY_Reg->PHY_REG25&0x7);
2393     ddr_print("ODT Pull-Up=0x%x, ODT Pull-Dwn=0x%x\n", (pPHY_Reg->PHY_REG27>>3)&0x7, pPHY_Reg->PHY_REG27&0x7);
2394     return 0;
2395 }
2396
2397 EXPORT_SYMBOL(ddr_init);
2398