blob: 39ee881c36c3f9507660d21a132ef7e11cad7ed8 [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002 * Copyright (C) 2001 Mike Corrigan IBM Corporation
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +10003 *
Linus Torvalds1da177e2005-04-16 15:20:36 -07004 * 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>
Michael Ellerman512d31d2005-06-30 15:08:27 +100013#include <linux/bootmem.h>
Michael Ellerman7b013282005-06-30 15:08:44 +100014#include <linux/seq_file.h>
15#include <linux/proc_fs.h>
Stephen Rothwellcabb5582005-09-30 16:16:52 +100016#include <linux/module.h>
17
Linus Torvalds1da177e2005-04-16 15:20:36 -070018#include <asm/system.h>
19#include <asm/paca.h>
20#include <asm/iSeries/ItLpQueue.h>
Kelly Dalye45423e2005-11-02 12:08:31 +110021#include <asm/iseries/hv_lp_event.h>
Kelly Dalyc0a8d052005-11-02 11:11:11 +110022#include <asm/iseries/hv_call_event.h>
Stephen Rothwell544cbba2005-09-28 02:18:47 +100023#include <asm/iSeries/ItLpNaca.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070024
Michael Ellermanab354b62005-06-30 15:12:21 +100025/*
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 */
Michael Ellermana6187462005-06-30 15:15:32 +100031struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
Michael Ellermanab354b62005-06-30 15:12:21 +100032
Michael Ellermaned094152005-06-30 15:16:09 +100033DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
34
35static char *event_types[HvLpEvent_Type_NumTypes] = {
Michael Ellerman9b047022005-06-30 15:16:18 +100036 "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"
Michael Ellerman7b013282005-06-30 15:08:44 +100045};
46
Linus Torvalds1da177e2005-04-16 15:20:36 -070047/* Array of LpEvent handler functions */
Stephen Rothwell544cbba2005-09-28 02:18:47 +100048static LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
49static unsigned lpEventHandlerPaths[HvLpEvent_Type_NumTypes];
Linus Torvalds1da177e2005-04-16 15:20:36 -070050
Michael Ellerman937b31b2005-06-30 15:15:42 +100051static struct HvLpEvent * get_next_hvlpevent(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070052{
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100053 struct HvLpEvent * event;
54 event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
55
56 if (event->xFlags.xValid) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070057 /* rmb() needed only for weakly consistent machines (regatta) */
58 rmb();
59 /* Set pointer to next potential event */
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100060 hvlpevent_queue.xSlicCurEventPtr += ((event->xSizeMinus1 +
61 LpEventAlign) / LpEventAlign) * LpEventAlign;
Linus Torvalds1da177e2005-04-16 15:20:36 -070062
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100063 /* 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -070074}
75
Michael Ellerman0c885c12005-06-30 15:07:33 +100076static unsigned long spread_lpevents = NR_CPUS;
Michael Ellermanbea248f2005-06-30 15:07:09 +100077
Michael Ellerman937b31b2005-06-30 15:15:42 +100078int hvlpevent_is_pending(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070079{
Michael Ellermanbea248f2005-06-30 15:07:09 +100080 struct HvLpEvent *next_event;
81
82 if (smp_processor_id() >= spread_lpevents)
83 return 0;
84
Michael Ellermana6187462005-06-30 15:15:32 +100085 next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100086
87 return next_event->xFlags.xValid |
88 hvlpevent_queue.xPlicOverflowIntPending;
Linus Torvalds1da177e2005-04-16 15:20:36 -070089}
90
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +100091static void hvlpevent_clear_valid(struct HvLpEvent * event)
Linus Torvalds1da177e2005-04-16 15:20:36 -070092{
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100093 /* 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.
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +100096 */
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100097 struct HvLpEvent *tmp;
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +100098 unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
99 LpEventAlign) - 1;
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000100
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000101 switch (extra) {
102 case 3:
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000103 tmp = (struct HvLpEvent*)((char*)event + 3 * LpEventAlign);
104 tmp->xFlags.xValid = 0;
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000105 case 2:
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000106 tmp = (struct HvLpEvent*)((char*)event + 2 * LpEventAlign);
107 tmp->xFlags.xValid = 0;
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000108 case 1:
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000109 tmp = (struct HvLpEvent*)((char*)event + 1 * LpEventAlign);
110 tmp->xFlags.xValid = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700111 }
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000112
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 mb();
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 event->xFlags.xValid = 0;
116}
117
Michael Ellerman74889802005-06-30 15:15:53 +1000118void process_hvlpevents(struct pt_regs *regs)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700119{
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000120 struct HvLpEvent * event;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121
122 /* If we have recursed, just return */
Michael Ellerman719d1cd2005-06-30 15:17:02 +1000123 if (!spin_trylock(&hvlpevent_queue.lock))
Michael Ellerman74889802005-06-30 15:15:53 +1000124 return;
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000125
Linus Torvalds1da177e2005-04-16 15:20:36 -0700126 for (;;) {
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000127 event = get_next_hvlpevent();
128 if (event) {
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000129 /* Call appropriate handler here, passing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700130 * 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)
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000134 *
135 * Handlers are responsible for ACK processing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700136 *
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!
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000141 */
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000142 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700147 else
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000148 printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000149
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000150 hvlpevent_clear_valid(event);
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000151 } else if (hvlpevent_queue.xPlicOverflowIntPending)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700152 /*
153 * No more valid events. If overflow events are
154 * pending process them
155 */
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000156 HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700157 else
158 break;
159 }
160
Michael Ellerman719d1cd2005-06-30 15:17:02 +1000161 spin_unlock(&hvlpevent_queue.lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700162}
Michael Ellerman0c885c12005-06-30 15:07:33 +1000163
164static 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
Michael Ellerman512d31d2005-06-30 15:08:27 +1000183void setup_hvlpevent_queue(void)
184{
185 void *eventStack;
186
Stephen Rothwell7c7eb282005-10-24 15:21:52 +1000187 /* Allocate a page for the Event Stack. */
Michael Ellerman512d31d2005-06-30 15:08:27 +1000188 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
Michael Ellermana6187462005-06-30 15:15:32 +1000194 hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
195 hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
196 hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
Michael Ellerman512d31d2005-06-30 15:08:27 +1000197 (LpEventStackSize - LpEventMaxSize);
Michael Ellermana6187462005-06-30 15:15:32 +1000198 hvlpevent_queue.xIndex = 0;
Michael Ellerman512d31d2005-06-30 15:08:27 +1000199}
Michael Ellerman7b013282005-06-30 15:08:44 +1000200
Stephen Rothwell544cbba2005-09-28 02:18:47 +1000201/* Register a handler for an LpEvent type */
202int 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}
210EXPORT_SYMBOL(HvLpEvent_registerHandler);
211
212int 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}
231EXPORT_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 */
238int 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
251int 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
Michael Ellerman7b013282005-06-30 15:08:44 +1000265static int proc_lpevents_show(struct seq_file *m, void *v)
266{
Michael Ellermaned094152005-06-30 15:16:09 +1000267 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 }
Michael Ellerman7b013282005-06-30 15:08:44 +1000280
281 seq_printf(m, "LpEventQueue 0\n");
Michael Ellermaned094152005-06-30 15:16:09 +1000282 seq_printf(m, " events processed:\t%lu\n", sum);
Michael Ellerman7b013282005-06-30 15:08:44 +1000283
Michael Ellermaned094152005-06-30 15:16:09 +1000284 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
Michael Ellerman9b047022005-06-30 15:16:18 +1000290 seq_printf(m, " %-20s %10lu\n", event_types[i], sum);
Michael Ellermaned094152005-06-30 15:16:09 +1000291 }
Michael Ellerman7b013282005-06-30 15:08:44 +1000292
293 seq_printf(m, "\n events processed by processor:\n");
294
Michael Ellermaned094152005-06-30 15:16:09 +1000295 for_each_online_cpu(cpu) {
296 seq_printf(m, " CPU%02d %10lu\n", cpu, cpu_totals[cpu]);
297 }
Michael Ellerman7b013282005-06-30 15:08:44 +1000298
299 return 0;
300}
301
302static int proc_lpevents_open(struct inode *inode, struct file *file)
303{
304 return single_open(file, proc_lpevents_show, NULL);
305}
306
307static 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
314static 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