[Blackfin] arch: __FUNCTION__ is gcc-specific, use __func__
[linux-2.6.git] / arch / blackfin / oprofile / common.c
1 /*
2  * File:         arch/blackfin/oprofile/common.c
3  * Based on:     arch/alpha/oprofile/common.c
4  * Author:       Anton Blanchard <anton@au.ibm.com>
5  *
6  * Created:
7  * Description:
8  *
9  * Modified:
10  *               Copyright (C) 2004 Anton Blanchard <anton@au.ibm.com>, IBM
11  *               Copyright 2004-2006 Analog Devices Inc.
12  *
13  * Bugs:         Enter bugs at http://blackfin.uclinux.org/
14  *
15  * This program is free software; you can redistribute it and/or modify
16  * it under the terms of the GNU General Public License as published by
17  * the Free Software Foundation; either version 2 of the License, or
18  * (at your option) any later version.
19  *
20  * This program is distributed in the hope that it will be useful,
21  * but WITHOUT ANY WARRANTY; without even the implied warranty of
22  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
23  * GNU General Public License for more details.
24  *
25  * You should have received a copy of the GNU General Public License
26  * along with this program; if not, see the file COPYING, or write
27  * to the Free Software Foundation, Inc.,
28  * 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
29  */
30
31 #include <linux/oprofile.h>
32 #include <linux/init.h>
33 #include <linux/smp.h>
34 #include <linux/errno.h>
35 #include <linux/mutex.h>
36 #include <linux/ptrace.h>
37 #include <linux/irq.h>
38 #include <linux/io.h>
39
40 #include <asm/system.h>
41 #include <asm/blackfin.h>
42
43 #include "op_blackfin.h"
44
45 #define BFIN_533_ID  0xE5040003
46 #define BFIN_537_ID  0xE5040002
47
48 static int pfmon_enabled;
49 static struct mutex pfmon_lock;
50
51 struct op_bfin533_model *model;
52
53 struct op_counter_config ctr[OP_MAX_COUNTER];
54
55 static int op_bfin_setup(void)
56 {
57         int ret;
58
59         /* Pre-compute the values to stuff in the hardware registers.  */
60         spin_lock(&oprofilefs_lock);
61         ret = model->reg_setup(ctr);
62         spin_unlock(&oprofilefs_lock);
63
64         return ret;
65 }
66
67 static void op_bfin_shutdown(void)
68 {
69 #if 0
70         /* what is the difference between shutdown and stop? */
71 #endif
72 }
73
74 static int op_bfin_start(void)
75 {
76         int ret = -EBUSY;
77
78         printk(KERN_INFO "KSDBG:in %s\n", __func__);
79         mutex_lock(&pfmon_lock);
80         if (!pfmon_enabled) {
81                 ret = model->start(ctr);
82                 pfmon_enabled = !ret;
83         }
84         mutex_unlock(&pfmon_lock);
85
86         return ret;
87 }
88
89 static void op_bfin_stop(void)
90 {
91         mutex_lock(&pfmon_lock);
92         if (pfmon_enabled) {
93                 model->stop();
94                 pfmon_enabled = 0;
95         }
96         mutex_unlock(&pfmon_lock);
97 }
98
99 static int op_bfin_create_files(struct super_block *sb, struct dentry *root)
100 {
101         int i;
102
103         for (i = 0; i < model->num_counters; ++i) {
104                 struct dentry *dir;
105                 char buf[3];
106                 printk(KERN_INFO "Oprofile: creating files... \n");
107
108                 snprintf(buf, sizeof buf, "%d", i);
109                 dir = oprofilefs_mkdir(sb, root, buf);
110
111                 oprofilefs_create_ulong(sb, dir, "enabled", &ctr[i].enabled);
112                 oprofilefs_create_ulong(sb, dir, "event", &ctr[i].event);
113                 oprofilefs_create_ulong(sb, dir, "count", &ctr[i].count);
114                 /*
115                  * We dont support per counter user/kernel selection, but
116                  * we leave the entries because userspace expects them
117                  */
118                 oprofilefs_create_ulong(sb, dir, "kernel", &ctr[i].kernel);
119                 oprofilefs_create_ulong(sb, dir, "user", &ctr[i].user);
120                 oprofilefs_create_ulong(sb, dir, "unit_mask",
121                                         &ctr[i].unit_mask);
122         }
123
124         return 0;
125 }
126 int __init oprofile_arch_init(struct oprofile_operations *ops)
127 {
128 #ifdef CONFIG_HARDWARE_PM
129         unsigned int dspid;
130
131         mutex_init(&pfmon_lock);
132
133         dspid = bfin_read_DSPID();
134
135         printk(KERN_INFO "Oprofile got the cpu id is 0x%x. \n", dspid);
136
137         switch (dspid) {
138         case BFIN_533_ID:
139                 model = &op_model_bfin533;
140                 model->num_counters = 2;
141                 break;
142         case BFIN_537_ID:
143                 model = &op_model_bfin533;
144                 model->num_counters = 2;
145                 break;
146         default:
147                 return -ENODEV;
148         }
149
150         ops->cpu_type = model->name;
151         ops->create_files = op_bfin_create_files;
152         ops->setup = op_bfin_setup;
153         ops->shutdown = op_bfin_shutdown;
154         ops->start = op_bfin_start;
155         ops->stop = op_bfin_stop;
156
157         printk(KERN_INFO "oprofile: using %s performance monitoring.\n",
158                ops->cpu_type);
159
160         return 0;
161 #else
162         return -1;
163 #endif
164 }
165
166 void oprofile_arch_exit(void)
167 {
168 }