c4f023294d750659e992b93afc1d22ca456065f6
[linux-2.6.git] / arch / avr32 / kernel / ocd.c
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
93 static u64 ocd_DC_get(void *data)
94 {
95         return ocd_read(DC);
96 }
97 static void ocd_DC_set(void *data, u64 val)
98 {
99         ocd_write(DC, val);
100 }
101 DEFINE_SIMPLE_ATTRIBUTE(fops_DC, ocd_DC_get, ocd_DC_set, "0x%08llx\n");
102
103 static u64 ocd_DS_get(void *data)
104 {
105         return ocd_read(DS);
106 }
107 DEFINE_SIMPLE_ATTRIBUTE(fops_DS, ocd_DS_get, NULL, "0x%08llx\n");
108
109 static u64 ocd_count_get(void *data)
110 {
111         return ocd_count;
112 }
113 DEFINE_SIMPLE_ATTRIBUTE(fops_count, ocd_count_get, NULL, "%lld\n");
114
115 static void ocd_debugfs_init(void)
116 {
117         struct dentry *root;
118
119         root = debugfs_create_dir("ocd", NULL);
120         if (IS_ERR(root) || !root)
121                 goto err_root;
122         ocd_debugfs_root = root;
123
124         ocd_debugfs_DC = debugfs_create_file("DC", S_IRUSR | S_IWUSR,
125                                 root, NULL, &fops_DC);
126         if (!ocd_debugfs_DC)
127                 goto err_DC;
128
129         ocd_debugfs_DS = debugfs_create_file("DS", S_IRUSR, root,
130                                 NULL, &fops_DS);
131         if (!ocd_debugfs_DS)
132                 goto err_DS;
133
134         ocd_debugfs_count = debugfs_create_file("count", S_IRUSR, root,
135                                 NULL, &fops_count);
136         if (!ocd_debugfs_count)
137                 goto err_count;
138
139         return;
140
141 err_count:
142         debugfs_remove(ocd_debugfs_DS);
143 err_DS:
144         debugfs_remove(ocd_debugfs_DC);
145 err_DC:
146         debugfs_remove(ocd_debugfs_root);
147 err_root:
148         printk(KERN_WARNING "OCD: Failed to create debugfs entries\n");
149 }
150 #else
151 static inline void ocd_debugfs_init(void)
152 {
153
154 }
155 #endif
156
157 static int __init ocd_init(void)
158 {
159         spin_lock_init(&ocd_lock);
160         ocd_debugfs_init();
161         return 0;
162 }
163 arch_initcall(ocd_init);