[PATCH] ppc64: Cleanup whitespace in arch/ppc64/kernel/ItLpQueue.c

Just cleanup white space.

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 83fb36a9bc09ffe250ac76656e3d040ba24613f8..61a9dbdd295a16fb9079cd19061a83866a2f3c4d 100644 (file)
--- 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
@@ -74,21 +74,21 @@ unsigned long ItLpQueueInProcess = 0;
 
 static struct HvLpEvent * get_next_hvlpevent(void)
 {
-       struct HvLpEvent * nextLpEvent = 
+       struct HvLpEvent * nextLpEvent =
                (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
-       if ( nextLpEvent->xFlags.xValid ) {
+       if (nextLpEvent->xFlags.xValid) {
                /* rmb() needed only for weakly consistent machines (regatta) */
                rmb();
                /* Set pointer to next potential event */
                hvlpevent_queue.xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
-                                     LpEventAlign ) /
-                                     LpEventAlign ) *
+                                     LpEventAlign) /
+                                     LpEventAlign) *
                                      LpEventAlign;
                /* Wrap to beginning if no room at end */
                if (hvlpevent_queue.xSlicCurEventPtr > hvlpevent_queue.xSlicLastValidEventPtr)
                        hvlpevent_queue.xSlicCurEventPtr = hvlpevent_queue.xSlicEventStackPtr;
        }
-       else 
+       else
                nextLpEvent = NULL;
 
        return nextLpEvent;
@@ -107,23 +107,23 @@ int hvlpevent_is_pending(void)
        return next_event->xFlags.xValid | hvlpevent_queue.xPlicOverflowIntPending;
 }
 
-static void hvlpevent_clear_valid( 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:
+        */
+       unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
+                                                LpEventAlign) - 1;
+       switch (extra) {
+       case 3:
           ((struct HvLpEvent*)((char*)event+3*LpEventAlign))->xFlags.xValid=0;
-         case 2:
+       case 2:
           ((struct HvLpEvent*)((char*)event+2*LpEventAlign))->xFlags.xValid=0;
-         case 1:
+       case 1:
           ((struct HvLpEvent*)((char*)event+1*LpEventAlign))->xFlags.xValid=0;
-         case 0:
-          ;    
+       case 0:
+               ;
        }
        mb();
        event->xFlags.xValid = 0;
@@ -136,7 +136,7 @@ void process_hvlpevents(struct pt_regs *regs)
        /* If we have recursed, just return */
        if ( !set_inUse() )
                return;
-       
+
        if (ItLpQueueInProcess == 0)
                ItLpQueueInProcess = 1;
        else
@@ -144,35 +144,35 @@ void process_hvlpevents(struct pt_regs *regs)
 
        for (;;) {
                nextLpEvent = get_next_hvlpevent();
-               if ( nextLpEvent ) {
-                       /* Call appropriate handler here, passing 
+               if (nextLpEvent) {
+                       /* 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 )
+                        */
+                       if (nextLpEvent->xType < HvLpEvent_Type_NumTypes)
                                __get_cpu_var(hvlpevent_counts)[nextLpEvent->xType]++;
-                       if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
-                            lpEventHandler[nextLpEvent->xType] ) 
+                       if (nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
+                                       lpEventHandler[nextLpEvent->xType])
                                lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
                        else
                                printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
-                       
-                       hvlpevent_clear_valid( nextLpEvent );
-               } else if ( hvlpevent_queue.xPlicOverflowIntPending )
+
+                       hvlpevent_clear_valid(nextLpEvent);
+               } else if (hvlpevent_queue.xPlicOverflowIntPending)
                        /*
                         * No more valid events. If overflow events are
                         * pending process them
                         */
-                       HvCallEvent_getOverflowLpEvents( hvlpevent_queue.xIndex);
+                       HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
                else
                        break;
        }