bL_switcher.c

  1// SPDX-License-Identifier: GPL-2.0-only
  2/*
  3 * arch/arm/common/bL_switcher.c -- big.LITTLE cluster switcher core driver
  4 *
  5 * Created by:	Nicolas Pitre, March 2012
  6 * Copyright:	(C) 2012-2013  Linaro Limited
  7 */
  8
  9#include <linux/atomic.h>
 10#include <linux/init.h>
 11#include <linux/kernel.h>
 12#include <linux/module.h>
 13#include <linux/sched/signal.h>
 14#include <uapi/linux/sched/types.h>
 15#include <linux/interrupt.h>
 16#include <linux/cpu_pm.h>
 17#include <linux/cpu.h>
 18#include <linux/cpumask.h>
 19#include <linux/kthread.h>
 20#include <linux/wait.h>
 21#include <linux/time.h>
 22#include <linux/clockchips.h>
 23#include <linux/hrtimer.h>
 24#include <linux/tick.h>
 25#include <linux/notifier.h>
 26#include <linux/mm.h>
 27#include <linux/mutex.h>
 28#include <linux/smp.h>
 29#include <linux/spinlock.h>
 30#include <linux/string.h>
 31#include <linux/sysfs.h>
 32#include <linux/irqchip/arm-gic.h>
 33#include <linux/moduleparam.h>
 34
 35#include <asm/smp_plat.h>
 36#include <asm/cputype.h>
 37#include <asm/suspend.h>
 38#include <asm/mcpm.h>
 39#include <asm/bL_switcher.h>
 40
 41#define CREATE_TRACE_POINTS
 42#include <trace/events/power_cpu_migrate.h>
 43
 44
 45/*
 46 * Use our own MPIDR accessors as the generic ones in asm/cputype.h have
 47 * __attribute_const__ and we don't want the compiler to assume any
 48 * constness here as the value _does_ change along some code paths.
 49 */
 50
 51static int read_mpidr(void)
 52{
 53	unsigned int id;
 54	asm volatile ("mrc p15, 0, %0, c0, c0, 5" : "=r" (id));
 55	return id & MPIDR_HWID_BITMASK;
 56}
 57
 58/*
 59 * bL switcher core code.
 60 */
 61
 62static void bL_do_switch(void *_arg)
 63{
 64	unsigned ib_mpidr, ib_cpu, ib_cluster;
 65	long volatile handshake, **handshake_ptr = _arg;
 66
 67	pr_debug("%s\n", __func__);
 68
 69	ib_mpidr = cpu_logical_map(smp_processor_id());
 70	ib_cpu = MPIDR_AFFINITY_LEVEL(ib_mpidr, 0);
 71	ib_cluster = MPIDR_AFFINITY_LEVEL(ib_mpidr, 1);
 72
 73	/* Advertise our handshake location */
 74	if (handshake_ptr) {
 75		handshake = 0;
 76		*handshake_ptr = &handshake;
 77	} else
 78		handshake = -1;
 79
 80	/*
 81	 * Our state has been saved at this point.  Let's release our
 82	 * inbound CPU.
 83	 */
 84	mcpm_set_entry_vector(ib_cpu, ib_cluster, cpu_resume);
 85	sev();
 86
 87	/*
 88	 * From this point, we must assume that our counterpart CPU might
 89	 * have taken over in its parallel world already, as if execution
 90	 * just returned from cpu_suspend().  It is therefore important to
 91	 * be very careful not to make any change the other guy is not
 92	 * expecting.  This is why we need stack isolation.
 93	 *
 94	 * Fancy under cover tasks could be performed here.  For now
 95	 * we have none.
 96	 */
 97
 98	/*
 99	 * Let's wait until our inbound is alive.
100	 */
101	while (!handshake) {
102		wfe();
103		smp_mb();
104	}
105
106	/* Let's put ourself down. */
107	mcpm_cpu_power_down();
108
109	/* should never get here */
110	BUG();
111}
112
113/*
114 * Stack isolation.  To ensure 'current' remains valid, we just use another
115 * piece of our thread's stack space which should be fairly lightly used.
116 * The selected area starts just above the thread_info structure located
117 * at the very bottom of the stack, aligned to a cache line, and indexed
118 * with the cluster number.
119 */
120#define STACK_SIZE 512
121extern void call_with_stack(void (*fn)(void *), void *arg, void *sp);
122static int bL_switchpoint(unsigned long _arg)
123{
124	unsigned int mpidr = read_mpidr();
125	unsigned int clusterid = MPIDR_AFFINITY_LEVEL(mpidr, 1);
126	void *stack = current_thread_info() + 1;
127	stack = PTR_ALIGN(stack, L1_CACHE_BYTES);
128	stack += clusterid * STACK_SIZE + STACK_SIZE;
129	call_with_stack(bL_do_switch, (void *)_arg, stack);
130	BUG();
131}
132
133/*
134 * Generic switcher interface
135 */
136
137static unsigned int bL_gic_id[MAX_CPUS_PER_CLUSTER][MAX_NR_CLUSTERS];
138static int bL_switcher_cpu_pairing[NR_CPUS];
139
140/*
141 * bL_switch_to - Switch to a specific cluster for the current CPU
142 * @new_cluster_id: the ID of the cluster to switch to.
143 *
144 * This function must be called on the CPU to be switched.
145 * Returns 0 on success, else a negative status code.
146 */
147static int bL_switch_to(unsigned int new_cluster_id)
148{
149	unsigned int mpidr, this_cpu, that_cpu;
150	unsigned int ob_mpidr, ob_cpu, ob_cluster, ib_mpidr, ib_cpu, ib_cluster;
151	struct completion inbound_alive;
152	long volatile *handshake_ptr;
153	int ipi_nr, ret;
154
155	this_cpu = smp_processor_id();
156	ob_mpidr = read_mpidr();
157	ob_cpu = MPIDR_AFFINITY_LEVEL(ob_mpidr, 0);
158	ob_cluster = MPIDR_AFFINITY_LEVEL(ob_mpidr, 1);
159	BUG_ON(cpu_logical_map(this_cpu) != ob_mpidr);
160
161	if (new_cluster_id == ob_cluster)
162		return 0;
163
164	that_cpu = bL_switcher_cpu_pairing[this_cpu];
165	ib_mpidr = cpu_logical_map(that_cpu);
166	ib_cpu = MPIDR_AFFINITY_LEVEL(ib_mpidr, 0);
167	ib_cluster = MPIDR_AFFINITY_LEVEL(ib_mpidr, 1);
168
169	pr_debug("before switch: CPU %d MPIDR %#x -> %#x\n",
170		 this_cpu, ob_mpidr, ib_mpidr);
171
172	this_cpu = smp_processor_id();
173
174	/* Close the gate for our entry vectors */
175	mcpm_set_entry_vector(ob_cpu, ob_cluster, NULL);
176	mcpm_set_entry_vector(ib_cpu, ib_cluster, NULL);
177
178	/* Install our "inbound alive" notifier. */
179	init_completion(&inbound_alive);
180	ipi_nr = register_ipi_completion(&inbound_alive, this_cpu);
181	ipi_nr |= ((1 << 16) << bL_gic_id[ob_cpu][ob_cluster]);
182	mcpm_set_early_poke(ib_cpu, ib_cluster, gic_get_sgir_physaddr(), ipi_nr);
183
184	/*
185	 * Let's wake up the inbound CPU now in case it requires some delay
186	 * to come online, but leave it gated in our entry vector code.
187	 */
188	ret = mcpm_cpu_power_up(ib_cpu, ib_cluster);
189	if (ret) {
190		pr_err("%s: mcpm_cpu_power_up() returned %d\n", __func__, ret);
191		return ret;
192	}
193
194	/*
195	 * Raise a SGI on the inbound CPU to make sure it doesn't stall
196	 * in a possible WFI, such as in bL_power_down().
197	 */
198	gic_send_sgi(bL_gic_id[ib_cpu][ib_cluster], 0);
199
200	/*
201	 * Wait for the inbound to come up.  This allows for other
202	 * tasks to be scheduled in the mean time.
203	 */
204	wait_for_completion(&inbound_alive);
205	mcpm_set_early_poke(ib_cpu, ib_cluster, 0, 0);
206
207	/*
208	 * From this point we are entering the switch critical zone
209	 * and can't take any interrupts anymore.
210	 */
211	local_irq_disable();
212	local_fiq_disable();
213	trace_cpu_migrate_begin(ktime_get_real_ns(), ob_mpidr);
214
215	/* redirect GIC's SGIs to our counterpart */
216	gic_migrate_target(bL_gic_id[ib_cpu][ib_cluster]);
217
218	tick_suspend_local();
219
220	ret = cpu_pm_enter();
221
222	/* we can not tolerate errors at this point */
223	if (ret)
224		panic("%s: cpu_pm_enter() returned %d\n", __func__, ret);
225
226	/* Swap the physical CPUs in the logical map for this logical CPU. */
227	cpu_logical_map(this_cpu) = ib_mpidr;
228	cpu_logical_map(that_cpu) = ob_mpidr;
229
230	/* Let's do the actual CPU switch. */
231	ret = cpu_suspend((unsigned long)&handshake_ptr, bL_switchpoint);
232	if (ret > 0)
233		panic("%s: cpu_suspend() returned %d\n", __func__, ret);
234
235	/* We are executing on the inbound CPU at this point */
236	mpidr = read_mpidr();
237	pr_debug("after switch: CPU %d MPIDR %#x\n", this_cpu, mpidr);
238	BUG_ON(mpidr != ib_mpidr);
239
240	mcpm_cpu_powered_up();
241
242	ret = cpu_pm_exit();
243
244	tick_resume_local();
245
246	trace_cpu_migrate_finish(ktime_get_real_ns(), ib_mpidr);
247	local_fiq_enable();
248	local_irq_enable();
249
250	*handshake_ptr = 1;
251	dsb_sev();
252
253	if (ret)
254		pr_err("%s exiting with error %d\n", __func__, ret);
255	return ret;
256}
257
258struct bL_thread {
259	spinlock_t lock;
260	struct task_struct *task;
261	wait_queue_head_t wq;
262	int wanted_cluster;
263	struct completion started;
264	bL_switch_completion_handler completer;
265	void *completer_cookie;
266};
267
268static struct bL_thread bL_threads[NR_CPUS];
269
270static int bL_switcher_thread(void *arg)
271{
272	struct bL_thread *t = arg;
273	int cluster;
274	bL_switch_completion_handler completer;
275	void *completer_cookie;
276
277	sched_set_fifo_low(current);
278	complete(&t->started);
279
280	do {
281		if (signal_pending(current))
282			flush_signals(current);
283		wait_event_interruptible(t->wq,
284				t->wanted_cluster != -1 ||
285				kthread_should_stop());
286
287		spin_lock(&t->lock);
288		cluster = t->wanted_cluster;
289		completer = t->completer;
290		completer_cookie = t->completer_cookie;
291		t->wanted_cluster = -1;
292		t->completer = NULL;
293		spin_unlock(&t->lock);
294
295		if (cluster != -1) {
296			bL_switch_to(cluster);
297
298			if (completer)
299				completer(completer_cookie);
300		}
301	} while (!kthread_should_stop());
302
303	return 0;
304}
305
306static struct task_struct *bL_switcher_thread_create(int cpu, void *arg)
307{
308	struct task_struct *task;
309
310	task = kthread_run_on_cpu(bL_switcher_thread, arg,
311				  cpu, "kswitcher_%d");
312	if (IS_ERR(task))
313		pr_err("%s failed for CPU %d\n", __func__, cpu);
314
315	return task;
316}
317
318/*
319 * bL_switch_request_cb - Switch to a specific cluster for the given CPU,
320 *      with completion notification via a callback
321 *
322 * @cpu: the CPU to switch
323 * @new_cluster_id: the ID of the cluster to switch to.
324 * @completer: switch completion callback.  if non-NULL,
325 *	@completer(@completer_cookie) will be called on completion of
326 *	the switch, in non-atomic context.
327 * @completer_cookie: opaque context argument for @completer.
328 *
329 * This function causes a cluster switch on the given CPU by waking up
330 * the appropriate switcher thread.  This function may or may not return
331 * before the switch has occurred.
332 *
333 * If a @completer callback function is supplied, it will be called when
334 * the switch is complete.  This can be used to determine asynchronously
335 * when the switch is complete, regardless of when bL_switch_request()
336 * returns.  When @completer is supplied, no new switch request is permitted
337 * for the affected CPU until after the switch is complete, and @completer
338 * has returned.
339 */
340int bL_switch_request_cb(unsigned int cpu, unsigned int new_cluster_id,
341			 bL_switch_completion_handler completer,
342			 void *completer_cookie)
343{
344	struct bL_thread *t;
345
346	if (cpu >= ARRAY_SIZE(bL_threads)) {
347		pr_err("%s: cpu %d out of bounds\n", __func__, cpu);
348		return -EINVAL;
349	}
350
351	t = &bL_threads[cpu];
352
353	if (IS_ERR(t->task))
354		return PTR_ERR(t->task);
355	if (!t->task)
356		return -ESRCH;
357
358	spin_lock(&t->lock);
359	if (t->completer) {
360		spin_unlock(&t->lock);
361		return -EBUSY;
362	}
363	t->completer = completer;
364	t->completer_cookie = completer_cookie;
365	t->wanted_cluster = new_cluster_id;
366	spin_unlock(&t->lock);
367	wake_up(&t->wq);
368	return 0;
369}
370EXPORT_SYMBOL_GPL(bL_switch_request_cb);
371
372/*
373 * Activation and configuration code.
374 */
375
376static DEFINE_MUTEX(bL_switcher_activation_lock);
377static BLOCKING_NOTIFIER_HEAD(bL_activation_notifier);
378static unsigned int bL_switcher_active;
379static unsigned int bL_switcher_cpu_original_cluster[NR_CPUS];
380static cpumask_t bL_switcher_removed_logical_cpus;
381
382int bL_switcher_register_notifier(struct notifier_block *nb)
383{
384	return blocking_notifier_chain_register(&bL_activation_notifier, nb);
385}
386EXPORT_SYMBOL_GPL(bL_switcher_register_notifier);
387
388int bL_switcher_unregister_notifier(struct notifier_block *nb)
389{
390	return blocking_notifier_chain_unregister(&bL_activation_notifier, nb);
391}
392EXPORT_SYMBOL_GPL(bL_switcher_unregister_notifier);
393
394static int bL_activation_notify(unsigned long val)
395{
396	int ret;
397
398	ret = blocking_notifier_call_chain(&bL_activation_notifier, val, NULL);
399	if (ret & NOTIFY_STOP_MASK)
400		pr_err("%s: notifier chain failed with status 0x%x\n",
401			__func__, ret);
402	return notifier_to_errno(ret);
403}
404
405static void bL_switcher_restore_cpus(void)
406{
407	int i;
408
409	for_each_cpu(i, &bL_switcher_removed_logical_cpus) {
410		struct device *cpu_dev = get_cpu_device(i);
411		int ret = device_online(cpu_dev);
412		if (ret)
413			dev_err(cpu_dev, "switcher: unable to restore CPU\n");
414	}
415}
416
417static int bL_switcher_halve_cpus(void)
418{
419	int i, j, cluster_0, gic_id, ret;
420	unsigned int cpu, cluster, mask;
421	cpumask_t available_cpus;
422
423	/* First pass to validate what we have */
424	mask = 0;
425	for_each_online_cpu(i) {
426		cpu = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 0);
427		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 1);
428		if (cluster >= 2) {
429			pr_err("%s: only dual cluster systems are supported\n", __func__);
430			return -EINVAL;
431		}
432		if (WARN_ON(cpu >= MAX_CPUS_PER_CLUSTER))
433			return -EINVAL;
434		mask |= (1 << cluster);
435	}
436	if (mask != 3) {
437		pr_err("%s: no CPU pairing possible\n", __func__);
438		return -EINVAL;
439	}
440
441	/*
442	 * Now let's do the pairing.  We match each CPU with another CPU
443	 * from a different cluster.  To get a uniform scheduling behavior
444	 * without fiddling with CPU topology and compute capacity data,
445	 * we'll use logical CPUs initially belonging to the same cluster.
446	 */
447	memset(bL_switcher_cpu_pairing, -1, sizeof(bL_switcher_cpu_pairing));
448	cpumask_copy(&available_cpus, cpu_online_mask);
449	cluster_0 = -1;
450	for_each_cpu(i, &available_cpus) {
451		int match = -1;
452		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 1);
453		if (cluster_0 == -1)
454			cluster_0 = cluster;
455		if (cluster != cluster_0)
456			continue;
457		cpumask_clear_cpu(i, &available_cpus);
458		for_each_cpu(j, &available_cpus) {
459			cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(j), 1);
460			/*
461			 * Let's remember the last match to create "odd"
462			 * pairings on purpose in order for other code not
463			 * to assume any relation between physical and
464			 * logical CPU numbers.
465			 */
466			if (cluster != cluster_0)
467				match = j;
468		}
469		if (match != -1) {
470			bL_switcher_cpu_pairing[i] = match;
471			cpumask_clear_cpu(match, &available_cpus);
472			pr_info("CPU%d paired with CPU%d\n", i, match);
473		}
474	}
475
476	/*
477	 * Now we disable the unwanted CPUs i.e. everything that has no
478	 * pairing information (that includes the pairing counterparts).
479	 */
480	cpumask_clear(&bL_switcher_removed_logical_cpus);
481	for_each_online_cpu(i) {
482		cpu = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 0);
483		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(i), 1);
484
485		/* Let's take note of the GIC ID for this CPU */
486		gic_id = gic_get_cpu_id(i);
487		if (gic_id < 0) {
488			pr_err("%s: bad GIC ID for CPU %d\n", __func__, i);
489			bL_switcher_restore_cpus();
490			return -EINVAL;
491		}
492		bL_gic_id[cpu][cluster] = gic_id;
493		pr_info("GIC ID for CPU %u cluster %u is %u\n",
494			cpu, cluster, gic_id);
495
496		if (bL_switcher_cpu_pairing[i] != -1) {
497			bL_switcher_cpu_original_cluster[i] = cluster;
498			continue;
499		}
500
501		ret = device_offline(get_cpu_device(i));
502		if (ret) {
503			bL_switcher_restore_cpus();
504			return ret;
505		}
506		cpumask_set_cpu(i, &bL_switcher_removed_logical_cpus);
507	}
508
509	return 0;
510}
511
512/* Determine the logical CPU a given physical CPU is grouped on. */
513int bL_switcher_get_logical_index(u32 mpidr)
514{
515	int cpu;
516
517	if (!bL_switcher_active)
518		return -EUNATCH;
519
520	mpidr &= MPIDR_HWID_BITMASK;
521	for_each_online_cpu(cpu) {
522		int pairing = bL_switcher_cpu_pairing[cpu];
523		if (pairing == -1)
524			continue;
525		if ((mpidr == cpu_logical_map(cpu)) ||
526		    (mpidr == cpu_logical_map(pairing)))
527			return cpu;
528	}
529	return -EINVAL;
530}
531
532static void bL_switcher_trace_trigger_cpu(void *__always_unused info)
533{
534	trace_cpu_migrate_current(ktime_get_real_ns(), read_mpidr());
535}
536
537int bL_switcher_trace_trigger(void)
538{
539	preempt_disable();
540
541	bL_switcher_trace_trigger_cpu(NULL);
542	smp_call_function(bL_switcher_trace_trigger_cpu, NULL, true);
543
544	preempt_enable();
545
546	return 0;
547}
548EXPORT_SYMBOL_GPL(bL_switcher_trace_trigger);
549
550static int bL_switcher_enable(void)
551{
552	int cpu, ret;
553
554	mutex_lock(&bL_switcher_activation_lock);
555	lock_device_hotplug();
556	if (bL_switcher_active) {
557		unlock_device_hotplug();
558		mutex_unlock(&bL_switcher_activation_lock);
559		return 0;
560	}
561
562	pr_info("big.LITTLE switcher initializing\n");
563
564	ret = bL_activation_notify(BL_NOTIFY_PRE_ENABLE);
565	if (ret)
566		goto error;
567
568	ret = bL_switcher_halve_cpus();
569	if (ret)
570		goto error;
571
572	bL_switcher_trace_trigger();
573
574	for_each_online_cpu(cpu) {
575		struct bL_thread *t = &bL_threads[cpu];
576		spin_lock_init(&t->lock);
577		init_waitqueue_head(&t->wq);
578		init_completion(&t->started);
579		t->wanted_cluster = -1;
580		t->task = bL_switcher_thread_create(cpu, t);
581	}
582
583	bL_switcher_active = 1;
584	bL_activation_notify(BL_NOTIFY_POST_ENABLE);
585	pr_info("big.LITTLE switcher initialized\n");
586	goto out;
587
588error:
589	pr_warn("big.LITTLE switcher initialization failed\n");
590	bL_activation_notify(BL_NOTIFY_POST_DISABLE);
591
592out:
593	unlock_device_hotplug();
594	mutex_unlock(&bL_switcher_activation_lock);
595	return ret;
596}
597
598#ifdef CONFIG_SYSFS
599
600static void bL_switcher_disable(void)
601{
602	unsigned int cpu, cluster;
603	struct bL_thread *t;
604	struct task_struct *task;
605
606	mutex_lock(&bL_switcher_activation_lock);
607	lock_device_hotplug();
608
609	if (!bL_switcher_active)
610		goto out;
611
612	if (bL_activation_notify(BL_NOTIFY_PRE_DISABLE) != 0) {
613		bL_activation_notify(BL_NOTIFY_POST_ENABLE);
614		goto out;
615	}
616
617	bL_switcher_active = 0;
618
619	/*
620	 * To deactivate the switcher, we must shut down the switcher
621	 * threads to prevent any other requests from being accepted.
622	 * Then, if the final cluster for given logical CPU is not the
623	 * same as the original one, we'll recreate a switcher thread
624	 * just for the purpose of switching the CPU back without any
625	 * possibility for interference from external requests.
626	 */
627	for_each_online_cpu(cpu) {
628		t = &bL_threads[cpu];
629		task = t->task;
630		t->task = NULL;
631		if (!task || IS_ERR(task))
632			continue;
633		kthread_stop(task);
634		/* no more switch may happen on this CPU at this point */
635		cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(cpu), 1);
636		if (cluster == bL_switcher_cpu_original_cluster[cpu])
637			continue;
638		init_completion(&t->started);
639		t->wanted_cluster = bL_switcher_cpu_original_cluster[cpu];
640		task = bL_switcher_thread_create(cpu, t);
641		if (!IS_ERR(task)) {
642			wait_for_completion(&t->started);
643			kthread_stop(task);
644			cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(cpu), 1);
645			if (cluster == bL_switcher_cpu_original_cluster[cpu])
646				continue;
647		}
648		/* If execution gets here, we're in trouble. */
649		pr_crit("%s: unable to restore original cluster for CPU %d\n",
650			__func__, cpu);
651		pr_crit("%s: CPU %d can't be restored\n",
652			__func__, bL_switcher_cpu_pairing[cpu]);
653		cpumask_clear_cpu(bL_switcher_cpu_pairing[cpu],
654				  &bL_switcher_removed_logical_cpus);
655	}
656
657	bL_switcher_restore_cpus();
658	bL_switcher_trace_trigger();
659
660	bL_activation_notify(BL_NOTIFY_POST_DISABLE);
661
662out:
663	unlock_device_hotplug();
664	mutex_unlock(&bL_switcher_activation_lock);
665}
666
667static ssize_t bL_switcher_active_show(struct kobject *kobj,
668		struct kobj_attribute *attr, char *buf)
669{
670	return sprintf(buf, "%u\n", bL_switcher_active);
671}
672
673static ssize_t bL_switcher_active_store(struct kobject *kobj,
674		struct kobj_attribute *attr, const char *buf, size_t count)
675{
676	int ret;
677
678	switch (buf[0]) {
679	case '0':
680		bL_switcher_disable();
681		ret = 0;
682		break;
683	case '1':
684		ret = bL_switcher_enable();
685		break;
686	default:
687		ret = -EINVAL;
688	}
689
690	return (ret >= 0) ? count : ret;
691}
692
693static ssize_t bL_switcher_trace_trigger_store(struct kobject *kobj,
694		struct kobj_attribute *attr, const char *buf, size_t count)
695{
696	int ret = bL_switcher_trace_trigger();
697
698	return ret ? ret : count;
699}
700
701static struct kobj_attribute bL_switcher_active_attr =
702	__ATTR(active, 0644, bL_switcher_active_show, bL_switcher_active_store);
703
704static struct kobj_attribute bL_switcher_trace_trigger_attr =
705	__ATTR(trace_trigger, 0200, NULL, bL_switcher_trace_trigger_store);
706
707static struct attribute *bL_switcher_attrs[] = {
708	&bL_switcher_active_attr.attr,
709	&bL_switcher_trace_trigger_attr.attr,
710	NULL,
711};
712
713static struct attribute_group bL_switcher_attr_group = {
714	.attrs = bL_switcher_attrs,
715};
716
717static struct kobject *bL_switcher_kobj;
718
719static int __init bL_switcher_sysfs_init(void)
720{
721	int ret;
722
723	bL_switcher_kobj = kobject_create_and_add("bL_switcher", kernel_kobj);
724	if (!bL_switcher_kobj)
725		return -ENOMEM;
726	ret = sysfs_create_group(bL_switcher_kobj, &bL_switcher_attr_group);
727	if (ret)
728		kobject_put(bL_switcher_kobj);
729	return ret;
730}
731
732#endif  /* CONFIG_SYSFS */
733
734bool bL_switcher_get_enabled(void)
735{
736	mutex_lock(&bL_switcher_activation_lock);
737
738	return bL_switcher_active;
739}
740EXPORT_SYMBOL_GPL(bL_switcher_get_enabled);
741
742void bL_switcher_put_enabled(void)
743{
744	mutex_unlock(&bL_switcher_activation_lock);
745}
746EXPORT_SYMBOL_GPL(bL_switcher_put_enabled);
747
748/*
749 * Veto any CPU hotplug operation on those CPUs we've removed
750 * while the switcher is active.
751 * We're just not ready to deal with that given the trickery involved.
752 */
753static int bL_switcher_cpu_pre(unsigned int cpu)
754{
755	int pairing;
756
757	if (!bL_switcher_active)
758		return 0;
759
760	pairing = bL_switcher_cpu_pairing[cpu];
761
762	if (pairing == -1)
763		return -EINVAL;
764	return 0;
765}
766
767static bool no_bL_switcher;
768core_param(no_bL_switcher, no_bL_switcher, bool, 0644);
769
770static int __init bL_switcher_init(void)
771{
772	int ret;
773
774	if (!mcpm_is_available())
775		return -ENODEV;
776
777	cpuhp_setup_state_nocalls(CPUHP_ARM_BL_PREPARE, "arm/bl:prepare",
778				  bL_switcher_cpu_pre, NULL);
779	ret = cpuhp_setup_state_nocalls(CPUHP_AP_ONLINE_DYN, "arm/bl:predown",
780					NULL, bL_switcher_cpu_pre);
781	if (ret < 0) {
782		cpuhp_remove_state_nocalls(CPUHP_ARM_BL_PREPARE);
783		pr_err("bL_switcher: Failed to allocate a hotplug state\n");
784		return ret;
785	}
786	if (!no_bL_switcher) {
787		ret = bL_switcher_enable();
788		if (ret)
789			return ret;
790	}
791
792#ifdef CONFIG_SYSFS
793	ret = bL_switcher_sysfs_init();
794	if (ret)
795		pr_err("%s: unable to create sysfs entry\n", __func__);
796#endif
797
798	return 0;
799}
800
801late_initcall(bL_switcher_init);