diff --git a/arch/ppc64/kernel/ItLpQueue.c b/arch/ppc64/kernel/ItLpQueue.c
index 61be23ed5004..35f6deac0b99 100644
--- a/arch/ppc64/kernel/ItLpQueue.c
+++ b/arch/ppc64/kernel/ItLpQueue.c
@@ -17,10 +17,10 @@
 #include <asm/iSeries/HvLpEvent.h>
 #include <asm/iSeries/HvCallEvent.h>
 
-static __inline__ int set_inUse( struct ItLpQueue * lpQueue )
+static __inline__ int set_inUse(void)
 {
 	int t;
-	u32 * inUseP = &(lpQueue->xInUseWord);
+	u32 * inUseP = &xItLpQueue.xInUseWord;
 
 	__asm__ __volatile__("\n\
 1:	lwarx	%0,0,%2		\n\
@@ -31,37 +31,37 @@ static __inline__ int set_inUse( struct ItLpQueue * lpQueue )
 	stwcx.	%0,0,%2		\n\
 	bne-	1b		\n\
 2:	eieio"
-	: "=&r" (t), "=m" (lpQueue->xInUseWord)
-	: "r" (inUseP), "m" (lpQueue->xInUseWord)
+	: "=&r" (t), "=m" (xItLpQueue.xInUseWord)
+	: "r" (inUseP), "m" (xItLpQueue.xInUseWord)
 	: "cc");
 
 	return t;
 }
 
-static __inline__ void clear_inUse( struct ItLpQueue * lpQueue )
+static __inline__ void clear_inUse(void)
 {
-	lpQueue->xInUseWord = 0;
+	xItLpQueue.xInUseWord = 0;
 }
 
 /* Array of LpEvent handler functions */
 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
 unsigned long ItLpQueueInProcess = 0;
 
-struct HvLpEvent * ItLpQueue_getNextLpEvent( struct ItLpQueue * lpQueue )
+struct HvLpEvent * ItLpQueue_getNextLpEvent(void)
 {
 	struct HvLpEvent * nextLpEvent = 
-		(struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
+		(struct HvLpEvent *)xItLpQueue.xSlicCurEventPtr;
 	if ( nextLpEvent->xFlags.xValid ) {
 		/* rmb() needed only for weakly consistent machines (regatta) */
 		rmb();
 		/* Set pointer to next potential event */
-		lpQueue->xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
+		xItLpQueue.xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
 				      LpEventAlign ) /
 				      LpEventAlign ) *
 				      LpEventAlign;
 		/* Wrap to beginning if no room at end */
-		if (lpQueue->xSlicCurEventPtr > lpQueue->xSlicLastValidEventPtr)
-			lpQueue->xSlicCurEventPtr = lpQueue->xSlicEventStackPtr;
+		if (xItLpQueue.xSlicCurEventPtr > xItLpQueue.xSlicLastValidEventPtr)
+			xItLpQueue.xSlicCurEventPtr = xItLpQueue.xSlicEventStackPtr;
 	}
 	else 
 		nextLpEvent = NULL;
@@ -71,15 +71,15 @@ struct HvLpEvent * ItLpQueue_getNextLpEvent( struct ItLpQueue * lpQueue )
 
 static unsigned long spread_lpevents = NR_CPUS;
 
-int ItLpQueue_isLpIntPending( struct ItLpQueue * lpQueue )
+int ItLpQueue_isLpIntPending(void)
 {
 	struct HvLpEvent *next_event;
 
 	if (smp_processor_id() >= spread_lpevents)
 		return 0;
 
-	next_event = (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
-	return next_event->xFlags.xValid | lpQueue->xPlicOverflowIntPending;
+	next_event = (struct HvLpEvent *)xItLpQueue.xSlicCurEventPtr;
+	return next_event->xFlags.xValid | xItLpQueue.xPlicOverflowIntPending;
 }
 
 void ItLpQueue_clearValid( struct HvLpEvent * event )
@@ -104,13 +104,13 @@ void ItLpQueue_clearValid( struct HvLpEvent * event )
 	event->xFlags.xValid = 0;
 }
 
-unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
+unsigned ItLpQueue_process(struct pt_regs *regs)
 {
 	unsigned numIntsProcessed = 0;
 	struct HvLpEvent * nextLpEvent;
 
 	/* If we have recursed, just return */
-	if ( !set_inUse( lpQueue ) )
+	if ( !set_inUse() )
 		return 0;
 	
 	if (ItLpQueueInProcess == 0)
@@ -119,13 +119,13 @@ unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
 		BUG();
 
 	for (;;) {
-		nextLpEvent = ItLpQueue_getNextLpEvent( lpQueue );
+		nextLpEvent = ItLpQueue_getNextLpEvent();
 		if ( nextLpEvent ) {
 			/* Count events to return to caller
-			 * and count processed events in lpQueue
+			 * and count processed events in xItLpQueue
  			 */
 			++numIntsProcessed;
-			lpQueue->xLpIntCount++;		
+			xItLpQueue.xLpIntCount++;
 			/* Call appropriate handler here, passing 
 			 * a pointer to the LpEvent.  The handler
 			 * must make a copy of the LpEvent if it
@@ -140,7 +140,7 @@ unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
 			 * here!
   			 */
 			if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes )
-				lpQueue->xLpIntCountByType[nextLpEvent->xType]++;
+				xItLpQueue.xLpIntCountByType[nextLpEvent->xType]++;
 			if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
 			     lpEventHandler[nextLpEvent->xType] ) 
 				lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
@@ -148,19 +148,19 @@ unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
 				printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
 			
 			ItLpQueue_clearValid( nextLpEvent );
-		} else if ( lpQueue->xPlicOverflowIntPending )
+		} else if ( xItLpQueue.xPlicOverflowIntPending )
 			/*
 			 * No more valid events. If overflow events are
 			 * pending process them
 			 */
-			HvCallEvent_getOverflowLpEvents( lpQueue->xIndex);
+			HvCallEvent_getOverflowLpEvents( xItLpQueue.xIndex);
 		else
 			break;
 	}
 
 	ItLpQueueInProcess = 0;
 	mb();
-	clear_inUse( lpQueue );
+	clear_inUse();
 
 	get_paca()->lpevent_count += numIntsProcessed;
 
diff --git a/arch/ppc64/kernel/idle.c b/arch/ppc64/kernel/idle.c
index 63977a7a3094..a7ebd0238d39 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(&xItLpQueue))
+			if (ItLpQueue_isLpIntPending())
 				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(&xItLpQueue))
+					if (ItLpQueue_isLpIntPending())
 						process_iSeries_events();
 					HMT_low();
 				}
diff --git a/arch/ppc64/kernel/irq.c b/arch/ppc64/kernel/irq.c
index b1e6acb02a9a..46a7151ad6d5 100644
--- a/arch/ppc64/kernel/irq.c
+++ b/arch/ppc64/kernel/irq.c
@@ -294,8 +294,8 @@ void do_IRQ(struct pt_regs *regs)
 		iSeries_smp_message_recv(regs);
 	}
 #endif /* CONFIG_SMP */
-	if (ItLpQueue_isLpIntPending(&xItLpQueue))
-		lpevent_count += ItLpQueue_process(&xItLpQueue, regs);
+	if (ItLpQueue_isLpIntPending())
+		lpevent_count += ItLpQueue_process(regs);
 
 	irq_exit();
 
diff --git a/arch/ppc64/kernel/mf.c b/arch/ppc64/kernel/mf.c
index d6a297a4feb3..ef9206998028 100644
--- a/arch/ppc64/kernel/mf.c
+++ b/arch/ppc64/kernel/mf.c
@@ -802,8 +802,8 @@ int mf_get_boot_rtc(struct rtc_time *tm)
 	/* We need to poll here as we are not yet taking interrupts */
 	while (rtc_data.busy) {
 		extern unsigned long lpevent_count;
-		if (ItLpQueue_isLpIntPending(&xItLpQueue))
-			lpevent_count += ItLpQueue_process(&xItLpQueue, NULL);
+		if (ItLpQueue_isLpIntPending())
+			lpevent_count += ItLpQueue_process(NULL);
 	}
 	return rtc_set_tm(rtc_data.rc, rtc_data.ce_msg.ce_msg, tm);
 }
diff --git a/arch/ppc64/kernel/time.c b/arch/ppc64/kernel/time.c
index cdc43afb563e..c133f9c28c57 100644
--- a/arch/ppc64/kernel/time.c
+++ b/arch/ppc64/kernel/time.c
@@ -367,8 +367,8 @@ int timer_interrupt(struct pt_regs * regs)
 	set_dec(next_dec);
 
 #ifdef CONFIG_PPC_ISERIES
-	if (ItLpQueue_isLpIntPending(&xItLpQueue))
-		lpevent_count += ItLpQueue_process(&xItLpQueue, regs);
+	if (ItLpQueue_isLpIntPending())
+		lpevent_count += ItLpQueue_process(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..832497e3259b 100644
--- a/include/asm-ppc64/iSeries/ItLpQueue.h
+++ b/include/asm-ppc64/iSeries/ItLpQueue.h
@@ -76,9 +76,9 @@ struct ItLpQueue {
 
 extern struct ItLpQueue xItLpQueue;
 
-extern struct HvLpEvent *ItLpQueue_getNextLpEvent(struct ItLpQueue *);
-extern int ItLpQueue_isLpIntPending(struct ItLpQueue *);
-extern unsigned ItLpQueue_process(struct ItLpQueue *, struct pt_regs *);
+extern struct HvLpEvent *ItLpQueue_getNextLpEvent(void);
+extern int ItLpQueue_isLpIntPending(void);
+extern unsigned ItLpQueue_process(struct pt_regs *);
 extern void ItLpQueue_clearValid(struct HvLpEvent *);
 
 #endif /* _ITLPQUEUE_H */