[PATCH] ppc64: Rename xItLpQueue to hvlpevent_queue

The xItLpQueue is a queue of HvLpEvents that we're given by the Hypervisor.
Rename xItLpQueue to hvlpevent_queue and make the type struct hvlpevent_queue.

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 7ddbfb9750dc4969ae9fecba790d626f4c689463..e55fe1a2725f642aefae34e116231d2447a998f5 100644 (file)
--- a/arch/ppc64/kernel/ItLpQueue.c
+++ b/arch/ppc64/kernel/ItLpQueue.c
@@ -26,7 +26,7 @@
  *
  * It is written to by the hypervisor so cannot end up in the BSS.
  */
-struct ItLpQueue xItLpQueue __attribute__((__section__(".data")));
+struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
 
 static char *event_types[9] = {
        "Hypervisor\t\t",
@@ -43,7 +43,7 @@ static char *event_types[9] = {
 static __inline__ int set_inUse(void)
 {
        int t;
-       u32 * inUseP = &xItLpQueue.xInUseWord;
+       u32 * inUseP = &hvlpevent_queue.xInUseWord;
 
        __asm__ __volatile__("\n\
 1:     lwarx   %0,0,%2         \n\
@@ -54,8 +54,8 @@ static __inline__ int set_inUse(void)
        stwcx.  %0,0,%2         \n\
        bne-    1b              \n\
 2:     eieio"
-       : "=&r" (t), "=m" (xItLpQueue.xInUseWord)
-       : "r" (inUseP), "m" (xItLpQueue.xInUseWord)
+       : "=&r" (t), "=m" (hvlpevent_queue.xInUseWord)
+       : "r" (inUseP), "m" (hvlpevent_queue.xInUseWord)
        : "cc");
 
        return t;
@@ -63,7 +63,7 @@ static __inline__ int set_inUse(void)
 
 static __inline__ void clear_inUse(void)
 {
-       xItLpQueue.xInUseWord = 0;
+       hvlpevent_queue.xInUseWord = 0;
 }
 
 /* Array of LpEvent handler functions */
@@ -73,18 +73,18 @@ unsigned long ItLpQueueInProcess = 0;
 static struct HvLpEvent * ItLpQueue_getNextLpEvent(void)
 {
        struct HvLpEvent * nextLpEvent = 
-               (struct HvLpEvent *)xItLpQueue.xSlicCurEventPtr;
+               (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
        if ( nextLpEvent->xFlags.xValid ) {
                /* rmb() needed only for weakly consistent machines (regatta) */
                rmb();
                /* Set pointer to next potential event */
-               xItLpQueue.xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
+               hvlpevent_queue.xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
                                      LpEventAlign ) /
                                      LpEventAlign ) *
                                      LpEventAlign;
                /* Wrap to beginning if no room at end */
-               if (xItLpQueue.xSlicCurEventPtr > xItLpQueue.xSlicLastValidEventPtr)
-                       xItLpQueue.xSlicCurEventPtr = xItLpQueue.xSlicEventStackPtr;
+               if (hvlpevent_queue.xSlicCurEventPtr > hvlpevent_queue.xSlicLastValidEventPtr)
+                       hvlpevent_queue.xSlicCurEventPtr = hvlpevent_queue.xSlicEventStackPtr;
        }
        else 
                nextLpEvent = NULL;
@@ -101,8 +101,8 @@ int ItLpQueue_isLpIntPending(void)
        if (smp_processor_id() >= spread_lpevents)
                return 0;
 
-       next_event = (struct HvLpEvent *)xItLpQueue.xSlicCurEventPtr;
-       return next_event->xFlags.xValid | xItLpQueue.xPlicOverflowIntPending;
+       next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
+       return next_event->xFlags.xValid | hvlpevent_queue.xPlicOverflowIntPending;
 }
 
 static void ItLpQueue_clearValid( struct HvLpEvent * event )
@@ -145,10 +145,10 @@ unsigned ItLpQueue_process(struct pt_regs *regs)
                nextLpEvent = ItLpQueue_getNextLpEvent();
                if ( nextLpEvent ) {
                        /* Count events to return to caller
-                        * and count processed events in xItLpQueue
+                        * and count processed events in hvlpevent_queue
                         */
                        ++numIntsProcessed;
-                       xItLpQueue.xLpIntCount++;
+                       hvlpevent_queue.xLpIntCount++;
                        /* Call appropriate handler here, passing 
                         * a pointer to the LpEvent.  The handler
                         * must make a copy of the LpEvent if it
@@ -163,7 +163,7 @@ unsigned ItLpQueue_process(struct pt_regs *regs)
                         * here!
                         */
                        if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes )
-                               xItLpQueue.xLpIntCountByType[nextLpEvent->xType]++;
+                               hvlpevent_queue.xLpIntCountByType[nextLpEvent->xType]++;
                        if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
                             lpEventHandler[nextLpEvent->xType] ) 
                                lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
@@ -171,12 +171,12 @@ unsigned ItLpQueue_process(struct pt_regs *regs)
                                printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
                        
                        ItLpQueue_clearValid( nextLpEvent );
-               } else if ( xItLpQueue.xPlicOverflowIntPending )
+               } else if ( hvlpevent_queue.xPlicOverflowIntPending )
                        /*
                         * No more valid events. If overflow events are
                         * pending process them
                         */
-                       HvCallEvent_getOverflowLpEvents( xItLpQueue.xIndex);
+                       HvCallEvent_getOverflowLpEvents( hvlpevent_queue.xIndex);
                else
                        break;
        }
@@ -224,11 +224,11 @@ void setup_hvlpevent_queue(void)
        /* Invoke the hypervisor to initialize the event stack */
        HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
 
-       xItLpQueue.xSlicEventStackPtr = (char *)eventStack;
-       xItLpQueue.xSlicCurEventPtr = (char *)eventStack;
-       xItLpQueue.xSlicLastValidEventPtr = (char *)eventStack +
+       hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
+       hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
+       hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
                                        (LpEventStackSize - LpEventMaxSize);
-       xItLpQueue.xIndex = 0;
+       hvlpevent_queue.xIndex = 0;
 }
 
 static int proc_lpevents_show(struct seq_file *m, void *v)
@@ -237,11 +237,11 @@ static int proc_lpevents_show(struct seq_file *m, void *v)
 
        seq_printf(m, "LpEventQueue 0\n");
        seq_printf(m, "  events processed:\t%lu\n",
-                  (unsigned long)xItLpQueue.xLpIntCount);
+                  (unsigned long)hvlpevent_queue.xLpIntCount);
 
        for (i = 0; i < 9; ++i)
                seq_printf(m, "    %s %10lu\n", event_types[i],
-                          (unsigned long)xItLpQueue.xLpIntCountByType[i]);
+                          (unsigned long)hvlpevent_queue.xLpIntCountByType[i]);
 
        seq_printf(m, "\n  events processed by processor:\n");
 

diff --git a/arch/ppc64/kernel/LparData.c b/arch/ppc64/kernel/LparData.c
index f42ee35f927a9f7adf47c5975c551721260f5010..6ffcf67dd50762bca3bf4383ea7986a4ff7678b0 100644 (file)
--- a/arch/ppc64/kernel/LparData.c
+++ b/arch/ppc64/kernel/LparData.c
@@ -193,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 */
@@ -211,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/include/asm-ppc64/iSeries/ItLpQueue.h b/include/asm-ppc64/iSeries/ItLpQueue.h
index be1cb7f3f884aea69c6c46eb96317529df079be2..bebfb364f556ce0f099f18723e7780abe24cfffd 100644 (file)
--- 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
@@ -74,7 +74,7 @@ struct ItLpQueue {
        u64     xLpIntCountByType[9];   // 0x38-0x7F Event counts by type
 };
 
-extern struct ItLpQueue xItLpQueue;
+extern struct hvlpevent_queue hvlpevent_queue;
 
 extern int ItLpQueue_isLpIntPending(void);
 extern unsigned ItLpQueue_process(struct pt_regs *);