arch/powerpc/platforms/iseries/lpevents.c

   1 /*
   2  * Copyright (C) 2001 Mike Corrigan  IBM Corporation
   3  *
   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.
   8  */
   9
  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/module.h>
  17
  18 #include <asm/system.h>
  19 #include <asm/paca.h>
  20 #include <asm/iseries/it_lp_queue.h>
  21 #include <asm/iseries/hv_lp_event.h>
  22 #include <asm/iseries/hv_call_event.h>
  23 #include "it_lp_naca.h"
  24
  25 /*
  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  */
  31 struct hvlpevent_queue hvlpevent_queue __attribute__((__section__(".data")));
  32
  33 DEFINE_PER_CPU(unsigned long[HvLpEvent_Type_NumTypes], hvlpevent_counts);
  34
  35 static char *event_types[HvLpEvent_Type_NumTypes] = {
  36         "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"
  45 };
  46
  47 /* Array of LpEvent handler functions */
  48 static LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
  49 static unsigned lpEventHandlerPaths[HvLpEvent_Type_NumTypes];
  50
  51 static struct HvLpEvent * get_next_hvlpevent(void)
  52 {
  53         struct HvLpEvent * event;
  54         event = (struct HvLpEvent *)hvlpevent_queue.hq_current_event;
  55
  56         if (hvlpevent_is_valid(event)) {
  57                 /* rmb() needed only for weakly consistent machines (regatta) */
  58                 rmb();
  59                 /* Set pointer to next potential event */
  60                 hvlpevent_queue.hq_current_event += ((event->xSizeMinus1 +
  61                                 IT_LP_EVENT_ALIGN) / IT_LP_EVENT_ALIGN) *
  62                                         IT_LP_EVENT_ALIGN;
  63
  64                 /* Wrap to beginning if no room at end */
  65                 if (hvlpevent_queue.hq_current_event >
  66                                 hvlpevent_queue.hq_last_event) {
  67                         hvlpevent_queue.hq_current_event =
  68                                 hvlpevent_queue.hq_event_stack;
  69                 }
  70         } else {
  71                 event = NULL;
  72         }
  73
  74         return event;
  75 }
  76
  77 static unsigned long spread_lpevents = NR_CPUS;
  78
  79 int hvlpevent_is_pending(void)
  80 {
  81         struct HvLpEvent *next_event;
  82
  83         if (smp_processor_id() >= spread_lpevents)
  84                 return 0;
  85
  86         next_event = (struct HvLpEvent *)hvlpevent_queue.hq_current_event;
  87
  88         return hvlpevent_is_valid(next_event) ||
  89                 hvlpevent_queue.hq_overflow_pending;
  90 }
  91
  92 static void hvlpevent_clear_valid(struct HvLpEvent * event)
  93 {
  94         /* Tell the Hypervisor that we're done with this event.
  95          * Also clear bits within this event that might look like valid bits.
  96          * ie. on 64-byte boundaries.
  97          */
  98         struct HvLpEvent *tmp;
  99         unsigned extra = ((event->xSizeMinus1 + IT_LP_EVENT_ALIGN) /
 100                                 IT_LP_EVENT_ALIGN) - 1;
 101
 102         switch (extra) {
 103         case 3:
 104                 tmp = (struct HvLpEvent*)((char*)event + 3 * IT_LP_EVENT_ALIGN);
 105                 hvlpevent_invalidate(tmp);
 106         case 2:
 107                 tmp = (struct HvLpEvent*)((char*)event + 2 * IT_LP_EVENT_ALIGN);
 108                 hvlpevent_invalidate(tmp);
 109         case 1:
 110                 tmp = (struct HvLpEvent*)((char*)event + 1 * IT_LP_EVENT_ALIGN);
 111                 hvlpevent_invalidate(tmp);
 112         }
 113
 114         mb();
 115
 116         hvlpevent_invalidate(event);
 117 }
 118
 119 void process_hvlpevents(void)
 120 {
 121         struct HvLpEvent * event;
 122
 123         /* If we have recursed, just return */
 124         if (!spin_trylock(&hvlpevent_queue.hq_lock))
 125                 return;
 126
 127         for (;;) {
 128                 event = get_next_hvlpevent();
 129                 if (event) {
 130                         /* Call appropriate handler here, passing
 131                          * a pointer to the LpEvent.  The handler
 132                          * must make a copy of the LpEvent if it
 133                          * needs it in a bottom half. (perhaps for
 134                          * an ACK)
 135                          *
 136                          *  Handlers are responsible for ACK processing
 137                          *
 138                          * The Hypervisor guarantees that LpEvents will
 139                          * only be delivered with types that we have
 140                          * registered for, so no type check is necessary
 141                          * here!
 142                          */
 143                         if (event->xType < HvLpEvent_Type_NumTypes)
 144                                 __get_cpu_var(hvlpevent_counts)[event->xType]++;
 145                         if (event->xType < HvLpEvent_Type_NumTypes &&
 146                                         lpEventHandler[event->xType])
 147                                 lpEventHandler[event->xType](event);
 148                         else
 149                                 printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
 150
 151                         hvlpevent_clear_valid(event);
 152                 } else if (hvlpevent_queue.hq_overflow_pending)
 153                         /*
 154                          * No more valid events. If overflow events are
 155                          * pending process them
 156                          */
 157                         HvCallEvent_getOverflowLpEvents(hvlpevent_queue.hq_index);
 158                 else
 159                         break;
 160         }
 161
 162         spin_unlock(&hvlpevent_queue.hq_lock);
 163 }
 164
 165 static int set_spread_lpevents(char *str)
 166 {
 167         unsigned long val = simple_strtoul(str, NULL, 0);
 168
 169         /*
 170          * The parameter is the number of processors to share in processing
 171          * lp events.
 172          */
 173         if (( val > 0) && (val <= NR_CPUS)) {
 174                 spread_lpevents = val;
 175                 printk("lpevent processing spread over %ld processors\n", val);
 176         } else {
 177                 printk("invalid spread_lpevents %ld\n", val);
 178         }
 179
 180         return 1;
 181 }
 182 __setup("spread_lpevents=", set_spread_lpevents);
 183
 184 void setup_hvlpevent_queue(void)
 185 {
 186         void *eventStack;
 187
 188         spin_lock_init(&hvlpevent_queue.hq_lock);
 189
 190         /* Allocate a page for the Event Stack. */
 191         eventStack = alloc_bootmem_pages(IT_LP_EVENT_STACK_SIZE);
 192         memset(eventStack, 0, IT_LP_EVENT_STACK_SIZE);
 193
 194         /* Invoke the hypervisor to initialize the event stack */
 195         HvCallEvent_setLpEventStack(0, eventStack, IT_LP_EVENT_STACK_SIZE);
 196
 197         hvlpevent_queue.hq_event_stack = eventStack;
 198         hvlpevent_queue.hq_current_event = eventStack;
 199         hvlpevent_queue.hq_last_event = (char *)eventStack +
 200                 (IT_LP_EVENT_STACK_SIZE - IT_LP_EVENT_MAX_SIZE);
 201         hvlpevent_queue.hq_index = 0;
 202 }
 203
 204 /* Register a handler for an LpEvent type */
 205 int HvLpEvent_registerHandler(HvLpEvent_Type eventType, LpEventHandler handler)
 206 {
 207         if (eventType < HvLpEvent_Type_NumTypes) {
 208                 lpEventHandler[eventType] = handler;
 209                 return 0;
 210         }
 211         return 1;
 212 }
 213 EXPORT_SYMBOL(HvLpEvent_registerHandler);
 214
 215 int HvLpEvent_unregisterHandler(HvLpEvent_Type eventType)
 216 {
 217         might_sleep();
 218
 219         if (eventType < HvLpEvent_Type_NumTypes) {
 220                 if (!lpEventHandlerPaths[eventType]) {
 221                         lpEventHandler[eventType] = NULL;
 222                         /*
 223                          * We now sleep until all other CPUs have scheduled.
 224                          * This ensures that the deletion is seen by all
 225                          * other CPUs, and that the deleted handler isn't
 226                          * still running on another CPU when we return.
 227                          */
 228                         synchronize_rcu();
 229                         return 0;
 230                 }
 231         }
 232         return 1;
 233 }
 234 EXPORT_SYMBOL(HvLpEvent_unregisterHandler);
 235
 236 /*
 237  * lpIndex is the partition index of the target partition.
 238  * needed only for VirtualIo, VirtualLan and SessionMgr.  Zero
 239  * indicates to use our partition index - for the other types.
 240  */
 241 int HvLpEvent_openPath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
 242 {
 243         if ((eventType < HvLpEvent_Type_NumTypes) &&
 244                         lpEventHandler[eventType]) {
 245                 if (lpIndex == 0)
 246                         lpIndex = itLpNaca.xLpIndex;
 247                 HvCallEvent_openLpEventPath(lpIndex, eventType);
 248                 ++lpEventHandlerPaths[eventType];
 249                 return 0;
 250         }
 251         return 1;
 252 }
 253
 254 int HvLpEvent_closePath(HvLpEvent_Type eventType, HvLpIndex lpIndex)
 255 {
 256         if ((eventType < HvLpEvent_Type_NumTypes) &&
 257                         lpEventHandler[eventType] &&
 258                         lpEventHandlerPaths[eventType]) {
 259                 if (lpIndex == 0)
 260                         lpIndex = itLpNaca.xLpIndex;
 261                 HvCallEvent_closeLpEventPath(lpIndex, eventType);
 262                 --lpEventHandlerPaths[eventType];
 263                 return 0;
 264         }
 265         return 1;
 266 }
 267
 268 static int proc_lpevents_show(struct seq_file *m, void *v)
 269 {
 270         int cpu, i;
 271         unsigned long sum;
 272         static unsigned long cpu_totals[NR_CPUS];
 273
 274         /* FIXME: do we care that there's no locking here? */
 275         sum = 0;
 276         for_each_online_cpu(cpu) {
 277                 cpu_totals[cpu] = 0;
 278                 for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
 279                         cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
 280                 }
 281                 sum += cpu_totals[cpu];
 282         }
 283
 284         seq_printf(m, "LpEventQueue 0\n");
 285         seq_printf(m, "  events processed:\t%lu\n", sum);
 286
 287         for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
 288                 sum = 0;
 289                 for_each_online_cpu(cpu) {
 290                         sum += per_cpu(hvlpevent_counts, cpu)[i];
 291                 }
 292
 293                 seq_printf(m, "    %-20s %10lu\n", event_types[i], sum);
 294         }
 295
 296         seq_printf(m, "\n  events processed by processor:\n");
 297
 298         for_each_online_cpu(cpu) {
 299                 seq_printf(m, "    CPU%02d  %10lu\n", cpu, cpu_totals[cpu]);
 300         }
 301
 302         return 0;
 303 }
 304
 305 static int proc_lpevents_open(struct inode *inode, struct file *file)
 306 {
 307         return single_open(file, proc_lpevents_show, NULL);
 308 }
 309
 310 static struct file_operations proc_lpevents_operations = {
 311         .open           = proc_lpevents_open,
 312         .read           = seq_read,
 313         .llseek         = seq_lseek,
 314         .release        = single_release,
 315 };
 316
 317 static int __init proc_lpevents_init(void)
 318 {
 319         struct proc_dir_entry *e;
 320
 321         e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
 322         if (e)
 323                 e->proc_fops = &proc_lpevents_operations;
 324
 325         return 0;
 326 }
 327 __initcall(proc_lpevents_init);
 328