2 * arch/arm/common/mcpm_entry.c -- entry point for multi-cluster PM
4 * Created by: Nicolas Pitre, March 2012
5 * Copyright: (C) 2012-2013 Linaro Limited
7 * This program is free software; you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License version 2 as
9 * published by the Free Software Foundation.
12 #include <linux/kernel.h>
13 #include <linux/init.h>
14 #include <linux/irqflags.h>
17 #include <asm/cacheflush.h>
18 #include <asm/idmap.h>
19 #include <asm/cputype.h>
21 extern unsigned long mcpm_entry_vectors
[MAX_NR_CLUSTERS
][MAX_CPUS_PER_CLUSTER
];
23 void mcpm_set_entry_vector(unsigned cpu
, unsigned cluster
, void *ptr
)
25 unsigned long val
= ptr
? virt_to_phys(ptr
) : 0;
26 mcpm_entry_vectors
[cluster
][cpu
] = val
;
27 sync_cache_w(&mcpm_entry_vectors
[cluster
][cpu
]);
30 extern unsigned long mcpm_entry_early_pokes
[MAX_NR_CLUSTERS
][MAX_CPUS_PER_CLUSTER
][2];
32 void mcpm_set_early_poke(unsigned cpu
, unsigned cluster
,
33 unsigned long poke_phys_addr
, unsigned long poke_val
)
35 unsigned long *poke
= &mcpm_entry_early_pokes
[cluster
][cpu
][0];
36 poke
[0] = poke_phys_addr
;
38 __cpuc_flush_dcache_area((void *)poke
, 8);
39 outer_clean_range(__pa(poke
), __pa(poke
+ 2));
42 static const struct mcpm_platform_ops
*platform_ops
;
44 int __init
mcpm_platform_register(const struct mcpm_platform_ops
*ops
)
52 int mcpm_cpu_power_up(unsigned int cpu
, unsigned int cluster
)
55 return -EUNATCH
; /* try not to shadow power_up errors */
57 return platform_ops
->power_up(cpu
, cluster
);
60 typedef void (*phys_reset_t
)(unsigned long);
62 void mcpm_cpu_power_down(void)
64 phys_reset_t phys_reset
;
66 if (WARN_ON_ONCE(!platform_ops
|| !platform_ops
->power_down
))
68 BUG_ON(!irqs_disabled());
71 * Do this before calling into the power_down method,
72 * as it might not always be safe to do afterwards.
74 setup_mm_for_reboot();
76 platform_ops
->power_down();
79 * It is possible for a power_up request to happen concurrently
80 * with a power_down request for the same CPU. In this case the
81 * power_down method might not be able to actually enter a
82 * powered down state with the WFI instruction if the power_up
83 * method has removed the required reset condition. The
84 * power_down method is then allowed to return. We must perform
85 * a re-entry in the kernel as if the power_up method just had
86 * deasserted reset on the CPU.
88 * To simplify race issues, the platform specific implementation
89 * must accommodate for the possibility of unordered calls to
90 * power_down and power_up with a usage count. Therefore, if a
91 * call to power_up is issued for a CPU that is not down, then
92 * the next call to power_down must not attempt a full shutdown
93 * but only do the minimum (normally disabling L1 cache and CPU
94 * coherency) and return just as if a concurrent power_up request
95 * had happened as described above.
98 phys_reset
= (phys_reset_t
)(unsigned long)virt_to_phys(cpu_reset
);
99 phys_reset(virt_to_phys(mcpm_entry_point
));
101 /* should never get here */
105 int mcpm_cpu_power_down_finish(unsigned int cpu
, unsigned int cluster
)
109 if (WARN_ON_ONCE(!platform_ops
|| !platform_ops
->power_down_finish
))
112 ret
= platform_ops
->power_down_finish(cpu
, cluster
);
114 pr_warn("%s: cpu %u, cluster %u failed to power down (%d)\n",
115 __func__
, cpu
, cluster
, ret
);
120 void mcpm_cpu_suspend(u64 expected_residency
)
122 phys_reset_t phys_reset
;
124 if (WARN_ON_ONCE(!platform_ops
|| !platform_ops
->suspend
))
126 BUG_ON(!irqs_disabled());
128 /* Very similar to mcpm_cpu_power_down() */
129 setup_mm_for_reboot();
130 platform_ops
->suspend(expected_residency
);
131 phys_reset
= (phys_reset_t
)(unsigned long)virt_to_phys(cpu_reset
);
132 phys_reset(virt_to_phys(mcpm_entry_point
));
136 int mcpm_cpu_powered_up(void)
140 if (platform_ops
->powered_up
)
141 platform_ops
->powered_up();
145 struct sync_struct mcpm_sync
;
148 * __mcpm_cpu_going_down: Indicates that the cpu is being torn down.
149 * This must be called at the point of committing to teardown of a CPU.
150 * The CPU cache (SCTRL.C bit) is expected to still be active.
152 void __mcpm_cpu_going_down(unsigned int cpu
, unsigned int cluster
)
154 mcpm_sync
.clusters
[cluster
].cpus
[cpu
].cpu
= CPU_GOING_DOWN
;
155 sync_cache_w(&mcpm_sync
.clusters
[cluster
].cpus
[cpu
].cpu
);
159 * __mcpm_cpu_down: Indicates that cpu teardown is complete and that the
160 * cluster can be torn down without disrupting this CPU.
161 * To avoid deadlocks, this must be called before a CPU is powered down.
162 * The CPU cache (SCTRL.C bit) is expected to be off.
163 * However L2 cache might or might not be active.
165 void __mcpm_cpu_down(unsigned int cpu
, unsigned int cluster
)
168 mcpm_sync
.clusters
[cluster
].cpus
[cpu
].cpu
= CPU_DOWN
;
169 sync_cache_w(&mcpm_sync
.clusters
[cluster
].cpus
[cpu
].cpu
);
174 * __mcpm_outbound_leave_critical: Leave the cluster teardown critical section.
175 * @state: the final state of the cluster:
176 * CLUSTER_UP: no destructive teardown was done and the cluster has been
177 * restored to the previous state (CPU cache still active); or
178 * CLUSTER_DOWN: the cluster has been torn-down, ready for power-off
179 * (CPU cache disabled, L2 cache either enabled or disabled).
181 void __mcpm_outbound_leave_critical(unsigned int cluster
, int state
)
184 mcpm_sync
.clusters
[cluster
].cluster
= state
;
185 sync_cache_w(&mcpm_sync
.clusters
[cluster
].cluster
);
190 * __mcpm_outbound_enter_critical: Enter the cluster teardown critical section.
191 * This function should be called by the last man, after local CPU teardown
192 * is complete. CPU cache expected to be active.
195 * false: the critical section was not entered because an inbound CPU was
196 * observed, or the cluster is already being set up;
197 * true: the critical section was entered: it is now safe to tear down the
200 bool __mcpm_outbound_enter_critical(unsigned int cpu
, unsigned int cluster
)
203 struct mcpm_sync_struct
*c
= &mcpm_sync
.clusters
[cluster
];
205 /* Warn inbound CPUs that the cluster is being torn down: */
206 c
->cluster
= CLUSTER_GOING_DOWN
;
207 sync_cache_w(&c
->cluster
);
209 /* Back out if the inbound cluster is already in the critical region: */
210 sync_cache_r(&c
->inbound
);
211 if (c
->inbound
== INBOUND_COMING_UP
)
215 * Wait for all CPUs to get out of the GOING_DOWN state, so that local
216 * teardown is complete on each CPU before tearing down the cluster.
218 * If any CPU has been woken up again from the DOWN state, then we
219 * shouldn't be taking the cluster down at all: abort in that case.
221 sync_cache_r(&c
->cpus
);
222 for (i
= 0; i
< MAX_CPUS_PER_CLUSTER
; i
++) {
229 cpustate
= c
->cpus
[i
].cpu
;
230 if (cpustate
!= CPU_GOING_DOWN
)
234 sync_cache_r(&c
->cpus
[i
].cpu
);
249 __mcpm_outbound_leave_critical(cluster
, CLUSTER_UP
);
253 int __mcpm_cluster_state(unsigned int cluster
)
255 sync_cache_r(&mcpm_sync
.clusters
[cluster
].cluster
);
256 return mcpm_sync
.clusters
[cluster
].cluster
;
259 extern unsigned long mcpm_power_up_setup_phys
;
261 int __init
mcpm_sync_init(
262 void (*power_up_setup
)(unsigned int affinity_level
))
264 unsigned int i
, j
, mpidr
, this_cluster
;
266 BUILD_BUG_ON(MCPM_SYNC_CLUSTER_SIZE
* MAX_NR_CLUSTERS
!= sizeof mcpm_sync
);
267 BUG_ON((unsigned long)&mcpm_sync
& (__CACHE_WRITEBACK_GRANULE
- 1));
270 * Set initial CPU and cluster states.
271 * Only one cluster is assumed to be active at this point.
273 for (i
= 0; i
< MAX_NR_CLUSTERS
; i
++) {
274 mcpm_sync
.clusters
[i
].cluster
= CLUSTER_DOWN
;
275 mcpm_sync
.clusters
[i
].inbound
= INBOUND_NOT_COMING_UP
;
276 for (j
= 0; j
< MAX_CPUS_PER_CLUSTER
; j
++)
277 mcpm_sync
.clusters
[i
].cpus
[j
].cpu
= CPU_DOWN
;
279 mpidr
= read_cpuid_mpidr();
280 this_cluster
= MPIDR_AFFINITY_LEVEL(mpidr
, 1);
281 for_each_online_cpu(i
)
282 mcpm_sync
.clusters
[this_cluster
].cpus
[i
].cpu
= CPU_UP
;
283 mcpm_sync
.clusters
[this_cluster
].cluster
= CLUSTER_UP
;
284 sync_cache_w(&mcpm_sync
);
286 if (power_up_setup
) {
287 mcpm_power_up_setup_phys
= virt_to_phys(power_up_setup
);
288 sync_cache_w(&mcpm_power_up_setup_phys
);