[Bluetooth] Code cleanup of the drivers source code

[pandora-kernel.git] / kernel / cpu.c

diff --git a/kernel/cpu.c b/kernel/cpu.c
index f230f9a..32c9662 100644 (file)
--- a/kernel/cpu.c
+++ b/kernel/cpu.c
@@ -21,6 +21,11 @@ static DEFINE_MUTEX(cpu_bitmask_lock);
 
 static __cpuinitdata BLOCKING_NOTIFIER_HEAD(cpu_chain);
 
+/* If set, cpu_up and cpu_down will return -EBUSY and do nothing.
+ * Should always be manipulated under cpu_add_remove_lock
+ */
+static int cpu_hotplug_disabled;
+
 #ifdef CONFIG_HOTPLUG_CPU
 
 /* Crappy recursive lock-takers in cpufreq! Complain loudly about idiots */
@@ -108,30 +113,25 @@ static int take_cpu_down(void *unused)
        return 0;
 }
 
-int cpu_down(unsigned int cpu)
+/* Requires cpu_add_remove_lock to be held */
+static int _cpu_down(unsigned int cpu)
 {
        int err;
        struct task_struct *p;
        cpumask_t old_allowed, tmp;
 
-       mutex_lock(&cpu_add_remove_lock);
-       if (num_online_cpus() == 1) {
-               err = -EBUSY;
-               goto out;
-       }
+       if (num_online_cpus() == 1)
+               return -EBUSY;
 
-       if (!cpu_online(cpu)) {
-               err = -EINVAL;
-               goto out;
-       }
+       if (!cpu_online(cpu))
+               return -EINVAL;
 
        err = blocking_notifier_call_chain(&cpu_chain, CPU_DOWN_PREPARE,
                                                (void *)(long)cpu);
        if (err == NOTIFY_BAD) {
                printk("%s: attempt to take down CPU %u failed\n",
                                __FUNCTION__, cpu);
-               err = -EINVAL;
-               goto out;
+               return -EINVAL;
        }
 
        /* Ensure that we are not runnable on dying cpu */
@@ -179,22 +179,32 @@ out_thread:
        err = kthread_stop(p);
 out_allowed:
        set_cpus_allowed(current, old_allowed);
-out:
+       return err;
+}
+
+int cpu_down(unsigned int cpu)
+{
+       int err = 0;
+
+       mutex_lock(&cpu_add_remove_lock);
+       if (cpu_hotplug_disabled)
+               err = -EBUSY;
+       else
+               err = _cpu_down(cpu);
+
        mutex_unlock(&cpu_add_remove_lock);
        return err;
 }
 #endif /*CONFIG_HOTPLUG_CPU*/
 
-int __devinit cpu_up(unsigned int cpu)
+/* Requires cpu_add_remove_lock to be held */
+static int __devinit _cpu_up(unsigned int cpu)
 {
        int ret;
        void *hcpu = (void *)(long)cpu;
 
-       mutex_lock(&cpu_add_remove_lock);
-       if (cpu_online(cpu) || !cpu_present(cpu)) {
-               ret = -EINVAL;
-               goto out;
-       }
+       if (cpu_online(cpu) || !cpu_present(cpu))
+               return -EINVAL;
 
        ret = blocking_notifier_call_chain(&cpu_chain, CPU_UP_PREPARE, hcpu);
        if (ret == NOTIFY_BAD) {
@@ -219,7 +229,95 @@ out_notify:
        if (ret != 0)
                blocking_notifier_call_chain(&cpu_chain,
                                CPU_UP_CANCELED, hcpu);
+
+       return ret;
+}
+
+int __devinit cpu_up(unsigned int cpu)
+{
+       int err = 0;
+
+       mutex_lock(&cpu_add_remove_lock);
+       if (cpu_hotplug_disabled)
+               err = -EBUSY;
+       else
+               err = _cpu_up(cpu);
+
+       mutex_unlock(&cpu_add_remove_lock);
+       return err;
+}
+
+#ifdef CONFIG_SUSPEND_SMP
+static cpumask_t frozen_cpus;
+
+int disable_nonboot_cpus(void)
+{
+       int cpu, first_cpu, error;
+
+       mutex_lock(&cpu_add_remove_lock);
+       first_cpu = first_cpu(cpu_present_map);
+       if (!cpu_online(first_cpu)) {
+               error = _cpu_up(first_cpu);
+               if (error) {
+                       printk(KERN_ERR "Could not bring CPU%d up.\n",
+                               first_cpu);
+                       goto out;
+               }
+       }
+       error = set_cpus_allowed(current, cpumask_of_cpu(first_cpu));
+       if (error) {
+               printk(KERN_ERR "Could not run on CPU%d\n", first_cpu);
+               goto out;
+       }
+       /* We take down all of the non-boot CPUs in one shot to avoid races
+        * with the userspace trying to use the CPU hotplug at the same time
+        */
+       cpus_clear(frozen_cpus);
+       printk("Disabling non-boot CPUs ...\n");
+       for_each_online_cpu(cpu) {
+               if (cpu == first_cpu)
+                       continue;
+               error = _cpu_down(cpu);
+               if (!error) {
+                       cpu_set(cpu, frozen_cpus);
+                       printk("CPU%d is down\n", cpu);
+               } else {
+                       printk(KERN_ERR "Error taking CPU%d down: %d\n",
+                               cpu, error);
+                       break;
+               }
+       }
+       if (!error) {
+               BUG_ON(num_online_cpus() > 1);
+               /* Make sure the CPUs won't be enabled by someone else */
+               cpu_hotplug_disabled = 1;
+       } else {
+               printk(KERN_ERR "Non-boot CPUs are not disabled");
+       }
 out:
        mutex_unlock(&cpu_add_remove_lock);
-       return ret;
+       return error;
+}
+
+void enable_nonboot_cpus(void)
+{
+       int cpu, error;
+
+       /* Allow everyone to use the CPU hotplug again */
+       mutex_lock(&cpu_add_remove_lock);
+       cpu_hotplug_disabled = 0;
+       mutex_unlock(&cpu_add_remove_lock);
+
+       printk("Enabling non-boot CPUs ...\n");
+       for_each_cpu_mask(cpu, frozen_cpus) {
+               error = cpu_up(cpu);
+               if (!error) {
+                       printk("CPU%d is up\n", cpu);
+                       continue;
+               }
+               printk(KERN_WARNING "Error taking CPU%d up: %d\n",
+                       cpu, error);
+       }
+       cpus_clear(frozen_cpus);
 }
+#endif