merge filename and modify reference to iseries/hv_lp_config.h
[linux-2.6.git] / arch / powerpc / platforms / iseries / lpevents.c
1 /*
2  * Copyright (C) 2001 Mike Corrigan  IBM Corporation
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License as published by
6  * the Free Software Foundation; either version 2 of the License, or
7  * (at your option) any later version.
8  */
9
10 #include <linux/stddef.h>
11 #include <linux/kernel.h>
12 #include <linux/sched.h>
13 #include <linux/bootmem.h>
14 #include <linux/seq_file.h>
15 #include <linux/proc_fs.h>
16 #include <linux/module.h>
17
18 #include <asm/system.h>
19 #include <asm/paca.h>
20 #include <asm/iSeries/ItLpQueue.h>
21 #include <asm/iSeries/HvLpEvent.h>
22 #include <asm/iseries/hv_call_event.h>
23 #include <asm/iSeries/ItLpNaca.h>
24
25 /*
26  * The LpQueue is used to pass event data from the hypervisor to
27  * the partition.  This is where I/O interrupt events are communicated.
28  *
29  * It is written to by the hypervisor so cannot end up in the BSS.
30  */
31 struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
32
33 DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
34
35 static char *event_types[HvLpEvent_Type_NumTypes] = {
36         "Hypervisor",
37         "Machine Facilities",
38         "Session Manager",
39         "SPD I/O",
40         "Virtual Bus",
41         "PCI I/O",
42         "RIO I/O",
43         "Virtual Lan",
44         "Virtual I/O"
45 };
46
47 /* Array of LpEvent handler functions */
48 static LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
49 static unsigned lpEventHandlerPaths[HvLpEvent_Type_NumTypes];
50
51 static struct HvLpEvent * get_next_hvlpevent(void)
52 {
53         struct HvLpEvent * event;
54         event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
55
56         if (event->xFlags.xValid) {
57                 /* rmb() needed only for weakly consistent machines (regatta) */
58                 rmb();
59                 /* Set pointer to next potential event */
60                 hvlpevent_queue.xSlicCurEventPtr += ((event->xSizeMinus1 +
61                                 LpEventAlign) / LpEventAlign) * LpEventAlign;
62
63                 /* Wrap to beginning if no room at end */
64                 if (hvlpevent_queue.xSlicCurEventPtr >
65                                 hvlpevent_queue.xSlicLastValidEventPtr) {
66                         hvlpevent_queue.xSlicCurEventPtr =
67                                 hvlpevent_queue.xSlicEventStackPtr;
68                 }
69         } else {
70                 event = NULL;
71         }
72
73         return event;
74 }
75
76 static unsigned long spread_lpevents = NR_CPUS;
77
78 int hvlpevent_is_pending(void)
79 {
80         struct HvLpEvent *next_event;
81
82         if (smp_processor_id() >= spread_lpevents)
83                 return 0;
84
85         next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
86
87         return next_event->xFlags.xValid |
88                 hvlpevent_queue.xPlicOverflowIntPending;
89 }
90
91 static void hvlpevent_clear_valid(struct HvLpEvent * event)
92 {
93         /* Tell the Hypervisor that we're done with this event.
94          * Also clear bits within this event that might look like valid bits.
95          * ie. on 64-byte boundaries.
96          */
97         struct HvLpEvent *tmp;
98         unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
99                                                  LpEventAlign) - 1;
100
101         switch (extra) {
102         case 3:
103                 tmp = (struct HvLpEvent*)((char*)event + 3 * LpEventAlign);
104                 tmp->xFlags.xValid = 0;
105         case 2:
106                 tmp = (struct HvLpEvent*)((char*)event + 2 * LpEventAlign);
107                 tmp->xFlags.xValid = 0;
108         case 1:
109                 tmp = (struct HvLpEvent*)((char*)event + 1 * LpEventAlign);
110                 tmp->xFlags.xValid = 0;
111         }
112
113         mb();
114
115         event->xFlags.xValid = 0;
116 }
117
118 void process_hvlpevents(struct pt_regs *regs)
119 {
120         struct HvLpEvent * event;
121
122         /* If we have recursed, just return */
123         if (!spin_trylock(&hvlpevent_queue.lock))
124                 return;
125
126         for (;;) {
127                 event = get_next_hvlpevent();
128                 if (event) {
129                         /* Call appropriate handler here, passing
130                          * a pointer to the LpEvent.  The handler
131                          * must make a copy of the LpEvent if it
132                          * needs it in a bottom half. (perhaps for
133                          * an ACK)
134                          *
135                          *  Handlers are responsible for ACK processing
136                          *
137                          * The Hypervisor guarantees that LpEvents will
138                          * only be delivered with types that we have
139                          * registered for, so no type check is necessary
140                          * here!
141                          */
142                         if (event->xType < HvLpEvent_Type_NumTypes)
143                                 __get_cpu_var(hvlpevent_counts)[event->xType]++;
144                         if (event->xType < HvLpEvent_Type_NumTypes &&
145                                         lpEventHandler[event->xType])
146                                 lpEventHandler[event->xType](event, regs);
147                         else
148                                 printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
149
150                         hvlpevent_clear_valid(event);
151                 } else if (hvlpevent_queue.xPlicOverflowIntPending)
152                         /*
153                          * No more valid events. If overflow events are
154                          * pending process them
155                          */
156                         HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
157                 else
158                         break;
159         }
160
161         spin_unlock(&hvlpevent_queue.lock);
162 }
163
164 static int set_spread_lpevents(char *str)
165 {
166         unsigned long val = simple_strtoul(str, NULL, 0);
167
168         /*
169          * The parameter is the number of processors to share in processing
170          * lp events.
171          */
172         if (( val > 0) && (val <= NR_CPUS)) {
173                 spread_lpevents = val;
174                 printk("lpevent processing spread over %ld processors\n", val);
175         } else {
176                 printk("invalid spread_lpevents %ld\n", val);
177         }
178
179         return 1;
180 }
181 __setup("spread_lpevents=", set_spread_lpevents);
182
183 void setup_hvlpevent_queue(void)
184 {
185         void *eventStack;
186
187         /* Allocate a page for the Event Stack. */
188         eventStack = alloc_bootmem_pages(LpEventStackSize);
189         memset(eventStack, 0, LpEventStackSize);
190
191         /* Invoke the hypervisor to initialize the event stack */
192         HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
193
194         hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
195         hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
196         hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
197                                         (LpEventStackSize - LpEventMaxSize);
198         hvlpevent_queue.xIndex = 0;
199 }
200
201 /* Register a handler for an LpEvent type */
202 int HvLpEvent_registerHandler(HvLpEvent_Type eventType, LpEventHandler handler)
203 {
204         if (eventType < HvLpEvent_Type_NumTypes) {
205                 lpEventHandler[eventType] = handler;
206                 return 0;
207         }
208         return 1;
209 }
210 EXPORT_SYMBOL(HvLpEvent_registerHandler);
211
212 int HvLpEvent_unregisterHandler(HvLpEvent_Type eventType)
213 {
214         might_sleep();
215
216         if (eventType < HvLpEvent_Type_NumTypes) {
217                 if (!lpEventHandlerPaths[eventType]) {
218                         lpEventHandler[eventType] = NULL;
219                         /*
220                          * We now sleep until all other CPUs have scheduled.
221                          * This ensures that the deletion is seen by all
222                          * other CPUs, and that the deleted handler isn't
223                          * still running on another CPU when we return.
224                          */
225                         synchronize_rcu();
226                         return 0;
227                 }
228         }
229         return 1;
230 }
231 EXPORT_SYMBOL(HvLpEvent_unregisterHandler);
232
233 /*
234  * lpIndex is the partition index of the target partition.
235  * needed only for VirtualIo, VirtualLan and SessionMgr.  Zero
236  * indicates to use our partition index - for the other types.
237  */
238 int HvLpEvent_openPath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
239 {
240         if ((eventType < HvLpEvent_Type_NumTypes) &&
241                         lpEventHandler[eventType]) {
242                 if (lpIndex == 0)
243                         lpIndex = itLpNaca.xLpIndex;
244                 HvCallEvent_openLpEventPath(lpIndex, eventType);
245                 ++lpEventHandlerPaths[eventType];
246                 return 0;
247         }
248         return 1;
249 }
250
251 int HvLpEvent_closePath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
252 {
253         if ((eventType < HvLpEvent_Type_NumTypes) &&
254                         lpEventHandler[eventType] &&
255                         lpEventHandlerPaths[eventType]) {
256                 if (lpIndex == 0)
257                         lpIndex = itLpNaca.xLpIndex;
258                 HvCallEvent_closeLpEventPath(lpIndex, eventType);
259                 --lpEventHandlerPaths[eventType];
260                 return 0;
261         }
262         return 1;
263 }
264
265 static int proc_lpevents_show(struct seq_file *m, void *v)
266 {
267         int cpu, i;
268         unsigned long sum;
269         static unsigned long cpu_totals[NR_CPUS];
270
271         /* FIXME: do we care that there's no locking here? */
272         sum = 0;
273         for_each_online_cpu(cpu) {
274                 cpu_totals[cpu] = 0;
275                 for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
276                         cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
277                 }
278                 sum += cpu_totals[cpu];
279         }
280
281         seq_printf(m, "LpEventQueue 0\n");
282         seq_printf(m, "  events processed:\t%lu\n", sum);
283
284         for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
285                 sum = 0;
286                 for_each_online_cpu(cpu) {
287                         sum += per_cpu(hvlpevent_counts, cpu)[i];
288                 }
289
290                 seq_printf(m, "    %-20s %10lu\n", event_types[i], sum);
291         }
292
293         seq_printf(m, "\n  events processed by processor:\n");
294
295         for_each_online_cpu(cpu) {
296                 seq_printf(m, "    CPU%02d  %10lu\n", cpu, cpu_totals[cpu]);
297         }
298
299         return 0;
300 }
301
302 static int proc_lpevents_open(struct inode *inode, struct file *file)
303 {
304         return single_open(file, proc_lpevents_show, NULL);
305 }
306
307 static struct file_operations proc_lpevents_operations = {
308         .open           = proc_lpevents_open,
309         .read           = seq_read,
310         .llseek         = seq_lseek,
311         .release        = single_release,
312 };
313
314 static int __init proc_lpevents_init(void)
315 {
316         struct proc_dir_entry *e;
317
318         e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
319         if (e)
320                 e->proc_fops = &proc_lpevents_operations;
321
322         return 0;
323 }
324 __initcall(proc_lpevents_init);
325