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