ARM: bL_switcher: ability to enable and disable the switcher via sysfs

The /sys/kernel/bL_switcher/enable file allows to enable or disable
the switcher by writing 1 or 0 to it respectively.  It is still enabled
by default on boot.

Signed-off-by: Nicolas Pitre <nico@linaro.org>

diff --git a/arch/arm/common/bL_switcher.c b/arch/arm/common/bL_switcher.c
index 1c2e5bcfb1f7896d92805a04900abb0484f397d9..395f60f6292b209607a1bb21c54f064482e6f70d 100644 (file)
--- a/arch/arm/common/bL_switcher.c
+++ b/arch/arm/common/bL_switcher.c
@@ -24,6 +24,7 @@
 #include <linux/tick.h>
 #include <linux/mm.h>
 #include <linux/string.h>
+#include <linux/sysfs.h>
 #include <linux/irqchip/arm-gic.h>
 
 #include <asm/smp_plat.h>
@@ -220,6 +221,7 @@ struct bL_thread {
        struct task_struct *task;
        wait_queue_head_t wq;
        int wanted_cluster;
+       struct completion started;
 };
 
 static struct bL_thread bL_threads[NR_CPUS];
@@ -231,6 +233,7 @@ static int bL_switcher_thread(void *arg)
        int cluster;
 
        sched_setscheduler_nocheck(current, SCHED_FIFO, &param);
+       complete(&t->started);
 
        do {
                if (signal_pending(current))
@@ -246,7 +249,7 @@ static int bL_switcher_thread(void *arg)
        return 0;
 }
 
-static struct task_struct * __init bL_switcher_thread_create(int cpu, void *arg)
+static struct task_struct *bL_switcher_thread_create(int cpu, void *arg)
 {
        struct task_struct *task;
 
@@ -295,9 +298,11 @@ EXPORT_SYMBOL_GPL(bL_switch_request);
  * Activation and configuration code.
  */
 
+static unsigned int bL_switcher_active;
+static unsigned int bL_switcher_cpu_original_cluster[MAX_CPUS_PER_CLUSTER];
 static cpumask_t bL_switcher_removed_logical_cpus;
 
-static void __init bL_switcher_restore_cpus(void)
+static void bL_switcher_restore_cpus(void)
 {
        int i;
 
@@ -305,7 +310,7 @@ static void __init bL_switcher_restore_cpus(void)
                cpu_up(i);
 }
 
-static int __init bL_switcher_halve_cpus(void)
+static int bL_switcher_halve_cpus(void)
 {
        int cpu, cluster, i, ret;
        cpumask_t cluster_mask[2], common_mask;
@@ -349,8 +354,10 @@ static int __init bL_switcher_halve_cpus(void)
                         * is equal to their physical CPU number. This is
                         * not perfect but good enough for now.
                         */
-                       if (cpu == i)
+                       if (cpu == i) {
+                               bL_switcher_cpu_original_cluster[cpu] = cluster;
                                continue;
+                       }
                }
 
                ret = cpu_down(i);
@@ -364,18 +371,18 @@ static int __init bL_switcher_halve_cpus(void)
        return 0;
 }
 
-static int __init bL_switcher_init(void)
+static int bL_switcher_enable(void)
 {
        int cpu, ret;
 
-       pr_info("big.LITTLE switcher initializing\n");
-
-       if (MAX_NR_CLUSTERS != 2) {
-               pr_err("%s: only dual cluster systems are supported\n", __func__);
-               return -EINVAL;
+       cpu_hotplug_driver_lock();
+       if (bL_switcher_active) {
+               cpu_hotplug_driver_unlock();
+               return 0;
        }
 
-       cpu_hotplug_driver_lock();
+       pr_info("big.LITTLE switcher initializing\n");
+
        ret = bL_switcher_halve_cpus();
        if (ret) {
                cpu_hotplug_driver_unlock();
@@ -385,13 +392,155 @@ static int __init bL_switcher_init(void)
        for_each_online_cpu(cpu) {
                struct bL_thread *t = &bL_threads[cpu];
                init_waitqueue_head(&t->wq);
+               init_completion(&t->started);
                t->wanted_cluster = -1;
                t->task = bL_switcher_thread_create(cpu, t);
        }
+
+       bL_switcher_active = 1;
        cpu_hotplug_driver_unlock();
 
        pr_info("big.LITTLE switcher initialized\n");
        return 0;
 }
 
+#ifdef CONFIG_SYSFS
+
+static void bL_switcher_disable(void)
+{
+       unsigned int cpu, cluster, i;
+       struct bL_thread *t;
+       struct task_struct *task;
+
+       cpu_hotplug_driver_lock();
+       if (!bL_switcher_active) {
+               cpu_hotplug_driver_unlock();
+               return;
+       }
+       bL_switcher_active = 0;
+
+       /*
+        * To deactivate the switcher, we must shut down the switcher
+        * threads to prevent any other requests from being accepted.
+        * Then, if the final cluster for given logical CPU is not the
+        * same as the original one, we'll recreate a switcher thread
+        * just for the purpose of switching the CPU back without any
+        * possibility for interference from external requests.
+        */
+       for_each_online_cpu(cpu) {
+               BUG_ON(cpu != (cpu_logical_map(cpu) & 0xff));
+               t = &bL_threads[cpu];
+               task = t->task;
+               t->task = NULL;
+               if (!task || IS_ERR(task))
+                       continue;
+               kthread_stop(task);
+               /* no more switch may happen on this CPU at this point */
+               cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(cpu), 1);
+               if (cluster == bL_switcher_cpu_original_cluster[cpu])
+                       continue;
+               init_completion(&t->started);
+               t->wanted_cluster = bL_switcher_cpu_original_cluster[cpu];
+               task = bL_switcher_thread_create(cpu, t);
+               if (!IS_ERR(task)) {
+                       wait_for_completion(&t->started);
+                       kthread_stop(task);
+                       cluster = MPIDR_AFFINITY_LEVEL(cpu_logical_map(cpu), 1);
+                       if (cluster == bL_switcher_cpu_original_cluster[cpu])
+                               continue;
+               }
+               /* If execution gets here, we're in trouble. */
+               pr_crit("%s: unable to restore original cluster for CPU %d\n",
+                       __func__, cpu);
+               for_each_cpu(i, &bL_switcher_removed_logical_cpus) {
+                       if ((cpu_logical_map(i) & 0xff) != cpu)
+                               continue;
+                       pr_crit("%s: CPU %d can't be restored\n",
+                               __func__, i);
+                       cpumask_clear_cpu(i, &bL_switcher_removed_logical_cpus);
+                       break;
+               }
+       }
+
+       bL_switcher_restore_cpus();
+       cpu_hotplug_driver_unlock();
+}
+
+static ssize_t bL_switcher_active_show(struct kobject *kobj,
+               struct kobj_attribute *attr, char *buf)
+{
+       return sprintf(buf, "%u\n", bL_switcher_active);
+}
+
+static ssize_t bL_switcher_active_store(struct kobject *kobj,
+               struct kobj_attribute *attr, const char *buf, size_t count)
+{
+       int ret;
+
+       switch (buf[0]) {
+       case '0':
+               bL_switcher_disable();
+               ret = 0;
+               break;
+       case '1':
+               ret = bL_switcher_enable();
+               break;
+       default:
+               ret = -EINVAL;
+       }
+
+       return (ret >= 0) ? count : ret;
+}
+
+static struct kobj_attribute bL_switcher_active_attr =
+       __ATTR(active, 0644, bL_switcher_active_show, bL_switcher_active_store);
+
+static struct attribute *bL_switcher_attrs[] = {
+       &bL_switcher_active_attr.attr,
+       NULL,
+};
+
+static struct attribute_group bL_switcher_attr_group = {
+       .attrs = bL_switcher_attrs,
+};
+
+static struct kobject *bL_switcher_kobj;
+
+static int __init bL_switcher_sysfs_init(void)
+{
+       int ret;
+
+       bL_switcher_kobj = kobject_create_and_add("bL_switcher", kernel_kobj);
+       if (!bL_switcher_kobj)
+               return -ENOMEM;
+       ret = sysfs_create_group(bL_switcher_kobj, &bL_switcher_attr_group);
+       if (ret)
+               kobject_put(bL_switcher_kobj);
+       return ret;
+}
+
+#endif  /* CONFIG_SYSFS */
+
+static int __init bL_switcher_init(void)
+{
+       int ret;
+
+       if (MAX_NR_CLUSTERS != 2) {
+               pr_err("%s: only dual cluster systems are supported\n", __func__);
+               return -EINVAL;
+       }
+
+       ret = bL_switcher_enable();
+       if (ret)
+               return ret;
+
+#ifdef CONFIG_SYSFS
+       ret = bL_switcher_sysfs_init();
+       if (ret)
+               pr_err("%s: unable to create sysfs entry\n", __func__);
+#endif
+
+       return 0;
+}
+
 late_initcall(bL_switcher_init);