[PATCH] powerpc: reduce oprofile/common.c differences
[linux-2.6.git] / arch / powerpc / oprofile / common.c
1 /*
2  * PPC 64 oprofile support:
3  * Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
4  * PPC 32 oprofile support: (based on PPC 64 support)
5  * Copyright (C) Freescale Semiconductor, Inc 2004
6  *      Author: Andy Fleming
7  *
8  * Based on alpha version.
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 #ifndef __powerpc64__
18 #include <linux/slab.h>
19 #endif /* ! __powerpc64__ */
20 #include <linux/init.h>
21 #include <linux/smp.h>
22 #include <linux/errno.h>
23 #include <asm/ptrace.h>
24 #include <asm/system.h>
25 #ifdef __powerpc64__
26 #include <asm/pmc.h>
27 #else /* __powerpc64__ */
28 #include <asm/perfmon.h>
29 #endif /* __powerpc64__ */
30 #include <asm/cputable.h>
31 #include <asm/oprofile_impl.h>
32
33 static struct op_powerpc_model *model;
34
35 static struct op_counter_config ctr[OP_MAX_COUNTER];
36 static struct op_system_config sys;
37
38 #ifndef __powerpc64__
39 static char *cpu_type;
40 #endif /* ! __powerpc64__ */
41
42 static void op_handle_interrupt(struct pt_regs *regs)
43 {
44         model->handle_interrupt(regs, ctr);
45 }
46
47 static int op_powerpc_setup(void)
48 {
49         int err;
50
51         /* Grab the hardware */
52         err = reserve_pmc_hardware(op_handle_interrupt);
53         if (err)
54                 return err;
55
56         /* Pre-compute the values to stuff in the hardware registers.  */
57         model->reg_setup(ctr, &sys, model->num_counters);
58
59         /* Configure the registers on all cpus.  */
60 #ifdef __powerpc64__
61         on_each_cpu(model->cpu_setup, NULL, 0, 1);
62 #else /* __powerpc64__ */
63 #if 0
64         /* FIXME: Make multi-cpu work */
65         on_each_cpu(model->reg_setup, NULL, 0, 1);
66 #endif
67 #endif /* __powerpc64__ */
68
69         return 0;
70 }
71
72 static void op_powerpc_shutdown(void)
73 {
74         release_pmc_hardware();
75 }
76
77 static void op_powerpc_cpu_start(void *dummy)
78 {
79         model->start(ctr);
80 }
81
82 static int op_powerpc_start(void)
83 {
84         on_each_cpu(op_powerpc_cpu_start, NULL, 0, 1);
85         return 0;
86 }
87
88 static inline void op_powerpc_cpu_stop(void *dummy)
89 {
90         model->stop();
91 }
92
93 static void op_powerpc_stop(void)
94 {
95         on_each_cpu(op_powerpc_cpu_stop, NULL, 0, 1);
96 }
97
98 static int op_powerpc_create_files(struct super_block *sb, struct dentry *root)
99 {
100         int i;
101
102 #ifdef __powerpc64__
103         /*
104          * There is one mmcr0, mmcr1 and mmcra for setting the events for
105          * all of the counters.
106          */
107         oprofilefs_create_ulong(sb, root, "mmcr0", &sys.mmcr0);
108         oprofilefs_create_ulong(sb, root, "mmcr1", &sys.mmcr1);
109         oprofilefs_create_ulong(sb, root, "mmcra", &sys.mmcra);
110 #endif /* __powerpc64__ */
111
112         for (i = 0; i < model->num_counters; ++i) {
113                 struct dentry *dir;
114                 char buf[3];
115
116                 snprintf(buf, sizeof buf, "%d", i);
117                 dir = oprofilefs_mkdir(sb, root, buf);
118
119                 oprofilefs_create_ulong(sb, dir, "enabled", &ctr[i].enabled);
120                 oprofilefs_create_ulong(sb, dir, "event", &ctr[i].event);
121                 oprofilefs_create_ulong(sb, dir, "count", &ctr[i].count);
122 #ifdef __powerpc64__
123                 /*
124                  * We dont support per counter user/kernel selection, but
125                  * we leave the entries because userspace expects them
126                  */
127 #endif /* __powerpc64__ */
128                 oprofilefs_create_ulong(sb, dir, "kernel", &ctr[i].kernel);
129                 oprofilefs_create_ulong(sb, dir, "user", &ctr[i].user);
130
131 #ifndef __powerpc64__
132                 /* FIXME: Not sure if this is used */
133 #endif /* ! __powerpc64__ */
134                 oprofilefs_create_ulong(sb, dir, "unit_mask", &ctr[i].unit_mask);
135         }
136
137         oprofilefs_create_ulong(sb, root, "enable_kernel", &sys.enable_kernel);
138         oprofilefs_create_ulong(sb, root, "enable_user", &sys.enable_user);
139 #ifdef __powerpc64__
140         oprofilefs_create_ulong(sb, root, "backtrace_spinlocks",
141                                 &sys.backtrace_spinlocks);
142 #endif /* __powerpc64__ */
143
144         /* Default to tracing both kernel and user */
145         sys.enable_kernel = 1;
146         sys.enable_user = 1;
147 #ifdef __powerpc64__
148         /* Turn on backtracing through spinlocks by default */
149         sys.backtrace_spinlocks = 1;
150 #endif /* __powerpc64__ */
151
152         return 0;
153 }
154
155 int __init oprofile_arch_init(struct oprofile_operations *ops)
156 {
157 #ifndef __powerpc64__
158         int cpu_id = smp_processor_id();
159
160 #ifdef CONFIG_FSL_BOOKE
161         model = &op_model_fsl_booke;
162 #else
163         return -ENODEV;
164 #endif
165
166         cpu_type = kmalloc(32, GFP_KERNEL);
167         if (NULL == cpu_type)
168                 return -ENOMEM;
169
170         sprintf(cpu_type, "ppc/%s", cur_cpu_spec[cpu_id]->cpu_name);
171
172         model->num_counters = cur_cpu_spec[cpu_id]->num_pmcs;
173
174         ops->cpu_type = cpu_type;
175 #else /* __powerpc64__ */
176         if (!cur_cpu_spec->oprofile_model || !cur_cpu_spec->oprofile_cpu_type)
177                 return -ENODEV;
178         model = cur_cpu_spec->oprofile_model;
179         model->num_counters = cur_cpu_spec->num_pmcs;
180
181         ops->cpu_type = cur_cpu_spec->oprofile_cpu_type;
182 #endif /* __powerpc64__ */
183         ops->create_files = op_powerpc_create_files;
184         ops->setup = op_powerpc_setup;
185         ops->shutdown = op_powerpc_shutdown;
186         ops->start = op_powerpc_start;
187         ops->stop = op_powerpc_stop;
188
189         printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
190                ops->cpu_type);
191
192         return 0;
193 }
194
195 void oprofile_arch_exit(void)
196 {
197 #ifndef __powerpc64__
198         kfree(cpu_type);
199         cpu_type = NULL;
200 #endif /* ! __powerpc64__ */
201 }