Merge git://git.kernel.org/pub/scm/linux/kernel/git/kyle/parisc-2.6

* git://git.kernel.org/pub/scm/linux/kernel/git/kyle/parisc-2.6:
  parisc: convert to generic compat_sys_ptrace
  parisc: add rtc platform driver
  parisc: initialize unwinder much earlier
  parisc: add new syscalls
  parisc: hijack jump to start_kernel
  parisc: add pdc_coproc_cfg_unlocked and set_firmware_width_unlocked
  parisc: move include/asm-parisc to arch/parisc/include/asm
  parisc: move pdc_result to real2.S
  parisc: unify CCIO_COLLECT_STATS implementation
  parisc: add arch/parisc/kernel/.gitignore
  parisc: ropes.h - fix <asm-parisc/*> -> <asm/*>
  parisc: parisc-agp - fix <asm-parisc/*> -> <asm/*>

Resolve remove/rename conflict: include/asm-parisc/a.out.h is no longer
relevant.

10 files changed, 290 insertions, 287 deletions

diff --git a/arch/parisc/kernel/.gitignore b/arch/parisc/kernel/.gitignore
new file mode 100644
index 000000000000..c5f676c3c224
--- /dev/null
+++ b/arch/parisc/kernel/.gitignore
@@ -0,0 +1 @@
+vmlinux.lds
diff --git a/arch/parisc/kernel/asm-offsets.c b/arch/parisc/kernel/asm-offsets.c
index 3efc0b73e4ff..699cf8ef2118 100644
--- a/arch/parisc/kernel/asm-offsets.c
+++ b/arch/parisc/kernel/asm-offsets.c
@@ -290,5 +290,8 @@ int main(void)
         DEFINE(EXCDATA_IP, offsetof(struct exception_data, fault_ip));
         DEFINE(EXCDATA_SPACE, offsetof(struct exception_data, fault_space));
         DEFINE(EXCDATA_ADDR, offsetof(struct exception_data, fault_addr));
+        BLANK();
+        DEFINE(ASM_PDC_RESULT_SIZE, NUM_PDC_RESULT * sizeof(unsigned long));
+        BLANK();
         return 0;
 }
diff --git a/arch/parisc/kernel/firmware.c b/arch/parisc/kernel/firmware.c
index 7177a6cd1b7f..03f26bd75bd8 100644
--- a/arch/parisc/kernel/firmware.c
+++ b/arch/parisc/kernel/firmware.c
@@ -71,8 +71,8 @@
 #include <asm/processor.h>      /* for boot_cpu_data */
 
 static DEFINE_SPINLOCK(pdc_lock);
-static unsigned long pdc_result[32] __attribute__ ((aligned (8)));
-static unsigned long pdc_result2[32] __attribute__ ((aligned (8)));
+extern unsigned long pdc_result[NUM_PDC_RESULT];
+extern unsigned long pdc_result2[NUM_PDC_RESULT];
 
 #ifdef CONFIG_64BIT
 #define WIDE_FIRMWARE 0x1
@@ -150,26 +150,40 @@ static void convert_to_wide(unsigned long *addr)
 #endif
 }
 
+#ifdef CONFIG_64BIT
+void __init set_firmware_width_unlocked(void)
+{
+        int ret;
+
+        ret = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES,
+                __pa(pdc_result), 0);
+        convert_to_wide(pdc_result);
+        if (pdc_result[0] != NARROW_FIRMWARE)
+                parisc_narrow_firmware = 0;
+}
+        
 /**
  * set_firmware_width - Determine if the firmware is wide or narrow.
  * 
- * This function must be called before any pdc_* function that uses the convert_to_wide
- * function.
+ * This function must be called before any pdc_* function that uses the
+ * convert_to_wide function.
  */
 void __init set_firmware_width(void)
 {
-#ifdef CONFIG_64BIT
-        int retval;
         unsigned long flags;
+        spin_lock_irqsave(&pdc_lock, flags);
+        set_firmware_width_unlocked();
+        spin_unlock_irqrestore(&pdc_lock, flags);
+}
+#else
+void __init set_firmware_width_unlocked(void) {
+        return;
+}
 
-        spin_lock_irqsave(&pdc_lock, flags);
-        retval = mem_pdc_call(PDC_MODEL, PDC_MODEL_CAPABILITIES, __pa(pdc_result), 0);
-        convert_to_wide(pdc_result);
-        if(pdc_result[0] != NARROW_FIRMWARE)
-                parisc_narrow_firmware = 0;
-        spin_unlock_irqrestore(&pdc_lock, flags);
-#endif
+void __init set_firmware_width(void) {
+        return;
 }
+#endif /*CONFIG_64BIT*/
 
 /**
  * pdc_emergency_unlock - Unlock the linux pdc lock
@@ -288,6 +302,20 @@ int pdc_chassis_warn(unsigned long *warn)
         return retval;
 }
 
+int __init pdc_coproc_cfg_unlocked(struct pdc_coproc_cfg *pdc_coproc_info)
+{
+        int ret;
+
+        ret = mem_pdc_call(PDC_COPROC, PDC_COPROC_CFG, __pa(pdc_result));
+        convert_to_wide(pdc_result);
+        pdc_coproc_info->ccr_functional = pdc_result[0];
+        pdc_coproc_info->ccr_present = pdc_result[1];
+        pdc_coproc_info->revision = pdc_result[17];
+        pdc_coproc_info->model = pdc_result[18];
+
+        return ret;
+}
+
 /**
  * pdc_coproc_cfg - To identify coprocessors attached to the processor.
  * @pdc_coproc_info: Return buffer address.
@@ -297,19 +325,14 @@ int pdc_chassis_warn(unsigned long *warn)
  */
 int __init pdc_coproc_cfg(struct pdc_coproc_cfg *pdc_coproc_info)
 {
-        int retval;
+        int ret;
         unsigned long flags;
 
-        spin_lock_irqsave(&pdc_lock, flags);
-        retval = mem_pdc_call(PDC_COPROC, PDC_COPROC_CFG, __pa(pdc_result));
-        convert_to_wide(pdc_result);
-        pdc_coproc_info->ccr_functional = pdc_result[0];
-        pdc_coproc_info->ccr_present = pdc_result[1];
-        pdc_coproc_info->revision = pdc_result[17];
-        pdc_coproc_info->model = pdc_result[18];
-        spin_unlock_irqrestore(&pdc_lock, flags);
+        spin_lock_irqsave(&pdc_lock, flags);
+        ret = pdc_coproc_cfg_unlocked(pdc_coproc_info);
+        spin_unlock_irqrestore(&pdc_lock, flags);
 
-        return retval;
+        return ret;
 }
 
 /**
diff --git a/arch/parisc/kernel/head.S b/arch/parisc/kernel/head.S
index a84e31e82876..0e3d9f9b9e33 100644
--- a/arch/parisc/kernel/head.S
+++ b/arch/parisc/kernel/head.S
@@ -121,7 +121,7 @@ $pgt_fill_loop:
         copy            %r0,%r2
 
         /* And the RFI Target address too */
-        load32          start_kernel,%r11
+        load32          start_parisc,%r11
 
         /* And the initial task pointer */
         load32          init_thread_union,%r6
diff --git a/arch/parisc/kernel/ptrace.c b/arch/parisc/kernel/ptrace.c
index 49c637970789..90904f9dfc50 100644
--- a/arch/parisc/kernel/ptrace.c
+++ b/arch/parisc/kernel/ptrace.c
@@ -4,6 +4,7 @@
  * Copyright (C) 2000 Hewlett-Packard Co, Linuxcare Inc.
  * Copyright (C) 2000 Matthew Wilcox <matthew@wil.cx>
  * Copyright (C) 2000 David Huggins-Daines <dhd@debian.org>
+ * Copyright (C) 2008 Helge Deller <deller@gmx.de>
  */
 
 #include <linux/kernel.h>
@@ -27,15 +28,149 @@
 /* PSW bits we allow the debugger to modify */
 #define USER_PSW_BITS   (PSW_N | PSW_V | PSW_CB)
 
-#undef DEBUG_PTRACE
+/*
+ * Called by kernel/ptrace.c when detaching..
+ *
+ * Make sure single step bits etc are not set.
+ */
+void ptrace_disable(struct task_struct *task)
+{
+        task->ptrace &= ~(PT_SINGLESTEP|PT_BLOCKSTEP);
 
-#ifdef DEBUG_PTRACE
-#define DBG(x...)       printk(x)
-#else
-#define DBG(x...)
-#endif
+        /* make sure the trap bits are not set */
+        pa_psw(task)->r = 0;
+        pa_psw(task)->t = 0;
+        pa_psw(task)->h = 0;
+        pa_psw(task)->l = 0;
+}
+
+/*
+ * The following functions are called by ptrace_resume() when
+ * enabling or disabling single/block tracing.
+ */
+void user_disable_single_step(struct task_struct *task)
+{
+        ptrace_disable(task);
+}
+
+void user_enable_single_step(struct task_struct *task)
+{
+        task->ptrace &= ~PT_BLOCKSTEP;
+        task->ptrace |= PT_SINGLESTEP;
+
+        if (pa_psw(task)->n) {
+                struct siginfo si;
+
+                /* Nullified, just crank over the queue. */
+                task_regs(task)->iaoq[0] = task_regs(task)->iaoq[1];
+                task_regs(task)->iasq[0] = task_regs(task)->iasq[1];
+                task_regs(task)->iaoq[1] = task_regs(task)->iaoq[0] + 4;
+                pa_psw(task)->n = 0;
+                pa_psw(task)->x = 0;
+                pa_psw(task)->y = 0;
+                pa_psw(task)->z = 0;
+                pa_psw(task)->b = 0;
+                ptrace_disable(task);
+                /* Don't wake up the task, but let the
+                   parent know something happened. */
+                si.si_code = TRAP_TRACE;
+                si.si_addr = (void __user *) (task_regs(task)->iaoq[0] & ~3);
+                si.si_signo = SIGTRAP;
+                si.si_errno = 0;
+                force_sig_info(SIGTRAP, &si, task);
+                /* notify_parent(task, SIGCHLD); */
+                return;
+        }
+
+        /* Enable recovery counter traps.  The recovery counter
+         * itself will be set to zero on a task switch.  If the
+         * task is suspended on a syscall then the syscall return
+         * path will overwrite the recovery counter with a suitable
+         * value such that it traps once back in user space.  We
+         * disable interrupts in the tasks PSW here also, to avoid
+         * interrupts while the recovery counter is decrementing.
+         */
+        pa_psw(task)->r = 1;
+        pa_psw(task)->t = 0;
+        pa_psw(task)->h = 0;
+        pa_psw(task)->l = 0;
+}
+
+void user_enable_block_step(struct task_struct *task)
+{
+        task->ptrace &= ~PT_SINGLESTEP;
+        task->ptrace |= PT_BLOCKSTEP;
+
+        /* Enable taken branch trap. */
+        pa_psw(task)->r = 0;
+        pa_psw(task)->t = 1;
+        pa_psw(task)->h = 0;
+        pa_psw(task)->l = 0;
+}
+
+long arch_ptrace(struct task_struct *child, long request, long addr, long data)
+{
+        unsigned long tmp;
+        long ret = -EIO;
 
-#ifdef CONFIG_64BIT
+        switch (request) {
+
+        /* Read the word at location addr in the USER area.  For ptraced
+           processes, the kernel saves all regs on a syscall. */
+        case PTRACE_PEEKUSR:
+                if ((addr & (sizeof(long)-1)) ||
+                    (unsigned long) addr >= sizeof(struct pt_regs))
+                        break;
+                tmp = *(unsigned long *) ((char *) task_regs(child) + addr);
+                ret = put_user(tmp, (unsigned long *) data);
+                break;
+
+        /* Write the word at location addr in the USER area.  This will need
+           to change when the kernel no longer saves all regs on a syscall.
+           FIXME.  There is a problem at the moment in that r3-r18 are only
+           saved if the process is ptraced on syscall entry, and even then
+           those values are overwritten by actual register values on syscall
+           exit. */
+        case PTRACE_POKEUSR:
+                /* Some register values written here may be ignored in
+                 * entry.S:syscall_restore_rfi; e.g. iaoq is written with
+                 * r31/r31+4, and not with the values in pt_regs.
+                 */
+                if (addr == PT_PSW) {
+                        /* Allow writing to Nullify, Divide-step-correction,
+                         * and carry/borrow bits.
+                         * BEWARE, if you set N, and then single step, it won't
+                         * stop on the nullified instruction.
+                         */
+                        data &= USER_PSW_BITS;
+                        task_regs(child)->gr[0] &= ~USER_PSW_BITS;
+                        task_regs(child)->gr[0] |= data;
+                        ret = 0;
+                        break;
+                }
+
+                if ((addr & (sizeof(long)-1)) ||
+                    (unsigned long) addr >= sizeof(struct pt_regs))
+                        break;
+                if ((addr >= PT_GR1 && addr <= PT_GR31) ||
+                                addr == PT_IAOQ0 || addr == PT_IAOQ1 ||
+                                (addr >= PT_FR0 && addr <= PT_FR31 + 4) ||
+                                addr == PT_SAR) {
+                        *(unsigned long *) ((char *) task_regs(child) + addr) = data;
+                        ret = 0;
+                }
+                break;
+
+        default:
+                ret = ptrace_request(child, request, addr, data);
+                break;
+        }
+
+        return ret;
+}
+
+
+#ifdef CONFIG_COMPAT
 
 /* This function is needed to translate 32 bit pt_regs offsets in to
  * 64 bit pt_regs offsets.  For example, a 32 bit gdb under a 64 bit kernel
@@ -61,106 +196,25 @@ static long translate_usr_offset(long offset)
         else
                 return -1;
 }
-#endif
 
-/*
- * Called by kernel/ptrace.c when detaching..
- *
- * Make sure single step bits etc are not set.
- */
-void ptrace_disable(struct task_struct *child)
+long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
+                        compat_ulong_t addr, compat_ulong_t data)
 {
-        /* make sure the trap bits are not set */
-        pa_psw(child)->r = 0;
-        pa_psw(child)->t = 0;
-        pa_psw(child)->h = 0;
-        pa_psw(child)->l = 0;
-}
-
-long arch_ptrace(struct task_struct *child, long request, long addr, long data)
-{
-        long ret;
-#ifdef DEBUG_PTRACE
-        long oaddr=addr, odata=data;
-#endif
+        compat_uint_t tmp;
+        long ret = -EIO;
 
         switch (request) {
-        case PTRACE_PEEKTEXT: /* read word at location addr. */ 
-        case PTRACE_PEEKDATA: {
-#ifdef CONFIG_64BIT
-                if (__is_compat_task(child)) {
-                        int copied;
-                        unsigned int tmp;
-
-                        addr &= 0xffffffffL;
-                        copied = access_process_vm(child, addr, &tmp, sizeof(tmp), 0);
-                        ret = -EIO;
-                        if (copied != sizeof(tmp))
-                                goto out_tsk;
-                        ret = put_user(tmp,(unsigned int *) data);
-                        DBG("sys_ptrace(PEEK%s, %d, %lx, %lx) returning %ld, data %x\n",
-                                request == PTRACE_PEEKTEXT ? "TEXT" : "DATA",
-                                pid, oaddr, odata, ret, tmp);
-                }
-                else
-#endif
-                        ret = generic_ptrace_peekdata(child, addr, data);
-                goto out_tsk;
-        }
 
-        /* when I and D space are separate, this will have to be fixed. */
-        case PTRACE_POKETEXT: /* write the word at location addr. */
-        case PTRACE_POKEDATA:
-                ret = 0;
-#ifdef CONFIG_64BIT
-                if (__is_compat_task(child)) {
-                        unsigned int tmp = (unsigned int)data;
-                        DBG("sys_ptrace(POKE%s, %d, %lx, %lx)\n",
-                                request == PTRACE_POKETEXT ? "TEXT" : "DATA",
-                                pid, oaddr, odata);
-                        addr &= 0xffffffffL;
-                        if (access_process_vm(child, addr, &tmp, sizeof(tmp), 1) == sizeof(tmp))
-                                goto out_tsk;
-                }
-                else
-#endif
-                {
-                        if (access_process_vm(child, addr, &data, sizeof(data), 1) == sizeof(data))
-                                goto out_tsk;
-                }
-                ret = -EIO;
-                goto out_tsk;
-
-        /* Read the word at location addr in the USER area.  For ptraced
-           processes, the kernel saves all regs on a syscall. */
-        case PTRACE_PEEKUSR: {
-                ret = -EIO;
-#ifdef CONFIG_64BIT
-                if (__is_compat_task(child)) {
-                        unsigned int tmp;
-
-                        if (addr & (sizeof(int)-1))
-                                goto out_tsk;
-                        if ((addr = translate_usr_offset(addr)) < 0)
-                                goto out_tsk;
-
-                        tmp = *(unsigned int *) ((char *) task_regs(child) + addr);
-                        ret = put_user(tmp, (unsigned int *) data);
-                        DBG("sys_ptrace(PEEKUSR, %d, %lx, %lx) returning %ld, addr %lx, data %x\n",
-                                pid, oaddr, odata, ret, addr, tmp);
-                }
-                else
-#endif
-                {
-                        unsigned long tmp;
+        case PTRACE_PEEKUSR:
+                if (addr & (sizeof(compat_uint_t)-1))
+                        break;
+                addr = translate_usr_offset(addr);
+                if (addr < 0)
+                        break;
 
-                        if ((addr & (sizeof(long)-1)) || (unsigned long) addr >= sizeof(struct pt_regs))
-                                goto out_tsk;
-                        tmp = *(unsigned long *) ((char *) task_regs(child) + addr);
-                        ret = put_user(tmp, (unsigned long *) data);
-                }
-                goto out_tsk;
-        }
+                tmp = *(compat_uint_t *) ((char *) task_regs(child) + addr);
+                ret = put_user(tmp, (compat_uint_t *) (unsigned long) data);
+                break;
 
         /* Write the word at location addr in the USER area.  This will need
            to change when the kernel no longer saves all regs on a syscall.
@@ -169,185 +223,46 @@ long arch_ptrace(struct task_struct *child, long request, long addr, long data)
            those values are overwritten by actual register values on syscall
            exit. */
         case PTRACE_POKEUSR:
-                ret = -EIO;
                 /* Some register values written here may be ignored in
                  * entry.S:syscall_restore_rfi; e.g. iaoq is written with
                  * r31/r31+4, and not with the values in pt_regs.
                  */
-                 /* PT_PSW=0, so this is valid for 32 bit processes under 64
-                 * bit kernels.
-                 */
                 if (addr == PT_PSW) {
-                        /* PT_PSW=0, so this is valid for 32 bit processes
-                         * under 64 bit kernels.
-                         *
-                         * Allow writing to Nullify, Divide-step-correction,
-                         * and carry/borrow bits.
-                         * BEWARE, if you set N, and then single step, it won't
-                         * stop on the nullified instruction.
+                        /* Since PT_PSW==0, it is valid for 32 bit processes
+                         * under 64 bit kernels as well.
                          */
-                        DBG("sys_ptrace(POKEUSR, %d, %lx, %lx)\n",
-                                pid, oaddr, odata);
-                        data &= USER_PSW_BITS;
-                        task_regs(child)->gr[0] &= ~USER_PSW_BITS;
-                        task_regs(child)->gr[0] |= data;
-                        ret = 0;
-                        goto out_tsk;
-                }
-#ifdef CONFIG_64BIT
-                if (__is_compat_task(child)) {
-                        if (addr & (sizeof(int)-1))
-                                goto out_tsk;
-                        if ((addr = translate_usr_offset(addr)) < 0)
-                                goto out_tsk;
-                        DBG("sys_ptrace(POKEUSR, %d, %lx, %lx) addr %lx\n",
-                                pid, oaddr, odata, addr);
+                        ret = arch_ptrace(child, request, addr, data);
+                } else {
+                        if (addr & (sizeof(compat_uint_t)-1))
+                                break;
+                        addr = translate_usr_offset(addr);
+                        if (addr < 0)
+                                break;
                         if (addr >= PT_FR0 && addr <= PT_FR31 + 4) {
                                 /* Special case, fp regs are 64 bits anyway */
-                                *(unsigned int *) ((char *) task_regs(child) + addr) = data;
+                                *(__u64 *) ((char *) task_regs(child) + addr) = data;
                                 ret = 0;
                         }
                         else if ((addr >= PT_GR1+4 && addr <= PT_GR31+4) ||
                                         addr == PT_IAOQ0+4 || addr == PT_IAOQ1+4 ||
                                         addr == PT_SAR+4) {
                                 /* Zero the top 32 bits */
-                                *(unsigned int *) ((char *) task_regs(child) + addr - 4) = 0;
-                                *(unsigned int *) ((char *) task_regs(child) + addr) = data;
+                                *(__u32 *) ((char *) task_regs(child) + addr - 4) = 0;
+                                *(__u32 *) ((char *) task_regs(child) + addr) = data;
                                 ret = 0;
                         }
-                        goto out_tsk;
                 }
-                else
-#endif
-                {
-                        if ((addr & (sizeof(long)-1)) || (unsigned long) addr >= sizeof(struct pt_regs))
-                                goto out_tsk;
-                        if ((addr >= PT_GR1 && addr <= PT_GR31) ||
-                                        addr == PT_IAOQ0 || addr == PT_IAOQ1 ||
-                                        (addr >= PT_FR0 && addr <= PT_FR31 + 4) ||
-                                        addr == PT_SAR) {
-                                *(unsigned long *) ((char *) task_regs(child) + addr) = data;
-                                ret = 0;
-                        }
-                        goto out_tsk;
-                }
-
-        case PTRACE_SYSCALL: /* continue and stop at next (return from) syscall */
-        case PTRACE_CONT:
-                ret = -EIO;
-                DBG("sys_ptrace(%s)\n",
-                        request == PTRACE_SYSCALL ? "SYSCALL" : "CONT");
-                if (!valid_signal(data))
-                        goto out_tsk;
-                child->ptrace &= ~(PT_SINGLESTEP|PT_BLOCKSTEP);
-                if (request == PTRACE_SYSCALL) {
-                        set_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                } else {
-                        clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                }               
-                child->exit_code = data;
-                goto out_wake_notrap;
-
-        case PTRACE_KILL:
-                /*
-                 * make the child exit.  Best I can do is send it a
-                 * sigkill.  perhaps it should be put in the status
-                 * that it wants to exit.
-                 */
-                ret = 0;
-                DBG("sys_ptrace(KILL)\n");
-                if (child->exit_state == EXIT_ZOMBIE)   /* already dead */
-                        goto out_tsk;
-                child->exit_code = SIGKILL;
-                goto out_wake_notrap;
-
-        case PTRACE_SINGLEBLOCK:
-                DBG("sys_ptrace(SINGLEBLOCK)\n");
-                ret = -EIO;
-                if (!valid_signal(data))
-                        goto out_tsk;
-                clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                child->ptrace &= ~PT_SINGLESTEP;
-                child->ptrace |= PT_BLOCKSTEP;
-                child->exit_code = data;
-
-                /* Enable taken branch trap. */
-                pa_psw(child)->r = 0;
-                pa_psw(child)->t = 1;
-                pa_psw(child)->h = 0;
-                pa_psw(child)->l = 0;
-                goto out_wake;
-
-        case PTRACE_SINGLESTEP:
-                DBG("sys_ptrace(SINGLESTEP)\n");
-                ret = -EIO;
-                if (!valid_signal(data))
-                        goto out_tsk;
-
-                clear_tsk_thread_flag(child, TIF_SYSCALL_TRACE);
-                child->ptrace &= ~PT_BLOCKSTEP;
-                child->ptrace |= PT_SINGLESTEP;
-                child->exit_code = data;
-
-                if (pa_psw(child)->n) {
-                        struct siginfo si;
-
-                        /* Nullified, just crank over the queue. */
-                        task_regs(child)->iaoq[0] = task_regs(child)->iaoq[1];
-                        task_regs(child)->iasq[0] = task_regs(child)->iasq[1];
-                        task_regs(child)->iaoq[1] = task_regs(child)->iaoq[0] + 4;
-                        pa_psw(child)->n = 0;
-                        pa_psw(child)->x = 0;
-                        pa_psw(child)->y = 0;
-                        pa_psw(child)->z = 0;
-                        pa_psw(child)->b = 0;
-                        ptrace_disable(child);
-                        /* Don't wake up the child, but let the
-                           parent know something happened. */
-                        si.si_code = TRAP_TRACE;
-                        si.si_addr = (void __user *) (task_regs(child)->iaoq[0] & ~3);
-                        si.si_signo = SIGTRAP;
-                        si.si_errno = 0;
-                        force_sig_info(SIGTRAP, &si, child);
-                        //notify_parent(child, SIGCHLD);
-                        //ret = 0;
-                        goto out_wake;
-                }
-
-                /* Enable recovery counter traps.  The recovery counter
-                 * itself will be set to zero on a task switch.  If the
-                 * task is suspended on a syscall then the syscall return
-                 * path will overwrite the recovery counter with a suitable
-                 * value such that it traps once back in user space.  We
-                 * disable interrupts in the childs PSW here also, to avoid
-                 * interrupts while the recovery counter is decrementing.
-                 */
-                pa_psw(child)->r = 1;
-                pa_psw(child)->t = 0;
-                pa_psw(child)->h = 0;
-                pa_psw(child)->l = 0;
-                /* give it a chance to run. */
-                goto out_wake;
-
-        case PTRACE_GETEVENTMSG:
-                ret = put_user(child->ptrace_message, (unsigned int __user *) data);
-                goto out_tsk;
+                break;
 
         default:
-                ret = ptrace_request(child, request, addr, data);
-                goto out_tsk;
+                ret = compat_ptrace_request(child, request, addr, data);
+                break;
         }
 
-out_wake_notrap:
-        ptrace_disable(child);
-out_wake:
-        wake_up_process(child);
-        ret = 0;
-out_tsk:
-        DBG("arch_ptrace(%ld, %d, %lx, %lx) returning %ld\n",
-                request, pid, oaddr, odata, ret);
         return ret;
 }
+#endif
+
 
 void syscall_trace(void)
 {
diff --git a/arch/parisc/kernel/real2.S b/arch/parisc/kernel/real2.S
index 7a92695d95a6..5f3d3a1f9037 100644
--- a/arch/parisc/kernel/real2.S
+++ b/arch/parisc/kernel/real2.S
@@ -8,12 +8,24 @@
  *
  */
 
+#include <asm/pdc.h>
 #include <asm/psw.h>
 #include <asm/assembly.h>
+#include <asm/asm-offsets.h>
 
 #include <linux/linkage.h>
 
+
         .section        .bss
+
+        .export pdc_result
+        .export pdc_result2
+        .align 8
+pdc_result:
+        .block  ASM_PDC_RESULT_SIZE
+pdc_result2:
+        .block  ASM_PDC_RESULT_SIZE
+
         .export real_stack
         .export real32_stack
         .export real64_stack
diff --git a/arch/parisc/kernel/setup.c b/arch/parisc/kernel/setup.c
index 39e7c5a5946a..7d27853ff8c8 100644
--- a/arch/parisc/kernel/setup.c
+++ b/arch/parisc/kernel/setup.c
@@ -44,6 +44,7 @@
 #include <asm/pdc_chassis.h>
 #include <asm/io.h>
 #include <asm/setup.h>
+#include <asm/unwind.h>
 
 static char __initdata command_line[COMMAND_LINE_SIZE];
 
@@ -123,6 +124,7 @@ void __init setup_arch(char **cmdline_p)
 #ifdef CONFIG_64BIT
         extern int parisc_narrow_firmware;
 #endif
+        unwind_init();
 
         init_per_cpu(smp_processor_id());       /* Set Modes & Enable FP */
 
@@ -368,6 +370,31 @@ static int __init parisc_init(void)
 
         return 0;
 }
-
 arch_initcall(parisc_init);
 
+void start_parisc(void)
+{
+        extern void start_kernel(void);
+
+        int ret, cpunum;
+        struct pdc_coproc_cfg coproc_cfg;
+
+        cpunum = smp_processor_id();
+
+        set_firmware_width_unlocked();
+
+        ret = pdc_coproc_cfg_unlocked(&coproc_cfg);
+        if (ret >= 0 && coproc_cfg.ccr_functional) {
+                mtctl(coproc_cfg.ccr_functional, 10);
+
+                cpu_data[cpunum].fp_rev = coproc_cfg.revision;
+                cpu_data[cpunum].fp_model = coproc_cfg.model;
+
+                asm volatile ("fstd     %fr0,8(%sp)");
+        } else {
+                panic("must have an fpu to boot linux");
+        }
+
+        start_kernel();
+        // not reached
+}
diff --git a/arch/parisc/kernel/syscall_table.S b/arch/parisc/kernel/syscall_table.S
index c7e59f548817..303d2b647e41 100644
--- a/arch/parisc/kernel/syscall_table.S
+++ b/arch/parisc/kernel/syscall_table.S
@@ -87,7 +87,7 @@
         ENTRY_SAME(setuid)
         ENTRY_SAME(getuid)
         ENTRY_COMP(stime)               /* 25 */
-        ENTRY_SAME(ptrace)
+        ENTRY_COMP(ptrace)
         ENTRY_SAME(alarm)
         /* see stat comment */
         ENTRY_COMP(newfstat)
@@ -407,6 +407,12 @@
         ENTRY_SAME(timerfd_create)
         ENTRY_COMP(timerfd_settime)
         ENTRY_COMP(timerfd_gettime)
+        ENTRY_COMP(signalfd4)
+        ENTRY_SAME(eventfd2)            /* 310 */
+        ENTRY_SAME(epoll_create1)
+        ENTRY_SAME(dup3)
+        ENTRY_SAME(pipe2)
+        ENTRY_SAME(inotify_init1)
 
         /* Nothing yet */
 
diff --git a/arch/parisc/kernel/time.c b/arch/parisc/kernel/time.c
index 24be86bba94d..4d09203bc693 100644
--- a/arch/parisc/kernel/time.c
+++ b/arch/parisc/kernel/time.c
@@ -23,6 +23,7 @@
 #include <linux/smp.h>
 #include <linux/profile.h>
 #include <linux/clocksource.h>
+#include <linux/platform_device.h>
 
 #include <asm/uaccess.h>
 #include <asm/io.h>
@@ -215,6 +216,24 @@ void __init start_cpu_itimer(void)
         cpu_data[cpu].it_value = next_tick;
 }
 
+struct platform_device rtc_parisc_dev = {
+        .name = "rtc-parisc",
+        .id = -1,
+};
+
+static int __init rtc_init(void)
+{
+        int ret;
+
+        ret = platform_device_register(&rtc_parisc_dev);
+        if (ret < 0)
+                printk(KERN_ERR "unable to register rtc device...\n");
+
+        /* not necessarily an error */
+        return 0;
+}
+module_init(rtc_init);
+
 void __init time_init(void)
 {
         static struct pdc_tod tod_data;
@@ -245,4 +264,3 @@ void __init time_init(void)
                 xtime.tv_nsec = 0;
         }
 }
-
diff --git a/arch/parisc/kernel/unwind.c b/arch/parisc/kernel/unwind.c
index 701b2d2d8882..6773c582e457 100644
--- a/arch/parisc/kernel/unwind.c
+++ b/arch/parisc/kernel/unwind.c
@@ -170,7 +170,7 @@ void unwind_table_remove(struct unwind_table *table)
 }
 
 /* Called from setup_arch to import the kernel unwind info */
-static int unwind_init(void)
+int unwind_init(void)
 {
         long start, stop;
         register unsigned long gp __asm__ ("r27");
@@ -417,5 +417,3 @@ int unwind_to_user(struct unwind_frame_info *info)
 
         return ret;
 }
-
-module_init(unwind_init);