Merge branch 'for-2.6.25' of master.kernel.org:/pub/scm/linux/kernel/git/galak/powerp...
[sfrench/cifs-2.6.git] / arch / powerpc / oprofile / op_model_fsl_emb.c
1 /*
2  * Freescale Embedded oprofile support, based on ppc64 oprofile support
3  * Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
4  *
5  * Copyright (c) 2004 Freescale Semiconductor, Inc
6  *
7  * Author: Andy Fleming
8  * Maintainer: Kumar Gala <galak@kernel.crashing.org>
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 <asm/ptrace.h>
20 #include <asm/system.h>
21 #include <asm/processor.h>
22 #include <asm/cputable.h>
23 #include <asm/reg_fsl_emb.h>
24 #include <asm/page.h>
25 #include <asm/pmc.h>
26 #include <asm/oprofile_impl.h>
27
28 static unsigned long reset_value[OP_MAX_COUNTER];
29
30 static int num_counters;
31 static int oprofile_running;
32
33 static inline u32 get_pmlca(int ctr)
34 {
35         u32 pmlca;
36
37         switch (ctr) {
38                 case 0:
39                         pmlca = mfpmr(PMRN_PMLCA0);
40                         break;
41                 case 1:
42                         pmlca = mfpmr(PMRN_PMLCA1);
43                         break;
44                 case 2:
45                         pmlca = mfpmr(PMRN_PMLCA2);
46                         break;
47                 case 3:
48                         pmlca = mfpmr(PMRN_PMLCA3);
49                         break;
50                 default:
51                         panic("Bad ctr number\n");
52         }
53
54         return pmlca;
55 }
56
57 static inline void set_pmlca(int ctr, u32 pmlca)
58 {
59         switch (ctr) {
60                 case 0:
61                         mtpmr(PMRN_PMLCA0, pmlca);
62                         break;
63                 case 1:
64                         mtpmr(PMRN_PMLCA1, pmlca);
65                         break;
66                 case 2:
67                         mtpmr(PMRN_PMLCA2, pmlca);
68                         break;
69                 case 3:
70                         mtpmr(PMRN_PMLCA3, pmlca);
71                         break;
72                 default:
73                         panic("Bad ctr number\n");
74         }
75 }
76
77 static inline unsigned int ctr_read(unsigned int i)
78 {
79         switch(i) {
80                 case 0:
81                         return mfpmr(PMRN_PMC0);
82                 case 1:
83                         return mfpmr(PMRN_PMC1);
84                 case 2:
85                         return mfpmr(PMRN_PMC2);
86                 case 3:
87                         return mfpmr(PMRN_PMC3);
88                 default:
89                         return 0;
90         }
91 }
92
93 static inline void ctr_write(unsigned int i, unsigned int val)
94 {
95         switch(i) {
96                 case 0:
97                         mtpmr(PMRN_PMC0, val);
98                         break;
99                 case 1:
100                         mtpmr(PMRN_PMC1, val);
101                         break;
102                 case 2:
103                         mtpmr(PMRN_PMC2, val);
104                         break;
105                 case 3:
106                         mtpmr(PMRN_PMC3, val);
107                         break;
108                 default:
109                         break;
110         }
111 }
112
113
114 static void init_pmc_stop(int ctr)
115 {
116         u32 pmlca = (PMLCA_FC | PMLCA_FCS | PMLCA_FCU |
117                         PMLCA_FCM1 | PMLCA_FCM0);
118         u32 pmlcb = 0;
119
120         switch (ctr) {
121                 case 0:
122                         mtpmr(PMRN_PMLCA0, pmlca);
123                         mtpmr(PMRN_PMLCB0, pmlcb);
124                         break;
125                 case 1:
126                         mtpmr(PMRN_PMLCA1, pmlca);
127                         mtpmr(PMRN_PMLCB1, pmlcb);
128                         break;
129                 case 2:
130                         mtpmr(PMRN_PMLCA2, pmlca);
131                         mtpmr(PMRN_PMLCB2, pmlcb);
132                         break;
133                 case 3:
134                         mtpmr(PMRN_PMLCA3, pmlca);
135                         mtpmr(PMRN_PMLCB3, pmlcb);
136                         break;
137                 default:
138                         panic("Bad ctr number!\n");
139         }
140 }
141
142 static void set_pmc_event(int ctr, int event)
143 {
144         u32 pmlca;
145
146         pmlca = get_pmlca(ctr);
147
148         pmlca = (pmlca & ~PMLCA_EVENT_MASK) |
149                 ((event << PMLCA_EVENT_SHIFT) &
150                  PMLCA_EVENT_MASK);
151
152         set_pmlca(ctr, pmlca);
153 }
154
155 static void set_pmc_user_kernel(int ctr, int user, int kernel)
156 {
157         u32 pmlca;
158
159         pmlca = get_pmlca(ctr);
160
161         if(user)
162                 pmlca &= ~PMLCA_FCU;
163         else
164                 pmlca |= PMLCA_FCU;
165
166         if(kernel)
167                 pmlca &= ~PMLCA_FCS;
168         else
169                 pmlca |= PMLCA_FCS;
170
171         set_pmlca(ctr, pmlca);
172 }
173
174 static void set_pmc_marked(int ctr, int mark0, int mark1)
175 {
176         u32 pmlca = get_pmlca(ctr);
177
178         if(mark0)
179                 pmlca &= ~PMLCA_FCM0;
180         else
181                 pmlca |= PMLCA_FCM0;
182
183         if(mark1)
184                 pmlca &= ~PMLCA_FCM1;
185         else
186                 pmlca |= PMLCA_FCM1;
187
188         set_pmlca(ctr, pmlca);
189 }
190
191 static void pmc_start_ctr(int ctr, int enable)
192 {
193         u32 pmlca = get_pmlca(ctr);
194
195         pmlca &= ~PMLCA_FC;
196
197         if (enable)
198                 pmlca |= PMLCA_CE;
199         else
200                 pmlca &= ~PMLCA_CE;
201
202         set_pmlca(ctr, pmlca);
203 }
204
205 static void pmc_start_ctrs(int enable)
206 {
207         u32 pmgc0 = mfpmr(PMRN_PMGC0);
208
209         pmgc0 &= ~PMGC0_FAC;
210         pmgc0 |= PMGC0_FCECE;
211
212         if (enable)
213                 pmgc0 |= PMGC0_PMIE;
214         else
215                 pmgc0 &= ~PMGC0_PMIE;
216
217         mtpmr(PMRN_PMGC0, pmgc0);
218 }
219
220 static void pmc_stop_ctrs(void)
221 {
222         u32 pmgc0 = mfpmr(PMRN_PMGC0);
223
224         pmgc0 |= PMGC0_FAC;
225
226         pmgc0 &= ~(PMGC0_PMIE | PMGC0_FCECE);
227
228         mtpmr(PMRN_PMGC0, pmgc0);
229 }
230
231 static void dump_pmcs(void)
232 {
233         printk("pmgc0: %x\n", mfpmr(PMRN_PMGC0));
234         printk("pmc\t\tpmlca\t\tpmlcb\n");
235         printk("%8x\t%8x\t%8x\n", mfpmr(PMRN_PMC0),
236                         mfpmr(PMRN_PMLCA0), mfpmr(PMRN_PMLCB0));
237         printk("%8x\t%8x\t%8x\n", mfpmr(PMRN_PMC1),
238                         mfpmr(PMRN_PMLCA1), mfpmr(PMRN_PMLCB1));
239         printk("%8x\t%8x\t%8x\n", mfpmr(PMRN_PMC2),
240                         mfpmr(PMRN_PMLCA2), mfpmr(PMRN_PMLCB2));
241         printk("%8x\t%8x\t%8x\n", mfpmr(PMRN_PMC3),
242                         mfpmr(PMRN_PMLCA3), mfpmr(PMRN_PMLCB3));
243 }
244
245 static int fsl_emb_cpu_setup(struct op_counter_config *ctr)
246 {
247         int i;
248
249         /* freeze all counters */
250         pmc_stop_ctrs();
251
252         for (i = 0;i < num_counters;i++) {
253                 init_pmc_stop(i);
254
255                 set_pmc_event(i, ctr[i].event);
256
257                 set_pmc_user_kernel(i, ctr[i].user, ctr[i].kernel);
258         }
259
260         return 0;
261 }
262
263 static int fsl_emb_reg_setup(struct op_counter_config *ctr,
264                              struct op_system_config *sys,
265                              int num_ctrs)
266 {
267         int i;
268
269         num_counters = num_ctrs;
270
271         /* Our counters count up, and "count" refers to
272          * how much before the next interrupt, and we interrupt
273          * on overflow.  So we calculate the starting value
274          * which will give us "count" until overflow.
275          * Then we set the events on the enabled counters */
276         for (i = 0; i < num_counters; ++i)
277                 reset_value[i] = 0x80000000UL - ctr[i].count;
278
279         return 0;
280 }
281
282 static int fsl_emb_start(struct op_counter_config *ctr)
283 {
284         int i;
285
286         mtmsr(mfmsr() | MSR_PMM);
287
288         for (i = 0; i < num_counters; ++i) {
289                 if (ctr[i].enabled) {
290                         ctr_write(i, reset_value[i]);
291                         /* Set each enabled counter to only
292                          * count when the Mark bit is *not* set */
293                         set_pmc_marked(i, 1, 0);
294                         pmc_start_ctr(i, 1);
295                 } else {
296                         ctr_write(i, 0);
297
298                         /* Set the ctr to be stopped */
299                         pmc_start_ctr(i, 0);
300                 }
301         }
302
303         /* Clear the freeze bit, and enable the interrupt.
304          * The counters won't actually start until the rfi clears
305          * the PMM bit */
306         pmc_start_ctrs(1);
307
308         oprofile_running = 1;
309
310         pr_debug("start on cpu %d, pmgc0 %x\n", smp_processor_id(),
311                         mfpmr(PMRN_PMGC0));
312
313         return 0;
314 }
315
316 static void fsl_emb_stop(void)
317 {
318         /* freeze counters */
319         pmc_stop_ctrs();
320
321         oprofile_running = 0;
322
323         pr_debug("stop on cpu %d, pmgc0 %x\n", smp_processor_id(),
324                         mfpmr(PMRN_PMGC0));
325
326         mb();
327 }
328
329
330 static void fsl_emb_handle_interrupt(struct pt_regs *regs,
331                                     struct op_counter_config *ctr)
332 {
333         unsigned long pc;
334         int is_kernel;
335         int val;
336         int i;
337
338         /* set the PMM bit (see comment below) */
339         mtmsr(mfmsr() | MSR_PMM);
340
341         pc = regs->nip;
342         is_kernel = is_kernel_addr(pc);
343
344         for (i = 0; i < num_counters; ++i) {
345                 val = ctr_read(i);
346                 if (val < 0) {
347                         if (oprofile_running && ctr[i].enabled) {
348                                 oprofile_add_ext_sample(pc, regs, i, is_kernel);
349                                 ctr_write(i, reset_value[i]);
350                         } else {
351                                 ctr_write(i, 0);
352                         }
353                 }
354         }
355
356         /* The freeze bit was set by the interrupt. */
357         /* Clear the freeze bit, and reenable the interrupt.
358          * The counters won't actually start until the rfi clears
359          * the PMM bit */
360         pmc_start_ctrs(1);
361 }
362
363 struct op_powerpc_model op_model_fsl_emb = {
364         .reg_setup              = fsl_emb_reg_setup,
365         .cpu_setup              = fsl_emb_cpu_setup,
366         .start                  = fsl_emb_start,
367         .stop                   = fsl_emb_stop,
368         .handle_interrupt       = fsl_emb_handle_interrupt,
369 };