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

   1 /*
   2  * (C) Copyright 2007
   3  * Sascha Hauer, Pengutronix
   4  *
   5  * (C) Copyright 2009 Freescale Semiconductor, Inc.
   6  *
   7  * SPDX-License-Identifier:     GPL-2.0+
   8  */
   9
  10 #include <common.h>
  11 #include <asm/armv7.h>
  12 #include <asm/bootm.h>
  13 #include <asm/pl310.h>
  14 #include <asm/errno.h>
  15 #include <asm/io.h>
  16 #include <asm/arch/imx-regs.h>
  17 #include <asm/arch/clock.h>
  18 #include <asm/arch/sys_proto.h>
  19 #include <asm/imx-common/boot_mode.h>
  20 #include <asm/imx-common/dma.h>
  21 #include <stdbool.h>
  22 #include <asm/arch/mxc_hdmi.h>
  23 #include <asm/arch/crm_regs.h>
  24 #include <dm.h>
  25 #include <imx_thermal.h>
  26
  27 enum ldo_reg {
  28         LDO_ARM,
  29         LDO_SOC,
  30         LDO_PU,
  31 };
  32
  33 struct scu_regs {
  34         u32     ctrl;
  35         u32     config;
  36         u32     status;
  37         u32     invalidate;
  38         u32     fpga_rev;
  39 };
  40
  41 #if defined(CONFIG_IMX6_THERMAL)
  42 static const struct imx_thermal_plat imx6_thermal_plat = {
  43         .regs = (void *)ANATOP_BASE_ADDR,
  44         .fuse_bank = 1,
  45         .fuse_word = 6,
  46 };
  47
  48 U_BOOT_DEVICE(imx6_thermal) = {
  49         .name = "imx_thermal",
  50         .platdata = &imx6_thermal_plat,
  51 };
  52 #endif
  53
  54 u32 get_nr_cpus(void)
  55 {
  56         struct scu_regs *scu = (struct scu_regs *)SCU_BASE_ADDR;
  57         return readl(&scu->config) & 3;
  58 }
  59
  60 u32 get_cpu_rev(void)
  61 {
  62         struct anatop_regs *anatop = (struct anatop_regs *)ANATOP_BASE_ADDR;
  63         u32 reg = readl(&anatop->digprog_sololite);
  64         u32 type = ((reg >> 16) & 0xff);
  65
  66         if (type != MXC_CPU_MX6SL) {
  67                 reg = readl(&anatop->digprog);
  68                 struct scu_regs *scu = (struct scu_regs *)SCU_BASE_ADDR;
  69                 u32 cfg = readl(&scu->config) & 3;
  70                 type = ((reg >> 16) & 0xff);
  71                 if (type == MXC_CPU_MX6DL) {
  72                         if (!cfg)
  73                                 type = MXC_CPU_MX6SOLO;
  74                 }
  75
  76                 if (type == MXC_CPU_MX6Q) {
  77                         if (cfg == 1)
  78                                 type = MXC_CPU_MX6D;
  79                 }
  80
  81         }
  82         reg &= 0xff;            /* mx6 silicon revision */
  83         return (type << 12) | (reg + 0x10);
  84 }
  85
  86 /*
  87  * OCOTP_CFG3[17:16] (see Fusemap Description Table offset 0x440)
  88  * defines a 2-bit SPEED_GRADING
  89  */
  90 #define OCOTP_CFG3_SPEED_SHIFT  16
  91 #define OCOTP_CFG3_SPEED_800MHZ 0
  92 #define OCOTP_CFG3_SPEED_850MHZ 1
  93 #define OCOTP_CFG3_SPEED_1GHZ   2
  94 #define OCOTP_CFG3_SPEED_1P2GHZ 3
  95
  96 u32 get_cpu_speed_grade_hz(void)
  97 {
  98         struct ocotp_regs *ocotp = (struct ocotp_regs *)OCOTP_BASE_ADDR;
  99         struct fuse_bank *bank = &ocotp->bank[0];
 100         struct fuse_bank0_regs *fuse =
 101                 (struct fuse_bank0_regs *)bank->fuse_regs;
 102         uint32_t val;
 103
 104         val = readl(&fuse->cfg3);
 105         val >>= OCOTP_CFG3_SPEED_SHIFT;
 106         val &= 0x3;
 107
 108         switch (val) {
 109         /* Valid for IMX6DQ */
 110         case OCOTP_CFG3_SPEED_1P2GHZ:
 111                 if (is_cpu_type(MXC_CPU_MX6Q) || is_cpu_type(MXC_CPU_MX6D))
 112                         return 1200000000;
 113         /* Valid for IMX6SX/IMX6SDL/IMX6DQ */
 114         case OCOTP_CFG3_SPEED_1GHZ:
 115                 return 996000000;
 116         /* Valid for IMX6DQ */
 117         case OCOTP_CFG3_SPEED_850MHZ:
 118                 if (is_cpu_type(MXC_CPU_MX6Q) || is_cpu_type(MXC_CPU_MX6D))
 119                         return 852000000;
 120         /* Valid for IMX6SX/IMX6SDL/IMX6DQ */
 121         case OCOTP_CFG3_SPEED_800MHZ:
 122                 return 792000000;
 123         }
 124         return 0;
 125 }
 126
 127 #ifdef CONFIG_REVISION_TAG
 128 u32 __weak get_board_rev(void)
 129 {
 130         u32 cpurev = get_cpu_rev();
 131         u32 type = ((cpurev >> 12) & 0xff);
 132         if (type == MXC_CPU_MX6SOLO)
 133                 cpurev = (MXC_CPU_MX6DL) << 12 | (cpurev & 0xFFF);
 134
 135         if (type == MXC_CPU_MX6D)
 136                 cpurev = (MXC_CPU_MX6Q) << 12 | (cpurev & 0xFFF);
 137
 138         return cpurev;
 139 }
 140 #endif
 141
 142 void init_aips(void)
 143 {
 144         struct aipstz_regs *aips1, *aips2;
 145 #ifdef CONFIG_MX6SX
 146         struct aipstz_regs *aips3;
 147 #endif
 148
 149         aips1 = (struct aipstz_regs *)AIPS1_BASE_ADDR;
 150         aips2 = (struct aipstz_regs *)AIPS2_BASE_ADDR;
 151 #ifdef CONFIG_MX6SX
 152         aips3 = (struct aipstz_regs *)AIPS3_CONFIG_BASE_ADDR;
 153 #endif
 154
 155         /*
 156          * Set all MPROTx to be non-bufferable, trusted for R/W,
 157          * not forced to user-mode.
 158          */
 159         writel(0x77777777, &aips1->mprot0);
 160         writel(0x77777777, &aips1->mprot1);
 161         writel(0x77777777, &aips2->mprot0);
 162         writel(0x77777777, &aips2->mprot1);
 163
 164         /*
 165          * Set all OPACRx to be non-bufferable, not require
 166          * supervisor privilege level for access,allow for
 167          * write access and untrusted master access.
 168          */
 169         writel(0x00000000, &aips1->opacr0);
 170         writel(0x00000000, &aips1->opacr1);
 171         writel(0x00000000, &aips1->opacr2);
 172         writel(0x00000000, &aips1->opacr3);
 173         writel(0x00000000, &aips1->opacr4);
 174         writel(0x00000000, &aips2->opacr0);
 175         writel(0x00000000, &aips2->opacr1);
 176         writel(0x00000000, &aips2->opacr2);
 177         writel(0x00000000, &aips2->opacr3);
 178         writel(0x00000000, &aips2->opacr4);
 179
 180 #ifdef CONFIG_MX6SX
 181         /*
 182          * Set all MPROTx to be non-bufferable, trusted for R/W,
 183          * not forced to user-mode.
 184          */
 185         writel(0x77777777, &aips3->mprot0);
 186         writel(0x77777777, &aips3->mprot1);
 187
 188         /*
 189          * Set all OPACRx to be non-bufferable, not require
 190          * supervisor privilege level for access,allow for
 191          * write access and untrusted master access.
 192          */
 193         writel(0x00000000, &aips3->opacr0);
 194         writel(0x00000000, &aips3->opacr1);
 195         writel(0x00000000, &aips3->opacr2);
 196         writel(0x00000000, &aips3->opacr3);
 197         writel(0x00000000, &aips3->opacr4);
 198 #endif
 199 }
 200
 201 static void clear_ldo_ramp(void)
 202 {
 203         struct anatop_regs *anatop = (struct anatop_regs *)ANATOP_BASE_ADDR;
 204         int reg;
 205
 206         /* ROM may modify LDO ramp up time according to fuse setting, so in
 207          * order to be in the safe side we neeed to reset these settings to
 208          * match the reset value: 0'b00
 209          */
 210         reg = readl(&anatop->ana_misc2);
 211         reg &= ~(0x3f << 24);
 212         writel(reg, &anatop->ana_misc2);
 213 }
 214
 215 /*
 216  * Set the PMU_REG_CORE register
 217  *
 218  * Set LDO_SOC/PU/ARM regulators to the specified millivolt level.
 219  * Possible values are from 0.725V to 1.450V in steps of
 220  * 0.025V (25mV).
 221  */
 222 static int set_ldo_voltage(enum ldo_reg ldo, u32 mv)
 223 {
 224         struct anatop_regs *anatop = (struct anatop_regs *)ANATOP_BASE_ADDR;
 225         u32 val, step, old, reg = readl(&anatop->reg_core);
 226         u8 shift;
 227
 228         if (mv < 725)
 229                 val = 0x00;     /* Power gated off */
 230         else if (mv > 1450)
 231                 val = 0x1F;     /* Power FET switched full on. No regulation */
 232         else
 233                 val = (mv - 700) / 25;
 234
 235         clear_ldo_ramp();
 236
 237         switch (ldo) {
 238         case LDO_SOC:
 239                 shift = 18;
 240                 break;
 241         case LDO_PU:
 242                 shift = 9;
 243                 break;
 244         case LDO_ARM:
 245                 shift = 0;
 246                 break;
 247         default:
 248                 return -EINVAL;
 249         }
 250
 251         old = (reg & (0x1F << shift)) >> shift;
 252         step = abs(val - old);
 253         if (step == 0)
 254                 return 0;
 255
 256         reg = (reg & ~(0x1F << shift)) | (val << shift);
 257         writel(reg, &anatop->reg_core);
 258
 259         /*
 260          * The LDO ramp-up is based on 64 clock cycles of 24 MHz = 2.6 us per
 261          * step
 262          */
 263         udelay(3 * step);
 264
 265         return 0;
 266 }
 267
 268 static void imx_set_wdog_powerdown(bool enable)
 269 {
 270         struct wdog_regs *wdog1 = (struct wdog_regs *)WDOG1_BASE_ADDR;
 271         struct wdog_regs *wdog2 = (struct wdog_regs *)WDOG2_BASE_ADDR;
 272
 273 #ifdef CONFIG_MX6SX
 274         struct wdog_regs *wdog3 = (struct wdog_regs *)WDOG3_BASE_ADDR;
 275         writew(enable, &wdog3->wmcr);
 276 #endif
 277
 278         /* Write to the PDE (Power Down Enable) bit */
 279         writew(enable, &wdog1->wmcr);
 280         writew(enable, &wdog2->wmcr);
 281 }
 282
 283 static void set_ahb_rate(u32 val)
 284 {
 285         struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 286         u32 reg, div;
 287
 288         div = get_periph_clk() / val - 1;
 289         reg = readl(&mxc_ccm->cbcdr);
 290
 291         writel((reg & (~MXC_CCM_CBCDR_AHB_PODF_MASK)) |
 292                 (div << MXC_CCM_CBCDR_AHB_PODF_OFFSET), &mxc_ccm->cbcdr);
 293 }
 294
 295 static void clear_mmdc_ch_mask(void)
 296 {
 297         struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 298
 299         /* Clear MMDC channel mask */
 300         writel(0, &mxc_ccm->ccdr);
 301 }
 302
 303 static void init_bandgap(void)
 304 {
 305         struct anatop_regs *anatop = (struct anatop_regs *)ANATOP_BASE_ADDR;
 306         /*
 307          * Ensure the bandgap has stabilized.
 308          */
 309         while (!(readl(&anatop->ana_misc0) & 0x80))
 310                 ;
 311         /*
 312          * For best noise performance of the analog blocks using the
 313          * outputs of the bandgap, the reftop_selfbiasoff bit should
 314          * be set.
 315          */
 316         writel(BM_ANADIG_ANA_MISC0_REFTOP_SELBIASOFF, &anatop->ana_misc0_set);
 317 }
 318
 319
 320 #ifdef CONFIG_MX6SL
 321 static void set_preclk_from_osc(void)
 322 {
 323         struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 324         u32 reg;
 325
 326         reg = readl(&mxc_ccm->cscmr1);
 327         reg |= MXC_CCM_CSCMR1_PER_CLK_SEL_MASK;
 328         writel(reg, &mxc_ccm->cscmr1);
 329 }
 330 #endif
 331
 332 #define SRC_SCR_WARM_RESET_ENABLE       0
 333
 334 static void init_src(void)
 335 {
 336         struct src *src_regs = (struct src *)SRC_BASE_ADDR;
 337         u32 val;
 338
 339         /*
 340          * force warm reset sources to generate cold reset
 341          * for a more reliable restart
 342          */
 343         val = readl(&src_regs->scr);
 344         val &= ~(1 << SRC_SCR_WARM_RESET_ENABLE);
 345         writel(val, &src_regs->scr);
 346 }
 347
 348 int arch_cpu_init(void)
 349 {
 350         init_aips();
 351
 352         /* Need to clear MMDC_CHx_MASK to make warm reset work. */
 353         clear_mmdc_ch_mask();
 354
 355         /*
 356          * Disable self-bias circuit in the analog bandap.
 357          * The self-bias circuit is used by the bandgap during startup.
 358          * This bit should be set after the bandgap has initialized.
 359          */
 360         init_bandgap();
 361
 362         /*
 363          * When low freq boot is enabled, ROM will not set AHB
 364          * freq, so we need to ensure AHB freq is 132MHz in such
 365          * scenario.
 366          */
 367         if (mxc_get_clock(MXC_ARM_CLK) == 396000000)
 368                 set_ahb_rate(132000000);
 369
 370                 /* Set perclk to source from OSC 24MHz */
 371 #if defined(CONFIG_MX6SL)
 372         set_preclk_from_osc();
 373 #endif
 374
 375         imx_set_wdog_powerdown(false); /* Disable PDE bit of WMCR register */
 376
 377 #ifdef CONFIG_APBH_DMA
 378         /* Start APBH DMA */
 379         mxs_dma_init();
 380 #endif
 381
 382         init_src();
 383
 384         return 0;
 385 }
 386
 387 int board_postclk_init(void)
 388 {
 389         set_ldo_voltage(LDO_SOC, 1175); /* Set VDDSOC to 1.175V */
 390
 391         return 0;
 392 }
 393
 394 #ifndef CONFIG_SYS_DCACHE_OFF
 395 void enable_caches(void)
 396 {
 397 #if defined(CONFIG_SYS_ARM_CACHE_WRITETHROUGH)
 398         enum dcache_option option = DCACHE_WRITETHROUGH;
 399 #else
 400         enum dcache_option option = DCACHE_WRITEBACK;
 401 #endif
 402
 403         /* Avoid random hang when download by usb */
 404         invalidate_dcache_all();
 405
 406         /* Enable D-cache. I-cache is already enabled in start.S */
 407         dcache_enable();
 408
 409         /* Enable caching on OCRAM and ROM */
 410         mmu_set_region_dcache_behaviour(ROMCP_ARB_BASE_ADDR,
 411                                         ROMCP_ARB_END_ADDR,
 412                                         option);
 413         mmu_set_region_dcache_behaviour(IRAM_BASE_ADDR,
 414                                         IRAM_SIZE,
 415                                         option);
 416 }
 417 #endif
 418
 419 #if defined(CONFIG_FEC_MXC)
 420 void imx_get_mac_from_fuse(int dev_id, unsigned char *mac)
 421 {
 422         struct ocotp_regs *ocotp = (struct ocotp_regs *)OCOTP_BASE_ADDR;
 423         struct fuse_bank *bank = &ocotp->bank[4];
 424         struct fuse_bank4_regs *fuse =
 425                         (struct fuse_bank4_regs *)bank->fuse_regs;
 426
 427         u32 value = readl(&fuse->mac_addr_high);
 428         mac[0] = (value >> 8);
 429         mac[1] = value ;
 430
 431         value = readl(&fuse->mac_addr_low);
 432         mac[2] = value >> 24 ;
 433         mac[3] = value >> 16 ;
 434         mac[4] = value >> 8 ;
 435         mac[5] = value ;
 436
 437 }
 438 #endif
 439
 440 void boot_mode_apply(unsigned cfg_val)
 441 {
 442         unsigned reg;
 443         struct src *psrc = (struct src *)SRC_BASE_ADDR;
 444         writel(cfg_val, &psrc->gpr9);
 445         reg = readl(&psrc->gpr10);
 446         if (cfg_val)
 447                 reg |= 1 << 28;
 448         else
 449                 reg &= ~(1 << 28);
 450         writel(reg, &psrc->gpr10);
 451 }
 452 /*
 453  * cfg_val will be used for
 454  * Boot_cfg4[7:0]:Boot_cfg3[7:0]:Boot_cfg2[7:0]:Boot_cfg1[7:0]
 455  * After reset, if GPR10[28] is 1, ROM will use GPR9[25:0]
 456  * instead of SBMR1 to determine the boot device.
 457  */
 458 const struct boot_mode soc_boot_modes[] = {
 459         {"normal",      MAKE_CFGVAL(0x00, 0x00, 0x00, 0x00)},
 460         /* reserved value should start rom usb */
 461         {"usb",         MAKE_CFGVAL(0x01, 0x00, 0x00, 0x00)},
 462         {"sata",        MAKE_CFGVAL(0x20, 0x00, 0x00, 0x00)},
 463         {"ecspi1:0",    MAKE_CFGVAL(0x30, 0x00, 0x00, 0x08)},
 464         {"ecspi1:1",    MAKE_CFGVAL(0x30, 0x00, 0x00, 0x18)},
 465         {"ecspi1:2",    MAKE_CFGVAL(0x30, 0x00, 0x00, 0x28)},
 466         {"ecspi1:3",    MAKE_CFGVAL(0x30, 0x00, 0x00, 0x38)},
 467         /* 4 bit bus width */
 468         {"esdhc1",      MAKE_CFGVAL(0x40, 0x20, 0x00, 0x00)},
 469         {"esdhc2",      MAKE_CFGVAL(0x40, 0x28, 0x00, 0x00)},
 470         {"esdhc3",      MAKE_CFGVAL(0x40, 0x30, 0x00, 0x00)},
 471         {"esdhc4",      MAKE_CFGVAL(0x40, 0x38, 0x00, 0x00)},
 472         {NULL,          0},
 473 };
 474
 475 void s_init(void)
 476 {
 477         struct anatop_regs *anatop = (struct anatop_regs *)ANATOP_BASE_ADDR;
 478         struct mxc_ccm_reg *ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 479         u32 mask480;
 480         u32 mask528;
 481         u32 reg, periph1, periph2;
 482
 483         if (is_cpu_type(MXC_CPU_MX6SX))
 484                 return;
 485
 486         /* Due to hardware limitation, on MX6Q we need to gate/ungate all PFDs
 487          * to make sure PFD is working right, otherwise, PFDs may
 488          * not output clock after reset, MX6DL and MX6SL have added 396M pfd
 489          * workaround in ROM code, as bus clock need it
 490          */
 491
 492         mask480 = ANATOP_PFD_CLKGATE_MASK(0) |
 493                 ANATOP_PFD_CLKGATE_MASK(1) |
 494                 ANATOP_PFD_CLKGATE_MASK(2) |
 495                 ANATOP_PFD_CLKGATE_MASK(3);
 496         mask528 = ANATOP_PFD_CLKGATE_MASK(1) |
 497                 ANATOP_PFD_CLKGATE_MASK(3);
 498
 499         reg = readl(&ccm->cbcmr);
 500         periph2 = ((reg & MXC_CCM_CBCMR_PRE_PERIPH2_CLK_SEL_MASK)
 501                 >> MXC_CCM_CBCMR_PRE_PERIPH2_CLK_SEL_OFFSET);
 502         periph1 = ((reg & MXC_CCM_CBCMR_PRE_PERIPH_CLK_SEL_MASK)
 503                 >> MXC_CCM_CBCMR_PRE_PERIPH_CLK_SEL_OFFSET);
 504
 505         /* Checking if PLL2 PFD0 or PLL2 PFD2 is using for periph clock */
 506         if ((periph2 != 0x2) && (periph1 != 0x2))
 507                 mask528 |= ANATOP_PFD_CLKGATE_MASK(0);
 508
 509         if ((periph2 != 0x1) && (periph1 != 0x1) &&
 510                 (periph2 != 0x3) && (periph1 != 0x3))
 511                 mask528 |= ANATOP_PFD_CLKGATE_MASK(2);
 512
 513         writel(mask480, &anatop->pfd_480_set);
 514         writel(mask528, &anatop->pfd_528_set);
 515         writel(mask480, &anatop->pfd_480_clr);
 516         writel(mask528, &anatop->pfd_528_clr);
 517 }
 518
 519 #ifdef CONFIG_IMX_HDMI
 520 void imx_enable_hdmi_phy(void)
 521 {
 522         struct hdmi_regs *hdmi = (struct hdmi_regs *)HDMI_ARB_BASE_ADDR;
 523         u8 reg;
 524         reg = readb(&hdmi->phy_conf0);
 525         reg |= HDMI_PHY_CONF0_PDZ_MASK;
 526         writeb(reg, &hdmi->phy_conf0);
 527         udelay(3000);
 528         reg |= HDMI_PHY_CONF0_ENTMDS_MASK;
 529         writeb(reg, &hdmi->phy_conf0);
 530         udelay(3000);
 531         reg |= HDMI_PHY_CONF0_GEN2_TXPWRON_MASK;
 532         writeb(reg, &hdmi->phy_conf0);
 533         writeb(HDMI_MC_PHYRSTZ_ASSERT, &hdmi->mc_phyrstz);
 534 }
 535
 536 void imx_setup_hdmi(void)
 537 {
 538         struct mxc_ccm_reg *mxc_ccm = (struct mxc_ccm_reg *)CCM_BASE_ADDR;
 539         struct hdmi_regs *hdmi  = (struct hdmi_regs *)HDMI_ARB_BASE_ADDR;
 540         int reg;
 541
 542         /* Turn on HDMI PHY clock */
 543         reg = readl(&mxc_ccm->CCGR2);
 544         reg |=  MXC_CCM_CCGR2_HDMI_TX_IAHBCLK_MASK|
 545                  MXC_CCM_CCGR2_HDMI_TX_ISFRCLK_MASK;
 546         writel(reg, &mxc_ccm->CCGR2);
 547         writeb(HDMI_MC_PHYRSTZ_DEASSERT, &hdmi->mc_phyrstz);
 548         reg = readl(&mxc_ccm->chsccdr);
 549         reg &= ~(MXC_CCM_CHSCCDR_IPU1_DI0_PRE_CLK_SEL_MASK|
 550                  MXC_CCM_CHSCCDR_IPU1_DI0_PODF_MASK|
 551                  MXC_CCM_CHSCCDR_IPU1_DI0_CLK_SEL_MASK);
 552         reg |= (CHSCCDR_PODF_DIVIDE_BY_3
 553                  << MXC_CCM_CHSCCDR_IPU1_DI0_PODF_OFFSET)
 554                  |(CHSCCDR_IPU_PRE_CLK_540M_PFD
 555                  << MXC_CCM_CHSCCDR_IPU1_DI0_PRE_CLK_SEL_OFFSET);
 556         writel(reg, &mxc_ccm->chsccdr);
 557 }
 558 #endif
 559
 560 #ifndef CONFIG_SYS_L2CACHE_OFF
 561 #define IOMUXC_GPR11_L2CACHE_AS_OCRAM 0x00000002
 562 void v7_outer_cache_enable(void)
 563 {
 564         struct pl310_regs *const pl310 = (struct pl310_regs *)L2_PL310_BASE;
 565         unsigned int val;
 566
 567
 568         /*
 569          * Set bit 22 in the auxiliary control register. If this bit
 570          * is cleared, PL310 treats Normal Shared Non-cacheable
 571          * accesses as Cacheable no-allocate.
 572          */
 573         setbits_le32(&pl310->pl310_aux_ctrl, L310_SHARED_ATT_OVERRIDE_ENABLE);
 574
 575 #if defined CONFIG_MX6SL
 576         struct iomuxc *iomux = (struct iomuxc *)IOMUXC_BASE_ADDR;
 577         val = readl(&iomux->gpr[11]);
 578         if (val & IOMUXC_GPR11_L2CACHE_AS_OCRAM) {
 579                 /* L2 cache configured as OCRAM, reset it */
 580                 val &= ~IOMUXC_GPR11_L2CACHE_AS_OCRAM;
 581                 writel(val, &iomux->gpr[11]);
 582         }
 583 #endif
 584
 585         /* Must disable the L2 before changing the latency parameters */
 586         clrbits_le32(&pl310->pl310_ctrl, L2X0_CTRL_EN);
 587
 588         writel(0x132, &pl310->pl310_tag_latency_ctrl);
 589         writel(0x132, &pl310->pl310_data_latency_ctrl);
 590
 591         val = readl(&pl310->pl310_prefetch_ctrl);
 592
 593         /* Turn on the L2 I/D prefetch */
 594         val |= 0x30000000;
 595
 596         /*
 597          * The L2 cache controller(PL310) version on the i.MX6D/Q is r3p1-50rel0
 598          * The L2 cache controller(PL310) version on the i.MX6DL/SOLO/SL is r3p2
 599          * But according to ARM PL310 errata: 752271
 600          * ID: 752271: Double linefill feature can cause data corruption
 601          * Fault Status: Present in: r3p0, r3p1, r3p1-50rel0. Fixed in r3p2
 602          * Workaround: The only workaround to this erratum is to disable the
 603          * double linefill feature. This is the default behavior.
 604          */
 605
 606 #ifndef CONFIG_MX6Q
 607         val |= 0x40800000;
 608 #endif
 609         writel(val, &pl310->pl310_prefetch_ctrl);
 610
 611         val = readl(&pl310->pl310_power_ctrl);
 612         val |= L2X0_DYNAMIC_CLK_GATING_EN;
 613         val |= L2X0_STNDBY_MODE_EN;
 614         writel(val, &pl310->pl310_power_ctrl);
 615
 616         setbits_le32(&pl310->pl310_ctrl, L2X0_CTRL_EN);
 617 }
 618
 619 void v7_outer_cache_disable(void)
 620 {
 621         struct pl310_regs *const pl310 = (struct pl310_regs *)L2_PL310_BASE;
 622
 623         clrbits_le32(&pl310->pl310_ctrl, L2X0_CTRL_EN);
 624 }
 625 #endif /* !CONFIG_SYS_L2CACHE_OFF */