arch/arm/mach-rockchip/rk312x.c

   1 /*
   2  * Device Tree support for Rockchip RK3288
   3  *
   4  * Copyright (C) 2014 ROCKCHIP, Inc.
   5  *
   6  * This program is free software; you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation; either version 2 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  */
  16
  17 #include <linux/clk-provider.h>
  18 #include <linux/clocksource.h>
  19 #include <linux/cpuidle.h>
  20 #include <linux/delay.h>
  21 #include <linux/init.h>
  22 #include <linux/irqchip.h>
  23 #include <linux/kernel.h>
  24 #include <linux/of_address.h>
  25 #include <linux/of_platform.h>
  26 #include <linux/rockchip/common.h>
  27 #include <linux/rockchip/cpu.h>
  28 #include <linux/rockchip/cru.h>
  29 #include <linux/rockchip/dvfs.h>
  30 #include <linux/rockchip/grf.h>
  31 #include <linux/rockchip/iomap.h>
  32 #include <linux/rockchip/pmu.h>
  33 /*#include <asm/cpuidle.h>*/
  34 #include <asm/cputype.h>
  35 #include <asm/mach/arch.h>
  36 #include <asm/mach/map.h>
  37 #include "cpu_axi.h"
  38 #include "loader.h"
  39 #define CPU 312x
  40 #include "sram.h"
  41 #include "pm.h"
  42 #include "pm-rk312x.c"
  43 #define RK312X_DEVICE(name) \
  44         { \
  45                 .virtual        = (unsigned long) RK_##name##_VIRT, \
  46                 .pfn            = __phys_to_pfn(RK312X_##name##_PHYS), \
  47                 .length         = RK312X_##name##_SIZE, \
  48                 .type           = MT_DEVICE, \
  49         }
  50
  51 static const char * const rk3126_dt_compat[] __initconst = {
  52         "rockchip,rk3126",
  53         NULL,
  54 };
  55
  56 static const char * const rk3128_dt_compat[] __initconst = {
  57         "rockchip,rk3128",
  58         NULL,
  59 };
  60
  61 #define RK312X_IMEM_VIRT (RK_BOOTRAM_VIRT + SZ_32K)
  62 #define RK312X_TIMER5_VIRT (RK_TIMER_VIRT + 0xa0)
  63
  64 static struct map_desc rk312x_io_desc[] __initdata = {
  65         RK312X_DEVICE(CRU),
  66         RK312X_DEVICE(GRF),
  67         RK312X_DEVICE(ROM),
  68         RK312X_DEVICE(PMU),
  69         RK312X_DEVICE(EFUSE),
  70         RK312X_DEVICE(TIMER),
  71         RK312X_DEVICE(CPU_AXI_BUS),
  72         RK_DEVICE(RK_DEBUG_UART_VIRT, RK312X_UART2_PHYS, RK312X_UART_SIZE),
  73         RK_DEVICE(RK_DDR_VIRT, RK312X_DDR_PCTL_PHYS, RK312X_DDR_PCTL_SIZE),
  74         RK_DEVICE(RK_DDR_VIRT + RK312X_DDR_PCTL_SIZE, RK312X_DDR_PHY_PHYS, RK312X_DDR_PHY_SIZE),
  75         RK_DEVICE(RK_GPIO_VIRT(0), RK312X_GPIO0_PHYS, RK312X_GPIO_SIZE),
  76         RK_DEVICE(RK_GPIO_VIRT(1), RK312X_GPIO1_PHYS, RK312X_GPIO_SIZE),
  77         RK_DEVICE(RK_GPIO_VIRT(2), RK312X_GPIO2_PHYS, RK312X_GPIO_SIZE),
  78         RK_DEVICE(RK_GPIO_VIRT(3), RK312X_GPIO3_PHYS, RK312X_GPIO_SIZE),
  79         RK_DEVICE(RK_GIC_VIRT, RK312X_GIC_DIST_PHYS, RK312X_GIC_DIST_SIZE),
  80         RK_DEVICE(RK_GIC_VIRT + RK312X_GIC_DIST_SIZE, RK312X_GIC_CPU_PHYS, RK312X_GIC_CPU_SIZE),
  81         RK_DEVICE(RK312X_IMEM_VIRT, RK312X_IMEM_PHYS, RK312X_IMEM_SIZE),
  82 };
  83 static void usb_uart_init(void)
  84 {
  85 #ifdef CONFIG_RK_USB_UART
  86         u32 soc_status0 = readl_relaxed(RK_GRF_VIRT + RK312X_GRF_SOC_STATUS0);
  87 #endif
  88         writel_relaxed(0x34000000, RK_GRF_VIRT + RK312X_GRF_UOC1_CON4);
  89 #ifdef CONFIG_RK_USB_UART
  90         if (!(soc_status0 & (1 << 5)) && (soc_status0 & (1 << 8))) {
  91                 /* software control usb phy enable */
  92                 writel_relaxed(0x007f0055, RK_GRF_VIRT + RK312X_GRF_UOC0_CON0);
  93                 writel_relaxed(0x34003000, RK_GRF_VIRT + RK312X_GRF_UOC1_CON4);
  94         }
  95 #endif
  96
  97         writel_relaxed(0x07, RK_DEBUG_UART_VIRT + 0x88);
  98         writel_relaxed(0x00, RK_DEBUG_UART_VIRT + 0x04);
  99         writel_relaxed(0x83, RK_DEBUG_UART_VIRT + 0x0c);
 100         writel_relaxed(0x0d, RK_DEBUG_UART_VIRT + 0x00);
 101         writel_relaxed(0x00, RK_DEBUG_UART_VIRT + 0x04);
 102         writel_relaxed(0x03, RK_DEBUG_UART_VIRT + 0x0c);
 103 }
 104
 105 static void __init rk312x_dt_map_io(void)
 106 {
 107         u32 val;
 108
 109         iotable_init(rk312x_io_desc, ARRAY_SIZE(rk312x_io_desc));
 110         debug_ll_io_init();
 111         usb_uart_init();
 112
 113         /* enable timer5 for core */
 114         writel_relaxed(0, RK312X_TIMER5_VIRT + 0x10);
 115         dsb();
 116         writel_relaxed(0xFFFFFFFF, RK312X_TIMER5_VIRT + 0x00);
 117         writel_relaxed(0xFFFFFFFF, RK312X_TIMER5_VIRT + 0x04);
 118         dsb();
 119         writel_relaxed(1, RK312X_TIMER5_VIRT + 0x10);
 120         dsb();
 121         val = readl_relaxed(RK_CRU_VIRT + RK312X_CRU_MISC_CON);
 122         val &= (~(1 << 15));
 123         writel_relaxed(0x80000000 | val, RK_CRU_VIRT + RK312X_CRU_MISC_CON);
 124         dsb();
 125
 126 }
 127
 128 static void __init rk3126_dt_map_io(void)
 129 {
 130         rockchip_soc_id = ROCKCHIP_SOC_RK3126;
 131
 132         rk312x_dt_map_io();
 133 }
 134
 135 static void __init rk3128_dt_map_io(void)
 136 {
 137         rockchip_soc_id = ROCKCHIP_SOC_RK3128;
 138
 139         rk312x_dt_map_io();
 140 }
 141 static DEFINE_SPINLOCK(pmu_idle_lock);
 142 static const u8 pmu_idle_map[] = {
 143         [IDLE_REQ_PERI] = 0,
 144         [IDLE_REQ_VIDEO] = 1,
 145         [IDLE_REQ_VIO] = 2,
 146         [IDLE_REQ_GPU] = 3,
 147         [IDLE_REQ_CORE] = 4,
 148         [IDLE_REQ_SYS] = 5,
 149         [IDLE_REQ_MSCH] = 6,
 150         [IDLE_REQ_CRYPTO] = 7,
 151
 152 };
 153 static int rk312x_pmu_set_idle_request(enum pmu_idle_req req, bool idle)
 154 {
 155         u32 val;
 156         unsigned long flags;
 157         u32 bit = pmu_idle_map[req];
 158         u32 idle_mask = BIT(bit) | BIT(bit + 16);
 159         u32 idle_target = (idle << bit) | (idle << (bit + 16));
 160         u32 mask = BIT(bit);
 161
 162         spin_lock_irqsave(&pmu_idle_lock, flags);
 163         val = pmu_readl(RK312X_PMU_IDLE_REQ);
 164         if (idle)
 165                 val |= mask;
 166         else
 167                 val &= ~mask;
 168         pmu_writel(val, RK312X_PMU_IDLE_REQ);
 169         dsb();
 170
 171         while (((pmu_readl(RK312X_PMU_IDLE_ST) & idle_mask) != idle_target))
 172                 ;
 173         spin_unlock_irqrestore(&pmu_idle_lock, flags);
 174         return 0;
 175 }
 176 static const u8 pmu_pd_map[] = {
 177         [PD_GPU] = 1,
 178         [PD_VIDEO] = 2,
 179         [PD_VIO] = 3,
 180 };
 181
 182 static const u8 pmu_st_map[] = {
 183         [PD_GPU] = 1,
 184         [PD_VIDEO] = 2,
 185         [PD_VIO] = 3,
 186 };
 187
 188 static noinline void rk312x_do_pmu_set_power_domain(enum pmu_power_domain domain
 189         , bool on)
 190 {
 191         u8 pd = pmu_pd_map[domain];
 192         u32 val = pmu_readl(RK312X_PMU_PWRDN_CON);
 193
 194         if (on)
 195                 val &= ~BIT(pd);
 196         else
 197                 val |=  BIT(pd);
 198         pmu_writel(val, RK312X_PMU_PWRDN_CON);
 199         dsb();
 200
 201         while ((pmu_readl(RK312X_PMU_PWRDN_ST) & BIT(pmu_st_map[domain])) == on)
 202                 ;
 203 }
 204
 205 static bool rk312x_pmu_power_domain_is_on(enum pmu_power_domain pd)
 206 {
 207         /*1"b0: power on, 1'b1: power off*/
 208         return !(pmu_readl(RK312X_PMU_PWRDN_ST) & BIT(pmu_st_map[pd]));
 209 }
 210 static DEFINE_SPINLOCK(pmu_pd_lock);
 211 static u32 rga_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 212 static u32 ebc_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 213 static u32 iep_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 214 static u32 lcdc0_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 215 static u32 vip0_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 216 static u32 gpu_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 217 static u32 video_qos[RK312X_CPU_AXI_QOS_NUM_REGS];
 218
 219 #define SAVE_QOS(array, NAME) RK312X_CPU_AXI_SAVE_QOS(array, RK312X_CPU_AXI_##NAME##_QOS_VIRT)
 220 #define RESTORE_QOS(array, NAME) RK312X_CPU_AXI_RESTORE_QOS(array, RK312X_CPU_AXI_##NAME##_QOS_VIRT)
 221
 222 static int rk312x_pmu_set_power_domain(enum pmu_power_domain pd, bool on)
 223 {
 224         unsigned long flags;
 225
 226         spin_lock_irqsave(&pmu_pd_lock, flags);
 227         if (rk312x_pmu_power_domain_is_on(pd) == on)
 228                 goto out;
 229         if (!on) {
 230                 if (pd == PD_GPU) {
 231                         SAVE_QOS(gpu_qos, GPU);
 232                         rk312x_pmu_set_idle_request(IDLE_REQ_GPU, true);
 233                 } else if (pd == PD_VIO) {
 234                         SAVE_QOS(rga_qos, VIO_RGA);
 235                         SAVE_QOS(ebc_qos, VIO_EBC);
 236                         SAVE_QOS(iep_qos, VIO_IEP);
 237                         SAVE_QOS(lcdc0_qos, VIO_LCDC0);
 238                         SAVE_QOS(vip0_qos, VIO_VIP0);
 239                         rk312x_pmu_set_idle_request(IDLE_REQ_VIO, true);
 240                 } else if (pd == PD_VIDEO) {
 241                         SAVE_QOS(video_qos, VIDEO);
 242                         rk312x_pmu_set_idle_request(IDLE_REQ_VIDEO, true);
 243                 }
 244         }
 245
 246         rk312x_do_pmu_set_power_domain(pd, on);
 247
 248         if (on) {
 249                 if (pd == PD_GPU) {
 250                         rk312x_pmu_set_idle_request(IDLE_REQ_GPU, false);
 251                         RESTORE_QOS(gpu_qos, GPU);
 252                 } else if (pd == PD_VIO) {
 253                         rk312x_pmu_set_idle_request(IDLE_REQ_VIO, false);
 254                         RESTORE_QOS(rga_qos, VIO_RGA);
 255                         RESTORE_QOS(ebc_qos, VIO_EBC);
 256                         RESTORE_QOS(iep_qos, VIO_IEP);
 257                         RESTORE_QOS(lcdc0_qos, VIO_LCDC0);
 258                         RESTORE_QOS(vip0_qos, VIO_VIP0);
 259                 } else if (pd == PD_VIDEO) {
 260                         rk312x_pmu_set_idle_request(IDLE_REQ_VIDEO, false);
 261                         RESTORE_QOS(video_qos, VIDEO);
 262                 }
 263         }
 264 out:
 265         spin_unlock_irqrestore(&pmu_pd_lock, flags);
 266
 267         return 0;
 268 }
 269 extern void secondary_startup(void);
 270 static int rk312x_sys_set_power_domain(enum pmu_power_domain pd, bool on)
 271 {
 272         u32 clks_save[RK312X_CRU_CLKGATES_CON_CNT];
 273         u32 clks_ungating[RK312X_CRU_CLKGATES_CON_CNT];
 274         u32 i, ret = 0;
 275
 276         for (i = 0; i < RK312X_CRU_CLKGATES_CON_CNT; i++) {
 277                 clks_save[i] = cru_readl(RK312X_CRU_CLKGATES_CON(i));
 278                 clks_ungating[i] = 0;
 279         }
 280         for (i = 0; i < RK312X_CRU_CLKGATES_CON_CNT; i++)
 281                 cru_writel(0xffff0000, RK312X_CRU_CLKGATES_CON(i));
 282
 283         if (on) {
 284 #ifdef CONFIG_SMP
 285                 if (pd >= PD_CPU_1 && pd <= PD_CPU_3) {
 286                         writel_relaxed(0x20000 << (pd - PD_CPU_1),
 287                                        RK_CRU_VIRT + RK312X_CRU_SOFTRSTS_CON(0));
 288                         dsb();
 289                         udelay(10);
 290                         writel_relaxed(virt_to_phys(secondary_startup),
 291                                        RK312X_IMEM_VIRT + 8);
 292                         writel_relaxed(0xDEADBEAF, RK312X_IMEM_VIRT + 4);
 293                         dsb_sev();
 294                 }
 295 #endif
 296         } else {
 297 #ifdef CONFIG_SMP
 298                 if (pd >= PD_CPU_1 && pd <= PD_CPU_3) {
 299                         writel_relaxed(0x20002 << (pd - PD_CPU_1),
 300                                        RK_CRU_VIRT + RK312X_CRU_SOFTRSTS_CON(0));
 301                         dsb();
 302                 }
 303 #endif
 304         }
 305
 306         if (((pd == PD_GPU) || (pd == PD_VIO) || (pd == PD_VIDEO)))
 307                 ret = rk312x_pmu_set_power_domain(pd, on);
 308
 309         for (i = 0; i < RK312X_CRU_CLKGATES_CON_CNT; i++) {
 310                 cru_writel(clks_save[i] | 0xffff0000
 311                         , RK312X_CRU_CLKGATES_CON(i));
 312         }
 313
 314         return ret;
 315 }
 316
 317 static void __init rk312x_dt_init_timer(void)
 318 {
 319         rockchip_pmu_ops.set_power_domain = rk312x_sys_set_power_domain;
 320         rockchip_pmu_ops.power_domain_is_on = rk312x_pmu_power_domain_is_on;
 321         rockchip_pmu_ops.set_idle_request = rk312x_pmu_set_idle_request;
 322         of_clk_init(NULL);
 323         clocksource_of_init();
 324         of_dvfs_init();
 325 }
 326
 327 static void __init rk312x_reserve(void)
 328 {
 329         /* reserve memory for ION */
 330         rockchip_ion_reserve();
 331 }
 332 #ifdef CONFIG_PM
 333 static void __init rk321x_init_suspend(void);
 334 #endif
 335 static void __init rk312x_init_late(void)
 336 {
 337 #ifdef CONFIG_PM
 338         rk321x_init_suspend();
 339 #endif
 340 }
 341
 342 static void rk312x_restart(char mode, const char *cmd)
 343 {
 344         u32 boot_flag, boot_mode;
 345
 346         rockchip_restart_get_boot_mode(cmd, &boot_flag, &boot_mode);
 347
 348         /* for loader */
 349         writel_relaxed(boot_flag, RK_PMU_VIRT + RK312X_PMU_SYS_REG0);
 350         /* for linux */
 351         writel_relaxed(boot_mode, RK_PMU_VIRT + RK312X_PMU_SYS_REG1);
 352
 353         dsb();
 354
 355         /* pll enter slow mode */
 356         writel_relaxed(0x30110000, RK_CRU_VIRT + RK312X_CRU_MODE_CON);
 357         dsb();
 358         writel_relaxed(0xeca8, RK_CRU_VIRT + RK312X_CRU_GLB_SRST_SND_VALUE);
 359         dsb();
 360 }
 361
 362 DT_MACHINE_START(RK3126_DT, "Rockchip RK3126")
 363         .smp            = smp_ops(rockchip_smp_ops),
 364         .map_io         = rk3126_dt_map_io,
 365         .init_time      = rk312x_dt_init_timer,
 366         .dt_compat      = rk3126_dt_compat,
 367         .init_late      = rk312x_init_late,
 368         .reserve        = rk312x_reserve,
 369         .restart        = rk312x_restart,
 370 MACHINE_END
 371
 372 DT_MACHINE_START(RK3128_DT, "Rockchip RK3128")
 373         .smp            = smp_ops(rockchip_smp_ops),
 374         .map_io         = rk3128_dt_map_io,
 375         .init_time      = rk312x_dt_init_timer,
 376         .dt_compat      = rk3128_dt_compat,
 377         .init_late      = rk312x_init_late,
 378         .reserve        = rk312x_reserve,
 379         .restart        = rk312x_restart,
 380 MACHINE_END
 381
 382
 383 char PIE_DATA(sram_stack)[1024];
 384 EXPORT_PIE_SYMBOL(DATA(sram_stack));
 385
 386 static int __init rk312x_pie_init(void)
 387 {
 388         int err;
 389
 390         if (!cpu_is_rk312x())
 391                 return 0;
 392
 393         err = rockchip_pie_init();
 394         if (err)
 395                 return err;
 396
 397         rockchip_pie_chunk = pie_load_sections(rockchip_sram_pool, rk312x);
 398         if (IS_ERR(rockchip_pie_chunk)) {
 399                 err = PTR_ERR(rockchip_pie_chunk);
 400                 pr_err("%s: failed to load section %d\n", __func__, err);
 401                 rockchip_pie_chunk = NULL;
 402                 return err;
 403         }
 404
 405         rockchip_sram_virt = kern_to_pie(rockchip_pie_chunk, &__pie_common_start[0]);
 406         rockchip_sram_stack = kern_to_pie(rockchip_pie_chunk, (char *)DATA(sram_stack) + sizeof(DATA(sram_stack)));
 407
 408         return 0;
 409 }
 410 arch_initcall(rk312x_pie_init);
 411
 412 #include "ddr_rk3126.c"
 413 static int __init rk312x_ddr_init(void)
 414 {
 415         if (cpu_is_rk312x()) {
 416                 ddr_change_freq = _ddr_change_freq;
 417                 ddr_round_rate = _ddr_round_rate;
 418                 ddr_set_auto_self_refresh = _ddr_set_auto_self_refresh;
 419                 ddr_bandwidth_get = _ddr_bandwidth_get;
 420                 ddr_init(DDR3_DEFAULT, 300);
 421                 }
 422         return 0;
 423 }
 424 arch_initcall_sync(rk312x_ddr_init);
 425
 426 #ifdef CONFIG_PM
 427 static u32 rk_pmu_pwrdn_st;
 428 static inline void rk_pm_soc_pd_suspend(void)
 429 {
 430         rk_pmu_pwrdn_st = pmu_readl(RK312X_PMU_PWRDN_ST);
 431         if (!(rk_pmu_pwrdn_st & BIT(pmu_st_map[PD_GPU])))
 432                 rk312x_sys_set_power_domain(PD_GPU, false);
 433
 434         if (!(rk_pmu_pwrdn_st & BIT(pmu_st_map[PD_VIO])))
 435                 rk312x_sys_set_power_domain(PD_VIO, false);
 436
 437         if (!(rk_pmu_pwrdn_st & BIT(pmu_st_map[PD_VIDEO])))
 438                 rk312x_sys_set_power_domain(PD_VIDEO, false);
 439 }
 440 static inline void rk_pm_soc_pd_resume(void)
 441 {
 442         if (!(rk_pmu_pwrdn_st & BIT(pmu_st_map[PD_VIDEO])))
 443                 rk312x_sys_set_power_domain(PD_VIDEO, true);
 444
 445         if (!(rk_pmu_pwrdn_st & BIT(pmu_st_map[PD_VIO])))
 446                 rk312x_sys_set_power_domain(PD_VIO, true);
 447
 448         if (!(rk_pmu_pwrdn_st & BIT(pmu_st_map[PD_GPU])))
 449                 rk312x_sys_set_power_domain(PD_GPU, true);
 450 }
 451 static void __init rk321x_init_suspend(void)
 452 {
 453         pr_info("%s\n", __func__);
 454         rockchip_suspend_init();
 455         rk312x_suspend_init();
 456         rkpm_set_ops_pwr_dmns(rk_pm_soc_pd_suspend, rk_pm_soc_pd_resume);
 457 }
 458 #endif