linux/drivers/tty/serial/kgdboc.c
<<
>>
Prefs
   1/*
   2 * Based on the same principle as kgdboe using the NETPOLL api, this
   3 * driver uses a console polling api to implement a gdb serial inteface
   4 * which is multiplexed on a console port.
   5 *
   6 * Maintainer: Jason Wessel <jason.wessel@windriver.com>
   7 *
   8 * 2007-2008 (c) Jason Wessel - Wind River Systems, Inc.
   9 *
  10 * This file is licensed under the terms of the GNU General Public
  11 * License version 2. This program is licensed "as is" without any
  12 * warranty of any kind, whether express or implied.
  13 */
  14#include <linux/kernel.h>
  15#include <linux/ctype.h>
  16#include <linux/kgdb.h>
  17#include <linux/kdb.h>
  18#include <linux/tty.h>
  19#include <linux/console.h>
  20#include <linux/vt_kern.h>
  21#include <linux/input.h>
  22#include <linux/module.h>
  23
  24#define MAX_CONFIG_LEN          40
  25
  26static struct kgdb_io           kgdboc_io_ops;
  27
  28/* -1 = init not run yet, 0 = unconfigured, 1 = configured. */
  29static int configured           = -1;
  30
  31static char config[MAX_CONFIG_LEN];
  32static struct kparam_string kps = {
  33        .string                 = config,
  34        .maxlen                 = MAX_CONFIG_LEN,
  35};
  36
  37static int kgdboc_use_kms;  /* 1 if we use kernel mode switching */
  38static struct tty_driver        *kgdb_tty_driver;
  39static int                      kgdb_tty_line;
  40
  41#ifdef CONFIG_KDB_KEYBOARD
  42static int kgdboc_reset_connect(struct input_handler *handler,
  43                                struct input_dev *dev,
  44                                const struct input_device_id *id)
  45{
  46        input_reset_device(dev);
  47
  48        /* Return an error - we do not want to bind, just to reset */
  49        return -ENODEV;
  50}
  51
  52static void kgdboc_reset_disconnect(struct input_handle *handle)
  53{
  54        /* We do not expect anyone to actually bind to us */
  55        BUG();
  56}
  57
  58static const struct input_device_id kgdboc_reset_ids[] = {
  59        {
  60                .flags = INPUT_DEVICE_ID_MATCH_EVBIT,
  61                .evbit = { BIT_MASK(EV_KEY) },
  62        },
  63        { }
  64};
  65
  66static struct input_handler kgdboc_reset_handler = {
  67        .connect        = kgdboc_reset_connect,
  68        .disconnect     = kgdboc_reset_disconnect,
  69        .name           = "kgdboc_reset",
  70        .id_table       = kgdboc_reset_ids,
  71};
  72
  73static DEFINE_MUTEX(kgdboc_reset_mutex);
  74
  75static void kgdboc_restore_input_helper(struct work_struct *dummy)
  76{
  77        /*
  78         * We need to take a mutex to prevent several instances of
  79         * this work running on different CPUs so they don't try
  80         * to register again already registered handler.
  81         */
  82        mutex_lock(&kgdboc_reset_mutex);
  83
  84        if (input_register_handler(&kgdboc_reset_handler) == 0)
  85                input_unregister_handler(&kgdboc_reset_handler);
  86
  87        mutex_unlock(&kgdboc_reset_mutex);
  88}
  89
  90static DECLARE_WORK(kgdboc_restore_input_work, kgdboc_restore_input_helper);
  91
  92static void kgdboc_restore_input(void)
  93{
  94        if (likely(system_state == SYSTEM_RUNNING))
  95                schedule_work(&kgdboc_restore_input_work);
  96}
  97
  98static int kgdboc_register_kbd(char **cptr)
  99{
 100        if (strncmp(*cptr, "kbd", 3) == 0 ||
 101                strncmp(*cptr, "kdb", 3) == 0) {
 102                if (kdb_poll_idx < KDB_POLL_FUNC_MAX) {
 103                        kdb_poll_funcs[kdb_poll_idx] = kdb_get_kbd_char;
 104                        kdb_poll_idx++;
 105                        if (cptr[0][3] == ',')
 106                                *cptr += 4;
 107                        else
 108                                return 1;
 109                }
 110        }
 111        return 0;
 112}
 113
 114static void kgdboc_unregister_kbd(void)
 115{
 116        int i;
 117
 118        for (i = 0; i < kdb_poll_idx; i++) {
 119                if (kdb_poll_funcs[i] == kdb_get_kbd_char) {
 120                        kdb_poll_idx--;
 121                        kdb_poll_funcs[i] = kdb_poll_funcs[kdb_poll_idx];
 122                        kdb_poll_funcs[kdb_poll_idx] = NULL;
 123                        i--;
 124                }
 125        }
 126        flush_work(&kgdboc_restore_input_work);
 127}
 128#else /* ! CONFIG_KDB_KEYBOARD */
 129#define kgdboc_register_kbd(x) 0
 130#define kgdboc_unregister_kbd()
 131#define kgdboc_restore_input()
 132#endif /* ! CONFIG_KDB_KEYBOARD */
 133
 134static int kgdboc_option_setup(char *opt)
 135{
 136        if (strlen(opt) >= MAX_CONFIG_LEN) {
 137                printk(KERN_ERR "kgdboc: config string too long\n");
 138                return -ENOSPC;
 139        }
 140        strcpy(config, opt);
 141
 142        return 0;
 143}
 144
 145__setup("kgdboc=", kgdboc_option_setup);
 146
 147static void cleanup_kgdboc(void)
 148{
 149        if (kgdb_unregister_nmi_console())
 150                return;
 151        kgdboc_unregister_kbd();
 152        if (configured == 1)
 153                kgdb_unregister_io_module(&kgdboc_io_ops);
 154}
 155
 156static int configure_kgdboc(void)
 157{
 158        struct tty_driver *p;
 159        int tty_line = 0;
 160        int err;
 161        char *cptr = config;
 162        struct console *cons;
 163
 164        err = kgdboc_option_setup(config);
 165        if (err || !strlen(config) || isspace(config[0]))
 166                goto noconfig;
 167
 168        err = -ENODEV;
 169        kgdboc_io_ops.is_console = 0;
 170        kgdb_tty_driver = NULL;
 171
 172        kgdboc_use_kms = 0;
 173        if (strncmp(cptr, "kms,", 4) == 0) {
 174                cptr += 4;
 175                kgdboc_use_kms = 1;
 176        }
 177
 178        if (kgdboc_register_kbd(&cptr))
 179                goto do_register;
 180
 181        p = tty_find_polling_driver(cptr, &tty_line);
 182        if (!p)
 183                goto noconfig;
 184
 185        cons = console_drivers;
 186        while (cons) {
 187                int idx;
 188                if (cons->device && cons->device(cons, &idx) == p &&
 189                    idx == tty_line) {
 190                        kgdboc_io_ops.is_console = 1;
 191                        break;
 192                }
 193                cons = cons->next;
 194        }
 195
 196        kgdb_tty_driver = p;
 197        kgdb_tty_line = tty_line;
 198
 199do_register:
 200        err = kgdb_register_io_module(&kgdboc_io_ops);
 201        if (err)
 202                goto noconfig;
 203
 204        err = kgdb_register_nmi_console();
 205        if (err)
 206                goto nmi_con_failed;
 207
 208        configured = 1;
 209
 210        return 0;
 211
 212nmi_con_failed:
 213        kgdb_unregister_io_module(&kgdboc_io_ops);
 214noconfig:
 215        kgdboc_unregister_kbd();
 216        config[0] = 0;
 217        configured = 0;
 218        cleanup_kgdboc();
 219
 220        return err;
 221}
 222
 223static int __init init_kgdboc(void)
 224{
 225        /* Already configured? */
 226        if (configured == 1)
 227                return 0;
 228
 229        return configure_kgdboc();
 230}
 231
 232static int kgdboc_get_char(void)
 233{
 234        if (!kgdb_tty_driver)
 235                return -1;
 236        return kgdb_tty_driver->ops->poll_get_char(kgdb_tty_driver,
 237                                                kgdb_tty_line);
 238}
 239
 240static void kgdboc_put_char(u8 chr)
 241{
 242        if (!kgdb_tty_driver)
 243                return;
 244        kgdb_tty_driver->ops->poll_put_char(kgdb_tty_driver,
 245                                        kgdb_tty_line, chr);
 246}
 247
 248static int param_set_kgdboc_var(const char *kmessage, struct kernel_param *kp)
 249{
 250        int len = strlen(kmessage);
 251
 252        if (len >= MAX_CONFIG_LEN) {
 253                printk(KERN_ERR "kgdboc: config string too long\n");
 254                return -ENOSPC;
 255        }
 256
 257        /* Only copy in the string if the init function has not run yet */
 258        if (configured < 0) {
 259                strcpy(config, kmessage);
 260                return 0;
 261        }
 262
 263        if (kgdb_connected) {
 264                printk(KERN_ERR
 265                       "kgdboc: Cannot reconfigure while KGDB is connected.\n");
 266
 267                return -EBUSY;
 268        }
 269
 270        strcpy(config, kmessage);
 271        /* Chop out \n char as a result of echo */
 272        if (config[len - 1] == '\n')
 273                config[len - 1] = '\0';
 274
 275        if (configured == 1)
 276                cleanup_kgdboc();
 277
 278        /* Go and configure with the new params. */
 279        return configure_kgdboc();
 280}
 281
 282static int dbg_restore_graphics;
 283
 284static void kgdboc_pre_exp_handler(void)
 285{
 286        if (!dbg_restore_graphics && kgdboc_use_kms) {
 287                dbg_restore_graphics = 1;
 288                con_debug_enter(vc_cons[fg_console].d);
 289        }
 290        /* Increment the module count when the debugger is active */
 291        if (!kgdb_connected)
 292                try_module_get(THIS_MODULE);
 293}
 294
 295static void kgdboc_post_exp_handler(void)
 296{
 297        /* decrement the module count when the debugger detaches */
 298        if (!kgdb_connected)
 299                module_put(THIS_MODULE);
 300        if (kgdboc_use_kms && dbg_restore_graphics) {
 301                dbg_restore_graphics = 0;
 302                con_debug_leave();
 303        }
 304        kgdboc_restore_input();
 305}
 306
 307static struct kgdb_io kgdboc_io_ops = {
 308        .name                   = "kgdboc",
 309        .read_char              = kgdboc_get_char,
 310        .write_char             = kgdboc_put_char,
 311        .pre_exception          = kgdboc_pre_exp_handler,
 312        .post_exception         = kgdboc_post_exp_handler,
 313};
 314
 315#ifdef CONFIG_KGDB_SERIAL_CONSOLE
 316/* This is only available if kgdboc is a built in for early debugging */
 317static int __init kgdboc_early_init(char *opt)
 318{
 319        /* save the first character of the config string because the
 320         * init routine can destroy it.
 321         */
 322        char save_ch;
 323
 324        kgdboc_option_setup(opt);
 325        save_ch = config[0];
 326        init_kgdboc();
 327        config[0] = save_ch;
 328        return 0;
 329}
 330
 331early_param("ekgdboc", kgdboc_early_init);
 332#endif /* CONFIG_KGDB_SERIAL_CONSOLE */
 333
 334module_init(init_kgdboc);
 335module_exit(cleanup_kgdboc);
 336module_param_call(kgdboc, param_set_kgdboc_var, param_get_string, &kps, 0644);
 337MODULE_PARM_DESC(kgdboc, "<serial_device>[,baud]");
 338MODULE_DESCRIPTION("KGDB Console TTY Driver");
 339MODULE_LICENSE("GPL");
 340