[deliverable/linux.git] / arch / arm / oprofile / common.c

/**
 * @file common.c
 *
 * @remark Copyright 2004 Oprofile Authors
 * @remark Read the file COPYING
 *
 * @author Zwane Mwaikambo
 */

#include <linux/init.h>
#include <linux/oprofile.h>
#include <linux/errno.h>
#include <linux/sysdev.h>
#include <asm/semaphore.h>

#include "op_counter.h"
#include "op_arm_model.h"

static struct op_arm_model_spec *op_arm_model;
static int op_arm_enabled;
static struct semaphore op_arm_sem;

struct op_counter_config counter_config[OP_MAX_COUNTER];

static int op_arm_create_files(struct super_block *sb, struct dentry *root)
{
	unsigned int i;

	for (i = 0; i < op_arm_model->num_counters; i++) {
		struct dentry *dir;
		char buf[2];

		snprintf(buf, sizeof buf, "%d", i);
		dir = oprofilefs_mkdir(sb, root, buf);
		oprofilefs_create_ulong(sb, dir, "enabled", &counter_config[i].enabled);
		oprofilefs_create_ulong(sb, dir, "event", &counter_config[i].event);
		oprofilefs_create_ulong(sb, dir, "count", &counter_config[i].count);
		oprofilefs_create_ulong(sb, dir, "unit_mask", &counter_config[i].unit_mask);
		oprofilefs_create_ulong(sb, dir, "kernel", &counter_config[i].kernel);
		oprofilefs_create_ulong(sb, dir, "user", &counter_config[i].user);
	}

	return 0;
}

static int op_arm_setup(void)
{
	int ret;

	spin_lock(&oprofilefs_lock);
	ret = op_arm_model->setup_ctrs();
	spin_unlock(&oprofilefs_lock);
	return ret;
}

static int op_arm_start(void)
{
	int ret = -EBUSY;

	down(&op_arm_sem);
	if (!op_arm_enabled) {
		ret = op_arm_model->start();
		op_arm_enabled = !ret;
	}
	up(&op_arm_sem);
	return ret;
}

static void op_arm_stop(void)
{
	down(&op_arm_sem);
	if (op_arm_enabled)
		op_arm_model->stop();
	op_arm_enabled = 0;
	up(&op_arm_sem);
}

#ifdef CONFIG_PM
static int op_arm_suspend(struct sys_device *dev, pm_message_t state)
{
	down(&op_arm_sem);
	if (op_arm_enabled)
		op_arm_model->stop();
	up(&op_arm_sem);
	return 0;
}

static int op_arm_resume(struct sys_device *dev)
{
	down(&op_arm_sem);
	if (op_arm_enabled && op_arm_model->start())
		op_arm_enabled = 0;
	up(&op_arm_sem);
	return 0;
}

static struct sysdev_class oprofile_sysclass = {
	set_kset_name("oprofile"),
	.resume		= op_arm_resume,
	.suspend	= op_arm_suspend,
};

static struct sys_device device_oprofile = {
	.id		= 0,
	.cls		= &oprofile_sysclass,
};

static int __init init_driverfs(void)
{
	int ret;

	if (!(ret = sysdev_class_register(&oprofile_sysclass)))
		ret = sysdev_register(&device_oprofile);

	return ret;
}

static void  exit_driverfs(void)
{
	sysdev_unregister(&device_oprofile);
	sysdev_class_unregister(&oprofile_sysclass);
}
#else
#define init_driverfs()	do { } while (0)
#define exit_driverfs() do { } while (0)
#endif /* CONFIG_PM */

int __init op_arm_init(struct oprofile_operations *ops, struct op_arm_model_spec *spec)
{
	init_MUTEX(&op_arm_sem);

	if (spec->init() < 0)
		return -ENODEV;

	op_arm_model = spec;
	init_driverfs();
	ops->create_files = op_arm_create_files;
	ops->setup = op_arm_setup;
	ops->shutdown = op_arm_stop;
	ops->start = op_arm_start;
	ops->stop = op_arm_stop;
	ops->cpu_type = op_arm_model->name;
	printk(KERN_INFO "oprofile: using %s\n", spec->name);

	return 0;
}

void op_arm_exit(void)
{
	if (op_arm_model) {
		exit_driverfs();
		op_arm_model = NULL;
	}
}
Commit	Line	Data
1da177e4 LT	1	/**
	2	* @file common.c
	3	*
	4	* @remark Copyright 2004 Oprofile Authors
	5	* @remark Read the file COPYING
	6	*
	7	* @author Zwane Mwaikambo
	8	*/
	9
	10	#include <linux/init.h>
	11	#include <linux/oprofile.h>
	12	#include <linux/errno.h>
1da177e4	13	#include <linux/sysdev.h>
b5893c56	14	#include <asm/semaphore.h>
1da177e4 LT	15
	16	#include "op_counter.h"
	17	#include "op_arm_model.h"
	18
55f05234 RK	19	static struct op_arm_model_spec *op_arm_model;
	20	static int op_arm_enabled;
	21	static struct semaphore op_arm_sem;
1da177e4	22
1da177e4 LT	23	struct op_counter_config counter_config[OP_MAX_COUNTER];
1da177e4 LT	24
55f05234	25	static int op_arm_create_files(struct super_block sb, struct dentry root)
1da177e4 LT	26	{
	27	unsigned int i;
	28
55f05234	29	for (i = 0; i < op_arm_model->num_counters; i++) {
1da177e4 LT	30	struct dentry *dir;
	31	char buf[2];
	32
	33	snprintf(buf, sizeof buf, "%d", i);
	34	dir = oprofilefs_mkdir(sb, root, buf);
	35	oprofilefs_create_ulong(sb, dir, "enabled", &counter_config[i].enabled);
	36	oprofilefs_create_ulong(sb, dir, "event", &counter_config[i].event);
	37	oprofilefs_create_ulong(sb, dir, "count", &counter_config[i].count);
	38	oprofilefs_create_ulong(sb, dir, "unit_mask", &counter_config[i].unit_mask);
	39	oprofilefs_create_ulong(sb, dir, "kernel", &counter_config[i].kernel);
	40	oprofilefs_create_ulong(sb, dir, "user", &counter_config[i].user);
	41	}
	42
	43	return 0;
	44	}
	45
55f05234	46	static int op_arm_setup(void)
1da177e4 LT	47	{
	48	int ret;
	49
	50	spin_lock(&oprofilefs_lock);
55f05234	51	ret = op_arm_model->setup_ctrs();
1da177e4 LT	52	spin_unlock(&oprofilefs_lock);
	53	return ret;
	54	}
	55
55f05234	56	static int op_arm_start(void)
1da177e4 LT	57	{
	58	int ret = -EBUSY;
	59
55f05234 RK	60	down(&op_arm_sem);
	61	if (!op_arm_enabled) {
	62	ret = op_arm_model->start();
	63	op_arm_enabled = !ret;
1da177e4	64	}
55f05234	65	up(&op_arm_sem);
1da177e4 LT	66	return ret;
	67	}
	68
55f05234	69	static void op_arm_stop(void)
1da177e4	70	{
55f05234 RK	71	down(&op_arm_sem);
	72	if (op_arm_enabled)
	73	op_arm_model->stop();
	74	op_arm_enabled = 0;
	75	up(&op_arm_sem);
1da177e4 LT	76	}
1da177e4 LT	77
b5893c56	78	#ifdef CONFIG_PM
55f05234	79	static int op_arm_suspend(struct sys_device *dev, pm_message_t state)
b5893c56	80	{
55f05234 RK	81	down(&op_arm_sem);
	82	if (op_arm_enabled)
	83	op_arm_model->stop();
	84	up(&op_arm_sem);
b5893c56 RK	85	return 0;
	86	}
	87
55f05234	88	static int op_arm_resume(struct sys_device *dev)
b5893c56	89	{
55f05234 RK	90	down(&op_arm_sem);
	91	if (op_arm_enabled && op_arm_model->start())
	92	op_arm_enabled = 0;
	93	up(&op_arm_sem);
b5893c56 RK	94	return 0;
	95	}
	96
	97	static struct sysdev_class oprofile_sysclass = {
	98	set_kset_name("oprofile"),
55f05234 RK	99	.resume = op_arm_resume,
55f05234 RK	100	.suspend = op_arm_suspend,
b5893c56 RK	101	};
	102
	103	static struct sys_device device_oprofile = {
	104	.id = 0,
	105	.cls = &oprofile_sysclass,
	106	};
	107
	108	static int __init init_driverfs(void)
	109	{
	110	int ret;
	111
	112	if (!(ret = sysdev_class_register(&oprofile_sysclass)))
	113	ret = sysdev_register(&device_oprofile);
	114
	115	return ret;
	116	}
	117
	118	static void exit_driverfs(void)
	119	{
	120	sysdev_unregister(&device_oprofile);
	121	sysdev_class_unregister(&oprofile_sysclass);
	122	}
	123	#else
	124	#define init_driverfs() do { } while (0)
	125	#define exit_driverfs() do { } while (0)
	126	#endif /* CONFIG_PM */
	127
55f05234	128	int __init op_arm_init(struct oprofile_operations ops, struct op_arm_model_spec spec)
1da177e4	129	{
55f05234	130	init_MUTEX(&op_arm_sem);
1da177e4 LT	131
	132	if (spec->init() < 0)
	133	return -ENODEV;
	134
55f05234	135	op_arm_model = spec;
1da177e4	136	init_driverfs();
55f05234 RK	137	ops->create_files = op_arm_create_files;
	138	ops->setup = op_arm_setup;
	139	ops->shutdown = op_arm_stop;
	140	ops->start = op_arm_start;
	141	ops->stop = op_arm_stop;
	142	ops->cpu_type = op_arm_model->name;
	143	printk(KERN_INFO "oprofile: using %s\n", spec->name);
1da177e4 LT	144
	145	return 0;
	146	}
	147
55f05234	148	void op_arm_exit(void)
1da177e4	149	{
55f05234	150	if (op_arm_model) {
1da177e4	151	exit_driverfs();
55f05234	152	op_arm_model = NULL;
1da177e4 LT	153	}
	154	}
	155