ALSA: mips: Convert to the common vmalloc memalloc
[sfrench/cifs-2.6.git] / arch / powerpc / oprofile / op_model_power4.c
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
4  * Added mmcra[slot] support:
5  * Copyright (C) 2006-2007 Will Schmidt <willschm@us.ibm.com>, IBM
6  */
7
8 #include <linux/oprofile.h>
9 #include <linux/smp.h>
10 #include <asm/firmware.h>
11 #include <asm/ptrace.h>
12 #include <asm/processor.h>
13 #include <asm/cputable.h>
14 #include <asm/rtas.h>
15 #include <asm/oprofile_impl.h>
16 #include <asm/reg.h>
17
18 #define dbg(args...)
19 #define OPROFILE_PM_PMCSEL_MSK      0xffULL
20 #define OPROFILE_PM_UNIT_SHIFT      60
21 #define OPROFILE_PM_UNIT_MSK        0xfULL
22 #define OPROFILE_MAX_PMC_NUM        3
23 #define OPROFILE_PMSEL_FIELD_WIDTH  8
24 #define OPROFILE_UNIT_FIELD_WIDTH   4
25 #define MMCRA_SIAR_VALID_MASK       0x10000000ULL
26
27 static unsigned long reset_value[OP_MAX_COUNTER];
28
29 static int oprofile_running;
30 static int use_slot_nums;
31
32 /* mmcr values are set in power4_reg_setup, used in power4_cpu_setup */
33 static u32 mmcr0_val;
34 static u64 mmcr1_val;
35 static u64 mmcra_val;
36 static u32 cntr_marked_events;
37
38 static int power7_marked_instr_event(u64 mmcr1)
39 {
40         u64 psel, unit;
41         int pmc, cntr_marked_events = 0;
42
43         /* Given the MMCR1 value, look at the field for each counter to
44          * determine if it is a marked event.  Code based on the function
45          * power7_marked_instr_event() in file arch/powerpc/perf/power7-pmu.c.
46          */
47         for (pmc = 0; pmc < 4; pmc++) {
48                 psel = mmcr1 & (OPROFILE_PM_PMCSEL_MSK
49                                 << (OPROFILE_MAX_PMC_NUM - pmc)
50                                 * OPROFILE_PMSEL_FIELD_WIDTH);
51                 psel = (psel >> ((OPROFILE_MAX_PMC_NUM - pmc)
52                                  * OPROFILE_PMSEL_FIELD_WIDTH)) & ~1ULL;
53                 unit = mmcr1 & (OPROFILE_PM_UNIT_MSK
54                                 << (OPROFILE_PM_UNIT_SHIFT
55                                     - (pmc * OPROFILE_PMSEL_FIELD_WIDTH )));
56                 unit = unit >> (OPROFILE_PM_UNIT_SHIFT
57                                 - (pmc * OPROFILE_PMSEL_FIELD_WIDTH));
58
59                 switch (psel >> 4) {
60                 case 2:
61                         cntr_marked_events |= (pmc == 1 || pmc == 3) << pmc;
62                         break;
63                 case 3:
64                         if (psel == 0x3c) {
65                                 cntr_marked_events |= (pmc == 0) << pmc;
66                                 break;
67                         }
68
69                         if (psel == 0x3e) {
70                                 cntr_marked_events |= (pmc != 1) << pmc;
71                                 break;
72                         }
73
74                         cntr_marked_events |= 1 << pmc;
75                         break;
76                 case 4:
77                 case 5:
78                         cntr_marked_events |= (unit == 0xd) << pmc;
79                         break;
80                 case 6:
81                         if (psel == 0x64)
82                                 cntr_marked_events |= (pmc >= 2) << pmc;
83                         break;
84                 case 8:
85                         cntr_marked_events |= (unit == 0xd) << pmc;
86                         break;
87                 }
88         }
89         return cntr_marked_events;
90 }
91
92 static int power4_reg_setup(struct op_counter_config *ctr,
93                              struct op_system_config *sys,
94                              int num_ctrs)
95 {
96         int i;
97
98         /*
99          * The performance counter event settings are given in the mmcr0,
100          * mmcr1 and mmcra values passed from the user in the
101          * op_system_config structure (sys variable).
102          */
103         mmcr0_val = sys->mmcr0;
104         mmcr1_val = sys->mmcr1;
105         mmcra_val = sys->mmcra;
106
107         /* Power 7+ and newer architectures:
108          * Determine which counter events in the group (the group of events is
109          * specified by the bit settings in the MMCR1 register) are marked
110          * events for use in the interrupt handler.  Do the calculation once
111          * before OProfile starts.  Information is used in the interrupt
112          * handler.  Starting with Power 7+ we only record the sample for
113          * marked events if the SIAR valid bit is set.  For non marked events
114          * the sample is always recorded.
115          */
116         if (pvr_version_is(PVR_POWER7p))
117                 cntr_marked_events = power7_marked_instr_event(mmcr1_val);
118         else
119                 cntr_marked_events = 0; /* For older processors, set the bit map
120                                          * to zero so the sample will always be
121                                          * be recorded.
122                                          */
123
124         for (i = 0; i < cur_cpu_spec->num_pmcs; ++i)
125                 reset_value[i] = 0x80000000UL - ctr[i].count;
126
127         /* setup user and kernel profiling */
128         if (sys->enable_kernel)
129                 mmcr0_val &= ~MMCR0_KERNEL_DISABLE;
130         else
131                 mmcr0_val |= MMCR0_KERNEL_DISABLE;
132
133         if (sys->enable_user)
134                 mmcr0_val &= ~MMCR0_PROBLEM_DISABLE;
135         else
136                 mmcr0_val |= MMCR0_PROBLEM_DISABLE;
137
138         if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p) ||
139             pvr_version_is(PVR_970) || pvr_version_is(PVR_970FX) ||
140             pvr_version_is(PVR_970MP) || pvr_version_is(PVR_970GX) ||
141             pvr_version_is(PVR_POWER5) || pvr_version_is(PVR_POWER5p))
142                 use_slot_nums = 1;
143
144         return 0;
145 }
146
147 extern void ppc_enable_pmcs(void);
148
149 /*
150  * Older CPUs require the MMCRA sample bit to be always set, but newer 
151  * CPUs only want it set for some groups. Eventually we will remove all
152  * knowledge of this bit in the kernel, oprofile userspace should be
153  * setting it when required.
154  *
155  * In order to keep current installations working we force the bit for
156  * those older CPUs. Once everyone has updated their oprofile userspace we
157  * can remove this hack.
158  */
159 static inline int mmcra_must_set_sample(void)
160 {
161         if (pvr_version_is(PVR_POWER4) || pvr_version_is(PVR_POWER4p) ||
162             pvr_version_is(PVR_970) || pvr_version_is(PVR_970FX) ||
163             pvr_version_is(PVR_970MP) || pvr_version_is(PVR_970GX))
164                 return 1;
165
166         return 0;
167 }
168
169 static int power4_cpu_setup(struct op_counter_config *ctr)
170 {
171         unsigned int mmcr0 = mmcr0_val;
172         unsigned long mmcra = mmcra_val;
173
174         ppc_enable_pmcs();
175
176         /* set the freeze bit */
177         mmcr0 |= MMCR0_FC;
178         mtspr(SPRN_MMCR0, mmcr0);
179
180         mmcr0 |= MMCR0_FCM1|MMCR0_PMXE|MMCR0_FCECE;
181         mmcr0 |= MMCR0_PMC1CE|MMCR0_PMCjCE;
182         mtspr(SPRN_MMCR0, mmcr0);
183
184         mtspr(SPRN_MMCR1, mmcr1_val);
185
186         if (mmcra_must_set_sample())
187                 mmcra |= MMCRA_SAMPLE_ENABLE;
188         mtspr(SPRN_MMCRA, mmcra);
189
190         dbg("setup on cpu %d, mmcr0 %lx\n", smp_processor_id(),
191             mfspr(SPRN_MMCR0));
192         dbg("setup on cpu %d, mmcr1 %lx\n", smp_processor_id(),
193             mfspr(SPRN_MMCR1));
194         dbg("setup on cpu %d, mmcra %lx\n", smp_processor_id(),
195             mfspr(SPRN_MMCRA));
196
197         return 0;
198 }
199
200 static int power4_start(struct op_counter_config *ctr)
201 {
202         int i;
203         unsigned int mmcr0;
204
205         /* set the PMM bit (see comment below) */
206         mtmsr(mfmsr() | MSR_PMM);
207
208         for (i = 0; i < cur_cpu_spec->num_pmcs; ++i) {
209                 if (ctr[i].enabled) {
210                         classic_ctr_write(i, reset_value[i]);
211                 } else {
212                         classic_ctr_write(i, 0);
213                 }
214         }
215
216         mmcr0 = mfspr(SPRN_MMCR0);
217
218         /*
219          * We must clear the PMAO bit on some (GQ) chips. Just do it
220          * all the time
221          */
222         mmcr0 &= ~MMCR0_PMAO;
223
224         /*
225          * now clear the freeze bit, counting will not start until we
226          * rfid from this excetion, because only at that point will
227          * the PMM bit be cleared
228          */
229         mmcr0 &= ~MMCR0_FC;
230         mtspr(SPRN_MMCR0, mmcr0);
231
232         oprofile_running = 1;
233
234         dbg("start on cpu %d, mmcr0 %x\n", smp_processor_id(), mmcr0);
235         return 0;
236 }
237
238 static void power4_stop(void)
239 {
240         unsigned int mmcr0;
241
242         /* freeze counters */
243         mmcr0 = mfspr(SPRN_MMCR0);
244         mmcr0 |= MMCR0_FC;
245         mtspr(SPRN_MMCR0, mmcr0);
246
247         oprofile_running = 0;
248
249         dbg("stop on cpu %d, mmcr0 %x\n", smp_processor_id(), mmcr0);
250
251         mb();
252 }
253
254 /* Fake functions used by canonicalize_pc */
255 static void __used hypervisor_bucket(void)
256 {
257 }
258
259 static void __used rtas_bucket(void)
260 {
261 }
262
263 static void __used kernel_unknown_bucket(void)
264 {
265 }
266
267 /*
268  * On GQ and newer the MMCRA stores the HV and PR bits at the time
269  * the SIAR was sampled. We use that to work out if the SIAR was sampled in
270  * the hypervisor, our exception vectors or RTAS.
271  * If the MMCRA_SAMPLE_ENABLE bit is set, we can use the MMCRA[slot] bits
272  * to more accurately identify the address of the sampled instruction. The
273  * mmcra[slot] bits represent the slot number of a sampled instruction
274  * within an instruction group.  The slot will contain a value between 1
275  * and 5 if MMCRA_SAMPLE_ENABLE is set, otherwise 0.
276  */
277 static unsigned long get_pc(struct pt_regs *regs)
278 {
279         unsigned long pc = mfspr(SPRN_SIAR);
280         unsigned long mmcra;
281         unsigned long slot;
282
283         /* Can't do much about it */
284         if (!cur_cpu_spec->oprofile_mmcra_sihv)
285                 return pc;
286
287         mmcra = mfspr(SPRN_MMCRA);
288
289         if (use_slot_nums && (mmcra & MMCRA_SAMPLE_ENABLE)) {
290                 slot = ((mmcra & MMCRA_SLOT) >> MMCRA_SLOT_SHIFT);
291                 if (slot > 1)
292                         pc += 4 * (slot - 1);
293         }
294
295         /* Were we in the hypervisor? */
296         if (firmware_has_feature(FW_FEATURE_LPAR) &&
297             (mmcra & cur_cpu_spec->oprofile_mmcra_sihv))
298                 /* function descriptor madness */
299                 return *((unsigned long *)hypervisor_bucket);
300
301         /* We were in userspace, nothing to do */
302         if (mmcra & cur_cpu_spec->oprofile_mmcra_sipr)
303                 return pc;
304
305 #ifdef CONFIG_PPC_RTAS
306         /* Were we in RTAS? */
307         if (pc >= rtas.base && pc < (rtas.base + rtas.size))
308                 /* function descriptor madness */
309                 return *((unsigned long *)rtas_bucket);
310 #endif
311
312         /* Were we in our exception vectors or SLB real mode miss handler? */
313         if (pc < 0x1000000UL)
314                 return (unsigned long)__va(pc);
315
316         /* Not sure where we were */
317         if (!is_kernel_addr(pc))
318                 /* function descriptor madness */
319                 return *((unsigned long *)kernel_unknown_bucket);
320
321         return pc;
322 }
323
324 static int get_kernel(unsigned long pc, unsigned long mmcra)
325 {
326         int is_kernel;
327
328         if (!cur_cpu_spec->oprofile_mmcra_sihv) {
329                 is_kernel = is_kernel_addr(pc);
330         } else {
331                 is_kernel = ((mmcra & cur_cpu_spec->oprofile_mmcra_sipr) == 0);
332         }
333
334         return is_kernel;
335 }
336
337 static bool pmc_overflow(unsigned long val)
338 {
339         if ((int)val < 0)
340                 return true;
341
342         /*
343          * Events on POWER7 can roll back if a speculative event doesn't
344          * eventually complete. Unfortunately in some rare cases they will
345          * raise a performance monitor exception. We need to catch this to
346          * ensure we reset the PMC. In all cases the PMC will be 256 or less
347          * cycles from overflow.
348          *
349          * We only do this if the first pass fails to find any overflowing
350          * PMCs because a user might set a period of less than 256 and we
351          * don't want to mistakenly reset them.
352          */
353         if (pvr_version_is(PVR_POWER7) && ((0x80000000 - val) <= 256))
354                 return true;
355
356         return false;
357 }
358
359 static void power4_handle_interrupt(struct pt_regs *regs,
360                                     struct op_counter_config *ctr)
361 {
362         unsigned long pc;
363         int is_kernel;
364         int val;
365         int i;
366         unsigned int mmcr0;
367         unsigned long mmcra;
368         bool siar_valid = false;
369
370         mmcra = mfspr(SPRN_MMCRA);
371
372         pc = get_pc(regs);
373         is_kernel = get_kernel(pc, mmcra);
374
375         /* set the PMM bit (see comment below) */
376         mtmsr(mfmsr() | MSR_PMM);
377
378         /* Check that the SIAR  valid bit in MMCRA is set to 1. */
379         if ((mmcra & MMCRA_SIAR_VALID_MASK) == MMCRA_SIAR_VALID_MASK)
380                 siar_valid = true;
381
382         for (i = 0; i < cur_cpu_spec->num_pmcs; ++i) {
383                 val = classic_ctr_read(i);
384                 if (pmc_overflow(val)) {
385                         if (oprofile_running && ctr[i].enabled) {
386                                 /* Power 7+ and newer architectures:
387                                  * If the event is a marked event, then only
388                                  * save the sample if the SIAR valid bit is
389                                  * set.  If the event is not marked, then
390                                  * always save the sample.
391                                  * Note, the Sample enable bit in the MMCRA
392                                  * register must be set to 1 if the group
393                                  * contains a marked event.
394                                  */
395                                 if ((siar_valid &&
396                                      (cntr_marked_events & (1 << i)))
397                                     || !(cntr_marked_events & (1 << i)))
398                                         oprofile_add_ext_sample(pc, regs, i,
399                                                                 is_kernel);
400
401                                 classic_ctr_write(i, reset_value[i]);
402                         } else {
403                                 classic_ctr_write(i, 0);
404                         }
405                 }
406         }
407
408         mmcr0 = mfspr(SPRN_MMCR0);
409
410         /* reset the perfmon trigger */
411         mmcr0 |= MMCR0_PMXE;
412
413         /*
414          * We must clear the PMAO bit on some (GQ) chips. Just do it
415          * all the time
416          */
417         mmcr0 &= ~MMCR0_PMAO;
418
419         /* Clear the appropriate bits in the MMCRA */
420         mmcra &= ~cur_cpu_spec->oprofile_mmcra_clear;
421         mtspr(SPRN_MMCRA, mmcra);
422
423         /*
424          * now clear the freeze bit, counting will not start until we
425          * rfid from this exception, because only at that point will
426          * the PMM bit be cleared
427          */
428         mmcr0 &= ~MMCR0_FC;
429         mtspr(SPRN_MMCR0, mmcr0);
430 }
431
432 struct op_powerpc_model op_model_power4 = {
433         .reg_setup              = power4_reg_setup,
434         .cpu_setup              = power4_cpu_setup,
435         .start                  = power4_start,
436         .stop                   = power4_stop,
437         .handle_interrupt       = power4_handle_interrupt,
438 };