arch/arm/cpu/armv7/mx6/ddr.c

   1 /*
   2  * Copyright (C) 2014 Gateworks Corporation
   3  * Author: Tim Harvey <tharvey@gateworks.com>
   4  *
   5  * SPDX-License-Identifier:     GPL-2.0+
   6  */
   7
   8 #include <common.h>
   9 #include <linux/types.h>
  10 #include <asm/arch/clock.h>
  11 #include <asm/arch/mx6-ddr.h>
  12 #include <asm/arch/sys_proto.h>
  13 #include <asm/io.h>
  14 #include <asm/types.h>
  15 #include <wait_bit.h>
  16
  17 #if defined(CONFIG_MX6QDL) || defined(CONFIG_MX6Q) || defined(CONFIG_MX6D)
  18
  19 static void reset_read_data_fifos(void)
  20 {
  21         struct mmdc_p_regs *mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
  22
  23         /* Reset data FIFOs twice. */
  24         setbits_le32(&mmdc0->mpdgctrl0, 1 << 31);
  25         wait_for_bit("MMDC", &mmdc0->mpdgctrl0, 1 << 31, 0, 100, 0);
  26
  27         setbits_le32(&mmdc0->mpdgctrl0, 1 << 31);
  28         wait_for_bit("MMDC", &mmdc0->mpdgctrl0, 1 << 31, 0, 100, 0);
  29 }
  30
  31 static void precharge_all(const bool cs0_enable, const bool cs1_enable)
  32 {
  33         struct mmdc_p_regs *mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
  34
  35         /*
  36          * Issue the Precharge-All command to the DDR device for both
  37          * chip selects. Note, CON_REQ bit should also remain set. If
  38          * only using one chip select, then precharge only the desired
  39          * chip select.
  40          */
  41         if (cs0_enable) { /* CS0 */
  42                 writel(0x04008050, &mmdc0->mdscr);
  43                 wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 1, 100, 0);
  44         }
  45
  46         if (cs1_enable) { /* CS1 */
  47                 writel(0x04008058, &mmdc0->mdscr);
  48                 wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 1, 100, 0);
  49         }
  50 }
  51
  52 static void force_delay_measurement(int bus_size)
  53 {
  54         struct mmdc_p_regs *mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
  55         struct mmdc_p_regs *mmdc1 = (struct mmdc_p_regs *)MMDC_P1_BASE_ADDR;
  56
  57         writel(0x800, &mmdc0->mpmur0);
  58         if (bus_size == 0x2)
  59                 writel(0x800, &mmdc1->mpmur0);
  60 }
  61
  62 static void modify_dg_result(u32 *reg_st0, u32 *reg_st1, u32 *reg_ctrl)
  63 {
  64         u32 dg_tmp_val, dg_dl_abs_offset, dg_hc_del, val_ctrl;
  65
  66         /*
  67          * DQS gating absolute offset should be modified from reflecting
  68          * (HW_DG_LOWx + HW_DG_UPx)/2 to reflecting (HW_DG_UPx - 0x80)
  69          */
  70
  71         val_ctrl = readl(reg_ctrl);
  72         val_ctrl &= 0xf0000000;
  73
  74         dg_tmp_val = ((readl(reg_st0) & 0x07ff0000) >> 16) - 0xc0;
  75         dg_dl_abs_offset = dg_tmp_val & 0x7f;
  76         dg_hc_del = (dg_tmp_val & 0x780) << 1;
  77
  78         val_ctrl |= dg_dl_abs_offset + dg_hc_del;
  79
  80         dg_tmp_val = ((readl(reg_st1) & 0x07ff0000) >> 16) - 0xc0;
  81         dg_dl_abs_offset = dg_tmp_val & 0x7f;
  82         dg_hc_del = (dg_tmp_val & 0x780) << 1;
  83
  84         val_ctrl |= (dg_dl_abs_offset + dg_hc_del) << 16;
  85
  86         writel(val_ctrl, reg_ctrl);
  87 }
  88
  89 int mmdc_do_write_level_calibration(void)
  90 {
  91         struct mmdc_p_regs *mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
  92         struct mmdc_p_regs *mmdc1 = (struct mmdc_p_regs *)MMDC_P1_BASE_ADDR;
  93         u32 esdmisc_val, zq_val;
  94         u32 errors = 0;
  95         u32 ldectrl[4];
  96         u32 ddr_mr1 = 0x4;
  97
  98         /*
  99          * Stash old values in case calibration fails,
 100          * we need to restore them
 101          */
 102         ldectrl[0] = readl(&mmdc0->mpwldectrl0);
 103         ldectrl[1] = readl(&mmdc0->mpwldectrl1);
 104         ldectrl[2] = readl(&mmdc1->mpwldectrl0);
 105         ldectrl[3] = readl(&mmdc1->mpwldectrl1);
 106
 107         /* disable DDR logic power down timer */
 108         clrbits_le32(&mmdc0->mdpdc, 0xff00);
 109
 110         /* disable Adopt power down timer */
 111         setbits_le32(&mmdc0->mapsr, 0x1);
 112
 113         debug("Starting write leveling calibration.\n");
 114
 115         /*
 116          * 2. disable auto refresh and ZQ calibration
 117          * before proceeding with Write Leveling calibration
 118          */
 119         esdmisc_val = readl(&mmdc0->mdref);
 120         writel(0x0000C000, &mmdc0->mdref);
 121         zq_val = readl(&mmdc0->mpzqhwctrl);
 122         writel(zq_val & ~0x3, &mmdc0->mpzqhwctrl);
 123
 124         /* 3. increase walat and ralat to maximum */
 125         setbits_le32(&mmdc0->mdmisc,
 126                      (1 << 6) | (1 << 7) | (1 << 8) | (1 << 16) | (1 << 17));
 127         setbits_le32(&mmdc1->mdmisc,
 128                      (1 << 6) | (1 << 7) | (1 << 8) | (1 << 16) | (1 << 17));
 129         /*
 130          * 4 & 5. Configure the external DDR device to enter write-leveling
 131          * mode through Load Mode Register command.
 132          * Register setting:
 133          * Bits[31:16] MR1 value (0x0080 write leveling enable)
 134          * Bit[9] set WL_EN to enable MMDC DQS output
 135          * Bits[6:4] set CMD bits for Load Mode Register programming
 136          * Bits[2:0] set CMD_BA to 0x1 for DDR MR1 programming
 137          */
 138         writel(0x00808231, &mmdc0->mdscr);
 139
 140         /* 6. Activate automatic calibration by setting MPWLGCR[HW_WL_EN] */
 141         writel(0x00000001, &mmdc0->mpwlgcr);
 142
 143         /*
 144          * 7. Upon completion of this process the MMDC de-asserts
 145          * the MPWLGCR[HW_WL_EN]
 146          */
 147         wait_for_bit("MMDC", &mmdc0->mpwlgcr, 1 << 0, 0, 100, 0);
 148
 149         /*
 150          * 8. check for any errors: check both PHYs for x64 configuration,
 151          * if x32, check only PHY0
 152          */
 153         if (readl(&mmdc0->mpwlgcr) & 0x00000F00)
 154                 errors |= 1;
 155         if (readl(&mmdc1->mpwlgcr) & 0x00000F00)
 156                 errors |= 2;
 157
 158         debug("Ending write leveling calibration. Error mask: 0x%x\n", errors);
 159
 160         /* check to see if cal failed */
 161         if ((readl(&mmdc0->mpwldectrl0) == 0x001F001F) &&
 162             (readl(&mmdc0->mpwldectrl1) == 0x001F001F) &&
 163             (readl(&mmdc1->mpwldectrl0) == 0x001F001F) &&
 164             (readl(&mmdc1->mpwldectrl1) == 0x001F001F)) {
 165                 debug("Cal seems to have soft-failed due to memory not supporting write leveling on all channels. Restoring original write leveling values.\n");
 166                 writel(ldectrl[0], &mmdc0->mpwldectrl0);
 167                 writel(ldectrl[1], &mmdc0->mpwldectrl1);
 168                 writel(ldectrl[2], &mmdc1->mpwldectrl0);
 169                 writel(ldectrl[3], &mmdc1->mpwldectrl1);
 170                 errors |= 4;
 171         }
 172
 173         /*
 174          * User should issue MRS command to exit write leveling mode
 175          * through Load Mode Register command
 176          * Register setting:
 177          * Bits[31:16] MR1 value "ddr_mr1" value from initialization
 178          * Bit[9] clear WL_EN to disable MMDC DQS output
 179          * Bits[6:4] set CMD bits for Load Mode Register programming
 180          * Bits[2:0] set CMD_BA to 0x1 for DDR MR1 programming
 181          */
 182         writel((ddr_mr1 << 16) + 0x8031, &mmdc0->mdscr);
 183
 184         /* re-enable auto refresh and zq cal */
 185         writel(esdmisc_val, &mmdc0->mdref);
 186         writel(zq_val, &mmdc0->mpzqhwctrl);
 187
 188         debug("\tMMDC_MPWLDECTRL0 after write level cal: 0x%08X\n",
 189               readl(&mmdc0->mpwldectrl0));
 190         debug("\tMMDC_MPWLDECTRL1 after write level cal: 0x%08X\n",
 191               readl(&mmdc0->mpwldectrl1));
 192         debug("\tMMDC_MPWLDECTRL0 after write level cal: 0x%08X\n",
 193               readl(&mmdc1->mpwldectrl0));
 194         debug("\tMMDC_MPWLDECTRL1 after write level cal: 0x%08X\n",
 195               readl(&mmdc1->mpwldectrl1));
 196
 197         /* We must force a readback of these values, to get them to stick */
 198         readl(&mmdc0->mpwldectrl0);
 199         readl(&mmdc0->mpwldectrl1);
 200         readl(&mmdc1->mpwldectrl0);
 201         readl(&mmdc1->mpwldectrl1);
 202
 203         /* enable DDR logic power down timer: */
 204         setbits_le32(&mmdc0->mdpdc, 0x00005500);
 205
 206         /* Enable Adopt power down timer: */
 207         clrbits_le32(&mmdc0->mapsr, 0x1);
 208
 209         /* Clear CON_REQ */
 210         writel(0, &mmdc0->mdscr);
 211
 212         return errors;
 213 }
 214
 215 int mmdc_do_dqs_calibration(void)
 216 {
 217         struct mmdc_p_regs *mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
 218         struct mmdc_p_regs *mmdc1 = (struct mmdc_p_regs *)MMDC_P1_BASE_ADDR;
 219         struct mx6dq_iomux_ddr_regs *mx6_ddr_iomux =
 220                 (struct mx6dq_iomux_ddr_regs *)MX6DQ_IOM_DDR_BASE;
 221         bool cs0_enable;
 222         bool cs1_enable;
 223         bool cs0_enable_initial;
 224         bool cs1_enable_initial;
 225         u32 esdmisc_val;
 226         u32 bus_size;
 227         u32 temp_ref;
 228         u32 pddword = 0x00ffff00; /* best so far, place into MPPDCMPR1 */
 229         u32 errors = 0;
 230         u32 initdelay = 0x40404040;
 231
 232         /* check to see which chip selects are enabled */
 233         cs0_enable_initial = readl(&mmdc0->mdctl) & 0x80000000;
 234         cs1_enable_initial = readl(&mmdc0->mdctl) & 0x40000000;
 235
 236         /* disable DDR logic power down timer: */
 237         clrbits_le32(&mmdc0->mdpdc, 0xff00);
 238
 239         /* disable Adopt power down timer: */
 240         setbits_le32(&mmdc0->mapsr, 0x1);
 241
 242         /* set DQS pull ups */
 243         setbits_le32(&mx6_ddr_iomux->dram_sdqs0, 0x7000);
 244         setbits_le32(&mx6_ddr_iomux->dram_sdqs1, 0x7000);
 245         setbits_le32(&mx6_ddr_iomux->dram_sdqs2, 0x7000);
 246         setbits_le32(&mx6_ddr_iomux->dram_sdqs3, 0x7000);
 247         setbits_le32(&mx6_ddr_iomux->dram_sdqs4, 0x7000);
 248         setbits_le32(&mx6_ddr_iomux->dram_sdqs5, 0x7000);
 249         setbits_le32(&mx6_ddr_iomux->dram_sdqs6, 0x7000);
 250         setbits_le32(&mx6_ddr_iomux->dram_sdqs7, 0x7000);
 251
 252         /* Save old RALAT and WALAT values */
 253         esdmisc_val = readl(&mmdc0->mdmisc);
 254
 255         setbits_le32(&mmdc0->mdmisc,
 256                      (1 << 6) | (1 << 7) | (1 << 8) | (1 << 16) | (1 << 17));
 257
 258         /* Disable auto refresh before proceeding with calibration */
 259         temp_ref = readl(&mmdc0->mdref);
 260         writel(0x0000c000, &mmdc0->mdref);
 261
 262         /*
 263          * Per the ref manual, issue one refresh cycle MDSCR[CMD]= 0x2,
 264          * this also sets the CON_REQ bit.
 265          */
 266         if (cs0_enable_initial)
 267                 writel(0x00008020, &mmdc0->mdscr);
 268         if (cs1_enable_initial)
 269                 writel(0x00008028, &mmdc0->mdscr);
 270
 271         /* poll to make sure the con_ack bit was asserted */
 272         wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 1, 100, 0);
 273
 274         /*
 275          * Check MDMISC register CALIB_PER_CS to see which CS calibration
 276          * is targeted to (under normal cases, it should be cleared
 277          * as this is the default value, indicating calibration is directed
 278          * to CS0).
 279          * Disable the other chip select not being target for calibration
 280          * to avoid any potential issues.  This will get re-enabled at end
 281          * of calibration.
 282          */
 283         if ((readl(&mmdc0->mdmisc) & 0x00100000) == 0)
 284                 clrbits_le32(&mmdc0->mdctl, 1 << 30);   /* clear SDE_1 */
 285         else
 286                 clrbits_le32(&mmdc0->mdctl, 1 << 31);   /* clear SDE_0 */
 287
 288         /*
 289          * Check to see which chip selects are now enabled for
 290          * the remainder of the calibration.
 291          */
 292         cs0_enable = readl(&mmdc0->mdctl) & 0x80000000;
 293         cs1_enable = readl(&mmdc0->mdctl) & 0x40000000;
 294
 295         /* Check to see what the data bus size is */
 296         bus_size = (readl(&mmdc0->mdctl) & 0x30000) >> 16;
 297         debug("Data bus size: %d (%d bits)\n", bus_size, 1 << (bus_size + 4));
 298
 299         precharge_all(cs0_enable, cs1_enable);
 300
 301         /* Write the pre-defined value into MPPDCMPR1 */
 302         writel(pddword, &mmdc0->mppdcmpr1);
 303
 304         /*
 305          * Issue a write access to the external DDR device by setting
 306          * the bit SW_DUMMY_WR (bit 0) in the MPSWDAR0 and then poll
 307          * this bit until it clears to indicate completion of the write access.
 308          */
 309         setbits_le32(&mmdc0->mpswdar0, 1);
 310         wait_for_bit("MMDC", &mmdc0->mpswdar0, 1 << 0, 0, 100, 0);
 311
 312         /* Set the RD_DL_ABS# bits to their default values
 313          * (will be calibrated later in the read delay-line calibration).
 314          * Both PHYs for x64 configuration, if x32, do only PHY0.
 315          */
 316         writel(initdelay, &mmdc0->mprddlctl);
 317         if (bus_size == 0x2)
 318                 writel(initdelay, &mmdc1->mprddlctl);
 319
 320         /* Force a measurment, for previous delay setup to take effect. */
 321         force_delay_measurement(bus_size);
 322
 323         /*
 324          * ***************************
 325          * Read DQS Gating calibration
 326          * ***************************
 327          */
 328         debug("Starting Read DQS Gating calibration.\n");
 329
 330         /*
 331          * Reset the read data FIFOs (two resets); only need to issue reset
 332          * to PHY0 since in x64 mode, the reset will also go to PHY1.
 333          */
 334         reset_read_data_fifos();
 335
 336         /*
 337          * Start the automatic read DQS gating calibration process by
 338          * asserting MPDGCTRL0[HW_DG_EN] and MPDGCTRL0[DG_CMP_CYC]
 339          * and then poll MPDGCTRL0[HW_DG_EN]] until this bit clears
 340          * to indicate completion.
 341          * Also, ensure that MPDGCTRL0[HW_DG_ERR] is clear to indicate
 342          * no errors were seen during calibration.
 343          */
 344
 345         /*
 346          * Set bit 30: chooses option to wait 32 cycles instead of
 347          * 16 before comparing read data.
 348          */
 349         setbits_le32(&mmdc0->mpdgctrl0, 1 << 30);
 350
 351         /* Set bit 28 to start automatic read DQS gating calibration */
 352         setbits_le32(&mmdc0->mpdgctrl0, 5 << 28);
 353
 354         /* Poll for completion.  MPDGCTRL0[HW_DG_EN] should be 0 */
 355         wait_for_bit("MMDC", &mmdc0->mpdgctrl0, 1 << 28, 0, 100, 0);
 356
 357         /*
 358          * Check to see if any errors were encountered during calibration
 359          * (check MPDGCTRL0[HW_DG_ERR]).
 360          * Check both PHYs for x64 configuration, if x32, check only PHY0.
 361          */
 362         if (readl(&mmdc0->mpdgctrl0) & 0x00001000)
 363                 errors |= 1;
 364
 365         if ((bus_size == 0x2) && (readl(&mmdc1->mpdgctrl0) & 0x00001000))
 366                 errors |= 2;
 367
 368         /*
 369          * DQS gating absolute offset should be modified from
 370          * reflecting (HW_DG_LOWx + HW_DG_UPx)/2 to
 371          * reflecting (HW_DG_UPx - 0x80)
 372          */
 373         modify_dg_result(&mmdc0->mpdghwst0, &mmdc0->mpdghwst1,
 374                          &mmdc0->mpdgctrl0);
 375         modify_dg_result(&mmdc0->mpdghwst2, &mmdc0->mpdghwst3,
 376                          &mmdc0->mpdgctrl1);
 377         if (bus_size == 0x2) {
 378                 modify_dg_result(&mmdc1->mpdghwst0, &mmdc1->mpdghwst1,
 379                                  &mmdc1->mpdgctrl0);
 380                 modify_dg_result(&mmdc1->mpdghwst2, &mmdc1->mpdghwst3,
 381                                  &mmdc1->mpdgctrl1);
 382         }
 383         debug("Ending Read DQS Gating calibration. Error mask: 0x%x\n", errors);
 384
 385         /*
 386          * **********************
 387          * Read Delay calibration
 388          * **********************
 389          */
 390         debug("Starting Read Delay calibration.\n");
 391
 392         reset_read_data_fifos();
 393
 394         /*
 395          * 4. Issue the Precharge-All command to the DDR device for both
 396          * chip selects.  If only using one chip select, then precharge
 397          * only the desired chip select.
 398          */
 399         precharge_all(cs0_enable, cs1_enable);
 400
 401         /*
 402          * 9. Read delay-line calibration
 403          * Start the automatic read calibration process by asserting
 404          * MPRDDLHWCTL[HW_RD_DL_EN].
 405          */
 406         writel(0x00000030, &mmdc0->mprddlhwctl);
 407
 408         /*
 409          * 10. poll for completion
 410          * MMDC indicates that the write data calibration had finished by
 411          * setting MPRDDLHWCTL[HW_RD_DL_EN] = 0.   Also, ensure that
 412          * no error bits were set.
 413          */
 414         wait_for_bit("MMDC", &mmdc0->mprddlhwctl, 1 << 4, 0, 100, 0);
 415
 416         /* check both PHYs for x64 configuration, if x32, check only PHY0 */
 417         if (readl(&mmdc0->mprddlhwctl) & 0x0000000f)
 418                 errors |= 4;
 419
 420         if ((bus_size == 0x2) && (readl(&mmdc1->mprddlhwctl) & 0x0000000f))
 421                 errors |= 8;
 422
 423         debug("Ending Read Delay calibration. Error mask: 0x%x\n", errors);
 424
 425         /*
 426          * ***********************
 427          * Write Delay Calibration
 428          * ***********************
 429          */
 430         debug("Starting Write Delay calibration.\n");
 431
 432         reset_read_data_fifos();
 433
 434         /*
 435          * 4. Issue the Precharge-All command to the DDR device for both
 436          * chip selects. If only using one chip select, then precharge
 437          * only the desired chip select.
 438          */
 439         precharge_all(cs0_enable, cs1_enable);
 440
 441         /*
 442          * 8. Set the WR_DL_ABS# bits to their default values.
 443          * Both PHYs for x64 configuration, if x32, do only PHY0.
 444          */
 445         writel(initdelay, &mmdc0->mpwrdlctl);
 446         if (bus_size == 0x2)
 447                 writel(initdelay, &mmdc1->mpwrdlctl);
 448
 449         /*
 450          * XXX This isn't in the manual. Force a measurement,
 451          * for previous delay setup to effect.
 452          */
 453         force_delay_measurement(bus_size);
 454
 455         /*
 456          * 9. 10. Start the automatic write calibration process
 457          * by asserting MPWRDLHWCTL0[HW_WR_DL_EN].
 458          */
 459         writel(0x00000030, &mmdc0->mpwrdlhwctl);
 460
 461         /*
 462          * Poll for completion.
 463          * MMDC indicates that the write data calibration had finished
 464          * by setting MPWRDLHWCTL[HW_WR_DL_EN] = 0.
 465          * Also, ensure that no error bits were set.
 466          */
 467         wait_for_bit("MMDC", &mmdc0->mpwrdlhwctl, 1 << 4, 0, 100, 0);
 468
 469         /* Check both PHYs for x64 configuration, if x32, check only PHY0 */
 470         if (readl(&mmdc0->mpwrdlhwctl) & 0x0000000f)
 471                 errors |= 16;
 472
 473         if ((bus_size == 0x2) && (readl(&mmdc1->mpwrdlhwctl) & 0x0000000f))
 474                 errors |= 32;
 475
 476         debug("Ending Write Delay calibration. Error mask: 0x%x\n", errors);
 477
 478         reset_read_data_fifos();
 479
 480         /* Enable DDR logic power down timer */
 481         setbits_le32(&mmdc0->mdpdc, 0x00005500);
 482
 483         /* Enable Adopt power down timer */
 484         clrbits_le32(&mmdc0->mapsr, 0x1);
 485
 486         /* Restore MDMISC value (RALAT, WALAT) to MMDCP1 */
 487         writel(esdmisc_val, &mmdc0->mdmisc);
 488
 489         /* Clear DQS pull ups */
 490         clrbits_le32(&mx6_ddr_iomux->dram_sdqs0, 0x7000);
 491         clrbits_le32(&mx6_ddr_iomux->dram_sdqs1, 0x7000);
 492         clrbits_le32(&mx6_ddr_iomux->dram_sdqs2, 0x7000);
 493         clrbits_le32(&mx6_ddr_iomux->dram_sdqs3, 0x7000);
 494         clrbits_le32(&mx6_ddr_iomux->dram_sdqs4, 0x7000);
 495         clrbits_le32(&mx6_ddr_iomux->dram_sdqs5, 0x7000);
 496         clrbits_le32(&mx6_ddr_iomux->dram_sdqs6, 0x7000);
 497         clrbits_le32(&mx6_ddr_iomux->dram_sdqs7, 0x7000);
 498
 499         /* Re-enable SDE (chip selects) if they were set initially */
 500         if (cs1_enable_initial)
 501                 /* Set SDE_1 */
 502                 setbits_le32(&mmdc0->mdctl, 1 << 30);
 503
 504         if (cs0_enable_initial)
 505                 /* Set SDE_0 */
 506                 setbits_le32(&mmdc0->mdctl, 1 << 31);
 507
 508         /* Re-enable to auto refresh */
 509         writel(temp_ref, &mmdc0->mdref);
 510
 511         /* Clear the MDSCR (including the con_req bit) */
 512         writel(0x0, &mmdc0->mdscr);     /* CS0 */
 513
 514         /* Poll to make sure the con_ack bit is clear */
 515         wait_for_bit("MMDC", &mmdc0->mdscr, 1 << 14, 0, 100, 0);
 516
 517         /*
 518          * Print out the registers that were updated as a result
 519          * of the calibration process.
 520          */
 521         debug("MMDC registers updated from calibration\n");
 522         debug("Read DQS gating calibration:\n");
 523         debug("\tMPDGCTRL0 PHY0 = 0x%08X\n", readl(&mmdc0->mpdgctrl0));
 524         debug("\tMPDGCTRL1 PHY0 = 0x%08X\n", readl(&mmdc0->mpdgctrl1));
 525         debug("\tMPDGCTRL0 PHY1 = 0x%08X\n", readl(&mmdc1->mpdgctrl0));
 526         debug("\tMPDGCTRL1 PHY1 = 0x%08X\n", readl(&mmdc1->mpdgctrl1));
 527         debug("Read calibration:\n");
 528         debug("\tMPRDDLCTL PHY0 = 0x%08X\n", readl(&mmdc0->mprddlctl));
 529         debug("\tMPRDDLCTL PHY1 = 0x%08X\n", readl(&mmdc1->mprddlctl));
 530         debug("Write calibration:\n");
 531         debug("\tMPWRDLCTL PHY0 = 0x%08X\n", readl(&mmdc0->mpwrdlctl));
 532         debug("\tMPWRDLCTL PHY1 = 0x%08X\n", readl(&mmdc1->mpwrdlctl));
 533
 534         /*
 535          * Registers below are for debugging purposes.  These print out
 536          * the upper and lower boundaries captured during
 537          * read DQS gating calibration.
 538          */
 539         debug("Status registers bounds for read DQS gating:\n");
 540         debug("\tMPDGHWST0 PHY0 = 0x%08x\n", readl(&mmdc0->mpdghwst0));
 541         debug("\tMPDGHWST1 PHY0 = 0x%08x\n", readl(&mmdc0->mpdghwst1));
 542         debug("\tMPDGHWST2 PHY0 = 0x%08x\n", readl(&mmdc0->mpdghwst2));
 543         debug("\tMPDGHWST3 PHY0 = 0x%08x\n", readl(&mmdc0->mpdghwst3));
 544         debug("\tMPDGHWST0 PHY1 = 0x%08x\n", readl(&mmdc1->mpdghwst0));
 545         debug("\tMPDGHWST1 PHY1 = 0x%08x\n", readl(&mmdc1->mpdghwst1));
 546         debug("\tMPDGHWST2 PHY1 = 0x%08x\n", readl(&mmdc1->mpdghwst2));
 547         debug("\tMPDGHWST3 PHY1 = 0x%08x\n", readl(&mmdc1->mpdghwst3));
 548
 549         debug("Final do_dqs_calibration error mask: 0x%x\n", errors);
 550
 551         return errors;
 552 }
 553 #endif
 554
 555 #if defined(CONFIG_MX6SX)
 556 /* Configure MX6SX mmdc iomux */
 557 void mx6sx_dram_iocfg(unsigned width,
 558                       const struct mx6sx_iomux_ddr_regs *ddr,
 559                       const struct mx6sx_iomux_grp_regs *grp)
 560 {
 561         struct mx6sx_iomux_ddr_regs *mx6_ddr_iomux;
 562         struct mx6sx_iomux_grp_regs *mx6_grp_iomux;
 563
 564         mx6_ddr_iomux = (struct mx6sx_iomux_ddr_regs *)MX6SX_IOM_DDR_BASE;
 565         mx6_grp_iomux = (struct mx6sx_iomux_grp_regs *)MX6SX_IOM_GRP_BASE;
 566
 567         /* DDR IO TYPE */
 568         writel(grp->grp_ddr_type, &mx6_grp_iomux->grp_ddr_type);
 569         writel(grp->grp_ddrpke, &mx6_grp_iomux->grp_ddrpke);
 570
 571         /* CLOCK */
 572         writel(ddr->dram_sdclk_0, &mx6_ddr_iomux->dram_sdclk_0);
 573
 574         /* ADDRESS */
 575         writel(ddr->dram_cas, &mx6_ddr_iomux->dram_cas);
 576         writel(ddr->dram_ras, &mx6_ddr_iomux->dram_ras);
 577         writel(grp->grp_addds, &mx6_grp_iomux->grp_addds);
 578
 579         /* Control */
 580         writel(ddr->dram_reset, &mx6_ddr_iomux->dram_reset);
 581         writel(ddr->dram_sdba2, &mx6_ddr_iomux->dram_sdba2);
 582         writel(ddr->dram_sdcke0, &mx6_ddr_iomux->dram_sdcke0);
 583         writel(ddr->dram_sdcke1, &mx6_ddr_iomux->dram_sdcke1);
 584         writel(ddr->dram_odt0, &mx6_ddr_iomux->dram_odt0);
 585         writel(ddr->dram_odt1, &mx6_ddr_iomux->dram_odt1);
 586         writel(grp->grp_ctlds, &mx6_grp_iomux->grp_ctlds);
 587
 588         /* Data Strobes */
 589         writel(grp->grp_ddrmode_ctl, &mx6_grp_iomux->grp_ddrmode_ctl);
 590         writel(ddr->dram_sdqs0, &mx6_ddr_iomux->dram_sdqs0);
 591         writel(ddr->dram_sdqs1, &mx6_ddr_iomux->dram_sdqs1);
 592         if (width >= 32) {
 593                 writel(ddr->dram_sdqs2, &mx6_ddr_iomux->dram_sdqs2);
 594                 writel(ddr->dram_sdqs3, &mx6_ddr_iomux->dram_sdqs3);
 595         }
 596
 597         /* Data */
 598         writel(grp->grp_ddrmode, &mx6_grp_iomux->grp_ddrmode);
 599         writel(grp->grp_b0ds, &mx6_grp_iomux->grp_b0ds);
 600         writel(grp->grp_b1ds, &mx6_grp_iomux->grp_b1ds);
 601         if (width >= 32) {
 602                 writel(grp->grp_b2ds, &mx6_grp_iomux->grp_b2ds);
 603                 writel(grp->grp_b3ds, &mx6_grp_iomux->grp_b3ds);
 604         }
 605         writel(ddr->dram_dqm0, &mx6_ddr_iomux->dram_dqm0);
 606         writel(ddr->dram_dqm1, &mx6_ddr_iomux->dram_dqm1);
 607         if (width >= 32) {
 608                 writel(ddr->dram_dqm2, &mx6_ddr_iomux->dram_dqm2);
 609                 writel(ddr->dram_dqm3, &mx6_ddr_iomux->dram_dqm3);
 610         }
 611 }
 612 #endif
 613
 614 #ifdef CONFIG_MX6UL
 615 void mx6ul_dram_iocfg(unsigned width,
 616                       const struct mx6ul_iomux_ddr_regs *ddr,
 617                       const struct mx6ul_iomux_grp_regs *grp)
 618 {
 619         struct mx6ul_iomux_ddr_regs *mx6_ddr_iomux;
 620         struct mx6ul_iomux_grp_regs *mx6_grp_iomux;
 621
 622         mx6_ddr_iomux = (struct mx6ul_iomux_ddr_regs *)MX6UL_IOM_DDR_BASE;
 623         mx6_grp_iomux = (struct mx6ul_iomux_grp_regs *)MX6UL_IOM_GRP_BASE;
 624
 625         /* DDR IO TYPE */
 626         writel(grp->grp_ddr_type, &mx6_grp_iomux->grp_ddr_type);
 627         writel(grp->grp_ddrpke, &mx6_grp_iomux->grp_ddrpke);
 628
 629         /* CLOCK */
 630         writel(ddr->dram_sdclk_0, &mx6_ddr_iomux->dram_sdclk_0);
 631
 632         /* ADDRESS */
 633         writel(ddr->dram_cas, &mx6_ddr_iomux->dram_cas);
 634         writel(ddr->dram_ras, &mx6_ddr_iomux->dram_ras);
 635         writel(grp->grp_addds, &mx6_grp_iomux->grp_addds);
 636
 637         /* Control */
 638         writel(ddr->dram_reset, &mx6_ddr_iomux->dram_reset);
 639         writel(ddr->dram_sdba2, &mx6_ddr_iomux->dram_sdba2);
 640         writel(ddr->dram_odt0, &mx6_ddr_iomux->dram_odt0);
 641         writel(ddr->dram_odt1, &mx6_ddr_iomux->dram_odt1);
 642         writel(grp->grp_ctlds, &mx6_grp_iomux->grp_ctlds);
 643
 644         /* Data Strobes */
 645         writel(grp->grp_ddrmode_ctl, &mx6_grp_iomux->grp_ddrmode_ctl);
 646         writel(ddr->dram_sdqs0, &mx6_ddr_iomux->dram_sdqs0);
 647         writel(ddr->dram_sdqs1, &mx6_ddr_iomux->dram_sdqs1);
 648
 649         /* Data */
 650         writel(grp->grp_ddrmode, &mx6_grp_iomux->grp_ddrmode);
 651         writel(grp->grp_b0ds, &mx6_grp_iomux->grp_b0ds);
 652         writel(grp->grp_b1ds, &mx6_grp_iomux->grp_b1ds);
 653         writel(ddr->dram_dqm0, &mx6_ddr_iomux->dram_dqm0);
 654         writel(ddr->dram_dqm1, &mx6_ddr_iomux->dram_dqm1);
 655 }
 656 #endif
 657
 658 #if defined(CONFIG_MX6SL)
 659 void mx6sl_dram_iocfg(unsigned width,
 660                       const struct mx6sl_iomux_ddr_regs *ddr,
 661                       const struct mx6sl_iomux_grp_regs *grp)
 662 {
 663         struct mx6sl_iomux_ddr_regs *mx6_ddr_iomux;
 664         struct mx6sl_iomux_grp_regs *mx6_grp_iomux;
 665
 666         mx6_ddr_iomux = (struct mx6sl_iomux_ddr_regs *)MX6SL_IOM_DDR_BASE;
 667         mx6_grp_iomux = (struct mx6sl_iomux_grp_regs *)MX6SL_IOM_GRP_BASE;
 668
 669         /* DDR IO TYPE */
 670         mx6_grp_iomux->grp_ddr_type = grp->grp_ddr_type;
 671         mx6_grp_iomux->grp_ddrpke = grp->grp_ddrpke;
 672
 673         /* CLOCK */
 674         mx6_ddr_iomux->dram_sdclk_0 = ddr->dram_sdclk_0;
 675
 676         /* ADDRESS */
 677         mx6_ddr_iomux->dram_cas = ddr->dram_cas;
 678         mx6_ddr_iomux->dram_ras = ddr->dram_ras;
 679         mx6_grp_iomux->grp_addds = grp->grp_addds;
 680
 681         /* Control */
 682         mx6_ddr_iomux->dram_reset = ddr->dram_reset;
 683         mx6_ddr_iomux->dram_sdba2 = ddr->dram_sdba2;
 684         mx6_grp_iomux->grp_ctlds = grp->grp_ctlds;
 685
 686         /* Data Strobes */
 687         mx6_grp_iomux->grp_ddrmode_ctl = grp->grp_ddrmode_ctl;
 688         mx6_ddr_iomux->dram_sdqs0 = ddr->dram_sdqs0;
 689         mx6_ddr_iomux->dram_sdqs1 = ddr->dram_sdqs1;
 690         if (width >= 32) {
 691                 mx6_ddr_iomux->dram_sdqs2 = ddr->dram_sdqs2;
 692                 mx6_ddr_iomux->dram_sdqs3 = ddr->dram_sdqs3;
 693         }
 694
 695         /* Data */
 696         mx6_grp_iomux->grp_ddrmode = grp->grp_ddrmode;
 697         mx6_grp_iomux->grp_b0ds = grp->grp_b0ds;
 698         mx6_grp_iomux->grp_b1ds = grp->grp_b1ds;
 699         if (width >= 32) {
 700                 mx6_grp_iomux->grp_b2ds = grp->grp_b2ds;
 701                 mx6_grp_iomux->grp_b3ds = grp->grp_b3ds;
 702         }
 703
 704         mx6_ddr_iomux->dram_dqm0 = ddr->dram_dqm0;
 705         mx6_ddr_iomux->dram_dqm1 = ddr->dram_dqm1;
 706         if (width >= 32) {
 707                 mx6_ddr_iomux->dram_dqm2 = ddr->dram_dqm2;
 708                 mx6_ddr_iomux->dram_dqm3 = ddr->dram_dqm3;
 709         }
 710 }
 711 #endif
 712
 713 #if defined(CONFIG_MX6QDL) || defined(CONFIG_MX6Q) || defined(CONFIG_MX6D)
 714 /* Configure MX6DQ mmdc iomux */
 715 void mx6dq_dram_iocfg(unsigned width,
 716                       const struct mx6dq_iomux_ddr_regs *ddr,
 717                       const struct mx6dq_iomux_grp_regs *grp)
 718 {
 719         volatile struct mx6dq_iomux_ddr_regs *mx6_ddr_iomux;
 720         volatile struct mx6dq_iomux_grp_regs *mx6_grp_iomux;
 721
 722         mx6_ddr_iomux = (struct mx6dq_iomux_ddr_regs *)MX6DQ_IOM_DDR_BASE;
 723         mx6_grp_iomux = (struct mx6dq_iomux_grp_regs *)MX6DQ_IOM_GRP_BASE;
 724
 725         /* DDR IO Type */
 726         mx6_grp_iomux->grp_ddr_type = grp->grp_ddr_type;
 727         mx6_grp_iomux->grp_ddrpke = grp->grp_ddrpke;
 728
 729         /* Clock */
 730         mx6_ddr_iomux->dram_sdclk_0 = ddr->dram_sdclk_0;
 731         mx6_ddr_iomux->dram_sdclk_1 = ddr->dram_sdclk_1;
 732
 733         /* Address */
 734         mx6_ddr_iomux->dram_cas = ddr->dram_cas;
 735         mx6_ddr_iomux->dram_ras = ddr->dram_ras;
 736         mx6_grp_iomux->grp_addds = grp->grp_addds;
 737
 738         /* Control */
 739         mx6_ddr_iomux->dram_reset = ddr->dram_reset;
 740         mx6_ddr_iomux->dram_sdcke0 = ddr->dram_sdcke0;
 741         mx6_ddr_iomux->dram_sdcke1 = ddr->dram_sdcke1;
 742         mx6_ddr_iomux->dram_sdba2 = ddr->dram_sdba2;
 743         mx6_ddr_iomux->dram_sdodt0 = ddr->dram_sdodt0;
 744         mx6_ddr_iomux->dram_sdodt1 = ddr->dram_sdodt1;
 745         mx6_grp_iomux->grp_ctlds = grp->grp_ctlds;
 746
 747         /* Data Strobes */
 748         mx6_grp_iomux->grp_ddrmode_ctl = grp->grp_ddrmode_ctl;
 749         mx6_ddr_iomux->dram_sdqs0 = ddr->dram_sdqs0;
 750         mx6_ddr_iomux->dram_sdqs1 = ddr->dram_sdqs1;
 751         if (width >= 32) {
 752                 mx6_ddr_iomux->dram_sdqs2 = ddr->dram_sdqs2;
 753                 mx6_ddr_iomux->dram_sdqs3 = ddr->dram_sdqs3;
 754         }
 755         if (width >= 64) {
 756                 mx6_ddr_iomux->dram_sdqs4 = ddr->dram_sdqs4;
 757                 mx6_ddr_iomux->dram_sdqs5 = ddr->dram_sdqs5;
 758                 mx6_ddr_iomux->dram_sdqs6 = ddr->dram_sdqs6;
 759                 mx6_ddr_iomux->dram_sdqs7 = ddr->dram_sdqs7;
 760         }
 761
 762         /* Data */
 763         mx6_grp_iomux->grp_ddrmode = grp->grp_ddrmode;
 764         mx6_grp_iomux->grp_b0ds = grp->grp_b0ds;
 765         mx6_grp_iomux->grp_b1ds = grp->grp_b1ds;
 766         if (width >= 32) {
 767                 mx6_grp_iomux->grp_b2ds = grp->grp_b2ds;
 768                 mx6_grp_iomux->grp_b3ds = grp->grp_b3ds;
 769         }
 770         if (width >= 64) {
 771                 mx6_grp_iomux->grp_b4ds = grp->grp_b4ds;
 772                 mx6_grp_iomux->grp_b5ds = grp->grp_b5ds;
 773                 mx6_grp_iomux->grp_b6ds = grp->grp_b6ds;
 774                 mx6_grp_iomux->grp_b7ds = grp->grp_b7ds;
 775         }
 776         mx6_ddr_iomux->dram_dqm0 = ddr->dram_dqm0;
 777         mx6_ddr_iomux->dram_dqm1 = ddr->dram_dqm1;
 778         if (width >= 32) {
 779                 mx6_ddr_iomux->dram_dqm2 = ddr->dram_dqm2;
 780                 mx6_ddr_iomux->dram_dqm3 = ddr->dram_dqm3;
 781         }
 782         if (width >= 64) {
 783                 mx6_ddr_iomux->dram_dqm4 = ddr->dram_dqm4;
 784                 mx6_ddr_iomux->dram_dqm5 = ddr->dram_dqm5;
 785                 mx6_ddr_iomux->dram_dqm6 = ddr->dram_dqm6;
 786                 mx6_ddr_iomux->dram_dqm7 = ddr->dram_dqm7;
 787         }
 788 }
 789 #endif
 790
 791 #if defined(CONFIG_MX6QDL) || defined(CONFIG_MX6DL) || defined(CONFIG_MX6S)
 792 /* Configure MX6SDL mmdc iomux */
 793 void mx6sdl_dram_iocfg(unsigned width,
 794                        const struct mx6sdl_iomux_ddr_regs *ddr,
 795                        const struct mx6sdl_iomux_grp_regs *grp)
 796 {
 797         volatile struct mx6sdl_iomux_ddr_regs *mx6_ddr_iomux;
 798         volatile struct mx6sdl_iomux_grp_regs *mx6_grp_iomux;
 799
 800         mx6_ddr_iomux = (struct mx6sdl_iomux_ddr_regs *)MX6SDL_IOM_DDR_BASE;
 801         mx6_grp_iomux = (struct mx6sdl_iomux_grp_regs *)MX6SDL_IOM_GRP_BASE;
 802
 803         /* DDR IO Type */
 804         mx6_grp_iomux->grp_ddr_type = grp->grp_ddr_type;
 805         mx6_grp_iomux->grp_ddrpke = grp->grp_ddrpke;
 806
 807         /* Clock */
 808         mx6_ddr_iomux->dram_sdclk_0 = ddr->dram_sdclk_0;
 809         mx6_ddr_iomux->dram_sdclk_1 = ddr->dram_sdclk_1;
 810
 811         /* Address */
 812         mx6_ddr_iomux->dram_cas = ddr->dram_cas;
 813         mx6_ddr_iomux->dram_ras = ddr->dram_ras;
 814         mx6_grp_iomux->grp_addds = grp->grp_addds;
 815
 816         /* Control */
 817         mx6_ddr_iomux->dram_reset = ddr->dram_reset;
 818         mx6_ddr_iomux->dram_sdcke0 = ddr->dram_sdcke0;
 819         mx6_ddr_iomux->dram_sdcke1 = ddr->dram_sdcke1;
 820         mx6_ddr_iomux->dram_sdba2 = ddr->dram_sdba2;
 821         mx6_ddr_iomux->dram_sdodt0 = ddr->dram_sdodt0;
 822         mx6_ddr_iomux->dram_sdodt1 = ddr->dram_sdodt1;
 823         mx6_grp_iomux->grp_ctlds = grp->grp_ctlds;
 824
 825         /* Data Strobes */
 826         mx6_grp_iomux->grp_ddrmode_ctl = grp->grp_ddrmode_ctl;
 827         mx6_ddr_iomux->dram_sdqs0 = ddr->dram_sdqs0;
 828         mx6_ddr_iomux->dram_sdqs1 = ddr->dram_sdqs1;
 829         if (width >= 32) {
 830                 mx6_ddr_iomux->dram_sdqs2 = ddr->dram_sdqs2;
 831                 mx6_ddr_iomux->dram_sdqs3 = ddr->dram_sdqs3;
 832         }
 833         if (width >= 64) {
 834                 mx6_ddr_iomux->dram_sdqs4 = ddr->dram_sdqs4;
 835                 mx6_ddr_iomux->dram_sdqs5 = ddr->dram_sdqs5;
 836                 mx6_ddr_iomux->dram_sdqs6 = ddr->dram_sdqs6;
 837                 mx6_ddr_iomux->dram_sdqs7 = ddr->dram_sdqs7;
 838         }
 839
 840         /* Data */
 841         mx6_grp_iomux->grp_ddrmode = grp->grp_ddrmode;
 842         mx6_grp_iomux->grp_b0ds = grp->grp_b0ds;
 843         mx6_grp_iomux->grp_b1ds = grp->grp_b1ds;
 844         if (width >= 32) {
 845                 mx6_grp_iomux->grp_b2ds = grp->grp_b2ds;
 846                 mx6_grp_iomux->grp_b3ds = grp->grp_b3ds;
 847         }
 848         if (width >= 64) {
 849                 mx6_grp_iomux->grp_b4ds = grp->grp_b4ds;
 850                 mx6_grp_iomux->grp_b5ds = grp->grp_b5ds;
 851                 mx6_grp_iomux->grp_b6ds = grp->grp_b6ds;
 852                 mx6_grp_iomux->grp_b7ds = grp->grp_b7ds;
 853         }
 854         mx6_ddr_iomux->dram_dqm0 = ddr->dram_dqm0;
 855         mx6_ddr_iomux->dram_dqm1 = ddr->dram_dqm1;
 856         if (width >= 32) {
 857                 mx6_ddr_iomux->dram_dqm2 = ddr->dram_dqm2;
 858                 mx6_ddr_iomux->dram_dqm3 = ddr->dram_dqm3;
 859         }
 860         if (width >= 64) {
 861                 mx6_ddr_iomux->dram_dqm4 = ddr->dram_dqm4;
 862                 mx6_ddr_iomux->dram_dqm5 = ddr->dram_dqm5;
 863                 mx6_ddr_iomux->dram_dqm6 = ddr->dram_dqm6;
 864                 mx6_ddr_iomux->dram_dqm7 = ddr->dram_dqm7;
 865         }
 866 }
 867 #endif
 868
 869 /*
 870  * Configure mx6 mmdc registers based on:
 871  *  - board-specific memory configuration
 872  *  - board-specific calibration data
 873  *  - ddr3/lpddr2 chip details
 874  *
 875  * The various calculations here are derived from the Freescale
 876  * 1. i.Mx6DQSDL DDR3 Script Aid spreadsheet (DOC-94917) designed to generate
 877  *    MMDC configuration registers based on memory system and memory chip
 878  *    parameters.
 879  *
 880  * 2. i.Mx6SL LPDDR2 Script Aid spreadsheet V0.04 designed to generate MMDC
 881  *    configuration registers based on memory system and memory chip
 882  *    parameters.
 883  *
 884  * The defaults here are those which were specified in the spreadsheet.
 885  * For details on each register, refer to the IMX6DQRM and/or IMX6SDLRM
 886  * and/or IMX6SLRM section titled MMDC initialization.
 887  */
 888 #define MR(val, ba, cmd, cs1) \
 889         ((val << 16) | (1 << 15) | (cmd << 4) | (cs1 << 3) | ba)
 890 #define MMDC1(entry, value) do {                                          \
 891         if (!is_mx6sx() && !is_mx6ul() && !is_mx6sl())                    \
 892                 mmdc1->entry = value;                                     \
 893         } while (0)
 894
 895 /*
 896  * According JESD209-2B-LPDDR2: Table 103
 897  * WL: write latency
 898  */
 899 static int lpddr2_wl(uint32_t mem_speed)
 900 {
 901         switch (mem_speed) {
 902         case 1066:
 903         case 933:
 904                 return 4;
 905         case 800:
 906                 return 3;
 907         case 677:
 908         case 533:
 909                 return 2;
 910         case 400:
 911         case 333:
 912                 return 1;
 913         default:
 914                 puts("invalid memory speed\n");
 915                 hang();
 916         }
 917
 918         return 0;
 919 }
 920
 921 /*
 922  * According JESD209-2B-LPDDR2: Table 103
 923  * RL: read latency
 924  */
 925 static int lpddr2_rl(uint32_t mem_speed)
 926 {
 927         switch (mem_speed) {
 928         case 1066:
 929                 return 8;
 930         case 933:
 931                 return 7;
 932         case 800:
 933                 return 6;
 934         case 677:
 935                 return 5;
 936         case 533:
 937                 return 4;
 938         case 400:
 939         case 333:
 940                 return 3;
 941         default:
 942                 puts("invalid memory speed\n");
 943                 hang();
 944         }
 945
 946         return 0;
 947 }
 948
 949 void mx6_lpddr2_cfg(const struct mx6_ddr_sysinfo *sysinfo,
 950                     const struct mx6_mmdc_calibration *calib,
 951                     const struct mx6_lpddr2_cfg *lpddr2_cfg)
 952 {
 953         volatile struct mmdc_p_regs *mmdc0;
 954         u32 val;
 955         u8 tcke, tcksrx, tcksre, trrd;
 956         u8 twl, txp, tfaw, tcl;
 957         u16 tras, twr, tmrd, trtp, twtr, trfc, txsr;
 958         u16 trcd_lp, trppb_lp, trpab_lp, trc_lp;
 959         u16 cs0_end;
 960         u8 coladdr;
 961         int clkper; /* clock period in picoseconds */
 962         int clock;  /* clock freq in mHz */
 963         int cs;
 964
 965         /* only support 16/32 bits */
 966         if (sysinfo->dsize > 1)
 967                 hang();
 968
 969         mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
 970
 971         clock = mxc_get_clock(MXC_DDR_CLK) / 1000000U;
 972         clkper = (1000 * 1000) / clock; /* pico seconds */
 973
 974         twl = lpddr2_wl(lpddr2_cfg->mem_speed) - 1;
 975
 976         /* LPDDR2-S2 and LPDDR2-S4 have the same tRFC value. */
 977         switch (lpddr2_cfg->density) {
 978         case 1:
 979         case 2:
 980         case 4:
 981                 trfc = DIV_ROUND_UP(130000, clkper) - 1;
 982                 txsr = DIV_ROUND_UP(140000, clkper) - 1;
 983                 break;
 984         case 8:
 985                 trfc = DIV_ROUND_UP(210000, clkper) - 1;
 986                 txsr = DIV_ROUND_UP(220000, clkper) - 1;
 987                 break;
 988         default:
 989                 /*
 990                  * 64Mb, 128Mb, 256Mb, 512Mb are not supported currently.
 991                  */
 992                 hang();
 993                 break;
 994         }
 995         /*
 996          * txpdll, txpr, taonpd and taofpd are not relevant in LPDDR2 mode,
 997          * set them to 0. */
 998         txp = DIV_ROUND_UP(7500, clkper) - 1;
 999         tcke = 3;
1000         if (lpddr2_cfg->mem_speed == 333)
1001                 tfaw = DIV_ROUND_UP(60000, clkper) - 1;
1002         else
1003                 tfaw = DIV_ROUND_UP(50000, clkper) - 1;
1004         trrd = DIV_ROUND_UP(10000, clkper) - 1;
1005
1006         /* tckesr for LPDDR2 */
1007         tcksre = DIV_ROUND_UP(15000, clkper);
1008         tcksrx = tcksre;
1009         twr  = DIV_ROUND_UP(15000, clkper) - 1;
1010         /*
1011          * tMRR: 2, tMRW: 5
1012          * tMRD should be set to max(tMRR, tMRW)
1013          */
1014         tmrd = 5;
1015         tras = DIV_ROUND_UP(lpddr2_cfg->trasmin, clkper / 10) - 1;
1016         /* LPDDR2 mode use tRCD_LP filed in MDCFG3. */
1017         trcd_lp = DIV_ROUND_UP(lpddr2_cfg->trcd_lp, clkper / 10) - 1;
1018         trc_lp = DIV_ROUND_UP(lpddr2_cfg->trasmin + lpddr2_cfg->trppb_lp,
1019                               clkper / 10) - 1;
1020         trppb_lp = DIV_ROUND_UP(lpddr2_cfg->trppb_lp, clkper / 10) - 1;
1021         trpab_lp = DIV_ROUND_UP(lpddr2_cfg->trpab_lp, clkper / 10) - 1;
1022         /* To LPDDR2, CL in MDCFG0 refers to RL */
1023         tcl = lpddr2_rl(lpddr2_cfg->mem_speed) - 3;
1024         twtr = DIV_ROUND_UP(7500, clkper) - 1;
1025         trtp = DIV_ROUND_UP(7500, clkper) - 1;
1026
1027         cs0_end = 4 * sysinfo->cs_density - 1;
1028
1029         debug("density:%d Gb (%d Gb per chip)\n",
1030               sysinfo->cs_density, lpddr2_cfg->density);
1031         debug("clock: %dMHz (%d ps)\n", clock, clkper);
1032         debug("memspd:%d\n", lpddr2_cfg->mem_speed);
1033         debug("trcd_lp=%d\n", trcd_lp);
1034         debug("trppb_lp=%d\n", trppb_lp);
1035         debug("trpab_lp=%d\n", trpab_lp);
1036         debug("trc_lp=%d\n", trc_lp);
1037         debug("tcke=%d\n", tcke);
1038         debug("tcksrx=%d\n", tcksrx);
1039         debug("tcksre=%d\n", tcksre);
1040         debug("trfc=%d\n", trfc);
1041         debug("txsr=%d\n", txsr);
1042         debug("txp=%d\n", txp);
1043         debug("tfaw=%d\n", tfaw);
1044         debug("tcl=%d\n", tcl);
1045         debug("tras=%d\n", tras);
1046         debug("twr=%d\n", twr);
1047         debug("tmrd=%d\n", tmrd);
1048         debug("twl=%d\n", twl);
1049         debug("trtp=%d\n", trtp);
1050         debug("twtr=%d\n", twtr);
1051         debug("trrd=%d\n", trrd);
1052         debug("cs0_end=%d\n", cs0_end);
1053         debug("ncs=%d\n", sysinfo->ncs);
1054
1055         /*
1056          * board-specific configuration:
1057          *  These values are determined empirically and vary per board layout
1058          */
1059         mmdc0->mpwldectrl0 = calib->p0_mpwldectrl0;
1060         mmdc0->mpwldectrl1 = calib->p0_mpwldectrl1;
1061         mmdc0->mpdgctrl0 = calib->p0_mpdgctrl0;
1062         mmdc0->mpdgctrl1 = calib->p0_mpdgctrl1;
1063         mmdc0->mprddlctl = calib->p0_mprddlctl;
1064         mmdc0->mpwrdlctl = calib->p0_mpwrdlctl;
1065         mmdc0->mpzqlp2ctl = calib->mpzqlp2ctl;
1066
1067         /* Read data DQ Byte0-3 delay */
1068         mmdc0->mprddqby0dl = 0x33333333;
1069         mmdc0->mprddqby1dl = 0x33333333;
1070         if (sysinfo->dsize > 0) {
1071                 mmdc0->mprddqby2dl = 0x33333333;
1072                 mmdc0->mprddqby3dl = 0x33333333;
1073         }
1074
1075         /* Write data DQ Byte0-3 delay */
1076         mmdc0->mpwrdqby0dl = 0xf3333333;
1077         mmdc0->mpwrdqby1dl = 0xf3333333;
1078         if (sysinfo->dsize > 0) {
1079                 mmdc0->mpwrdqby2dl = 0xf3333333;
1080                 mmdc0->mpwrdqby3dl = 0xf3333333;
1081         }
1082
1083         /*
1084          * In LPDDR2 mode this register should be cleared,
1085          * so no termination will be activated.
1086          */
1087         mmdc0->mpodtctrl = 0;
1088
1089         /* complete calibration */
1090         val = (1 << 11); /* Force measurement on delay-lines */
1091         mmdc0->mpmur0 = val;
1092
1093         /* Step 1: configuration request */
1094         mmdc0->mdscr = (u32)(1 << 15); /* config request */
1095
1096         /* Step 2: Timing configuration */
1097         mmdc0->mdcfg0 = (trfc << 24) | (txsr << 16) | (txp << 13) |
1098                         (tfaw << 4) | tcl;
1099         mmdc0->mdcfg1 = (tras << 16) | (twr << 9) | (tmrd << 5) | twl;
1100         mmdc0->mdcfg2 = (trtp << 6) | (twtr << 3) | trrd;
1101         mmdc0->mdcfg3lp = (trc_lp << 16) | (trcd_lp << 8) |
1102                           (trppb_lp << 4) | trpab_lp;
1103         mmdc0->mdotc = 0;
1104
1105         mmdc0->mdasp = cs0_end; /* CS addressing */
1106
1107         /* Step 3: Configure DDR type */
1108         mmdc0->mdmisc = (sysinfo->cs1_mirror << 19) | (sysinfo->walat << 16) |
1109                         (sysinfo->bi_on << 12) | (sysinfo->mif3_mode << 9) |
1110                         (sysinfo->ralat << 6) | (1 << 3);
1111
1112         /* Step 4: Configure delay while leaving reset */
1113         mmdc0->mdor = (sysinfo->sde_to_rst << 8) |
1114                       (sysinfo->rst_to_cke << 0);
1115
1116         /* Step 5: Configure DDR physical parameters (density and burst len) */
1117         coladdr = lpddr2_cfg->coladdr;
1118         if (lpddr2_cfg->coladdr == 8)           /* 8-bit COL is 0x3 */
1119                 coladdr += 4;
1120         else if (lpddr2_cfg->coladdr == 12)     /* 12-bit COL is 0x4 */
1121                 coladdr += 1;
1122         mmdc0->mdctl =  (lpddr2_cfg->rowaddr - 11) << 24 |      /* ROW */
1123                         (coladdr - 9) << 20 |                   /* COL */
1124                         (0 << 19) |     /* Burst Length = 4 for LPDDR2 */
1125                         (sysinfo->dsize << 16); /* DDR data bus size */
1126
1127         /* Step 6: Perform ZQ calibration */
1128         val = 0xa1390003; /* one-time HW ZQ calib */
1129         mmdc0->mpzqhwctrl = val;
1130
1131         /* Step 7: Enable MMDC with desired chip select */
1132         mmdc0->mdctl |= (1 << 31) |                          /* SDE_0 for CS0 */
1133                         ((sysinfo->ncs == 2) ? 1 : 0) << 30; /* SDE_1 for CS1 */
1134
1135         /* Step 8: Write Mode Registers to Init LPDDR2 devices */
1136         for (cs = 0; cs < sysinfo->ncs; cs++) {
1137                 /* MR63: reset */
1138                 mmdc0->mdscr = MR(63, 0, 3, cs);
1139                 /* MR10: calibration,
1140                  * 0xff is calibration command after intilization.
1141                  */
1142                 val = 0xA | (0xff << 8);
1143                 mmdc0->mdscr = MR(val, 0, 3, cs);
1144                 /* MR1 */
1145                 val = 0x1 | (0x82 << 8);
1146                 mmdc0->mdscr = MR(val, 0, 3, cs);
1147                 /* MR2 */
1148                 val = 0x2 | (0x04 << 8);
1149                 mmdc0->mdscr = MR(val, 0, 3, cs);
1150                 /* MR3 */
1151                 val = 0x3 | (0x02 << 8);
1152                 mmdc0->mdscr = MR(val, 0, 3, cs);
1153         }
1154
1155         /* Step 10: Power down control and self-refresh */
1156         mmdc0->mdpdc = (tcke & 0x7) << 16 |
1157                         5            << 12 |  /* PWDT_1: 256 cycles */
1158                         5            <<  8 |  /* PWDT_0: 256 cycles */
1159                         1            <<  6 |  /* BOTH_CS_PD */
1160                         (tcksrx & 0x7) << 3 |
1161                         (tcksre & 0x7);
1162         mmdc0->mapsr = 0x00001006; /* ADOPT power down enabled */
1163
1164         /* Step 11: Configure ZQ calibration: one-time and periodic 1ms */
1165         val = 0xa1310003;
1166         mmdc0->mpzqhwctrl = val;
1167
1168         /* Step 12: Configure and activate periodic refresh */
1169         mmdc0->mdref = (sysinfo->refsel << 14) | (sysinfo->refr << 11);
1170
1171         /* Step 13: Deassert config request - init complete */
1172         mmdc0->mdscr = 0x00000000;
1173
1174         /* wait for auto-ZQ calibration to complete */
1175         mdelay(1);
1176 }
1177
1178 void mx6_ddr3_cfg(const struct mx6_ddr_sysinfo *sysinfo,
1179                   const struct mx6_mmdc_calibration *calib,
1180                   const struct mx6_ddr3_cfg *ddr3_cfg)
1181 {
1182         volatile struct mmdc_p_regs *mmdc0;
1183         volatile struct mmdc_p_regs *mmdc1;
1184         u32 val;
1185         u8 tcke, tcksrx, tcksre, txpdll, taofpd, taonpd, trrd;
1186         u8 todtlon, taxpd, tanpd, tcwl, txp, tfaw, tcl;
1187         u8 todt_idle_off = 0x4; /* from DDR3 Script Aid spreadsheet */
1188         u16 trcd, trc, tras, twr, tmrd, trtp, trp, twtr, trfc, txs, txpr;
1189         u16 cs0_end;
1190         u16 tdllk = 0x1ff; /* DLL locking time: 512 cycles (JEDEC DDR3) */
1191         u8 coladdr;
1192         int clkper; /* clock period in picoseconds */
1193         int clock; /* clock freq in MHz */
1194         int cs;
1195         u16 mem_speed = ddr3_cfg->mem_speed;
1196
1197         mmdc0 = (struct mmdc_p_regs *)MMDC_P0_BASE_ADDR;
1198         if (!is_mx6sx() && !is_mx6ul() && !is_mx6sl())
1199                 mmdc1 = (struct mmdc_p_regs *)MMDC_P1_BASE_ADDR;
1200
1201         /* Limit mem_speed for MX6D/MX6Q */
1202         if (is_mx6dq() || is_mx6dqp()) {
1203                 if (mem_speed > 1066)
1204                         mem_speed = 1066; /* 1066 MT/s */
1205
1206                 tcwl = 4;
1207         }
1208         /* Limit mem_speed for MX6S/MX6DL */
1209         else {
1210                 if (mem_speed > 800)
1211                         mem_speed = 800;  /* 800 MT/s */
1212
1213                 tcwl = 3;
1214         }
1215
1216         clock = mem_speed / 2;
1217         /*
1218          * Data rate of 1066 MT/s requires 533 MHz DDR3 clock, but MX6D/Q supports
1219          * up to 528 MHz, so reduce the clock to fit chip specs
1220          */
1221         if (is_mx6dq() || is_mx6dqp()) {
1222                 if (clock > 528)
1223                         clock = 528; /* 528 MHz */
1224         }
1225
1226         clkper = (1000 * 1000) / clock; /* pico seconds */
1227         todtlon = tcwl;
1228         taxpd = tcwl;
1229         tanpd = tcwl;
1230
1231         switch (ddr3_cfg->density) {
1232         case 1: /* 1Gb per chip */
1233                 trfc = DIV_ROUND_UP(110000, clkper) - 1;
1234                 txs = DIV_ROUND_UP(120000, clkper) - 1;
1235                 break;
1236         case 2: /* 2Gb per chip */
1237                 trfc = DIV_ROUND_UP(160000, clkper) - 1;
1238                 txs = DIV_ROUND_UP(170000, clkper) - 1;
1239                 break;
1240         case 4: /* 4Gb per chip */
1241                 trfc = DIV_ROUND_UP(260000, clkper) - 1;
1242                 txs = DIV_ROUND_UP(270000, clkper) - 1;
1243                 break;
1244         case 8: /* 8Gb per chip */
1245                 trfc = DIV_ROUND_UP(350000, clkper) - 1;
1246                 txs = DIV_ROUND_UP(360000, clkper) - 1;
1247                 break;
1248         default:
1249                 /* invalid density */
1250                 puts("invalid chip density\n");
1251                 hang();
1252                 break;
1253         }
1254         txpr = txs;
1255
1256         switch (mem_speed) {
1257         case 800:
1258                 txp = DIV_ROUND_UP(max(3 * clkper, 7500), clkper) - 1;
1259                 tcke = DIV_ROUND_UP(max(3 * clkper, 7500), clkper) - 1;
1260                 if (ddr3_cfg->pagesz == 1) {
1261                         tfaw = DIV_ROUND_UP(40000, clkper) - 1;
1262                         trrd = DIV_ROUND_UP(max(4 * clkper, 10000), clkper) - 1;
1263                 } else {
1264                         tfaw = DIV_ROUND_UP(50000, clkper) - 1;
1265                         trrd = DIV_ROUND_UP(max(4 * clkper, 10000), clkper) - 1;
1266                 }
1267                 break;
1268         case 1066:
1269                 txp = DIV_ROUND_UP(max(3 * clkper, 7500), clkper) - 1;
1270                 tcke = DIV_ROUND_UP(max(3 * clkper, 5625), clkper) - 1;
1271                 if (ddr3_cfg->pagesz == 1) {
1272                         tfaw = DIV_ROUND_UP(37500, clkper) - 1;
1273                         trrd = DIV_ROUND_UP(max(4 * clkper, 7500), clkper) - 1;
1274                 } else {
1275                         tfaw = DIV_ROUND_UP(50000, clkper) - 1;
1276                         trrd = DIV_ROUND_UP(max(4 * clkper, 10000), clkper) - 1;
1277                 }
1278                 break;
1279         default:
1280                 puts("invalid memory speed\n");
1281                 hang();
1282                 break;
1283         }
1284         txpdll = DIV_ROUND_UP(max(10 * clkper, 24000), clkper) - 1;
1285         tcksre = DIV_ROUND_UP(max(5 * clkper, 10000), clkper);
1286         taonpd = DIV_ROUND_UP(2000, clkper) - 1;
1287         tcksrx = tcksre;
1288         taofpd = taonpd;
1289         twr  = DIV_ROUND_UP(15000, clkper) - 1;
1290         tmrd = DIV_ROUND_UP(max(12 * clkper, 15000), clkper) - 1;
1291         trc  = DIV_ROUND_UP(ddr3_cfg->trcmin, clkper / 10) - 1;
1292         tras = DIV_ROUND_UP(ddr3_cfg->trasmin, clkper / 10) - 1;
1293         tcl  = DIV_ROUND_UP(ddr3_cfg->trcd, clkper / 10) - 3;
1294         trp  = DIV_ROUND_UP(ddr3_cfg->trcd, clkper / 10) - 1;
1295         twtr = ROUND(max(4 * clkper, 7500) / clkper, 1) - 1;
1296         trcd = trp;
1297         trtp = twtr;
1298         cs0_end = 4 * sysinfo->cs_density - 1;
1299
1300         debug("density:%d Gb (%d Gb per chip)\n",
1301               sysinfo->cs_density, ddr3_cfg->density);
1302         debug("clock: %dMHz (%d ps)\n", clock, clkper);
1303         debug("memspd:%d\n", mem_speed);
1304         debug("tcke=%d\n", tcke);
1305         debug("tcksrx=%d\n", tcksrx);
1306         debug("tcksre=%d\n", tcksre);
1307         debug("taofpd=%d\n", taofpd);
1308         debug("taonpd=%d\n", taonpd);
1309         debug("todtlon=%d\n", todtlon);
1310         debug("tanpd=%d\n", tanpd);
1311         debug("taxpd=%d\n", taxpd);
1312         debug("trfc=%d\n", trfc);
1313         debug("txs=%d\n", txs);
1314         debug("txp=%d\n", txp);
1315         debug("txpdll=%d\n", txpdll);
1316         debug("tfaw=%d\n", tfaw);
1317         debug("tcl=%d\n", tcl);
1318         debug("trcd=%d\n", trcd);
1319         debug("trp=%d\n", trp);
1320         debug("trc=%d\n", trc);
1321         debug("tras=%d\n", tras);
1322         debug("twr=%d\n", twr);
1323         debug("tmrd=%d\n", tmrd);
1324         debug("tcwl=%d\n", tcwl);
1325         debug("tdllk=%d\n", tdllk);
1326         debug("trtp=%d\n", trtp);
1327         debug("twtr=%d\n", twtr);
1328         debug("trrd=%d\n", trrd);
1329         debug("txpr=%d\n", txpr);
1330         debug("cs0_end=%d\n", cs0_end);
1331         debug("ncs=%d\n", sysinfo->ncs);
1332         debug("Rtt_wr=%d\n", sysinfo->rtt_wr);
1333         debug("Rtt_nom=%d\n", sysinfo->rtt_nom);
1334         debug("SRT=%d\n", ddr3_cfg->SRT);
1335         debug("twr=%d\n", twr);
1336
1337         /*
1338          * board-specific configuration:
1339          *  These values are determined empirically and vary per board layout
1340          *  see:
1341          *   appnote, ddr3 spreadsheet
1342          */
1343         mmdc0->mpwldectrl0 = calib->p0_mpwldectrl0;
1344         mmdc0->mpwldectrl1 = calib->p0_mpwldectrl1;
1345         mmdc0->mpdgctrl0 = calib->p0_mpdgctrl0;
1346         mmdc0->mpdgctrl1 = calib->p0_mpdgctrl1;
1347         mmdc0->mprddlctl = calib->p0_mprddlctl;
1348         mmdc0->mpwrdlctl = calib->p0_mpwrdlctl;
1349         if (sysinfo->dsize > 1) {
1350                 MMDC1(mpwldectrl0, calib->p1_mpwldectrl0);
1351                 MMDC1(mpwldectrl1, calib->p1_mpwldectrl1);
1352                 MMDC1(mpdgctrl0, calib->p1_mpdgctrl0);
1353                 MMDC1(mpdgctrl1, calib->p1_mpdgctrl1);
1354                 MMDC1(mprddlctl, calib->p1_mprddlctl);
1355                 MMDC1(mpwrdlctl, calib->p1_mpwrdlctl);
1356         }
1357
1358         /* Read data DQ Byte0-3 delay */
1359         mmdc0->mprddqby0dl = 0x33333333;
1360         mmdc0->mprddqby1dl = 0x33333333;
1361         if (sysinfo->dsize > 0) {
1362                 mmdc0->mprddqby2dl = 0x33333333;
1363                 mmdc0->mprddqby3dl = 0x33333333;
1364         }
1365
1366         if (sysinfo->dsize > 1) {
1367                 MMDC1(mprddqby0dl, 0x33333333);
1368                 MMDC1(mprddqby1dl, 0x33333333);
1369                 MMDC1(mprddqby2dl, 0x33333333);
1370                 MMDC1(mprddqby3dl, 0x33333333);
1371         }
1372
1373         /* MMDC Termination: rtt_nom:2 RZQ/2(120ohm), rtt_nom:1 RZQ/4(60ohm) */
1374         val = (sysinfo->rtt_nom == 2) ? 0x00011117 : 0x00022227;
1375         mmdc0->mpodtctrl = val;
1376         if (sysinfo->dsize > 1)
1377                 MMDC1(mpodtctrl, val);
1378
1379         /* complete calibration */
1380         val = (1 << 11); /* Force measurement on delay-lines */
1381         mmdc0->mpmur0 = val;
1382         if (sysinfo->dsize > 1)
1383                 MMDC1(mpmur0, val);
1384
1385         /* Step 1: configuration request */
1386         mmdc0->mdscr = (u32)(1 << 15); /* config request */
1387
1388         /* Step 2: Timing configuration */
1389         mmdc0->mdcfg0 = (trfc << 24) | (txs << 16) | (txp << 13) |
1390                         (txpdll << 9) | (tfaw << 4) | tcl;
1391         mmdc0->mdcfg1 = (trcd << 29) | (trp << 26) | (trc << 21) |
1392                         (tras << 16) | (1 << 15) /* trpa */ |
1393                         (twr << 9) | (tmrd << 5) | tcwl;
1394         mmdc0->mdcfg2 = (tdllk << 16) | (trtp << 6) | (twtr << 3) | trrd;
1395         mmdc0->mdotc = (taofpd << 27) | (taonpd << 24) | (tanpd << 20) |
1396                        (taxpd << 16) | (todtlon << 12) | (todt_idle_off << 4);
1397         mmdc0->mdasp = cs0_end; /* CS addressing */
1398
1399         /* Step 3: Configure DDR type */
1400         mmdc0->mdmisc = (sysinfo->cs1_mirror << 19) | (sysinfo->walat << 16) |
1401                         (sysinfo->bi_on << 12) | (sysinfo->mif3_mode << 9) |
1402                         (sysinfo->ralat << 6);
1403
1404         /* Step 4: Configure delay while leaving reset */
1405         mmdc0->mdor = (txpr << 16) | (sysinfo->sde_to_rst << 8) |
1406                       (sysinfo->rst_to_cke << 0);
1407
1408         /* Step 5: Configure DDR physical parameters (density and burst len) */
1409         coladdr = ddr3_cfg->coladdr;
1410         if (ddr3_cfg->coladdr == 8)             /* 8-bit COL is 0x3 */
1411                 coladdr += 4;
1412         else if (ddr3_cfg->coladdr == 12)       /* 12-bit COL is 0x4 */
1413                 coladdr += 1;
1414         mmdc0->mdctl =  (ddr3_cfg->rowaddr - 11) << 24 |        /* ROW */
1415                         (coladdr - 9) << 20 |                   /* COL */
1416                         (1 << 19) |             /* Burst Length = 8 for DDR3 */
1417                         (sysinfo->dsize << 16);         /* DDR data bus size */
1418
1419         /* Step 6: Perform ZQ calibration */
1420         val = 0xa1390001; /* one-time HW ZQ calib */
1421         mmdc0->mpzqhwctrl = val;
1422         if (sysinfo->dsize > 1)
1423                 MMDC1(mpzqhwctrl, val);
1424
1425         /* Step 7: Enable MMDC with desired chip select */
1426         mmdc0->mdctl |= (1 << 31) |                          /* SDE_0 for CS0 */
1427                         ((sysinfo->ncs == 2) ? 1 : 0) << 30; /* SDE_1 for CS1 */
1428
1429         /* Step 8: Write Mode Registers to Init DDR3 devices */
1430         for (cs = 0; cs < sysinfo->ncs; cs++) {
1431                 /* MR2 */
1432                 val = (sysinfo->rtt_wr & 3) << 9 | (ddr3_cfg->SRT & 1) << 7 |
1433                       ((tcwl - 3) & 3) << 3;
1434                 debug("MR2 CS%d: 0x%08x\n", cs, (u32)MR(val, 2, 3, cs));
1435                 mmdc0->mdscr = MR(val, 2, 3, cs);
1436                 /* MR3 */
1437                 debug("MR3 CS%d: 0x%08x\n", cs, (u32)MR(0, 3, 3, cs));
1438                 mmdc0->mdscr = MR(0, 3, 3, cs);
1439                 /* MR1 */
1440                 val = ((sysinfo->rtt_nom & 1) ? 1 : 0) << 2 |
1441                       ((sysinfo->rtt_nom & 2) ? 1 : 0) << 6;
1442                 debug("MR1 CS%d: 0x%08x\n", cs, (u32)MR(val, 1, 3, cs));
1443                 mmdc0->mdscr = MR(val, 1, 3, cs);
1444                 /* MR0 */
1445                 val = ((tcl - 1) << 4) |        /* CAS */
1446                       (1 << 8)   |              /* DLL Reset */
1447                       ((twr - 3) << 9) |        /* Write Recovery */
1448                       (sysinfo->pd_fast_exit << 12); /* Precharge PD PLL on */
1449                 debug("MR0 CS%d: 0x%08x\n", cs, (u32)MR(val, 0, 3, cs));
1450                 mmdc0->mdscr = MR(val, 0, 3, cs);
1451                 /* ZQ calibration */
1452                 val = (1 << 10);
1453                 mmdc0->mdscr = MR(val, 0, 4, cs);
1454         }
1455
1456         /* Step 10: Power down control and self-refresh */
1457         mmdc0->mdpdc = (tcke & 0x7) << 16 |
1458                         5            << 12 |  /* PWDT_1: 256 cycles */
1459                         5            <<  8 |  /* PWDT_0: 256 cycles */
1460                         1            <<  6 |  /* BOTH_CS_PD */
1461                         (tcksrx & 0x7) << 3 |
1462                         (tcksre & 0x7);
1463         if (!sysinfo->pd_fast_exit)
1464                 mmdc0->mdpdc |= (1 << 7); /* SLOW_PD */
1465         mmdc0->mapsr = 0x00001006; /* ADOPT power down enabled */
1466
1467         /* Step 11: Configure ZQ calibration: one-time and periodic 1ms */
1468         val = 0xa1390003;
1469         mmdc0->mpzqhwctrl = val;
1470         if (sysinfo->dsize > 1)
1471                 MMDC1(mpzqhwctrl, val);
1472
1473         /* Step 12: Configure and activate periodic refresh */
1474         mmdc0->mdref = (sysinfo->refsel << 14) | (sysinfo->refr << 11);
1475
1476         /* Step 13: Deassert config request - init complete */
1477         mmdc0->mdscr = 0x00000000;
1478
1479         /* wait for auto-ZQ calibration to complete */
1480         mdelay(1);
1481 }
1482
1483 void mx6_dram_cfg(const struct mx6_ddr_sysinfo *sysinfo,
1484                   const struct mx6_mmdc_calibration *calib,
1485                   const void *ddr_cfg)
1486 {
1487         if (sysinfo->ddr_type == DDR_TYPE_DDR3) {
1488                 mx6_ddr3_cfg(sysinfo, calib, ddr_cfg);
1489         } else if (sysinfo->ddr_type == DDR_TYPE_LPDDR2) {
1490                 mx6_lpddr2_cfg(sysinfo, calib, ddr_cfg);
1491         } else {
1492                 puts("Unsupported ddr type\n");
1493                 hang();
1494         }
1495 }