arch/arm/mach-sunxi/dram_sun4i.c

   1 // SPDX-License-Identifier: GPL-2.0+
   2 /*
   3  * sunxi DRAM controller initialization
   4  * (C) Copyright 2012 Henrik Nordstrom <henrik@henriknordstrom.net>
   5  * (C) Copyright 2013 Luke Kenneth Casson Leighton <lkcl@lkcl.net>
   6  *
   7  * Based on sun4i Linux kernel sources mach-sunxi/pm/standby/dram*.c
   8  * and earlier U-Boot Allwinner A10 SPL work
   9  *
  10  * (C) Copyright 2007-2012
  11  * Allwinner Technology Co., Ltd. <www.allwinnertech.com>
  12  * Berg Xing <bergxing@allwinnertech.com>
  13  * Tom Cubie <tangliang@allwinnertech.com>
  14  */
  15
  16 /*
  17  * Unfortunately the only documentation we have on the sun7i DRAM
  18  * controller is Allwinner boot0 + boot1 code, and that code uses
  19  * magic numbers & shifts with no explanations. Hence this code is
  20  * rather undocumented and full of magic.
  21  */
  22
  23 #include <common.h>
  24 #include <asm/io.h>
  25 #include <asm/arch/clock.h>
  26 #include <asm/arch/dram.h>
  27 #include <asm/arch/timer.h>
  28 #include <asm/arch/sys_proto.h>
  29
  30 #define CPU_CFG_CHIP_VER(n) ((n) << 6)
  31 #define CPU_CFG_CHIP_VER_MASK CPU_CFG_CHIP_VER(0x3)
  32 #define CPU_CFG_CHIP_REV_A 0x0
  33 #define CPU_CFG_CHIP_REV_C1 0x1
  34 #define CPU_CFG_CHIP_REV_C2 0x2
  35 #define CPU_CFG_CHIP_REV_B 0x3
  36
  37 /*
  38  * Wait up to 1s for mask to be clear in given reg.
  39  */
  40 static inline void await_bits_clear(u32 *reg, u32 mask)
  41 {
  42         mctl_await_completion(reg, mask, 0);
  43 }
  44
  45 /*
  46  * Wait up to 1s for mask to be set in given reg.
  47  */
  48 static inline void await_bits_set(u32 *reg, u32 mask)
  49 {
  50         mctl_await_completion(reg, mask, mask);
  51 }
  52
  53 /*
  54  * This performs the external DRAM reset by driving the RESET pin low and
  55  * then high again. According to the DDR3 spec, the RESET pin needs to be
  56  * kept low for at least 200 us.
  57  */
  58 static void mctl_ddr3_reset(void)
  59 {
  60         struct sunxi_dram_reg *dram =
  61                         (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
  62
  63 #ifdef CONFIG_MACH_SUN4I
  64         struct sunxi_timer_reg *timer =
  65                         (struct sunxi_timer_reg *)SUNXI_TIMER_BASE;
  66         u32 reg_val;
  67
  68         writel(0, &timer->cpu_cfg);
  69         reg_val = readl(&timer->cpu_cfg);
  70
  71         if ((reg_val & CPU_CFG_CHIP_VER_MASK) !=
  72             CPU_CFG_CHIP_VER(CPU_CFG_CHIP_REV_A)) {
  73                 setbits_le32(&dram->mcr, DRAM_MCR_RESET);
  74                 udelay(200);
  75                 clrbits_le32(&dram->mcr, DRAM_MCR_RESET);
  76         } else
  77 #endif
  78         {
  79                 clrbits_le32(&dram->mcr, DRAM_MCR_RESET);
  80                 udelay(200);
  81                 setbits_le32(&dram->mcr, DRAM_MCR_RESET);
  82         }
  83         /* After the RESET pin is de-asserted, the DDR3 spec requires to wait
  84          * for additional 500 us before driving the CKE pin (Clock Enable)
  85          * high. The duration of this delay can be configured in the SDR_IDCR
  86          * (Initialization Delay Configuration Register) and applied
  87          * automatically by the DRAM controller during the DDR3 initialization
  88          * step. But SDR_IDCR has limited range on sun4i/sun5i hardware and
  89          * can't provide sufficient delay at DRAM clock frequencies higher than
  90          * 524 MHz (while Allwinner A13 supports DRAM clock frequency up to
  91          * 533 MHz according to the datasheet). Additionally, there is no
  92          * official documentation for the SDR_IDCR register anywhere, and
  93          * there is always a chance that we are interpreting it wrong.
  94          * Better be safe than sorry, so add an explicit delay here. */
  95         udelay(500);
  96 }
  97
  98 static void mctl_set_drive(void)
  99 {
 100         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 101
 102 #ifdef CONFIG_MACH_SUN7I
 103         clrsetbits_le32(&dram->mcr, DRAM_MCR_MODE_NORM(0x3) | (0x3 << 28),
 104 #else
 105         clrsetbits_le32(&dram->mcr, DRAM_MCR_MODE_NORM(0x3),
 106 #endif
 107                         DRAM_MCR_MODE_EN(0x3) |
 108                         0xffc);
 109 }
 110
 111 static void mctl_itm_disable(void)
 112 {
 113         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 114
 115         clrsetbits_le32(&dram->ccr, DRAM_CCR_INIT, DRAM_CCR_ITM_OFF);
 116 }
 117
 118 static void mctl_itm_enable(void)
 119 {
 120         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 121
 122         clrbits_le32(&dram->ccr, DRAM_CCR_ITM_OFF);
 123 }
 124
 125 static void mctl_itm_reset(void)
 126 {
 127         mctl_itm_disable();
 128         udelay(1); /* ITM reset needs a bit of delay */
 129         mctl_itm_enable();
 130         udelay(1);
 131 }
 132
 133 static void mctl_enable_dll0(u32 phase)
 134 {
 135         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 136
 137         clrsetbits_le32(&dram->dllcr[0], 0x3f << 6,
 138                         ((phase >> 16) & 0x3f) << 6);
 139         clrsetbits_le32(&dram->dllcr[0], DRAM_DLLCR_NRESET, DRAM_DLLCR_DISABLE);
 140         udelay(2);
 141
 142         clrbits_le32(&dram->dllcr[0], DRAM_DLLCR_NRESET | DRAM_DLLCR_DISABLE);
 143         udelay(22);
 144
 145         clrsetbits_le32(&dram->dllcr[0], DRAM_DLLCR_DISABLE, DRAM_DLLCR_NRESET);
 146         udelay(22);
 147 }
 148
 149 /* Get the number of DDR byte lanes */
 150 static u32 mctl_get_number_of_lanes(void)
 151 {
 152         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 153         if ((readl(&dram->dcr) & DRAM_DCR_BUS_WIDTH_MASK) ==
 154                                 DRAM_DCR_BUS_WIDTH(DRAM_DCR_BUS_WIDTH_32BIT))
 155                 return 4;
 156         else
 157                 return 2;
 158 }
 159
 160 /*
 161  * Note: This differs from pm/standby in that it checks the bus width
 162  */
 163 static void mctl_enable_dllx(u32 phase)
 164 {
 165         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 166         u32 i, number_of_lanes;
 167
 168         number_of_lanes = mctl_get_number_of_lanes();
 169
 170         for (i = 1; i <= number_of_lanes; i++) {
 171                 clrsetbits_le32(&dram->dllcr[i], 0xf << 14,
 172                                 (phase & 0xf) << 14);
 173                 clrsetbits_le32(&dram->dllcr[i], DRAM_DLLCR_NRESET,
 174                                 DRAM_DLLCR_DISABLE);
 175                 phase >>= 4;
 176         }
 177         udelay(2);
 178
 179         for (i = 1; i <= number_of_lanes; i++)
 180                 clrbits_le32(&dram->dllcr[i], DRAM_DLLCR_NRESET |
 181                              DRAM_DLLCR_DISABLE);
 182         udelay(22);
 183
 184         for (i = 1; i <= number_of_lanes; i++)
 185                 clrsetbits_le32(&dram->dllcr[i], DRAM_DLLCR_DISABLE,
 186                                 DRAM_DLLCR_NRESET);
 187         udelay(22);
 188 }
 189
 190 static u32 hpcr_value[32] = {
 191 #ifdef CONFIG_MACH_SUN5I
 192         0, 0, 0, 0,
 193         0, 0, 0, 0,
 194         0, 0, 0, 0,
 195         0, 0, 0, 0,
 196         0x1031, 0x1031, 0x0735, 0x1035,
 197         0x1035, 0x0731, 0x1031, 0,
 198         0x0301, 0x0301, 0x0301, 0x0301,
 199         0x0301, 0x0301, 0x0301, 0
 200 #endif
 201 #ifdef CONFIG_MACH_SUN4I
 202         0x0301, 0x0301, 0x0301, 0x0301,
 203         0x0301, 0x0301, 0, 0,
 204         0, 0, 0, 0,
 205         0, 0, 0, 0,
 206         0x1031, 0x1031, 0x0735, 0x5031,
 207         0x1035, 0x0731, 0x1031, 0x0735,
 208         0x1035, 0x1031, 0x0731, 0x1035,
 209         0x1031, 0x0301, 0x0301, 0x0731
 210 #endif
 211 #ifdef CONFIG_MACH_SUN7I
 212         0x0301, 0x0301, 0x0301, 0x0301,
 213         0x0301, 0x0301, 0x0301, 0x0301,
 214         0, 0, 0, 0,
 215         0, 0, 0, 0,
 216         0x1031, 0x1031, 0x0735, 0x1035,
 217         0x1035, 0x0731, 0x1031, 0x0735,
 218         0x1035, 0x1031, 0x0731, 0x1035,
 219         0x0001, 0x1031, 0, 0x1031
 220         /* last row differs from boot0 source table
 221          * 0x1031, 0x0301, 0x0301, 0x0731
 222          * but boot0 code skips #28 and #30, and sets #29 and #31 to the
 223          * value from #28 entry (0x1031)
 224          */
 225 #endif
 226 };
 227
 228 static void mctl_configure_hostport(void)
 229 {
 230         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 231         u32 i;
 232
 233         for (i = 0; i < 32; i++)
 234                 writel(hpcr_value[i], &dram->hpcr[i]);
 235 }
 236
 237 static void mctl_setup_dram_clock(u32 clk, u32 mbus_clk)
 238 {
 239         u32 reg_val;
 240         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
 241         u32 pll5p_clk, pll6x_clk;
 242         u32 pll5p_div, pll6x_div;
 243         u32 pll5p_rate, pll6x_rate;
 244
 245         /* setup DRAM PLL */
 246         reg_val = readl(&ccm->pll5_cfg);
 247         reg_val &= ~CCM_PLL5_CTRL_M_MASK;               /* set M to 0 (x1) */
 248         reg_val &= ~CCM_PLL5_CTRL_K_MASK;               /* set K to 0 (x1) */
 249         reg_val &= ~CCM_PLL5_CTRL_N_MASK;               /* set N to 0 (x0) */
 250         reg_val &= ~CCM_PLL5_CTRL_P_MASK;               /* set P to 0 (x1) */
 251 #ifdef CONFIG_OLD_SUNXI_KERNEL_COMPAT
 252         /* Old kernels are hardcoded to P=1 (divide by 2) */
 253         reg_val |= CCM_PLL5_CTRL_P(1);
 254 #endif
 255         if (clk >= 540 && clk < 552) {
 256                 /* dram = 540MHz */
 257                 reg_val |= CCM_PLL5_CTRL_M(CCM_PLL5_CTRL_M_X(2));
 258                 reg_val |= CCM_PLL5_CTRL_K(CCM_PLL5_CTRL_K_X(3));
 259                 reg_val |= CCM_PLL5_CTRL_N(CCM_PLL5_CTRL_N_X(15));
 260         } else if (clk >= 512 && clk < 528) {
 261                 /* dram = 512MHz */
 262                 reg_val |= CCM_PLL5_CTRL_M(CCM_PLL5_CTRL_M_X(3));
 263                 reg_val |= CCM_PLL5_CTRL_K(CCM_PLL5_CTRL_K_X(4));
 264                 reg_val |= CCM_PLL5_CTRL_N(CCM_PLL5_CTRL_N_X(16));
 265         } else if (clk >= 496 && clk < 504) {
 266                 /* dram = 496MHz */
 267                 reg_val |= CCM_PLL5_CTRL_M(CCM_PLL5_CTRL_M_X(3));
 268                 reg_val |= CCM_PLL5_CTRL_K(CCM_PLL5_CTRL_K_X(2));
 269                 reg_val |= CCM_PLL5_CTRL_N(CCM_PLL5_CTRL_N_X(31));
 270         } else if (clk >= 468 && clk < 480) {
 271                 /* dram = 468MHz */
 272                 reg_val |= CCM_PLL5_CTRL_M(CCM_PLL5_CTRL_M_X(2));
 273                 reg_val |= CCM_PLL5_CTRL_K(CCM_PLL5_CTRL_K_X(3));
 274                 reg_val |= CCM_PLL5_CTRL_N(CCM_PLL5_CTRL_N_X(13));
 275         } else if (clk >= 396 && clk < 408) {
 276                 /* dram = 396MHz */
 277                 reg_val |= CCM_PLL5_CTRL_M(CCM_PLL5_CTRL_M_X(2));
 278                 reg_val |= CCM_PLL5_CTRL_K(CCM_PLL5_CTRL_K_X(3));
 279                 reg_val |= CCM_PLL5_CTRL_N(CCM_PLL5_CTRL_N_X(11));
 280         } else  {
 281                 /* any other frequency that is a multiple of 24 */
 282                 reg_val |= CCM_PLL5_CTRL_M(CCM_PLL5_CTRL_M_X(2));
 283                 reg_val |= CCM_PLL5_CTRL_K(CCM_PLL5_CTRL_K_X(2));
 284                 reg_val |= CCM_PLL5_CTRL_N(CCM_PLL5_CTRL_N_X(clk / 24));
 285         }
 286         reg_val &= ~CCM_PLL5_CTRL_VCO_GAIN;             /* PLL VCO Gain off */
 287         reg_val |= CCM_PLL5_CTRL_EN;                    /* PLL On */
 288         writel(reg_val, &ccm->pll5_cfg);
 289         udelay(5500);
 290
 291         setbits_le32(&ccm->pll5_cfg, CCM_PLL5_CTRL_DDR_CLK);
 292
 293 #if defined(CONFIG_MACH_SUN4I) || defined(CONFIG_MACH_SUN7I)
 294         /* reset GPS */
 295         clrbits_le32(&ccm->gps_clk_cfg, CCM_GPS_CTRL_RESET | CCM_GPS_CTRL_GATE);
 296         setbits_le32(&ccm->ahb_gate0, CCM_AHB_GATE_GPS);
 297         udelay(1);
 298         clrbits_le32(&ccm->ahb_gate0, CCM_AHB_GATE_GPS);
 299 #endif
 300
 301         /* setup MBUS clock */
 302         if (!mbus_clk)
 303                 mbus_clk = 300;
 304
 305         /* PLL5P and PLL6 are the potential clock sources for MBUS */
 306         pll6x_clk = clock_get_pll6() / 1000000;
 307 #ifdef CONFIG_MACH_SUN7I
 308         pll6x_clk *= 2; /* sun7i uses PLL6*2, sun5i uses just PLL6 */
 309 #endif
 310         pll5p_clk = clock_get_pll5p() / 1000000;
 311         pll6x_div = DIV_ROUND_UP(pll6x_clk, mbus_clk);
 312         pll5p_div = DIV_ROUND_UP(pll5p_clk, mbus_clk);
 313         pll6x_rate = pll6x_clk / pll6x_div;
 314         pll5p_rate = pll5p_clk / pll5p_div;
 315
 316         if (pll6x_div <= 16 && pll6x_rate > pll5p_rate) {
 317                 /* use PLL6 as the MBUS clock source */
 318                 reg_val = CCM_MBUS_CTRL_GATE |
 319                           CCM_MBUS_CTRL_CLK_SRC(CCM_MBUS_CTRL_CLK_SRC_PLL6) |
 320                           CCM_MBUS_CTRL_N(CCM_MBUS_CTRL_N_X(1)) |
 321                           CCM_MBUS_CTRL_M(CCM_MBUS_CTRL_M_X(pll6x_div));
 322         } else if (pll5p_div <= 16) {
 323                 /* use PLL5P as the MBUS clock source */
 324                 reg_val = CCM_MBUS_CTRL_GATE |
 325                           CCM_MBUS_CTRL_CLK_SRC(CCM_MBUS_CTRL_CLK_SRC_PLL5) |
 326                           CCM_MBUS_CTRL_N(CCM_MBUS_CTRL_N_X(1)) |
 327                           CCM_MBUS_CTRL_M(CCM_MBUS_CTRL_M_X(pll5p_div));
 328         } else {
 329                 panic("Bad mbus_clk\n");
 330         }
 331         writel(reg_val, &ccm->mbus_clk_cfg);
 332
 333         /*
 334          * open DRAMC AHB & DLL register clock
 335          * close it first
 336          */
 337 #if defined(CONFIG_MACH_SUN5I) || defined(CONFIG_MACH_SUN7I)
 338         clrbits_le32(&ccm->ahb_gate0, CCM_AHB_GATE_SDRAM | CCM_AHB_GATE_DLL);
 339 #else
 340         clrbits_le32(&ccm->ahb_gate0, CCM_AHB_GATE_SDRAM);
 341 #endif
 342         udelay(22);
 343
 344         /* then open it */
 345 #if defined(CONFIG_MACH_SUN5I) || defined(CONFIG_MACH_SUN7I)
 346         setbits_le32(&ccm->ahb_gate0, CCM_AHB_GATE_SDRAM | CCM_AHB_GATE_DLL);
 347 #else
 348         setbits_le32(&ccm->ahb_gate0, CCM_AHB_GATE_SDRAM);
 349 #endif
 350         udelay(22);
 351 }
 352
 353 /*
 354  * The data from rslrX and rdgrX registers (X=rank) is stored
 355  * in a single 32-bit value using the following format:
 356  *   bits [31:26] - DQS gating system latency for byte lane 3
 357  *   bits [25:24] - DQS gating phase select for byte lane 3
 358  *   bits [23:18] - DQS gating system latency for byte lane 2
 359  *   bits [17:16] - DQS gating phase select for byte lane 2
 360  *   bits [15:10] - DQS gating system latency for byte lane 1
 361  *   bits [ 9:8 ] - DQS gating phase select for byte lane 1
 362  *   bits [ 7:2 ] - DQS gating system latency for byte lane 0
 363  *   bits [ 1:0 ] - DQS gating phase select for byte lane 0
 364  */
 365 static void mctl_set_dqs_gating_delay(int rank, u32 dqs_gating_delay)
 366 {
 367         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 368         u32 lane, number_of_lanes = mctl_get_number_of_lanes();
 369         /* rank0 gating system latency (3 bits per lane: cycles) */
 370         u32 slr = readl(rank == 0 ? &dram->rslr0 : &dram->rslr1);
 371         /* rank0 gating phase select (2 bits per lane: 90, 180, 270, 360) */
 372         u32 dgr = readl(rank == 0 ? &dram->rdgr0 : &dram->rdgr1);
 373         for (lane = 0; lane < number_of_lanes; lane++) {
 374                 u32 tmp = dqs_gating_delay >> (lane * 8);
 375                 slr &= ~(7 << (lane * 3));
 376                 slr |= ((tmp >> 2) & 7) << (lane * 3);
 377                 dgr &= ~(3 << (lane * 2));
 378                 dgr |= (tmp & 3) << (lane * 2);
 379         }
 380         writel(slr, rank == 0 ? &dram->rslr0 : &dram->rslr1);
 381         writel(dgr, rank == 0 ? &dram->rdgr0 : &dram->rdgr1);
 382 }
 383
 384 static int dramc_scan_readpipe(void)
 385 {
 386         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 387         u32 reg_val;
 388
 389         /* data training trigger */
 390         clrbits_le32(&dram->csr, DRAM_CSR_FAILED);
 391         setbits_le32(&dram->ccr, DRAM_CCR_DATA_TRAINING);
 392
 393         /* check whether data training process has completed */
 394         await_bits_clear(&dram->ccr, DRAM_CCR_DATA_TRAINING);
 395
 396         /* check data training result */
 397         reg_val = readl(&dram->csr);
 398         if (reg_val & DRAM_CSR_FAILED)
 399                 return -1;
 400
 401         return 0;
 402 }
 403
 404 static void dramc_clock_output_en(u32 on)
 405 {
 406 #if defined(CONFIG_MACH_SUN5I) || defined(CONFIG_MACH_SUN7I)
 407         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 408
 409         if (on)
 410                 setbits_le32(&dram->mcr, DRAM_MCR_DCLK_OUT);
 411         else
 412                 clrbits_le32(&dram->mcr, DRAM_MCR_DCLK_OUT);
 413 #endif
 414 #ifdef CONFIG_MACH_SUN4I
 415         struct sunxi_ccm_reg *ccm = (struct sunxi_ccm_reg *)SUNXI_CCM_BASE;
 416         if (on)
 417                 setbits_le32(&ccm->dram_clk_gate, CCM_DRAM_CTRL_DCLK_OUT);
 418         else
 419                 clrbits_le32(&ccm->dram_clk_gate, CCM_DRAM_CTRL_DCLK_OUT);
 420 #endif
 421 }
 422
 423 /* tRFC in nanoseconds for different densities (from the DDR3 spec) */
 424 static const u16 tRFC_DDR3_table[6] = {
 425         /* 256Mb    512Mb    1Gb      2Gb      4Gb      8Gb */
 426            90,      90,      110,     160,     300,     350
 427 };
 428
 429 static void dramc_set_autorefresh_cycle(u32 clk, u32 density)
 430 {
 431         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 432         u32 tRFC, tREFI;
 433
 434         tRFC = (tRFC_DDR3_table[density] * clk + 999) / 1000;
 435         tREFI = (7987 * clk) >> 10;     /* <= 7.8us */
 436
 437         writel(DRAM_DRR_TREFI(tREFI) | DRAM_DRR_TRFC(tRFC), &dram->drr);
 438 }
 439
 440 /* Calculate the value for A11, A10, A9 bits in MR0 (write recovery) */
 441 static u32 ddr3_write_recovery(u32 clk)
 442 {
 443         u32 twr_ns = 15; /* DDR3 spec says that it is 15ns for all speed bins */
 444         u32 twr_ck = (twr_ns * clk + 999) / 1000;
 445         if (twr_ck < 5)
 446                 return 1;
 447         else if (twr_ck <= 8)
 448                 return twr_ck - 4;
 449         else if (twr_ck <= 10)
 450                 return 5;
 451         else
 452                 return 6;
 453 }
 454
 455 /*
 456  * If the dram->ppwrsctl (SDR_DPCR) register has the lowest bit set to 1, this
 457  * means that DRAM is currently in self-refresh mode and retaining the old
 458  * data. Since we have no idea what to do in this situation yet, just set this
 459  * register to 0 and initialize DRAM in the same way as on any normal reboot
 460  * (discarding whatever was stored there).
 461  *
 462  * Note: on sun7i hardware, the highest 16 bits need to be set to 0x1651 magic
 463  * value for this write operation to have any effect. On sun5i hadware this
 464  * magic value is not necessary. And on sun4i hardware the writes to this
 465  * register seem to have no effect at all.
 466  */
 467 static void mctl_disable_power_save(void)
 468 {
 469         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 470         writel(0x16510000, &dram->ppwrsctl);
 471 }
 472
 473 /*
 474  * After the DRAM is powered up or reset, the DDR3 spec requires to wait at
 475  * least 500 us before driving the CKE pin (Clock Enable) high. The dram->idct
 476  * (SDR_IDCR) register appears to configure this delay, which gets applied
 477  * right at the time when the DRAM initialization is activated in the
 478  * 'mctl_ddr3_initialize' function.
 479  */
 480 static void mctl_set_cke_delay(void)
 481 {
 482         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 483
 484         /* The CKE delay is represented in DRAM clock cycles, multiplied by N
 485          * (where N=2 for sun4i/sun5i and N=3 for sun7i). Here it is set to
 486          * the maximum possible value 0x1ffff, just like in the Allwinner's
 487          * boot0 bootloader. The resulting delay value is somewhere between
 488          * ~0.4 ms (sun5i with 648 MHz DRAM clock speed) and ~1.1 ms (sun7i
 489          * with 360 MHz DRAM clock speed). */
 490         setbits_le32(&dram->idcr, 0x1ffff);
 491 }
 492
 493 /*
 494  * This triggers the DRAM initialization. It performs sending the mode registers
 495  * to the DRAM among other things. Very likely the ZQCL command is also getting
 496  * executed (to do the initial impedance calibration on the DRAM side of the
 497  * wire). The memory controller and the PHY must be already configured before
 498  * calling this function.
 499  */
 500 static void mctl_ddr3_initialize(void)
 501 {
 502         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 503         setbits_le32(&dram->ccr, DRAM_CCR_INIT);
 504         await_bits_clear(&dram->ccr, DRAM_CCR_INIT);
 505 }
 506
 507 /*
 508  * Perform impedance calibration on the DRAM controller side of the wire.
 509  */
 510 static void mctl_set_impedance(u32 zq, bool odt_en)
 511 {
 512         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 513         u32 reg_val;
 514         u32 zprog = zq & 0xFF, zdata = (zq >> 8) & 0xFFFFF;
 515
 516 #ifndef CONFIG_MACH_SUN7I
 517         /* Appears that some kind of automatically initiated default
 518          * ZQ calibration is already in progress at this point on sun4i/sun5i
 519          * hardware, but not on sun7i. So it is reasonable to wait for its
 520          * completion before doing anything else. */
 521         await_bits_set(&dram->zqsr, DRAM_ZQSR_ZDONE);
 522 #endif
 523
 524         /* ZQ calibration is not really useful unless ODT is enabled */
 525         if (!odt_en)
 526                 return;
 527
 528 #ifdef CONFIG_MACH_SUN7I
 529         /* Enabling ODT in SDR_IOCR on sun7i hardware results in a deadlock
 530          * unless bit 24 is set in SDR_ZQCR1. Not much is known about the
 531          * SDR_ZQCR1 register, but there are hints indicating that it might
 532          * be related to periodic impedance re-calibration. This particular
 533          * magic value is borrowed from the Allwinner boot0 bootloader, and
 534          * using it helps to avoid troubles */
 535         writel((1 << 24) | (1 << 1), &dram->zqcr1);
 536 #endif
 537
 538         /* Needed at least for sun5i, because it does not self clear there */
 539         clrbits_le32(&dram->zqcr0, DRAM_ZQCR0_ZCAL);
 540
 541         if (zdata) {
 542                 /* Set the user supplied impedance data */
 543                 reg_val = DRAM_ZQCR0_ZDEN | zdata;
 544                 writel(reg_val, &dram->zqcr0);
 545                 /* no need to wait, this takes effect immediately */
 546         } else {
 547                 /* Do the calibration using the external resistor */
 548                 reg_val = DRAM_ZQCR0_ZCAL | DRAM_ZQCR0_IMP_DIV(zprog);
 549                 writel(reg_val, &dram->zqcr0);
 550                 /* Wait for the new impedance configuration to settle */
 551                 await_bits_set(&dram->zqsr, DRAM_ZQSR_ZDONE);
 552         }
 553
 554         /* Needed at least for sun5i, because it does not self clear there */
 555         clrbits_le32(&dram->zqcr0, DRAM_ZQCR0_ZCAL);
 556
 557         /* Set I/O configure register */
 558         writel(DRAM_IOCR_ODT_EN, &dram->iocr);
 559 }
 560
 561 static unsigned long dramc_init_helper(struct dram_para *para)
 562 {
 563         struct sunxi_dram_reg *dram = (struct sunxi_dram_reg *)SUNXI_DRAMC_BASE;
 564         u32 reg_val;
 565         u32 density;
 566         int ret_val;
 567
 568         /*
 569          * only single rank DDR3 is supported by this code even though the
 570          * hardware can theoretically support DDR2 and up to two ranks
 571          */
 572         if (para->type != DRAM_MEMORY_TYPE_DDR3 || para->rank_num != 1)
 573                 return 0;
 574
 575         /* setup DRAM relative clock */
 576         mctl_setup_dram_clock(para->clock, para->mbus_clock);
 577
 578         /* Disable any pad power save control */
 579         mctl_disable_power_save();
 580
 581         mctl_set_drive();
 582
 583         /* dram clock off */
 584         dramc_clock_output_en(0);
 585
 586 #ifdef CONFIG_MACH_SUN4I
 587         /* select dram controller 1 */
 588         writel(DRAM_CSEL_MAGIC, &dram->csel);
 589 #endif
 590
 591         mctl_itm_disable();
 592         mctl_enable_dll0(para->tpr3);
 593
 594         /* configure external DRAM */
 595         reg_val = DRAM_DCR_TYPE_DDR3;
 596         reg_val |= DRAM_DCR_IO_WIDTH(para->io_width >> 3);
 597
 598         if (para->density == 256)
 599                 density = DRAM_DCR_CHIP_DENSITY_256M;
 600         else if (para->density == 512)
 601                 density = DRAM_DCR_CHIP_DENSITY_512M;
 602         else if (para->density == 1024)
 603                 density = DRAM_DCR_CHIP_DENSITY_1024M;
 604         else if (para->density == 2048)
 605                 density = DRAM_DCR_CHIP_DENSITY_2048M;
 606         else if (para->density == 4096)
 607                 density = DRAM_DCR_CHIP_DENSITY_4096M;
 608         else if (para->density == 8192)
 609                 density = DRAM_DCR_CHIP_DENSITY_8192M;
 610         else
 611                 density = DRAM_DCR_CHIP_DENSITY_256M;
 612
 613         reg_val |= DRAM_DCR_CHIP_DENSITY(density);
 614         reg_val |= DRAM_DCR_BUS_WIDTH((para->bus_width >> 3) - 1);
 615         reg_val |= DRAM_DCR_RANK_SEL(para->rank_num - 1);
 616         reg_val |= DRAM_DCR_CMD_RANK_ALL;
 617         reg_val |= DRAM_DCR_MODE(DRAM_DCR_MODE_INTERLEAVE);
 618         writel(reg_val, &dram->dcr);
 619
 620         dramc_clock_output_en(1);
 621
 622         mctl_set_impedance(para->zq, para->odt_en);
 623
 624         mctl_set_cke_delay();
 625
 626         mctl_ddr3_reset();
 627
 628         udelay(1);
 629
 630         await_bits_clear(&dram->ccr, DRAM_CCR_INIT);
 631
 632         mctl_enable_dllx(para->tpr3);
 633
 634         /* set refresh period */
 635         dramc_set_autorefresh_cycle(para->clock, density);
 636
 637         /* set timing parameters */
 638         writel(para->tpr0, &dram->tpr0);
 639         writel(para->tpr1, &dram->tpr1);
 640         writel(para->tpr2, &dram->tpr2);
 641
 642         reg_val = DRAM_MR_BURST_LENGTH(0x0);
 643 #if (defined(CONFIG_MACH_SUN5I) || defined(CONFIG_MACH_SUN7I))
 644         reg_val |= DRAM_MR_POWER_DOWN;
 645 #endif
 646         reg_val |= DRAM_MR_CAS_LAT(para->cas - 4);
 647         reg_val |= DRAM_MR_WRITE_RECOVERY(ddr3_write_recovery(para->clock));
 648         writel(reg_val, &dram->mr);
 649
 650         writel(para->emr1, &dram->emr);
 651         writel(para->emr2, &dram->emr2);
 652         writel(para->emr3, &dram->emr3);
 653
 654         /* disable drift compensation and set passive DQS window mode */
 655         clrsetbits_le32(&dram->ccr, DRAM_CCR_DQS_DRIFT_COMP, DRAM_CCR_DQS_GATE);
 656
 657 #ifdef CONFIG_MACH_SUN7I
 658         /* Command rate timing mode 2T & 1T */
 659         if (para->tpr4 & 0x1)
 660                 setbits_le32(&dram->ccr, DRAM_CCR_COMMAND_RATE_1T);
 661 #endif
 662         /* initialize external DRAM */
 663         mctl_ddr3_initialize();
 664
 665         /* scan read pipe value */
 666         mctl_itm_enable();
 667
 668         /* Hardware DQS gate training */
 669         ret_val = dramc_scan_readpipe();
 670
 671         if (ret_val < 0)
 672                 return 0;
 673
 674         /* allow to override the DQS training results with a custom delay */
 675         if (para->dqs_gating_delay)
 676                 mctl_set_dqs_gating_delay(0, para->dqs_gating_delay);
 677
 678         /* set the DQS gating window type */
 679         if (para->active_windowing)
 680                 clrbits_le32(&dram->ccr, DRAM_CCR_DQS_GATE);
 681         else
 682                 setbits_le32(&dram->ccr, DRAM_CCR_DQS_GATE);
 683
 684         mctl_itm_reset();
 685
 686         /* configure all host port */
 687         mctl_configure_hostport();
 688
 689         return get_ram_size((long *)PHYS_SDRAM_0, PHYS_SDRAM_0_SIZE);
 690 }
 691
 692 unsigned long dramc_init(struct dram_para *para)
 693 {
 694         unsigned long dram_size, actual_density;
 695
 696         /* If the dram configuration is not provided, use a default */
 697         if (!para)
 698                 return 0;
 699
 700         /* if everything is known, then autodetection is not necessary */
 701         if (para->io_width && para->bus_width && para->density)
 702                 return dramc_init_helper(para);
 703
 704         /* try to autodetect the DRAM bus width and density */
 705         para->io_width  = 16;
 706         para->bus_width = 32;
 707 #if defined(CONFIG_MACH_SUN4I) || defined(CONFIG_MACH_SUN5I)
 708         /* only A0-A14 address lines on A10/A13, limiting max density to 4096 */
 709         para->density = 4096;
 710 #else
 711         /* all A0-A15 address lines on A20, which allow density 8192 */
 712         para->density = 8192;
 713 #endif
 714
 715         dram_size = dramc_init_helper(para);
 716         if (!dram_size) {
 717                 /* if 32-bit bus width failed, try 16-bit bus width instead */
 718                 para->bus_width = 16;
 719                 dram_size = dramc_init_helper(para);
 720                 if (!dram_size) {
 721                         /* if 16-bit bus width also failed, then bail out */
 722                         return dram_size;
 723                 }
 724         }
 725
 726         /* check if we need to adjust the density */
 727         actual_density = (dram_size >> 17) * para->io_width / para->bus_width;
 728
 729         if (actual_density != para->density) {
 730                 /* update the density and re-initialize DRAM again */
 731                 para->density = actual_density;
 732                 dram_size = dramc_init_helper(para);
 733         }
 734
 735         return dram_size;
 736 }