[deliverable/linux.git] / drivers / serial / kgdboc.c

/*
 * Based on the same principle as kgdboe using the NETPOLL api, this
 * driver uses a console polling api to implement a gdb serial inteface
 * which is multiplexed on a console port.
 *
 * Maintainer: Jason Wessel <jason.wessel@windriver.com>
 *
 * 2007-2008 (c) Jason Wessel - Wind River Systems, Inc.
 *
 * This file is licensed under the terms of the GNU General Public
 * License version 2. This program is licensed "as is" without any
 * warranty of any kind, whether express or implied.
 */
#include <linux/kernel.h>
#include <linux/ctype.h>
#include <linux/kgdb.h>
#include <linux/tty.h>

#define MAX_CONFIG_LEN		40

static struct kgdb_io		kgdboc_io_ops;

/* -1 = init not run yet, 0 = unconfigured, 1 = configured. */
static int configured		= -1;

static char config[MAX_CONFIG_LEN];
static struct kparam_string kps = {
	.string			= config,
	.maxlen			= MAX_CONFIG_LEN,
};

static struct tty_driver	*kgdb_tty_driver;
static int			kgdb_tty_line;

static int kgdboc_option_setup(char *opt)
{
	if (strlen(opt) > MAX_CONFIG_LEN) {
		printk(KERN_ERR "kgdboc: config string too long\n");
		return -ENOSPC;
	}
	strcpy(config, opt);

	return 0;
}

__setup("kgdboc=", kgdboc_option_setup);

static int configure_kgdboc(void)
{
	struct tty_driver *p;
	int tty_line = 0;
	int err;

	err = kgdboc_option_setup(config);
	if (err || !strlen(config) || isspace(config[0]))
		goto noconfig;

	err = -ENODEV;

	p = tty_find_polling_driver(config, &tty_line);
	if (!p)
		goto noconfig;

	kgdb_tty_driver = p;
	kgdb_tty_line = tty_line;

	err = kgdb_register_io_module(&kgdboc_io_ops);
	if (err)
		goto noconfig;

	configured = 1;

	return 0;

noconfig:
	config[0] = 0;
	configured = 0;

	return err;
}

static int __init init_kgdboc(void)
{
	/* Already configured? */
	if (configured == 1)
		return 0;

	return configure_kgdboc();
}

static void cleanup_kgdboc(void)
{
	if (configured == 1)
		kgdb_unregister_io_module(&kgdboc_io_ops);
}

static int kgdboc_get_char(void)
{
	return kgdb_tty_driver->poll_get_char(kgdb_tty_driver, kgdb_tty_line);
}

static void kgdboc_put_char(u8 chr)
{
	kgdb_tty_driver->poll_put_char(kgdb_tty_driver, kgdb_tty_line, chr);
}

static int param_set_kgdboc_var(const char *kmessage, struct kernel_param *kp)
{
	int len = strlen(kmessage);

	if (len >= MAX_CONFIG_LEN) {
		printk(KERN_ERR "kgdboc: config string too long\n");
		return -ENOSPC;
	}

	/* Only copy in the string if the init function has not run yet */
	if (configured < 0) {
		strcpy(config, kmessage);
		return 0;
	}

	if (kgdb_connected) {
		printk(KERN_ERR
		       "kgdboc: Cannot reconfigure while KGDB is connected.\n");

		return -EBUSY;
	}

	strcpy(config, kmessage);
	/* Chop out \n char as a result of echo */
	if (config[len - 1] == '\n')
		config[len - 1] = '\0';

	if (configured == 1)
		cleanup_kgdboc();

	/* Go and configure with the new params. */
	return configure_kgdboc();
}

static void kgdboc_pre_exp_handler(void)
{
	/* Increment the module count when the debugger is active */
	if (!kgdb_connected)
		try_module_get(THIS_MODULE);
}

static void kgdboc_post_exp_handler(void)
{
	/* decrement the module count when the debugger detaches */
	if (!kgdb_connected)
		module_put(THIS_MODULE);
}

static struct kgdb_io kgdboc_io_ops = {
	.name			= "kgdboc",
	.read_char		= kgdboc_get_char,
	.write_char		= kgdboc_put_char,
	.pre_exception		= kgdboc_pre_exp_handler,
	.post_exception		= kgdboc_post_exp_handler,
};

module_init(init_kgdboc);
module_exit(cleanup_kgdboc);
module_param_call(kgdboc, param_set_kgdboc_var, param_get_string, &kps, 0644);
MODULE_PARM_DESC(kgdboc, "<serial_device>[,baud]");
MODULE_DESCRIPTION("KGDB Console TTY Driver");
MODULE_LICENSE("GPL");
Commit	Line	Data
f2d937f3 JW	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/tty.h>
	18
	19	#define MAX_CONFIG_LEN 40
	20
	21	static struct kgdb_io kgdboc_io_ops;
	22
	23	/* -1 = init not run yet, 0 = unconfigured, 1 = configured. */
	24	static int configured = -1;
	25
	26	static char config[MAX_CONFIG_LEN];
	27	static struct kparam_string kps = {
	28	.string = config,
	29	.maxlen = MAX_CONFIG_LEN,
	30	};
	31
	32	static struct tty_driver *kgdb_tty_driver;
	33	static int kgdb_tty_line;
	34
	35	static int kgdboc_option_setup(char *opt)
	36	{
	37	if (strlen(opt) > MAX_CONFIG_LEN) {
	38	printk(KERN_ERR "kgdboc: config string too long\n");
	39	return -ENOSPC;
	40	}
	41	strcpy(config, opt);
	42
	43	return 0;
	44	}
	45
	46	__setup("kgdboc=", kgdboc_option_setup);
	47
	48	static int configure_kgdboc(void)
	49	{
	50	struct tty_driver *p;
	51	int tty_line = 0;
	52	int err;
	53
	54	err = kgdboc_option_setup(config);
	55	if (err \|\| !strlen(config) \|\| isspace(config[0]))
	56	goto noconfig;
	57
	58	err = -ENODEV;
	59
	60	p = tty_find_polling_driver(config, &tty_line);
	61	if (!p)
	62	goto noconfig;
	63
	64	kgdb_tty_driver = p;
65	kgdb_tty_line = tty_line;
66
67	err = kgdb_register_io_module(&kgdboc_io_ops);
68	if (err)
69	goto noconfig;
70
71	configured = 1;
72
73	return 0;
74
75	noconfig:
76	config[0] = 0;
77	configured = 0;
78
79	return err;
80	}
81
82	static int __init init_kgdboc(void)
83	{
84	/* Already configured? */
85	if (configured == 1)
86	return 0;
87
88	return configure_kgdboc();
89	}
90
91	static void cleanup_kgdboc(void)
92	{
93	if (configured == 1)
94	kgdb_unregister_io_module(&kgdboc_io_ops);
95	}
96
97	static int kgdboc_get_char(void)
98	{
99	return kgdb_tty_driver->poll_get_char(kgdb_tty_driver, kgdb_tty_line);
100	}
101
102	static void kgdboc_put_char(u8 chr)
103	{
104	kgdb_tty_driver->poll_put_char(kgdb_tty_driver, kgdb_tty_line, chr);
105	}
106
107	static int param_set_kgdboc_var(const char kmessage, struct kernel_param kp)
108	{
c191e5ad JW	109	int len = strlen(kmessage);
	110
	111	if (len >= MAX_CONFIG_LEN) {
f2d937f3 JW	112	printk(KERN_ERR "kgdboc: config string too long\n");
	113	return -ENOSPC;
	114	}
	115
	116	/* Only copy in the string if the init function has not run yet */
	117	if (configured < 0) {
	118	strcpy(config, kmessage);
	119	return 0;
	120	}
	121
	122	if (kgdb_connected) {
	123	printk(KERN_ERR
	124	"kgdboc: Cannot reconfigure while KGDB is connected.\n");
	125
	126	return -EBUSY;
	127	}
	128
	129	strcpy(config, kmessage);
c191e5ad JW	130	/* Chop out \n char as a result of echo */
	131	if (config[len - 1] == '\n')
	132	config[len - 1] = '\0';
f2d937f3 JW	133
	134	if (configured == 1)
	135	cleanup_kgdboc();
	136
	137	/* Go and configure with the new params. */
	138	return configure_kgdboc();
	139	}
	140
	141	static void kgdboc_pre_exp_handler(void)
	142	{
	143	/* Increment the module count when the debugger is active */
	144	if (!kgdb_connected)
	145	try_module_get(THIS_MODULE);
	146	}
	147
	148	static void kgdboc_post_exp_handler(void)
	149	{
	150	/* decrement the module count when the debugger detaches */
	151	if (!kgdb_connected)
	152	module_put(THIS_MODULE);
	153	}
	154
	155	static struct kgdb_io kgdboc_io_ops = {
	156	.name = "kgdboc",
	157	.read_char = kgdboc_get_char,
	158	.write_char = kgdboc_put_char,
	159	.pre_exception = kgdboc_pre_exp_handler,
	160	.post_exception = kgdboc_post_exp_handler,
	161	};
	162
	163	module_init(init_kgdboc);
	164	module_exit(cleanup_kgdboc);
	165	module_param_call(kgdboc, param_set_kgdboc_var, param_get_string, &kps, 0644);
	166	MODULE_PARM_DESC(kgdboc, "<serial_device>[,baud]");
	167	MODULE_DESCRIPTION("KGDB Console TTY Driver");
	168	MODULE_LICENSE("GPL");