linux-moblin: Add 2.6.27 moblin kernel

This will be the default moblin kernel.
We also moved the 2.6.27-rc* kernels to meta-moblin.

1 files changed, 136 insertions, 0 deletions

diff --git a/meta-moblin/packages/linux/linux-moblin-2.6.27-rc6/0024-fastboot-create-a-asynchronous-initlevel.patch b/meta-moblin/packages/linux/linux-moblin-2.6.27-rc6/0024-fastboot-create-a-asynchronous-initlevel.patch
new file mode 100644
index 0000000000..7c19053b0e
--- /dev/null
+++ b/meta-moblin/packages/linux/linux-moblin-2.6.27-rc6/0024-fastboot-create-a-asynchronous-initlevel.patch
@@ -0,0 +1,136 @@
+From ac9103dd8e4dc65c110d6cba9a3380c6c617ffa7 Mon Sep 17 00:00:00 2001
+From: Arjan van de Ven <arjan@linux.intel.com>
+Date: Fri, 18 Jul 2008 15:16:08 -0700
+Subject: [PATCH] fastboot: create a "asynchronous" initlevel
+
+This patch creates an asynchronous initlevel (6a) which is at the same
+level as the normal device initcalls, but with the difference that they
+are run asynchronous from all the other initcalls. The purpose of this
+*selective* level is that we can move long waiting inits that are not
+boot-critical to this level one at a time.
+
+To keep things not totally insane, the asynchronous initcalls are async
+to the other initcalls, but are still ordered to themselves; think of it
+as "bottom-half-not-softirq". This has the benefit that async drivers
+still have stable device ordering between them.
+
+Signed-off-by: Arjan van de Ven <arjan@linux.intel.com>
+Signed-off-by: Ingo Molnar <mingo@elte.hu>
+---
+ include/asm-generic/vmlinux.lds.h |    3 +++
+ include/linux/init.h              |    6 ++++++
+ init/main.c                       |   36 +++++++++++++++++++++++++++++++++---
+ 3 files changed, 42 insertions(+), 3 deletions(-)
+
+diff --git a/include/asm-generic/vmlinux.lds.h b/include/asm-generic/vmlinux.lds.h
+index 729f6b0..39c1afc 100644
+--- a/include/asm-generic/vmlinux.lds.h
++++ b/include/asm-generic/vmlinux.lds.h
+@@ -372,6 +372,9 @@
+        *(.initcall5.init)                                              \
+        *(.initcall5s.init)                                             \
+        *(.initcallrootfs.init)                                         \
++       __async_initcall_start = .;                                     \
++       *(.initcall6a.init)                                             \
++       __async_initcall_end = .;                                       \
+        *(.initcall6.init)                                              \
+        *(.initcall6s.init)                                             \
+        *(.initcall7.init)                                              \
+diff --git a/include/linux/init.h b/include/linux/init.h
+index 21d658c..75db909 100644
+--- a/include/linux/init.h
++++ b/include/linux/init.h
+@@ -197,11 +197,13 @@
+ #define fs_initcall_sync(fn)           __define_initcall("5s",fn,5s)
+ #define rootfs_initcall(fn)            __define_initcall("rootfs",fn,rootfs)
+ #define device_initcall(fn)            __define_initcall("6",fn,6)
++#define device_initcall_async(fn)      __define_initcall("6a", fn, 6a)
+ #define device_initcall_sync(fn)       __define_initcall("6s",fn,6s)
+ #define late_initcall(fn)              __define_initcall("7",fn,7)
+ #define late_initcall_sync(fn)         __define_initcall("7s",fn,7s)
+ 
+ #define __initcall(fn) device_initcall(fn)
++#define __initcall_async(fn) device_initcall_async(fn)
+ 
+ #define __exitcall(fn) \
+        static exitcall_t __exitcall_##fn __exit_call = fn
+@@ -257,6 +259,7 @@
+  * be one per module.
+  */
+ #define module_init(x) __initcall(x);
++#define module_init_async(x)   __initcall_async(x);
+ 
+ /**
+  * module_exit() - driver exit entry point
+@@ -279,10 +282,13 @@
+ #define subsys_initcall(fn)            module_init(fn)
+ #define fs_initcall(fn)                        module_init(fn)
+ #define device_initcall(fn)            module_init(fn)
++#define device_initcall_async(fn)      module_init(fn)
+ #define late_initcall(fn)              module_init(fn)
+ 
+ #define security_initcall(fn)          module_init(fn)
+ 
++#define module_init_async(fn)          module_init(fn)
++
+ /* Each module must use one module_init(). */
+ #define module_init(initfn)                                    \
+        static inline initcall_t __inittest(void)               \
+diff --git a/init/main.c b/init/main.c
+index edeace0..6961de2 100644
+--- a/init/main.c
++++ b/init/main.c
+@@ -746,18 +746,47 @@
+ 
+ 
+ extern initcall_t __initcall_start[], __initcall_end[], __early_initcall_end[];
++extern initcall_t __async_initcall_start[], __async_initcall_end[];
+ 
+-static void __init do_initcalls(void)
++static void __init do_async_initcalls(struct work_struct *dummy)
+ {
+        initcall_t *call;
+ 
+-       for (call = __early_initcall_end; call < __initcall_end; call++)
++       for (call = __async_initcall_start; call < __async_initcall_end; call++)
+                do_one_initcall(*call);
++}
++
++static struct workqueue_struct *async_init_wq;
++
++static void __init do_initcalls(void)
++{
++       initcall_t *call;
++       static DECLARE_WORK(async_work, do_async_initcalls);
++       int phase = 0; /* 0 = levels 0 - 6, 1 = level 6a, 2 = after level 6a */
++
++       async_init_wq = create_singlethread_workqueue("kasyncinit");
++
++       for (call = __early_initcall_end; call < __initcall_end; call++) {
++               if (phase == 0 && call >= __async_initcall_start) {
++                       phase = 1;
++                       queue_work(async_init_wq, &async_work);
++               }
++               if (phase == 1 && call >= __async_initcall_end)
++                       phase = 2;
++               if (phase != 1)
++                       do_one_initcall(*call);
++       }
+ 
+-       /* Make sure there is no pending stuff from the initcall sequence */
++       /*
++       * Make sure there is no pending stuff from the initcall sequence,
++       * including the async initcalls
++       */
+        flush_scheduled_work();
++       flush_workqueue(async_init_wq);
++       destroy_workqueue(async_init_wq);
+ }
+ 
++
+ /*
+  * Ok, the machine is now initialized. None of the devices
+  * have been touched yet, but the CPU subsystem is up and
+-- 
+1.5.4.3
+