gator: ARM DS-5.6 Streamline gator driver
[android-sdk/arm-ds5-gator.git] / gator_events_armv7.c
1 /**
2  * Copyright (C) ARM Limited 2010-2011. All rights reserved.
3  *
4  * This program is free software; you can redistribute it and/or modify
5  * it under the terms of the GNU General Public License version 2 as
6  * published by the Free Software Foundation.
7  */
9 #include "gator.h"
11 #define CORTEX_A5       0xc05
12 #define CORTEX_A8       0xc08
13 #define CORTEX_A9       0xc09
14 #define CORTEX_A15      0xc0f
16 static const char *pmnc_name;
17 static int pmnc_count;
19 // Per-CPU PMNC: config reg
20 #define PMNC_E          (1 << 0)        /* Enable all counters */
21 #define PMNC_P          (1 << 1)        /* Reset all counters */
22 #define PMNC_C          (1 << 2)        /* Cycle counter reset */
23 #define PMNC_MASK       0x3f            /* Mask for writable bits */
25 // ccnt reg
26 #define CCNT_REG        (1 << 31)
28 #define CCNT            0
29 #define CNT0            1
30 #define CNTMAX          (6+1)
32 static unsigned long pmnc_enabled[CNTMAX];
33 static unsigned long pmnc_event[CNTMAX];
34 static unsigned long pmnc_key[CNTMAX];
36 static DEFINE_PER_CPU(int[CNTMAX], perfPrev);
37 static DEFINE_PER_CPU(int[CNTMAX * 2], perfCnt);
39 static inline void armv7_pmnc_write(u32 val)
40 {
41         val &= PMNC_MASK;
42         asm volatile("mcr p15, 0, %0, c9, c12, 0" : : "r" (val));
43 }
45 static inline u32 armv7_pmnc_read(void)
46 {
47         u32 val;
48         asm volatile("mrc p15, 0, %0, c9, c12, 0" : "=r" (val));
49         return val;
50 }
52 static inline u32 armv7_ccnt_read(void)
53 {
54         u32 zero = 0;
55         u32 den = CCNT_REG;
56         u32 val;
58         asm volatile("mcr p15, 0, %0, c9, c12, 2" : : "r" (den));       // disable
59         asm volatile("mrc p15, 0, %0, c9, c13, 0" : "=r" (val));        // read
60         asm volatile("mcr p15, 0, %0, c9, c13, 0" : : "r" (zero));      // zero
61         asm volatile("mcr p15, 0, %0, c9, c12, 1" : : "r" (den));       // enable
63         return val;
64 }
66 static inline u32 armv7_cntn_read(unsigned int cnt)
67 {
68         u32 zero = 0;
69         u32 sel = (cnt - CNT0);
70         u32 den = 1 << sel;
71         u32 val;
73         asm volatile("mcr p15, 0, %0, c9, c12, 2" : : "r" (den));       // disable
74         asm volatile("mcr p15, 0, %0, c9, c12, 5" : : "r" (sel));       // select
75         asm volatile("mrc p15, 0, %0, c9, c13, 2" : "=r" (val));        // read
76         asm volatile("mcr p15, 0, %0, c9, c13, 2" : : "r" (zero));      // zero
77         asm volatile("mcr p15, 0, %0, c9, c12, 1" : : "r" (den));       // enable
79         return val;
80 }
82 static inline u32 armv7_pmnc_enable_counter(unsigned int cnt)
83 {
84         u32 val;
86         if (cnt >= CNTMAX) {
87                 pr_err("gator: CPU%u enabling wrong PMNC counter %d\n", smp_processor_id(), cnt);
88                 return -1;
89         }
91         if (cnt == CCNT)
92                 val = CCNT_REG;
93         else
94                 val = (1 << (cnt - CNT0));
96         asm volatile("mcr p15, 0, %0, c9, c12, 1" : : "r" (val));
98         return cnt;
99 }
101 static inline u32 armv7_pmnc_disable_counter(unsigned int cnt)
103         u32 val;
105         if (cnt >= CNTMAX) {
106                 pr_err("gator: CPU%u disabling wrong PMNC counter %d\n", smp_processor_id(), cnt);
107                 return -1;
108         }
110         if (cnt == CCNT)
111                 val = CCNT_REG;
112         else
113                 val = (1 << (cnt - CNT0));
115         asm volatile("mcr p15, 0, %0, c9, c12, 2" : : "r" (val));
117         return cnt;
120 static inline int armv7_pmnc_select_counter(unsigned int cnt)
122         u32 val;
124         if ((cnt == CCNT) || (cnt >= CNTMAX)) {
125                 pr_err("gator: CPU%u selecting wrong PMNC counter %d\n", smp_processor_id(), cnt);
126                 return -1;
127         }
129         val = (cnt - CNT0);
130         asm volatile("mcr p15, 0, %0, c9, c12, 5" : : "r" (val));
132         return cnt;
135 static inline void armv7_pmnc_write_evtsel(unsigned int cnt, u32 val)
137         if (armv7_pmnc_select_counter(cnt) == cnt) {
138                 asm volatile("mcr p15, 0, %0, c9, c13, 1" : : "r" (val));
139         }
142 static void armv7_pmnc_reset_counter(unsigned int cnt)
144         u32 val = 0;
146         if (cnt == CCNT) {
147                 armv7_pmnc_disable_counter(cnt);
149                 asm volatile("mcr p15, 0, %0, c9, c13, 0" : : "r" (val));
151                 if (pmnc_enabled[cnt] != 0)
152                     armv7_pmnc_enable_counter(cnt);
154         } else if (cnt >= CNTMAX) {
155                 pr_err("gator: CPU%u resetting wrong PMNC counter %d\n", smp_processor_id(), cnt);
156         } else {
157                 armv7_pmnc_disable_counter(cnt);
159                 if (armv7_pmnc_select_counter(cnt) == cnt)
160                     asm volatile("mcr p15, 0, %0, c9, c13, 2" : : "r" (val));
162                 if (pmnc_enabled[cnt] != 0)
163                     armv7_pmnc_enable_counter(cnt);
164         }
167 static int gator_events_armv7_create_files(struct super_block *sb, struct dentry *root)
169         struct dentry *dir;
170         int i;
172         for (i = 0; i < pmnc_count; i++) {
173                 char buf[40];
174                 if (i == 0) {
175                         snprintf(buf, sizeof buf, "ARM_%s_ccnt", pmnc_name);
176                 } else {
177                         snprintf(buf, sizeof buf, "ARM_%s_cnt%d", pmnc_name, i-1);
178                 }
179                 dir = gatorfs_mkdir(sb, root, buf);
180                 if (!dir) {
181                         return -1;
182                 }
183                 gatorfs_create_ulong(sb, dir, "enabled", &pmnc_enabled[i]);
184                 if (i > 0) {
185                         gatorfs_create_ulong(sb, dir, "event", &pmnc_event[i]);
186                 }
187                 gatorfs_create_ro_ulong(sb, dir, "key", &pmnc_key[i]);
188         }
190         return 0;
193 static void gator_events_armv7_online(void)
195         unsigned int cnt;
196         int cpu = smp_processor_id();
198         if (armv7_pmnc_read() & PMNC_E) {
199                 armv7_pmnc_write(armv7_pmnc_read() & ~PMNC_E);
200         }
202         // Initialize & Reset PMNC: C bit and P bit
203         armv7_pmnc_write(PMNC_P | PMNC_C);
205         for (cnt = CCNT; cnt < CNTMAX; cnt++) {
206                 unsigned long event;
208                 per_cpu(perfPrev, cpu)[cnt] = 0;
210                 if (!pmnc_enabled[cnt])
211                         continue;
213                 // Disable counter
214                 armv7_pmnc_disable_counter(cnt);
216                 event = pmnc_event[cnt] & 255;
218                 // Set event (if destined for PMNx counters), we don't need to set the event if it's a cycle count
219                 if (cnt != CCNT)
220                         armv7_pmnc_write_evtsel(cnt, event);
222                 // Reset counter
223                 armv7_pmnc_reset_counter(cnt);
225                 // Enable counter, but do not enable interrupt for this counter
226                 armv7_pmnc_enable_counter(cnt);
227         }
229         // enable
230         armv7_pmnc_write(armv7_pmnc_read() | PMNC_E);
233 static void gator_events_armv7_offline(void)
235         armv7_pmnc_write(armv7_pmnc_read() & ~PMNC_E);
238 static void gator_events_armv7_stop(void)
240         unsigned int cnt;
242         for (cnt = CCNT; cnt < CNTMAX; cnt++) {
243                 pmnc_enabled[cnt] = 0;
244                 pmnc_event[cnt] = 0;
245         }
248 static int gator_events_armv7_read(int **buffer)
250         int cnt, len = 0;
251         int cpu = smp_processor_id();
253         if (!pmnc_count)
254                 return 0;
256         for (cnt = 0; cnt < pmnc_count; cnt++) {
257                 if (pmnc_enabled[cnt]) {
258                         int value;
259                         if (cnt == CCNT) {
260                                 value = armv7_ccnt_read();
261                         } else {
262                                 value = armv7_cntn_read(cnt);
263                         }
264                         if (value != per_cpu(perfPrev, cpu)[cnt]) {
265                                 per_cpu(perfPrev, cpu)[cnt] = value;
266                                 per_cpu(perfCnt, cpu)[len++] = pmnc_key[cnt];
267                                 per_cpu(perfCnt, cpu)[len++] = value;
268                         }
269                 }
270         }
272         // update or discard
273         if (buffer)
274                 *buffer = per_cpu(perfCnt, cpu);
276         return len;
279 static struct gator_interface gator_events_armv7_interface = {
280         .create_files = gator_events_armv7_create_files,
281         .stop = gator_events_armv7_stop,
282         .online = gator_events_armv7_online,
283         .offline = gator_events_armv7_offline,
284         .read = gator_events_armv7_read,
285 };
287 int gator_events_armv7_init(void)
289         unsigned int cnt;
291         switch (gator_cpuid()) {
292         case CORTEX_A5:
293                 pmnc_name = "Cortex-A5";
294                 pmnc_count = 2;
295                 break;
296         case CORTEX_A8:
297                 pmnc_name = "Cortex-A8";
298                 pmnc_count = 4;
299                 break;
300         case CORTEX_A9:
301                 pmnc_name = "Cortex-A9";
302                 pmnc_count = 6;
303                 break;
304         case CORTEX_A15:
305                 pmnc_name = "Cortex-A15";
306                 pmnc_count = 6;
307                 break;
308         default:
309                 return -1;
310         }
312         pmnc_count++; // CNT[n] + CCNT
314         for (cnt = CCNT; cnt < CNTMAX; cnt++) {
315                 pmnc_enabled[cnt] = 0;
316                 pmnc_event[cnt] = 0;
317                 pmnc_key[cnt] = gator_events_get_key();
318         }
320         return gator_events_install(&gator_events_armv7_interface);
322 gator_events_init(gator_events_armv7_init);