ssl.c 5.18 KB
Newer Older
Linus Torvalds's avatar
Linus Torvalds committed
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
/* 
 * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
 * Licensed under the GPL
 */

#include "linux/config.h"
#include "linux/fs.h"
#include "linux/tty.h"
#include "linux/tty_driver.h"
#include "linux/major.h"
#include "linux/mm.h"
#include "linux/init.h"
#include "linux/console.h"
#include "asm/termbits.h"
#include "asm/irq.h"
#include "line.h"
#include "ssl.h"
#include "chan_kern.h"
#include "user_util.h"
#include "kern_util.h"
#include "kern.h"
#include "init.h"
#include "irq_user.h"
#include "mconsole_kern.h"

static int ssl_version = 1;

/* Referenced only by tty_driver below - presumably it's locked correctly
 * by the tty driver.
 */

static struct tty_driver *ssl_driver;

#define NR_PORTS 64

void ssl_announce(char *dev_name, int dev)
{
	printk(KERN_INFO "Serial line %d assigned device '%s'\n", dev,
	       dev_name);
}

static struct chan_opts opts = {
	.announce 	= ssl_announce,
	.xterm_title	= "Serial Line #%d",
	.raw		= 1,
	.tramp_stack 	= 0,
	.in_kernel 	= 1,
};

static int ssl_config(char *str);
static int ssl_get_config(char *dev, char *str, int size, char **error_out);
52
static int ssl_remove(int n);
Linus Torvalds's avatar
Linus Torvalds committed
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

static struct line_driver driver = {
	.name 			= "UML serial line",
	.device_name 		= "ttyS",
	.devfs_name 		= "tts/",
	.major 			= TTY_MAJOR,
	.minor_start 		= 64,
	.type 		 	= TTY_DRIVER_TYPE_SERIAL,
	.subtype 	 	= 0,
	.read_irq 		= SSL_IRQ,
	.read_irq_name 		= "ssl",
	.write_irq 		= SSL_WRITE_IRQ,
	.write_irq_name 	= "ssl-write",
	.symlink_from 		= "serial",
	.symlink_to 		= "tts",
	.mc  = {
		.name  		= "ssl",
		.config 	= ssl_config,
		.get_config 	= ssl_get_config,
Jeff Dike's avatar
Jeff Dike committed
72
		.id		= line_id,
Linus Torvalds's avatar
Linus Torvalds committed
73
74
75
76
77
78
79
80
81
82
83
84
85
86
		.remove 	= ssl_remove,
	},
};

/* The array is initialized by line_init, which is an initcall.  The 
 * individual elements are protected by individual semaphores.
 */
static struct line serial_lines[NR_PORTS] =
	{ [0 ... NR_PORTS - 1] = LINE_INIT(CONFIG_SSL_CHAN, &driver) };

static struct lines lines = LINES_INIT(NR_PORTS);

static int ssl_config(char *str)
{
Jeff Dike's avatar
Jeff Dike committed
87
	return line_config(serial_lines, ARRAY_SIZE(serial_lines), str);
Linus Torvalds's avatar
Linus Torvalds committed
88
89
90
91
}

static int ssl_get_config(char *dev, char *str, int size, char **error_out)
{
Jeff Dike's avatar
Jeff Dike committed
92
93
	return line_get_config(dev, serial_lines, ARRAY_SIZE(serial_lines), str,
			       size, error_out);
Linus Torvalds's avatar
Linus Torvalds committed
94
95
}

96
static int ssl_remove(int n)
Linus Torvalds's avatar
Linus Torvalds committed
97
{
Jeff Dike's avatar
Jeff Dike committed
98
	return line_remove(serial_lines, ARRAY_SIZE(serial_lines), n);
Linus Torvalds's avatar
Linus Torvalds committed
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
}

int ssl_open(struct tty_struct *tty, struct file *filp)
{
	return line_open(serial_lines, tty, &opts);
}

#if 0
static void ssl_flush_buffer(struct tty_struct *tty)
{
	return;
}

static void ssl_throttle(struct tty_struct * tty)
{
	printk(KERN_ERR "Someone should implement ssl_throttle\n");
}

static void ssl_unthrottle(struct tty_struct * tty)
{
	printk(KERN_ERR "Someone should implement ssl_unthrottle\n");
}

static void ssl_stop(struct tty_struct *tty)
{
	printk(KERN_ERR "Someone should implement ssl_stop\n");
}

static void ssl_start(struct tty_struct *tty)
{
	printk(KERN_ERR "Someone should implement ssl_start\n");
}

void ssl_hangup(struct tty_struct *tty)
{
}
#endif

static struct tty_operations ssl_ops = {
	.open 	 		= ssl_open,
	.close 	 		= line_close,
	.write 	 		= line_write,
	.put_char 		= line_put_char,
	.write_room		= line_write_room,
	.chars_in_buffer 	= line_chars_in_buffer,
144
145
	.flush_buffer 		= line_flush_buffer,
	.flush_chars 		= line_flush_chars,
Linus Torvalds's avatar
Linus Torvalds committed
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
	.set_termios 		= line_set_termios,
	.ioctl 	 		= line_ioctl,
#if 0
	.throttle 		= ssl_throttle,
	.unthrottle 		= ssl_unthrottle,
	.stop 	 		= ssl_stop,
	.start 	 		= ssl_start,
	.hangup 	 	= ssl_hangup,
#endif
};

/* Changed by ssl_init and referenced by ssl_exit, which are both serialized
 * by being an initcall and exitcall, respectively.
 */
static int ssl_init_done = 0;

static void ssl_console_write(struct console *c, const char *string,
			      unsigned len)
{
	struct line *line = &serial_lines[c->index];
166
	unsigned long flags;
Linus Torvalds's avatar
Linus Torvalds committed
167

168
	spin_lock_irqsave(&line->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
169
	console_write_chan(&line->chan_list, string, len);
170
	spin_unlock_irqrestore(&line->lock, flags);
Linus Torvalds's avatar
Linus Torvalds committed
171
172
173
174
175
176
177
178
179
180
181
182
}

static struct tty_driver *ssl_console_device(struct console *c, int *index)
{
	*index = c->index;
	return ssl_driver;
}

static int ssl_console_setup(struct console *co, char *options)
{
	struct line *line = &serial_lines[co->index];

Jeff Dike's avatar
Jeff Dike committed
183
	return console_open_chan(line, co, &opts);
Linus Torvalds's avatar
Linus Torvalds committed
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
}

static struct console ssl_cons = {
	.name		= "ttyS",
	.write		= ssl_console_write,
	.device		= ssl_console_device,
	.setup		= ssl_console_setup,
	.flags		= CON_PRINTBUFFER,
	.index		= -1,
};

int ssl_init(void)
{
	char *new_title;

Jeff Dike's avatar
Jeff Dike committed
199
	printk(KERN_INFO "Initializing software serial port version %d\n",
Linus Torvalds's avatar
Linus Torvalds committed
200
201
	       ssl_version);
	ssl_driver = line_register_devfs(&lines, &driver, &ssl_ops,
Jeff Dike's avatar
Jeff Dike committed
202
203
					 serial_lines,
					 ARRAY_SIZE(serial_lines));
Linus Torvalds's avatar
Linus Torvalds committed
204

Jeff Dike's avatar
Jeff Dike committed
205
	lines_init(serial_lines, ARRAY_SIZE(serial_lines));
Linus Torvalds's avatar
Linus Torvalds committed
206
207
208
209
210
211
212

	new_title = add_xterm_umid(opts.xterm_title);
	if (new_title != NULL)
		opts.xterm_title = new_title;

	ssl_init_done = 1;
	register_console(&ssl_cons);
Jeff Dike's avatar
Jeff Dike committed
213
	return 0;
Linus Torvalds's avatar
Linus Torvalds committed
214
215
216
217
218
219
220
}
late_initcall(ssl_init);

static void ssl_exit(void)
{
	if (!ssl_init_done)
		return;
Jeff Dike's avatar
Jeff Dike committed
221
	close_lines(serial_lines, ARRAY_SIZE(serial_lines));
Linus Torvalds's avatar
Linus Torvalds committed
222
223
224
225
226
}
__uml_exitcall(ssl_exit);

static int ssl_chan_setup(char *str)
{
Jeff Dike's avatar
Jeff Dike committed
227
	return line_setup(serial_lines, ARRAY_SIZE(serial_lines), str, 1);
Linus Torvalds's avatar
Linus Torvalds committed
228
229
230
231
}

__setup("ssl", ssl_chan_setup);
__channel_help(ssl_chan_setup, "ssl");