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