Automatic merge of /spare/repo/netdev-2.6 branch r8169
[linux-2.6] / arch / ppc64 / kernel / ItLpQueue.c
1 /*
2  * ItLpQueue.c
3  * Copyright (C) 2001 Mike Corrigan  IBM Corporation
4  * 
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  */
10
11 #include <linux/stddef.h>
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <asm/system.h>
15 #include <asm/paca.h>
16 #include <asm/iSeries/ItLpQueue.h>
17 #include <asm/iSeries/HvLpEvent.h>
18 #include <asm/iSeries/HvCallEvent.h>
19 #include <asm/iSeries/LparData.h>
20
21 static __inline__ int set_inUse( struct ItLpQueue * lpQueue )
22 {
23         int t;
24         u32 * inUseP = &(lpQueue->xInUseWord);
25
26         __asm__ __volatile__("\n\
27 1:      lwarx   %0,0,%2         \n\
28         cmpwi   0,%0,0          \n\
29         li      %0,0            \n\
30         bne-    2f              \n\
31         addi    %0,%0,1         \n\
32         stwcx.  %0,0,%2         \n\
33         bne-    1b              \n\
34 2:      eieio"
35         : "=&r" (t), "=m" (lpQueue->xInUseWord)
36         : "r" (inUseP), "m" (lpQueue->xInUseWord)
37         : "cc");
38
39         return t;
40 }
41
42 static __inline__ void clear_inUse( struct ItLpQueue * lpQueue )
43 {
44         lpQueue->xInUseWord = 0;
45 }
46
47 /* Array of LpEvent handler functions */
48 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
49 unsigned long ItLpQueueInProcess = 0;
50
51 struct HvLpEvent * ItLpQueue_getNextLpEvent( struct ItLpQueue * lpQueue )
52 {
53         struct HvLpEvent * nextLpEvent = 
54                 (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
55         if ( nextLpEvent->xFlags.xValid ) {
56                 /* rmb() needed only for weakly consistent machines (regatta) */
57                 rmb();
58                 /* Set pointer to next potential event */
59                 lpQueue->xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
60                                       LpEventAlign ) /
61                                       LpEventAlign ) *
62                                       LpEventAlign;
63                 /* Wrap to beginning if no room at end */
64                 if (lpQueue->xSlicCurEventPtr > lpQueue->xSlicLastValidEventPtr)
65                         lpQueue->xSlicCurEventPtr = lpQueue->xSlicEventStackPtr;
66         }
67         else 
68                 nextLpEvent = NULL;
69
70         return nextLpEvent;
71 }
72
73 int ItLpQueue_isLpIntPending( struct ItLpQueue * lpQueue )
74 {
75         int retval = 0;
76         struct HvLpEvent * nextLpEvent;
77         if ( lpQueue ) {
78                 nextLpEvent = (struct HvLpEvent *)lpQueue->xSlicCurEventPtr;
79                 retval = nextLpEvent->xFlags.xValid | lpQueue->xPlicOverflowIntPending;
80         }
81         return retval;
82 }
83
84 void ItLpQueue_clearValid( struct HvLpEvent * event )
85 {
86         /* Clear the valid bit of the event
87          * Also clear bits within this event that might
88          * look like valid bits (on 64-byte boundaries)
89          */
90         unsigned extra = (( event->xSizeMinus1 + LpEventAlign ) /
91                                                  LpEventAlign ) - 1;
92         switch ( extra ) {
93           case 3:
94            ((struct HvLpEvent*)((char*)event+3*LpEventAlign))->xFlags.xValid=0;
95           case 2:
96            ((struct HvLpEvent*)((char*)event+2*LpEventAlign))->xFlags.xValid=0;
97           case 1:
98            ((struct HvLpEvent*)((char*)event+1*LpEventAlign))->xFlags.xValid=0;
99           case 0:
100            ;    
101         }
102         mb();
103         event->xFlags.xValid = 0;
104 }
105
106 unsigned ItLpQueue_process( struct ItLpQueue * lpQueue, struct pt_regs *regs )
107 {
108         unsigned numIntsProcessed = 0;
109         struct HvLpEvent * nextLpEvent;
110
111         /* If we have recursed, just return */
112         if ( !set_inUse( lpQueue ) )
113                 return 0;
114         
115         if (ItLpQueueInProcess == 0)
116                 ItLpQueueInProcess = 1;
117         else
118                 BUG();
119
120         for (;;) {
121                 nextLpEvent = ItLpQueue_getNextLpEvent( lpQueue );
122                 if ( nextLpEvent ) {
123                         /* Count events to return to caller
124                          * and count processed events in lpQueue
125                          */
126                         ++numIntsProcessed;
127                         lpQueue->xLpIntCount++;         
128                         /* Call appropriate handler here, passing 
129                          * a pointer to the LpEvent.  The handler
130                          * must make a copy of the LpEvent if it
131                          * needs it in a bottom half. (perhaps for
132                          * an ACK)
133                          *      
134                          *  Handlers are responsible for ACK processing 
135                          *
136                          * The Hypervisor guarantees that LpEvents will
137                          * only be delivered with types that we have
138                          * registered for, so no type check is necessary
139                          * here!
140                          */
141                         if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes )
142                                 lpQueue->xLpIntCountByType[nextLpEvent->xType]++;
143                         if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
144                              lpEventHandler[nextLpEvent->xType] ) 
145                                 lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
146                         else
147                                 printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
148                         
149                         ItLpQueue_clearValid( nextLpEvent );
150                 } else if ( lpQueue->xPlicOverflowIntPending )
151                         /*
152                          * No more valid events. If overflow events are
153                          * pending process them
154                          */
155                         HvCallEvent_getOverflowLpEvents( lpQueue->xIndex);
156                 else
157                         break;
158         }
159
160         ItLpQueueInProcess = 0;
161         mb();
162         clear_inUse( lpQueue );
163
164         get_paca()->lpevent_count += numIntsProcessed;
165
166         return numIntsProcessed;
167 }