[GitHub/mt8127/android_kernel_alcatel_ttab.git] / drivers / tty / bfin_jtag_comm.c

/*
 * TTY over Blackfin JTAG Communication
 *
 * Copyright 2008-2009 Analog Devices Inc.
 *
 * Enter bugs at http://blackfin.uclinux.org/
 *
 * Licensed under the GPL-2 or later.
 */

#define DRV_NAME "bfin-jtag-comm"
#define DEV_NAME "ttyBFJC"
#define pr_fmt(fmt) DRV_NAME ": " fmt

#include <linux/circ_buf.h>
#include <linux/console.h>
#include <linux/delay.h>
#include <linux/err.h>
#include <linux/kernel.h>
#include <linux/kthread.h>
#include <linux/module.h>
#include <linux/mutex.h>
#include <linux/sched.h>
#include <linux/slab.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/atomic.h>

#define pr_init(fmt, args...) ({ static const __initconst char __fmt[] = fmt; printk(__fmt, ## args); })

/* See the Debug/Emulation chapter in the HRM */
#define EMUDOF   0x00000001	/* EMUDAT_OUT full & valid */
#define EMUDIF   0x00000002	/* EMUDAT_IN full & valid */
#define EMUDOOVF 0x00000004	/* EMUDAT_OUT overflow */
#define EMUDIOVF 0x00000008	/* EMUDAT_IN overflow */

static inline uint32_t bfin_write_emudat(uint32_t emudat)
{
	__asm__ __volatile__("emudat = %0;" : : "d"(emudat));
	return emudat;
}

static inline uint32_t bfin_read_emudat(void)
{
	uint32_t emudat;
	__asm__ __volatile__("%0 = emudat;" : "=d"(emudat));
	return emudat;
}

static inline uint32_t bfin_write_emudat_chars(char a, char b, char c, char d)
{
	return bfin_write_emudat((a << 0) | (b << 8) | (c << 16) | (d << 24));
}

#define CIRC_SIZE 2048	/* see comment in tty_io.c:do_tty_write() */
#define CIRC_MASK (CIRC_SIZE - 1)
#define circ_empty(circ)     ((circ)->head == (circ)->tail)
#define circ_free(circ)      CIRC_SPACE((circ)->head, (circ)->tail, CIRC_SIZE)
#define circ_cnt(circ)       CIRC_CNT((circ)->head, (circ)->tail, CIRC_SIZE)
#define circ_byte(circ, idx) ((circ)->buf[(idx) & CIRC_MASK])

static struct tty_driver *bfin_jc_driver;
static struct task_struct *bfin_jc_kthread;
static struct tty_struct * volatile bfin_jc_tty;
static unsigned long bfin_jc_count;
static DEFINE_MUTEX(bfin_jc_tty_mutex);
static volatile struct circ_buf bfin_jc_write_buf;

static int
bfin_jc_emudat_manager(void *arg)
{
	uint32_t inbound_len = 0, outbound_len = 0;

	while (!kthread_should_stop()) {
		/* no one left to give data to, so sleep */
		if (bfin_jc_tty == NULL && circ_empty(&bfin_jc_write_buf)) {
			pr_debug("waiting for readers\n");
			__set_current_state(TASK_UNINTERRUPTIBLE);
			schedule();
			__set_current_state(TASK_RUNNING);
		}

		/* no data available, so just chill */
		if (!(bfin_read_DBGSTAT() & EMUDIF) && circ_empty(&bfin_jc_write_buf)) {
			pr_debug("waiting for data (in_len = %i) (circ: %i %i)\n",
				inbound_len, bfin_jc_write_buf.tail, bfin_jc_write_buf.head);
			if (inbound_len)
				schedule();
			else
				schedule_timeout_interruptible(HZ);
			continue;
		}

		/* if incoming data is ready, eat it */
		if (bfin_read_DBGSTAT() & EMUDIF) {
			struct tty_struct *tty;
			mutex_lock(&bfin_jc_tty_mutex);
			tty = (struct tty_struct *)bfin_jc_tty;
			if (tty != NULL) {
				uint32_t emudat = bfin_read_emudat();
				if (inbound_len == 0) {
					pr_debug("incoming length: 0x%08x\n", emudat);
					inbound_len = emudat;
				} else {
					size_t num_chars = (4 <= inbound_len ? 4 : inbound_len);
					pr_debug("  incoming data: 0x%08x (pushing %zu)\n", emudat, num_chars);
					inbound_len -= num_chars;
					tty_insert_flip_string(tty, (unsigned char *)&emudat, num_chars);
					tty_flip_buffer_push(tty);
				}
			}
			mutex_unlock(&bfin_jc_tty_mutex);
		}

		/* if outgoing data is ready, post it */
		if (!(bfin_read_DBGSTAT() & EMUDOF) && !circ_empty(&bfin_jc_write_buf)) {
			if (outbound_len == 0) {
				outbound_len = circ_cnt(&bfin_jc_write_buf);
				bfin_write_emudat(outbound_len);
				pr_debug("outgoing length: 0x%08x\n", outbound_len);
			} else {
				struct tty_struct *tty;
				int tail = bfin_jc_write_buf.tail;
				size_t ate = (4 <= outbound_len ? 4 : outbound_len);
				uint32_t emudat =
				bfin_write_emudat_chars(
					circ_byte(&bfin_jc_write_buf, tail + 0),
					circ_byte(&bfin_jc_write_buf, tail + 1),
					circ_byte(&bfin_jc_write_buf, tail + 2),
					circ_byte(&bfin_jc_write_buf, tail + 3)
				);
				bfin_jc_write_buf.tail += ate;
				outbound_len -= ate;
				mutex_lock(&bfin_jc_tty_mutex);
				tty = (struct tty_struct *)bfin_jc_tty;
				if (tty)
					tty_wakeup(tty);
				mutex_unlock(&bfin_jc_tty_mutex);
				pr_debug("  outgoing data: 0x%08x (pushing %zu)\n", emudat, ate);
			}
		}
	}

	__set_current_state(TASK_RUNNING);
	return 0;
}

static int
bfin_jc_open(struct tty_struct *tty, struct file *filp)
{
	mutex_lock(&bfin_jc_tty_mutex);
	pr_debug("open %lu\n", bfin_jc_count);
	++bfin_jc_count;
	bfin_jc_tty = tty;
	wake_up_process(bfin_jc_kthread);
	mutex_unlock(&bfin_jc_tty_mutex);
	return 0;
}

static void
bfin_jc_close(struct tty_struct *tty, struct file *filp)
{
	mutex_lock(&bfin_jc_tty_mutex);
	pr_debug("close %lu\n", bfin_jc_count);
	if (--bfin_jc_count == 0)
		bfin_jc_tty = NULL;
	wake_up_process(bfin_jc_kthread);
	mutex_unlock(&bfin_jc_tty_mutex);
}

/* XXX: we dont handle the put_char() case where we must handle count = 1 */
static int
bfin_jc_circ_write(const unsigned char *buf, int count)
{
	int i;
	count = min(count, circ_free(&bfin_jc_write_buf));
	pr_debug("going to write chunk of %i bytes\n", count);
	for (i = 0; i < count; ++i)
		circ_byte(&bfin_jc_write_buf, bfin_jc_write_buf.head + i) = buf[i];
	bfin_jc_write_buf.head += i;
	return i;
}

#ifndef CONFIG_BFIN_JTAG_COMM_CONSOLE
# define console_lock()
# define console_unlock()
#endif
static int
bfin_jc_write(struct tty_struct *tty, const unsigned char *buf, int count)
{
	int i;
	console_lock();
	i = bfin_jc_circ_write(buf, count);
	console_unlock();
	wake_up_process(bfin_jc_kthread);
	return i;
}

static void
bfin_jc_flush_chars(struct tty_struct *tty)
{
	wake_up_process(bfin_jc_kthread);
}

static int
bfin_jc_write_room(struct tty_struct *tty)
{
	return circ_free(&bfin_jc_write_buf);
}

static int
bfin_jc_chars_in_buffer(struct tty_struct *tty)
{
	return circ_cnt(&bfin_jc_write_buf);
}

static void
bfin_jc_wait_until_sent(struct tty_struct *tty, int timeout)
{
	unsigned long expire = jiffies + timeout;
	while (!circ_empty(&bfin_jc_write_buf)) {
		if (signal_pending(current))
			break;
		if (time_after(jiffies, expire))
			break;
	}
}

static const struct tty_operations bfin_jc_ops = {
	.open            = bfin_jc_open,
	.close           = bfin_jc_close,
	.write           = bfin_jc_write,
	/*.put_char        = bfin_jc_put_char,*/
	.flush_chars     = bfin_jc_flush_chars,
	.write_room      = bfin_jc_write_room,
	.chars_in_buffer = bfin_jc_chars_in_buffer,
	.wait_until_sent = bfin_jc_wait_until_sent,
};

static int __init bfin_jc_init(void)
{
	int ret;

	bfin_jc_kthread = kthread_create(bfin_jc_emudat_manager, NULL, DRV_NAME);
	if (IS_ERR(bfin_jc_kthread))
		return PTR_ERR(bfin_jc_kthread);

	ret = -ENOMEM;

	bfin_jc_write_buf.head = bfin_jc_write_buf.tail = 0;
	bfin_jc_write_buf.buf = kmalloc(CIRC_SIZE, GFP_KERNEL);
	if (!bfin_jc_write_buf.buf)
		goto err_buf;

	bfin_jc_driver = alloc_tty_driver(1);
	if (!bfin_jc_driver)
		goto err_driver;

	bfin_jc_driver->owner        = THIS_MODULE;
	bfin_jc_driver->driver_name  = DRV_NAME;
	bfin_jc_driver->name         = DEV_NAME;
	bfin_jc_driver->type         = TTY_DRIVER_TYPE_SERIAL;
	bfin_jc_driver->subtype      = SERIAL_TYPE_NORMAL;
	bfin_jc_driver->init_termios = tty_std_termios;
	tty_set_operations(bfin_jc_driver, &bfin_jc_ops);

	ret = tty_register_driver(bfin_jc_driver);
	if (ret)
		goto err;

	pr_init(KERN_INFO DRV_NAME ": initialized\n");

	return 0;

 err:
	put_tty_driver(bfin_jc_driver);
 err_driver:
	kfree(bfin_jc_write_buf.buf);
 err_buf:
	kthread_stop(bfin_jc_kthread);
	return ret;
}
module_init(bfin_jc_init);

static void __exit bfin_jc_exit(void)
{
	kthread_stop(bfin_jc_kthread);
	kfree(bfin_jc_write_buf.buf);
	tty_unregister_driver(bfin_jc_driver);
	put_tty_driver(bfin_jc_driver);
}
module_exit(bfin_jc_exit);

#if defined(CONFIG_BFIN_JTAG_COMM_CONSOLE) || defined(CONFIG_EARLY_PRINTK)
static void
bfin_jc_straight_buffer_write(const char *buf, unsigned count)
{
	unsigned ate = 0;
	while (bfin_read_DBGSTAT() & EMUDOF)
		continue;
	bfin_write_emudat(count);
	while (ate < count) {
		while (bfin_read_DBGSTAT() & EMUDOF)
			continue;
		bfin_write_emudat_chars(buf[ate], buf[ate+1], buf[ate+2], buf[ate+3]);
		ate += 4;
	}
}
#endif

#ifdef CONFIG_BFIN_JTAG_COMM_CONSOLE
static void
bfin_jc_console_write(struct console *co, const char *buf, unsigned count)
{
	if (bfin_jc_kthread == NULL)
		bfin_jc_straight_buffer_write(buf, count);
	else
		bfin_jc_circ_write(buf, count);
}

static struct tty_driver *
bfin_jc_console_device(struct console *co, int *index)
{
	*index = co->index;
	return bfin_jc_driver;
}

static struct console bfin_jc_console = {
	.name    = DEV_NAME,
	.write   = bfin_jc_console_write,
	.device  = bfin_jc_console_device,
	.flags   = CON_ANYTIME | CON_PRINTBUFFER,
	.index   = -1,
};

static int __init bfin_jc_console_init(void)
{
	register_console(&bfin_jc_console);
	return 0;
}
console_initcall(bfin_jc_console_init);
#endif

#ifdef CONFIG_EARLY_PRINTK
static void __init
bfin_jc_early_write(struct console *co, const char *buf, unsigned int count)
{
	bfin_jc_straight_buffer_write(buf, count);
}

static struct __initdata console bfin_jc_early_console = {
	.name   = "early_BFJC",
	.write   = bfin_jc_early_write,
	.flags   = CON_ANYTIME | CON_PRINTBUFFER,
	.index   = -1,
};

struct console * __init
bfin_jc_early_init(unsigned int port, unsigned int cflag)
{
	return &bfin_jc_early_console;
}
#endif

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