[PATCH] ppc64: Formatting cleanups in arch/ppc64/kernel/ItLpQueue.c
[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 <linux/bootmem.h>
15 #include <linux/seq_file.h>
16 #include <linux/proc_fs.h>
17 #include <asm/system.h>
18 #include <asm/paca.h>
19 #include <asm/iSeries/ItLpQueue.h>
20 #include <asm/iSeries/HvLpEvent.h>
21 #include <asm/iSeries/HvCallEvent.h>
22
23 /*
24  * The LpQueue is used to pass event data from the hypervisor to
25  * the partition.  This is where I/O interrupt events are communicated.
26  *
27  * It is written to by the hypervisor so cannot end up in the BSS.
28  */
29 struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
30
31 DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
32
33 static char *event_types[HvLpEvent_Type_NumTypes] = {
34         "Hypervisor",
35         "Machine Facilities",
36         "Session Manager",
37         "SPD I/O",
38         "Virtual Bus",
39         "PCI I/O",
40         "RIO I/O",
41         "Virtual Lan",
42         "Virtual I/O"
43 };
44
45 static __inline__ int set_inUse(void)
46 {
47         int t;
48         u32 * inUseP = &hvlpevent_queue.xInUseWord;
49
50         __asm__ __volatile__("\n\
51 1:      lwarx   %0,0,%2         \n\
52         cmpwi   0,%0,0          \n\
53         li      %0,0            \n\
54         bne-    2f              \n\
55         addi    %0,%0,1         \n\
56         stwcx.  %0,0,%2         \n\
57         bne-    1b              \n\
58 2:      eieio"
59         : "=&r" (t), "=m" (hvlpevent_queue.xInUseWord)
60         : "r" (inUseP), "m" (hvlpevent_queue.xInUseWord)
61         : "cc");
62
63         return t;
64 }
65
66 static __inline__ void clear_inUse(void)
67 {
68         hvlpevent_queue.xInUseWord = 0;
69 }
70
71 /* Array of LpEvent handler functions */
72 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
73 unsigned long ItLpQueueInProcess = 0;
74
75 static struct HvLpEvent * get_next_hvlpevent(void)
76 {
77         struct HvLpEvent * event;
78         event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
79
80         if (event->xFlags.xValid) {
81                 /* rmb() needed only for weakly consistent machines (regatta) */
82                 rmb();
83                 /* Set pointer to next potential event */
84                 hvlpevent_queue.xSlicCurEventPtr += ((event->xSizeMinus1 +
85                                 LpEventAlign) / LpEventAlign) * LpEventAlign;
86
87                 /* Wrap to beginning if no room at end */
88                 if (hvlpevent_queue.xSlicCurEventPtr >
89                                 hvlpevent_queue.xSlicLastValidEventPtr) {
90                         hvlpevent_queue.xSlicCurEventPtr =
91                                 hvlpevent_queue.xSlicEventStackPtr;
92                 }
93         } else {
94                 event = NULL;
95         }
96
97         return event;
98 }
99
100 static unsigned long spread_lpevents = NR_CPUS;
101
102 int hvlpevent_is_pending(void)
103 {
104         struct HvLpEvent *next_event;
105
106         if (smp_processor_id() >= spread_lpevents)
107                 return 0;
108
109         next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
110
111         return next_event->xFlags.xValid |
112                 hvlpevent_queue.xPlicOverflowIntPending;
113 }
114
115 static void hvlpevent_clear_valid(struct HvLpEvent * event)
116 {
117         /* Tell the Hypervisor that we're done with this event.
118          * Also clear bits within this event that might look like valid bits.
119          * ie. on 64-byte boundaries.
120          */
121         struct HvLpEvent *tmp;
122         unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
123                                                  LpEventAlign) - 1;
124
125         switch (extra) {
126         case 3:
127                 tmp = (struct HvLpEvent*)((char*)event + 3 * LpEventAlign);
128                 tmp->xFlags.xValid = 0;
129         case 2:
130                 tmp = (struct HvLpEvent*)((char*)event + 2 * LpEventAlign);
131                 tmp->xFlags.xValid = 0;
132         case 1:
133                 tmp = (struct HvLpEvent*)((char*)event + 1 * LpEventAlign);
134                 tmp->xFlags.xValid = 0;
135         }
136
137         mb();
138
139         event->xFlags.xValid = 0;
140 }
141
142 void process_hvlpevents(struct pt_regs *regs)
143 {
144         struct HvLpEvent * event;
145
146         /* If we have recursed, just return */
147         if ( !set_inUse() )
148                 return;
149
150         if (ItLpQueueInProcess == 0)
151                 ItLpQueueInProcess = 1;
152         else
153                 BUG();
154
155         for (;;) {
156                 event = get_next_hvlpevent();
157                 if (event) {
158                         /* Call appropriate handler here, passing
159                          * a pointer to the LpEvent.  The handler
160                          * must make a copy of the LpEvent if it
161                          * needs it in a bottom half. (perhaps for
162                          * an ACK)
163                          *
164                          *  Handlers are responsible for ACK processing
165                          *
166                          * The Hypervisor guarantees that LpEvents will
167                          * only be delivered with types that we have
168                          * registered for, so no type check is necessary
169                          * here!
170                          */
171                         if (event->xType < HvLpEvent_Type_NumTypes)
172                                 __get_cpu_var(hvlpevent_counts)[event->xType]++;
173                         if (event->xType < HvLpEvent_Type_NumTypes &&
174                                         lpEventHandler[event->xType])
175                                 lpEventHandler[event->xType](event, regs);
176                         else
177                                 printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
178
179                         hvlpevent_clear_valid(event);
180                 } else if (hvlpevent_queue.xPlicOverflowIntPending)
181                         /*
182                          * No more valid events. If overflow events are
183                          * pending process them
184                          */
185                         HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
186                 else
187                         break;
188         }
189
190         ItLpQueueInProcess = 0;
191         mb();
192         clear_inUse();
193 }
194
195 static int set_spread_lpevents(char *str)
196 {
197         unsigned long val = simple_strtoul(str, NULL, 0);
198
199         /*
200          * The parameter is the number of processors to share in processing
201          * lp events.
202          */
203         if (( val > 0) && (val <= NR_CPUS)) {
204                 spread_lpevents = val;
205                 printk("lpevent processing spread over %ld processors\n", val);
206         } else {
207                 printk("invalid spread_lpevents %ld\n", val);
208         }
209
210         return 1;
211 }
212 __setup("spread_lpevents=", set_spread_lpevents);
213
214 void setup_hvlpevent_queue(void)
215 {
216         void *eventStack;
217
218         /*
219          * Allocate a page for the Event Stack. The Hypervisor needs the
220          * absolute real address, so we subtract out the KERNELBASE and add
221          * in the absolute real address of the kernel load area.
222          */
223         eventStack = alloc_bootmem_pages(LpEventStackSize);
224         memset(eventStack, 0, LpEventStackSize);
225
226         /* Invoke the hypervisor to initialize the event stack */
227         HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
228
229         hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
230         hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
231         hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
232                                         (LpEventStackSize - LpEventMaxSize);
233         hvlpevent_queue.xIndex = 0;
234 }
235
236 static int proc_lpevents_show(struct seq_file *m, void *v)
237 {
238         int cpu, i;
239         unsigned long sum;
240         static unsigned long cpu_totals[NR_CPUS];
241
242         /* FIXME: do we care that there's no locking here? */
243         sum = 0;
244         for_each_online_cpu(cpu) {
245                 cpu_totals[cpu] = 0;
246                 for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
247                         cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
248                 }
249                 sum += cpu_totals[cpu];
250         }
251
252         seq_printf(m, "LpEventQueue 0\n");
253         seq_printf(m, "  events processed:\t%lu\n", sum);
254
255         for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
256                 sum = 0;
257                 for_each_online_cpu(cpu) {
258                         sum += per_cpu(hvlpevent_counts, cpu)[i];
259                 }
260
261                 seq_printf(m, "    %-20s %10lu\n", event_types[i], sum);
262         }
263
264         seq_printf(m, "\n  events processed by processor:\n");
265
266         for_each_online_cpu(cpu) {
267                 seq_printf(m, "    CPU%02d  %10lu\n", cpu, cpu_totals[cpu]);
268         }
269
270         return 0;
271 }
272
273 static int proc_lpevents_open(struct inode *inode, struct file *file)
274 {
275         return single_open(file, proc_lpevents_show, NULL);
276 }
277
278 static struct file_operations proc_lpevents_operations = {
279         .open           = proc_lpevents_open,
280         .read           = seq_read,
281         .llseek         = seq_lseek,
282         .release        = single_release,
283 };
284
285 static int __init proc_lpevents_init(void)
286 {
287         struct proc_dir_entry *e;
288
289         e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
290         if (e)
291                 e->proc_fops = &proc_lpevents_operations;
292
293         return 0;
294 }
295 __initcall(proc_lpevents_init);
296