[linux-block.git] / arch / cris / arch-v10 / kernel / debugport.c

// SPDX-License-Identifier: GPL-2.0
/* Serialport functions for debugging
 *
 * Copyright (c) 2000-2007 Axis Communications AB
 *
 * Authors:  Bjorn Wesen
 *
 * Exports:
 *    console_print_etrax(char *buf)
 *    int getDebugChar()
 *    putDebugChar(int)
 *    enableDebugIRQ()
 *    init_etrax_debug()
 *
 */

#include <linux/console.h>
#include <linux/init.h>
#include <linux/major.h>
#include <linux/delay.h>
#include <linux/tty.h>
#include <arch/svinto.h>

extern void reset_watchdog(void);

struct dbg_port
{
  unsigned int index;
  const volatile unsigned* read;
  volatile char* write;
  volatile unsigned* xoff;
  volatile char* baud;
  volatile char* tr_ctrl;
  volatile char* rec_ctrl;
  unsigned long irq;
  unsigned int started;
  unsigned long baudrate;
  unsigned char parity;
  unsigned int bits;
};

struct dbg_port ports[]=
{
  {
    0,
    R_SERIAL0_READ,
    R_SERIAL0_TR_DATA,
    R_SERIAL0_XOFF,
    R_SERIAL0_BAUD,
    R_SERIAL0_TR_CTRL,
    R_SERIAL0_REC_CTRL,
    IO_STATE(R_IRQ_MASK1_SET, ser0_data, set),
    0,
    115200,
    'N',
    8
  },
  {
    1,
    R_SERIAL1_READ,
    R_SERIAL1_TR_DATA,
    R_SERIAL1_XOFF,
    R_SERIAL1_BAUD,
    R_SERIAL1_TR_CTRL,
    R_SERIAL1_REC_CTRL,
    IO_STATE(R_IRQ_MASK1_SET, ser1_data, set),
    0,
    115200,
    'N',
    8
  },
  {
    2,
    R_SERIAL2_READ,
    R_SERIAL2_TR_DATA,
    R_SERIAL2_XOFF,
    R_SERIAL2_BAUD,
    R_SERIAL2_TR_CTRL,
    R_SERIAL2_REC_CTRL,
    IO_STATE(R_IRQ_MASK1_SET, ser2_data, set),
    0,
    115200,
    'N',
    8
  },
  {
    3,
    R_SERIAL3_READ,
    R_SERIAL3_TR_DATA,
    R_SERIAL3_XOFF,
    R_SERIAL3_BAUD,
    R_SERIAL3_TR_CTRL,
    R_SERIAL3_REC_CTRL,
    IO_STATE(R_IRQ_MASK1_SET, ser3_data, set),
    0,
    115200,
    'N',
    8
  }
};

#ifdef CONFIG_ETRAX_SERIAL
extern struct tty_driver *serial_driver;
#endif

struct dbg_port* port =
#if defined(CONFIG_ETRAX_DEBUG_PORT0)
  &ports[0];
#elif defined(CONFIG_ETRAX_DEBUG_PORT1)
  &ports[1];
#elif defined(CONFIG_ETRAX_DEBUG_PORT2)
  &ports[2];
#elif defined(CONFIG_ETRAX_DEBUG_PORT3)
  &ports[3];
#else
  NULL;
#endif

static struct dbg_port* kgdb_port =
#if defined(CONFIG_ETRAX_KGDB_PORT0)
  &ports[0];
#elif defined(CONFIG_ETRAX_KGDB_PORT1)
  &ports[1];
#elif defined(CONFIG_ETRAX_KGDB_PORT2)
  &ports[2];
#elif defined(CONFIG_ETRAX_KGDB_PORT3)
  &ports[3];
#else
  NULL;
#endif

static void
start_port(struct dbg_port* p)
{
	unsigned long rec_ctrl = 0;
	unsigned long tr_ctrl = 0;

	if (!p)
		return;

	if (p->started)
		return;
	p->started = 1;

	if (p->index == 0)
	{
		genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma6);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma6, unused);
	}
	else if (p->index == 1)
	{
		genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma8);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma8, usb);
	}
	else if (p->index == 2)
	{
		genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma2);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma2, par0);
		genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma3);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma3, par0);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, ser2, select);
	}
	else
	{
		genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma4);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma4, par1);
		genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma5);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, dma5, par1);
		genconfig_shadow |= IO_STATE(R_GEN_CONFIG, ser3, select);
	}

	*R_GEN_CONFIG = genconfig_shadow;

	*p->xoff =
		IO_STATE(R_SERIAL0_XOFF, tx_stop, enable) |
		IO_STATE(R_SERIAL0_XOFF, auto_xoff, disable) |
		IO_FIELD(R_SERIAL0_XOFF, xoff_char, 0);

	switch (p->baudrate)
	{
	case 0:
	case 115200:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
		break;
	case 1200:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c1200Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c1200Hz);
		break;
	case 2400:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c2400Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c2400Hz);
		break;
	case 4800:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c4800Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c4800Hz);
		break;
	case 9600:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c9600Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c9600Hz);
		  break;
	case 19200:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c19k2Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c19k2Hz);
		 break;
	case 38400:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c38k4Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c38k4Hz);
		break;
	case 57600:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c57k6Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c57k6Hz);
		break;
	default:
		*p->baud =
		  IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) |
		  IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
		  break;
        }

	if (p->parity == 'E') {
		rec_ctrl =
		  IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) |
		  IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
		tr_ctrl =
		  IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) |
		  IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
	} else if (p->parity == 'O') {
		rec_ctrl =
		  IO_STATE(R_SERIAL0_REC_CTRL, rec_par, odd) |
		  IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
		tr_ctrl =
		  IO_STATE(R_SERIAL0_TR_CTRL, tr_par, odd) |
		  IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
	} else {
		rec_ctrl =
		  IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) |
		  IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, disable);
		tr_ctrl =
		  IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) |
		  IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, disable);
	}
	if (p->bits == 7)
	{
		rec_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_7bit);
		tr_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_7bit);
	}
	else
	{
		rec_ctrl |= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_8bit);
		tr_ctrl |= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_8bit);
	}

	*p->rec_ctrl =
		IO_STATE(R_SERIAL0_REC_CTRL, dma_err, stop) |
		IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable) |
		IO_STATE(R_SERIAL0_REC_CTRL, rts_, active) |
		IO_STATE(R_SERIAL0_REC_CTRL, sampling, middle) |
		IO_STATE(R_SERIAL0_REC_CTRL, rec_stick_par, normal) |
		rec_ctrl;

	*p->tr_ctrl =
		IO_FIELD(R_SERIAL0_TR_CTRL, txd, 0) |
		IO_STATE(R_SERIAL0_TR_CTRL, tr_enable, enable) |
		IO_STATE(R_SERIAL0_TR_CTRL, auto_cts, disabled) |
		IO_STATE(R_SERIAL0_TR_CTRL, stop_bits, one_bit) |
		IO_STATE(R_SERIAL0_TR_CTRL, tr_stick_par, normal) |
		tr_ctrl;
}

static void
console_write_direct(struct console *co, const char *buf, unsigned int len)
{
	int i;
	unsigned long flags;

        if (!port)
		return;

	local_irq_save(flags);

	/* Send data */
	for (i = 0; i < len; i++) {
		/* LF -> CRLF */
		if (buf[i] == '\n') {
			while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
			;
			*port->write = '\r';
		}
		/* Wait until transmitter is ready and send.*/
		while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
			;
		*port->write = buf[i];
	}

	/*
	 * Feed the watchdog, otherwise it will reset the chip during boot.
	 * The time to send an ordinary boot message line (10-90 chars)
	 * varies between 1-8ms at 115200. What makes up for the additional
	 * 90ms that allows the watchdog to bite?
	*/
	reset_watchdog();

	local_irq_restore(flags);
}

static void
console_write(struct console *co, const char *buf, unsigned int len)
{
	if (!port)
		return;

        console_write_direct(co, buf, len);
}

/* legacy function */

void
console_print_etrax(const char *buf)
{
	console_write(NULL, buf, strlen(buf));
}

/* Use polling to get a single character FROM the debug port */

int
getDebugChar(void)
{
	unsigned long readval;

	if (!kgdb_port)
		return 0;

	do {
		readval = *kgdb_port->read;
	} while (!(readval & IO_MASK(R_SERIAL0_READ, data_avail)));

	return (readval & IO_MASK(R_SERIAL0_READ, data_in));
}

/* Use polling to put a single character to the debug port */

void
putDebugChar(int val)
{
	if (!kgdb_port)
		return;

	while (!(*kgdb_port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
		;
	*kgdb_port->write = val;
}

/* Enable irq for receiving chars on the debug port, used by kgdb */

void
enableDebugIRQ(void)
{
	if (!kgdb_port)
		return;

	*R_IRQ_MASK1_SET = kgdb_port->irq;
	/* use R_VECT_MASK directly, since we really bypass Linux normal
	 * IRQ handling in kgdb anyway, we don't need to use enable_irq
	 */
	*R_VECT_MASK_SET = IO_STATE(R_VECT_MASK_SET, serial, set);

	*kgdb_port->rec_ctrl = IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable);
}

static int __init
console_setup(struct console *co, char *options)
{
	char* s;

	if (options) {
		port = &ports[co->index];
		port->baudrate = 115200;
                port->parity = 'N';
                port->bits = 8;
		port->baudrate = simple_strtoul(options, NULL, 10);
		s = options;
		while(*s >= '0' && *s <= '9')
			s++;
		if (*s) port->parity = *s++;
		if (*s) port->bits   = *s++ - '0';
		port->started = 0;
		start_port(0);
	}
	return 0;
}


/* This is a dummy serial device that throws away anything written to it.
 * This is used when no debug output is wanted.
 */
static struct tty_driver dummy_driver;

static int dummy_open(struct tty_struct *tty, struct file * filp)
{
	return 0;
}

static void dummy_close(struct tty_struct *tty, struct file * filp)
{
}

static int dummy_write(struct tty_struct * tty,
                       const unsigned char *buf, int count)
{
	return count;
}

static int dummy_write_room(struct tty_struct *tty)
{
	return 8192;
}

static const struct tty_operations dummy_ops = {
	.open = dummy_open,
	.close = dummy_close,
	.write = dummy_write,
	.write_room = dummy_write_room,
};

void __init
init_dummy_console(void)
{
	memset(&dummy_driver, 0, sizeof(struct tty_driver));
	dummy_driver.driver_name = "serial";
	dummy_driver.name = "ttyS";
	dummy_driver.major = TTY_MAJOR;
	dummy_driver.minor_start = 68;
	dummy_driver.num = 1;       /* etrax100 has 4 serial ports */
	dummy_driver.type = TTY_DRIVER_TYPE_SERIAL;
	dummy_driver.subtype = SERIAL_TYPE_NORMAL;
	dummy_driver.init_termios = tty_std_termios;
	/* Normally B9600 default... */
	dummy_driver.init_termios.c_cflag =
		B115200 | CS8 | CREAD | HUPCL | CLOCAL;
	dummy_driver.flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
	dummy_driver.init_termios.c_ispeed = 115200;
	dummy_driver.init_termios.c_ospeed = 115200;

	dummy_driver.ops = &dummy_ops;
	if (tty_register_driver(&dummy_driver))
		panic("Couldn't register dummy serial driver\n");
}

static struct tty_driver*
etrax_console_device(struct console* co, int *index)
{
	if (port)
		*index = port->index;
	else
		*index = 0;
#ifdef CONFIG_ETRAX_SERIAL
        return port ? serial_driver : &dummy_driver;
#else
	return &dummy_driver;
#endif
}

static struct console ser_console = {
	name : "ttyS",
	write: console_write,
	read : NULL,
	device : etrax_console_device,
	unblank : NULL,
	setup : console_setup,
	flags : CON_PRINTBUFFER,
	index : -1,
	cflag : 0,
	next : NULL
};
static struct console ser0_console = {
	name : "ttyS",
	write: console_write,
	read : NULL,
	device : etrax_console_device,
	unblank : NULL,
	setup : console_setup,
	flags : CON_PRINTBUFFER,
	index : 0,
	cflag : 0,
	next : NULL
};

static struct console ser1_console = {
	name : "ttyS",
	write: console_write,
	read : NULL,
	device : etrax_console_device,
	unblank : NULL,
	setup : console_setup,
	flags : CON_PRINTBUFFER,
	index : 1,
	cflag : 0,
	next : NULL
};
static struct console ser2_console = {
	name : "ttyS",
	write: console_write,
	read : NULL,
	device : etrax_console_device,
	unblank : NULL,
	setup : console_setup,
	flags : CON_PRINTBUFFER,
	index : 2,
	cflag : 0,
	next : NULL
};
static struct console ser3_console = {
	name : "ttyS",
	write: console_write,
	read : NULL,
	device : etrax_console_device,
	unblank : NULL,
	setup : console_setup,
	flags : CON_PRINTBUFFER,
	index : 3,
	cflag : 0,
	next : NULL
};
/*
 *      Register console (for printk's etc)
 */

int __init
init_etrax_debug(void)
{
	static int first = 1;

	if (!first) {
		unregister_console(&ser_console);
		register_console(&ser0_console);
		register_console(&ser1_console);
		register_console(&ser2_console);
		register_console(&ser3_console);
                init_dummy_console();
		return 0;
	}

	first = 0;
	register_console(&ser_console);
	start_port(port);
#ifdef CONFIG_ETRAX_KGDB
	start_port(kgdb_port);
#endif
	return 0;
}
__initcall(init_etrax_debug);
Commit	Line	Data
b2441318	1	// SPDX-License-Identifier: GPL-2.0
1da177e4 LT	2	/* Serialport functions for debugging
1da177e4 LT	3	*
18b0f346	4	* Copyright (c) 2000-2007 Axis Communications AB
1da177e4 LT	5	*
	6	* Authors: Bjorn Wesen
	7	*
	8	* Exports:
	9	* console_print_etrax(char *buf)
	10	* int getDebugChar()
	11	* putDebugChar(int)
	12	* enableDebugIRQ()
	13	* init_etrax_debug()
	14	*
1da177e4 LT	15	*/
1da177e4 LT	16
1da177e4 LT	17	#include <linux/console.h>
	18	#include <linux/init.h>
	19	#include <linux/major.h>
	20	#include <linux/delay.h>
	21	#include <linux/tty.h>
556dcee7	22	#include <arch/svinto.h>
1da177e4	23
18b0f346 JN	24	extern void reset_watchdog(void);
18b0f346 JN	25
1da177e4 LT	26	struct dbg_port
	27	{
	28	unsigned int index;
	29	const volatile unsigned* read;
	30	volatile char* write;
	31	volatile unsigned* xoff;
	32	volatile char* baud;
	33	volatile char* tr_ctrl;
	34	volatile char* rec_ctrl;
	35	unsigned long irq;
	36	unsigned int started;
	37	unsigned long baudrate;
	38	unsigned char parity;
	39	unsigned int bits;
	40	};
	41
	42	struct dbg_port ports[]=
	43	{
	44	{
	45	0,
	46	R_SERIAL0_READ,
	47	R_SERIAL0_TR_DATA,
	48	R_SERIAL0_XOFF,
	49	R_SERIAL0_BAUD,
	50	R_SERIAL0_TR_CTRL,
	51	R_SERIAL0_REC_CTRL,
05b4c28c MS	52	IO_STATE(R_IRQ_MASK1_SET, ser0_data, set),
	53	0,
	54	115200,
	55	'N',
	56	8
1da177e4 LT	57	},
	58	{
	59	1,
	60	R_SERIAL1_READ,
	61	R_SERIAL1_TR_DATA,
	62	R_SERIAL1_XOFF,
	63	R_SERIAL1_BAUD,
	64	R_SERIAL1_TR_CTRL,
	65	R_SERIAL1_REC_CTRL,
05b4c28c MS	66	IO_STATE(R_IRQ_MASK1_SET, ser1_data, set),
	67	0,
	68	115200,
	69	'N',
	70	8
1da177e4 LT	71	},
	72	{
	73	2,
	74	R_SERIAL2_READ,
	75	R_SERIAL2_TR_DATA,
	76	R_SERIAL2_XOFF,
	77	R_SERIAL2_BAUD,
	78	R_SERIAL2_TR_CTRL,
	79	R_SERIAL2_REC_CTRL,
05b4c28c MS	80	IO_STATE(R_IRQ_MASK1_SET, ser2_data, set),
	81	0,
	82	115200,
	83	'N',
	84	8
1da177e4 LT	85	},
	86	{
	87	3,
	88	R_SERIAL3_READ,
	89	R_SERIAL3_TR_DATA,
	90	R_SERIAL3_XOFF,
	91	R_SERIAL3_BAUD,
	92	R_SERIAL3_TR_CTRL,
	93	R_SERIAL3_REC_CTRL,
05b4c28c MS	94	IO_STATE(R_IRQ_MASK1_SET, ser3_data, set),
	95	0,
	96	115200,
	97	'N',
	98	8
1da177e4 LT	99	}
	100	};
	101
18b0f346	102	#ifdef CONFIG_ETRAX_SERIAL
05b4c28c	103	extern struct tty_driver *serial_driver;
18b0f346	104	#endif
1da177e4 LT	105
	106	struct dbg_port* port =
	107	#if defined(CONFIG_ETRAX_DEBUG_PORT0)
	108	&ports[0];
	109	#elif defined(CONFIG_ETRAX_DEBUG_PORT1)
	110	&ports[1];
	111	#elif defined(CONFIG_ETRAX_DEBUG_PORT2)
	112	&ports[2];
	113	#elif defined(CONFIG_ETRAX_DEBUG_PORT3)
	114	&ports[3];
	115	#else
	116	NULL;
	117	#endif
1da177e4	118
05b4c28c MS	119	static struct dbg_port* kgdb_port =
	120	#if defined(CONFIG_ETRAX_KGDB_PORT0)
	121	&ports[0];
	122	#elif defined(CONFIG_ETRAX_KGDB_PORT1)
	123	&ports[1];
	124	#elif defined(CONFIG_ETRAX_KGDB_PORT2)
	125	&ports[2];
	126	#elif defined(CONFIG_ETRAX_KGDB_PORT3)
	127	&ports[3];
	128	#else
	129	NULL;
	130	#endif
1da177e4 LT	131
1da177e4 LT	132	static void
05b4c28c	133	start_port(struct dbg_port* p)
1da177e4 LT	134	{
	135	unsigned long rec_ctrl = 0;
	136	unsigned long tr_ctrl = 0;
	137
05b4c28c	138	if (!p)
1da177e4 LT	139	return;
1da177e4 LT	140
05b4c28c	141	if (p->started)
1da177e4	142	return;
05b4c28c	143	p->started = 1;
1da177e4	144
05b4c28c	145	if (p->index == 0)
1da177e4 LT	146	{
	147	genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma6);
	148	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, dma6, unused);
	149	}
05b4c28c	150	else if (p->index == 1)
1da177e4 LT	151	{
	152	genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma8);
	153	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, dma8, usb);
	154	}
05b4c28c	155	else if (p->index == 2)
1da177e4 LT	156	{
	157	genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma2);
	158	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, dma2, par0);
	159	genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma3);
	160	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, dma3, par0);
	161	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, ser2, select);
	162	}
	163	else
	164	{
	165	genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma4);
	166	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, dma4, par1);
	167	genconfig_shadow &= ~IO_MASK(R_GEN_CONFIG, dma5);
	168	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, dma5, par1);
	169	genconfig_shadow \|= IO_STATE(R_GEN_CONFIG, ser3, select);
	170	}
	171
	172	*R_GEN_CONFIG = genconfig_shadow;
	173
05b4c28c	174	*p->xoff =
1da177e4 LT	175	IO_STATE(R_SERIAL0_XOFF, tx_stop, enable) \|
	176	IO_STATE(R_SERIAL0_XOFF, auto_xoff, disable) \|
	177	IO_FIELD(R_SERIAL0_XOFF, xoff_char, 0);
	178
05b4c28c	179	switch (p->baudrate)
1da177e4 LT	180	{
	181	case 0:
	182	case 115200:
05b4c28c	183	*p->baud =
1da177e4 LT	184	IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) \|
	185	IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
	186	break;
	187	case 1200:
05b4c28c	188	*p->baud =
1da177e4 LT	189	IO_STATE(R_SERIAL0_BAUD, tr_baud, c1200Hz) \|
	190	IO_STATE(R_SERIAL0_BAUD, rec_baud, c1200Hz);
	191	break;
	192	case 2400:
05b4c28c	193	*p->baud =
1da177e4 LT	194	IO_STATE(R_SERIAL0_BAUD, tr_baud, c2400Hz) \|
	195	IO_STATE(R_SERIAL0_BAUD, rec_baud, c2400Hz);
	196	break;
	197	case 4800:
05b4c28c	198	*p->baud =
1da177e4 LT	199	IO_STATE(R_SERIAL0_BAUD, tr_baud, c4800Hz) \|
	200	IO_STATE(R_SERIAL0_BAUD, rec_baud, c4800Hz);
	201	break;
	202	case 9600:
05b4c28c	203	*p->baud =
1da177e4 LT	204	IO_STATE(R_SERIAL0_BAUD, tr_baud, c9600Hz) \|
	205	IO_STATE(R_SERIAL0_BAUD, rec_baud, c9600Hz);
	206	break;
	207	case 19200:
05b4c28c	208	*p->baud =
1da177e4 LT	209	IO_STATE(R_SERIAL0_BAUD, tr_baud, c19k2Hz) \|
	210	IO_STATE(R_SERIAL0_BAUD, rec_baud, c19k2Hz);
	211	break;
	212	case 38400:
05b4c28c	213	*p->baud =
1da177e4 LT	214	IO_STATE(R_SERIAL0_BAUD, tr_baud, c38k4Hz) \|
	215	IO_STATE(R_SERIAL0_BAUD, rec_baud, c38k4Hz);
	216	break;
	217	case 57600:
05b4c28c	218	*p->baud =
1da177e4 LT	219	IO_STATE(R_SERIAL0_BAUD, tr_baud, c57k6Hz) \|
	220	IO_STATE(R_SERIAL0_BAUD, rec_baud, c57k6Hz);
	221	break;
	222	default:
05b4c28c	223	*p->baud =
1da177e4 LT	224	IO_STATE(R_SERIAL0_BAUD, tr_baud, c115k2Hz) \|
	225	IO_STATE(R_SERIAL0_BAUD, rec_baud, c115k2Hz);
	226	break;
	227	}
	228
05b4c28c	229	if (p->parity == 'E') {
1da177e4 LT	230	rec_ctrl =
	231	IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) \|
	232	IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
	233	tr_ctrl =
	234	IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) \|
	235	IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
05b4c28c	236	} else if (p->parity == 'O') {
1da177e4 LT	237	rec_ctrl =
	238	IO_STATE(R_SERIAL0_REC_CTRL, rec_par, odd) \|
	239	IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, enable);
	240	tr_ctrl =
	241	IO_STATE(R_SERIAL0_TR_CTRL, tr_par, odd) \|
	242	IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, enable);
	243	} else {
	244	rec_ctrl =
	245	IO_STATE(R_SERIAL0_REC_CTRL, rec_par, even) \|
	246	IO_STATE(R_SERIAL0_REC_CTRL, rec_par_en, disable);
	247	tr_ctrl =
	248	IO_STATE(R_SERIAL0_TR_CTRL, tr_par, even) \|
	249	IO_STATE(R_SERIAL0_TR_CTRL, tr_par_en, disable);
	250	}
05b4c28c	251	if (p->bits == 7)
1da177e4 LT	252	{
	253	rec_ctrl \|= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_7bit);
	254	tr_ctrl \|= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_7bit);
	255	}
	256	else
	257	{
	258	rec_ctrl \|= IO_STATE(R_SERIAL0_REC_CTRL, rec_bitnr, rec_8bit);
	259	tr_ctrl \|= IO_STATE(R_SERIAL0_TR_CTRL, tr_bitnr, tr_8bit);
	260	}
	261
05b4c28c	262	*p->rec_ctrl =
1da177e4 LT	263	IO_STATE(R_SERIAL0_REC_CTRL, dma_err, stop) \|
	264	IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable) \|
	265	IO_STATE(R_SERIAL0_REC_CTRL, rts_, active) \|
	266	IO_STATE(R_SERIAL0_REC_CTRL, sampling, middle) \|
	267	IO_STATE(R_SERIAL0_REC_CTRL, rec_stick_par, normal) \|
	268	rec_ctrl;
	269
05b4c28c	270	*p->tr_ctrl =
1da177e4 LT	271	IO_FIELD(R_SERIAL0_TR_CTRL, txd, 0) \|
	272	IO_STATE(R_SERIAL0_TR_CTRL, tr_enable, enable) \|
	273	IO_STATE(R_SERIAL0_TR_CTRL, auto_cts, disabled) \|
	274	IO_STATE(R_SERIAL0_TR_CTRL, stop_bits, one_bit) \|
	275	IO_STATE(R_SERIAL0_TR_CTRL, tr_stick_par, normal) \|
	276	tr_ctrl;
	277	}
	278
	279	static void
	280	console_write_direct(struct console co, const char buf, unsigned int len)
	281	{
	282	int i;
	283	unsigned long flags;
05b4c28c MS	284
	285	if (!port)
	286	return;
	287
18b0f346 JN	288	local_irq_save(flags);
18b0f346 JN	289
1da177e4 LT	290	/* Send data */
1da177e4 LT	291	for (i = 0; i < len; i++) {
05b4c28c MS	292	/* LF -> CRLF */
	293	if (buf[i] == '\n') {
	294	while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
	295	;
	296	*port->write = '\r';
	297	}
1da177e4 LT	298	/* Wait until transmitter is ready and send.*/
	299	while (!(*port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
	300	;
	301	*port->write = buf[i];
	302	}
1da177e4	303
18b0f346 JN	304	/*
	305	* Feed the watchdog, otherwise it will reset the chip during boot.
	306	* The time to send an ordinary boot message line (10-90 chars)
	307	* varies between 1-8ms at 115200. What makes up for the additional
	308	* 90ms that allows the watchdog to bite?
	309	*/
	310	reset_watchdog();
	311
	312	local_irq_restore(flags);
05b4c28c MS	313	}
05b4c28c MS	314
1da177e4 LT	315	static void
	316	console_write(struct console co, const char buf, unsigned int len)
	317	{
	318	if (!port)
	319	return;
	320
05b4c28c	321	console_write_direct(co, buf, len);
1da177e4 LT	322	}
	323
	324	/* legacy function */
	325
	326	void
	327	console_print_etrax(const char *buf)
	328	{
	329	console_write(NULL, buf, strlen(buf));
	330	}
	331
	332	/* Use polling to get a single character FROM the debug port */
	333
	334	int
	335	getDebugChar(void)
	336	{
	337	unsigned long readval;
	338
05b4c28c MS	339	if (!kgdb_port)
	340	return 0;
	341
1da177e4	342	do {
05b4c28c	343	readval = *kgdb_port->read;
1da177e4 LT	344	} while (!(readval & IO_MASK(R_SERIAL0_READ, data_avail)));
	345
	346	return (readval & IO_MASK(R_SERIAL0_READ, data_in));
	347	}
	348
	349	/* Use polling to put a single character to the debug port */
	350
	351	void
	352	putDebugChar(int val)
	353	{
05b4c28c MS	354	if (!kgdb_port)
	355	return;
	356
	357	while (!(*kgdb_port->read & IO_MASK(R_SERIAL0_READ, tr_ready)))
1da177e4	358	;
05b4c28c	359	*kgdb_port->write = val;
1da177e4 LT	360	}
	361
	362	/* Enable irq for receiving chars on the debug port, used by kgdb */
	363
	364	void
	365	enableDebugIRQ(void)
	366	{
05b4c28c MS	367	if (!kgdb_port)
	368	return;
	369
	370	*R_IRQ_MASK1_SET = kgdb_port->irq;
1da177e4 LT	371	/* use R_VECT_MASK directly, since we really bypass Linux normal
	372	* IRQ handling in kgdb anyway, we don't need to use enable_irq
	373	*/
	374	*R_VECT_MASK_SET = IO_STATE(R_VECT_MASK_SET, serial, set);
	375
05b4c28c	376	*kgdb_port->rec_ctrl = IO_STATE(R_SERIAL0_REC_CTRL, rec_enable, enable);
1da177e4 LT	377	}
	378
	379	static int __init
	380	console_setup(struct console co, char options)
	381	{
	382	char* s;
	383
	384	if (options) {
	385	port = &ports[co->index];
	386	port->baudrate = 115200;
	387	port->parity = 'N';
	388	port->bits = 8;
	389	port->baudrate = simple_strtoul(options, NULL, 10);
	390	s = options;
	391	while(s >= '0' && s <= '9')
	392	s++;
	393	if (s) port->parity = s++;
	394	if (s) port->bits = s++ - '0';
	395	port->started = 0;
05b4c28c	396	start_port(0);
1da177e4 LT	397	}
	398	return 0;
	399	}
	400
18b0f346	401
05b4c28c MS	402	/* This is a dummy serial device that throws away anything written to it.
	403	* This is used when no debug output is wanted.
	404	*/
	405	static struct tty_driver dummy_driver;
	406
	407	static int dummy_open(struct tty_struct tty, struct file filp)
	408	{
	409	return 0;
	410	}
	411
	412	static void dummy_close(struct tty_struct tty, struct file filp)
	413	{
	414	}
	415
	416	static int dummy_write(struct tty_struct * tty,
	417	const unsigned char *buf, int count)
	418	{
	419	return count;
	420	}
	421
3aa30df3	422	static int dummy_write_room(struct tty_struct *tty)
05b4c28c MS	423	{
	424	return 8192;
	425	}
	426
3aa30df3	427	static const struct tty_operations dummy_ops = {
bd451d5e JN	428	.open = dummy_open,
	429	.close = dummy_close,
	430	.write = dummy_write,
	431	.write_room = dummy_write_room,
3aa30df3 HK	432	};
3aa30df3 HK	433
05b4c28c MS	434	void __init
	435	init_dummy_console(void)
	436	{
	437	memset(&dummy_driver, 0, sizeof(struct tty_driver));
	438	dummy_driver.driver_name = "serial";
	439	dummy_driver.name = "ttyS";
	440	dummy_driver.major = TTY_MAJOR;
	441	dummy_driver.minor_start = 68;
	442	dummy_driver.num = 1; /* etrax100 has 4 serial ports */
	443	dummy_driver.type = TTY_DRIVER_TYPE_SERIAL;
	444	dummy_driver.subtype = SERIAL_TYPE_NORMAL;
	445	dummy_driver.init_termios = tty_std_termios;
3aa30df3	446	/* Normally B9600 default... */
05b4c28c	447	dummy_driver.init_termios.c_cflag =
3aa30df3	448	B115200 \| CS8 \| CREAD \| HUPCL \| CLOCAL;
331b8319	449	dummy_driver.flags = TTY_DRIVER_REAL_RAW \| TTY_DRIVER_DYNAMIC_DEV;
3aa30df3 HK	450	dummy_driver.init_termios.c_ispeed = 115200;
3aa30df3 HK	451	dummy_driver.init_termios.c_ospeed = 115200;
05b4c28c	452
3aa30df3	453	dummy_driver.ops = &dummy_ops;
05b4c28c MS	454	if (tty_register_driver(&dummy_driver))
	455	panic("Couldn't register dummy serial driver\n");
	456	}
	457
	458	static struct tty_driver*
	459	etrax_console_device(struct console* co, int *index)
	460	{
	461	if (port)
	462	*index = port->index;
18b0f346 JN	463	else
	464	*index = 0;
	465	#ifdef CONFIG_ETRAX_SERIAL
05b4c28c	466	return port ? serial_driver : &dummy_driver;
18b0f346 JN	467	#else
	468	return &dummy_driver;
	469	#endif
05b4c28c MS	470	}
05b4c28c MS	471
56edefc9	472	static struct console ser_console = {
1da177e4 LT	473	name : "ttyS",
	474	write: console_write,
	475	read : NULL,
	476	device : etrax_console_device,
	477	unblank : NULL,
	478	setup : console_setup,
	479	flags : CON_PRINTBUFFER,
	480	index : -1,
	481	cflag : 0,
	482	next : NULL
	483	};
56edefc9	484	static struct console ser0_console = {
1da177e4 LT	485	name : "ttyS",
	486	write: console_write,
	487	read : NULL,
	488	device : etrax_console_device,
	489	unblank : NULL,
	490	setup : console_setup,
	491	flags : CON_PRINTBUFFER,
	492	index : 0,
	493	cflag : 0,
	494	next : NULL
	495	};
	496
56edefc9	497	static struct console ser1_console = {
1da177e4 LT	498	name : "ttyS",
	499	write: console_write,
	500	read : NULL,
	501	device : etrax_console_device,
	502	unblank : NULL,
	503	setup : console_setup,
	504	flags : CON_PRINTBUFFER,
	505	index : 1,
	506	cflag : 0,
	507	next : NULL
	508	};
56edefc9	509	static struct console ser2_console = {
1da177e4 LT	510	name : "ttyS",
	511	write: console_write,
	512	read : NULL,
	513	device : etrax_console_device,
	514	unblank : NULL,
	515	setup : console_setup,
	516	flags : CON_PRINTBUFFER,
	517	index : 2,
	518	cflag : 0,
	519	next : NULL
	520	};
56edefc9	521	static struct console ser3_console = {
1da177e4 LT	522	name : "ttyS",
	523	write: console_write,
	524	read : NULL,
	525	device : etrax_console_device,
	526	unblank : NULL,
	527	setup : console_setup,
	528	flags : CON_PRINTBUFFER,
	529	index : 3,
	530	cflag : 0,
	531	next : NULL
	532	};
	533	/*
	534	* Register console (for printk's etc)
	535	*/
	536
	537	int __init
	538	init_etrax_debug(void)
	539	{
	540	static int first = 1;
	541
	542	if (!first) {
56edefc9 GR	543	unregister_console(&ser_console);
	544	register_console(&ser0_console);
	545	register_console(&ser1_console);
	546	register_console(&ser2_console);
	547	register_console(&ser3_console);
05b4c28c	548	init_dummy_console();
1da177e4 LT	549	return 0;
1da177e4 LT	550	}
1da177e4	551
05b4c28c	552	first = 0;
56edefc9	553	register_console(&ser_console);
05b4c28c MS	554	start_port(port);
	555	#ifdef CONFIG_ETRAX_KGDB
	556	start_port(kgdb_port);
	557	#endif
1da177e4 LT	558	return 0;
1da177e4 LT	559	}
1da177e4	560	__initcall(init_etrax_debug);