Patched in Tegra support.

18 files changed, 240 insertions, 68 deletions

diff --git a/arch/unicore32/kernel/Makefile b/arch/unicore32/kernel/Makefile
index fa497e0efe5..aeb0f181568 100644
--- a/arch/unicore32/kernel/Makefile
+++ b/arch/unicore32/kernel/Makefile
@@ -16,6 +16,7 @@ obj-$(CONFIG_UNICORE_FPU_F64)	+= fpu-ucf64.o
 obj-$(CONFIG_ARCH_PUV3)         += clock.o irq.o time.o
 
 obj-$(CONFIG_PUV3_GPIO)         += gpio.o
+obj-$(CONFIG_PUV3_PWM)          += pwm.o
 obj-$(CONFIG_PUV3_PM)           += pm.o sleep.o
 obj-$(CONFIG_HIBERNATION)       += hibernate.o hibernate_asm.o
 
@@ -28,4 +29,4 @@ obj-$(CONFIG_PUV3_NB0916)	+= puv3-nb0916.o
 head-y                          := head.o
 obj-$(CONFIG_DEBUG_LL)          += debug.o
 
-extra-y                         := $(head-y) vmlinux.lds
+extra-y                         := $(head-y) init_task.o vmlinux.lds
diff --git a/arch/unicore32/kernel/dma.c b/arch/unicore32/kernel/dma.c
index ed2d4d78d9c..ae441bc3122 100644
--- a/arch/unicore32/kernel/dma.c
+++ b/arch/unicore32/kernel/dma.c
@@ -18,6 +18,7 @@
 #include <linux/errno.h>
 #include <linux/io.h>
 
+#include <asm/system.h>
 #include <asm/irq.h>
 #include <mach/hardware.h>
 #include <mach/dma.h>
diff --git a/arch/unicore32/kernel/entry.S b/arch/unicore32/kernel/entry.S
index 581630d9144..00a259f9819 100644
--- a/arch/unicore32/kernel/entry.S
+++ b/arch/unicore32/kernel/entry.S
@@ -544,6 +544,8 @@ fast_work_pending:
 work_pending:
         cand.a  r1, #_TIF_NEED_RESCHED
         bne     work_resched
+        cand.a  r1, #_TIF_SIGPENDING|_TIF_NOTIFY_RESUME
+        beq     no_work_pending
         mov     r0, sp                          @ 'regs'
         mov     r2, why                         @ 'syscall'
         cand.a  r1, #_TIF_SIGPENDING            @ delivering a signal?
@@ -573,16 +575,17 @@ ENDPROC(ret_to_user)
  */
 ENTRY(ret_from_fork)
         b.l     schedule_tail
+        get_thread_info tsk
+        ldw     r1, [tsk+], #TI_FLAGS           @ check for syscall tracing
+        mov     why, #1
+        cand.a  r1, #_TIF_SYSCALL_TRACE         @ are we tracing syscalls?
+        beq     ret_slow_syscall
+        mov     r1, sp
+        mov     r0, #1                          @ trace exit [IP = 1]
+        b.l     syscall_trace
         b       ret_slow_syscall
 ENDPROC(ret_from_fork)
 
-ENTRY(ret_from_kernel_thread)
-        b.l     schedule_tail
-        mov     r0, r5
-        adr     lr, ret_slow_syscall
-        mov     pc, r4
-ENDPROC(ret_from_kernel_thread)
-
 /*=============================================================================
  * SWI handler
  *-----------------------------------------------------------------------------
@@ -668,6 +671,17 @@ __cr_alignment:
 #endif
         .ltorg
 
+ENTRY(sys_execve)
+                add     r3, sp, #S_OFF
+                b       __sys_execve
+ENDPROC(sys_execve)
+
+ENTRY(sys_clone)
+                add     ip, sp, #S_OFF
+                stw     ip, [sp+], #4
+                b       __sys_clone
+ENDPROC(sys_clone)
+
 ENTRY(sys_rt_sigreturn)
                 add     r0, sp, #S_OFF
                 mov     why, #0         @ prevent syscall restart handling
diff --git a/arch/unicore32/kernel/head.S b/arch/unicore32/kernel/head.S
index e8f0b98c02e..8caf322e110 100644
--- a/arch/unicore32/kernel/head.S
+++ b/arch/unicore32/kernel/head.S
@@ -17,7 +17,7 @@
 #include <generated/asm-offsets.h>
 #include <asm/memory.h>
 #include <asm/thread_info.h>
-#include <asm/hwdef-copro.h>
+#include <asm/system.h>
 #include <asm/pgtable-hwdef.h>
 
 #if (PHYS_OFFSET & 0x003fffff)
diff --git a/arch/unicore32/kernel/hibernate.c b/arch/unicore32/kernel/hibernate.c
index d75ef8b6cb5..7d0f0b7983a 100644
--- a/arch/unicore32/kernel/hibernate.c
+++ b/arch/unicore32/kernel/hibernate.c
@@ -15,6 +15,7 @@
 #include <linux/suspend.h>
 #include <linux/bootmem.h>
 
+#include <asm/system.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
 #include <asm/pgalloc.h>
diff --git a/arch/unicore32/kernel/irq.c b/arch/unicore32/kernel/irq.c
index 0be5ccd7ccd..d4efa7d679f 100644
--- a/arch/unicore32/kernel/irq.c
+++ b/arch/unicore32/kernel/irq.c
@@ -26,6 +26,7 @@
 #include <linux/syscore_ops.h>
 #include <linux/gpio.h>
 
+#include <asm/system.h>
 #include <mach/hardware.h>
 
 #include "setup.h"
diff --git a/arch/unicore32/kernel/ksyms.c b/arch/unicore32/kernel/ksyms.c
index d285d71cbe3..a8970809428 100644
--- a/arch/unicore32/kernel/ksyms.c
+++ b/arch/unicore32/kernel/ksyms.c
@@ -20,11 +20,12 @@
 #include <linux/io.h>
 
 #include <asm/checksum.h>
+#include <asm/system.h>
 
 #include "ksyms.h"
 
-EXPORT_SYMBOL(find_next_zero_bit);
-EXPORT_SYMBOL(find_next_bit);
+EXPORT_SYMBOL(__uc32_find_next_zero_bit);
+EXPORT_SYMBOL(__uc32_find_next_bit);
 
 EXPORT_SYMBOL(__backtrace);
 
diff --git a/arch/unicore32/kernel/module.c b/arch/unicore32/kernel/module.c
index 16bd1495b93..8fbe8577f5e 100644
--- a/arch/unicore32/kernel/module.c
+++ b/arch/unicore32/kernel/module.c
@@ -27,6 +27,9 @@ void *module_alloc(unsigned long size)
         struct vm_struct *area;
 
         size = PAGE_ALIGN(size);
+        if (!size)
+                return NULL;
+
         area = __get_vm_area(size, VM_ALLOC, MODULES_VADDR, MODULES_END);
         if (!area)
                 return NULL;
diff --git a/arch/unicore32/kernel/pci.c b/arch/unicore32/kernel/pci.c
index ef69c0c8282..4892fbb54eb 100644
--- a/arch/unicore32/kernel/pci.c
+++ b/arch/unicore32/kernel/pci.c
@@ -21,6 +21,7 @@
 #include <linux/io.h>
 
 static int debug_pci;
+static int use_firmware;
 
 #define CONFIG_CMD(bus, devfn, where)   \
         (0x80000000 | (bus->number << 16) | (devfn << 8) | (where & ~3))
@@ -154,6 +155,14 @@ void __init puv3_pci_adjust_zones(unsigned long *zone_size,
         zhole_size[0] = 0;
 }
 
+void __devinit pcibios_update_irq(struct pci_dev *dev, int irq)
+{
+        if (debug_pci)
+                printk(KERN_DEBUG "PCI: Assigning IRQ %02d to %s\n",
+                                irq, pci_name(dev));
+        pci_write_config_byte(dev, PCI_INTERRUPT_LINE, irq);
+}
+
 /*
  * If the bus contains any of these devices, then we must not turn on
  * parity checking of any kind.
@@ -167,7 +176,7 @@ static inline int pdev_bad_for_parity(struct pci_dev *dev)
  * pcibios_fixup_bus - Called after each bus is probed,
  * but before its children are examined.
  */
-void pcibios_fixup_bus(struct pci_bus *bus)
+void __devinit pcibios_fixup_bus(struct pci_bus *bus)
 {
         struct pci_dev *dev;
         u16 features = PCI_COMMAND_SERR
@@ -250,7 +259,9 @@ void pcibios_fixup_bus(struct pci_bus *bus)
         printk(KERN_INFO "PCI: bus%d: Fast back to back transfers %sabled\n",
                 bus->number, (features & PCI_COMMAND_FAST_BACK) ? "en" : "dis");
 }
+#ifdef CONFIG_HOTPLUG
 EXPORT_SYMBOL(pcibios_fixup_bus);
+#endif
 
 static int __init pci_common_init(void)
 {
@@ -265,7 +276,7 @@ static int __init pci_common_init(void)
 
         pci_fixup_irqs(pci_common_swizzle, pci_puv3_map_irq);
 
-        if (!pci_has_flag(PCI_PROBE_ONLY)) {
+        if (!use_firmware) {
                 /*
                  * Size the bridge windows.
                  */
@@ -286,23 +297,18 @@ static int __init pci_common_init(void)
 }
 subsys_initcall(pci_common_init);
 
-char * __init pcibios_setup(char *str)
+char * __devinit pcibios_setup(char *str)
 {
         if (!strcmp(str, "debug")) {
                 debug_pci = 1;
                 return NULL;
         } else if (!strcmp(str, "firmware")) {
-                pci_add_flags(PCI_PROBE_ONLY);
+                use_firmware = 1;
                 return NULL;
         }
         return str;
 }
 
-void pcibios_set_master(struct pci_dev *dev)
-{
-        /* No special bus mastering setup handling */
-}
-
 /*
  * From arch/i386/kernel/pci-i386.c:
  *
diff --git a/arch/unicore32/kernel/process.c b/arch/unicore32/kernel/process.c
index 62bad9fed03..ba401df971e 100644
--- a/arch/unicore32/kernel/process.c
+++ b/arch/unicore32/kernel/process.c
@@ -34,6 +34,7 @@
 
 #include <asm/cacheflush.h>
 #include <asm/processor.h>
+#include <asm/system.h>
 #include <asm/stacktrace.h>
 
 #include "setup.h"
@@ -54,8 +55,7 @@ void cpu_idle(void)
 {
         /* endless idle loop with no priority at all */
         while (1) {
-                tick_nohz_idle_enter();
-                rcu_idle_enter();
+                tick_nohz_stop_sched_tick(1);
                 while (!need_resched()) {
                         local_irq_disable();
                         stop_critical_timings();
@@ -63,8 +63,7 @@ void cpu_idle(void)
                         local_irq_enable();
                         start_critical_timings();
                 }
-                rcu_idle_exit();
-                tick_nohz_idle_exit();
+                tick_nohz_restart_sched_tick();
                 preempt_enable_no_resched();
                 schedule();
                 preempt_disable();
@@ -258,32 +257,25 @@ void release_thread(struct task_struct *dead_task)
 }
 
 asmlinkage void ret_from_fork(void) __asm__("ret_from_fork");
-asmlinkage void ret_from_kernel_thread(void) __asm__("ret_from_kernel_thread");
 
 int
 copy_thread(unsigned long clone_flags, unsigned long stack_start,
-            unsigned long stk_sz, struct task_struct *p)
+            unsigned long stk_sz, struct task_struct *p, struct pt_regs *regs)
 {
         struct thread_info *thread = task_thread_info(p);
         struct pt_regs *childregs = task_pt_regs(p);
 
+        *childregs = *regs;
+        childregs->UCreg_00 = 0;
+        childregs->UCreg_sp = stack_start;
+
         memset(&thread->cpu_context, 0, sizeof(struct cpu_context_save));
         thread->cpu_context.sp = (unsigned long)childregs;
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                thread->cpu_context.pc = (unsigned long)ret_from_kernel_thread;
-                thread->cpu_context.r4 = stack_start;
-                thread->cpu_context.r5 = stk_sz;
-                memset(childregs, 0, sizeof(struct pt_regs));
-        } else {
-                thread->cpu_context.pc = (unsigned long)ret_from_fork;
-                *childregs = *current_pt_regs();
-                childregs->UCreg_00 = 0;
-                if (stack_start)
-                        childregs->UCreg_sp = stack_start;
-
-                if (clone_flags & CLONE_SETTLS)
-                        childregs->UCreg_16 = childregs->UCreg_03;
-        }
+        thread->cpu_context.pc = (unsigned long)ret_from_fork;
+
+        if (clone_flags & CLONE_SETTLS)
+                childregs->UCreg_16 = regs->UCreg_03;
+
         return 0;
 }
 
@@ -312,6 +304,42 @@ int dump_fpu(struct pt_regs *regs, elf_fpregset_t *fp)
 }
 EXPORT_SYMBOL(dump_fpu);
 
+/*
+ * Shuffle the argument into the correct register before calling the
+ * thread function.  r1 is the thread argument, r2 is the pointer to
+ * the thread function, and r3 points to the exit function.
+ */
+asm(".pushsection .text\n"
+"       .align\n"
+"       .type   kernel_thread_helper, #function\n"
+"kernel_thread_helper:\n"
+"       mov.a   asr, r7\n"
+"       mov     r0, r4\n"
+"       mov     lr, r6\n"
+"       mov     pc, r5\n"
+"       .size   kernel_thread_helper, . - kernel_thread_helper\n"
+"       .popsection");
+
+/*
+ * Create a kernel thread.
+ */
+pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags)
+{
+        struct pt_regs regs;
+
+        memset(&regs, 0, sizeof(regs));
+
+        regs.UCreg_04 = (unsigned long)arg;
+        regs.UCreg_05 = (unsigned long)fn;
+        regs.UCreg_06 = (unsigned long)do_exit;
+        regs.UCreg_07 = PRIV_MODE;
+        regs.UCreg_pc = (unsigned long)kernel_thread_helper;
+        regs.UCreg_asr = regs.UCreg_07 | PSR_I_BIT;
+
+        return do_fork(flags|CLONE_VM|CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
+}
+EXPORT_SYMBOL(kernel_thread);
+
 unsigned long get_wchan(struct task_struct *p)
 {
         struct stackframe frame;
@@ -351,7 +379,7 @@ int vectors_user_mapping(void)
         return install_special_mapping(mm, 0xffff0000, PAGE_SIZE,
                                        VM_READ | VM_EXEC |
                                        VM_MAYREAD | VM_MAYEXEC |
-                                       VM_DONTEXPAND | VM_DONTDUMP,
+                                       VM_ALWAYSDUMP | VM_RESERVED,
                                        NULL);
 }
 
diff --git a/arch/unicore32/kernel/puv3-core.c b/arch/unicore32/kernel/puv3-core.c
index 254adeecc61..1a505a78776 100644
--- a/arch/unicore32/kernel/puv3-core.c
+++ b/arch/unicore32/kernel/puv3-core.c
@@ -13,6 +13,7 @@
 
 #include <linux/init.h>
 #include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/amba/bus.h>
 #include <linux/platform_device.h>
 #include <linux/io.h>
diff --git a/arch/unicore32/kernel/puv3-nb0916.c b/arch/unicore32/kernel/puv3-nb0916.c
index 181108b8ecc..e731c561ed4 100644
--- a/arch/unicore32/kernel/puv3-nb0916.c
+++ b/arch/unicore32/kernel/puv3-nb0916.c
@@ -13,6 +13,7 @@
 
 #include <linux/init.h>
 #include <linux/device.h>
+#include <linux/sysdev.h>
 #include <linux/platform_device.h>
 #include <linux/mtd/physmap.h>
 #include <linux/io.h>
@@ -123,7 +124,7 @@ int __init mach_nb0916_init(void)
 
         if (request_irq(gpio_to_irq(GPI_LCD_CASE_OFF),
                 &nb0916_lcdcaseoff_handler,
-                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                 "NB0916 lcd case off", NULL) < 0) {
 
                 printk(KERN_DEBUG "LCD-Case-OFF IRQ %d not available\n",
@@ -131,7 +132,7 @@ int __init mach_nb0916_init(void)
         }
 
         if (request_irq(gpio_to_irq(GPI_OTP_INT), &nb0916_overheat_handler,
-                IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
+                IRQF_DISABLED | IRQF_TRIGGER_RISING | IRQF_TRIGGER_FALLING,
                 "NB0916 overheating protection", NULL) < 0) {
 
                 printk(KERN_DEBUG "Overheating Protection IRQ %d not available\n",
diff --git a/arch/unicore32/kernel/setup.c b/arch/unicore32/kernel/setup.c
index 87adbf5ebfe..471b6bca8da 100644
--- a/arch/unicore32/kernel/setup.c
+++ b/arch/unicore32/kernel/setup.c
@@ -37,7 +37,6 @@
 #include <asm/cacheflush.h>
 #include <asm/tlbflush.h>
 #include <asm/traps.h>
-#include <asm/memblock.h>
 
 #include "setup.h"
 
@@ -65,7 +64,7 @@ static char default_command_line[COMMAND_LINE_SIZE] __initdata = CONFIG_CMDLINE;
  */
 static struct resource mem_res[] = {
         {
-                .name = "Kernel code",
+                .name = "Kernel text",
                 .start = 0,
                 .end = 0,
                 .flags = IORESOURCE_MEM
diff --git a/arch/unicore32/kernel/setup.h b/arch/unicore32/kernel/setup.h
index 30f749da8f7..dcd1306eb5c 100644
--- a/arch/unicore32/kernel/setup.h
+++ b/arch/unicore32/kernel/setup.h
@@ -12,11 +12,8 @@
 #ifndef __UNICORE_KERNEL_SETUP_H__
 #define __UNICORE_KERNEL_SETUP_H__
 
-#include <asm/hwdef-copro.h>
-
 extern void paging_init(void);
 extern void puv3_core_init(void);
-extern void cpu_init(void);
 
 extern void puv3_ps2_init(void);
 extern void pci_puv3_preinit(void);
@@ -30,10 +27,4 @@ extern char __vectors_start[], __vectors_end[];
 extern void kernel_thread_helper(void);
 
 extern void __init early_signal_init(void);
-
-extern asmlinkage void __backtrace(void);
-extern asmlinkage void c_backtrace(unsigned long fp, int pmode);
-
-extern void __show_regs(struct pt_regs *);
-
 #endif
diff --git a/arch/unicore32/kernel/signal.c b/arch/unicore32/kernel/signal.c
index b8b2ffd774d..b163fca5678 100644
--- a/arch/unicore32/kernel/signal.c
+++ b/arch/unicore32/kernel/signal.c
@@ -12,6 +12,7 @@
 #include <linux/errno.h>
 #include <linux/signal.h>
 #include <linux/personality.h>
+#include <linux/freezer.h>
 #include <linux/uaccess.h>
 #include <linux/tracehook.h>
 #include <linux/elf.h>
@@ -20,6 +21,8 @@
 #include <asm/cacheflush.h>
 #include <asm/ucontext.h>
 
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 /*
  * For UniCore syscalls, we encode the syscall number into the instruction.
  */
@@ -58,8 +61,13 @@ static int restore_sigframe(struct pt_regs *regs, struct sigframe __user *sf)
         int err;
 
         err = __copy_from_user(&set, &sf->uc.uc_sigmask, sizeof(set));
-        if (err == 0)
-                set_current_blocked(&set);
+        if (err == 0) {
+                sigdelsetmask(&set, ~_BLOCKABLE);
+                spin_lock_irq(&current->sighand->siglock);
+                current->blocked = set;
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+        }
 
         err |= __get_user(regs->UCreg_00, &sf->uc.uc_mcontext.regs.UCreg_00);
         err |= __get_user(regs->UCreg_01, &sf->uc.uc_mcontext.regs.UCreg_01);
@@ -307,12 +315,12 @@ static inline void setup_syscall_restart(struct pt_regs *regs)
 /*
  * OK, we're invoking a handler
  */
-static void handle_signal(unsigned long sig, struct k_sigaction *ka,
-              siginfo_t *info, struct pt_regs *regs, int syscall)
+static int handle_signal(unsigned long sig, struct k_sigaction *ka,
+              siginfo_t *info, sigset_t *oldset,
+              struct pt_regs *regs, int syscall)
 {
         struct thread_info *thread = current_thread_info();
         struct task_struct *tsk = current;
-        sigset_t *oldset = sigmask_to_save();
         int usig = sig;
         int ret;
 
@@ -358,10 +366,21 @@ static void handle_signal(unsigned long sig, struct k_sigaction *ka,
 
         if (ret != 0) {
                 force_sigsegv(sig, tsk);
-                return;
+                return ret;
         }
 
-        signal_delivered(sig, info, ka, regs, 0);
+        /*
+         * Block the signal if we were successful.
+         */
+        spin_lock_irq(&tsk->sighand->siglock);
+        sigorsets(&tsk->blocked, &tsk->blocked,
+                  &ka->sa.sa_mask);
+        if (!(ka->sa.sa_flags & SA_NODEFER))
+                sigaddset(&tsk->blocked, sig);
+        recalc_sigpending();
+        spin_unlock_irq(&tsk->sighand->siglock);
+
+        return 0;
 }
 
 /*
@@ -388,12 +407,32 @@ static void do_signal(struct pt_regs *regs, int syscall)
         if (!user_mode(regs))
                 return;
 
+        if (try_to_freeze())
+                goto no_signal;
+
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
         if (signr > 0) {
-                handle_signal(signr, &ka, &info, regs, syscall);
+                sigset_t *oldset;
+
+                if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                        oldset = &current->saved_sigmask;
+                else
+                        oldset = &current->blocked;
+                if (handle_signal(signr, &ka, &info, oldset, regs, syscall)
+                                == 0) {
+                        /*
+                         * A signal was successfully delivered; the saved
+                         * sigmask will have been stored in the signal frame,
+                         * and will be restored by sigreturn, so we can simply
+                         * clear the TIF_RESTORE_SIGMASK flag.
+                         */
+                        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                }
                 return;
         }
 
+ no_signal:
         /*
          * No signal to deliver to the process - restart the syscall.
          */
@@ -416,11 +455,15 @@ static void do_signal(struct pt_regs *regs, int syscall)
                     regs->UCreg_00 == -ERESTARTNOINTR) {
                         setup_syscall_restart(regs);
                 }
+
+                /* If there's no signal to deliver, we just put the saved
+                 * sigmask back.
+                 */
+                if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                        clear_thread_flag(TIF_RESTORE_SIGMASK);
+                        sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+                }
         }
-        /* If there's no signal to deliver, we just put the saved
-         * sigmask back.
-         */
-        restore_saved_sigmask();
 }
 
 asmlinkage void do_notify_resume(struct pt_regs *regs,
@@ -432,6 +475,8 @@ asmlinkage void do_notify_resume(struct pt_regs *regs,
         if (thread_flags & _TIF_NOTIFY_RESUME) {
                 clear_thread_flag(TIF_NOTIFY_RESUME);
                 tracehook_notify_resume(regs);
+                if (current->replacement_session_keyring)
+                        key_replace_session_keyring();
         }
 }
 
diff --git a/arch/unicore32/kernel/sys.c b/arch/unicore32/kernel/sys.c
index cfe79c9529b..3afe60a39ac 100644
--- a/arch/unicore32/kernel/sys.c
+++ b/arch/unicore32/kernel/sys.c
@@ -28,6 +28,84 @@
 #include <asm/syscalls.h>
 #include <asm/cacheflush.h>
 
+/* Clone a task - this clones the calling program thread.
+ * This is called indirectly via a small wrapper
+ */
+asmlinkage long __sys_clone(unsigned long clone_flags, unsigned long newsp,
+                         void __user *parent_tid, void __user *child_tid,
+                         struct pt_regs *regs)
+{
+        if (!newsp)
+                newsp = regs->UCreg_sp;
+
+        return do_fork(clone_flags, newsp, regs, 0,
+                        parent_tid, child_tid);
+}
+
+/* sys_execve() executes a new program.
+ * This is called indirectly via a small wrapper
+ */
+asmlinkage long __sys_execve(const char __user *filename,
+                          const char __user *const __user *argv,
+                          const char __user *const __user *envp,
+                          struct pt_regs *regs)
+{
+        int error;
+        char *fn;
+
+        fn = getname(filename);
+        error = PTR_ERR(fn);
+        if (IS_ERR(fn))
+                goto out;
+        error = do_execve(fn, argv, envp, regs);
+        putname(fn);
+out:
+        return error;
+}
+
+int kernel_execve(const char *filename,
+                  const char *const argv[],
+                  const char *const envp[])
+{
+        struct pt_regs regs;
+        int ret;
+
+        memset(&regs, 0, sizeof(struct pt_regs));
+        ret = do_execve(filename,
+                        (const char __user *const __user *)argv,
+                        (const char __user *const __user *)envp, &regs);
+        if (ret < 0)
+                goto out;
+
+        /*
+         * Save argc to the register structure for userspace.
+         */
+        regs.UCreg_00 = ret;
+
+        /*
+         * We were successful.  We won't be returning to our caller, but
+         * instead to user space by manipulating the kernel stack.
+         */
+        asm("add        r0, %0, %1\n\t"
+                "mov    r1, %2\n\t"
+                "mov    r2, %3\n\t"
+                "mov    r22, #0\n\t"    /* not a syscall */
+                "mov    r23, %0\n\t"    /* thread structure */
+                "b.l    memmove\n\t"    /* copy regs to top of stack */
+                "mov    sp, r0\n\t"     /* reposition stack pointer */
+                "b      ret_to_user"
+                :
+                : "r" (current_thread_info()),
+                  "Ir" (THREAD_START_SP - sizeof(regs)),
+                  "r" (&regs),
+                  "Ir" (sizeof(regs))
+                : "r0", "r1", "r2", "r3", "ip", "lr", "memory");
+
+ out:
+        return ret;
+}
+EXPORT_SYMBOL(kernel_execve);
+
 /* Note: used by the compat code even in 64-bit Linux. */
 SYSCALL_DEFINE6(mmap2, unsigned long, addr, unsigned long, len,
                 unsigned long, prot, unsigned long, flags,
diff --git a/arch/unicore32/kernel/time.c b/arch/unicore32/kernel/time.c
index d3824b2ff64..080710c0924 100644
--- a/arch/unicore32/kernel/time.c
+++ b/arch/unicore32/kernel/time.c
@@ -86,7 +86,7 @@ static struct clocksource cksrc_puv3_oscr = {
 
 static struct irqaction puv3_timer_irq = {
         .name           = "ost0",
-        .flags          = IRQF_TIMER | IRQF_IRQPOLL,
+        .flags          = IRQF_DISABLED | IRQF_TIMER | IRQF_IRQPOLL,
         .handler        = puv3_ost0_interrupt,
         .dev_id         = &ckevt_puv3_osmr0,
 };
diff --git a/arch/unicore32/kernel/traps.c b/arch/unicore32/kernel/traps.c
index 2054f0d4db1..b9a26465e72 100644
--- a/arch/unicore32/kernel/traps.c
+++ b/arch/unicore32/kernel/traps.c
@@ -26,6 +26,7 @@
 #include <linux/unistd.h>
 
 #include <asm/cacheflush.h>
+#include <asm/system.h>
 #include <asm/traps.h>
 
 #include "setup.h"