intel-iommu: Fix enabling snooping feature by mistake
[linux-2.6.git] / drivers / char / bfin_jtag_comm.c
1 /*
2  * TTY over Blackfin JTAG Communication
3  *
4  * Copyright 2008-2009 Analog Devices Inc.
5  *
6  * Enter bugs at http://blackfin.uclinux.org/
7  *
8  * Licensed under the GPL-2 or later.
9  */
10
11 #define DRV_NAME "bfin-jtag-comm"
12 #define DEV_NAME "ttyBFJC"
13 #define pr_fmt(fmt) DRV_NAME ": " fmt
14
15 #include <linux/circ_buf.h>
16 #include <linux/console.h>
17 #include <linux/delay.h>
18 #include <linux/err.h>
19 #include <linux/kernel.h>
20 #include <linux/kthread.h>
21 #include <linux/module.h>
22 #include <linux/mutex.h>
23 #include <linux/sched.h>
24 #include <linux/tty.h>
25 #include <linux/tty_driver.h>
26 #include <linux/tty_flip.h>
27 #include <asm/atomic.h>
28
29 #define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })
30
31 /* See the Debug/Emulation chapter in the HRM */
32 #define EMUDOF   0x00000001     /* EMUDAT_OUT full & valid */
33 #define EMUDIF   0x00000002     /* EMUDAT_IN full & valid */
34 #define EMUDOOVF 0x00000004     /* EMUDAT_OUT overflow */
35 #define EMUDIOVF 0x00000008     /* EMUDAT_IN overflow */
36
37 static inline uint32_t bfin_write_emudat(uint32_t emudat)
38 {
39         __asm__ __volatile__("emudat = %0;" : : "d"(emudat));
40         return emudat;
41 }
42
43 static inline uint32_t bfin_read_emudat(void)
44 {
45         uint32_t emudat;
46         __asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
47         return emudat;
48 }
49
50 static inline uint32_t bfin_write_emudat_chars(char a, char b, char c, char d)
51 {
52         return bfin_write_emudat((a << 0) | (b << 8) | (c << 16) | (d << 24));
53 }
54
55 #define CIRC_SIZE 2048  /* see comment in tty_io.c:do_tty_write() */
56 #define CIRC_MASK (CIRC_SIZE - 1)
57 #define circ_empty(circ)     ((circ)->head == (circ)->tail)
58 #define circ_free(circ)      CIRC_SPACE((circ)->head, (circ)->tail, CIRC_SIZE)
59 #define circ_cnt(circ)       CIRC_CNT((circ)->head, (circ)->tail, CIRC_SIZE)
60 #define circ_byte(circ, idx) ((circ)->buf[(idx) & CIRC_MASK])
61
62 static struct tty_driver *bfin_jc_driver;
63 static struct task_struct *bfin_jc_kthread;
64 static struct tty_struct * volatile bfin_jc_tty;
65 static unsigned long bfin_jc_count;
66 static DEFINE_MUTEX(bfin_jc_tty_mutex);
67 static volatile struct circ_buf bfin_jc_write_buf;
68
69 static int
70 bfin_jc_emudat_manager(void *arg)
71 {
72         uint32_t inbound_len = 0, outbound_len = 0;
73
74         while (!kthread_should_stop()) {
75                 /* no one left to give data to, so sleep */
76                 if (bfin_jc_tty == NULL && circ_empty(&bfin_jc_write_buf)) {
77                         pr_debug("waiting for readers\n");
78                         __set_current_state(TASK_UNINTERRUPTIBLE);
79                         schedule();
80                         __set_current_state(TASK_RUNNING);
81                 }
82
83                 /* no data available, so just chill */
84                 if (!(bfin_read_DBGSTAT() & EMUDIF) && circ_empty(&bfin_jc_write_buf)) {
85                         pr_debug("waiting for data (in_len = %i) (circ: %i %i)\n",
86                                 inbound_len, bfin_jc_write_buf.tail, bfin_jc_write_buf.head);
87                         if (inbound_len)
88                                 schedule();
89                         else
90                                 schedule_timeout_interruptible(HZ);
91                         continue;
92                 }
93
94                 /* if incoming data is ready, eat it */
95                 if (bfin_read_DBGSTAT() & EMUDIF) {
96                         struct tty_struct *tty;
97                         mutex_lock(&bfin_jc_tty_mutex);
98                         tty = (struct tty_struct *)bfin_jc_tty;
99                         if (tty != NULL) {
100                                 uint32_t emudat = bfin_read_emudat();
101                                 if (inbound_len == 0) {
102                                         pr_debug("incoming length: 0x%08x\n", emudat);
103                                         inbound_len = emudat;
104                                 } else {
105                                         size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
106                                         pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
107                                         inbound_len -= num_chars;
108                                         tty_insert_flip_string(tty, (unsigned char *)&emudat, num_chars);
109                                         tty_flip_buffer_push(tty);
110                                 }
111                         }
112                         mutex_unlock(&bfin_jc_tty_mutex);
113                 }
114
115                 /* if outgoing data is ready, post it */
116                 if (!(bfin_read_DBGSTAT() & EMUDOF) && !circ_empty(&bfin_jc_write_buf)) {
117                         if (outbound_len == 0) {
118                                 outbound_len = circ_cnt(&bfin_jc_write_buf);
119                                 bfin_write_emudat(outbound_len);
120                                 pr_debug("outgoing length: 0x%08x\n", outbound_len);
121                         } else {
122                                 struct tty_struct *tty;
123                                 int tail = bfin_jc_write_buf.tail;
124                                 size_t ate = (4 <= outbound_len ? 4 : outbound_len);
125                                 uint32_t emudat =
126                                 bfin_write_emudat_chars(
127                                         circ_byte(&bfin_jc_write_buf, tail + 0),
128                                         circ_byte(&bfin_jc_write_buf, tail + 1),
129                                         circ_byte(&bfin_jc_write_buf, tail + 2),
130                                         circ_byte(&bfin_jc_write_buf, tail + 3)
131                                 );
132                                 bfin_jc_write_buf.tail += ate;
133                                 outbound_len -= ate;
134                                 mutex_lock(&bfin_jc_tty_mutex);
135                                 tty = (struct tty_struct *)bfin_jc_tty;
136                                 if (tty)
137                                         tty_wakeup(tty);
138                                 mutex_unlock(&bfin_jc_tty_mutex);
139                                 pr_debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
140                         }
141                 }
142         }
143
144         __set_current_state(TASK_RUNNING);
145         return 0;
146 }
147
148 static int
149 bfin_jc_open(struct tty_struct *tty, struct file *filp)
150 {
151         mutex_lock(&bfin_jc_tty_mutex);
152         pr_debug("open %lu\n", bfin_jc_count);
153         ++bfin_jc_count;
154         bfin_jc_tty = tty;
155         wake_up_process(bfin_jc_kthread);
156         mutex_unlock(&bfin_jc_tty_mutex);
157         return 0;
158 }
159
160 static void
161 bfin_jc_close(struct tty_struct *tty, struct file *filp)
162 {
163         mutex_lock(&bfin_jc_tty_mutex);
164         pr_debug("close %lu\n", bfin_jc_count);
165         if (--bfin_jc_count == 0)
166                 bfin_jc_tty = NULL;
167         wake_up_process(bfin_jc_kthread);
168         mutex_unlock(&bfin_jc_tty_mutex);
169 }
170
171 /* XXX: we dont handle the put_char() case where we must handle count = 1 */
172 static int
173 bfin_jc_circ_write(const unsigned char *buf, int count)
174 {
175         int i;
176         count = min(count, circ_free(&bfin_jc_write_buf));
177         pr_debug("going to write chunk of %i bytes\n", count);
178         for (i = 0; i < count; ++i)
179                 circ_byte(&bfin_jc_write_buf, bfin_jc_write_buf.head + i) = buf[i];
180         bfin_jc_write_buf.head += i;
181         return i;
182 }
183
184 #ifndef CONFIG_BFIN_JTAG_COMM_CONSOLE
185 # define acquire_console_sem()
186 # define release_console_sem()
187 #endif
188 static int
189 bfin_jc_write(struct tty_struct *tty, const unsigned char *buf, int count)
190 {
191         int i;
192         acquire_console_sem();
193         i = bfin_jc_circ_write(buf, count);
194         release_console_sem();
195         wake_up_process(bfin_jc_kthread);
196         return i;
197 }
198
199 static void
200 bfin_jc_flush_chars(struct tty_struct *tty)
201 {
202         wake_up_process(bfin_jc_kthread);
203 }
204
205 static int
206 bfin_jc_write_room(struct tty_struct *tty)
207 {
208         return circ_free(&bfin_jc_write_buf);
209 }
210
211 static int
212 bfin_jc_chars_in_buffer(struct tty_struct *tty)
213 {
214         return circ_cnt(&bfin_jc_write_buf);
215 }
216
217 static void
218 bfin_jc_wait_until_sent(struct tty_struct *tty, int timeout)
219 {
220         unsigned long expire = jiffies + timeout;
221         while (!circ_empty(&bfin_jc_write_buf)) {
222                 if (signal_pending(current))
223                         break;
224                 if (time_after(jiffies, expire))
225                         break;
226         }
227 }
228
229 static struct tty_operations bfin_jc_ops = {
230         .open            = bfin_jc_open,
231         .close           = bfin_jc_close,
232         .write           = bfin_jc_write,
233         /*.put_char        = bfin_jc_put_char,*/
234         .flush_chars     = bfin_jc_flush_chars,
235         .write_room      = bfin_jc_write_room,
236         .chars_in_buffer = bfin_jc_chars_in_buffer,
237         .wait_until_sent = bfin_jc_wait_until_sent,
238 };
239
240 static int __init bfin_jc_init(void)
241 {
242         int ret;
243
244         bfin_jc_kthread = kthread_create(bfin_jc_emudat_manager, NULL, DRV_NAME);
245         if (IS_ERR(bfin_jc_kthread))
246                 return PTR_ERR(bfin_jc_kthread);
247
248         ret = -ENOMEM;
249
250         bfin_jc_write_buf.head = bfin_jc_write_buf.tail = 0;
251         bfin_jc_write_buf.buf = kmalloc(CIRC_SIZE, GFP_KERNEL);
252         if (!bfin_jc_write_buf.buf)
253                 goto err;
254
255         bfin_jc_driver = alloc_tty_driver(1);
256         if (!bfin_jc_driver)
257                 goto err;
258
259         bfin_jc_driver->owner        = THIS_MODULE;
260         bfin_jc_driver->driver_name  = DRV_NAME;
261         bfin_jc_driver->name         = DEV_NAME;
262         bfin_jc_driver->type         = TTY_DRIVER_TYPE_SERIAL;
263         bfin_jc_driver->subtype      = SERIAL_TYPE_NORMAL;
264         bfin_jc_driver->init_termios = tty_std_termios;
265         tty_set_operations(bfin_jc_driver, &bfin_jc_ops);
266
267         ret = tty_register_driver(bfin_jc_driver);
268         if (ret)
269                 goto err;
270
271         pr_init(KERN_INFO DRV_NAME ": initialized\n");
272
273         return 0;
274
275  err:
276         put_tty_driver(bfin_jc_driver);
277         kfree(bfin_jc_write_buf.buf);
278         kthread_stop(bfin_jc_kthread);
279         return ret;
280 }
281 module_init(bfin_jc_init);
282
283 static void __exit bfin_jc_exit(void)
284 {
285         kthread_stop(bfin_jc_kthread);
286         kfree(bfin_jc_write_buf.buf);
287         tty_unregister_driver(bfin_jc_driver);
288         put_tty_driver(bfin_jc_driver);
289 }
290 module_exit(bfin_jc_exit);
291
292 #if defined(CONFIG_BFIN_JTAG_COMM_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
293 static void
294 bfin_jc_straight_buffer_write(const char *buf, unsigned count)
295 {
296         unsigned ate = 0;
297         while (bfin_read_DBGSTAT() & EMUDOF)
298                 continue;
299         bfin_write_emudat(count);
300         while (ate < count) {
301                 while (bfin_read_DBGSTAT() & EMUDOF)
302                         continue;
303                 bfin_write_emudat_chars(buf[ate], buf[ate+1], buf[ate+2], buf[ate+3]);
304                 ate += 4;
305         }
306 }
307 #endif
308
309 #ifdef CONFIG_BFIN_JTAG_COMM_CONSOLE
310 static void
311 bfin_jc_console_write(struct console *co, const char *buf, unsigned count)
312 {
313         if (bfin_jc_kthread == NULL)
314                 bfin_jc_straight_buffer_write(buf, count);
315         else
316                 bfin_jc_circ_write(buf, count);
317 }
318
319 static struct tty_driver *
320 bfin_jc_console_device(struct console *co, int *index)
321 {
322         *index = co->index;
323         return bfin_jc_driver;
324 }
325
326 static struct console bfin_jc_console = {
327         .name    = DEV_NAME,
328         .write   = bfin_jc_console_write,
329         .device  = bfin_jc_console_device,
330         .flags   = CON_ANYTIME | CON_PRINTBUFFER,
331         .index   = -1,
332 };
333
334 static int __init bfin_jc_console_init(void)
335 {
336         register_console(&bfin_jc_console);
337         return 0;
338 }
339 console_initcall(bfin_jc_console_init);
340 #endif
341
342 #ifdef CONFIG_EARLY_PRINTK
343 static void __init
344 bfin_jc_early_write(struct console *co, const char *buf, unsigned int count)
345 {
346         bfin_jc_straight_buffer_write(buf, count);
347 }
348
349 static struct __initdata console bfin_jc_early_console = {
350         .name   = "early_BFJC",
351         .write   = bfin_jc_early_write,
352         .flags   = CON_ANYTIME | CON_PRINTBUFFER,
353         .index   = -1,
354 };
355
356 struct console * __init
357 bfin_jc_early_init(unsigned int port, unsigned int cflag)
358 {
359         return &bfin_jc_early_console;
360 }
361 #endif
362
363 MODULE_AUTHOR("Mike Frysinger <vapier@gentoo.org>");
364 MODULE_DESCRIPTION("TTY over Blackfin JTAG Communication");
365 MODULE_LICENSE("GPL");