[PATCH] ppc64: Don't pass the pointers to xItLpQueue around

Because there's only one ItLpQueue and we know where it is, ie. xItLpQueue,
there's no point passing pointers to it it around all over the place.

Signed-off-by: Michael Ellerman <michael@ellerman.id.au>
Acked-by: Stephen Rothwell <sfr@canb.auug.org.au>
Signed-off-by: Paul Mackerras <paulus@samba.org>

diff --git a/arch/ppc64/kernel/ItLpQueue.c b/arch/ppc64/kernel/ItLpQueue.c
index 61be23ed50040c86853ca43ca075e2576088b4e0..35f6deac0b99fc6e67fa286f57ca5189b9e05f0f 100644 (file)
--- 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 63977a7a3094b807f70643452446682b9e47e2c2..a7ebd0238d39a989401cb68088f262e6796466e6 100644 (file)
--- 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 b1e6acb02a9a7631c5a977eee302e6209573a9f5..46a7151ad6d5d31860553fceb1212bda955b1b00 100644 (file)
--- 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 d6a297a4feb3b9cfe7804a3a9030ff3fba574141..ef9206998028cd98d151e2cfcc57bcbb19dcff19 100644 (file)
--- 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 cdc43afb563e4b644b58d640bd44bcf0158f57b1..c133f9c28c57aba2c953a76754222e96185bfac3 100644 (file)
--- 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 393299e04d7fcf713915815d74fcba66888f09f0..832497e3259bf7b1b8b83845ec490859b64461d1 100644 (file)
--- 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 */