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 #include <linux/init.h>
18 #include <linux/smp.h>
19 #include <linux/errno.h>
20 #include <asm/ptrace.h>
21 #include <asm/pmc.h>
22 #include <asm/cputable.h>
23 #include <asm/oprofile_impl.h>
24 #include <asm/firmware.h>
25
26 static struct op_powerpc_model *model;
27
28 static struct op_counter_config ctr[OP_MAX_COUNTER];
29 static struct op_system_config sys;
30
31 static int op_per_cpu_rc;
32
op_handle_interrupt(struct pt_regs * regs)33 static void op_handle_interrupt(struct pt_regs *regs)
34 {
35 model->handle_interrupt(regs, ctr);
36 }
37
op_powerpc_cpu_setup(void * dummy)38 static void op_powerpc_cpu_setup(void *dummy)
39 {
40 int ret;
41
42 ret = model->cpu_setup(ctr);
43
44 if (ret != 0)
45 op_per_cpu_rc = ret;
46 }
47
op_powerpc_setup(void)48 static int op_powerpc_setup(void)
49 {
50 int err;
51
52 op_per_cpu_rc = 0;
53
54 /* Grab the hardware */
55 err = reserve_pmc_hardware(op_handle_interrupt);
56 if (err)
57 return err;
58
59 /* Pre-compute the values to stuff in the hardware registers. */
60 op_per_cpu_rc = model->reg_setup(ctr, &sys, model->num_counters);
61
62 if (op_per_cpu_rc)
63 goto out;
64
65 /* Configure the registers on all cpus. If an error occurs on one
66 * of the cpus, op_per_cpu_rc will be set to the error */
67 on_each_cpu(op_powerpc_cpu_setup, NULL, 1);
68
69 out: if (op_per_cpu_rc) {
70 /* error on setup release the performance counter hardware */
71 release_pmc_hardware();
72 }
73
74 return op_per_cpu_rc;
75 }
76
op_powerpc_shutdown(void)77 static void op_powerpc_shutdown(void)
78 {
79 release_pmc_hardware();
80 }
81
op_powerpc_cpu_start(void * dummy)82 static void op_powerpc_cpu_start(void *dummy)
83 {
84 /* If any of the cpus have return an error, set the
85 * global flag to the error so it can be returned
86 * to the generic OProfile caller.
87 */
88 int ret;
89
90 ret = model->start(ctr);
91 if (ret != 0)
92 op_per_cpu_rc = ret;
93 }
94
op_powerpc_start(void)95 static int op_powerpc_start(void)
96 {
97 op_per_cpu_rc = 0;
98
99 if (model->global_start)
100 return model->global_start(ctr);
101 if (model->start) {
102 on_each_cpu(op_powerpc_cpu_start, NULL, 1);
103 return op_per_cpu_rc;
104 }
105 return -EIO; /* No start function is defined for this
106 power architecture */
107 }
108
op_powerpc_cpu_stop(void * dummy)109 static inline void op_powerpc_cpu_stop(void *dummy)
110 {
111 model->stop();
112 }
113
op_powerpc_stop(void)114 static void op_powerpc_stop(void)
115 {
116 if (model->stop)
117 on_each_cpu(op_powerpc_cpu_stop, NULL, 1);
118 if (model->global_stop)
119 model->global_stop();
120 }
121
op_powerpc_create_files(struct dentry * root)122 static int op_powerpc_create_files(struct dentry *root)
123 {
124 int i;
125
126 #ifdef CONFIG_PPC64
127 /*
128 * There is one mmcr0, mmcr1 and mmcra for setting the events for
129 * all of the counters.
130 */
131 oprofilefs_create_ulong(root, "mmcr0", &sys.mmcr0);
132 oprofilefs_create_ulong(root, "mmcr1", &sys.mmcr1);
133 oprofilefs_create_ulong(root, "mmcra", &sys.mmcra);
134 #ifdef CONFIG_OPROFILE_CELL
135 /* create a file the user tool can check to see what level of profiling
136 * support exits with this kernel. Initialize bit mask to indicate
137 * what support the kernel has:
138 * bit 0 - Supports SPU event profiling in addition to PPU
139 * event and cycles; and SPU cycle profiling
140 * bits 1-31 - Currently unused.
141 *
142 * If the file does not exist, then the kernel only supports SPU
143 * cycle profiling, PPU event and cycle profiling.
144 */
145 oprofilefs_create_ulong(root, "cell_support", &sys.cell_support);
146 sys.cell_support = 0x1; /* Note, the user OProfile tool must check
147 * that this bit is set before attempting to
148 * user SPU event profiling. Older kernels
149 * will not have this file, hence the user
150 * tool is not allowed to do SPU event
151 * profiling on older kernels. Older kernels
152 * will accept SPU events but collected data
153 * is garbage.
154 */
155 #endif
156 #endif
157
158 for (i = 0; i < model->num_counters; ++i) {
159 struct dentry *dir;
160 char buf[4];
161
162 snprintf(buf, sizeof buf, "%d", i);
163 dir = oprofilefs_mkdir(root, buf);
164
165 oprofilefs_create_ulong(dir, "enabled", &ctr[i].enabled);
166 oprofilefs_create_ulong(dir, "event", &ctr[i].event);
167 oprofilefs_create_ulong(dir, "count", &ctr[i].count);
168
169 /*
170 * Classic PowerPC doesn't support per-counter
171 * control like this, but the options are
172 * expected, so they remain. For Freescale
173 * Book-E style performance monitors, we do
174 * support them.
175 */
176 oprofilefs_create_ulong(dir, "kernel", &ctr[i].kernel);
177 oprofilefs_create_ulong(dir, "user", &ctr[i].user);
178
179 oprofilefs_create_ulong(dir, "unit_mask", &ctr[i].unit_mask);
180 }
181
182 oprofilefs_create_ulong(root, "enable_kernel", &sys.enable_kernel);
183 oprofilefs_create_ulong(root, "enable_user", &sys.enable_user);
184
185 /* Default to tracing both kernel and user */
186 sys.enable_kernel = 1;
187 sys.enable_user = 1;
188
189 return 0;
190 }
191
oprofile_arch_init(struct oprofile_operations * ops)192 int __init oprofile_arch_init(struct oprofile_operations *ops)
193 {
194 if (!cur_cpu_spec->oprofile_cpu_type)
195 return -ENODEV;
196
197 switch (cur_cpu_spec->oprofile_type) {
198 #ifdef CONFIG_PPC_BOOK3S_64
199 #ifdef CONFIG_OPROFILE_CELL
200 case PPC_OPROFILE_CELL:
201 if (firmware_has_feature(FW_FEATURE_LPAR))
202 return -ENODEV;
203 model = &op_model_cell;
204 ops->sync_start = model->sync_start;
205 ops->sync_stop = model->sync_stop;
206 break;
207 #endif
208 case PPC_OPROFILE_POWER4:
209 model = &op_model_power4;
210 break;
211 case PPC_OPROFILE_PA6T:
212 model = &op_model_pa6t;
213 break;
214 #endif
215 #ifdef CONFIG_6xx
216 case PPC_OPROFILE_G4:
217 model = &op_model_7450;
218 break;
219 #endif
220 #if defined(CONFIG_FSL_EMB_PERFMON)
221 case PPC_OPROFILE_FSL_EMB:
222 model = &op_model_fsl_emb;
223 break;
224 #endif
225 default:
226 return -ENODEV;
227 }
228
229 model->num_counters = cur_cpu_spec->num_pmcs;
230
231 ops->cpu_type = cur_cpu_spec->oprofile_cpu_type;
232 ops->create_files = op_powerpc_create_files;
233 ops->setup = op_powerpc_setup;
234 ops->shutdown = op_powerpc_shutdown;
235 ops->start = op_powerpc_start;
236 ops->stop = op_powerpc_stop;
237 ops->backtrace = op_powerpc_backtrace;
238
239 printk(KERN_DEBUG "oprofile: using %s performance monitoring.\n",
240 ops->cpu_type);
241
242 return 0;
243 }
244
oprofile_arch_exit(void)245 void oprofile_arch_exit(void)
246 {
247 }
248