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
);