arch/arm/oprofile/op_model_mpcore.c

   1 /**
   2  * @file op_model_mpcore.c
   3  * MPCORE Event Monitor Driver
   4  * @remark Copyright 2004 ARM SMP Development Team
   5  * @remark Copyright 2000-2004 Deepak Saxena <dsaxena@mvista.com>
   6  * @remark Copyright 2000-2004 MontaVista Software Inc
   7  * @remark Copyright 2004 Dave Jiang <dave.jiang@intel.com>
   8  * @remark Copyright 2004 Intel Corporation
   9  * @remark Copyright 2004 Zwane Mwaikambo <zwane@arm.linux.org.uk>
  10  * @remark Copyright 2004 Oprofile Authors
  11  *
  12  * @remark Read the file COPYING
  13  *
  14  * @author Zwane Mwaikambo
  15  *
  16  *  Counters:
  17  *    0: PMN0 on CPU0, per-cpu configurable event counter
  18  *    1: PMN1 on CPU0, per-cpu configurable event counter
  19  *    2: CCNT on CPU0
  20  *    3: PMN0 on CPU1
  21  *    4: PMN1 on CPU1
  22  *    5: CCNT on CPU1
  23  *    6: PMN0 on CPU1
  24  *    7: PMN1 on CPU1
  25  *    8: CCNT on CPU1
  26  *    9: PMN0 on CPU1
  27  *   10: PMN1 on CPU1
  28  *   11: CCNT on CPU1
  29  *   12-19: configurable SCU event counters
  30  */
  31
  32 /* #define DEBUG */
  33 #include <linux/types.h>
  34 #include <linux/errno.h>
  35 #include <linux/sched.h>
  36 #include <linux/oprofile.h>
  37 #include <linux/interrupt.h>
  38 #include <linux/smp.h>
  39
  40 #include <asm/io.h>
  41 #include <asm/irq.h>
  42 #include <asm/mach/irq.h>
  43 #include <asm/hardware.h>
  44 #include <asm/system.h>
  45
  46 #include "op_counter.h"
  47 #include "op_arm_model.h"
  48 #include "op_model_arm11_core.h"
  49 #include "op_model_mpcore.h"
  50
  51 /*
  52  * MPCore SCU event monitor support
  53  */
  54 #define SCU_EVENTMONITORS_VA_BASE __io_address(REALVIEW_MPCORE_SCU_BASE + 0x10)
  55
  56 /*
  57  * Bitmask of used SCU counters
  58  */
  59 static unsigned int scu_em_used;
  60
  61 /*
  62  * 2 helper fns take a counter number from 0-7 (not the userspace-visible counter number)
  63  */
  64 static inline void scu_reset_counter(struct eventmonitor __iomem *emc, unsigned int n)
  65 {
  66         writel(-(u32)counter_config[SCU_COUNTER(n)].count, &emc->MC[n]);
  67 }
  68
  69 static inline void scu_set_event(struct eventmonitor __iomem *emc, unsigned int n, u32 event)
  70 {
  71         event &= 0xff;
  72         writeb(event, &emc->MCEB[n]);
  73 }
  74
  75 /*
  76  * SCU counters' IRQ handler (one IRQ per counter => 2 IRQs per CPU)
  77  */
  78 static irqreturn_t scu_em_interrupt(int irq, void *arg)
  79 {
  80         struct eventmonitor __iomem *emc = SCU_EVENTMONITORS_VA_BASE;
  81         unsigned int cnt;
  82
  83         cnt = irq - IRQ_PMU_SCU0;
  84         oprofile_add_sample(get_irq_regs(), SCU_COUNTER(cnt));
  85         scu_reset_counter(emc, cnt);
  86
  87         /* Clear overflow flag for this counter */
  88         writel(1 << (cnt + 16), &emc->PMCR);
  89
  90         return IRQ_HANDLED;
  91 }
  92
  93 /* Configure just the SCU counters that the user has requested */
  94 static void scu_setup(void)
  95 {
  96         struct eventmonitor __iomem *emc = SCU_EVENTMONITORS_VA_BASE;
  97         unsigned int i;
  98
  99         scu_em_used = 0;
 100
 101         for (i = 0; i < NUM_SCU_COUNTERS; i++) {
 102                 if (counter_config[SCU_COUNTER(i)].enabled &&
 103                     counter_config[SCU_COUNTER(i)].event) {
 104                         scu_set_event(emc, i, 0); /* disable counter for now */
 105                         scu_em_used |= 1 << i;
 106                 }
 107         }
 108 }
 109
 110 static int scu_start(void)
 111 {
 112         struct eventmonitor __iomem *emc = SCU_EVENTMONITORS_VA_BASE;
 113         unsigned int temp, i;
 114         unsigned long event;
 115         int ret = 0;
 116
 117         /*
 118          * request the SCU counter interrupts that we need
 119          */
 120         for (i = 0; i < NUM_SCU_COUNTERS; i++) {
 121                 if (scu_em_used & (1 << i)) {
 122                         ret = request_irq(IRQ_PMU_SCU0 + i, scu_em_interrupt, IRQF_DISABLED, "SCU PMU", NULL);
 123                         if (ret) {
 124                                 printk(KERN_ERR "oprofile: unable to request IRQ%u for SCU Event Monitor\n",
 125                                        IRQ_PMU_SCU0 + i);
 126                                 goto err_free_scu;
 127                         }
 128                 }
 129         }
 130
 131         /*
 132          * clear overflow and enable interrupt for all used counters
 133          */
 134         temp = readl(&emc->PMCR);
 135         for (i = 0; i < NUM_SCU_COUNTERS; i++) {
 136                 if (scu_em_used & (1 << i)) {
 137                         scu_reset_counter(emc, i);
 138                         event = counter_config[SCU_COUNTER(i)].event;
 139                         scu_set_event(emc, i, event);
 140
 141                         /* clear overflow/interrupt */
 142                         temp |= 1 << (i + 16);
 143                         /* enable interrupt*/
 144                         temp |= 1 << (i + 8);
 145                 }
 146         }
 147
 148         /* Enable all 8 counters */
 149         temp |= PMCR_E;
 150         writel(temp, &emc->PMCR);
 151
 152         return 0;
 153
 154  err_free_scu:
 155         while (i--)
 156                 free_irq(IRQ_PMU_SCU0 + i, NULL);
 157         return ret;
 158 }
 159
 160 static void scu_stop(void)
 161 {
 162         struct eventmonitor __iomem *emc = SCU_EVENTMONITORS_VA_BASE;
 163         unsigned int temp, i;
 164
 165         /* Disable counter interrupts */
 166         /* Don't disable all 8 counters (with the E bit) as they may be in use */
 167         temp = readl(&emc->PMCR);
 168         for (i = 0; i < NUM_SCU_COUNTERS; i++) {
 169                 if (scu_em_used & (1 << i))
 170                         temp &= ~(1 << (i + 8));
 171         }
 172         writel(temp, &emc->PMCR);
 173
 174         /* Free counter interrupts and reset counters */
 175         for (i = 0; i < NUM_SCU_COUNTERS; i++) {
 176                 if (scu_em_used & (1 << i)) {
 177                         scu_reset_counter(emc, i);
 178                         free_irq(IRQ_PMU_SCU0 + i, NULL);
 179                 }
 180         }
 181 }
 182
 183 struct em_function_data {
 184         int (*fn)(void);
 185         int ret;
 186 };
 187
 188 static void em_func(void *data)
 189 {
 190         struct em_function_data *d = data;
 191         int ret = d->fn();
 192         if (ret)
 193                 d->ret = ret;
 194 }
 195
 196 static int em_call_function(int (*fn)(void))
 197 {
 198         struct em_function_data data;
 199
 200         data.fn = fn;
 201         data.ret = 0;
 202
 203         smp_call_function(em_func, &data, 1, 1);
 204         em_func(&data);
 205
 206         return data.ret;
 207 }
 208
 209 /*
 210  * Glue to stick the individual ARM11 PMUs and the SCU
 211  * into the oprofile framework.
 212  */
 213 static int em_setup_ctrs(void)
 214 {
 215         int ret;
 216
 217         /* Configure CPU counters by cross-calling to the other CPUs */
 218         ret = em_call_function(arm11_setup_pmu);
 219         if (ret == 0)
 220                 scu_setup();
 221
 222         return 0;
 223 }
 224
 225 static int arm11_irqs[] = {
 226         [0]     = IRQ_PMU_CPU0,
 227         [1]     = IRQ_PMU_CPU1,
 228         [2]     = IRQ_PMU_CPU2,
 229         [3]     = IRQ_PMU_CPU3
 230 };
 231
 232 static int em_start(void)
 233 {
 234         int ret;
 235
 236         ret = arm11_request_interrupts(arm11_irqs, ARRAY_SIZE(arm11_irqs));
 237         if (ret == 0) {
 238                 em_call_function(arm11_start_pmu);
 239
 240                 ret = scu_start();
 241                 if (ret)
 242                         arm11_release_interrupts(arm11_irqs, ARRAY_SIZE(arm11_irqs));
 243         }
 244         return ret;
 245 }
 246
 247 static void em_stop(void)
 248 {
 249         em_call_function(arm11_stop_pmu);
 250         arm11_release_interrupts(arm11_irqs, ARRAY_SIZE(arm11_irqs));
 251         scu_stop();
 252 }
 253
 254 /*
 255  * Why isn't there a function to route an IRQ to a specific CPU in
 256  * genirq?
 257  */
 258 static void em_route_irq(int irq, unsigned int cpu)
 259 {
 260         irq_desc[irq].affinity = cpumask_of_cpu(cpu);
 261         irq_desc[irq].chip->set_affinity(irq, cpumask_of_cpu(cpu));
 262 }
 263
 264 static int em_setup(void)
 265 {
 266         /*
 267          * Send SCU PMU interrupts to the "owner" CPU.
 268          */
 269         em_route_irq(IRQ_PMU_SCU0, 0);
 270         em_route_irq(IRQ_PMU_SCU1, 0);
 271         em_route_irq(IRQ_PMU_SCU2, 1);
 272         em_route_irq(IRQ_PMU_SCU3, 1);
 273         em_route_irq(IRQ_PMU_SCU4, 2);
 274         em_route_irq(IRQ_PMU_SCU5, 2);
 275         em_route_irq(IRQ_PMU_SCU6, 3);
 276         em_route_irq(IRQ_PMU_SCU7, 3);
 277
 278         /*
 279          * Send CP15 PMU interrupts to the owner CPU.
 280          */
 281         em_route_irq(IRQ_PMU_CPU0, 0);
 282         em_route_irq(IRQ_PMU_CPU1, 1);
 283         em_route_irq(IRQ_PMU_CPU2, 2);
 284         em_route_irq(IRQ_PMU_CPU3, 3);
 285
 286         return 0;
 287 }
 288
 289 struct op_arm_model_spec op_mpcore_spec = {
 290         .init           = em_setup,
 291         .num_counters   = MPCORE_NUM_COUNTERS,
 292         .setup_ctrs     = em_setup_ctrs,
 293         .start          = em_start,
 294         .stop           = em_stop,
 295         .name           = "arm/mpcore",
 296 };