[deliverable/linux.git] / arch / xtensa / platforms / iss / console.c

/*
 * arch/xtensa/platforms/iss/console.c
 *
 * This file is subject to the terms and conditions of the GNU General Public
 * License.  See the file "COPYING" in the main directory of this archive
 * for more details.
 *
 * Copyright (C) 2001-2005 Tensilica Inc.
 *   Authors	Christian Zankel, Joe Taylor
 */

#include <linux/module.h>
#include <linux/kernel.h>
#include <linux/sched.h>
#include <linux/console.h>
#include <linux/init.h>
#include <linux/mm.h>
#include <linux/major.h>
#include <linux/param.h>
#include <linux/seq_file.h>
#include <linux/serial.h>

#include <asm/uaccess.h>
#include <asm/irq.h>

#include <platform/simcall.h>

#include <linux/tty.h>
#include <linux/tty_flip.h>

#ifdef SERIAL_INLINE
#define _INLINE_ inline
#endif

#define SERIAL_MAX_NUM_LINES 1
#define SERIAL_TIMER_VALUE (20 * HZ)

static struct tty_driver *serial_driver;
static struct tty_port serial_port;
static struct timer_list serial_timer;

static DEFINE_SPINLOCK(timer_lock);

int errno;

static int __simc (int a, int b, int c, int d, int e, int f) __attribute__((__noinline__));
static int __simc (int a, int b, int c, int d, int e, int f)
{
	int ret;
	__asm__ __volatile__ ("simcall\n"
			"mov %0, a2\n"
			"mov %1, a3\n" : "=a" (ret), "=a" (errno)
			: : "a2", "a3");
	return ret;
}

static char *serial_version = "0.1";
static char *serial_name = "ISS serial driver";

/*
 * This routine is called whenever a serial port is opened.  It
 * enables interrupts for a serial port, linking in its async structure into
 * the IRQ chain.   It also performs the serial-specific
 * initialization for the tty structure.
 */

static void rs_poll(unsigned long);

static int rs_open(struct tty_struct *tty, struct file * filp)
{
	tty->port = &serial_port;
	spin_lock(&timer_lock);
	if (tty->count == 1) {
		setup_timer(&serial_timer, rs_poll, (unsigned long)tty);
		mod_timer(&serial_timer, jiffies + SERIAL_TIMER_VALUE);
	}
	spin_unlock(&timer_lock);

	return 0;
}


/*
 * ------------------------------------------------------------
 * iss_serial_close()
 *
 * This routine is called when the serial port gets closed.  First, we
 * wait for the last remaining data to be sent.  Then, we unlink its
 * async structure from the interrupt chain if necessary, and we free
 * that IRQ if nothing is left in the chain.
 * ------------------------------------------------------------
 */
static void rs_close(struct tty_struct *tty, struct file * filp)
{
	spin_lock_bh(&timer_lock);
	if (tty->count == 1)
		del_timer_sync(&serial_timer);
	spin_unlock_bh(&timer_lock);
}


static int rs_write(struct tty_struct * tty,
		    const unsigned char *buf, int count)
{
	/* see drivers/char/serialX.c to reference original version */

	__simc (SYS_write, 1, (unsigned long)buf, count, 0, 0);
	return count;
}

static void rs_poll(unsigned long priv)
{
	struct tty_struct* tty = (struct tty_struct*) priv;

	struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
	int i = 0;
	unsigned char c;

	spin_lock(&timer_lock);

	while (__simc(SYS_select_one, 0, XTISS_SELECT_ONE_READ, (int)&tv,0,0)){
		__simc (SYS_read, 0, (unsigned long)&c, 1, 0, 0);
		tty_insert_flip_char(tty, c, TTY_NORMAL);
		i++;
	}

	if (i)
		tty_flip_buffer_push(tty);


	mod_timer(&serial_timer, jiffies + SERIAL_TIMER_VALUE);
	spin_unlock(&timer_lock);
}


static int rs_put_char(struct tty_struct *tty, unsigned char ch)
{
	char buf[2];

	buf[0] = ch;
	buf[1] = '\0';		/* Is this NULL necessary? */
	__simc (SYS_write, 1, (unsigned long) buf, 1, 0, 0);
	return 1;
}

static void rs_flush_chars(struct tty_struct *tty)
{
}

static int rs_write_room(struct tty_struct *tty)
{
	/* Let's say iss can always accept 2K characters.. */
	return 2 * 1024;
}

static int rs_chars_in_buffer(struct tty_struct *tty)
{
	/* the iss doesn't buffer characters */
	return 0;
}

static void rs_hangup(struct tty_struct *tty)
{
	/* Stub, once again.. */
}

static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
{
	/* Stub, once again.. */
}

static int rs_proc_show(struct seq_file *m, void *v)
{
	seq_printf(m, "serinfo:1.0 driver:%s\n", serial_version);
	return 0;
}

static int rs_proc_open(struct inode *inode, struct file *file)
{
	return single_open(file, rs_proc_show, NULL);
}

static const struct file_operations rs_proc_fops = {
	.owner		= THIS_MODULE,
	.open		= rs_proc_open,
	.read		= seq_read,
	.llseek		= seq_lseek,
	.release	= single_release,
};

static const struct tty_operations serial_ops = {
	.open = rs_open,
	.close = rs_close,
	.write = rs_write,
	.put_char = rs_put_char,
	.flush_chars = rs_flush_chars,
	.write_room = rs_write_room,
	.chars_in_buffer = rs_chars_in_buffer,
	.hangup = rs_hangup,
	.wait_until_sent = rs_wait_until_sent,
	.proc_fops = &rs_proc_fops,
};

int __init rs_init(void)
{
	tty_port_init(&serial_port);

	serial_driver = alloc_tty_driver(SERIAL_MAX_NUM_LINES);

	printk ("%s %s\n", serial_name, serial_version);

	/* Initialize the tty_driver structure */

	serial_driver->driver_name = "iss_serial";
	serial_driver->name = "ttyS";
	serial_driver->major = TTY_MAJOR;
	serial_driver->minor_start = 64;
	serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
	serial_driver->subtype = SERIAL_TYPE_NORMAL;
	serial_driver->init_termios = tty_std_termios;
	serial_driver->init_termios.c_cflag =
		B9600 | CS8 | CREAD | HUPCL | CLOCAL;
	serial_driver->flags = TTY_DRIVER_REAL_RAW;

	tty_set_operations(serial_driver, &serial_ops);
	tty_port_link_device(&serial_port, serial_driver, 0);

	if (tty_register_driver(serial_driver))
		panic("Couldn't register serial driver\n");
	return 0;
}


static __exit void rs_exit(void)
{
	int error;

	if ((error = tty_unregister_driver(serial_driver)))
		printk("ISS_SERIAL: failed to unregister serial driver (%d)\n",
		       error);
	put_tty_driver(serial_driver);
}


/* We use `late_initcall' instead of just `__initcall' as a workaround for
 * the fact that (1) simcons_tty_init can't be called before tty_init,
 * (2) tty_init is called via `module_init', (3) if statically linked,
 * module_init == device_init, and (4) there's no ordering of init lists.
 * We can do this easily because simcons is always statically linked, but
 * other tty drivers that depend on tty_init and which must use
 * `module_init' to declare their init routines are likely to be broken.
 */

late_initcall(rs_init);


#ifdef CONFIG_SERIAL_CONSOLE

static void iss_console_write(struct console *co, const char *s, unsigned count)
{
	int len = strlen(s);

	if (s != 0 && *s != 0)
		__simc (SYS_write, 1, (unsigned long)s,
			count < len ? count : len,0,0);
}

static struct tty_driver* iss_console_device(struct console *c, int *index)
{
	*index = c->index;
	return serial_driver;
}


static struct console sercons = {
	.name = "ttyS",
	.write = iss_console_write,
	.device = iss_console_device,
	.flags = CON_PRINTBUFFER,
	.index = -1
};

static int __init iss_console_init(void)
{
	register_console(&sercons);
	return 0;
}

console_initcall(iss_console_init);

#endif /* CONFIG_SERIAL_CONSOLE */
Commit	Line	Data
7282bee7	1	/*
5fee325e	2	* arch/xtensa/platforms/iss/console.c
7282bee7 CZ	3	*
	4	* This file is subject to the terms and conditions of the GNU General Public
	5	* License. See the file "COPYING" in the main directory of this archive
	6	* for more details.
	7	*
	8	* Copyright (C) 2001-2005 Tensilica Inc.
	9	* Authors Christian Zankel, Joe Taylor
	10	*/
	11
	12	#include <linux/module.h>
7282bee7 CZ	13	#include <linux/kernel.h>
	14	#include <linux/sched.h>
	15	#include <linux/console.h>
	16	#include <linux/init.h>
7282bee7 CZ	17	#include <linux/mm.h>
	18	#include <linux/major.h>
	19	#include <linux/param.h>
14071693	20	#include <linux/seq_file.h>
7282bee7	21	#include <linux/serial.h>
7282bee7 CZ	22
	23	#include <asm/uaccess.h>
	24	#include <asm/irq.h>
	25
5fee325e	26	#include <platform/simcall.h>
7282bee7 CZ	27
	28	#include <linux/tty.h>
	29	#include <linux/tty_flip.h>
	30
173d6681 CZ	31	#ifdef SERIAL_INLINE
	32	#define _INLINE_ inline
	33	#endif
	34
7282bee7 CZ	35	#define SERIAL_MAX_NUM_LINES 1
	36	#define SERIAL_TIMER_VALUE (20 * HZ)
	37
	38	static struct tty_driver *serial_driver;
885f8b0f	39	static struct tty_port serial_port;
7282bee7 CZ	40	static struct timer_list serial_timer;
	41
	42	static DEFINE_SPINLOCK(timer_lock);
	43
	44	int errno;
	45
c8654158	46	static int __simc (int a, int b, int c, int d, int e, int f) __attribute__((__noinline__));
7282bee7 CZ	47	static int __simc (int a, int b, int c, int d, int e, int f)
	48	{
	49	int ret;
	50	__asm__ __volatile__ ("simcall\n"
	51	"mov %0, a2\n"
	52	"mov %1, a3\n" : "=a" (ret), "=a" (errno)
	53	: : "a2", "a3");
	54	return ret;
	55	}
	56
	57	static char *serial_version = "0.1";
	58	static char *serial_name = "ISS serial driver";
	59
	60	/*
	61	* This routine is called whenever a serial port is opened. It
	62	* enables interrupts for a serial port, linking in its async structure into
	63	* the IRQ chain. It also performs the serial-specific
	64	* initialization for the tty structure.
	65	*/
	66
	67	static void rs_poll(unsigned long);
	68
	69	static int rs_open(struct tty_struct tty, struct file filp)
	70	{
885f8b0f	71	tty->port = &serial_port;
7282bee7	72	spin_lock(&timer_lock);
7282bee7	73	if (tty->count == 1) {
86e7e874	74	setup_timer(&serial_timer, rs_poll, (unsigned long)tty);
7282bee7 CZ	75	mod_timer(&serial_timer, jiffies + SERIAL_TIMER_VALUE);
	76	}
	77	spin_unlock(&timer_lock);
	78
	79	return 0;
	80	}
	81
	82
	83	/*
	84	* ------------------------------------------------------------
	85	* iss_serial_close()
	86	*
	87	* This routine is called when the serial port gets closed. First, we
	88	* wait for the last remaining data to be sent. Then, we unlink its
	89	* async structure from the interrupt chain if necessary, and we free
	90	* that IRQ if nothing is left in the chain.
	91	* ------------------------------------------------------------
	92	*/
	93	static void rs_close(struct tty_struct tty, struct file filp)
	94	{
c9ddb1d6	95	spin_lock_bh(&timer_lock);
7282bee7 CZ	96	if (tty->count == 1)
7282bee7 CZ	97	del_timer_sync(&serial_timer);
c9ddb1d6	98	spin_unlock_bh(&timer_lock);
7282bee7 CZ	99	}
	100
	101
	102	static int rs_write(struct tty_struct * tty,
	103	const unsigned char *buf, int count)
	104	{
	105	/* see drivers/char/serialX.c to reference original version */
	106
	107	__simc (SYS_write, 1, (unsigned long)buf, count, 0, 0);
	108	return count;
	109	}
	110
	111	static void rs_poll(unsigned long priv)
	112	{
	113	struct tty_struct* tty = (struct tty_struct*) priv;
	114
	115	struct timeval tv = { .tv_sec = 0, .tv_usec = 0 };
	116	int i = 0;
	117	unsigned char c;
	118
	119	spin_lock(&timer_lock);
	120
	121	while (__simc(SYS_select_one, 0, XTISS_SELECT_ONE_READ, (int)&tv,0,0)){
	122	__simc (SYS_read, 0, (unsigned long)&c, 1, 0, 0);
81459169	123	tty_insert_flip_char(tty, c, TTY_NORMAL);
7282bee7 CZ	124	i++;
	125	}
	126
	127	if (i)
	128	tty_flip_buffer_push(tty);
	129
	130
	131	mod_timer(&serial_timer, jiffies + SERIAL_TIMER_VALUE);
	132	spin_unlock(&timer_lock);
	133	}
	134
	135
5a891ed5	136	static int rs_put_char(struct tty_struct *tty, unsigned char ch)
7282bee7 CZ	137	{
	138	char buf[2];
	139
7282bee7 CZ	140	buf[0] = ch;
	141	buf[1] = '\0'; /* Is this NULL necessary? */
	142	__simc (SYS_write, 1, (unsigned long) buf, 1, 0, 0);
5a891ed5	143	return 1;
7282bee7 CZ	144	}
	145
	146	static void rs_flush_chars(struct tty_struct *tty)
	147	{
	148	}
	149
	150	static int rs_write_room(struct tty_struct *tty)
	151	{
	152	/* Let's say iss can always accept 2K characters.. */
	153	return 2 * 1024;
	154	}
	155
	156	static int rs_chars_in_buffer(struct tty_struct *tty)
	157	{
	158	/* the iss doesn't buffer characters */
	159	return 0;
	160	}
	161
	162	static void rs_hangup(struct tty_struct *tty)
	163	{
	164	/* Stub, once again.. */
	165	}
	166
	167	static void rs_wait_until_sent(struct tty_struct *tty, int timeout)
	168	{
	169	/* Stub, once again.. */
	170	}
	171
14071693	172	static int rs_proc_show(struct seq_file m, void v)
7282bee7	173	{
14071693 AD	174	seq_printf(m, "serinfo:1.0 driver:%s\n", serial_version);
	175	return 0;
	176	}
7282bee7	177
14071693 AD	178	static int rs_proc_open(struct inode inode, struct file file)
	179	{
	180	return single_open(file, rs_proc_show, NULL);
7282bee7 CZ	181	}
7282bee7 CZ	182
14071693 AD	183	static const struct file_operations rs_proc_fops = {
	184	.owner = THIS_MODULE,
	185	.open = rs_proc_open,
	186	.read = seq_read,
	187	.llseek = seq_lseek,
	188	.release = single_release,
	189	};
7282bee7	190
1cceefd3	191	static const struct tty_operations serial_ops = {
7282bee7 CZ	192	.open = rs_open,
	193	.close = rs_close,
	194	.write = rs_write,
	195	.put_char = rs_put_char,
	196	.flush_chars = rs_flush_chars,
	197	.write_room = rs_write_room,
	198	.chars_in_buffer = rs_chars_in_buffer,
	199	.hangup = rs_hangup,
	200	.wait_until_sent = rs_wait_until_sent,
14071693	201	.proc_fops = &rs_proc_fops,
7282bee7 CZ	202	};
	203
	204	int __init rs_init(void)
	205	{
885f8b0f JS	206	tty_port_init(&serial_port);
885f8b0f JS	207
410235fd	208	serial_driver = alloc_tty_driver(SERIAL_MAX_NUM_LINES);
7282bee7 CZ	209
	210	printk ("%s %s\n", serial_name, serial_version);
	211
	212	/* Initialize the tty_driver structure */
	213
7282bee7 CZ	214	serial_driver->driver_name = "iss_serial";
	215	serial_driver->name = "ttyS";
	216	serial_driver->major = TTY_MAJOR;
	217	serial_driver->minor_start = 64;
	218	serial_driver->type = TTY_DRIVER_TYPE_SERIAL;
	219	serial_driver->subtype = SERIAL_TYPE_NORMAL;
	220	serial_driver->init_termios = tty_std_termios;
	221	serial_driver->init_termios.c_cflag =
	222	B9600 \| CS8 \| CREAD \| HUPCL \| CLOCAL;
	223	serial_driver->flags = TTY_DRIVER_REAL_RAW;
	224
	225	tty_set_operations(serial_driver, &serial_ops);
b19e2ca7	226	tty_port_link_device(&serial_port, serial_driver, 0);
7282bee7 CZ	227
	228	if (tty_register_driver(serial_driver))
	229	panic("Couldn't register serial driver\n");
	230	return 0;
	231	}
	232
	233
	234	static __exit void rs_exit(void)
	235	{
	236	int error;
	237
	238	if ((error = tty_unregister_driver(serial_driver)))
	239	printk("ISS_SERIAL: failed to unregister serial driver (%d)\n",
	240	error);
	241	put_tty_driver(serial_driver);
	242	}
	243
	244
	245	/* We use `late_initcall' instead of just `__initcall' as a workaround for
	246	* the fact that (1) simcons_tty_init can't be called before tty_init,
	247	* (2) tty_init is called via `module_init', (3) if statically linked,
	248	* module_init == device_init, and (4) there's no ordering of init lists.
	249	* We can do this easily because simcons is always statically linked, but
	250	* other tty drivers that depend on tty_init and which must use
	251	* `module_init' to declare their init routines are likely to be broken.
	252	*/
	253
	254	late_initcall(rs_init);
	255
	256
	257	#ifdef CONFIG_SERIAL_CONSOLE
	258
	259	static void iss_console_write(struct console co, const char s, unsigned count)
	260	{
	261	int len = strlen(s);
	262
	263	if (s != 0 && *s != 0)
	264	__simc (SYS_write, 1, (unsigned long)s,
	265	count < len ? count : len,0,0);
	266	}
	267
	268	static struct tty_driver* iss_console_device(struct console c, int index)
	269	{
	270	*index = c->index;
	271	return serial_driver;
	272	}
	273
	274
	275	static struct console sercons = {
	276	.name = "ttyS",
	277	.write = iss_console_write,
	278	.device = iss_console_device,
	279	.flags = CON_PRINTBUFFER,
	280	.index = -1
	281	};
	282
	283	static int __init iss_console_init(void)
	284	{
	285	register_console(&sercons);
	286	return 0;
	287	}
	288
	289	console_initcall(iss_console_init);
	290
291	#endif /* CONFIG_SERIAL_CONSOLE */
292