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