blob: b0f8a857ec02d356d1f4a88f8e21cfbcd8b4f66f [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>
Stephen Rothwell13d2c9b2007-01-04 17:04:21 +110020#include <asm/firmware.h>
Kelly Daly8875ccf2005-11-02 14:13:34 +110021#include <asm/iseries/it_lp_queue.h>
Kelly Dalye45423e2005-11-02 12:08:31 +110022#include <asm/iseries/hv_lp_event.h>
Kelly Dalyc0a8d052005-11-02 11:11:11 +110023#include <asm/iseries/hv_call_event.h>
Michael Ellerman06a36db2006-07-13 17:52:17 +100024#include "it_lp_naca.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -070025
Michael Ellermanab354b62005-06-30 15:12:21 +100026/*
27 * The LpQueue is used to pass event data from the hypervisor to
28 * the partition. This is where I/O interrupt events are communicated.
29 *
30 * It is written to by the hypervisor so cannot end up in the BSS.
31 */
Michael Ellermana6187462005-06-30 15:15:32 +100032struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
Michael Ellermanab354b62005-06-30 15:12:21 +100033
Michael Ellermaned094152005-06-30 15:16:09 +100034DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
35
36static char *event_types[HvLpEvent_Type_NumTypes] = {
Michael Ellerman9b047022005-06-30 15:16:18 +100037 "Hypervisor",
38 "Machine Facilities",
39 "Session Manager",
40 "SPD I/O",
41 "Virtual Bus",
42 "PCI I/O",
43 "RIO I/O",
44 "Virtual Lan",
45 "Virtual I/O"
Michael Ellerman7b013282005-06-30 15:08:44 +100046};
47
Linus Torvalds1da177e2005-04-16 15:20:36 -070048/* Array of LpEvent handler functions */
Stephen Rothwell544cbba2005-09-28 02:18:47 +100049static LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
50static unsigned lpEventHandlerPaths[HvLpEvent_Type_NumTypes];
Linus Torvalds1da177e2005-04-16 15:20:36 -070051
Michael Ellerman937b31b2005-06-30 15:15:42 +100052static struct HvLpEvent * get_next_hvlpevent(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070053{
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100054 struct HvLpEvent * event;
Stephen Rothwell612f02d2006-06-28 11:49:10 +100055 event = (struct HvLpEvent *)hvlpevent_queue.hq_current_event;
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100056
Stephen Rothwell677f8c02006-01-12 13:47:43 +110057 if (hvlpevent_is_valid(event)) {
Linus Torvalds1da177e2005-04-16 15:20:36 -070058 /* rmb() needed only for weakly consistent machines (regatta) */
59 rmb();
60 /* Set pointer to next potential event */
Stephen Rothwell612f02d2006-06-28 11:49:10 +100061 hvlpevent_queue.hq_current_event += ((event->xSizeMinus1 +
62 IT_LP_EVENT_ALIGN) / IT_LP_EVENT_ALIGN) *
63 IT_LP_EVENT_ALIGN;
Linus Torvalds1da177e2005-04-16 15:20:36 -070064
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100065 /* Wrap to beginning if no room at end */
Stephen Rothwell612f02d2006-06-28 11:49:10 +100066 if (hvlpevent_queue.hq_current_event >
67 hvlpevent_queue.hq_last_event) {
68 hvlpevent_queue.hq_current_event =
69 hvlpevent_queue.hq_event_stack;
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100070 }
71 } else {
72 event = NULL;
73 }
74
75 return event;
Linus Torvalds1da177e2005-04-16 15:20:36 -070076}
77
Michael Ellerman0c885c12005-06-30 15:07:33 +100078static unsigned long spread_lpevents = NR_CPUS;
Michael Ellermanbea248f2005-06-30 15:07:09 +100079
Michael Ellerman937b31b2005-06-30 15:15:42 +100080int hvlpevent_is_pending(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -070081{
Michael Ellermanbea248f2005-06-30 15:07:09 +100082 struct HvLpEvent *next_event;
83
84 if (smp_processor_id() >= spread_lpevents)
85 return 0;
86
Stephen Rothwell612f02d2006-06-28 11:49:10 +100087 next_event = (struct HvLpEvent *)hvlpevent_queue.hq_current_event;
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100088
Stephen Rothwell677f8c02006-01-12 13:47:43 +110089 return hvlpevent_is_valid(next_event) ||
Stephen Rothwell612f02d2006-06-28 11:49:10 +100090 hvlpevent_queue.hq_overflow_pending;
Linus Torvalds1da177e2005-04-16 15:20:36 -070091}
92
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +100093static void hvlpevent_clear_valid(struct HvLpEvent * event)
Linus Torvalds1da177e2005-04-16 15:20:36 -070094{
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100095 /* Tell the Hypervisor that we're done with this event.
96 * Also clear bits within this event that might look like valid bits.
97 * ie. on 64-byte boundaries.
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +100098 */
Michael Ellermanffe1b7e2005-06-30 15:16:48 +100099 struct HvLpEvent *tmp;
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000100 unsigned extra = ((event->xSizeMinus1 + IT_LP_EVENT_ALIGN) /
101 IT_LP_EVENT_ALIGN) - 1;
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000102
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000103 switch (extra) {
104 case 3:
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000105 tmp = (struct HvLpEvent*)((char*)event + 3 * IT_LP_EVENT_ALIGN);
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100106 hvlpevent_invalidate(tmp);
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000107 case 2:
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000108 tmp = (struct HvLpEvent*)((char*)event + 2 * IT_LP_EVENT_ALIGN);
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100109 hvlpevent_invalidate(tmp);
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000110 case 1:
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000111 tmp = (struct HvLpEvent*)((char*)event + 1 * IT_LP_EVENT_ALIGN);
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100112 hvlpevent_invalidate(tmp);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113 }
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000114
Linus Torvalds1da177e2005-04-16 15:20:36 -0700115 mb();
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000116
Stephen Rothwell677f8c02006-01-12 13:47:43 +1100117 hvlpevent_invalidate(event);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700118}
119
Olaf Hering35a84c22006-10-07 22:08:26 +1000120void process_hvlpevents(void)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700121{
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000122 struct HvLpEvent * event;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700123
Stephen Rothwell88f01782007-12-12 14:58:12 +1100124 restart:
Linus Torvalds1da177e2005-04-16 15:20:36 -0700125 /* If we have recursed, just return */
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000126 if (!spin_trylock(&hvlpevent_queue.hq_lock))
Michael Ellerman74889802005-06-30 15:15:53 +1000127 return;
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000128
Linus Torvalds1da177e2005-04-16 15:20:36 -0700129 for (;;) {
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000130 event = get_next_hvlpevent();
131 if (event) {
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000132 /* Call appropriate handler here, passing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700133 * a pointer to the LpEvent. The handler
134 * must make a copy of the LpEvent if it
135 * needs it in a bottom half. (perhaps for
136 * an ACK)
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000137 *
138 * Handlers are responsible for ACK processing
Linus Torvalds1da177e2005-04-16 15:20:36 -0700139 *
140 * The Hypervisor guarantees that LpEvents will
141 * only be delivered with types that we have
142 * registered for, so no type check is necessary
143 * here!
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000144 */
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000145 if (event->xType < HvLpEvent_Type_NumTypes)
146 __get_cpu_var(hvlpevent_counts)[event->xType]++;
147 if (event->xType < HvLpEvent_Type_NumTypes &&
148 lpEventHandler[event->xType])
Olaf Hering35a84c22006-10-07 22:08:26 +1000149 lpEventHandler[event->xType](event);
Stephen Rothwell88f01782007-12-12 14:58:12 +1100150 else {
151 u8 type = event->xType;
152
153 /*
154 * Don't printk in the spinlock as printk
155 * may require ack events form the HV to send
156 * any characters there.
157 */
158 hvlpevent_clear_valid(event);
159 spin_unlock(&hvlpevent_queue.hq_lock);
160 printk(KERN_INFO
161 "Unexpected Lp Event type=%d\n", type);
162 goto restart;
163 }
Michael Ellerman38fcdcfe2005-06-30 15:16:28 +1000164
Michael Ellermanffe1b7e2005-06-30 15:16:48 +1000165 hvlpevent_clear_valid(event);
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000166 } else if (hvlpevent_queue.hq_overflow_pending)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700167 /*
168 * No more valid events. If overflow events are
169 * pending process them
170 */
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000171 HvCallEvent_getOverflowLpEvents(hvlpevent_queue.hq_index);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700172 else
173 break;
174 }
175
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000176 spin_unlock(&hvlpevent_queue.hq_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700177}
Michael Ellerman0c885c12005-06-30 15:07:33 +1000178
179static int set_spread_lpevents(char *str)
180{
181 unsigned long val = simple_strtoul(str, NULL, 0);
182
183 /*
184 * The parameter is the number of processors to share in processing
185 * lp events.
186 */
187 if (( val > 0) && (val <= NR_CPUS)) {
188 spread_lpevents = val;
189 printk("lpevent processing spread over %ld processors\n", val);
190 } else {
191 printk("invalid spread_lpevents %ld\n", val);
192 }
193
194 return 1;
195}
196__setup("spread_lpevents=", set_spread_lpevents);
197
Stephen Rothwell16782a62007-07-25 09:29:19 +1000198void __init setup_hvlpevent_queue(void)
Michael Ellerman512d31d2005-06-30 15:08:27 +1000199{
200 void *eventStack;
201
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000202 spin_lock_init(&hvlpevent_queue.hq_lock);
Michael Ellermanbd6ef572006-02-20 19:07:31 +1100203
Stephen Rothwell7c7eb282005-10-24 15:21:52 +1000204 /* Allocate a page for the Event Stack. */
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000205 eventStack = alloc_bootmem_pages(IT_LP_EVENT_STACK_SIZE);
206 memset(eventStack, 0, IT_LP_EVENT_STACK_SIZE);
Michael Ellerman512d31d2005-06-30 15:08:27 +1000207
208 /* Invoke the hypervisor to initialize the event stack */
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000209 HvCallEvent_setLpEventStack(0, eventStack, IT_LP_EVENT_STACK_SIZE);
Michael Ellerman512d31d2005-06-30 15:08:27 +1000210
Stephen Rothwell612f02d2006-06-28 11:49:10 +1000211 hvlpevent_queue.hq_event_stack = eventStack;
212 hvlpevent_queue.hq_current_event = eventStack;
213 hvlpevent_queue.hq_last_event = (char *)eventStack +
214 (IT_LP_EVENT_STACK_SIZE - IT_LP_EVENT_MAX_SIZE);
215 hvlpevent_queue.hq_index = 0;
Michael Ellerman512d31d2005-06-30 15:08:27 +1000216}
Michael Ellerman7b013282005-06-30 15:08:44 +1000217
Stephen Rothwell544cbba2005-09-28 02:18:47 +1000218/* Register a handler for an LpEvent type */
219int HvLpEvent_registerHandler(HvLpEvent_Type eventType, LpEventHandler handler)
220{
221 if (eventType < HvLpEvent_Type_NumTypes) {
222 lpEventHandler[eventType] = handler;
223 return 0;
224 }
225 return 1;
226}
227EXPORT_SYMBOL(HvLpEvent_registerHandler);
228
229int HvLpEvent_unregisterHandler(HvLpEvent_Type eventType)
230{
231 might_sleep();
232
233 if (eventType < HvLpEvent_Type_NumTypes) {
234 if (!lpEventHandlerPaths[eventType]) {
235 lpEventHandler[eventType] = NULL;
236 /*
237 * We now sleep until all other CPUs have scheduled.
238 * This ensures that the deletion is seen by all
239 * other CPUs, and that the deleted handler isn't
240 * still running on another CPU when we return.
241 */
Stephen Rothwell731e74c2007-12-12 15:00:56 +1100242 synchronize_sched();
Stephen Rothwell544cbba2005-09-28 02:18:47 +1000243 return 0;
244 }
245 }
246 return 1;
247}
248EXPORT_SYMBOL(HvLpEvent_unregisterHandler);
249
250/*
251 * lpIndex is the partition index of the target partition.
252 * needed only for VirtualIo, VirtualLan and SessionMgr. Zero
253 * indicates to use our partition index - for the other types.
254 */
255int HvLpEvent_openPath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
256{
257 if ((eventType < HvLpEvent_Type_NumTypes) &&
258 lpEventHandler[eventType]) {
259 if (lpIndex == 0)
260 lpIndex = itLpNaca.xLpIndex;
261 HvCallEvent_openLpEventPath(lpIndex, eventType);
262 ++lpEventHandlerPaths[eventType];
263 return 0;
264 }
265 return 1;
266}
267
268int HvLpEvent_closePath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
269{
270 if ((eventType < HvLpEvent_Type_NumTypes) &&
271 lpEventHandler[eventType] &&
272 lpEventHandlerPaths[eventType]) {
273 if (lpIndex == 0)
274 lpIndex = itLpNaca.xLpIndex;
275 HvCallEvent_closeLpEventPath(lpIndex, eventType);
276 --lpEventHandlerPaths[eventType];
277 return 0;
278 }
279 return 1;
280}
281
Michael Ellerman7b013282005-06-30 15:08:44 +1000282static int proc_lpevents_show(struct seq_file *m, void *v)
283{
Michael Ellermaned094152005-06-30 15:16:09 +1000284 int cpu, i;
285 unsigned long sum;
286 static unsigned long cpu_totals[NR_CPUS];
287
288 /* FIXME: do we care that there's no locking here? */
289 sum = 0;
290 for_each_online_cpu(cpu) {
291 cpu_totals[cpu] = 0;
292 for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
293 cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
294 }
295 sum += cpu_totals[cpu];
296 }
Michael Ellerman7b013282005-06-30 15:08:44 +1000297
298 seq_printf(m, "LpEventQueue 0\n");
Michael Ellermaned094152005-06-30 15:16:09 +1000299 seq_printf(m, " events processed:\t%lu\n", sum);
Michael Ellerman7b013282005-06-30 15:08:44 +1000300
Michael Ellermaned094152005-06-30 15:16:09 +1000301 for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
302 sum = 0;
303 for_each_online_cpu(cpu) {
304 sum += per_cpu(hvlpevent_counts, cpu)[i];
305 }
306
Michael Ellerman9b047022005-06-30 15:16:18 +1000307 seq_printf(m, " %-20s %10lu\n", event_types[i], sum);
Michael Ellermaned094152005-06-30 15:16:09 +1000308 }
Michael Ellerman7b013282005-06-30 15:08:44 +1000309
310 seq_printf(m, "\n events processed by processor:\n");
311
Michael Ellermaned094152005-06-30 15:16:09 +1000312 for_each_online_cpu(cpu) {
313 seq_printf(m, " CPU%02d %10lu\n", cpu, cpu_totals[cpu]);
314 }
Michael Ellerman7b013282005-06-30 15:08:44 +1000315
316 return 0;
317}
318
319static int proc_lpevents_open(struct inode *inode, struct file *file)
320{
321 return single_open(file, proc_lpevents_show, NULL);
322}
323
Arjan van de Ven5dfe4c92007-02-12 00:55:31 -0800324static const struct file_operations proc_lpevents_operations = {
Michael Ellerman7b013282005-06-30 15:08:44 +1000325 .open = proc_lpevents_open,
326 .read = seq_read,
327 .llseek = seq_lseek,
328 .release = single_release,
329};
330
331static int __init proc_lpevents_init(void)
332{
Stephen Rothwell13d2c9b2007-01-04 17:04:21 +1100333 if (!firmware_has_feature(FW_FEATURE_ISERIES))
334 return 0;
335
Denis V. Lunev66747132008-04-29 01:02:26 -0700336 proc_create("iSeries/lpevents", S_IFREG|S_IRUGO, NULL,
337 &proc_lpevents_operations);
Michael Ellerman7b013282005-06-30 15:08:44 +1000338 return 0;
339}
340__initcall(proc_lpevents_init);
341