Patched in Tegra support.

10 files changed, 291 insertions, 67 deletions

diff --git a/arch/cris/arch-v32/kernel/debugport.c b/arch/cris/arch-v32/kernel/debugport.c
index 610909b003f..794b364d9f7 100644
--- a/arch/cris/arch-v32/kernel/debugport.c
+++ b/arch/cris/arch-v32/kernel/debugport.c
@@ -4,6 +4,7 @@
 
 #include <linux/console.h>
 #include <linux/init.h>
+#include <asm/system.h>
 #include <hwregs/reg_rdwr.h>
 #include <hwregs/reg_map.h>
 #include <hwregs/ser_defs.h>
diff --git a/arch/cris/arch-v32/kernel/entry.S b/arch/cris/arch-v32/kernel/entry.S
index faa644111fe..c3ea4694fba 100644
--- a/arch/cris/arch-v32/kernel/entry.S
+++ b/arch/cris/arch-v32/kernel/entry.S
@@ -31,7 +31,6 @@
         .globl system_call
         .globl ret_from_intr
         .globl ret_from_fork
-        .globl ret_from_kernel_thread
         .globl resume
         .globl multiple_interrupt
         .globl nmi_interrupt
@@ -85,18 +84,6 @@ ret_from_fork:
         nop
         .size   ret_from_fork, . - ret_from_fork
 
-        .type   ret_from_kernel_thread,@function
-ret_from_kernel_thread:
-        jsr schedule_tail
-        nop
-        move.d  $r2, $r10
-        jsr     $r1
-        nop
-        moveq   0, $r9                  ; no syscall restarts, TYVM...
-        ba  ret_from_sys_call
-        nop
-        .size   ret_from_kernel_thread, . - ret_from_kernel_thread
-
         .type   ret_from_intr,@function
 ret_from_intr:
         ;; Check for resched if preemptive kernel, or if we're going back to
@@ -544,6 +531,15 @@ _ugdb_handle_exception:
         ba      do_sigtrap              ; SIGTRAP the offending process.
         move.d  [$sp+], $r0             ; Restore R0 in delay slot.
 
+        .global kernel_execve
+        .type   kernel_execve,@function
+kernel_execve:
+        move.d __NR_execve, $r9
+        break 13
+        ret
+        nop
+        .size   kernel_execve, . - kernel_execve
+
         .data
 
         .section .rodata,"a"
diff --git a/arch/cris/arch-v32/kernel/fasttimer.c b/arch/cris/arch-v32/kernel/fasttimer.c
index ab1551ee43c..111caa1a2ef 100644
--- a/arch/cris/arch-v32/kernel/fasttimer.c
+++ b/arch/cris/arch-v32/kernel/fasttimer.c
@@ -17,6 +17,7 @@
 #include <linux/delay.h>
 
 #include <asm/irq.h>
+#include <asm/system.h>
 
 #include <hwregs/reg_map.h>
 #include <hwregs/reg_rdwr.h>
diff --git a/arch/cris/arch-v32/kernel/head.S b/arch/cris/arch-v32/kernel/head.S
index 51e34165ece..5d502b9ab56 100644
--- a/arch/cris/arch-v32/kernel/head.S
+++ b/arch/cris/arch-v32/kernel/head.S
@@ -36,6 +36,13 @@
         .global nand_boot
         .global swapper_pg_dir
 
+        ;; Dummy section to make it bootable with current VCS simulator
+#ifdef CONFIG_ETRAX_VCS_SIM
+        .section ".boot", "ax"
+        ba tstart
+        nop
+#endif
+
         .text
 tstart:
         ;; This is the entry point of the kernel. The CPU is currently in
@@ -68,10 +75,17 @@ secondary_cpu_entry: /* Entry point for secondary CPUs */
                 | REG_FIELD(mmu, rw_mm_kbase_hi, base_c, 4)     \
                 | REG_FIELD(mmu, rw_mm_kbase_hi, base_d, 5)     \
                 | REG_FIELD(mmu, rw_mm_kbase_hi, base_b, 0xb), $r0
-#else
+#elif !defined(CONFIG_ETRAX_VCS_SIM)
         move.d  REG_FIELD(mmu, rw_mm_kbase_hi, base_e, 8)       \
                 | REG_FIELD(mmu, rw_mm_kbase_hi, base_c, 4)     \
                 | REG_FIELD(mmu, rw_mm_kbase_hi, base_b, 0xb), $r0
+#else
+        ;; Map the virtual DRAM to the RW eprom area at address 0.
+        ;; Also map 0xa for the hook calls,
+        move.d  REG_FIELD(mmu, rw_mm_kbase_hi, base_e, 8)       \
+                | REG_FIELD(mmu, rw_mm_kbase_hi, base_c, 4)     \
+                | REG_FIELD(mmu, rw_mm_kbase_hi, base_b, 0xb)   \
+                | REG_FIELD(mmu, rw_mm_kbase_hi, base_a, 0xa), $r0
 #endif
 
         ;; Temporary map of 0x40 -> 0x40 and 0x00 -> 0x00.
@@ -112,7 +126,7 @@ secondary_cpu_entry: /* Entry point for secondary CPUs */
                 | REG_STATE(mmu, rw_mm_cfg, seg_2, page)        \
                 | REG_STATE(mmu, rw_mm_cfg, seg_1, page)        \
                 | REG_STATE(mmu, rw_mm_cfg, seg_0, linear), $r2
-#else
+#elif !defined(CONFIG_ETRAX_VCS_SIM)
         move.d  REG_STATE(mmu, rw_mm_cfg, we, on)               \
                 | REG_STATE(mmu, rw_mm_cfg, acc, on)            \
                 | REG_STATE(mmu, rw_mm_cfg, ex, on)             \
@@ -133,6 +147,27 @@ secondary_cpu_entry: /* Entry point for secondary CPUs */
                 | REG_STATE(mmu, rw_mm_cfg, seg_2, page)        \
                 | REG_STATE(mmu, rw_mm_cfg, seg_1, page)        \
                 | REG_STATE(mmu, rw_mm_cfg, seg_0, linear), $r2
+#else
+        move.d  REG_STATE(mmu, rw_mm_cfg, we, on)               \
+                | REG_STATE(mmu, rw_mm_cfg, acc, on)            \
+                | REG_STATE(mmu, rw_mm_cfg, ex, on)             \
+                | REG_STATE(mmu, rw_mm_cfg, inv, on)            \
+                | REG_STATE(mmu, rw_mm_cfg, seg_f, linear)      \
+                | REG_STATE(mmu, rw_mm_cfg, seg_e, linear)      \
+                | REG_STATE(mmu, rw_mm_cfg, seg_d, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_c, linear)      \
+                | REG_STATE(mmu, rw_mm_cfg, seg_b, linear)      \
+                | REG_STATE(mmu, rw_mm_cfg, seg_a, linear)      \
+                | REG_STATE(mmu, rw_mm_cfg, seg_9, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_8, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_7, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_6, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_5, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_4, linear)      \
+                | REG_STATE(mmu, rw_mm_cfg, seg_3, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_2, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_1, page)        \
+                | REG_STATE(mmu, rw_mm_cfg, seg_0, linear), $r2
 #endif
 
         ;; Update instruction MMU.
@@ -191,6 +226,7 @@ master_cpu:
         move.d secondary_cpu_entry, $r1
         move.d $r1, [$r0]
 #endif
+#ifndef CONFIG_ETRAX_VCS_SIM
         ; Check if starting from DRAM (network->RAM boot or unpacked
         ; compressed kernel), or directly from flash.
         lapcq   ., $r0
@@ -198,6 +234,7 @@ master_cpu:
         cmp.d   0x10000, $r0    ; Arbitrary, something above this code.
         blo     _inflash0
         nop
+#endif
 
         jump    _inram          ; Jump to cached RAM.
         nop
@@ -289,6 +326,7 @@ move_cramfs:
         move.d  romfs_length, $r1
         move.d  $r0, [$r1]
 
+#ifndef CONFIG_ETRAX_VCS_SIM
         ;; The kernel could have been unpacked to DRAM by the loader, but
         ;; the cramfs image could still be in the flash immediately
         ;; following the compressed kernel image. The loader passes the address
@@ -297,6 +335,10 @@ move_cramfs:
         cmp.d   0x0ffffff8, $r9
         bhs     _no_romfs_in_flash ; R9 points outside the flash area.
         nop
+#else
+        ba _no_romfs_in_flash
+        nop
+#endif
         ;; cramfs rootfs might to be in flash. Check for it.
         move.d  [$r9], $r0      ; cramfs_super.magic
         cmp.d   CRAMFS_MAGIC, $r0
@@ -354,6 +396,7 @@ _no_romfs_in_flash:
         move.d  romfs_length, $r3
         move.d  $r2, [$r3]      ; store size at romfs_length
 
+#ifndef CONFIG_ETRAX_VCS_SIM
         add.d   $r2, $r0        ; copy from end and downwards
         add.d   $r2, $r1
 
@@ -367,6 +410,7 @@ _no_romfs_in_flash:
         subq    1, $r2
         bne     1b
         nop
+#endif
 
 4:
         ;; BSS move done.
@@ -411,6 +455,7 @@ no_command_line:
         move.d  etrax_irv, $r1  ; Set the exception base register and pointer.
         move.d  $r0, [$r1]
 
+#ifndef CONFIG_ETRAX_VCS_SIM
         ;; Clear the BSS region from _bss_start to _end.
         move.d  __bss_start, $r0
         move.d  _end, $r1
@@ -418,6 +463,15 @@ no_command_line:
         cmp.d   $r1, $r0
         blo 1b
         nop
+#endif
+
+#ifdef CONFIG_ETRAX_VCS_SIM
+        /* Set the watchdog timeout to something big. Will be removed when */
+        /* watchdog can be disabled with command line option */
+        move.d  0x7fffffff, $r10
+        jsr     CPU_WATCHDOG_TIMEOUT
+        nop
+#endif
 
         ; Initialize registers to increase determinism
         move.d __bss_start, $r0
diff --git a/arch/cris/arch-v32/kernel/kgdb.c b/arch/cris/arch-v32/kernel/kgdb.c
index b06813aeb12..c0343c3ea7f 100644
--- a/arch/cris/arch-v32/kernel/kgdb.c
+++ b/arch/cris/arch-v32/kernel/kgdb.c
@@ -381,9 +381,23 @@ static int read_register(char regno, unsigned int *valptr);
 /* Serial port, reads one character. ETRAX 100 specific. from debugport.c */
 int getDebugChar(void);
 
+#ifdef CONFIG_ETRAX_VCS_SIM
+int getDebugChar(void)
+{
+  return socketread();
+}
+#endif
+
 /* Serial port, writes one character. ETRAX 100 specific. from debugport.c */
 void putDebugChar(int val);
 
+#ifdef CONFIG_ETRAX_VCS_SIM
+void putDebugChar(int val)
+{
+  socketwrite((char *)&val, 1);
+}
+#endif
+
 /* Returns the integer equivalent of a hexadecimal character. */
 static int hex(char ch);
 
@@ -663,7 +677,7 @@ mem2hex(char *buf, unsigned char *mem, int count)
                 /* Valid mem address. */
                 for (i = 0; i < count; i++) {
                         ch = *mem++;
-                        buf = hex_byte_pack(buf, ch);
+                        buf = pack_hex_byte(buf, ch);
                 }
         }
         /* Terminate properly. */
@@ -681,7 +695,7 @@ mem2hex_nbo(char *buf, unsigned char *mem, int count)
         mem += count - 1;
         for (i = 0; i < count; i++) {
                 ch = *mem--;
-                buf = hex_byte_pack(buf, ch);
+                buf = pack_hex_byte(buf, ch);
         }
 
         /* Terminate properly. */
@@ -866,7 +880,7 @@ stub_is_stopped(int sigval)
         /* Send trap type (converted to signal) */
 
         *ptr++ = 'T';
-        ptr = hex_byte_pack(ptr, sigval);
+        ptr = pack_hex_byte(ptr, sigval);
 
         if (((reg.exs & 0xff00) >> 8) == 0xc) {
 
@@ -974,26 +988,26 @@ stub_is_stopped(int sigval)
         }
         /* Only send PC, frame and stack pointer. */
         read_register(PC, &reg_cont);
-        ptr = hex_byte_pack(ptr, PC);
+        ptr = pack_hex_byte(ptr, PC);
         *ptr++ = ':';
         ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[PC]);
         *ptr++ = ';';
 
         read_register(R8, &reg_cont);
-        ptr = hex_byte_pack(ptr, R8);
+        ptr = pack_hex_byte(ptr, R8);
         *ptr++ = ':';
         ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[R8]);
         *ptr++ = ';';
 
         read_register(SP, &reg_cont);
-        ptr = hex_byte_pack(ptr, SP);
+        ptr = pack_hex_byte(ptr, SP);
         *ptr++ = ':';
         ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[SP]);
         *ptr++ = ';';
 
         /* Send ERP as well; this will save us an entire register fetch in some cases. */
         read_register(ERP, &reg_cont);
-        ptr = hex_byte_pack(ptr, ERP);
+        ptr = pack_hex_byte(ptr, ERP);
         *ptr++ = ':';
         ptr = mem2hex(ptr, (unsigned char *)&reg_cont, register_size[ERP]);
         *ptr++ = ';';
diff --git a/arch/cris/arch-v32/kernel/process.c b/arch/cris/arch-v32/kernel/process.c
index 2b23ef0e445..0570e8ce603 100644
--- a/arch/cris/arch-v32/kernel/process.c
+++ b/arch/cris/arch-v32/kernel/process.c
@@ -16,7 +16,6 @@
 #include <hwregs/reg_map.h>
 #include <hwregs/timer_defs.h>
 #include <hwregs/intr_vect_defs.h>
-#include <linux/ptrace.h>
 
 extern void stop_watchdog(void);
 
@@ -95,6 +94,31 @@ unsigned long thread_saved_pc(struct task_struct *t)
         return task_pt_regs(t)->erp;
 }
 
+static void
+kernel_thread_helper(void* dummy, int (*fn)(void *), void * arg)
+{
+        fn(arg);
+        do_exit(-1); /* Should never be called, return bad exit value. */
+}
+
+/* Create a kernel thread. */
+int
+kernel_thread(int (*fn)(void *), void * arg, unsigned long flags)
+{
+        struct pt_regs regs;
+
+        memset(&regs, 0, sizeof(regs));
+
+        /* Don't use r10 since that is set to 0 in copy_thread. */
+        regs.r11 = (unsigned long) fn;
+        regs.r12 = (unsigned long) arg;
+        regs.erp = (unsigned long) kernel_thread_helper;
+        regs.ccs = 1 << (I_CCS_BITNR + CCS_SHIFT);
+
+        /* Create the new process. */
+        return do_fork(flags | CLONE_VM | CLONE_UNTRACED, 0, &regs, 0, NULL, NULL);
+}
+
 /*
  * Setup the child's kernel stack with a pt_regs and call switch_stack() on it.
  * It will be unnested during _resume and _ret_from_sys_call when the new thread
@@ -105,42 +129,34 @@ unsigned long thread_saved_pc(struct task_struct *t)
  */
 
 extern asmlinkage void ret_from_fork(void);
-extern asmlinkage void ret_from_kernel_thread(void);
 
 int
 copy_thread(unsigned long clone_flags, unsigned long usp,
-        unsigned long arg, struct task_struct *p)
+        unsigned long unused,
+        struct task_struct *p, struct pt_regs *regs)
 {
-        struct pt_regs *childregs = task_pt_regs(p);
-        struct switch_stack *swstack = ((struct switch_stack *) childregs) - 1;
+        struct pt_regs *childregs;
+        struct switch_stack *swstack;
 
         /*
          * Put the pt_regs structure at the end of the new kernel stack page and
          * fix it up. Note: the task_struct doubles as the kernel stack for the
          * task.
          */
-        if (unlikely(p->flags & PF_KTHREAD)) {
-                memset(swstack, 0,
-                        sizeof(struct switch_stack) + sizeof(struct pt_regs));
-                swstack->r1 = usp;
-                swstack->r2 = arg;
-                childregs->ccs = 1 << (I_CCS_BITNR + CCS_SHIFT);
-                swstack->return_ip = (unsigned long) ret_from_kernel_thread;
-                p->thread.ksp = (unsigned long) swstack;
-                p->thread.usp = 0;
-                return 0;
-        }
-        *childregs = *current_pt_regs();        /* Struct copy of pt_regs. */
+        childregs = task_pt_regs(p);
+        *childregs = *regs;     /* Struct copy of pt_regs. */
+        p->set_child_tid = p->clear_child_tid = NULL;
         childregs->r10 = 0;     /* Child returns 0 after a fork/clone. */
 
         /* Set a new TLS ?
          * The TLS is in $mof because it is the 5th argument to sys_clone.
          */
         if (p->mm && (clone_flags & CLONE_SETTLS)) {
-                task_thread_info(p)->tls = childregs->mof;
+                task_thread_info(p)->tls = regs->mof;
         }
 
         /* Put the switch stack right below the pt_regs. */
+        swstack = ((struct switch_stack *) childregs) - 1;
 
         /* Parameter to ret_from_sys_call. 0 is don't restart the syscall. */
         swstack->r9 = 0;
@@ -152,12 +168,76 @@ copy_thread(unsigned long clone_flags, unsigned long usp,
         swstack->return_ip = (unsigned long) ret_from_fork;
 
         /* Fix the user-mode and kernel-mode stackpointer. */
-        p->thread.usp = usp ?: rdusp();
+        p->thread.usp = usp;
         p->thread.ksp = (unsigned long) swstack;
 
         return 0;
 }
 
+/*
+ * Be aware of the "magic" 7th argument in the four system-calls below.
+ * They need the latest stackframe, which is put as the 7th argument by
+ * entry.S. The previous arguments are dummies or actually used, but need
+ * to be defined to reach the 7th argument.
+ *
+ * N.B.: Another method to get the stackframe is to use current_regs(). But
+ * it returns the latest stack-frame stacked when going from _user mode_ and
+ * some of these (at least sys_clone) are called from kernel-mode sometimes
+ * (for example during kernel_thread, above) and thus cannot use it. Thus,
+ * to be sure not to get any surprises, we use the method for the other calls
+ * as well.
+ */
+asmlinkage int
+sys_fork(long r10, long r11, long r12, long r13, long mof, long srp,
+        struct pt_regs *regs)
+{
+        return do_fork(SIGCHLD, rdusp(), regs, 0, NULL, NULL);
+}
+
+/* FIXME: Is parent_tid/child_tid really third/fourth argument? Update lib? */
+asmlinkage int
+sys_clone(unsigned long newusp, unsigned long flags, int *parent_tid, int *child_tid,
+        unsigned long tls, long srp, struct pt_regs *regs)
+{
+        if (!newusp)
+                newusp = rdusp();
+
+        return do_fork(flags, newusp, regs, 0, parent_tid, child_tid);
+}
+
+/*
+ * vfork is a system call in i386 because of register-pressure - maybe
+ * we can remove it and handle it in libc but we put it here until then.
+ */
+asmlinkage int
+sys_vfork(long r10, long r11, long r12, long r13, long mof, long srp,
+        struct pt_regs *regs)
+{
+        return do_fork(CLONE_VFORK | CLONE_VM | SIGCHLD, rdusp(), regs, 0, NULL, NULL);
+}
+
+/* sys_execve() executes a new program. */
+asmlinkage int
+sys_execve(const char *fname,
+           const char *const *argv,
+           const char *const *envp, long r13, long mof, long srp,
+           struct pt_regs *regs)
+{
+        int error;
+        char *filename;
+
+        filename = getname(fname);
+        error = PTR_ERR(filename);
+
+        if (IS_ERR(filename))
+                goto out;
+
+        error = do_execve(filename, argv, envp, regs);
+        putname(filename);
+ out:
+        return error;
+}
+
 unsigned long
 get_wchan(struct task_struct *p)
 {
diff --git a/arch/cris/arch-v32/kernel/ptrace.c b/arch/cris/arch-v32/kernel/ptrace.c
index f085229cf87..511ece94a57 100644
--- a/arch/cris/arch-v32/kernel/ptrace.c
+++ b/arch/cris/arch-v32/kernel/ptrace.c
@@ -15,6 +15,7 @@
 #include <asm/uaccess.h>
 #include <asm/page.h>
 #include <asm/pgtable.h>
+#include <asm/system.h>
 #include <asm/processor.h>
 #include <arch/hwregs/supp_reg.h>
 
@@ -114,6 +115,8 @@ void user_disable_single_step(struct task_struct *child)
 void
 ptrace_disable(struct task_struct *child)
 {
+        unsigned long tmp;
+
         /* Deconfigure SPC and S-bit. */
         user_disable_single_step(child);
         put_reg(child, PT_SPC, 0);
diff --git a/arch/cris/arch-v32/kernel/signal.c b/arch/cris/arch-v32/kernel/signal.c
index b60d1b65a42..ce4ab1a5552 100644
--- a/arch/cris/arch-v32/kernel/signal.c
+++ b/arch/cris/arch-v32/kernel/signal.c
@@ -24,6 +24,9 @@
 
 extern unsigned long cris_signal_return_page;
 
+/* Flag to check if a signal is blockable. */
+#define _BLOCKABLE (~(sigmask(SIGKILL) | sigmask(SIGSTOP)))
+
 /*
  * A syscall in CRIS is really a "break 13" instruction, which is 2
  * bytes. The registers is manipulated so upon return the instruction
@@ -56,11 +59,19 @@ void keep_debug_flags(unsigned long oldccs, unsigned long oldspc,
  * dummy arguments to be able to reach the regs argument.
  */
 int
-sys_sigsuspend(old_sigset_t mask)
+sys_sigsuspend(old_sigset_t mask, long r11, long r12, long r13, long mof,
+               long srp, struct pt_regs *regs)
 {
-        sigset_t blocked;
-        siginitset(&blocked, mask);
-        return sigsuspend(&blocked);
+        mask &= _BLOCKABLE;
+        spin_lock_irq(&current->sighand->siglock);
+        current->saved_sigmask = current->blocked;
+        siginitset(&current->blocked, mask);
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
+        current->state = TASK_INTERRUPTIBLE;
+        schedule();
+        set_thread_flag(TIF_RESTORE_SIGMASK);
+        return -ERESTARTNOHAND;
 }
 
 int
@@ -76,11 +87,11 @@ sys_sigaction(int signal, const struct old_sigaction *act,
 
                 if (!access_ok(VERIFY_READ, act, sizeof(*act)) ||
                     __get_user(newk.sa.sa_handler, &act->sa_handler) ||
-                    __get_user(newk.sa.sa_restorer, &act->sa_restorer) ||
-                    __get_user(newk.sa.sa_flags, &act->sa_flags) ||
-                    __get_user(mask, &act->sa_mask))
+                    __get_user(newk.sa.sa_restorer, &act->sa_restorer))
                         return -EFAULT;
 
+                __get_user(newk.sa.sa_flags, &act->sa_flags);
+                __get_user(mask, &act->sa_mask);
                 siginitset(&newk.sa.sa_mask, mask);
         }
 
@@ -89,11 +100,11 @@ sys_sigaction(int signal, const struct old_sigaction *act,
         if (!retval && oact) {
                 if (!access_ok(VERIFY_WRITE, oact, sizeof(*oact)) ||
                     __put_user(oldk.sa.sa_handler, &oact->sa_handler) ||
-                    __put_user(oldk.sa.sa_restorer, &oact->sa_restorer) ||
-                    __put_user(oldk.sa.sa_flags, &oact->sa_flags) ||
-                    __put_user(oldk.sa.sa_mask.sig[0], &oact->sa_mask))
+                    __put_user(oldk.sa.sa_restorer, &oact->sa_restorer))
                         return -EFAULT;
 
+                __put_user(oldk.sa.sa_flags, &oact->sa_flags);
+                __put_user(oldk.sa.sa_mask.sig[0], &oact->sa_mask);
         }
 
         return retval;
@@ -164,7 +175,13 @@ sys_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp,
                                                  sizeof(frame->extramask))))
                 goto badframe;
 
-        set_current_blocked(&set);
+        sigdelsetmask(&set, ~_BLOCKABLE);
+        spin_lock_irq(&current->sighand->siglock);
+
+        current->blocked = set;
+
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
 
         if (restore_sigcontext(regs, &frame->sc))
                 goto badframe;
@@ -204,7 +221,13 @@ sys_rt_sigreturn(long r10, long r11, long r12, long r13, long mof, long srp,
         if (__copy_from_user(&set, &frame->uc.uc_sigmask, sizeof(set)))
                 goto badframe;
 
-        set_current_blocked(&set);
+        sigdelsetmask(&set, ~_BLOCKABLE);
+        spin_lock_irq(&current->sighand->siglock);
+
+        current->blocked = set;
+
+        recalc_sigpending();
+        spin_unlock_irq(&current->sighand->siglock);
 
         if (restore_sigcontext(regs, &frame->uc.uc_mcontext))
                 goto badframe;
@@ -340,7 +363,10 @@ setup_frame(int sig, struct k_sigaction *ka,  sigset_t *set,
         return 0;
 
 give_sigsegv:
-        force_sigsegv(sig, current);
+        if (sig == SIGSEGV)
+                ka->sa.sa_handler = SIG_DFL;
+
+        force_sig(SIGSEGV, current);
         return -EFAULT;
 }
 
@@ -424,17 +450,19 @@ setup_rt_frame(int sig, struct k_sigaction *ka, siginfo_t *info,
         return 0;
 
 give_sigsegv:
-        force_sigsegv(sig, current);
+        if (sig == SIGSEGV)
+                ka->sa.sa_handler = SIG_DFL;
+
+        force_sig(SIGSEGV, current);
         return -EFAULT;
 }
 
 /* Invoke a signal handler to, well, handle the signal. */
-static inline void
+static inline int
 handle_signal(int canrestart, unsigned long sig,
               siginfo_t *info, struct k_sigaction *ka,
-              struct pt_regs * regs)
+              sigset_t *oldset, struct pt_regs * regs)
 {
-        sigset_t *oldset = sigmask_to_save();
         int ret;
 
         /* Check if this got called from a system call. */
@@ -484,8 +512,20 @@ handle_signal(int canrestart, unsigned long sig,
         else
                 ret = setup_frame(sig, ka, oldset, regs);
 
-        if (ret == 0)
-                signal_delivered(sig, info, ka, regs, 0);
+        if (ka->sa.sa_flags & SA_ONESHOT)
+                ka->sa.sa_handler = SIG_DFL;
+
+        if (ret == 0) {
+                spin_lock_irq(&current->sighand->siglock);
+                sigorsets(&current->blocked, &current->blocked,
+                        &ka->sa.sa_mask);
+                if (!(ka->sa.sa_flags & SA_NODEFER))
+                        sigaddset(&current->blocked, sig);
+                recalc_sigpending();
+                spin_unlock_irq(&current->sighand->siglock);
+        }
+
+        return ret;
 }
 
 /*
@@ -505,6 +545,7 @@ do_signal(int canrestart, struct pt_regs *regs)
         int signr;
         siginfo_t info;
         struct k_sigaction ka;
+        sigset_t *oldset;
 
         /*
          * The common case should go fast, which is why this point is
@@ -514,11 +555,25 @@ do_signal(int canrestart, struct pt_regs *regs)
         if (!user_mode(regs))
                 return;
 
+        if (test_thread_flag(TIF_RESTORE_SIGMASK))
+                oldset = &current->saved_sigmask;
+        else
+                oldset = &current->blocked;
+
         signr = get_signal_to_deliver(&info, &ka, regs, NULL);
 
         if (signr > 0) {
                 /* Whee!  Actually deliver the signal.  */
-                handle_signal(canrestart, signr, &info, &ka, regs);
+                if (handle_signal(canrestart, signr, &info, &ka,
+                                oldset, regs)) {
+                        /* 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;
         }
 
@@ -539,7 +594,10 @@ do_signal(int canrestart, struct pt_regs *regs)
 
         /* if there's no signal to deliver, we just put the saved sigmask
          * back */
-        restore_saved_sigmask();
+        if (test_thread_flag(TIF_RESTORE_SIGMASK)) {
+                clear_thread_flag(TIF_RESTORE_SIGMASK);
+                sigprocmask(SIG_SETMASK, &current->saved_sigmask, NULL);
+        }
 }
 
 asmlinkage void
diff --git a/arch/cris/arch-v32/kernel/smp.c b/arch/cris/arch-v32/kernel/smp.c
index 04a16edd540..0b99df72d2a 100644
--- a/arch/cris/arch-v32/kernel/smp.c
+++ b/arch/cris/arch-v32/kernel/smp.c
@@ -84,7 +84,7 @@ void __init smp_prepare_cpus(unsigned int max_cpus)
                 cpumask_set_cpu(i, &phys_cpu_present_map);
 }
 
-void smp_prepare_boot_cpu(void)
+void __devinit smp_prepare_boot_cpu(void)
 {
         /* PGD pointer has moved after per_cpu initialization so
          * update the MMU.
@@ -108,12 +108,17 @@ void __init smp_cpus_done(unsigned int max_cpus)
 
 /* Bring one cpu online.*/
 static int __init
-smp_boot_one_cpu(int cpuid, struct task_struct idle)
+smp_boot_one_cpu(int cpuid)
 {
         unsigned timeout;
+        struct task_struct *idle;
         cpumask_t cpu_mask;
 
         cpumask_clear(&cpu_mask);
+        idle = fork_idle(cpuid);
+        if (IS_ERR(idle))
+                panic("SMP: fork failed for CPU:%d", cpuid);
+
         task_thread_info(idle)->cpu = cpuid;
 
         /* Information to the CPU that is about to boot */
@@ -137,6 +142,9 @@ smp_boot_one_cpu(int cpuid, struct task_struct idle)
                 barrier();
         }
 
+        put_task_struct(idle);
+        idle = NULL;
+
         printk(KERN_CRIT "SMP: CPU:%d is stuck.\n", cpuid);
         return -1;
 }
@@ -199,9 +207,9 @@ int setup_profiling_timer(unsigned int multiplier)
  */
 unsigned long cache_decay_ticks = 1;
 
-int __cpuinit __cpu_up(unsigned int cpu, struct task_struct *tidle)
+int __cpuinit __cpu_up(unsigned int cpu)
 {
-        smp_boot_one_cpu(cpu, tidle);
+        smp_boot_one_cpu(cpu);
         return cpu_online(cpu) ? 0 : -ENOSYS;
 }
 
diff --git a/arch/cris/arch-v32/kernel/time.c b/arch/cris/arch-v32/kernel/time.c
index 8c4b45efd7b..bb978ede898 100644
--- a/arch/cris/arch-v32/kernel/time.c
+++ b/arch/cris/arch-v32/kernel/time.c
@@ -18,6 +18,7 @@
 #include <asm/signal.h>
 #include <asm/io.h>
 #include <asm/delay.h>
+#include <asm/rtc.h>
 #include <asm/irq.h>
 #include <asm/irq_regs.h>
 
@@ -46,12 +47,14 @@ static struct clocksource cont_rotime = {
         .rating = 300,
         .read   = read_cont_rotime,
         .mask   = CLOCKSOURCE_MASK(32),
+        .shift  = 10,
         .flags  = CLOCK_SOURCE_IS_CONTINUOUS,
 };
 
 static int __init etrax_init_cont_rotime(void)
 {
-        clocksource_register_khz(&cont_rotime, 100000);
+        cont_rotime.mult = clocksource_khz2mult(100000, cont_rotime.shift);
+        clocksource_register(&cont_rotime);
         return 0;
 }
 arch_initcall(etrax_init_cont_rotime);
@@ -66,6 +69,7 @@ unsigned long timer_regs[NR_CPUS] =
 };
 
 extern int set_rtc_mmss(unsigned long nowtime);
+extern int have_rtc;
 
 #ifdef CONFIG_CPU_FREQ
 static int
@@ -263,6 +267,11 @@ void __init time_init(void)
          */
         loops_per_usec = 50;
 
+        if(RTC_INIT() < 0)
+                have_rtc = 0;
+        else
+                have_rtc = 1;
+
         /* Start CPU local timer. */
         cris_timer_init();