3 * Copyright (C) 2001 Mike Corrigan IBM Corporation
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (at your option) any later version.
11 #include <linux/stddef.h>
12 #include <linux/kernel.h>
13 #include <linux/sched.h>
14 #include <linux/bootmem.h>
15 #include <linux/seq_file.h>
16 #include <linux/proc_fs.h>
17 #include <asm/system.h>
19 #include <asm/iSeries/ItLpQueue.h>
20 #include <asm/iSeries/HvLpEvent.h>
21 #include <asm/iSeries/HvCallEvent.h>
24 * The LpQueue is used to pass event data from the hypervisor to
25 * the partition. This is where I/O interrupt events are communicated.
27 * It is written to by the hypervisor so cannot end up in the BSS.
29 struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
31 DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
33 static char *event_types[HvLpEvent_Type_NumTypes] = {
45 static __inline__ int set_inUse(void)
48 u32 * inUseP = &hvlpevent_queue.xInUseWord;
50 __asm__ __volatile__("\n\
59 : "=&r" (t), "=m" (hvlpevent_queue.xInUseWord)
60 : "r" (inUseP), "m" (hvlpevent_queue.xInUseWord)
66 static __inline__ void clear_inUse(void)
68 hvlpevent_queue.xInUseWord = 0;
71 /* Array of LpEvent handler functions */
72 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
73 unsigned long ItLpQueueInProcess = 0;
75 static struct HvLpEvent * get_next_hvlpevent(void)
77 struct HvLpEvent * nextLpEvent =
78 (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
79 if ( nextLpEvent->xFlags.xValid ) {
80 /* rmb() needed only for weakly consistent machines (regatta) */
82 /* Set pointer to next potential event */
83 hvlpevent_queue.xSlicCurEventPtr += ((nextLpEvent->xSizeMinus1 +
87 /* Wrap to beginning if no room at end */
88 if (hvlpevent_queue.xSlicCurEventPtr > hvlpevent_queue.xSlicLastValidEventPtr)
89 hvlpevent_queue.xSlicCurEventPtr = hvlpevent_queue.xSlicEventStackPtr;
97 static unsigned long spread_lpevents = NR_CPUS;
99 int hvlpevent_is_pending(void)
101 struct HvLpEvent *next_event;
103 if (smp_processor_id() >= spread_lpevents)
106 next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
107 return next_event->xFlags.xValid | hvlpevent_queue.xPlicOverflowIntPending;
110 static void hvlpevent_clear_valid( struct HvLpEvent * event )
112 /* Clear the valid bit of the event
113 * Also clear bits within this event that might
114 * look like valid bits (on 64-byte boundaries)
116 unsigned extra = (( event->xSizeMinus1 + LpEventAlign ) /
120 ((struct HvLpEvent*)((char*)event+3*LpEventAlign))->xFlags.xValid=0;
122 ((struct HvLpEvent*)((char*)event+2*LpEventAlign))->xFlags.xValid=0;
124 ((struct HvLpEvent*)((char*)event+1*LpEventAlign))->xFlags.xValid=0;
129 event->xFlags.xValid = 0;
132 void process_hvlpevents(struct pt_regs *regs)
134 struct HvLpEvent * nextLpEvent;
136 /* If we have recursed, just return */
140 if (ItLpQueueInProcess == 0)
141 ItLpQueueInProcess = 1;
146 nextLpEvent = get_next_hvlpevent();
148 /* Call appropriate handler here, passing
149 * a pointer to the LpEvent. The handler
150 * must make a copy of the LpEvent if it
151 * needs it in a bottom half. (perhaps for
154 * Handlers are responsible for ACK processing
156 * The Hypervisor guarantees that LpEvents will
157 * only be delivered with types that we have
158 * registered for, so no type check is necessary
161 if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes )
162 __get_cpu_var(hvlpevent_counts)[nextLpEvent->xType]++;
163 if ( nextLpEvent->xType < HvLpEvent_Type_NumTypes &&
164 lpEventHandler[nextLpEvent->xType] )
165 lpEventHandler[nextLpEvent->xType](nextLpEvent, regs);
167 printk(KERN_INFO "Unexpected Lp Event type=%d\n", nextLpEvent->xType );
169 hvlpevent_clear_valid( nextLpEvent );
170 } else if ( hvlpevent_queue.xPlicOverflowIntPending )
172 * No more valid events. If overflow events are
173 * pending process them
175 HvCallEvent_getOverflowLpEvents( hvlpevent_queue.xIndex);
180 ItLpQueueInProcess = 0;
185 static int set_spread_lpevents(char *str)
187 unsigned long val = simple_strtoul(str, NULL, 0);
190 * The parameter is the number of processors to share in processing
193 if (( val > 0) && (val <= NR_CPUS)) {
194 spread_lpevents = val;
195 printk("lpevent processing spread over %ld processors\n", val);
197 printk("invalid spread_lpevents %ld\n", val);
202 __setup("spread_lpevents=", set_spread_lpevents);
204 void setup_hvlpevent_queue(void)
209 * Allocate a page for the Event Stack. The Hypervisor needs the
210 * absolute real address, so we subtract out the KERNELBASE and add
211 * in the absolute real address of the kernel load area.
213 eventStack = alloc_bootmem_pages(LpEventStackSize);
214 memset(eventStack, 0, LpEventStackSize);
216 /* Invoke the hypervisor to initialize the event stack */
217 HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
219 hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
220 hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
221 hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
222 (LpEventStackSize - LpEventMaxSize);
223 hvlpevent_queue.xIndex = 0;
226 static int proc_lpevents_show(struct seq_file *m, void *v)
230 static unsigned long cpu_totals[NR_CPUS];
232 /* FIXME: do we care that there's no locking here? */
234 for_each_online_cpu(cpu) {
236 for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
237 cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
239 sum += cpu_totals[cpu];
242 seq_printf(m, "LpEventQueue 0\n");
243 seq_printf(m, " events processed:\t%lu\n", sum);
245 for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
247 for_each_online_cpu(cpu) {
248 sum += per_cpu(hvlpevent_counts, cpu)[i];
251 seq_printf(m, " %-20s %10lu\n", event_types[i], sum);
254 seq_printf(m, "\n events processed by processor:\n");
256 for_each_online_cpu(cpu) {
257 seq_printf(m, " CPU%02d %10lu\n", cpu, cpu_totals[cpu]);
263 static int proc_lpevents_open(struct inode *inode, struct file *file)
265 return single_open(file, proc_lpevents_show, NULL);
268 static struct file_operations proc_lpevents_operations = {
269 .open = proc_lpevents_open,
272 .release = single_release,
275 static int __init proc_lpevents_init(void)
277 struct proc_dir_entry *e;
279 e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
281 e->proc_fops = &proc_lpevents_operations;
285 __initcall(proc_lpevents_init);