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/slab.h>
 19#include <linux/errno.h>
 20#include <linux/atomic.h>
 21#include <linux/console.h>
 22#include <linux/tty.h>
 23#include <linux/tty_driver.h>
 24#include <linux/tty_flip.h>
 25#include <linux/serial_core.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
 33static int kgdb_nmi_knock = 1;
 34module_param_named(knock, kgdb_nmi_knock, int, 0600);
 35MODULE_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
 41static char *kgdb_nmi_magic = "$3#33";
 42module_param_named(magic, kgdb_nmi_magic, charp, 0600);
 43MODULE_PARM_DESC(magic, "magic sequence to enter NMI debugger (default $3#33)");
 44
 45static bool kgdb_nmi_tty_enabled;
 46
 47static 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
 58static struct tty_driver *kgdb_nmi_tty_driver;
 59
 60static 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
 66static 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
 81struct 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
 87static 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
 98static void kgdb_tty_poke(void)
 99{
100	tick_program_event(ktime_get(), 0);
101}
102#else
103static inline void kgdb_tty_poke(void) {}
104#endif
105
106static struct tty_port *kgdb_nmi_port;
107
108static 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
126static 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 */
181bool 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 */
202static void kgdb_nmi_tty_receiver(unsigned long data)
203{
204	struct kgdb_nmi_tty_priv *priv = (void *)data;
205	char ch;
206
207	tasklet_schedule(&priv->tlet);
208
209	if (likely(!kgdb_nmi_tty_enabled || !kfifo_len(&priv->fifo)))
210		return;
211
212	while (kfifo_out(&priv->fifo, &ch, 1))
213		tty_insert_flip_char(&priv->port, ch, TTY_NORMAL);
214	tty_flip_buffer_push(&priv->port);
215}
216
217static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
218{
219	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
220
221	kgdb_nmi_port = port;
222	tasklet_schedule(&priv->tlet);
223	return 0;
224}
225
226static void kgdb_nmi_tty_shutdown(struct tty_port *port)
227{
228	struct kgdb_nmi_tty_priv *priv = port->tty->driver_data;
229
230	tasklet_kill(&priv->tlet);
231	kgdb_nmi_port = NULL;
232}
233
234static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
235	.activate	= kgdb_nmi_tty_activate,
236	.shutdown	= kgdb_nmi_tty_shutdown,
237};
238
239static int kgdb_nmi_tty_install(struct tty_driver *drv, struct tty_struct *tty)
240{
241	struct kgdb_nmi_tty_priv *priv;
242	int ret;
243
244	priv = kzalloc(sizeof(*priv), GFP_KERNEL);
245	if (!priv)
246		return -ENOMEM;
247
248	INIT_KFIFO(priv->fifo);
249	tasklet_init(&priv->tlet, kgdb_nmi_tty_receiver, (unsigned long)priv);
250	tty_port_init(&priv->port);
251	priv->port.ops = &kgdb_nmi_tty_port_ops;
252	tty->driver_data = priv;
253
254	ret = tty_port_install(&priv->port, drv, tty);
255	if (ret) {
256		pr_err("%s: can't install tty port: %d\n", __func__, ret);
257		goto err;
258	}
259	return 0;
260err:
261	tty_port_destroy(&priv->port);
262	kfree(priv);
263	return ret;
264}
265
266static void kgdb_nmi_tty_cleanup(struct tty_struct *tty)
267{
268	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
269
270	tty->driver_data = NULL;
271	tty_port_destroy(&priv->port);
272	kfree(priv);
273}
274
275static int kgdb_nmi_tty_open(struct tty_struct *tty, struct file *file)
276{
277	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
278
279	return tty_port_open(&priv->port, tty, file);
280}
281
282static void kgdb_nmi_tty_close(struct tty_struct *tty, struct file *file)
283{
284	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
285
286	tty_port_close(&priv->port, tty, file);
287}
288
289static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
290{
291	struct kgdb_nmi_tty_priv *priv = tty->driver_data;
292
293	tty_port_hangup(&priv->port);
294}
295
296static int kgdb_nmi_tty_write_room(struct tty_struct *tty)
297{
298	/* Actually, we can handle any amount as we use polled writes. */
299	return 2048;
300}
301
302static int kgdb_nmi_tty_write(struct tty_struct *tty, const unchar *buf, int c)
303{
304	int i;
305
306	for (i = 0; i < c; i++)
307		dbg_io_ops->write_char(buf[i]);
308	return c;
309}
310
311static const struct tty_operations kgdb_nmi_tty_ops = {
312	.open		= kgdb_nmi_tty_open,
313	.close		= kgdb_nmi_tty_close,
314	.install	= kgdb_nmi_tty_install,
315	.cleanup	= kgdb_nmi_tty_cleanup,
316	.hangup		= kgdb_nmi_tty_hangup,
317	.write_room	= kgdb_nmi_tty_write_room,
318	.write		= kgdb_nmi_tty_write,
319};
320
321static int kgdb_nmi_enable_console(int argc, const char *argv[])
322{
323	kgdb_nmi_tty_enabled = !(argc == 1 && !strcmp(argv[1], "off"));
324	return 0;
325}
326
327int kgdb_register_nmi_console(void)
328{
329	int ret;
330
331	if (!arch_kgdb_ops.enable_nmi)
332		return 0;
333
334	kgdb_nmi_tty_driver = alloc_tty_driver(1);
335	if (!kgdb_nmi_tty_driver) {
336		pr_err("%s: cannot allocate tty\n", __func__);
337		return -ENOMEM;
338	}
339	kgdb_nmi_tty_driver->driver_name	= "ttyNMI";
340	kgdb_nmi_tty_driver->name		= "ttyNMI";
341	kgdb_nmi_tty_driver->num		= 1;
342	kgdb_nmi_tty_driver->type		= TTY_DRIVER_TYPE_SERIAL;
343	kgdb_nmi_tty_driver->subtype		= SERIAL_TYPE_NORMAL;
344	kgdb_nmi_tty_driver->flags		= TTY_DRIVER_REAL_RAW;
345	kgdb_nmi_tty_driver->init_termios	= tty_std_termios;
346	tty_termios_encode_baud_rate(&kgdb_nmi_tty_driver->init_termios,
347				     KGDB_NMI_BAUD, KGDB_NMI_BAUD);
348	tty_set_operations(kgdb_nmi_tty_driver, &kgdb_nmi_tty_ops);
349
350	ret = tty_register_driver(kgdb_nmi_tty_driver);
351	if (ret) {
352		pr_err("%s: can't register tty driver: %d\n", __func__, ret);
353		goto err_drv_reg;
354	}
355
356	ret = kdb_register("nmi_console", kgdb_nmi_enable_console, "[off]",
357			   "switch to Linux NMI console", 0);
358	if (ret) {
359		pr_err("%s: can't register kdb command: %d\n", __func__, ret);
360		goto err_kdb_reg;
361	}
362
363	register_console(&kgdb_nmi_console);
364	arch_kgdb_ops.enable_nmi(1);
365
366	return 0;
367err_kdb_reg:
368	tty_unregister_driver(kgdb_nmi_tty_driver);
369err_drv_reg:
370	put_tty_driver(kgdb_nmi_tty_driver);
371	return ret;
372}
373EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
374
375int kgdb_unregister_nmi_console(void)
376{
377	int ret;
378
379	if (!arch_kgdb_ops.enable_nmi)
380		return 0;
381	arch_kgdb_ops.enable_nmi(0);
382
383	kdb_unregister("nmi_console");
384
385	ret = unregister_console(&kgdb_nmi_console);
386	if (ret)
387		return ret;
388
389	ret = tty_unregister_driver(kgdb_nmi_tty_driver);
390	if (ret)
391		return ret;
392	put_tty_driver(kgdb_nmi_tty_driver);
393
394	return 0;
395}
396EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);