2 * KGDB NMI serial console
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>
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.
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>
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 " \
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)");
45 static atomic_t kgdb_nmi_num_readers = ATOMIC_INIT(0);
47 static int kgdb_nmi_console_setup(struct console *co, char *options)
49 /* The NMI console uses the dbg_io_ops to issue console messages. To
50 * avoid duplicate messages during kdb sessions we must inform kdb's
51 * I/O utilities that messages sent to the console will automatically
52 * be displayed on the dbg_io.
54 dbg_io_ops->is_console = true;
59 static void kgdb_nmi_console_write(struct console *co, const char *s, uint c)
63 for (i = 0; i < c; i++)
64 dbg_io_ops->write_char(s[i]);
67 static struct tty_driver *kgdb_nmi_tty_driver;
69 static struct tty_driver *kgdb_nmi_console_device(struct console *co, int *idx)
72 return kgdb_nmi_tty_driver;
75 static struct console kgdb_nmi_console = {
77 .setup = kgdb_nmi_console_setup,
78 .write = kgdb_nmi_console_write,
79 .device = kgdb_nmi_console_device,
80 .flags = CON_PRINTBUFFER | CON_ANYTIME | CON_ENABLED,
85 * This is usually the maximum rate on debug ports. We make fifo large enough
86 * to make copy-pasting to the terminal usable.
88 #define KGDB_NMI_BAUD 115200
89 #define KGDB_NMI_FIFO_SIZE roundup_pow_of_two(KGDB_NMI_BAUD / 8 / HZ)
91 struct kgdb_nmi_tty_priv {
93 struct timer_list timer;
94 STRUCT_KFIFO(char, KGDB_NMI_FIFO_SIZE) fifo;
97 static struct tty_port *kgdb_nmi_port;
99 static void kgdb_tty_recv(int ch)
101 struct kgdb_nmi_tty_priv *priv;
104 if (!kgdb_nmi_port || ch < 0)
107 * Can't use port->tty->driver_data as tty might be not there. Timer
108 * will check for tty and will get the ref, but here we don't have to
109 * do that, and actually, we can't: we're in NMI context, no locks are
112 priv = container_of(kgdb_nmi_port, struct kgdb_nmi_tty_priv, port);
113 kfifo_in(&priv->fifo, &c, 1);
116 static int kgdb_nmi_poll_one_knock(void)
120 const char *magic = kgdb_nmi_magic;
121 size_t m = strlen(magic);
124 c = dbg_io_ops->read_char();
125 if (c == NO_POLL_CHAR)
128 if (!kgdb_nmi_knock && (c == '\r' || c == '\n')) {
130 } else if (c == magic[n]) {
139 if (atomic_read(&kgdb_nmi_num_readers)) {
149 kdb_printf("\r%s %s to enter the debugger> %*s",
150 kgdb_nmi_knock ? "Type" : "Hit",
151 kgdb_nmi_knock ? magic : "<return>", (int)m, "");
158 * kgdb_nmi_poll_knock - Check if it is time to enter the debugger
160 * "Serial ports are often noisy, especially when muxed over another port (we
161 * often use serial over the headset connector). Noise on the async command
162 * line just causes characters that are ignored, on a command line that blocked
163 * execution noise would be catastrophic." -- Colin Cross
165 * So, this function implements KGDB/KDB knocking on the serial line: we won't
166 * enter the debugger until we receive a known magic phrase (which is actually
167 * "$3#33", known as "escape to KDB" command. There is also a relaxed variant
168 * of knocking, i.e. just pressing the return key is enough to enter the
169 * debugger. And if knocking is disabled, the function always returns 1.
171 bool kgdb_nmi_poll_knock(void)
173 if (kgdb_nmi_knock < 0)
179 ret = kgdb_nmi_poll_one_knock();
180 if (ret == NO_POLL_CHAR)
189 * The tasklet is cheap, it does not cause wakeups when reschedules itself,
190 * instead it waits for the next tick.
192 static void kgdb_nmi_tty_receiver(unsigned long data)
194 struct kgdb_nmi_tty_priv *priv = (void *)data;
197 priv->timer.expires = jiffies + (HZ/100);
198 add_timer(&priv->timer);
200 if (likely(!atomic_read(&kgdb_nmi_num_readers) ||
201 !kfifo_len(&priv->fifo)))
204 while (kfifo_out(&priv->fifo, &ch, 1))
205 tty_insert_flip_char(&priv->port, ch, TTY_NORMAL);
206 tty_flip_buffer_push(&priv->port);
209 static int kgdb_nmi_tty_activate(struct tty_port *port, struct tty_struct *tty)
211 struct kgdb_nmi_tty_priv *priv =
212 container_of(port, struct kgdb_nmi_tty_priv, port);
214 kgdb_nmi_port = port;
215 priv->timer.expires = jiffies + (HZ/100);
216 add_timer(&priv->timer);
221 static void kgdb_nmi_tty_shutdown(struct tty_port *port)
223 struct kgdb_nmi_tty_priv *priv =
224 container_of(port, struct kgdb_nmi_tty_priv, port);
226 del_timer(&priv->timer);
227 kgdb_nmi_port = NULL;
230 static const struct tty_port_operations kgdb_nmi_tty_port_ops = {
231 .activate = kgdb_nmi_tty_activate,
232 .shutdown = kgdb_nmi_tty_shutdown,
235 static int kgdb_nmi_tty_install(struct tty_driver *drv, struct tty_struct *tty)
237 struct kgdb_nmi_tty_priv *priv;
240 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
244 INIT_KFIFO(priv->fifo);
245 setup_timer(&priv->timer, kgdb_nmi_tty_receiver, (unsigned long)priv);
246 tty_port_init(&priv->port);
247 priv->port.ops = &kgdb_nmi_tty_port_ops;
248 tty->driver_data = priv;
250 ret = tty_port_install(&priv->port, drv, tty);
252 pr_err("%s: can't install tty port: %d\n", __func__, ret);
257 tty_port_destroy(&priv->port);
262 static void kgdb_nmi_tty_cleanup(struct tty_struct *tty)
264 struct kgdb_nmi_tty_priv *priv = tty->driver_data;
266 tty->driver_data = NULL;
267 tty_port_destroy(&priv->port);
271 static int kgdb_nmi_tty_open(struct tty_struct *tty, struct file *file)
273 struct kgdb_nmi_tty_priv *priv = tty->driver_data;
274 unsigned int mode = file->f_flags & O_ACCMODE;
277 ret = tty_port_open(&priv->port, tty, file);
278 if (!ret && (mode == O_RDONLY || mode == O_RDWR))
279 atomic_inc(&kgdb_nmi_num_readers);
284 static void kgdb_nmi_tty_close(struct tty_struct *tty, struct file *file)
286 struct kgdb_nmi_tty_priv *priv = tty->driver_data;
287 unsigned int mode = file->f_flags & O_ACCMODE;
289 if (mode == O_RDONLY || mode == O_RDWR)
290 atomic_dec(&kgdb_nmi_num_readers);
292 tty_port_close(&priv->port, tty, file);
295 static void kgdb_nmi_tty_hangup(struct tty_struct *tty)
297 struct kgdb_nmi_tty_priv *priv = tty->driver_data;
299 tty_port_hangup(&priv->port);
302 static int kgdb_nmi_tty_write_room(struct tty_struct *tty)
304 /* Actually, we can handle any amount as we use polled writes. */
308 static int kgdb_nmi_tty_write(struct tty_struct *tty, const unchar *buf, int c)
312 for (i = 0; i < c; i++)
313 dbg_io_ops->write_char(buf[i]);
317 static const struct tty_operations kgdb_nmi_tty_ops = {
318 .open = kgdb_nmi_tty_open,
319 .close = kgdb_nmi_tty_close,
320 .install = kgdb_nmi_tty_install,
321 .cleanup = kgdb_nmi_tty_cleanup,
322 .hangup = kgdb_nmi_tty_hangup,
323 .write_room = kgdb_nmi_tty_write_room,
324 .write = kgdb_nmi_tty_write,
327 int kgdb_register_nmi_console(void)
331 if (!arch_kgdb_ops.enable_nmi)
334 kgdb_nmi_tty_driver = alloc_tty_driver(1);
335 if (!kgdb_nmi_tty_driver) {
336 pr_err("%s: cannot allocate tty\n", __func__);
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);
350 ret = tty_register_driver(kgdb_nmi_tty_driver);
352 pr_err("%s: can't register tty driver: %d\n", __func__, ret);
356 register_console(&kgdb_nmi_console);
357 arch_kgdb_ops.enable_nmi(1);
361 put_tty_driver(kgdb_nmi_tty_driver);
364 EXPORT_SYMBOL_GPL(kgdb_register_nmi_console);
366 int kgdb_unregister_nmi_console(void)
370 if (!arch_kgdb_ops.enable_nmi)
372 arch_kgdb_ops.enable_nmi(0);
374 ret = unregister_console(&kgdb_nmi_console);
378 ret = tty_unregister_driver(kgdb_nmi_tty_driver);
381 put_tty_driver(kgdb_nmi_tty_driver);
385 EXPORT_SYMBOL_GPL(kgdb_unregister_nmi_console);