2
* Copyright (C) 2001 Mike Corrigan IBM Corporation
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.
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/export.h>
18
#include <asm/system.h>
20
#include <asm/firmware.h>
21
#include <asm/iseries/it_lp_queue.h>
22
#include <asm/iseries/hv_lp_event.h>
23
#include <asm/iseries/hv_call_event.h>
24
#include "it_lp_naca.h"
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.
30
* It is written to by the hypervisor so cannot end up in the BSS.
32
struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
34
DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
36
static char *event_types[HvLpEvent_Type_NumTypes] = {
48
/* Array of LpEvent handler functions */
49
static LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
50
static unsigned lpEventHandlerPaths[HvLpEvent_Type_NumTypes];
52
static struct HvLpEvent * get_next_hvlpevent(void)
54
struct HvLpEvent * event;
55
event = (struct HvLpEvent *)hvlpevent_queue.hq_current_event;
57
if (hvlpevent_is_valid(event)) {
58
/* rmb() needed only for weakly consistent machines (regatta) */
60
/* Set pointer to next potential event */
61
hvlpevent_queue.hq_current_event += ((event->xSizeMinus1 +
62
IT_LP_EVENT_ALIGN) / IT_LP_EVENT_ALIGN) *
65
/* Wrap to beginning if no room at end */
66
if (hvlpevent_queue.hq_current_event >
67
hvlpevent_queue.hq_last_event) {
68
hvlpevent_queue.hq_current_event =
69
hvlpevent_queue.hq_event_stack;
78
static unsigned long spread_lpevents = NR_CPUS;
80
int hvlpevent_is_pending(void)
82
struct HvLpEvent *next_event;
84
if (smp_processor_id() >= spread_lpevents)
87
next_event = (struct HvLpEvent *)hvlpevent_queue.hq_current_event;
89
return hvlpevent_is_valid(next_event) ||
90
hvlpevent_queue.hq_overflow_pending;
93
static void hvlpevent_clear_valid(struct HvLpEvent * event)
95
/* 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.
99
struct HvLpEvent *tmp;
100
unsigned extra = ((event->xSizeMinus1 + IT_LP_EVENT_ALIGN) /
101
IT_LP_EVENT_ALIGN) - 1;
105
tmp = (struct HvLpEvent*)((char*)event + 3 * IT_LP_EVENT_ALIGN);
106
hvlpevent_invalidate(tmp);
108
tmp = (struct HvLpEvent*)((char*)event + 2 * IT_LP_EVENT_ALIGN);
109
hvlpevent_invalidate(tmp);
111
tmp = (struct HvLpEvent*)((char*)event + 1 * IT_LP_EVENT_ALIGN);
112
hvlpevent_invalidate(tmp);
117
hvlpevent_invalidate(event);
120
void process_hvlpevents(void)
122
struct HvLpEvent * event;
125
/* If we have recursed, just return */
126
if (!spin_trylock(&hvlpevent_queue.hq_lock))
130
event = get_next_hvlpevent();
132
/* Call appropriate handler here, passing
133
* 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
138
* Handlers are responsible for ACK processing
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
145
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])
149
lpEventHandler[event->xType](event);
151
u8 type = event->xType;
154
* Don't printk in the spinlock as printk
155
* may require ack events form the HV to send
156
* any characters there.
158
hvlpevent_clear_valid(event);
159
spin_unlock(&hvlpevent_queue.hq_lock);
161
"Unexpected Lp Event type=%d\n", type);
165
hvlpevent_clear_valid(event);
166
} else if (hvlpevent_queue.hq_overflow_pending)
168
* No more valid events. If overflow events are
169
* pending process them
171
HvCallEvent_getOverflowLpEvents(hvlpevent_queue.hq_index);
176
spin_unlock(&hvlpevent_queue.hq_lock);
179
static int set_spread_lpevents(char *str)
181
unsigned long val = simple_strtoul(str, NULL, 0);
184
* The parameter is the number of processors to share in processing
187
if (( val > 0) && (val <= NR_CPUS)) {
188
spread_lpevents = val;
189
printk("lpevent processing spread over %ld processors\n", val);
191
printk("invalid spread_lpevents %ld\n", val);
196
__setup("spread_lpevents=", set_spread_lpevents);
198
void __init setup_hvlpevent_queue(void)
202
spin_lock_init(&hvlpevent_queue.hq_lock);
204
/* Allocate a page for the Event Stack. */
205
eventStack = alloc_bootmem_pages(IT_LP_EVENT_STACK_SIZE);
206
memset(eventStack, 0, IT_LP_EVENT_STACK_SIZE);
208
/* Invoke the hypervisor to initialize the event stack */
209
HvCallEvent_setLpEventStack(0, eventStack, IT_LP_EVENT_STACK_SIZE);
211
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;
218
/* Register a handler for an LpEvent type */
219
int HvLpEvent_registerHandler(HvLpEvent_Type eventType, LpEventHandler handler)
221
if (eventType < HvLpEvent_Type_NumTypes) {
222
lpEventHandler[eventType] = handler;
227
EXPORT_SYMBOL(HvLpEvent_registerHandler);
229
int HvLpEvent_unregisterHandler(HvLpEvent_Type eventType)
233
if (eventType < HvLpEvent_Type_NumTypes) {
234
if (!lpEventHandlerPaths[eventType]) {
235
lpEventHandler[eventType] = NULL;
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.
248
EXPORT_SYMBOL(HvLpEvent_unregisterHandler);
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.
255
int HvLpEvent_openPath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
257
if ((eventType < HvLpEvent_Type_NumTypes) &&
258
lpEventHandler[eventType]) {
260
lpIndex = itLpNaca.xLpIndex;
261
HvCallEvent_openLpEventPath(lpIndex, eventType);
262
++lpEventHandlerPaths[eventType];
268
int HvLpEvent_closePath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
270
if ((eventType < HvLpEvent_Type_NumTypes) &&
271
lpEventHandler[eventType] &&
272
lpEventHandlerPaths[eventType]) {
274
lpIndex = itLpNaca.xLpIndex;
275
HvCallEvent_closeLpEventPath(lpIndex, eventType);
276
--lpEventHandlerPaths[eventType];
282
static int proc_lpevents_show(struct seq_file *m, void *v)
286
static unsigned long cpu_totals[NR_CPUS];
288
/* FIXME: do we care that there's no locking here? */
290
for_each_online_cpu(cpu) {
292
for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
293
cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
295
sum += cpu_totals[cpu];
298
seq_printf(m, "LpEventQueue 0\n");
299
seq_printf(m, " events processed:\t%lu\n", sum);
301
for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
303
for_each_online_cpu(cpu) {
304
sum += per_cpu(hvlpevent_counts, cpu)[i];
307
seq_printf(m, " %-20s %10lu\n", event_types[i], sum);
310
seq_printf(m, "\n events processed by processor:\n");
312
for_each_online_cpu(cpu) {
313
seq_printf(m, " CPU%02d %10lu\n", cpu, cpu_totals[cpu]);
319
static int proc_lpevents_open(struct inode *inode, struct file *file)
321
return single_open(file, proc_lpevents_show, NULL);
324
static const struct file_operations proc_lpevents_operations = {
325
.open = proc_lpevents_open,
328
.release = single_release,
331
static int __init proc_lpevents_init(void)
333
if (!firmware_has_feature(FW_FEATURE_ISERIES))
336
proc_create("iSeries/lpevents", S_IFREG|S_IRUGO, NULL,
337
&proc_lpevents_operations);
340
__initcall(proc_lpevents_init);