[deliverable/linux.git] / arch / avr32 / kernel / ocd.c

/*
 * Copyright (C) 2007 Atmel Corporation
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 */
#include <linux/init.h>
#include <linux/sched.h>
#include <linux/spinlock.h>

#include <asm/ocd.h>

static long ocd_count;
static spinlock_t ocd_lock;

/**
 * ocd_enable - enable on-chip debugging
 * @child: task to be debugged
 *
 * If @child is non-NULL, ocd_enable() first checks if debugging has
 * already been enabled for @child, and if it has, does nothing.
 *
 * If @child is NULL (e.g. when debugging the kernel), or debugging
 * has not already been enabled for it, ocd_enable() increments the
 * reference count and enables the debugging hardware.
 */
void ocd_enable(struct task_struct *child)
{
	u32 dc;

	if (child)
		pr_debug("ocd_enable: child=%s [%u]\n",
				child->comm, child->pid);
	else
		pr_debug("ocd_enable (no child)\n");

	if (!child || !test_and_set_tsk_thread_flag(child, TIF_DEBUG)) {
		spin_lock(&ocd_lock);
		ocd_count++;
		dc = ocd_read(DC);
		dc |= (1 << OCD_DC_MM_BIT) | (1 << OCD_DC_DBE_BIT);
		ocd_write(DC, dc);
		spin_unlock(&ocd_lock);
	}
}

/**
 * ocd_disable - disable on-chip debugging
 * @child: task that was being debugged, but isn't anymore
 *
 * If @child is non-NULL, ocd_disable() checks if debugging is enabled
 * for @child, and if it isn't, does nothing.
 *
 * If @child is NULL (e.g. when debugging the kernel), or debugging is
 * enabled, ocd_disable() decrements the reference count, and if it
 * reaches zero, disables the debugging hardware.
 */
void ocd_disable(struct task_struct *child)
{
	u32 dc;

	if (!child)
		pr_debug("ocd_disable (no child)\n");
	else if (test_tsk_thread_flag(child, TIF_DEBUG))
		pr_debug("ocd_disable: child=%s [%u]\n",
				child->comm, child->pid);

	if (!child || test_and_clear_tsk_thread_flag(child, TIF_DEBUG)) {
		spin_lock(&ocd_lock);
		ocd_count--;

		WARN_ON(ocd_count < 0);

		if (ocd_count <= 0) {
			dc = ocd_read(DC);
			dc &= ~((1 << OCD_DC_MM_BIT) | (1 << OCD_DC_DBE_BIT));
			ocd_write(DC, dc);
		}
		spin_unlock(&ocd_lock);
	}
}

#ifdef CONFIG_DEBUG_FS
#include <linux/debugfs.h>
#include <linux/module.h>

static struct dentry *ocd_debugfs_root;
static struct dentry *ocd_debugfs_DC;
static struct dentry *ocd_debugfs_DS;
static struct dentry *ocd_debugfs_count;

static int ocd_DC_get(void *data, u64 *val)
{
	*val = ocd_read(DC);
	return 0;
}
static int ocd_DC_set(void *data, u64 val)
{
	ocd_write(DC, val);
	return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(fops_DC, ocd_DC_get, ocd_DC_set, "0x%08llx\n");

static int ocd_DS_get(void *data, u64 *val)
{
	*val = ocd_read(DS);
	return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(fops_DS, ocd_DS_get, NULL, "0x%08llx\n");

static int ocd_count_get(void *data, u64 *val)
{
	*val = ocd_count;
	return 0;
}
DEFINE_SIMPLE_ATTRIBUTE(fops_count, ocd_count_get, NULL, "%lld\n");

static void ocd_debugfs_init(void)
{
	struct dentry *root;

	root = debugfs_create_dir("ocd", NULL);
	if (IS_ERR(root) || !root)
		goto err_root;
	ocd_debugfs_root = root;

	ocd_debugfs_DC = debugfs_create_file("DC", S_IRUSR | S_IWUSR,
				root, NULL, &fops_DC);
	if (!ocd_debugfs_DC)
		goto err_DC;

	ocd_debugfs_DS = debugfs_create_file("DS", S_IRUSR, root,
				NULL, &fops_DS);
	if (!ocd_debugfs_DS)
		goto err_DS;

	ocd_debugfs_count = debugfs_create_file("count", S_IRUSR, root,
				NULL, &fops_count);
	if (!ocd_debugfs_count)
		goto err_count;

	return;

err_count:
	debugfs_remove(ocd_debugfs_DS);
err_DS:
	debugfs_remove(ocd_debugfs_DC);
err_DC:
	debugfs_remove(ocd_debugfs_root);
err_root:
	printk(KERN_WARNING "OCD: Failed to create debugfs entries\n");
}
#else
static inline void ocd_debugfs_init(void)
{

}
#endif

static int __init ocd_init(void)
{
	spin_lock_init(&ocd_lock);
	ocd_debugfs_init();
	return 0;
}
arch_initcall(ocd_init);
Commit	Line	Data
13b54a50 HS	1	/*
	2	* Copyright (C) 2007 Atmel Corporation
	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	*/
	8	#include <linux/init.h>
	9	#include <linux/sched.h>
	10	#include <linux/spinlock.h>
	11
	12	#include <asm/ocd.h>
	13
	14	static long ocd_count;
	15	static spinlock_t ocd_lock;
	16
	17	/**
	18	* ocd_enable - enable on-chip debugging
	19	* @child: task to be debugged
	20	*
	21	* If @child is non-NULL, ocd_enable() first checks if debugging has
	22	* already been enabled for @child, and if it has, does nothing.
	23	*
	24	* If @child is NULL (e.g. when debugging the kernel), or debugging
	25	* has not already been enabled for it, ocd_enable() increments the
	26	* reference count and enables the debugging hardware.
	27	*/
	28	void ocd_enable(struct task_struct *child)
	29	{
	30	u32 dc;
	31
	32	if (child)
	33	pr_debug("ocd_enable: child=%s [%u]\n",
	34	child->comm, child->pid);
	35	else
	36	pr_debug("ocd_enable (no child)\n");
	37
	38	if (!child \|\| !test_and_set_tsk_thread_flag(child, TIF_DEBUG)) {
	39	spin_lock(&ocd_lock);
	40	ocd_count++;
	41	dc = ocd_read(DC);
	42	dc \|= (1 << OCD_DC_MM_BIT) \| (1 << OCD_DC_DBE_BIT);
	43	ocd_write(DC, dc);
	44	spin_unlock(&ocd_lock);
	45	}
	46	}
	47
	48	/**
	49	* ocd_disable - disable on-chip debugging
	50	* @child: task that was being debugged, but isn't anymore
	51	*
	52	* If @child is non-NULL, ocd_disable() checks if debugging is enabled
	53	* for @child, and if it isn't, does nothing.
	54	*
	55	* If @child is NULL (e.g. when debugging the kernel), or debugging is
	56	* enabled, ocd_disable() decrements the reference count, and if it
	57	* reaches zero, disables the debugging hardware.
	58	*/
	59	void ocd_disable(struct task_struct *child)
	60	{
	61	u32 dc;
	62
	63	if (!child)
	64	pr_debug("ocd_disable (no child)\n");
65	else if (test_tsk_thread_flag(child, TIF_DEBUG))
66	pr_debug("ocd_disable: child=%s [%u]\n",
67	child->comm, child->pid);
68
69	if (!child \|\| test_and_clear_tsk_thread_flag(child, TIF_DEBUG)) {
70	spin_lock(&ocd_lock);
71	ocd_count--;
72
73	WARN_ON(ocd_count < 0);
74
75	if (ocd_count <= 0) {
76	dc = ocd_read(DC);
77	dc &= ~((1 << OCD_DC_MM_BIT) \| (1 << OCD_DC_DBE_BIT));
78	ocd_write(DC, dc);
79	}
80	spin_unlock(&ocd_lock);
81	}
82	}
83
84	#ifdef CONFIG_DEBUG_FS
85	#include <linux/debugfs.h>
86	#include <linux/module.h>
87
88	static struct dentry *ocd_debugfs_root;
89	static struct dentry *ocd_debugfs_DC;
90	static struct dentry *ocd_debugfs_DS;
91	static struct dentry *ocd_debugfs_count;
92
8b88b099	93	static int ocd_DC_get(void data, u64 val)
13b54a50	94	{
8b88b099 CH	95	*val = ocd_read(DC);
8b88b099 CH	96	return 0;
13b54a50	97	}
8b88b099	98	static int ocd_DC_set(void *data, u64 val)
13b54a50 HS	99	{
13b54a50 HS	100	ocd_write(DC, val);
8b88b099	101	return 0;
13b54a50 HS	102	}
	103	DEFINE_SIMPLE_ATTRIBUTE(fops_DC, ocd_DC_get, ocd_DC_set, "0x%08llx\n");
	104
8b88b099	105	static int ocd_DS_get(void data, u64 val)
13b54a50	106	{
8b88b099 CH	107	*val = ocd_read(DS);
8b88b099 CH	108	return 0;
13b54a50 HS	109	}
	110	DEFINE_SIMPLE_ATTRIBUTE(fops_DS, ocd_DS_get, NULL, "0x%08llx\n");
	111
8b88b099	112	static int ocd_count_get(void data, u64 val)
13b54a50	113	{
8b88b099 CH	114	*val = ocd_count;
8b88b099 CH	115	return 0;
13b54a50 HS	116	}
	117	DEFINE_SIMPLE_ATTRIBUTE(fops_count, ocd_count_get, NULL, "%lld\n");
	118
	119	static void ocd_debugfs_init(void)
	120	{
	121	struct dentry *root;
	122
	123	root = debugfs_create_dir("ocd", NULL);
	124	if (IS_ERR(root) \|\| !root)
	125	goto err_root;
	126	ocd_debugfs_root = root;
	127
	128	ocd_debugfs_DC = debugfs_create_file("DC", S_IRUSR \| S_IWUSR,
	129	root, NULL, &fops_DC);
	130	if (!ocd_debugfs_DC)
	131	goto err_DC;
	132
	133	ocd_debugfs_DS = debugfs_create_file("DS", S_IRUSR, root,
	134	NULL, &fops_DS);
	135	if (!ocd_debugfs_DS)
	136	goto err_DS;
	137
	138	ocd_debugfs_count = debugfs_create_file("count", S_IRUSR, root,
	139	NULL, &fops_count);
	140	if (!ocd_debugfs_count)
	141	goto err_count;
	142
	143	return;
	144
	145	err_count:
	146	debugfs_remove(ocd_debugfs_DS);
	147	err_DS:
	148	debugfs_remove(ocd_debugfs_DC);
	149	err_DC:
	150	debugfs_remove(ocd_debugfs_root);
	151	err_root:
	152	printk(KERN_WARNING "OCD: Failed to create debugfs entries\n");
	153	}
	154	#else
	155	static inline void ocd_debugfs_init(void)
	156	{
	157
	158	}
	159	#endif
	160
	161	static int __init ocd_init(void)
	162	{
	163	spin_lock_init(&ocd_lock);
	164	ocd_debugfs_init();
	165	return 0;
	166	}
	167	arch_initcall(ocd_init);