arch/ppc64/kernel/ItLpQueue.c

   1 /*
   2  * ItLpQueue.c
   3  * Copyright (C) 2001 Mike Corrigan  IBM Corporation
   4  *
   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.
   9  */
  10
  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>
  18 #include <asm/paca.h>
  19 #include <asm/iSeries/ItLpQueue.h>
  20 #include <asm/iSeries/HvLpEvent.h>
  21 #include <asm/iSeries/HvCallEvent.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 static __inline__ int set_inUse(void)
  46 {
  47         int t;
  48         u32 * inUseP = &hvlpevent_queue.xInUseWord;
  49
  50         __asm__ __volatile__("\n\
  51 1:      lwarx   %0,0,%2         \n\
  52         cmpwi   0,%0,0          \n\
  53         li      %0,0            \n\
  54         bne-    2f              \n\
  55         addi    %0,%0,1         \n\
  56         stwcx.  %0,0,%2         \n\
  57         bne-    1b              \n\
  58 2:      eieio"
  59         : "=&r" (t), "=m" (hvlpevent_queue.xInUseWord)
  60         : "r" (inUseP), "m" (hvlpevent_queue.xInUseWord)
  61         : "cc");
  62
  63         return t;
  64 }
  65
  66 static __inline__ void clear_inUse(void)
  67 {
  68         hvlpevent_queue.xInUseWord = 0;
  69 }
  70
  71 /* Array of LpEvent handler functions */
  72 extern LpEventHandler lpEventHandler[HvLpEvent_Type_NumTypes];
  73 unsigned long ItLpQueueInProcess = 0;
  74
  75 static struct HvLpEvent * get_next_hvlpevent(void)
  76 {
  77         struct HvLpEvent * event;
  78         event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
  79
  80         if (event->xFlags.xValid) {
  81                 /* rmb() needed only for weakly consistent machines (regatta) */
  82                 rmb();
  83                 /* Set pointer to next potential event */
  84                 hvlpevent_queue.xSlicCurEventPtr += ((event->xSizeMinus1 +
  85                                 LpEventAlign) / LpEventAlign) * LpEventAlign;
  86
  87                 /* Wrap to beginning if no room at end */
  88                 if (hvlpevent_queue.xSlicCurEventPtr >
  89                                 hvlpevent_queue.xSlicLastValidEventPtr) {
  90                         hvlpevent_queue.xSlicCurEventPtr =
  91                                 hvlpevent_queue.xSlicEventStackPtr;
  92                 }
  93         } else {
  94                 event = NULL;
  95         }
  96
  97         return event;
  98 }
  99
 100 static unsigned long spread_lpevents = NR_CPUS;
 101
 102 int hvlpevent_is_pending(void)
 103 {
 104         struct HvLpEvent *next_event;
 105
 106         if (smp_processor_id() >= spread_lpevents)
 107                 return 0;
 108
 109         next_event = (struct HvLpEvent *)hvlpevent_queue.xSlicCurEventPtr;
 110
 111         return next_event->xFlags.xValid |
 112                 hvlpevent_queue.xPlicOverflowIntPending;
 113 }
 114
 115 static void hvlpevent_clear_valid(struct HvLpEvent * event)
 116 {
 117         /* Tell the Hypervisor that we're done with this event.
 118          * Also clear bits within this event that might look like valid bits.
 119          * ie. on 64-byte boundaries.
 120          */
 121         struct HvLpEvent *tmp;
 122         unsigned extra = ((event->xSizeMinus1 + LpEventAlign) /
 123                                                  LpEventAlign) - 1;
 124
 125         switch (extra) {
 126         case 3:
 127                 tmp = (struct HvLpEvent*)((char*)event + 3 * LpEventAlign);
 128                 tmp->xFlags.xValid = 0;
 129         case 2:
 130                 tmp = (struct HvLpEvent*)((char*)event + 2 * LpEventAlign);
 131                 tmp->xFlags.xValid = 0;
 132         case 1:
 133                 tmp = (struct HvLpEvent*)((char*)event + 1 * LpEventAlign);
 134                 tmp->xFlags.xValid = 0;
 135         }
 136
 137         mb();
 138
 139         event->xFlags.xValid = 0;
 140 }
 141
 142 void process_hvlpevents(struct pt_regs *regs)
 143 {
 144         struct HvLpEvent * event;
 145
 146         /* If we have recursed, just return */
 147         if ( !set_inUse() )
 148                 return;
 149
 150         if (ItLpQueueInProcess == 0)
 151                 ItLpQueueInProcess = 1;
 152         else
 153                 BUG();
 154
 155         for (;;) {
 156                 event = get_next_hvlpevent();
 157                 if (event) {
 158                         /* Call appropriate handler here, passing
 159                          * a pointer to the LpEvent.  The handler
 160                          * must make a copy of the LpEvent if it
 161                          * needs it in a bottom half. (perhaps for
 162                          * an ACK)
 163                          *
 164                          *  Handlers are responsible for ACK processing
 165                          *
 166                          * The Hypervisor guarantees that LpEvents will
 167                          * only be delivered with types that we have
 168                          * registered for, so no type check is necessary
 169                          * here!
 170                          */
 171                         if (event->xType < HvLpEvent_Type_NumTypes)
 172                                 __get_cpu_var(hvlpevent_counts)[event->xType]++;
 173                         if (event->xType < HvLpEvent_Type_NumTypes &&
 174                                         lpEventHandler[event->xType])
 175                                 lpEventHandler[event->xType](event, regs);
 176                         else
 177                                 printk(KERN_INFO "Unexpected Lp Event type=%d\n", event->xType );
 178
 179                         hvlpevent_clear_valid(event);
 180                 } else if (hvlpevent_queue.xPlicOverflowIntPending)
 181                         /*
 182                          * No more valid events. If overflow events are
 183                          * pending process them
 184                          */
 185                         HvCallEvent_getOverflowLpEvents(hvlpevent_queue.xIndex);
 186                 else
 187                         break;
 188         }
 189
 190         ItLpQueueInProcess = 0;
 191         mb();
 192         clear_inUse();
 193 }
 194
 195 static int set_spread_lpevents(char *str)
 196 {
 197         unsigned long val = simple_strtoul(str, NULL, 0);
 198
 199         /*
 200          * The parameter is the number of processors to share in processing
 201          * lp events.
 202          */
 203         if (( val > 0) && (val <= NR_CPUS)) {
 204                 spread_lpevents = val;
 205                 printk("lpevent processing spread over %ld processors\n", val);
 206         } else {
 207                 printk("invalid spread_lpevents %ld\n", val);
 208         }
 209
 210         return 1;
 211 }
 212 __setup("spread_lpevents=", set_spread_lpevents);
 213
 214 void setup_hvlpevent_queue(void)
 215 {
 216         void *eventStack;
 217
 218         /*
 219          * Allocate a page for the Event Stack. The Hypervisor needs the
 220          * absolute real address, so we subtract out the KERNELBASE and add
 221          * in the absolute real address of the kernel load area.
 222          */
 223         eventStack = alloc_bootmem_pages(LpEventStackSize);
 224         memset(eventStack, 0, LpEventStackSize);
 225
 226         /* Invoke the hypervisor to initialize the event stack */
 227         HvCallEvent_setLpEventStack(0, eventStack, LpEventStackSize);
 228
 229         hvlpevent_queue.xSlicEventStackPtr = (char *)eventStack;
 230         hvlpevent_queue.xSlicCurEventPtr = (char *)eventStack;
 231         hvlpevent_queue.xSlicLastValidEventPtr = (char *)eventStack +
 232                                         (LpEventStackSize - LpEventMaxSize);
 233         hvlpevent_queue.xIndex = 0;
 234 }
 235
 236 static int proc_lpevents_show(struct seq_file *m, void *v)
 237 {
 238         int cpu, i;
 239         unsigned long sum;
 240         static unsigned long cpu_totals[NR_CPUS];
 241
 242         /* FIXME: do we care that there's no locking here? */
 243         sum = 0;
 244         for_each_online_cpu(cpu) {
 245                 cpu_totals[cpu] = 0;
 246                 for (i = 0; i < HvLpEvent_Type_NumTypes; i++) {
 247                         cpu_totals[cpu] += per_cpu(hvlpevent_counts, cpu)[i];
 248                 }
 249                 sum += cpu_totals[cpu];
 250         }
 251
 252         seq_printf(m, "LpEventQueue 0\n");
 253         seq_printf(m, "  events processed:\t%lu\n", sum);
 254
 255         for (i = 0; i < HvLpEvent_Type_NumTypes; ++i) {
 256                 sum = 0;
 257                 for_each_online_cpu(cpu) {
 258                         sum += per_cpu(hvlpevent_counts, cpu)[i];
 259                 }
 260
 261                 seq_printf(m, "    %-20s %10lu\n", event_types[i], sum);
 262         }
 263
 264         seq_printf(m, "\n  events processed by processor:\n");
 265
 266         for_each_online_cpu(cpu) {
 267                 seq_printf(m, "    CPU%02d  %10lu\n", cpu, cpu_totals[cpu]);
 268         }
 269
 270         return 0;
 271 }
 272
 273 static int proc_lpevents_open(struct inode *inode, struct file *file)
 274 {
 275         return single_open(file, proc_lpevents_show, NULL);
 276 }
 277
 278 static struct file_operations proc_lpevents_operations = {
 279         .open           = proc_lpevents_open,
 280         .read           = seq_read,
 281         .llseek         = seq_lseek,
 282         .release        = single_release,
 283 };
 284
 285 static int __init proc_lpevents_init(void)
 286 {
 287         struct proc_dir_entry *e;
 288
 289         e = create_proc_entry("iSeries/lpevents", S_IFREG|S_IRUGO, NULL);
 290         if (e)
 291                 e->proc_fops = &proc_lpevents_operations;
 292
 293         return 0;
 294 }
 295 __initcall(proc_lpevents_init);
 296