[deliverable/linux.git] / drivers / tty / serial / kgdb_nmi.c

/*
 * KGDB NMI serial console
 *
 * Copyright 2010 Google, Inc.
 *		  Arve Hjønnevåg <arve@android.com>
 *		  Colin Cross <ccross@android.com>
 * Copyright 2012 Linaro Ltd.
 *		  Anton Vorontsov <anton.vorontsov@linaro.org>
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License version 2 as published
 * by the Free Software Foundation.
 */

#include <linux/kernel.h>
#include <linux/module.h>
#include <linux/compiler.h>
#include <linux/init.h>
#include <linux/slab.h>
#include <linux/errno.h>
#include <linux/atomic.h>
#include <linux/console.h>
#include <linux/tty.h>
#include <linux/tty_driver.h>
#include <linux/tty_flip.h>
#include <linux/interrupt.h>
#include <linux/hrtimer.h>
#include <linux/tick.h>
#include <linux/kfifo.h>
#include <linux/kgdb.h>
#include <linux/kdb.h>

static int kgdb_nmi_knock = 1;
module_param_named(knock, kgdb_nmi_knock, int, 0600);
MODULE_PARM_DESC(knock, "if set to 1 (default), the special '$3#33' command " \
			"must be used to enter the debugger; when set to 0, " \
			"hitting return key is enough to enter the debugger; " \
			"when set to -1, the debugger is entered immediately " \
			"upon NMI");

static char *kgdb_nmi_magic = "$3#33";
module_param_named(magic, kgdb_nmi_magic, charp, 0600);
MODULE_PARM_DESC(magic, "magic sequence to enter NMI debugger (default $3#33)");

static bool kgdb_nmi_tty_enabled;

static void kgdb_nmi_console_write(struct console *co, const char *s, uint c)
{
	int i;

	if (!kgdb_nmi_tty_enabled || atomic_read(&kgdb_active) >= 0)
		return;

	for (i = 0; i < c; i++)
		dbg_io_ops->write_char(s[i]);
}

static struct tty_driver *kgdb_nmi_tty_driver;

static struct tty_driver *kgdb_nmi_console_device(struct console *co, int *idx)
{
	*idx = co->index;
	return kgdb_nmi_tty_driver;
}

static struct console kgdb_nmi_console = {
	.name	= "ttyNMI",
	.write	= kgdb_nmi_console_write,
	.device	= kgdb_nmi_console_device,
	.flags	= CON_PRINTBUFFER | CON_ANYTIME | CON_ENABLED,
	.index	= -1,
};

/*
 * This is usually the maximum rate on debug ports. We make fifo large enough
 * to make copy-pasting to the terminal usable.
 */
#define KGDB_NMI_BAUD		115200
#define KGDB_NMI_FIFO_SIZE	roundup_pow_of_two(KGDB_NMI_BAUD / 8 / HZ)

struct kgdb_nmi_tty_priv {
	struct tty_port port;
	struct tasklet_struct tlet;
	STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
};

static struct kgdb_nmi_tty_priv *kgdb_nmi_port_to_priv(struct tty_port *port)
{
	return container_of(port, struct kgdb_nmi_tty_priv, port);
}

/*
 * Our debugging console is polled in a tasklet, so we'll check for input
 * every tick. In HZ-less mode, we should program the next tick.  We have
 * to use the lowlevel stuff as no locks should be grabbed.
 */
#ifdef CONFIG_HIGH_RES_TIMERS
static void kgdb_tty_poke(void)
{
	tick_program_event(ktime_get(), 0);
}
#else
static inline void kgdb_tty_poke(void) {}
#endif

static struct tty_port *kgdb_nmi_port;

static void kgdb_tty_recv(int ch)
{
	struct kgdb_nmi_tty_priv *priv;
	char c = ch;

	if (!kgdb_nmi_port || ch < 0)
		return;
	/*
	 * Can't use port->tty->driver_data as tty might be not there. Tasklet
	 * will check for tty and will get the ref, but here we don't have to
	 * do that, and actually, we can't: we're in NMI context, no locks are
	 * possible.
	 */
	priv = kgdb_nmi_port_to_priv(kgdb_nmi_port);
	kfifo_in(&priv->fifo, &c, 1);
	kgdb_tty_poke();
}

static int kgdb_nmi_poll_one_knock(void)
{
	static int n;
	int c = -1;
	const char *magic = kgdb_nmi_magic;
	size_t m = strlen(magic);
	bool printch = 0;

	c = dbg_io_ops->read_char();
	if (c == NO_POLL_CHAR)
		return c;

	if (!kgdb_nmi_knock && (c == '\r' || c == '\n')) {
		return 1;
	} else if (c == magic[n]) {
		n = (n + 1) % m;
		if (!n)
			return 1;
		printch = 1;
	} else {
		n = 0;
	}

	if (kgdb_nmi_tty_enabled) {
		kgdb_tty_recv(c);
		return 0;
	}

	if (printch) {
		kdb_printf("%c", c);
		return 0;
	}

	kdb_printf("\r%s %s to enter the debugger> %*s",
		   kgdb_nmi_knock ? "Type" : "Hit",
		   kgdb_nmi_knock ? magic  : "<return>", (int)m, "");
	while (m--)
		kdb_printf("\b");
	return 0;
}

/**
 * kgdb_nmi_poll_knock - Check if it is time to enter the debugger
 *
 * "Serial ports are often noisy, especially when muxed over another port (we
 * often use serial over the headset connector). Noise on the async command
 * line just causes characters that are ignored, on a command line that blocked
 * execution noise would be catastrophic." -- Colin Cross
 *
 * So, this function implements KGDB/KDB knocking on the serial line: we won't
 * enter the debugger until we receive a known magic phrase (which is actually
 * "$3#33", known as "escape to KDB" command. There is also a relaxed variant
 * of knocking, i.e. just pressing the return key is enough to enter the
 * debugger. And if knocking is disabled, the function always returns 1.
 */
bool kgdb_nmi_poll_knock(void)
{
	if (kgdb_nmi_knock < 0)
		return 1;

	while (1) {
		int ret;

		ret = kgdb_nmi_poll_one_knock();
		if (ret == NO_POLL_CHAR)
			return 0;
		else if (ret == 1)
			break;
	}
	return 1;
}

/*
 * The tasklet is cheap, it does not cause wakeups when reschedules itself,
 * instead it waits for the next tick.
 */
static void kgdb_nmi_tty_receiver(unsigned long data)
{
	struct kgdb_nmi_tty_priv *priv = (void *)data;
	struct tty_struct *tty;
	char ch;

	tasklet_schedule(&priv->tlet);

	if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo)))
		return;

	/* Port is there, but tty might be hung up, check. */
	tty = tty_port_tty_get(kgdb_nmi_port);
	if (!tty)
		return;

	while (kfifo_out(&priv->fifo, &ch, 1))
		tty_insert_flip_char(priv->port.tty, ch, TTY_NORMAL);
	tty_flip_buffer_push(priv->port.tty);

	tty_kref_put(tty);
}

static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
{
	struct kgdb_nmi_tty_priv *priv = tty->driver_data;

	kgdb_nmi_port = port;
	tasklet_schedule(&priv->tlet);
	return 0;
}

static void kgdb_nmi_tty_shutdown(struct tty_port *port)
{
	struct kgdb_nmi_tty_priv *priv = port->tty->driver_data;

	tasklet_kill(&priv->tlet);
	kgdb_nmi_port = NULL;
}

static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
	.activate	= kgdb_nmi_tty_activate,
	.shutdown	= kgdb_nmi_tty_shutdown,
};

static int kgdb_nmi_tty_install(struct tty_driver *drv, struct tty_struct *tty)
{
	struct kgdb_nmi_tty_priv *priv;
	int ret;

	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
	if (!priv)
		return -ENOMEM;

	INIT_KFIFO(priv->fifo);
	tasklet_init(&priv->tlet, kgdb_nmi_tty_receiver, (unsigned long)priv);
	tty_port_init(&priv->port);
	priv->port.ops = &kgdb_nmi_tty_port_ops;
	tty->driver_data = priv;

	ret = tty_port_install(&priv->port, drv, tty);
	if (ret) {
		pr_err("%s: can't install tty port: %d\n", __func__, ret);
		goto err;
	}
	return 0;
err:
	tty_port_destroy(&priv->port);
	kfree(priv);
	return ret;
}

static void kgdb_nmi_tty_cleanup(struct tty_struct *tty)
{
	struct kgdb_nmi_tty_priv *priv = tty->driver_data;

	tty->driver_data = NULL;
	tty_port_destroy(&priv->port);
	kfree(priv);
}

static int kgdb_nmi_tty_open(struct tty_struct *tty, struct file *file)
{
	struct kgdb_nmi_tty_priv *priv = tty->driver_data;

	return tty_port_open(&priv->port, tty, file);
}

static void kgdb_nmi_tty_close(struct tty_struct *tty, struct file *file)
{
	struct kgdb_nmi_tty_priv *priv = tty->driver_data;

	tty_port_close(&priv->port, tty, file);
}

static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
{
	struct kgdb_nmi_tty_priv *priv = tty->driver_data;

	tty_port_hangup(&priv->port);
}

static int kgdb_nmi_tty_write_room(struct tty_struct *tty)
{
	/* Actually, we can handle any amount as we use polled writes. */
	return 2048;
}

static int kgdb_nmi_tty_write(struct tty_struct *tty, const unchar *buf, int c)
{
	int i;

	for (i = 0; i < c; i++)
		dbg_io_ops->write_char(buf[i]);
	return c;
}

static const struct tty_operations kgdb_nmi_tty_ops = {
	.open		= kgdb_nmi_tty_open,
	.close		= kgdb_nmi_tty_close,
	.install	= kgdb_nmi_tty_install,
	.cleanup	= kgdb_nmi_tty_cleanup,
	.hangup		= kgdb_nmi_tty_hangup,
	.write_room	= kgdb_nmi_tty_write_room,
	.write		= kgdb_nmi_tty_write,
};

static int kgdb_nmi_enable_console(int argc, const char *argv[])
{
	kgdb_nmi_tty_enabled = !(argc == 1 && !strcmp(argv[1], "off"));
	return 0;
}

int kgdb_register_nmi_console(void)
{
	int ret;

	if (!arch_kgdb_ops.enable_nmi)
		return 0;

	kgdb_nmi_tty_driver = alloc_tty_driver(1);
	if (!kgdb_nmi_tty_driver) {
		pr_err("%s: cannot allocate tty\n", __func__);
		return -ENOMEM;
	}
	kgdb_nmi_tty_driver->driver_name	= "ttyNMI";
	kgdb_nmi_tty_driver->name		= "ttyNMI";
	kgdb_nmi_tty_driver->num		= 1;
	kgdb_nmi_tty_driver->type		= TTY_DRIVER_TYPE_SERIAL;
	kgdb_nmi_tty_driver->subtype		= SERIAL_TYPE_NORMAL;
	kgdb_nmi_tty_driver->flags		= TTY_DRIVER_REAL_RAW;
	kgdb_nmi_tty_driver->init_termios	= tty_std_termios;
	tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios,
				     KGDB_NMI_BAUD, KGDB_NMI_BAUD);
	tty_set_operations(kgdb_nmi_tty_driver, &kgdb_nmi_tty_ops);

	ret = tty_register_driver(kgdb_nmi_tty_driver);
	if (ret) {
		pr_err("%s: can't register tty driver: %d\n", __func__, ret);
		goto err_drv_reg;
	}

	ret = kdb_register("nmi_console", kgdb_nmi_enable_console, "[off]",
			   "switch to Linux NMI console", 0);
	if (ret) {
		pr_err("%s: can't register kdb command: %d\n", __func__, ret);
		goto err_kdb_reg;
	}

	register_console(&kgdb_nmi_console);
	arch_kgdb_ops.enable_nmi(1);

	return 0;
err_kdb_reg:
	tty_unregister_driver(kgdb_nmi_tty_driver);
err_drv_reg:
	put_tty_driver(kgdb_nmi_tty_driver);
	return ret;
}
EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);

int kgdb_unregister_nmi_console(void)
{
	int ret;

	if (!arch_kgdb_ops.enable_nmi)
		return 0;
	arch_kgdb_ops.enable_nmi(0);

	kdb_unregister("nmi_console");

	ret = unregister_console(&kgdb_nmi_console);
	if (ret)
		return ret;

	ret = tty_unregister_driver(kgdb_nmi_tty_driver);
	if (ret)
		return ret;
	put_tty_driver(kgdb_nmi_tty_driver);

	return 0;
}
EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);
Commit	Line	Data
0c57dfcc AV	1	/*
	2	* KGDB NMI serial console
	3	*
	4	* Copyright 2010 Google, Inc.
	5	* Arve Hjønnevåg <arve@android.com>
	6	* Colin Cross <ccross@android.com>
	7	* Copyright 2012 Linaro Ltd.
	8	* Anton Vorontsov <anton.vorontsov@linaro.org>
	9	*
	10	* This program is free software; you can redistribute it and/or modify it
	11	* under the terms of the GNU General Public License version 2 as published
	12	* by the Free Software Foundation.
	13	*/
	14
	15	#include <linux/kernel.h>
	16	#include <linux/module.h>
	17	#include <linux/compiler.h>
	18	#include <linux/init.h>
	19	#include <linux/slab.h>
	20	#include <linux/errno.h>
	21	#include <linux/atomic.h>
	22	#include <linux/console.h>
	23	#include <linux/tty.h>
	24	#include <linux/tty_driver.h>
	25	#include <linux/tty_flip.h>
	26	#include <linux/interrupt.h>
	27	#include <linux/hrtimer.h>
	28	#include <linux/tick.h>
	29	#include <linux/kfifo.h>
	30	#include <linux/kgdb.h>
	31	#include <linux/kdb.h>
	32
	33	static int kgdb_nmi_knock = 1;
	34	module_param_named(knock, kgdb_nmi_knock, int, 0600);
	35	MODULE_PARM_DESC(knock, "if set to 1 (default), the special '$3#33' command " \
	36	"must be used to enter the debugger; when set to 0, " \
	37	"hitting return key is enough to enter the debugger; " \
	38	"when set to -1, the debugger is entered immediately " \
	39	"upon NMI");
	40
	41	static char *kgdb_nmi_magic = "$3#33";
	42	module_param_named(magic, kgdb_nmi_magic, charp, 0600);
	43	MODULE_PARM_DESC(magic, "magic sequence to enter NMI debugger (default $3#33)");
	44
	45	static bool kgdb_nmi_tty_enabled;
	46
	47	static void kgdb_nmi_console_write(struct console co, const char s, uint c)
	48	{
	49	int i;
	50
	51	if (!kgdb_nmi_tty_enabled \|\| atomic_read(&kgdb_active) >= 0)
	52	return;
	53
	54	for (i = 0; i < c; i++)
	55	dbg_io_ops->write_char(s[i]);
	56	}
	57
	58	static struct tty_driver *kgdb_nmi_tty_driver;
	59
	60	static struct tty_driver kgdb_nmi_console_device(struct console co, int *idx)
	61	{
	62	*idx = co->index;
	63	return kgdb_nmi_tty_driver;
	64	}
65
66	static struct console kgdb_nmi_console = {
67	.name = "ttyNMI",
68	.write = kgdb_nmi_console_write,
69	.device = kgdb_nmi_console_device,
70	.flags = CON_PRINTBUFFER \| CON_ANYTIME \| CON_ENABLED,
71	.index = -1,
72	};
73
74	/*
75	* This is usually the maximum rate on debug ports. We make fifo large enough
76	* to make copy-pasting to the terminal usable.
77	*/
78	#define KGDB_NMI_BAUD 115200
79	#define KGDB_NMI_FIFO_SIZE roundup_pow_of_two(KGDB_NMI_BAUD / 8 / HZ)
80
81	struct kgdb_nmi_tty_priv {
82	struct tty_port port;
83	struct tasklet_struct tlet;
84	STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
85	};
86
87	static struct kgdb_nmi_tty_priv kgdb_nmi_port_to_priv(struct tty_port port)
88	{
89	return container_of(port, struct kgdb_nmi_tty_priv, port);
90	}
91
92	/*
93	* Our debugging console is polled in a tasklet, so we'll check for input
94	* every tick. In HZ-less mode, we should program the next tick. We have
95	* to use the lowlevel stuff as no locks should be grabbed.
96	*/
97	#ifdef CONFIG_HIGH_RES_TIMERS
98	static void kgdb_tty_poke(void)
99	{
100	tick_program_event(ktime_get(), 0);
101	}
102	#else
103	static inline void kgdb_tty_poke(void) {}
104	#endif
105
106	static struct tty_port *kgdb_nmi_port;
107
108	static void kgdb_tty_recv(int ch)
109	{
110	struct kgdb_nmi_tty_priv *priv;
111	char c = ch;
112
113	if (!kgdb_nmi_port \|\| ch < 0)
114	return;
115	/*
116	* Can't use port->tty->driver_data as tty might be not there. Tasklet
117	* will check for tty and will get the ref, but here we don't have to
118	* do that, and actually, we can't: we're in NMI context, no locks are
119	* possible.
120	*/
121	priv = kgdb_nmi_port_to_priv(kgdb_nmi_port);
122	kfifo_in(&priv->fifo, &c, 1);
123	kgdb_tty_poke();
124	}
125
126	static int kgdb_nmi_poll_one_knock(void)
127	{
128	static int n;
129	int c = -1;
130	const char *magic = kgdb_nmi_magic;
131	size_t m = strlen(magic);
132	bool printch = 0;
133
134	c = dbg_io_ops->read_char();
135	if (c == NO_POLL_CHAR)
136	return c;
137
138	if (!kgdb_nmi_knock && (c == '\r' \|\| c == '\n')) {
139	return 1;
140	} else if (c == magic[n]) {
141	n = (n + 1) % m;
142	if (!n)
143	return 1;
144	printch = 1;
145	} else {
146	n = 0;
147	}
148
149	if (kgdb_nmi_tty_enabled) {
150	kgdb_tty_recv(c);
151	return 0;
152	}
153
154	if (printch) {
155	kdb_printf("%c", c);
156	return 0;
157	}
158
159	kdb_printf("\r%s %s to enter the debugger> %*s",
160	kgdb_nmi_knock ? "Type" : "Hit",
161	kgdb_nmi_knock ? magic : "<return>", (int)m, "");
162	while (m--)
163	kdb_printf("\b");
164	return 0;
165	}
166
167	/**
168	* kgdb_nmi_poll_knock - Check if it is time to enter the debugger
169	*
170	* "Serial ports are often noisy, especially when muxed over another port (we
171	* often use serial over the headset connector). Noise on the async command
172	* line just causes characters that are ignored, on a command line that blocked
173	* execution noise would be catastrophic." -- Colin Cross
174	*
175	* So, this function implements KGDB/KDB knocking on the serial line: we won't
176	* enter the debugger until we receive a known magic phrase (which is actually
177	* "$3#33", known as "escape to KDB" command. There is also a relaxed variant
178	* of knocking, i.e. just pressing the return key is enough to enter the
179	* debugger. And if knocking is disabled, the function always returns 1.
180	*/
181	bool kgdb_nmi_poll_knock(void)
182	{
183	if (kgdb_nmi_knock < 0)
184	return 1;
185
186	while (1) {
187	int ret;
188
189	ret = kgdb_nmi_poll_one_knock();
190	if (ret == NO_POLL_CHAR)
191	return 0;
192	else if (ret == 1)
193	break;
194	}
195	return 1;
196	}
197
198	/*
199	* The tasklet is cheap, it does not cause wakeups when reschedules itself,
200	* instead it waits for the next tick.
201	*/
202	static void kgdb_nmi_tty_receiver(unsigned long data)
203	{
204	struct kgdb_nmi_tty_priv priv = (void )data;
205	struct tty_struct *tty;
206	char ch;
207
208	tasklet_schedule(&priv->tlet);
209
210	if (likely(!kgdb_nmi_tty_enabled \|\| !kfifo_len(&priv->fifo)))
211	return;
212
213	/* Port is there, but tty might be hung up, check. */
214	tty = tty_port_tty_get(kgdb_nmi_port);
215	if (!tty)
216	return;
217
218	while (kfifo_out(&priv->fifo, &ch, 1))
219	tty_insert_flip_char(priv->port.tty, ch, TTY_NORMAL);
220	tty_flip_buffer_push(priv->port.tty);
221
222	tty_kref_put(tty);
223	}
224
225	static int kgdb_nmi_tty_activate(struct tty_port port, struct tty_struct tty)
226	{
227	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
228
229	kgdb_nmi_port = port;
230	tasklet_schedule(&priv->tlet);
231	return 0;
232	}
233
234	static void kgdb_nmi_tty_shutdown(struct tty_port *port)
235	{
236	struct kgdb_nmi_tty_priv *priv = port->tty->driver_data;
237
238	tasklet_kill(&priv->tlet);
239	kgdb_nmi_port = NULL;
240	}
241
242	static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
243	.activate = kgdb_nmi_tty_activate,
244	.shutdown = kgdb_nmi_tty_shutdown,
245	};
246
247	static int kgdb_nmi_tty_install(struct tty_driver drv, struct tty_struct tty)
248	{
249	struct kgdb_nmi_tty_priv *priv;
250	int ret;
251
252	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
253	if (!priv)
254	return -ENOMEM;
255
256	INIT_KFIFO(priv->fifo);
257	tasklet_init(&priv->tlet, kgdb_nmi_tty_receiver, (unsigned long)priv);
258	tty_port_init(&priv->port);
259	priv->port.ops = &kgdb_nmi_tty_port_ops;
260	tty->driver_data = priv;
261
262	ret = tty_port_install(&priv->port, drv, tty);
263	if (ret) {
264	pr_err("%s: can't install tty port: %d\n", __func__, ret);
265	goto err;
266	}
267	return 0;
268	err:
191c5f10	269	tty_port_destroy(&priv->port);
0c57dfcc AV	270	kfree(priv);
	271	return ret;
	272	}
	273
	274	static void kgdb_nmi_tty_cleanup(struct tty_struct *tty)
	275	{
	276	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
	277
	278	tty->driver_data = NULL;
191c5f10	279	tty_port_destroy(&priv->port);
0c57dfcc AV	280	kfree(priv);
	281	}
	282
	283	static int kgdb_nmi_tty_open(struct tty_struct tty, struct file file)
	284	{
	285	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
	286
	287	return tty_port_open(&priv->port, tty, file);
	288	}
	289
	290	static void kgdb_nmi_tty_close(struct tty_struct tty, struct file file)
	291	{
	292	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
	293
	294	tty_port_close(&priv->port, tty, file);
	295	}
	296
	297	static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
	298	{
	299	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
	300
	301	tty_port_hangup(&priv->port);
	302	}
	303
	304	static int kgdb_nmi_tty_write_room(struct tty_struct *tty)
	305	{
	306	/* Actually, we can handle any amount as we use polled writes. */
	307	return 2048;
	308	}
	309
	310	static int kgdb_nmi_tty_write(struct tty_struct tty, const unchar buf, int c)
	311	{
	312	int i;
	313
	314	for (i = 0; i < c; i++)
	315	dbg_io_ops->write_char(buf[i]);
	316	return c;
	317	}
	318
	319	static const struct tty_operations kgdb_nmi_tty_ops = {
	320	.open = kgdb_nmi_tty_open,
	321	.close = kgdb_nmi_tty_close,
	322	.install = kgdb_nmi_tty_install,
	323	.cleanup = kgdb_nmi_tty_cleanup,
	324	.hangup = kgdb_nmi_tty_hangup,
	325	.write_room = kgdb_nmi_tty_write_room,
	326	.write = kgdb_nmi_tty_write,
	327	};
	328
	329	static int kgdb_nmi_enable_console(int argc, const char *argv[])
	330	{
	331	kgdb_nmi_tty_enabled = !(argc == 1 && !strcmp(argv[1], "off"));
	332	return 0;
	333	}
	334
	335	int kgdb_register_nmi_console(void)
	336	{
	337	int ret;
	338
	339	if (!arch_kgdb_ops.enable_nmi)
	340	return 0;
	341
	342	kgdb_nmi_tty_driver = alloc_tty_driver(1);
	343	if (!kgdb_nmi_tty_driver) {
344	pr_err("%s: cannot allocate tty\n", __func__);
345	return -ENOMEM;
346	}
347	kgdb_nmi_tty_driver->driver_name = "ttyNMI";
348	kgdb_nmi_tty_driver->name = "ttyNMI";
349	kgdb_nmi_tty_driver->num = 1;
350	kgdb_nmi_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
351	kgdb_nmi_tty_driver->subtype = SERIAL_TYPE_NORMAL;
352	kgdb_nmi_tty_driver->flags = TTY_DRIVER_REAL_RAW;
353	kgdb_nmi_tty_driver->init_termios = tty_std_termios;
354	tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios,
355	KGDB_NMI_BAUD, KGDB_NMI_BAUD);
356	tty_set_operations(kgdb_nmi_tty_driver, &kgdb_nmi_tty_ops);
357
358	ret = tty_register_driver(kgdb_nmi_tty_driver);
359	if (ret) {
360	pr_err("%s: can't register tty driver: %d\n", __func__, ret);
361	goto err_drv_reg;
362	}
363
364	ret = kdb_register("nmi_console", kgdb_nmi_enable_console, "[off]",
365	"switch to Linux NMI console", 0);
366	if (ret) {
367	pr_err("%s: can't register kdb command: %d\n", __func__, ret);
368	goto err_kdb_reg;
369	}
370
371	register_console(&kgdb_nmi_console);
372	arch_kgdb_ops.enable_nmi(1);
373
374	return 0;
375	err_kdb_reg:
376	tty_unregister_driver(kgdb_nmi_tty_driver);
377	err_drv_reg:
378	put_tty_driver(kgdb_nmi_tty_driver);
379	return ret;
380	}
381	EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
382
383	int kgdb_unregister_nmi_console(void)
384	{
385	int ret;
386
387	if (!arch_kgdb_ops.enable_nmi)
388	return 0;
389	arch_kgdb_ops.enable_nmi(0);
390
391	kdb_unregister("nmi_console");
392
393	ret = unregister_console(&kgdb_nmi_console);
394	if (ret)
395	return ret;
396
397	ret = tty_unregister_driver(kgdb_nmi_tty_driver);
398	if (ret)
399	return ret;
400	put_tty_driver(kgdb_nmi_tty_driver);
401
402	return 0;
403	}
404	EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);