2 * Copyright (c) 2013 MundoReader S.L.
3 * Author: Heiko Stuebner <heiko@sntech.de>
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
16 #include <linux/delay.h>
17 #include <linux/init.h>
18 #include <linux/smp.h>
21 #include <linux/of_address.h>
22 #include <linux/regmap.h>
23 #include <linux/mfd/syscon.h>
25 #include <linux/reset.h>
26 #include <linux/cpu.h>
27 #include <asm/cacheflush.h>
29 #include <asm/smp_scu.h>
30 #include <asm/smp_plat.h>
31 #include <asm/mach/map.h>
35 static void __iomem *scu_base_addr;
36 static void __iomem *sram_base_addr;
39 #define PMU_PWRDN_CON 0x08
40 #define PMU_PWRDN_ST 0x0c
42 #define PMU_PWRDN_SCU 4
44 static struct regmap *pmu;
46 static int pmu_power_domain_is_on(int pd)
51 ret = regmap_read(pmu, PMU_PWRDN_ST, &val);
55 return !(val & BIT(pd));
58 struct reset_control *rockchip_get_core_reset(int cpu)
60 struct device *dev = get_cpu_device(cpu);
61 struct device_node *np;
63 /* The cpu device is only available after the initial core bringup */
67 np = of_get_cpu_node(cpu, 0);
69 return of_reset_control_get(np, NULL);
72 static int pmu_set_power_domain(int pd, bool on)
74 u32 val = (on) ? 0 : BIT(pd);
78 * We need to soft reset the cpu when we turn off the cpu power domain,
79 * or else the active processors might be stalled when the individual
80 * processor is powered down.
82 if (read_cpuid_part() != ARM_CPU_PART_CORTEX_A9) {
83 struct reset_control *rstc = rockchip_get_core_reset(pd);
86 pr_err("%s: could not get reset control for core %d\n",
92 reset_control_deassert(rstc);
94 reset_control_assert(rstc);
96 reset_control_put(rstc);
99 ret = regmap_update_bits(pmu, PMU_PWRDN_CON, BIT(pd), val);
101 pr_err("%s: could not update power domain\n", __func__);
107 ret = pmu_power_domain_is_on(pd);
109 pr_err("%s: could not read power domain state\n",
119 * Handling of CPU cores
122 static int __cpuinit rockchip_boot_secondary(unsigned int cpu,
123 struct task_struct *idle)
127 if (!sram_base_addr || !pmu) {
128 pr_err("%s: sram or pmu missing for cpu boot\n", __func__);
133 pr_err("%s: cpu %d outside maximum number of cpus %d\n",
134 __func__, cpu, ncores);
139 ret = pmu_set_power_domain(0 + cpu, true);
143 if (read_cpuid_part() != ARM_CPU_PART_CORTEX_A9) {
144 /* We communicate with the bootrom to active the cpus other
145 * than cpu0, after a blob of initialize code, they will
146 * stay at wfe state, once they are actived, they will check
148 * sram_base_addr + 4: 0xdeadbeaf
149 * sram_base_addr + 8: start address for pc
152 writel(virt_to_phys(rockchip_secondary_startup),
154 writel(0xDEADBEAF, sram_base_addr + 4);
162 * rockchip_smp_prepare_sram - populate necessary sram block
163 * Starting cores execute the code residing at the start of the on-chip sram
164 * after power-on. Therefore make sure, this sram region is reserved and
165 * big enough. After this check, copy the trampoline code that directs the
166 * core to the real startup code in ram into the sram-region.
167 * @node: mmio-sram device node
169 static int __init rockchip_smp_prepare_sram(struct device_node *node)
171 unsigned int trampoline_sz = &rockchip_secondary_trampoline_end -
172 &rockchip_secondary_trampoline;
177 ret = of_address_to_resource(node, 0, &res);
179 pr_err("%s: could not get address for node %s\n",
180 __func__, node->full_name);
184 rsize = resource_size(&res);
185 if (rsize < trampoline_sz) {
186 pr_err("%s: reserved block with size 0x%x is to small for trampoline size 0x%x\n",
187 __func__, rsize, trampoline_sz);
191 /* set the boot function for the sram code */
192 rockchip_boot_fn = virt_to_phys(rockchip_secondary_startup);
194 /* copy the trampoline to sram, that runs during startup of the core */
195 memcpy(sram_base_addr, &rockchip_secondary_trampoline, trampoline_sz);
197 outer_clean_range(0, trampoline_sz);
204 static struct regmap_config rockchip_pmu_regmap_config = {
210 static int __init rockchip_smp_prepare_pmu(void)
212 struct device_node *node;
213 void __iomem *pmu_base;
216 * This function is only called via smp_ops->smp_prepare_cpu().
217 * That only happens if a "/cpus" device tree node exists
218 * and has an "enable-method" property that selects the SMP
219 * operations defined herein.
221 node = of_find_node_by_path("/cpus");
223 pmu = syscon_regmap_lookup_by_phandle(node, "rockchip,pmu");
228 pmu = syscon_regmap_lookup_by_compatible("rockchip,rk3066-pmu");
232 /* fallback, create our own regmap for the pmu area */
234 node = of_find_compatible_node(NULL, NULL, "rockchip,rk3066-pmu");
236 pr_err("%s: could not find pmu dt node\n", __func__);
240 pmu_base = of_iomap(node, 0);
242 pr_err("%s: could not map pmu registers\n", __func__);
246 pmu = regmap_init_mmio(NULL, pmu_base, &rockchip_pmu_regmap_config);
248 int ret = PTR_ERR(pmu);
252 pr_err("%s: regmap init failed\n", __func__);
259 static void __init rockchip_smp_prepare_cpus(unsigned int max_cpus)
261 struct device_node *node;
264 node = of_find_compatible_node(NULL, NULL, "rockchip,rk3066-smp-sram");
266 pr_err("%s: could not find sram dt node\n", __func__);
270 sram_base_addr = of_iomap(node, 0);
271 if (!sram_base_addr) {
272 pr_err("%s: could not map sram registers\n", __func__);
276 if (rockchip_smp_prepare_pmu())
279 if (read_cpuid_part() == ARM_CPU_PART_CORTEX_A9) {
280 if (rockchip_smp_prepare_sram(node))
283 /* enable the SCU power domain */
284 pmu_set_power_domain(PMU_PWRDN_SCU, true);
286 node = of_find_compatible_node(NULL, NULL, "arm,cortex-a9-scu");
288 pr_err("%s: missing scu\n", __func__);
292 scu_base_addr = of_iomap(node, 0);
293 if (!scu_base_addr) {
294 pr_err("%s: could not map scu registers\n", __func__);
299 * While the number of cpus is gathered from dt, also get the
300 * number of cores from the scu to verify this value when
303 ncores = scu_get_core_count(scu_base_addr);
304 pr_err("%s: ncores %d\n", __func__, ncores);
306 scu_enable(scu_base_addr);
310 asm ("mrc p15, 1, %0, c9, c0, 2\n" : "=r" (l2ctlr));
311 ncores = ((l2ctlr >> 24) & 0x3) + 1;
314 /* Make sure that all cores except the first are really off */
315 for (i = 1; i < ncores; i++)
316 pmu_set_power_domain(0 + i, false);
319 #ifdef CONFIG_HOTPLUG_CPU
320 static int rockchip_cpu_kill(unsigned int cpu)
322 pmu_set_power_domain(0 + cpu, false);
326 static void rockchip_cpu_die(unsigned int cpu)
328 v7_exit_coherency_flush(louis);
334 static struct smp_operations rockchip_smp_ops __initdata = {
335 .smp_prepare_cpus = rockchip_smp_prepare_cpus,
336 .smp_boot_secondary = rockchip_boot_secondary,
337 #ifdef CONFIG_HOTPLUG_CPU
338 .cpu_kill = rockchip_cpu_kill,
339 .cpu_die = rockchip_cpu_die,
342 CPU_METHOD_OF_DECLARE(rk3066_smp, "rockchip,rk3066-smp", &rockchip_smp_ops);