[PATCH] powerpc: merge oprofile headers
[linux-2.6.git] / arch / ppc / oprofile / common.c
1 /*
2  * PPC 32 oprofile support
3  * Based on PPC64 oprofile support
4  * Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
5  *
6  * Copyright (C) Freescale Semiconductor, Inc 2004
7  *
8  * Author: Andy Fleming
9  *
10  * This program is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU General Public License
12  * as published by the Free Software Foundation; either version
13  * 2 of the License, or (at your option) any later version.
14  */
15
16 #include <linux/oprofile.h>
17 #include <linux/slab.h>
18 #include <linux/init.h>
19 #include <linux/smp.h>
20 #include <linux/errno.h>
21 #include <asm/ptrace.h>
22 #include <asm/system.h>
23 #include <asm/perfmon.h>
24 #include <asm/cputable.h>
25 #include <asm/oprofile_impl.h>
26
27 static struct op_powerpc_model *model;
28
29 static struct op_counter_config ctr[OP_MAX_COUNTER];
30 static struct op_system_config sys;
31
32 static void op_handle_interrupt(struct pt_regs *regs)
33 {
34         model->handle_interrupt(regs, ctr);
35 }
36
37 static int op_ppc32_setup(void)
38 {
39         /* Install our interrupt handler into the existing hook.  */
40         if(request_perfmon_irq(&op_handle_interrupt))
41                 return -EBUSY;
42
43         mb();
44
45         /* Pre-compute the values to stuff in the hardware registers.  */
46         model->reg_setup(ctr, &sys, model->num_counters);
47
48 #if 0
49         /* FIXME: Make multi-cpu work */
50         /* Configure the registers on all cpus.  */
51         on_each_cpu(model->reg_setup, NULL, 0, 1);
52 #endif
53
54         return 0;
55 }
56
57 static void op_ppc32_shutdown(void)
58 {
59         mb();
60
61         /* Remove our interrupt handler. We may be removing this module. */
62         free_perfmon_irq();
63 }
64
65 static void op_ppc32_cpu_start(void *dummy)
66 {
67         model->start(ctr);
68 }
69
70 static int op_ppc32_start(void)
71 {
72         on_each_cpu(op_ppc32_cpu_start, NULL, 0, 1);
73         return 0;
74 }
75
76 static inline void op_ppc32_cpu_stop(void *dummy)
77 {
78         model->stop();
79 }
80
81 static void op_ppc32_stop(void)
82 {
83         on_each_cpu(op_ppc32_cpu_stop, NULL, 0, 1);
84 }
85
86 static int op_ppc32_create_files(struct super_block *sb, struct dentry *root)
87 {
88         int i;
89
90         for (i = 0; i < model->num_counters; ++i) {
91                 struct dentry *dir;
92                 char buf[3];
93
94                 snprintf(buf, sizeof buf, "%d", i);
95                 dir = oprofilefs_mkdir(sb, root, buf);
96
97                 oprofilefs_create_ulong(sb, dir, "enabled", &ctr[i].enabled);
98                 oprofilefs_create_ulong(sb, dir, "event", &ctr[i].event);
99                 oprofilefs_create_ulong(sb, dir, "count", &ctr[i].count);
100                 oprofilefs_create_ulong(sb, dir, "kernel", &ctr[i].kernel);
101                 oprofilefs_create_ulong(sb, dir, "user", &ctr[i].user);
102
103                 /* FIXME: Not sure if this is used */
104                 oprofilefs_create_ulong(sb, dir, "unit_mask", &ctr[i].unit_mask);
105         }
106
107         oprofilefs_create_ulong(sb, root, "enable_kernel", &sys.enable_kernel);
108         oprofilefs_create_ulong(sb, root, "enable_user", &sys.enable_user);
109
110         /* Default to tracing both kernel and user */
111         sys.enable_kernel = 1;
112         sys.enable_user = 1;
113
114         return 0;
115 }
116
117 static struct oprofile_operations oprof_ppc32_ops = {
118         .create_files   = op_ppc32_create_files,
119         .setup          = op_ppc32_setup,
120         .shutdown       = op_ppc32_shutdown,
121         .start          = op_ppc32_start,
122         .stop           = op_ppc32_stop,
123         .cpu_type       = NULL          /* To be filled in below. */
124 };
125
126 int __init oprofile_arch_init(struct oprofile_operations *ops)
127 {
128         char *name;
129         int cpu_id = smp_processor_id();
130
131 #ifdef CONFIG_FSL_BOOKE
132         model = &op_model_fsl_booke;
133 #else
134         return -ENODEV;
135 #endif
136
137         name = kmalloc(32, GFP_KERNEL);
138
139         if (NULL == name)
140                 return -ENOMEM;
141
142         sprintf(name, "ppc/%s", cur_cpu_spec[cpu_id]->cpu_name);
143
144         oprof_ppc32_ops.cpu_type = name;
145
146         model->num_counters = cur_cpu_spec[cpu_id]->num_pmcs;
147
148         *ops = oprof_ppc32_ops;
149
150         printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
151                oprof_ppc32_ops.cpu_type);
152
153         return 0;
154 }
155
156 void oprofile_arch_exit(void)
157 {
158         kfree(oprof_ppc32_ops.cpu_type);
159         oprof_ppc32_ops.cpu_type = NULL;
160 }