u-boot/cpu/mips/ar7240/qca_dram.c

   1 /*
   2  * Qualcomm/Atheros WiSoCs DRAM related
   3  * functions for WiSoC families:
   4  * - Atheros AR933x
   5  * - Atheros AR934x
   6  * - Qualcomm/Atheros QCA953x
   7  * - Qualcomm/Atheros QCA955x
   8  * - Qualcomm/Atheros QCA956x
   9  *
  10  * Copyright (C) 2016 Piotr Dymacz <piotr@dymacz.pl>
  11  * Copyright (C) 2015-2016 Wills Wang <wills.wang@live.com>
  12  * Copyright (C) 2014 Qualcomm Atheros, Inc.
  13  * Copyright (C) 2008-2010 Atheros Communications Inc.
  14  *
  15  * SPDX-License-Identifier: GPL-2.0
  16  */
  17
  18 #include <config.h>
  19 #include <common.h>
  20 #include <asm/addrspace.h>
  21 #include <soc/qca_soc_common.h>
  22 #include <soc/qca_dram.h>
  23
  24 #define QCA_DDR_SIZE_INCREMENT  (8 * 1024 * 1024)
  25
  26 /*
  27  * Returns size (in bytes) of the DRAM memory
  28  *
  29  * DDR wraps around, write a pattern to 0x00000000
  30  * at 8M, 16M, 32M etc. and check when it gets overwritten
  31  */
  32 u32 qca_dram_size(void)
  33 {
  34         u8 *p = (u8 *)KSEG1;
  35         u8 pattern = 0x77;
  36         u32 i;
  37
  38         *p = pattern;
  39
  40         #define max_i   (QCA_DRAM_MAX_SIZE_VAL / QCA_DDR_SIZE_INCREMENT)
  41
  42         for (i = 1; (i < max_i); i++) {
  43                 *(p + i * QCA_DDR_SIZE_INCREMENT) = (u8)i;
  44
  45                 if (*p != pattern) {
  46                         break;
  47                 }
  48         }
  49
  50 #ifndef CONFIG_SKIP_LOWLEVEL_INIT
  51         return ((i < max_i) ?
  52                         (i * QCA_DDR_SIZE_INCREMENT) : QCA_DRAM_MAX_SIZE_VAL);
  53 #else
  54         /*
  55          * TODO:
  56          * something is wrong with relocation,
  57          * need to fix it for boards with > 32M of RAM
  58          *
  59          * For now just return 1 MB smaller size
  60          */
  61         return ((i < max_i) ?
  62                         (i * QCA_DDR_SIZE_INCREMENT) : QCA_DRAM_MAX_SIZE_VAL) - 1024 * 1024;
  63 #endif
  64 }
  65
  66 /*
  67  * Return memory type value from BOOT_STRAP register
  68  */
  69 u32 qca_dram_type(void)
  70 {
  71 #if defined(CONFIG_BOARD_DRAM_TYPE_SDR)
  72         #error "SDRAM is not supported!"
  73         return RAM_MEMORY_TYPE_SDR;
  74 #elif defined(CONFIG_BOARD_DRAM_TYPE_DDR1)
  75         return RAM_MEMORY_TYPE_DDR1;
  76 #elif defined(CONFIG_BOARD_DRAM_TYPE_DDR2)
  77         return RAM_MEMORY_TYPE_DDR2;
  78 #else
  79         u32 dram_type;
  80
  81         dram_type = ((qca_soc_reg_read(QCA_RST_BOOTSTRAP_REG)
  82                                  & QCA_RST_BOOTSTRAP_MEM_TYPE_MASK) >> QCA_RST_BOOTSTRAP_MEM_TYPE_SHIFT);
  83
  84         switch (dram_type) {
  85         case QCA_RST_BOOTSTRAP_MEM_TYPE_SDR_VAL:
  86                 dram_type = RAM_MEMORY_TYPE_SDR;
  87                 break;
  88         case QCA_RST_BOOTSTRAP_MEM_TYPE_DDR1_VAL:
  89                 dram_type = RAM_MEMORY_TYPE_DDR1;
  90                 break;
  91         case QCA_RST_BOOTSTRAP_MEM_TYPE_DDR2_VAL:
  92                 dram_type = RAM_MEMORY_TYPE_DDR2;
  93                 break;
  94         default:
  95                 dram_type = RAM_MEMORY_TYPE_UNKNOWN;
  96                 break;
  97         }
  98
  99         return dram_type;
 100 #endif
 101 }
 102
 103 /*
 104  * Returns DDR width (16 or 32)
 105  */
 106 u32 qca_dram_ddr_width(void)
 107 {
 108 #ifndef CONFIG_BOARD_DRAM_DDR_WIDTH
 109         #if (SOC_TYPE & QCA_AR933X_SOC)
 110         return 16;
 111         #else
 112         if (qca_soc_reg_read(QCA_RST_BOOTSTRAP_REG)
 113                 & QCA_RST_BOOTSTRAP_DDR_WIDTH_32_MASK)
 114                 return 32;
 115
 116         return 16;
 117         #endif
 118 #else
 119         return CONFIG_BOARD_DRAM_DDR_WIDTH;
 120 #endif
 121 }
 122
 123 /*
 124  * Returns CAS latency, based on setting in DDR_CONFIG register
 125  */
 126 u32 qca_dram_cas_lat(void)
 127 {
 128 #ifndef CONFIG_BOARD_DRAM_CAS_LATENCY
 129         u32 reg;
 130
 131         reg = (qca_soc_reg_read(QCA_DDR_CFG_REG) & QCA_DDR_CFG_CAS_3LSB_MASK)
 132                   >> QCA_DDR_CFG_CAS_3LSB_SHIFT;
 133
 134         if (qca_soc_reg_read(QCA_DDR_CFG_REG) & QCA_DDR_CFG_CAS_MSB_MASK)
 135                 reg = reg + 8;
 136
 137         /* CAS_LATENCY value in DDR_CONFIG register == 2 * MEM_CAS */
 138         return reg / 2;
 139 #else
 140         return CONFIG_BOARD_DRAM_CAS_LATENCY
 141 #endif
 142 }
 143
 144 /*
 145  * Returns tRCD latency
 146  */
 147 u32 qca_dram_trcd_lat(void)
 148 {
 149         u32 reg;
 150
 151         reg = (qca_soc_reg_read(QCA_DDR_CFG_REG) & QCA_DDR_CFG_TRCD_MASK)
 152                   >> QCA_DDR_CFG_TRCD_SHIFT;
 153
 154         return reg / 2;
 155 }
 156
 157 /*
 158  * Returns tRP latency
 159  */
 160 u32 qca_dram_trp_lat(void)
 161 {
 162         u32 reg;
 163
 164         reg = (qca_soc_reg_read(QCA_DDR_CFG_REG) & QCA_DDR_CFG_TRP_MASK)
 165                   >> QCA_DDR_CFG_TRP_SHIFT;
 166
 167         return reg / 2;
 168 }
 169
 170 /*
 171  * Returns tRAS latency
 172  */
 173 u32 qca_dram_tras_lat(void)
 174 {
 175         u32 reg;
 176
 177         reg = (qca_soc_reg_read(QCA_DDR_CFG_REG) & QCA_DDR_CFG_TRAS_MASK)
 178                   >> QCA_DDR_CFG_TRAS_SHIFT;
 179
 180         return reg / 2;
 181 }
 182
 183 /*
 184  * ===============================================
 185  * DQS delay tap controller tune related functions
 186  * ===============================================
 187  */
 188 #define DQS_DELAY_TAP_DEFAULT_VAL               8
 189
 190 #if (SOC_TYPE & QCA_AR933X_SOC) |\
 191         (SOC_TYPE & QCA_AR934X_SOC)
 192         #define DQS_DELAY_TAP_MAX_VAL           62
 193 #else
 194         #define DQS_DELAY_TAP_MAX_VAL           63
 195 #endif
 196
 197 /*
 198  * Setup DQS_{0,1,2,3} delay tap control register/s
 199  */
 200 static void qca_ddr_tap_save(u32 tap, u32 ddr_width)
 201 {
 202 #if (SOC_TYPE & QCA_AR933X_SOC) |\
 203         (SOC_TYPE & QCA_AR934X_SOC)
 204         u32 tap_h;
 205
 206         /* It seems that AR93xx SoCs have two delay chains */
 207         if (tap > (DQS_DELAY_TAP_MAX_VAL / 2)) {
 208                 tap_h = tap - (DQS_DELAY_TAP_MAX_VAL / 2);
 209                 tap = tap & QCA_DDR_TAP_CTRL_TAP_L_MASK;
 210                 tap = tap | (tap_h << QCA_DDR_TAP_CTRL_TAP_H_SHIFT);
 211         }
 212 #endif
 213
 214         qca_soc_reg_write(QCA_DDR_TAP_CTRL_0_REG, tap);
 215         qca_soc_reg_write(QCA_DDR_TAP_CTRL_1_REG, tap);
 216
 217         /* Setup DQS2 and DQS3 only for 32-bit DDR interface width */
 218         if (ddr_width == 32) {
 219                 qca_soc_reg_write(QCA_DDR_TAP_CTRL_2_REG, tap);
 220                 qca_soc_reg_write(QCA_DDR_TAP_CTRL_3_REG, tap);
 221         }
 222 }
 223
 224 /*
 225  * Only for AR933x we will use different code
 226  * for delay tap controller tune as it seems
 227  * that this SoC doesn't have DDR BIST.
 228  *
 229  * Below function is universal, so it should
 230  * work also for other QC/A WiSoCs and give
 231  * same (or very similar) results. The only
 232  * difference is that the DDR BIST based
 233  * version seems to be much faster.
 234  */
 235 #if (SOC_TYPE & QCA_AR933X_SOC)
 236
 237         #define DQS_DELAY_TAP_PATTERN_OFFSET    0x2000
 238         #define DQS_DELAY_TAP_PATTERN_SIZE              0x1000
 239         #define DQS_DELAY_TAP_TEST_LOOPS                2
 240
 241 /*
 242  * Prepare pattern for further tests
 243  */
 244 static inline void qca_ddr_tap_patt(void)
 245 {
 246         u32 i, j, pat;
 247         u32 *addr;
 248
 249         /* Prepare 4M (256 x 4 x 4 bytes) pattern */
 250         addr = (void *)KSEG1ADDR(DQS_DELAY_TAP_PATTERN_OFFSET);
 251
 252         for (i = 0; i < 256; i++) {
 253                 pat = 0;
 254
 255                 for (j = 0; j < 8; j++) {
 256                         if (i & (1 << j)) {
 257                                 if (j % 2)
 258                                         pat |= 0xFFFF0000;
 259                                 else
 260                                         pat |= 0x0000FFFF;
 261                         }
 262
 263                         if (j % 2) {
 264                                 *addr++ = pat;
 265                                 pat = 0;
 266                         }
 267                 }
 268         }
 269 }
 270
 271 /*
 272  * This function is a modified C version of the original
 273  * ar933x_ddr_tap_init() function, written in asm,
 274  * included in Atheros (Q)SDK code.
 275  *
 276  * Below is a modified version, partially based on:
 277  * https://patchwork.ozlabs.org/patch/569046/
 278  */
 279 static void qca_ddr_tap_tune(u32 ddr_width)
 280 {
 281         u32 *addr, *addr_k0, *addr_k1;
 282         u32 tap, tap_hi, tap_lo;
 283         u32 err, got_lo, i;
 284
 285         /* Pattern */
 286         qca_ddr_tap_patt();
 287
 288         got_lo = 0;
 289         tap_hi = 0;
 290         tap_lo = 0;
 291
 292         addr = (void *)KSEG1ADDR(DQS_DELAY_TAP_PATTERN_OFFSET
 293                                                          + DQS_DELAY_TAP_PATTERN_SIZE);
 294
 295         /*
 296          * Idea here is to test all possible tap values, one by one,
 297          * starting from the lowest. We are looking for a range within
 298          * the written and read back data is the same. We assume here
 299          * that the valid tap range is continuous.
 300          *
 301          * From hardware POV, delay tap controller is used to adjust
 302          * the data window.
 303          */
 304         for (tap = 0; tap <= DQS_DELAY_TAP_MAX_VAL; tap++) {
 305                 qca_ddr_tap_save(tap, ddr_width);
 306
 307                 err = 0;
 308
 309                 for (i = 0; i < DQS_DELAY_TAP_TEST_LOOPS; i++) {
 310                         addr_k1 = (void *)KSEG1ADDR(DQS_DELAY_TAP_PATTERN_OFFSET);
 311                         addr_k0 = (void *)KSEG0ADDR(DQS_DELAY_TAP_PATTERN_OFFSET);
 312
 313                         while (addr_k1 < addr) {
 314                                 if (*addr_k1++ != *addr_k0++) {
 315                                         err = 1;
 316                                         break;
 317                                 }
 318                         }
 319
 320                         if (err)
 321                                 break;
 322                 }
 323
 324                 if (err) {
 325                         if (got_lo) {
 326                                 if (tap > 0)
 327                                         tap_hi = tap - 1;
 328
 329                                 break;
 330                         }
 331                 } else {
 332                         if (!got_lo) {
 333                                 tap_lo = tap;
 334                                 got_lo = 1;
 335                         } else {
 336                                 tap_hi = tap;
 337                         }
 338                 }
 339         }
 340
 341         /* Calculate final tap value (rounded up average) */
 342         if (got_lo) {
 343                 tap = (tap_hi + tap_lo + 1) / 2;
 344         } else {
 345                 tap = DQS_DELAY_TAP_DEFAULT_VAL;
 346         }
 347
 348         qca_ddr_tap_save(tap, ddr_width);
 349 }
 350
 351 #else /* SOC_TYPE & QCA_AR933X_SOC */
 352
 353         #define DQS_DELAY_TAP_TEST_LOOPS        8
 354
 355 /*
 356  * Unknown magic values and registers from Atheros (Q)SDK.
 357  *
 358  * It looks like some test patterns and masks setup,
 359  * but it's not confirmed. Used here values are
 360  * different, but were tested on real hardware.
 361  */
 362 static inline void qca_ddr_tap_bist_init(void)
 363 {
 364         qca_soc_reg_write(QCA_DDR_PERF_COMP_AHB_GE0_0_REG, 0xAAAAAAAA);
 365         qca_soc_reg_write(QCA_DDR_PERF_MASK_AHB_GE0_0_REG, 0xAAAAAAAA);
 366
 367         qca_soc_reg_write(QCA_DDR_PERF_COMP_AHB_GE0_1_REG, 0x55555555);
 368         qca_soc_reg_write(QCA_DDR_PERF_MASK_AHB_GE0_1_REG, 0x55555555);
 369
 370         qca_soc_reg_write(QCA_DDR_PERF_COMP_AHB_GE1_0_REG, 0xAAAAAAAA);
 371         qca_soc_reg_write(QCA_DDR_PERF_MASK_AHB_GE1_0_REG, 0xAAAAAAAA);
 372
 373         qca_soc_reg_write(QCA_DDR_PERF_COMP_AHB_GE1_1_REG, 0x55555555);
 374         qca_soc_reg_write(QCA_DDR_PERF_MASK_AHB_GE1_1_REG, 0x55555555);
 375 }
 376
 377 /*
 378  * This function is a modified C version of the original
 379  * ath_ddr_tap_cal() function, written in asm,
 380  * included in Atheros (Q)SDK code.
 381  *
 382  * It seems that newer QC/A WiSoCs have some kind of
 383  * built-in self-test (BIST) for DDR controller, but
 384  * none of the used registers or their values are
 385  * described in datasheets, so for now, we will just
 386  * use them as in original code.
 387  *
 388  * Below is a modified version, partially based on:
 389  * https://patchwork.ozlabs.org/patch/569047/
 390  */
 391 static void qca_ddr_tap_tune(u32 ddr_width)
 392 {
 393         u32 tap, tap_hi, tap_lo;
 394         u32 fail, got_lo, reg;
 395
 396         got_lo = 0;
 397         tap_hi = 0;
 398         tap_lo = 0;
 399
 400         /* How many test loops per tested tap value */
 401         qca_soc_reg_write(QCA_DDR_PERF_COMP_ADDR_1_REG,
 402                                           (DQS_DELAY_TAP_TEST_LOOPS
 403                                            << QCA_DDR_PERF_COMP_ADDR_1_TEST_CNT_SHIFT));
 404
 405         /*
 406          * Unknown magic value, original comment:
 407          * "4 Row Address Bits, 4 Column Address Bits, 2 BA bits"
 408          */
 409         qca_soc_reg_write(QCA_DDR_PERF_MASK_ADDR_0_REG, 0xFA5DE83F);
 410
 411         /*
 412          * Test all possible tap values, try to find working range
 413          * (minimum and maximum delays) and use average value
 414          */
 415         for (tap = 0; tap <= DQS_DELAY_TAP_MAX_VAL; tap++) {
 416                 qca_ddr_tap_save(tap, ddr_width);
 417
 418                 qca_ddr_tap_bist_init();
 419
 420                 /* Enable BIST test and wait for finish */
 421                 qca_soc_reg_write(QCA_DDR_BIST_REG, QCA_DDR_BIST_TEST_EN_MASK);
 422
 423                 do {
 424                         reg = qca_soc_reg_read(QCA_DDR_BIST_STATUS_REG);
 425                 } while (!(reg & QCA_DDR_BIST_STATUS_DONE_MASK));
 426
 427                 /* Disable BIST test */
 428                 qca_soc_reg_write(QCA_DDR_BIST_REG, 0);
 429
 430                 /* Check how many tests failed */
 431                 fail = (reg & QCA_DDR_BIST_STATUS_FAIL_CNT_MASK)
 432                            >> QCA_DDR_BIST_STATUS_FAIL_CNT_SHIFT;
 433
 434                 if (fail == 0) {
 435                         if (!got_lo) {
 436                                 tap_lo = tap;
 437                                 got_lo = 1;
 438                         } else {
 439                                 tap_hi = tap;
 440                         }
 441                 } else {
 442                         if (got_lo) {
 443                                 if (tap > 0)
 444                                         tap_hi = tap - 1;
 445
 446                                 break;
 447                         }
 448                 }
 449         }
 450
 451         /* Calculate final tap value (rounded up average) */
 452         if (got_lo) {
 453                 tap = (tap_hi + tap_lo + 1) / 2;
 454         } else {
 455                 tap = DQS_DELAY_TAP_DEFAULT_VAL;
 456         }
 457
 458         qca_ddr_tap_save(tap, ddr_width);
 459 }
 460
 461 #endif /* SOC_TYPE & QCA_AR933X_SOC */
 462
 463 /*
 464  * ===============================================
 465  * DDR controller initialization related functions
 466  * ===============================================
 467  */
 468
 469 /*
 470  * Below defines are "safe" DDR1/DDR2 timing parameters.
 471  * They should work for most chips, but not for all.
 472  *
 473  * For different values, user can define target value
 474  * of all memory controller related registers.
 475  *
 476  */
 477 #define DDRx_tMRD_ns    10
 478 #define DDRx_tRAS_ns    40
 479 #define DDRx_tRCD_ns    15
 480 #define DDRx_tRP_ns             15
 481 #define DDRx_tRRD_ns    10
 482 #define DDRx_tWR_ns             15
 483 #define DDRx_tWTR_ns    10
 484
 485 #define DDR1_tRFC_ns    75
 486 #define DDR2_tRFC_ns    120
 487
 488 #define DDR2_tFAW_ns    50
 489 #define DDR2_tWL_ns             5
 490
 491 #define DDR_addit_lat   0
 492 #define DDR_burst_len   8
 493
 494 /* All above values are safe for clocks not lower than below values */
 495 #define DDR1_timing_clk_max             400
 496 #define DDR2_timing_clk_max             533
 497
 498 /* Maximum timing values, based on register fields sizes */
 499 #define MAX_tFAW                BITS(0, 6)
 500 #define MAX_tMRD                BITS(0, 4)
 501 #define MAX_tRAS                BITS(0, 5)
 502 #define MAX_tRCD                BITS(0, 4)
 503 #define MAX_tRFC                BITS(0, 6)
 504 #define MAX_tRP                 BITS(0, 4)
 505 #define MAX_tRRD                BITS(0, 4)
 506 #define MAX_tRTP                BITS(0, 4)
 507 #define MAX_tRTW                BITS(0, 5)
 508 #define MAX_tWL                 BITS(0, 4)
 509 #define MAX_tWR                 BITS(0, 4)
 510 #define MAX_tWTR                BITS(0, 5)
 511
 512 /*
 513  * Setup DDR_CONFIG register
 514  */
 515 static inline void qca_dram_set_ddr_cfg(u32 mem_cas,
 516                                                                                 u32 ddr_clk,
 517                                                                                 u32 mem_type)
 518 {
 519 #ifndef CONFIG_QCA_DDR_CFG_REG_VAL
 520         u32 reg = 0;
 521         u32 tmp = 0;
 522
 523         reg = qca_soc_reg_read(QCA_DDR_CFG_REG);
 524
 525         /* Always use page close policy */
 526         reg = reg | QCA_DDR_CFG_PAGE_CLOSE_MASK;
 527
 528         /* CAS should be (2 * MEM_CAS) or (2 * MEM_CAS) + 1/2/3 */
 529         tmp = 2 * mem_cas;
 530         tmp = (tmp << QCA_DDR_CFG_CAS_3LSB_SHIFT) & QCA_DDR_CFG_CAS_3LSB_MASK;
 531         if (mem_cas > 3) {
 532                 tmp = tmp | QCA_DDR_CFG_CAS_MSB_MASK;
 533         }
 534
 535         reg = reg & ~QCA_DDR_CFG_CAS_3LSB_MASK;
 536         reg = reg | tmp;
 537
 538         /*
 539          * Calculate rest of timing related values,
 540          * always round up to closest integer
 541          */
 542
 543         /* tMRD */
 544         tmp = ((DDRx_tMRD_ns * ddr_clk) + 500) / 1000;
 545         if (tmp > MAX_tMRD)
 546                 tmp = MAX_tMRD;
 547
 548         tmp = (tmp << QCA_DDR_CFG_TMRD_SHIFT) & QCA_DDR_CFG_TMRD_MASK;
 549         reg = reg & ~QCA_DDR_CFG_TMRD_MASK;
 550         reg = reg | tmp;
 551
 552         /* tRFC */
 553         if (mem_type == RAM_MEMORY_TYPE_DDR2) {
 554                 tmp = ((DDR2_tRFC_ns * ddr_clk) + 500) / 1000;
 555         } else {
 556                 tmp = ((DDR1_tRFC_ns * ddr_clk) + 500) / 1000;
 557         }
 558
 559         if (tmp > MAX_tRFC)
 560                 tmp = MAX_tRFC;
 561
 562         tmp = (tmp << QCA_DDR_CFG_TRFC_SHIFT) & QCA_DDR_CFG_TRFC_MASK;
 563         reg = reg & ~QCA_DDR_CFG_TRFC_MASK;
 564         reg = reg | tmp;
 565
 566         /* tRRD */
 567         tmp = ((DDRx_tRRD_ns * ddr_clk) + 500) / 1000;
 568         if (tmp > MAX_tRRD)
 569                 tmp = MAX_tRRD;
 570
 571         tmp = (tmp << QCA_DDR_CFG_TRRD_SHIFT) & QCA_DDR_CFG_TRRD_MASK;
 572         reg = reg & ~QCA_DDR_CFG_TRRD_MASK;
 573         reg = reg | tmp;
 574
 575         /* tRP */
 576         tmp = ((DDRx_tRP_ns * ddr_clk) + 500) / 1000;
 577         if (tmp > MAX_tRP)
 578                 tmp = MAX_tRP;
 579
 580         tmp = (tmp << QCA_DDR_CFG_TRP_SHIFT) & QCA_DDR_CFG_TRP_MASK;
 581         reg = reg & ~QCA_DDR_CFG_TRP_MASK;
 582         reg = reg | tmp;
 583
 584         /* tRCD */
 585         tmp = ((DDRx_tRCD_ns * ddr_clk) + 500) / 1000;
 586         if (tmp > MAX_tRCD)
 587                 tmp = MAX_tRCD;
 588
 589         tmp = (tmp << QCA_DDR_CFG_TRCD_SHIFT) & QCA_DDR_CFG_TRCD_MASK;
 590         reg = reg & ~QCA_DDR_CFG_TRCD_MASK;
 591         reg = reg | tmp;
 592
 593         /* tRAS */
 594         tmp = ((DDRx_tRAS_ns * ddr_clk) + 500) / 1000;
 595         if (tmp > MAX_tRAS)
 596                 tmp = MAX_tRAS;
 597
 598         tmp = (tmp << QCA_DDR_CFG_TRAS_SHIFT) & QCA_DDR_CFG_TRAS_MASK;
 599         reg = reg & ~QCA_DDR_CFG_TRAS_MASK;
 600         reg = reg | tmp;
 601
 602         qca_soc_reg_write(QCA_DDR_CFG_REG, reg);
 603 #else
 604         qca_soc_reg_write(QCA_DDR_CFG_REG, CONFIG_QCA_DDR_CFG_REG_VAL);
 605 #endif
 606 }
 607
 608 /*
 609  * Setup DDR_CONFIG2 register
 610  */
 611 static inline void qca_dram_set_ddr_cfg2(u32 mem_cas,
 612                                                                                  u32 ddr_clk,
 613                                                                                  u32 mem_type,
 614                                                                                  u32 ddr_width)
 615 {
 616 #ifndef CONFIG_QCA_DDR_CFG2_REG_VAL
 617         u32 reg = 0;
 618         u32 tmp = 0;
 619
 620         reg = qca_soc_reg_read(QCA_DDR_CFG2_REG);
 621
 622         /* Enable CKE */
 623         reg = reg | QCA_DDR_CFG2_CKE_MASK;
 624
 625         /* Gate open latency = 2 * MEM_CAS */
 626         tmp = 2 * mem_cas;
 627         tmp = (tmp << QCA_DDR_CFG2_GATE_OPEN_LATENCY_SHIFT)
 628                   & QCA_DDR_CFG2_GATE_OPEN_LATENCY_MASK;
 629         reg = reg & ~QCA_DDR_CFG2_GATE_OPEN_LATENCY_MASK;
 630         reg = reg | tmp;
 631
 632         /* tWTR */
 633         if (mem_type == RAM_MEMORY_TYPE_DDR2) {
 634                 /* tWTR = 2 * WL + BL + 2 * max(tWTR/tCK, 2) */
 635                 tmp = 2 * (mem_cas + DDR_addit_lat - 1) + DDR_burst_len + 4;
 636
 637                 if (ddr_clk >= 600)
 638                         tmp = tmp + 2;
 639         } else {
 640                 /* tWTR = 2 + BL + (2 * tWTR/tCK) */
 641                 tmp = 2 + DDR_burst_len + (((DDRx_tWTR_ns * ddr_clk) + 500) / 1000);
 642         }
 643
 644         if (tmp > MAX_tWTR)
 645                 tmp = MAX_tWTR;
 646
 647         tmp = (tmp << QCA_DDR_CFG2_TWTR_SHIFT) & QCA_DDR_CFG2_TWTR_MASK;
 648         reg = reg & ~QCA_DDR_CFG2_TWTR_MASK;
 649         reg = reg | tmp;
 650
 651         /* tRTP */
 652         if (ddr_width == 32) {
 653                 tmp = DDR_burst_len;
 654         } else {
 655                 tmp = MAX_tRTP;
 656         }
 657
 658         tmp = (tmp << QCA_DDR_CFG2_TRTP_SHIFT) & QCA_DDR_CFG2_TRTP_MASK;
 659         reg = reg & ~QCA_DDR_CFG2_TRTP_MASK;
 660         reg = reg | tmp;
 661
 662         /* tRTW */
 663         if (mem_type == RAM_MEMORY_TYPE_DDR2) {
 664                 /* tRTW = 2 * (RL + BL/2 + 1 -WL), RL = CL + AL, WL = RL - 1 */
 665                 tmp = DDR_burst_len + 4;
 666         } else {
 667                 /* tRTW = 2 * (CL + BL/2) */
 668                 tmp = DDR_burst_len + (2 * mem_cas);
 669         }
 670
 671         if (tmp > MAX_tRTW)
 672                 tmp = MAX_tRTW;
 673
 674         tmp = (tmp << QCA_DDR_CFG2_TRTW_SHIFT) & QCA_DDR_CFG2_TRTW_MASK;
 675         reg = reg & ~QCA_DDR_CFG2_TRTW_MASK;
 676         reg = reg | tmp;
 677
 678         /* tWR */
 679         tmp = ((DDRx_tWR_ns * ddr_clk) + 500) / 1000;
 680         if (tmp > MAX_tWR)
 681                 tmp = MAX_tWR;
 682
 683         tmp = (tmp << QCA_DDR_CFG2_TWR_SHIFT) & QCA_DDR_CFG2_TWR_MASK;
 684         reg = reg & ~QCA_DDR_CFG2_TWR_MASK;
 685         reg = reg | tmp;
 686
 687         /* Always use burst length = 8 and type: sequential */
 688         tmp = (DDR_burst_len << QCA_DDR_CFG2_BURST_LEN_SHIFT)
 689                   & QCA_DDR_CFG2_BURST_LEN_MASK;
 690         reg = reg & ~(QCA_DDR_CFG2_BURST_LEN_MASK
 691                                   | QCA_DDR_CFG2_BURST_TYPE_MASK);
 692         reg = reg | tmp;
 693
 694         qca_soc_reg_write(QCA_DDR_CFG2_REG, reg);
 695 #else
 696         qca_soc_reg_write(QCA_DDR_CFG2_REG, CONFIG_QCA_DDR_CFG2_REG_VAL);
 697 #endif
 698 }
 699
 700 /*
 701  * Setup DDR2_CONFIG register (only for DDR2)
 702  */
 703 static inline void qca_dram_set_ddr2_cfg(u32 mem_cas,
 704                                                                                  u32 ddr_clk)
 705 {
 706 #ifndef CONFIG_QCA_DDR_DDR2_CFG_REG_VAL
 707         u32 reg = 0;
 708         u32 tmp = 0;
 709
 710         reg = qca_soc_reg_read(QCA_DDR_DDR2_CFG_REG);
 711
 712         /* Enable DDR2 */
 713         reg = reg | QCA_DDR_DDR2_CFG_DDR2_EN_MASK;
 714
 715         /* tFAW */
 716         tmp = ((DDR2_tFAW_ns * ddr_clk) + 500) / 1000;
 717         if (tmp > MAX_tFAW)
 718                 tmp = MAX_tFAW;
 719
 720         tmp = (tmp << QCA_DDR_DDR2_CFG_DDR2_TFAW_SHIFT)
 721                   & QCA_DDR_DDR2_CFG_DDR2_TFAW_MASK;
 722         reg = reg & ~QCA_DDR_DDR2_CFG_DDR2_TFAW_MASK;
 723         reg = reg | tmp;
 724
 725         /* tWL */
 726         tmp = (2 * mem_cas) - 3;
 727
 728         /* For some reason, odd value doesn't work on AR933x (FIXME) */
 729         #if (SOC_TYPE & QCA_AR933X_SOC)
 730         if (tmp % 2)
 731                 tmp = tmp - 1;
 732         #endif
 733
 734         tmp = (tmp << QCA_DDR_DDR2_CFG_DDR2_TWL_SHIFT)
 735                   & QCA_DDR_DDR2_CFG_DDR2_TWL_MASK;
 736         reg = reg & ~QCA_DDR_DDR2_CFG_DDR2_TWL_MASK;
 737         reg = reg | tmp;
 738
 739         qca_soc_reg_write(QCA_DDR_DDR2_CFG_REG, reg);
 740 #else
 741         qca_soc_reg_write(QCA_DDR_DDR2_CFG_REG, CONFIG_QCA_DDR_DDR2_CFG_REG_VAL);
 742 #endif
 743 }
 744
 745 /*
 746  * Enables DDR refresh and sets
 747  * refresh period based on XTAL
 748  */
 749 static inline void qca_dram_set_en_refresh(void)
 750 {
 751         /*
 752          * Enable DDR refresh and setup refresh period:
 753          * 1. We assume 7.8 us maximum average period refresh interval
 754          * 2. 7.8 us ~= 0.1282 MHz
 755          * 3. For 25 MHz XTAL: (25 / 0.1282) ~= 195
 756          * 4. For 40 MHz XTAL: (40 / 0.1282) ~= 312
 757          */
 758         if (qca_xtal_is_40mhz()) {
 759                 qca_soc_reg_write(QCA_DDR_REFRESH_REG,
 760                                                   QCA_DDR_REFRESH_EN_MASK
 761                                                   | (312 << QCA_DDR_REFRESH_PERIOD_SHIFT));
 762         } else {
 763                 qca_soc_reg_write(QCA_DDR_REFRESH_REG,
 764                                                   QCA_DDR_REFRESH_EN_MASK
 765                                                   | (195 << QCA_DDR_REFRESH_PERIOD_SHIFT));
 766         }
 767 }
 768
 769 /*
 770  * Initial DRAM configuration
 771  */
 772 void qca_dram_init(void)
 773 {
 774         u32 ahb_clk, cpu_clk, ddr_clk, mem_type, tmp_clk;
 775         u32 cas_lat, ddr_width, reg, tmp, wr_recovery;
 776
 777         mem_type = qca_dram_type();
 778
 779         qca_sys_clocks(&cpu_clk, &ddr_clk, &ahb_clk, NULL, NULL);
 780         cpu_clk = cpu_clk / 1000000;
 781         ddr_clk = ddr_clk / 1000000;
 782         ahb_clk = ahb_clk / 1000000;
 783
 784         /* Set CAS based on clock, but allow to set static value */
 785 #ifndef CONFIG_BOARD_DRAM_CAS_LATENCY
 786         if (mem_type == RAM_MEMORY_TYPE_DDR1) {
 787                 if (ddr_clk <= 266) {
 788                         cas_lat = 2;
 789                 } else {
 790                         cas_lat = 3;
 791                 }
 792         } else {
 793                 if (ddr_clk <= 400) {
 794                         cas_lat = 3;
 795                 } else if (ddr_clk <= 533) {
 796                         cas_lat = 4;
 797                 } else if (ddr_clk <= 666) {
 798                         cas_lat = 5;
 799                 } else if (ddr_clk <= 800) {
 800                         cas_lat = 6;
 801                 } else {
 802                         cas_lat = 7;
 803                 }
 804         }
 805 #else
 806         cas_lat = CONFIG_BOARD_DRAM_CAS_LATENCY;
 807 #endif
 808
 809 #if (SOC_TYPE & QCA_AR933X_SOC)
 810         /* AR933x supports only 16-bit memory */
 811         ddr_width = 16;
 812         qca_soc_reg_write(QCA_DDR_RD_DATA_THIS_CYCLE_REG, 0xFF);
 813 #else
 814         /* For other WiSoCs we can determine DDR width, based on bootstrap */
 815         ddr_width = qca_dram_ddr_width();
 816
 817         if (ddr_width == 32) {
 818                 /* For 32-bit clear HALF_WIDTH and set VEC = 0xFF */
 819                 qca_soc_reg_read_clear(QCA_DDR_CTRL_CFG_REG,
 820                                                            QCA_DDR_CTRL_CFG_HALF_WIDTH_MASK);
 821
 822                 qca_soc_reg_write(QCA_DDR_RD_DATA_THIS_CYCLE_REG, 0xFF);
 823         } else {
 824                 qca_soc_reg_read_set(QCA_DDR_CTRL_CFG_REG,
 825                                                          QCA_DDR_CTRL_CFG_HALF_WIDTH_MASK);
 826
 827                 qca_soc_reg_write(QCA_DDR_RD_DATA_THIS_CYCLE_REG, 0xFFFF);
 828         }
 829
 830         /* If DDR_CLK < 2 * AHB_CLK, set DDR FSM wait control to 0xA24 */
 831         if (ddr_clk < (2 * ahb_clk))
 832                 qca_soc_reg_write(QCA_DDR_FSM_WAIT_CTRL_REG, 0xA24);
 833 #endif
 834
 835         /*
 836          * CPU/DDR sync mode only when we don't use
 837          * fractional multipliers in PLL/clocks config
 838          */
 839         tmp = 0;
 840
 841 #if (SOC_TYPE & QCA_AR933X_SOC)
 842         reg = qca_soc_reg_read(QCA_PLL_CPU_PLL_DITHER_FRAC_REG);
 843         reg = (reg & QCA_PLL_CPU_PLL_DITHER_FRAC_NFRAC_MIN_MASK)
 844                   >> QCA_PLL_CPU_PLL_DITHER_FRAC_NFRAC_MIN_SHIFT;
 845
 846         if (reg)
 847                 tmp = 1;
 848 #else
 849         reg = qca_soc_reg_read(QCA_PLL_CPU_PLL_DITHER_REG);
 850         reg = (reg & QCA_PLL_CPU_PLL_DITHER_NFRAC_MIN_MASK)
 851                   >> QCA_PLL_CPU_PLL_DITHER_NFRAC_MIN_SHIFT;
 852
 853         if (reg)
 854                 tmp = 1;
 855
 856         reg = qca_soc_reg_read(QCA_PLL_DDR_PLL_DITHER_REG);
 857         reg = (reg & QCA_PLL_DDR_PLL_DITHER_NFRAC_MIN_MASK)
 858                   >> QCA_PLL_DDR_PLL_DITHER_NFRAC_MIN_SHIFT;
 859
 860         if (reg)
 861                 tmp = 1;
 862 #endif
 863
 864         if (!tmp && (cpu_clk == ddr_clk)) {
 865 #if (SOC_TYPE & QCA_AR933X_SOC)
 866                 qca_soc_reg_read_set(QCA_DDR_TAP_CTRL_3_REG, (1 << 8));
 867 #else
 868                 qca_soc_reg_read_set(QCA_DDR_CTRL_CFG_REG,
 869                                                          QCA_DDR_CTRL_CFG_CPU_DDR_SYNC_MASK);
 870 #endif
 871         } else {
 872 #if (SOC_TYPE & QCA_AR933X_SOC)
 873                 qca_soc_reg_read_clear(QCA_DDR_TAP_CTRL_3_REG, (1 << 8));
 874 #else
 875                 qca_soc_reg_read_clear(QCA_DDR_CTRL_CFG_REG,
 876                                                            QCA_DDR_CTRL_CFG_CPU_DDR_SYNC_MASK);
 877 #endif
 878         }
 879
 880         /* Check if clock is not too low for our "safe" timing values */
 881         tmp_clk = ddr_clk;
 882         if (mem_type == RAM_MEMORY_TYPE_DDR1) {
 883                 if (tmp_clk < DDR1_timing_clk_max)
 884                         tmp_clk = DDR1_timing_clk_max;
 885         } else {
 886                 if (tmp_clk < DDR2_timing_clk_max)
 887                         tmp_clk = DDR2_timing_clk_max;
 888         }
 889
 890         /* Enable DDR2 */
 891         if (mem_type == RAM_MEMORY_TYPE_DDR2) {
 892 #if (SOC_TYPE & QCA_AR933X_SOC)
 893                 qca_dram_set_ddr2_cfg(cas_lat, tmp_clk);
 894 #else
 895                 qca_soc_reg_write(QCA_DDR_CTRL_CFG_REG,
 896                                                   QCA_DDR_CTRL_CFG_PAD_DDR2_SEL_MASK);
 897
 898                 qca_dram_set_ddr2_cfg(cas_lat, tmp_clk);
 899 #endif
 900
 901         }
 902
 903         /* Setup DDR timing related registers */
 904         qca_dram_set_ddr_cfg(cas_lat, tmp_clk, mem_type);
 905         qca_dram_set_ddr_cfg2(cas_lat, tmp_clk, mem_type, ddr_width);
 906
 907         /* Precharge all */
 908         qca_dram_force_preall();
 909
 910         if (mem_type == RAM_MEMORY_TYPE_DDR2) {
 911                 /* Setup target EMR2 and EMR3 */
 912                 qca_dram_set_emr2(_ddr_sdram_emr2_val(0, 0, 0));
 913                 qca_dram_set_emr3(0);
 914         }
 915
 916         /* Enable and reset DLL */
 917         qca_dram_set_emr(_ddr_sdram_emr_val(0, 1, 0, 0, 0, 0));
 918         qca_dram_set_mr(_ddr_sdram_mr_val(0, 0, 1, 0));
 919
 920         /* Precharge all, 2x auto refresh */
 921         qca_dram_force_preall();
 922
 923         qca_dram_force_aref();
 924         qca_dram_force_aref();
 925
 926         if (mem_type == RAM_MEMORY_TYPE_DDR2) {
 927                 /* Setup target MR */
 928                 wr_recovery = ((DDRx_tWR_ns * tmp_clk) + 1000) / 2000;
 929                 qca_dram_set_mr(_ddr_sdram_mr_val(0, cas_lat, 0, wr_recovery));
 930
 931                 /* OCD calibration, target EMR (nDQS disable, weak strength) */
 932                 qca_dram_set_emr(
 933                         _ddr_sdram_emr_val(0, 1, DDR_SDRAM_EMR_OCD_DEFAULT_VAL, 1, 0, 0));
 934
 935                 qca_dram_set_emr(
 936                         _ddr_sdram_emr_val(0, 1, DDR_SDRAM_EMR_OCD_EXIT_VAL, 1, 0, 0));
 937         } else {
 938                 /* Setup target MR */
 939                 qca_dram_set_mr(_ddr_sdram_mr_val(0, cas_lat, 0, 0));
 940         }
 941
 942         /* Enable DDR refresh and setup refresh period */
 943         qca_dram_set_en_refresh();
 944
 945         /*
 946          * At this point memory should be fully configured,
 947          * so we can perform delay tap controller tune.
 948          */
 949         qca_ddr_tap_tune(ddr_width);
 950 }