Merge rsync://rsync.kernel.org/pub/scm/linux/kernel/git/paulus/ppc64-2.6

18 files changed, 291 insertions, 530 deletions

diff --git a/arch/ppc64/boot/Makefile b/arch/ppc64/boot/Makefile
index d3e1d6af9203..683b2d43c15f 100644
--- a/arch/ppc64/boot/Makefile
+++ b/arch/ppc64/boot/Makefile
@@ -52,7 +52,7 @@ obj-sec = $(foreach section, $(1), $(patsubst %,$(obj)/kernel-%.o, $(section)))
 src-sec = $(foreach section, $(1), $(patsubst %,$(obj)/kernel-%.c, $(section)))
 gz-sec  = $(foreach section, $(1), $(patsubst %,$(obj)/kernel-%.gz, $(section)))
 
-hostprogs-y             := piggy addnote addRamDisk
+hostprogs-y             := addnote addRamDisk
 targets                 += zImage zImage.initrd imagesize.c \
                            $(patsubst $(obj)/%,%, $(call obj-sec, $(required) $(initrd))) \
                            $(patsubst $(obj)/%,%, $(call src-sec, $(required) $(initrd))) \
@@ -78,9 +78,6 @@ addsection = $(CROSS32OBJCOPY) $(1) \
 quiet_cmd_addnote = ADDNOTE $@ 
       cmd_addnote = $(CROSS32LD) $(BOOTLFLAGS) -o $@ $(obj-boot) && $(obj)/addnote $@
 
-quiet_cmd_piggy = PIGGY   $@
-      cmd_piggy = $(obj)/piggyback $(@:.o=) < $< | $(CROSS32AS) -o $@
-
 $(call gz-sec, $(required)): $(obj)/kernel-%.gz: % FORCE
         $(call if_changed,gzip)
 
diff --git a/arch/ppc64/boot/main.c b/arch/ppc64/boot/main.c
index da12ea2ca464..199d9804f61c 100644
--- a/arch/ppc64/boot/main.c
+++ b/arch/ppc64/boot/main.c
@@ -17,7 +17,6 @@
 
 extern void *finddevice(const char *);
 extern int getprop(void *, const char *, void *, int);
-extern void printk(char *fmt, ...);
 extern void printf(const char *fmt, ...);
 extern int sprintf(char *buf, const char *fmt, ...);
 void gunzip(void *, int, unsigned char *, int *);
@@ -147,10 +146,10 @@ void start(unsigned long a1, unsigned long a2, void *promptr)
                 }
                 a1 = initrd.addr;
                 a2 = initrd.size;
-                printf("initial ramdisk moving 0x%lx <- 0x%lx (%lx bytes)\n\r",
+                printf("initial ramdisk moving 0x%lx <- 0x%lx (0x%lx bytes)\n\r",
                        initrd.addr, (unsigned long)_initrd_start, initrd.size);
                 memmove((void *)initrd.addr, (void *)_initrd_start, initrd.size);
-                printf("initrd head: 0x%lx\n\r", *((u32 *)initrd.addr));
+                printf("initrd head: 0x%lx\n\r", *((unsigned long *)initrd.addr));
         }
 
         /* Eventually gunzip the kernel */
@@ -201,9 +200,6 @@ void start(unsigned long a1, unsigned long a2, void *promptr)
 
         flush_cache((void *)vmlinux.addr, vmlinux.size);
 
-        if (a1)
-                printf("initrd head: 0x%lx\n\r", *((u32 *)initrd.addr));
-
         kernel_entry = (kernel_entry_t)vmlinux.addr;
 #ifdef DEBUG
         printf( "kernel:\n\r"
diff --git a/arch/ppc64/boot/mknote.c b/arch/ppc64/boot/mknote.c
deleted file mode 100644
index 120cc1d89739..000000000000
--- a/arch/ppc64/boot/mknote.c
+++ /dev/null
@@ -1,43 +0,0 @@
-/*
- * Copyright (C) Cort Dougan 1999.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- *
- * Generate a note section as per the CHRP specification.
- *
- */
-
-#include <stdio.h>
-
-#define PL(x) printf("%c%c%c%c", ((x)>>24)&0xff, ((x)>>16)&0xff, ((x)>>8)&0xff, (x)&0xff );
-
-int main(void)
-{
-/* header */
-        /* namesz */
-        PL(strlen("PowerPC")+1);
-        /* descrsz */
-        PL(6*4);
-        /* type */
-        PL(0x1275);
-        /* name */
-        printf("PowerPC"); printf("%c", 0);
-        
-/* descriptor */
-        /* real-mode */
-        PL(0xffffffff);
-        /* real-base */
-        PL(0x00c00000);
-        /* real-size */
-        PL(0xffffffff);
-        /* virt-base */
-        PL(0xffffffff);
-        /* virt-size */
-        PL(0xffffffff);
-        /* load-base */
-        PL(0x4000);
-        return 0;
-}
diff --git a/arch/ppc64/boot/piggyback.c b/arch/ppc64/boot/piggyback.c
deleted file mode 100644
index 235c7a87269c..000000000000
--- a/arch/ppc64/boot/piggyback.c
+++ /dev/null
@@ -1,83 +0,0 @@
-/*
- * Copyright 2001 IBM Corp 
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License
- * as published by the Free Software Foundation; either version
- * 2 of the License, or (at your option) any later version.
- */
-#include <stdio.h>
-#include <unistd.h>
-#include <string.h>
-
-extern long ce_exec_config[];
-
-int main(int argc, char *argv[])
-{
-        int i, cnt, pos, len;
-        unsigned int cksum, val;
-        unsigned char *lp;
-        unsigned char buf[8192];
-        char *varname;
-        if (argc != 2)
-        {
-                fprintf(stderr, "usage: %s name <in-file >out-file\n",
-                        argv[0]);
-                exit(1);
-        }
-
-        varname = strrchr(argv[1], '/');
-        if (varname)
-                varname++;
-        else
-                varname = argv[1];
-
-        fprintf(stdout, "#\n");
-        fprintf(stdout, "# Miscellaneous data structures:\n");
-        fprintf(stdout, "# WARNING - this file is automatically generated!\n");
-        fprintf(stdout, "#\n");
-        fprintf(stdout, "\n");
-        fprintf(stdout, "\t.data\n");
-        fprintf(stdout, "\t.globl %s_data\n", varname);
-        fprintf(stdout, "%s_data:\n", varname);
-        pos = 0;
-        cksum = 0;
-        while ((len = read(0, buf, sizeof(buf))) > 0)
-        {
-                cnt = 0;
-                lp = (unsigned char *)buf;
-                len = (len + 3) & ~3;  /* Round up to longwords */
-                for (i = 0;  i < len;  i += 4)
-                {
-                        if (cnt == 0)
-                        {
-                                fprintf(stdout, "\t.long\t");
-                        }
-                        fprintf(stdout, "0x%02X%02X%02X%02X", lp[0], lp[1], lp[2], lp[3]);
-                        val = *(unsigned long *)lp;
-                        cksum ^= val;
-                        lp += 4;
-                        if (++cnt == 4)
-                        {
-                                cnt = 0;
-                                fprintf(stdout, " # %x \n", pos+i-12);
-                                fflush(stdout);
-                        } else
-                        {
-                                fprintf(stdout, ",");
-                        }
-                }
-                if (cnt)
-                {
-                        fprintf(stdout, "0\n");
-                }
-                pos += len;
-        }
-        fprintf(stdout, "\t.globl %s_len\n", varname);
-        fprintf(stdout, "%s_len:\t.long\t0x%x\n", varname, pos);
-        fflush(stdout);
-        fclose(stdout);
-        fprintf(stderr, "cksum = %x\n", cksum);
-        exit(0);
-}
-
diff --git a/arch/ppc64/boot/prom.c b/arch/ppc64/boot/prom.c
index d5218b15824e..5e48b80ff5a0 100644
--- a/arch/ppc64/boot/prom.c
+++ b/arch/ppc64/boot/prom.c
@@ -40,7 +40,7 @@ void *finddevice(const char *name);
 int getprop(void *phandle, const char *name, void *buf, int buflen);
 void chrpboot(int a1, int a2, void *prom);      /* in main.c */
 
-void printk(char *fmt, ...);
+int printf(char *fmt, ...);
 
 /* there is no convenient header to get this from...  -- paulus */
 extern unsigned long strlen(const char *);
@@ -220,7 +220,7 @@ readchar(void)
                 case 1:
                         return ch;
                 case -1:
-                        printk("read(stdin) returned -1\r\n");
+                        printf("read(stdin) returned -1\r\n");
                         return -1;
                 }
         }
@@ -627,18 +627,6 @@ int sprintf(char * buf, const char *fmt, ...)
 
 static char sprint_buf[1024];
 
-void
-printk(char *fmt, ...)
-{
-        va_list args;
-        int n;
-
-        va_start(args, fmt);
-        n = vsprintf(sprint_buf, fmt, args);
-        va_end(args);
-        write(stdout, sprint_buf, n);
-}
-
 int
 printf(char *fmt, ...)
 {
diff --git a/arch/ppc64/kernel/ItLpQueue.c b/arch/ppc64/kernel/ItLpQueue.c
index cdea00d7707f..4231861288a3 100644
--- a/arch/ppc64/kernel/ItLpQueue.c
+++ b/arch/ppc64/kernel/ItLpQueue.c
@@ -1,7 +1,7 @@
 /*
  * ItLpQueue.c
  * Copyright (C) 2001 Mike Corrigan  IBM Corporation
- * 
+ *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
@@ -11,156 +11,252 @@
 #include <linux/stddef.h>
 #include <linux/kernel.h>
 #include <linux/sched.h>
+#include <linux/bootmem.h>
+#include <linux/seq_file.h>
+#include <linux/proc_fs.h>
 #include <asm/system.h>
 #include <asm/paca.h>
 #include <asm/iSeries/ItLpQueue.h>
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/HvCallEvent.h>
 
-static __inline__ int set_inUse( struct ItLpQueue * lpQueue )
-{
-        int t;
-        u32 * inUseP = &(lpQueue->xInUseWord);
-
-        __asm__ __volatile__("\n\
-1:      lwarx   %0,0,%2         \n\
-        cmpwi   0,%0,0          \n\
-        li      %0,0            \n\
-        bne-    2f              \n\
-        addi    %0,%0,1         \n\
-        stwcx.  %0,0,%2         \n\
-        bne-    1b              \n\
-2:      eieio"
-        : "=&r" (t), "=m" (lpQueue->xInUseWord)
-        : "r" (inUseP), "m" (lpQueue->xInUseWord)
-        : "cc");
-
-        return t;
-}
+/*
+ * The LpQueue is used to pass event data from the hypervisor to
+ * the partition.  This is where I/O interrupt events are communicated.
+ *
+ * It is written to by the hypervisor so cannot end up in the BSS.
+ */
+struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
 
-static __inline__ void clear_inUse( struct ItLpQueue * lpQueue )
-{
-        lpQueue->xInUseWord = 0;
-}
+DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
+
+static char *event_types[HvLpEvent_Type_NumTypes] = {
+        "Hypervisor",
+        "Machine Facilities",
+        "Session Manager",
+        "SPD I/O",
+        "Virtual Bus",
+        "PCI I/O",
+        "RIO I/O",
+        "Virtual Lan",
+        "Virtual I/O"
+};
 
 /* Array of LpEvent handler functions */
 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
-unsigned long ItLpQueueInProcess = 0;
 
-struct HvLpEvent * ItLpQueue_getNextLpEvent( struct ItLpQueue * lpQueue )
+static struct HvLpEvent * get_next_hvlpevent(void)
 {
-        struct HvLpEvent * nextLpEvent = 
-                (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
-        if ( nextLpEvent->xFlags.xValid ) {
+        struct HvLpEvent * event;
+        event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
+
+        if (event->xFlags.xValid) {
                 /* rmb() needed only for weakly consistent machines (regatta) */
                 rmb();
                 /* Set pointer to next potential event */
-                lpQueue->xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
-                                      LpEventAlign ) /
-                                      LpEventAlign ) *
-                                      LpEventAlign;
+                hvlpevent_queue.xSlicCurEventPtr += ((event->xSizeMinus1 +
+                                LpEventAlign) / LpEventAlign) * LpEventAlign;
+
                 /* Wrap to beginning if no room at end */
-                if (lpQueue->xSlicCurEventPtr > lpQueue->xSlicLastValidEventPtr)
-                        lpQueue->xSlicCurEventPtr = lpQueue->xSlicEventStackPtr;
+                if (hvlpevent_queue.xSlicCurEventPtr >
+                                hvlpevent_queue.xSlicLastValidEventPtr) {
+                        hvlpevent_queue.xSlicCurEventPtr =
+                                hvlpevent_queue.xSlicEventStackPtr;
+                }
+        } else {
+                event = NULL;
         }
-        else 
-                nextLpEvent = NULL;
 
-        return nextLpEvent;
+        return event;
 }
 
-int ItLpQueue_isLpIntPending( struct ItLpQueue * lpQueue )
+static unsigned long spread_lpevents = NR_CPUS;
+
+int hvlpevent_is_pending(void)
 {
-        int retval = 0;
-        struct HvLpEvent * nextLpEvent;
-        if ( lpQueue ) {
-                nextLpEvent = (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
-                retval = nextLpEvent->xFlags.xValid | lpQueue->xPlicOverflowIntPending;
-        }
-        return retval;
+        struct HvLpEvent *next_event;
+
+        if (smp_processor_id() >= spread_lpevents)
+                return 0;
+
+        next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
+
+        return next_event->xFlags.xValid |
+                hvlpevent_queue.xPlicOverflowIntPending;
 }
 
-void ItLpQueue_clearValid( struct HvLpEvent * event )
+static void hvlpevent_clear_valid(struct HvLpEvent * event)
 {
-        /* Clear the valid bit of the event
-         * Also clear bits within this event that might
-         * look like valid bits (on 64-byte boundaries)
-         */
-        unsigned extra = (( event->xSizeMinus1 + LpEventAlign ) /
-                                                 LpEventAlign ) - 1;
-        switch ( extra ) {
-          case 3:
-           ((struct HvLpEvent*)((char*)event+3*LpEventAlign))->xFlags.xValid=0;
-          case 2:
-           ((struct HvLpEvent*)((char*)event+2*LpEventAlign))->xFlags.xValid=0;
-          case 1:
-           ((struct HvLpEvent*)((char*)event+1*LpEventAlign))->xFlags.xValid=0;
-          case 0:
-           ;    
+        /* Tell the Hypervisor that we're done with this event.
+         * Also clear bits within this event that might look like valid bits.
+         * ie. on 64-byte boundaries.
+         */
+        struct HvLpEvent *tmp;
+        unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
+                                                 LpEventAlign) - 1;
+
+        switch (extra) {
+        case 3:
+                tmp = (struct HvLpEvent*)((char*)event + 3 * LpEventAlign);
+                tmp->xFlags.xValid = 0;
+        case 2:
+                tmp = (struct HvLpEvent*)((char*)event + 2 * LpEventAlign);
+                tmp->xFlags.xValid = 0;
+        case 1:
+                tmp = (struct HvLpEvent*)((char*)event + 1 * LpEventAlign);
+                tmp->xFlags.xValid = 0;
         }
+
         mb();
+
         event->xFlags.xValid = 0;
 }
 
-unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
+void process_hvlpevents(struct pt_regs *regs)
 {
-        unsigned numIntsProcessed = 0;
-        struct HvLpEvent * nextLpEvent;
+        struct HvLpEvent * event;
 
         /* If we have recursed, just return */
-        if ( !set_inUse( lpQueue ) )
-                return 0;
-        
-        if (ItLpQueueInProcess == 0)
-                ItLpQueueInProcess = 1;
-        else
-                BUG();
+        if (!spin_trylock(&hvlpevent_queue.lock))
+                return;
 
         for (;;) {
-                nextLpEvent = ItLpQueue_getNextLpEvent( lpQueue );
-                if ( nextLpEvent ) {
-                        /* Count events to return to caller
-                         * and count processed events in lpQueue
-                         */
-                        ++numIntsProcessed;
-                        lpQueue->xLpIntCount++;         
-                        /* Call appropriate handler here, passing 
+                event = get_next_hvlpevent();
+                if (event) {
+                        /* Call appropriate handler here, passing
                          * a pointer to the LpEvent.  The handler
                          * must make a copy of the LpEvent if it
                          * needs it in a bottom half. (perhaps for
                          * an ACK)
-                         *      
-                         *  Handlers are responsible for ACK processing 
+                         *
+                         *  Handlers are responsible for ACK processing
                          *
                          * The Hypervisor guarantees that LpEvents will
                          * only be delivered with types that we have
                          * registered for, so no type check is necessary
                          * here!
-                         */
-                        if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes )
-                                lpQueue->xLpIntCountByType[nextLpEvent->xType]++;
-                        if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
-                             lpEventHandler[nextLpEvent->xType] ) 
-                                lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
+                         */
+                        if (event->xType < HvLpEvent_Type_NumTypes)
+                                __get_cpu_var(hvlpevent_counts)[event->xType]++;
+                        if (event->xType < HvLpEvent_Type_NumTypes &&
+                                        lpEventHandler[event->xType])
+                                lpEventHandler[event->xType](event, regs);
                         else
-                                printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
-                        
-                        ItLpQueue_clearValid( nextLpEvent );
-                } else if ( lpQueue->xPlicOverflowIntPending )
+                                printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
+
+                        hvlpevent_clear_valid(event);
+                } else if (hvlpevent_queue.xPlicOverflowIntPending)
                         /*
                          * No more valid events. If overflow events are
                          * pending process them
                          */
-                        HvCallEvent_getOverflowLpEvents( lpQueue->xIndex);
+                        HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
                 else
                         break;
         }
 
-        ItLpQueueInProcess = 0;
-        mb();
-        clear_inUse( lpQueue );
+        spin_unlock(&hvlpevent_queue.lock);
+}
+
+static int set_spread_lpevents(char *str)
+{
+        unsigned long val = simple_strtoul(str, NULL, 0);
+
+        /*
+         * The parameter is the number of processors to share in processing
+         * lp events.
+         */
+        if (( val > 0) && (val <= NR_CPUS)) {
+                spread_lpevents = val;
+                printk("lpevent processing spread over %ld processors\n", val);
+        } else {
+                printk("invalid spread_lpevents %ld\n", val);
+        }
 
-        get_paca()->lpevent_count += numIntsProcessed;
+        return 1;
+}
+__setup("spread_lpevents=", set_spread_lpevents);
+
+void setup_hvlpevent_queue(void)
+{
+        void *eventStack;
+
+        /*
+         * Allocate a page for the Event Stack. The Hypervisor needs the
+         * absolute real address, so we subtract out the KERNELBASE and add
+         * in the absolute real address of the kernel load area.
+         */
+        eventStack = alloc_bootmem_pages(LpEventStackSize);
+        memset(eventStack, 0, LpEventStackSize);
+
+        /* Invoke the hypervisor to initialize the event stack */
+        HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
+
+        hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
+        hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
+        hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
+                                        (LpEventStackSize - LpEventMaxSize);
+        hvlpevent_queue.xIndex = 0;
+}
+
+static int proc_lpevents_show(struct seq_file *m, void *v)
+{
+        int cpu, i;
+        unsigned long sum;
+        static unsigned long cpu_totals[NR_CPUS];
+
+        /* FIXME: do we care that there's no locking here? */
+        sum = 0;
+        for_each_online_cpu(cpu) {
+                cpu_totals[cpu] = 0;
+                for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
+                        cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
+                }
+                sum += cpu_totals[cpu];
+        }
+
+        seq_printf(m, "LpEventQueue 0\n");
+        seq_printf(m, "  events processed:\t%lu\n", sum);
+
+        for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
+                sum = 0;
+                for_each_online_cpu(cpu) {
+                        sum += per_cpu(hvlpevent_counts, cpu)[i];
+                }
+
+                seq_printf(m, "    %-20s %10lu\n", event_types[i], sum);
+        }
+
+        seq_printf(m, "\n  events processed by processor:\n");
+
+        for_each_online_cpu(cpu) {
+                seq_printf(m, "    CPU%02d  %10lu\n", cpu, cpu_totals[cpu]);
+        }
+
+        return 0;
+}
+
+static int proc_lpevents_open(struct inode *inode, struct file *file)
+{
+        return single_open(file, proc_lpevents_show, NULL);
+}
 
-        return numIntsProcessed;
+static struct file_operations proc_lpevents_operations = {
+        .open           = proc_lpevents_open,
+        .read           = seq_read,
+        .llseek         = seq_lseek,
+        .release        = single_release,
+};
+
+static int __init proc_lpevents_init(void)
+{
+        struct proc_dir_entry *e;
+
+        e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
+        if (e)
+                e->proc_fops = &proc_lpevents_operations;
+
+        return 0;
 }
+__initcall(proc_lpevents_init);
+
diff --git a/arch/ppc64/kernel/LparData.c b/arch/ppc64/kernel/LparData.c
index badc5a443614..6ffcf67dd507 100644
--- a/arch/ppc64/kernel/LparData.c
+++ b/arch/ppc64/kernel/LparData.c
@@ -28,13 +28,6 @@
 #include <asm/iSeries/IoHriProcessorVpd.h>
 #include <asm/iSeries/ItSpCommArea.h>
 
-/* The LpQueue is used to pass event data from the hypervisor to
- * the partition.  This is where I/O interrupt events are communicated.
- */
-
-/* May be filled in by the hypervisor so cannot end up in the BSS */
-struct ItLpQueue xItLpQueue __attribute__((__section__(".data")));
-
 
 /* The HvReleaseData is the root of the information shared between 
  * the hypervisor and Linux.  
@@ -200,7 +193,7 @@ struct ItVpdAreas itVpdAreas = {
                 0,0,0,                  /* 13 - 15 */
                 sizeof(struct IoHriProcessorVpd),/* 16 length of Proc Vpd */
                 0,0,0,0,0,0,            /* 17 - 22  */
-                sizeof(struct ItLpQueue),/*     23 length of Lp Queue */
+                sizeof(struct hvlpevent_queue), /* 23 length of Lp Queue */
                 0,0                     /* 24 - 25 */
                 },
         .xSlicVpdAdrs = {                       /* VPD addresses */
@@ -218,7 +211,7 @@ struct ItVpdAreas itVpdAreas = {
                 0,0,0,                  /* 13 - 15 */
                 &xIoHriProcessorVpd,    /*      16 Proc Vpd */
                 0,0,0,0,0,0,            /* 17 - 22 */
-                &xItLpQueue,            /*      23 Lp Queue */
+                &hvlpevent_queue,       /*      23 Lp Queue */
                 0,0
         }
 };
diff --git a/arch/ppc64/kernel/iSeries_proc.c b/arch/ppc64/kernel/iSeries_proc.c
index 356bd9931fcc..0fe3116eba29 100644
--- a/arch/ppc64/kernel/iSeries_proc.c
+++ b/arch/ppc64/kernel/iSeries_proc.c
@@ -40,50 +40,6 @@ static int __init iseries_proc_create(void)
 }
 core_initcall(iseries_proc_create);
 
-static char *event_types[9] = {
-        "Hypervisor\t\t",
-        "Machine Facilities\t",
-        "Session Manager\t",
-        "SPD I/O\t\t",
-        "Virtual Bus\t\t",
-        "PCI I/O\t\t",
-        "RIO I/O\t\t",
-        "Virtual Lan\t\t",
-        "Virtual I/O\t\t"
-};
-
-static int proc_lpevents_show(struct seq_file *m, void *v)
-{
-        unsigned int i;
-
-        seq_printf(m, "LpEventQueue 0\n");
-        seq_printf(m, "  events processed:\t%lu\n",
-                   (unsigned long)xItLpQueue.xLpIntCount);
-
-        for (i = 0; i < 9; ++i)
-                seq_printf(m, "    %s %10lu\n", event_types[i],
-                           (unsigned long)xItLpQueue.xLpIntCountByType[i]);
-
-        seq_printf(m, "\n  events processed by processor:\n");
-
-        for_each_online_cpu(i)
-                seq_printf(m, "    CPU%02d  %10u\n", i, paca[i].lpevent_count);
-
-        return 0;
-}
-
-static int proc_lpevents_open(struct inode *inode, struct file *file)
-{
-        return single_open(file, proc_lpevents_show, NULL);
-}
-
-static struct file_operations proc_lpevents_operations = {
-        .open           = proc_lpevents_open,
-        .read           = seq_read,
-        .llseek         = seq_lseek,
-        .release        = single_release,
-};
-
 static unsigned long startTitan = 0;
 static unsigned long startTb = 0;
 
@@ -148,10 +104,6 @@ static int __init iseries_proc_init(void)
 {
         struct proc_dir_entry *e;
 
-        e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
-        if (e)
-                e->proc_fops = &proc_lpevents_operations;
-
         e = create_proc_entry("iSeries/titanTod", S_IFREG|S_IRUGO, NULL);
         if (e)
                 e->proc_fops = &proc_titantod_operations;
diff --git a/arch/ppc64/kernel/iSeries_setup.c b/arch/ppc64/kernel/iSeries_setup.c
index 86966ce76b58..b3f770f6d402 100644
--- a/arch/ppc64/kernel/iSeries_setup.c
+++ b/arch/ppc64/kernel/iSeries_setup.c
@@ -24,7 +24,6 @@
 #include <linux/smp.h>
 #include <linux/param.h>
 #include <linux/string.h>
-#include <linux/bootmem.h>
 #include <linux/initrd.h>
 #include <linux/seq_file.h>
 #include <linux/kdev_t.h>
@@ -676,7 +675,6 @@ static void __init iSeries_bolt_kernel(unsigned long saddr, unsigned long eaddr)
  */
 static void __init iSeries_setup_arch(void)
 {
-        void *eventStack;
         unsigned procIx = get_paca()->lppaca.dyn_hv_phys_proc_index;
 
         /* Add an eye catcher and the systemcfg layout version number */
@@ -685,24 +683,7 @@ static void __init iSeries_setup_arch(void)
         systemcfg->version.minor = SYSTEMCFG_MINOR;
 
         /* Setup the Lp Event Queue */
-
-        /* Allocate a page for the Event Stack
-         * The hypervisor wants the absolute real address, so
-         * we subtract out the KERNELBASE and add in the
-         * absolute real address of the kernel load area
-         */
-        eventStack = alloc_bootmem_pages(LpEventStackSize);
-        memset(eventStack, 0, LpEventStackSize);
-
-        /* Invoke the hypervisor to initialize the event stack */
-        HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
-
-        /* Initialize fields in our Lp Event Queue */
-        xItLpQueue.xSlicEventStackPtr = (char *)eventStack;
-        xItLpQueue.xSlicCurEventPtr = (char *)eventStack;
-        xItLpQueue.xSlicLastValidEventPtr = (char *)eventStack +
-                                        (LpEventStackSize - LpEventMaxSize);
-        xItLpQueue.xIndex = 0;
+        setup_hvlpevent_queue();
 
         /* Compute processor frequency */
         procFreqHz = ((1UL << 34) * 1000000) /
@@ -853,28 +834,6 @@ static int __init iSeries_src_init(void)
 
 late_initcall(iSeries_src_init);
 
-static int set_spread_lpevents(char *str)
-{
-        unsigned long i;
-        unsigned long val = simple_strtoul(str, NULL, 0);
-
-        /*
-         * The parameter is the number of processors to share in processing
-         * lp events.
-         */
-        if (( val > 0) && (val <= NR_CPUS)) {
-                for (i = 1; i < val; ++i)
-                        paca[i].lpqueue_ptr = paca[0].lpqueue_ptr;
-
-                printk("lpevent processing spread over %ld processors\n", val);
-        } else {
-                printk("invalid spread_lpevents %ld\n", val);
-        }
-
-        return 1;
-}
-__setup("spread_lpevents=", set_spread_lpevents);
-
 #ifndef CONFIG_PCI
 void __init iSeries_init_IRQ(void) { }
 #endif
diff --git a/arch/ppc64/kernel/idle.c b/arch/ppc64/kernel/idle.c
index bdf13b4dc1c8..08952c7e6216 100644
--- a/arch/ppc64/kernel/idle.c
+++ b/arch/ppc64/kernel/idle.c
@@ -88,7 +88,7 @@ static int iSeries_idle(void)
 
         while (1) {
                 if (lpaca->lppaca.shared_proc) {
-                        if (ItLpQueue_isLpIntPending(lpaca->lpqueue_ptr))
+                        if (hvlpevent_is_pending())
                                 process_iSeries_events();
                         if (!need_resched())
                                 yield_shared_processor();
@@ -100,7 +100,7 @@ static int iSeries_idle(void)
 
                                 while (!need_resched()) {
                                         HMT_medium();
-                                        if (ItLpQueue_isLpIntPending(lpaca->lpqueue_ptr))
+                                        if (hvlpevent_is_pending())
                                                 process_iSeries_events();
                                         HMT_low();
                                 }
diff --git a/arch/ppc64/kernel/irq.c b/arch/ppc64/kernel/irq.c
index ffe300611f00..f41afe545045 100644
--- a/arch/ppc64/kernel/irq.c
+++ b/arch/ppc64/kernel/irq.c
@@ -66,7 +66,6 @@ EXPORT_SYMBOL(irq_desc);
 int distribute_irqs = 1;
 int __irq_offset_value;
 int ppc_spurious_interrupts;
-unsigned long lpevent_count;
 u64 ppc64_interrupt_controller;
 
 int show_interrupts(struct seq_file *p, void *v)
@@ -269,7 +268,6 @@ out:
 void do_IRQ(struct pt_regs *regs)
 {
         struct paca_struct *lpaca;
-        struct ItLpQueue *lpq;
 
         irq_enter();
 
@@ -295,9 +293,8 @@ void do_IRQ(struct pt_regs *regs)
                 iSeries_smp_message_recv(regs);
         }
 #endif /* CONFIG_SMP */
-        lpq = lpaca->lpqueue_ptr;
-        if (lpq && ItLpQueue_isLpIntPending(lpq))
-                lpevent_count += ItLpQueue_process(lpq, regs);
+        if (hvlpevent_is_pending())
+                process_hvlpevents(regs);
 
         irq_exit();
 
diff --git a/arch/ppc64/kernel/mf.c b/arch/ppc64/kernel/mf.c
index d98bebf7042f..ef4a338ebd01 100644
--- a/arch/ppc64/kernel/mf.c
+++ b/arch/ppc64/kernel/mf.c
@@ -801,10 +801,8 @@ int mf_get_boot_rtc(struct rtc_time *tm)
                 return rc;
         /* We need to poll here as we are not yet taking interrupts */
         while (rtc_data.busy) {
-                extern unsigned long lpevent_count;
-                struct ItLpQueue *lpq = get_paca()->lpqueue_ptr;
-                if (lpq && ItLpQueue_isLpIntPending(lpq))
-                        lpevent_count += ItLpQueue_process(lpq, NULL);
+                if (hvlpevent_is_pending())
+                        process_hvlpevents(NULL);
         }
         return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
 }
diff --git a/arch/ppc64/kernel/nvram.c b/arch/ppc64/kernel/nvram.c
index 4e71781a4414..4fb1a9f5060d 100644
--- a/arch/ppc64/kernel/nvram.c
+++ b/arch/ppc64/kernel/nvram.c
@@ -338,9 +338,8 @@ static int nvram_remove_os_partition(void)
  */
 static int nvram_create_os_partition(void)
 {
-        struct list_head * p;
-        struct nvram_partition *part = NULL;
-        struct nvram_partition *new_part = NULL;
+        struct nvram_partition *part;
+        struct nvram_partition *new_part;
         struct nvram_partition *free_part = NULL;
         int seq_init[2] = { 0, 0 };
         loff_t tmp_index;
@@ -349,8 +348,7 @@ static int nvram_create_os_partition(void)
         
         /* Find a free partition that will give us the maximum needed size 
            If can't find one that will give us the minimum size needed */
-        list_for_each(p, &nvram_part->partition) {
-                part = list_entry(p, struct nvram_partition, partition);
+        list_for_each_entry(part, &nvram_part->partition, partition) {
                 if (part->header.signature != NVRAM_SIG_FREE)
                         continue;
 
diff --git a/arch/ppc64/kernel/pacaData.c b/arch/ppc64/kernel/pacaData.c
index a3e0975c26c1..6316188737b6 100644
--- a/arch/ppc64/kernel/pacaData.c
+++ b/arch/ppc64/kernel/pacaData.c
@@ -42,21 +42,7 @@ extern unsigned long __toc_start;
  * processors.  The processor VPD array needs one entry per physical
  * processor (not thread).
  */
-#ifdef CONFIG_PPC_ISERIES
-#define EXTRA_INITS(number, lpq)                                            \
-        .lppaca_ptr = &paca[number].lppaca,                                 \
-        .lpqueue_ptr = (lpq),           /* &xItLpQueue, */                  \
-        .reg_save_ptr = &paca[number].reg_save,                             \
-        .reg_save = {                                                       \
-                .xDesc = 0xd397d9e2,    /* "LpRS" */                        \
-                .xSize = sizeof(struct ItLpRegSave)                         \
-        },
-#else
-#define EXTRA_INITS(number, lpq)
-#endif
-
-#define PACAINITDATA(number,start,lpq,asrr,asrv)                            \
-{                                                                           \
+#define PACA_INIT_COMMON(number, start, asrr, asrv)                         \
         .lock_token = 0x8000,                                               \
         .paca_index = (number),         /* Paca Index */                    \
         .default_decr = 0x00ff0000,     /* Initial Decr */                  \
@@ -74,147 +60,79 @@ extern unsigned long __toc_start;
                 .end_of_quantum = 0xfffffffffffffffful,                     \
                 .slb_count = 64,                                            \
         },                                                                  \
-        EXTRA_INITS((number), (lpq))                                        \
-}
 
-struct paca_struct paca[] = {
 #ifdef CONFIG_PPC_ISERIES
-        PACAINITDATA( 0, 1, &xItLpQueue, 0, STAB0_VIRT_ADDR),
+#define PACA_INIT_ISERIES(number)                                           \
+        .lppaca_ptr = &paca[number].lppaca,                                 \
+        .reg_save_ptr = &paca[number].reg_save,                             \
+        .reg_save = {                                                       \
+                .xDesc = 0xd397d9e2,    /* "LpRS" */                        \
+                .xSize = sizeof(struct ItLpRegSave)                         \
+        }
+
+#define PACA_INIT(number)                                                   \
+{                                                                           \
+        PACA_INIT_COMMON(number, 0, 0, 0)                                   \
+        PACA_INIT_ISERIES(number)                                           \
+}
+
+#define BOOTCPU_PACA_INIT(number)                                           \
+{                                                                           \
+        PACA_INIT_COMMON(number, 1, 0, STAB0_VIRT_ADDR)                     \
+        PACA_INIT_ISERIES(number)                                           \
+}
+
 #else
-        PACAINITDATA( 0, 1, NULL, STAB0_PHYS_ADDR, STAB0_VIRT_ADDR),
+#define PACA_INIT(number)                                                   \
+{                                                                           \
+        PACA_INIT_COMMON(number, 0, 0, 0)                                   \
+}
+
+#define BOOTCPU_PACA_INIT(number)                                           \
+{                                                                           \
+        PACA_INIT_COMMON(number, 1, STAB0_PHYS_ADDR, STAB0_VIRT_ADDR)       \
+}
 #endif
+
+struct paca_struct paca[] = {
+        BOOTCPU_PACA_INIT(0),
 #if NR_CPUS > 1
-        PACAINITDATA( 1, 0, NULL, 0, 0),
-        PACAINITDATA( 2, 0, NULL, 0, 0),
-        PACAINITDATA( 3, 0, NULL, 0, 0),
+        PACA_INIT(  1), PACA_INIT(  2), PACA_INIT(  3),
 #if NR_CPUS > 4
-        PACAINITDATA( 4, 0, NULL, 0, 0),
-        PACAINITDATA( 5, 0, NULL, 0, 0),
-        PACAINITDATA( 6, 0, NULL, 0, 0),
-        PACAINITDATA( 7, 0, NULL, 0, 0),
+        PACA_INIT(  4), PACA_INIT(  5), PACA_INIT(  6), PACA_INIT(  7),
 #if NR_CPUS > 8
-        PACAINITDATA( 8, 0, NULL, 0, 0),
-        PACAINITDATA( 9, 0, NULL, 0, 0),
-        PACAINITDATA(10, 0, NULL, 0, 0),
-        PACAINITDATA(11, 0, NULL, 0, 0),
-        PACAINITDATA(12, 0, NULL, 0, 0),
-        PACAINITDATA(13, 0, NULL, 0, 0),
-        PACAINITDATA(14, 0, NULL, 0, 0),
-        PACAINITDATA(15, 0, NULL, 0, 0),
-        PACAINITDATA(16, 0, NULL, 0, 0),
-        PACAINITDATA(17, 0, NULL, 0, 0),
-        PACAINITDATA(18, 0, NULL, 0, 0),
-        PACAINITDATA(19, 0, NULL, 0, 0),
-        PACAINITDATA(20, 0, NULL, 0, 0),
-        PACAINITDATA(21, 0, NULL, 0, 0),
-        PACAINITDATA(22, 0, NULL, 0, 0),
-        PACAINITDATA(23, 0, NULL, 0, 0),
-        PACAINITDATA(24, 0, NULL, 0, 0),
-        PACAINITDATA(25, 0, NULL, 0, 0),
-        PACAINITDATA(26, 0, NULL, 0, 0),
-        PACAINITDATA(27, 0, NULL, 0, 0),
-        PACAINITDATA(28, 0, NULL, 0, 0),
-        PACAINITDATA(29, 0, NULL, 0, 0),
-        PACAINITDATA(30, 0, NULL, 0, 0),
-        PACAINITDATA(31, 0, NULL, 0, 0),
+        PACA_INIT(  8), PACA_INIT(  9), PACA_INIT( 10), PACA_INIT( 11),
+        PACA_INIT( 12), PACA_INIT( 13), PACA_INIT( 14), PACA_INIT( 15),
+        PACA_INIT( 16), PACA_INIT( 17), PACA_INIT( 18), PACA_INIT( 19),
+        PACA_INIT( 20), PACA_INIT( 21), PACA_INIT( 22), PACA_INIT( 23),
+        PACA_INIT( 24), PACA_INIT( 25), PACA_INIT( 26), PACA_INIT( 27),
+        PACA_INIT( 28), PACA_INIT( 29), PACA_INIT( 30), PACA_INIT( 31),
 #if NR_CPUS > 32
-        PACAINITDATA(32, 0, NULL, 0, 0),
-        PACAINITDATA(33, 0, NULL, 0, 0),
-        PACAINITDATA(34, 0, NULL, 0, 0),
-        PACAINITDATA(35, 0, NULL, 0, 0),
-        PACAINITDATA(36, 0, NULL, 0, 0),
-        PACAINITDATA(37, 0, NULL, 0, 0),
-        PACAINITDATA(38, 0, NULL, 0, 0),
-        PACAINITDATA(39, 0, NULL, 0, 0),
-        PACAINITDATA(40, 0, NULL, 0, 0),
-        PACAINITDATA(41, 0, NULL, 0, 0),
-        PACAINITDATA(42, 0, NULL, 0, 0),
-        PACAINITDATA(43, 0, NULL, 0, 0),
-        PACAINITDATA(44, 0, NULL, 0, 0),
-        PACAINITDATA(45, 0, NULL, 0, 0),
-        PACAINITDATA(46, 0, NULL, 0, 0),
-        PACAINITDATA(47, 0, NULL, 0, 0),
-        PACAINITDATA(48, 0, NULL, 0, 0),
-        PACAINITDATA(49, 0, NULL, 0, 0),
-        PACAINITDATA(50, 0, NULL, 0, 0),
-        PACAINITDATA(51, 0, NULL, 0, 0),
-        PACAINITDATA(52, 0, NULL, 0, 0),
-        PACAINITDATA(53, 0, NULL, 0, 0),
-        PACAINITDATA(54, 0, NULL, 0, 0),
-        PACAINITDATA(55, 0, NULL, 0, 0),
-        PACAINITDATA(56, 0, NULL, 0, 0),
-        PACAINITDATA(57, 0, NULL, 0, 0),
-        PACAINITDATA(58, 0, NULL, 0, 0),
-        PACAINITDATA(59, 0, NULL, 0, 0),
-        PACAINITDATA(60, 0, NULL, 0, 0),
-        PACAINITDATA(61, 0, NULL, 0, 0),
-        PACAINITDATA(62, 0, NULL, 0, 0),
-        PACAINITDATA(63, 0, NULL, 0, 0),
+        PACA_INIT( 32), PACA_INIT( 33), PACA_INIT( 34), PACA_INIT( 35),
+        PACA_INIT( 36), PACA_INIT( 37), PACA_INIT( 38), PACA_INIT( 39),
+        PACA_INIT( 40), PACA_INIT( 41), PACA_INIT( 42), PACA_INIT( 43),
+        PACA_INIT( 44), PACA_INIT( 45), PACA_INIT( 46), PACA_INIT( 47),
+        PACA_INIT( 48), PACA_INIT( 49), PACA_INIT( 50), PACA_INIT( 51),
+        PACA_INIT( 52), PACA_INIT( 53), PACA_INIT( 54), PACA_INIT( 55),
+        PACA_INIT( 56), PACA_INIT( 57), PACA_INIT( 58), PACA_INIT( 59),
+        PACA_INIT( 60), PACA_INIT( 61), PACA_INIT( 62), PACA_INIT( 63),
 #if NR_CPUS > 64
-        PACAINITDATA(64, 0, NULL, 0, 0),
-        PACAINITDATA(65, 0, NULL, 0, 0),
-        PACAINITDATA(66, 0, NULL, 0, 0),
-        PACAINITDATA(67, 0, NULL, 0, 0),
-        PACAINITDATA(68, 0, NULL, 0, 0),
-        PACAINITDATA(69, 0, NULL, 0, 0),
-        PACAINITDATA(70, 0, NULL, 0, 0),
-        PACAINITDATA(71, 0, NULL, 0, 0),
-        PACAINITDATA(72, 0, NULL, 0, 0),
-        PACAINITDATA(73, 0, NULL, 0, 0),
-        PACAINITDATA(74, 0, NULL, 0, 0),
-        PACAINITDATA(75, 0, NULL, 0, 0),
-        PACAINITDATA(76, 0, NULL, 0, 0),
-        PACAINITDATA(77, 0, NULL, 0, 0),
-        PACAINITDATA(78, 0, NULL, 0, 0),
-        PACAINITDATA(79, 0, NULL, 0, 0),
-        PACAINITDATA(80, 0, NULL, 0, 0),
-        PACAINITDATA(81, 0, NULL, 0, 0),
-        PACAINITDATA(82, 0, NULL, 0, 0),
-        PACAINITDATA(83, 0, NULL, 0, 0),
-        PACAINITDATA(84, 0, NULL, 0, 0),
-        PACAINITDATA(85, 0, NULL, 0, 0),
-        PACAINITDATA(86, 0, NULL, 0, 0),
-        PACAINITDATA(87, 0, NULL, 0, 0),
-        PACAINITDATA(88, 0, NULL, 0, 0),
-        PACAINITDATA(89, 0, NULL, 0, 0),
-        PACAINITDATA(90, 0, NULL, 0, 0),
-        PACAINITDATA(91, 0, NULL, 0, 0),
-        PACAINITDATA(92, 0, NULL, 0, 0),
-        PACAINITDATA(93, 0, NULL, 0, 0),
-        PACAINITDATA(94, 0, NULL, 0, 0),
-        PACAINITDATA(95, 0, NULL, 0, 0),
-        PACAINITDATA(96, 0, NULL, 0, 0),
-        PACAINITDATA(97, 0, NULL, 0, 0),
-        PACAINITDATA(98, 0, NULL, 0, 0),
-        PACAINITDATA(99, 0, NULL, 0, 0),
-        PACAINITDATA(100, 0, NULL, 0, 0),
-        PACAINITDATA(101, 0, NULL, 0, 0),
-        PACAINITDATA(102, 0, NULL, 0, 0),
-        PACAINITDATA(103, 0, NULL, 0, 0),
-        PACAINITDATA(104, 0, NULL, 0, 0),
-        PACAINITDATA(105, 0, NULL, 0, 0),
-        PACAINITDATA(106, 0, NULL, 0, 0),
-        PACAINITDATA(107, 0, NULL, 0, 0),
-        PACAINITDATA(108, 0, NULL, 0, 0),
-        PACAINITDATA(109, 0, NULL, 0, 0),
-        PACAINITDATA(110, 0, NULL, 0, 0),
-        PACAINITDATA(111, 0, NULL, 0, 0),
-        PACAINITDATA(112, 0, NULL, 0, 0),
-        PACAINITDATA(113, 0, NULL, 0, 0),
-        PACAINITDATA(114, 0, NULL, 0, 0),
-        PACAINITDATA(115, 0, NULL, 0, 0),
-        PACAINITDATA(116, 0, NULL, 0, 0),
-        PACAINITDATA(117, 0, NULL, 0, 0),
-        PACAINITDATA(118, 0, NULL, 0, 0),
-        PACAINITDATA(119, 0, NULL, 0, 0),
-        PACAINITDATA(120, 0, NULL, 0, 0),
-        PACAINITDATA(121, 0, NULL, 0, 0),
-        PACAINITDATA(122, 0, NULL, 0, 0),
-        PACAINITDATA(123, 0, NULL, 0, 0),
-        PACAINITDATA(124, 0, NULL, 0, 0),
-        PACAINITDATA(125, 0, NULL, 0, 0),
-        PACAINITDATA(126, 0, NULL, 0, 0),
-        PACAINITDATA(127, 0, NULL, 0, 0),
+        PACA_INIT( 64), PACA_INIT( 65), PACA_INIT( 66), PACA_INIT( 67),
+        PACA_INIT( 68), PACA_INIT( 69), PACA_INIT( 70), PACA_INIT( 71),
+        PACA_INIT( 72), PACA_INIT( 73), PACA_INIT( 74), PACA_INIT( 75),
+        PACA_INIT( 76), PACA_INIT( 77), PACA_INIT( 78), PACA_INIT( 79),
+        PACA_INIT( 80), PACA_INIT( 81), PACA_INIT( 82), PACA_INIT( 83),
+        PACA_INIT( 84), PACA_INIT( 85), PACA_INIT( 86), PACA_INIT( 87),
+        PACA_INIT( 88), PACA_INIT( 89), PACA_INIT( 90), PACA_INIT( 91),
+        PACA_INIT( 92), PACA_INIT( 93), PACA_INIT( 94), PACA_INIT( 95),
+        PACA_INIT( 96), PACA_INIT( 97), PACA_INIT( 98), PACA_INIT( 99),
+        PACA_INIT(100), PACA_INIT(101), PACA_INIT(102), PACA_INIT(103),
+        PACA_INIT(104), PACA_INIT(105), PACA_INIT(106), PACA_INIT(107),
+        PACA_INIT(108), PACA_INIT(109), PACA_INIT(110), PACA_INIT(111),
+        PACA_INIT(112), PACA_INIT(113), PACA_INIT(114), PACA_INIT(115),
+        PACA_INIT(116), PACA_INIT(117), PACA_INIT(118), PACA_INIT(119),
+        PACA_INIT(120), PACA_INIT(121), PACA_INIT(122), PACA_INIT(123),
+        PACA_INIT(124), PACA_INIT(125), PACA_INIT(126), PACA_INIT(127),
 #endif
 #endif
 #endif
diff --git a/arch/ppc64/kernel/sysfs.c b/arch/ppc64/kernel/sysfs.c
index c8fa6569b2fd..2f704a2cafb1 100644
--- a/arch/ppc64/kernel/sysfs.c
+++ b/arch/ppc64/kernel/sysfs.c
@@ -400,7 +400,12 @@ static int __init topology_init(void)
                 struct cpu *c = &per_cpu(cpu_devices, cpu);
 
 #ifdef CONFIG_NUMA
-                parent = &node_devices[cpu_to_node(cpu)];
+                /* The node to which a cpu belongs can't be known
+                 * until the cpu is made present.
+                 */
+                parent = NULL;
+                if (cpu_present(cpu))
+                        parent = &node_devices[cpu_to_node(cpu)];
 #endif
                 /*
                  * For now, we just see if the system supports making
diff --git a/arch/ppc64/kernel/time.c b/arch/ppc64/kernel/time.c
index 2a532db9138a..909462e1adea 100644
--- a/arch/ppc64/kernel/time.c
+++ b/arch/ppc64/kernel/time.c
@@ -99,7 +99,6 @@ unsigned long tb_to_ns_shift;
 struct gettimeofday_struct do_gtod;
 
 extern unsigned long wall_jiffies;
-extern unsigned long lpevent_count;
 extern int smp_tb_synchronized;
 
 extern struct timezone sys_tz;
@@ -367,11 +366,8 @@ int timer_interrupt(struct pt_regs * regs)
         set_dec(next_dec);
 
 #ifdef CONFIG_PPC_ISERIES
-        {
-                struct ItLpQueue *lpq = lpaca->lpqueue_ptr;
-                if (lpq && ItLpQueue_isLpIntPending(lpq))
-                        lpevent_count += ItLpQueue_process(lpq, regs);
-        }
+        if (hvlpevent_is_pending())
+                process_hvlpevents(regs);
 #endif
 
 /* collect purr register values often, for accurate calculations */
diff --git a/include/asm-ppc64/iSeries/ItLpQueue.h b/include/asm-ppc64/iSeries/ItLpQueue.h
index 393299e04d7f..69b26ad74135 100644
--- a/include/asm-ppc64/iSeries/ItLpQueue.h
+++ b/include/asm-ppc64/iSeries/ItLpQueue.h
@@ -41,7 +41,7 @@ struct HvLpEvent;
 #define LpEventMaxSize          256
 #define LpEventAlign            64
 
-struct ItLpQueue {
+struct hvlpevent_queue {
 /*
  * The xSlicCurEventPtr is the pointer to the next event stack entry
  * that will become valid.  The OS must peek at this entry to determine
@@ -69,16 +69,13 @@ struct ItLpQueue {
         char    *xSlicEventStackPtr;    // 0x20
         u8      xIndex;                 // 0x28 unique sequential index.
         u8      xSlicRsvd[3];           // 0x29-2b
-        u32     xInUseWord;             // 0x2C
-        u64     xLpIntCount;            // 0x30 Total Lp Int msgs processed
-        u64     xLpIntCountByType[9];   // 0x38-0x7F Event counts by type
+        spinlock_t      lock;
 };
 
-extern struct ItLpQueue xItLpQueue;
+extern struct hvlpevent_queue hvlpevent_queue;
 
-extern struct HvLpEvent *ItLpQueue_getNextLpEvent(struct ItLpQueue *);
-extern int ItLpQueue_isLpIntPending(struct ItLpQueue *);
-extern unsigned ItLpQueue_process(struct ItLpQueue *, struct pt_regs *);
-extern void ItLpQueue_clearValid(struct HvLpEvent *);
+extern int hvlpevent_is_pending(void);
+extern void process_hvlpevents(struct pt_regs *);
+extern void setup_hvlpevent_queue(void);
 
 #endif /* _ITLPQUEUE_H */
diff --git a/include/asm-ppc64/paca.h b/include/asm-ppc64/paca.h
index ae76cae1483f..2f0f36f73d38 100644
--- a/include/asm-ppc64/paca.h
+++ b/include/asm-ppc64/paca.h
@@ -20,7 +20,6 @@
 #include        <asm/types.h>
 #include        <asm/lppaca.h>
 #include        <asm/iSeries/ItLpRegSave.h>
-#include        <asm/iSeries/ItLpQueue.h>
 #include        <asm/mmu.h>
 
 register struct paca_struct *local_paca asm("r13");
@@ -62,7 +61,6 @@ struct paca_struct {
         u16 paca_index;                 /* Logical processor number */
 
         u32 default_decr;               /* Default decrementer value */
-        struct ItLpQueue *lpqueue_ptr;  /* LpQueue handled by this CPU */
         u64 kernel_toc;                 /* Kernel TOC address */
         u64 stab_real;                  /* Absolute address of segment table */
         u64 stab_addr;                  /* Virtual address of segment table */
@@ -91,7 +89,6 @@ struct paca_struct {
         u64 next_jiffy_update_tb;       /* TB value for next jiffy update */
         u64 saved_r1;                   /* r1 save for RTAS calls */
         u64 saved_msr;                  /* MSR saved here by enter_rtas */
-        u32 lpevent_count;              /* lpevents processed  */
         u8 proc_enabled;                /* irq soft-enable flag */
 
         /* not yet used */