arch/arm/cpu/armv7/tegra2/ap20.c

   1 /*
   2 * (C) Copyright 2010-2011
   3 * NVIDIA Corporation <www.nvidia.com>
   4 *
   5 * See file CREDITS for list of people who contributed to this
   6 * project.
   7 *
   8 * This program is free software; you can redistribute it and/or
   9 * modify it under the terms of the GNU General Public License as
  10 * published by the Free Software Foundation; either version 2 of
  11 * the License, or (at your option) any later version.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston,
  21 * MA 02111-1307 USA
  22 */
  23
  24 #include <asm/io.h>
  25 #include <asm/arch/tegra2.h>
  26 #include <asm/arch/ap20.h>
  27 #include <asm/arch/clk_rst.h>
  28 #include <asm/arch/clock.h>
  29 #include <asm/arch/fuse.h>
  30 #include <asm/arch/gp_padctrl.h>
  31 #include <asm/arch/pmc.h>
  32 #include <asm/arch/pinmux.h>
  33 #include <asm/arch/scu.h>
  34 #include <asm/arch/warmboot.h>
  35 #include <common.h>
  36
  37 int tegra_get_chip_type(void)
  38 {
  39         struct apb_misc_gp_ctlr *gp;
  40         struct fuse_regs *fuse = (struct fuse_regs *)TEGRA2_FUSE_BASE;
  41         uint tegra_sku_id, rev;
  42
  43         /*
  44          * This is undocumented, Chip ID is bits 15:8 of the register
  45          * APB_MISC + 0x804, and has value 0x20 for Tegra20, 0x30 for
  46          * Tegra30
  47          */
  48         gp = (struct apb_misc_gp_ctlr *)TEGRA2_APB_MISC_GP_BASE;
  49         rev = (readl(&gp->hidrev) & HIDREV_CHIPID_MASK) >> HIDREV_CHIPID_SHIFT;
  50
  51         tegra_sku_id = readl(&fuse->sku_info) & 0xff;
  52
  53         switch (rev) {
  54         case CHIPID_TEGRA2:
  55                 switch (tegra_sku_id) {
  56                 case SKU_ID_T20:
  57                         return TEGRA_SOC_T20;
  58                 case SKU_ID_T25SE:
  59                 case SKU_ID_AP25:
  60                 case SKU_ID_T25:
  61                 case SKU_ID_AP25E:
  62                 case SKU_ID_T25E:
  63                         return TEGRA_SOC_T25;
  64                 }
  65                 break;
  66         }
  67         /* unknown sku id */
  68         return TEGRA_SOC_UNKNOWN;
  69 }
  70
  71 /* Returns 1 if the current CPU executing is a Cortex-A9, else 0 */
  72 static int ap20_cpu_is_cortexa9(void)
  73 {
  74         u32 id = readb(NV_PA_PG_UP_BASE + PG_UP_TAG_0);
  75         return id == (PG_UP_TAG_0_PID_CPU & 0xff);
  76 }
  77
  78 void init_pllx(void)
  79 {
  80         struct clk_rst_ctlr *clkrst = (struct clk_rst_ctlr *)NV_PA_CLK_RST_BASE;
  81         struct clk_pll *pll = &clkrst->crc_pll[CLOCK_ID_XCPU];
  82         u32 reg;
  83
  84         /* If PLLX is already enabled, just return */
  85         if (readl(&pll->pll_base) & PLL_ENABLE_MASK)
  86                 return;
  87
  88         /* Set PLLX_MISC */
  89         writel(1 << PLL_CPCON_SHIFT, &pll->pll_misc);
  90
  91         /* Use 12MHz clock here */
  92         reg = PLL_BYPASS_MASK | (12 << PLL_DIVM_SHIFT);
  93         reg |= 1000 << PLL_DIVN_SHIFT;
  94         writel(reg, &pll->pll_base);
  95
  96         reg |= PLL_ENABLE_MASK;
  97         writel(reg, &pll->pll_base);
  98
  99         reg &= ~PLL_BYPASS_MASK;
 100         writel(reg, &pll->pll_base);
 101 }
 102
 103 static void enable_cpu_clock(int enable)
 104 {
 105         struct clk_rst_ctlr *clkrst = (struct clk_rst_ctlr *)NV_PA_CLK_RST_BASE;
 106         u32 clk;
 107
 108         /*
 109          * NOTE:
 110          * Regardless of whether the request is to enable or disable the CPU
 111          * clock, every processor in the CPU complex except the master (CPU 0)
 112          * will have it's clock stopped because the AVP only talks to the
 113          * master. The AVP does not know (nor does it need to know) that there
 114          * are multiple processors in the CPU complex.
 115          */
 116
 117         if (enable) {
 118                 /* Initialize PLLX */
 119                 init_pllx();
 120
 121                 /* Wait until all clocks are stable */
 122                 udelay(PLL_STABILIZATION_DELAY);
 123
 124                 writel(CCLK_BURST_POLICY, &clkrst->crc_cclk_brst_pol);
 125                 writel(SUPER_CCLK_DIVIDER, &clkrst->crc_super_cclk_div);
 126         }
 127
 128         /*
 129          * Read the register containing the individual CPU clock enables and
 130          * always stop the clock to CPU 1.
 131          */
 132         clk = readl(&clkrst->crc_clk_cpu_cmplx);
 133         clk |= 1 << CPU1_CLK_STP_SHIFT;
 134
 135         /* Stop/Unstop the CPU clock */
 136         clk &= ~CPU0_CLK_STP_MASK;
 137         clk |= !enable << CPU0_CLK_STP_SHIFT;
 138         writel(clk, &clkrst->crc_clk_cpu_cmplx);
 139
 140         clock_enable(PERIPH_ID_CPU);
 141 }
 142
 143 static int is_cpu_powered(void)
 144 {
 145         struct pmc_ctlr *pmc = (struct pmc_ctlr *)TEGRA2_PMC_BASE;
 146
 147         return (readl(&pmc->pmc_pwrgate_status) & CPU_PWRED) ? 1 : 0;
 148 }
 149
 150 static void remove_cpu_io_clamps(void)
 151 {
 152         struct pmc_ctlr *pmc = (struct pmc_ctlr *)TEGRA2_PMC_BASE;
 153         u32 reg;
 154
 155         /* Remove the clamps on the CPU I/O signals */
 156         reg = readl(&pmc->pmc_remove_clamping);
 157         reg |= CPU_CLMP;
 158         writel(reg, &pmc->pmc_remove_clamping);
 159
 160         /* Give I/O signals time to stabilize */
 161         udelay(IO_STABILIZATION_DELAY);
 162 }
 163
 164 static void powerup_cpu(void)
 165 {
 166         struct pmc_ctlr *pmc = (struct pmc_ctlr *)TEGRA2_PMC_BASE;
 167         u32 reg;
 168         int timeout = IO_STABILIZATION_DELAY;
 169
 170         if (!is_cpu_powered()) {
 171                 /* Toggle the CPU power state (OFF -> ON) */
 172                 reg = readl(&pmc->pmc_pwrgate_toggle);
 173                 reg &= PARTID_CP;
 174                 reg |= START_CP;
 175                 writel(reg, &pmc->pmc_pwrgate_toggle);
 176
 177                 /* Wait for the power to come up */
 178                 while (!is_cpu_powered()) {
 179                         if (timeout-- == 0)
 180                                 printf("CPU failed to power up!\n");
 181                         else
 182                                 udelay(10);
 183                 }
 184
 185                 /*
 186                  * Remove the I/O clamps from CPU power partition.
 187                  * Recommended only on a Warm boot, if the CPU partition gets
 188                  * power gated. Shouldn't cause any harm when called after a
 189                  * cold boot according to HW, probably just redundant.
 190                  */
 191                 remove_cpu_io_clamps();
 192         }
 193 }
 194
 195 static void enable_cpu_power_rail(void)
 196 {
 197         struct pmc_ctlr *pmc = (struct pmc_ctlr *)TEGRA2_PMC_BASE;
 198         u32 reg;
 199
 200         reg = readl(&pmc->pmc_cntrl);
 201         reg |= CPUPWRREQ_OE;
 202         writel(reg, &pmc->pmc_cntrl);
 203
 204         /*
 205          * The TI PMU65861C needs a 3.75ms delay between enabling
 206          * the power rail and enabling the CPU clock.  This delay
 207          * between SM1EN and SM1 is for switching time + the ramp
 208          * up of the voltage to the CPU (VDD_CPU from PMU).
 209          */
 210         udelay(3750);
 211 }
 212
 213 static void reset_A9_cpu(int reset)
 214 {
 215         /*
 216         * NOTE:  Regardless of whether the request is to hold the CPU in reset
 217         *        or take it out of reset, every processor in the CPU complex
 218         *        except the master (CPU 0) will be held in reset because the
 219         *        AVP only talks to the master. The AVP does not know that there
 220         *        are multiple processors in the CPU complex.
 221         */
 222
 223         /* Hold CPU 1 in reset, and CPU 0 if asked */
 224         reset_cmplx_set_enable(1, crc_rst_cpu | crc_rst_de | crc_rst_debug, 1);
 225         reset_cmplx_set_enable(0, crc_rst_cpu | crc_rst_de | crc_rst_debug,
 226                                reset);
 227
 228         /* Enable/Disable master CPU reset */
 229         reset_set_enable(PERIPH_ID_CPU, reset);
 230 }
 231
 232 static void clock_enable_coresight(int enable)
 233 {
 234         u32 rst, src;
 235
 236         clock_set_enable(PERIPH_ID_CORESIGHT, enable);
 237         reset_set_enable(PERIPH_ID_CORESIGHT, !enable);
 238
 239         if (enable) {
 240                 /*
 241                  * Put CoreSight on PLLP_OUT0 (216 MHz) and divide it down by
 242                  *  1.5, giving an effective frequency of 144MHz.
 243                  * Set PLLP_OUT0 [bits31:30 = 00], and use a 7.1 divisor
 244                  *  (bits 7:0), so 00000001b == 1.5 (n+1 + .5)
 245                  */
 246                 src = CLK_DIVIDER(NVBL_PLLP_KHZ, 144000);
 247                 clock_ll_set_source_divisor(PERIPH_ID_CSI, 0, src);
 248
 249                 /* Unlock the CPU CoreSight interfaces */
 250                 rst = 0xC5ACCE55;
 251                 writel(rst, CSITE_CPU_DBG0_LAR);
 252                 writel(rst, CSITE_CPU_DBG1_LAR);
 253         }
 254 }
 255
 256 void start_cpu(u32 reset_vector)
 257 {
 258         /* Enable VDD_CPU */
 259         enable_cpu_power_rail();
 260
 261         /* Hold the CPUs in reset */
 262         reset_A9_cpu(1);
 263
 264         /* Disable the CPU clock */
 265         enable_cpu_clock(0);
 266
 267         /* Enable CoreSight */
 268         clock_enable_coresight(1);
 269
 270         /*
 271          * Set the entry point for CPU execution from reset,
 272          *  if it's a non-zero value.
 273          */
 274         if (reset_vector)
 275                 writel(reset_vector, EXCEP_VECTOR_CPU_RESET_VECTOR);
 276
 277         /* Enable the CPU clock */
 278         enable_cpu_clock(1);
 279
 280         /* If the CPU doesn't already have power, power it up */
 281         powerup_cpu();
 282
 283         /* Take the CPU out of reset */
 284         reset_A9_cpu(0);
 285 }
 286
 287
 288 void halt_avp(void)
 289 {
 290         for (;;) {
 291                 writel((HALT_COP_EVENT_JTAG | HALT_COP_EVENT_IRQ_1 \
 292                         | HALT_COP_EVENT_FIQ_1 | (FLOW_MODE_STOP<<29)),
 293                         FLOW_CTLR_HALT_COP_EVENTS);
 294         }
 295 }
 296
 297 void enable_scu(void)
 298 {
 299         struct scu_ctlr *scu = (struct scu_ctlr *)NV_PA_ARM_PERIPHBASE;
 300         u32 reg;
 301
 302         /* If SCU already setup/enabled, return */
 303         if (readl(&scu->scu_ctrl) & SCU_CTRL_ENABLE)
 304                 return;
 305
 306         /* Invalidate all ways for all processors */
 307         writel(0xFFFF, &scu->scu_inv_all);
 308
 309         /* Enable SCU - bit 0 */
 310         reg = readl(&scu->scu_ctrl);
 311         reg |= SCU_CTRL_ENABLE;
 312         writel(reg, &scu->scu_ctrl);
 313 }
 314
 315 void init_pmc_scratch(void)
 316 {
 317         struct pmc_ctlr *const pmc = (struct pmc_ctlr *)TEGRA2_PMC_BASE;
 318         int i;
 319
 320         /* SCRATCH0 is initialized by the boot ROM and shouldn't be cleared */
 321         for (i = 0; i < 23; i++)
 322                 writel(0, &pmc->pmc_scratch1+i);
 323
 324         /* ODMDATA is for kernel use to determine RAM size, LP config, etc. */
 325         writel(CONFIG_SYS_BOARD_ODMDATA, &pmc->pmc_scratch20);
 326
 327 #ifdef CONFIG_TEGRA2_LP0
 328         /* save Sdram params to PMC 2, 4, and 24 for WB0 */
 329         warmboot_save_sdram_params();
 330 #endif
 331 }
 332
 333 void tegra2_start(void)
 334 {
 335         struct pmux_tri_ctlr *pmt = (struct pmux_tri_ctlr *)NV_PA_APB_MISC_BASE;
 336
 337         /* If we are the AVP, start up the first Cortex-A9 */
 338         if (!ap20_cpu_is_cortexa9()) {
 339                 /* enable JTAG */
 340                 writel(0xC0, &pmt->pmt_cfg_ctl);
 341
 342                 /*
 343                  * If we are ARM7 - give it a different stack. We are about to
 344                  * start up the A9 which will want to use this one.
 345                  */
 346                 asm volatile("mov       sp, %0\n"
 347                         : : "r"(AVP_EARLY_BOOT_STACK_LIMIT));
 348
 349                 start_cpu((u32)_start);
 350                 halt_avp();
 351                 /* not reached */
 352         }
 353
 354         /* Init PMC scratch memory */
 355         init_pmc_scratch();
 356
 357         enable_scu();
 358
 359         /* enable SMP mode and FW for CPU0, by writing to Auxiliary Ctl reg */
 360         asm volatile(
 361                 "mrc    p15, 0, r0, c1, c0, 1\n"
 362                 "orr    r0, r0, #0x41\n"
 363                 "mcr    p15, 0, r0, c1, c0, 1\n");
 364
 365         /* FIXME: should have ap20's L2 disabled too? */
 366 }