Merge branch 'upstream-linus' of git://git.kernel.org/pub/scm/linux/kernel/git/mfashe...
[linux-2.6] / arch / um / drivers / ssl.c
1 /* 
2  * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
3  * Licensed under the GPL
4  */
5
6 #include "linux/fs.h"
7 #include "linux/tty.h"
8 #include "linux/tty_driver.h"
9 #include "linux/major.h"
10 #include "linux/mm.h"
11 #include "linux/init.h"
12 #include "linux/console.h"
13 #include "asm/termbits.h"
14 #include "asm/irq.h"
15 #include "line.h"
16 #include "ssl.h"
17 #include "chan_kern.h"
18 #include "kern_util.h"
19 #include "kern.h"
20 #include "init.h"
21 #include "irq_user.h"
22 #include "mconsole_kern.h"
23
24 static const int ssl_version = 1;
25
26 /* Referenced only by tty_driver below - presumably it's locked correctly
27  * by the tty driver.
28  */
29
30 static struct tty_driver *ssl_driver;
31
32 #define NR_PORTS 64
33
34 static void ssl_announce(char *dev_name, int dev)
35 {
36         printk(KERN_INFO "Serial line %d assigned device '%s'\n", dev,
37                dev_name);
38 }
39
40 /* Almost const, except that xterm_title may be changed in an initcall */
41 static struct chan_opts opts = {
42         .announce       = ssl_announce,
43         .xterm_title    = "Serial Line #%d",
44         .raw            = 1,
45 };
46
47 static int ssl_config(char *str, char **error_out);
48 static int ssl_get_config(char *dev, char *str, int size, char **error_out);
49 static int ssl_remove(int n, char **error_out);
50
51
52 /* Const, except for .mc.list */
53 static struct line_driver driver = {
54         .name                   = "UML serial line",
55         .device_name            = "ttyS",
56         .major                  = TTY_MAJOR,
57         .minor_start            = 64,
58         .type                   = TTY_DRIVER_TYPE_SERIAL,
59         .subtype                = 0,
60         .read_irq               = SSL_IRQ,
61         .read_irq_name          = "ssl",
62         .write_irq              = SSL_WRITE_IRQ,
63         .write_irq_name         = "ssl-write",
64         .mc  = {
65                 .list           = LIST_HEAD_INIT(driver.mc.list),
66                 .name           = "ssl",
67                 .config         = ssl_config,
68                 .get_config     = ssl_get_config,
69                 .id             = line_id,
70                 .remove         = ssl_remove,
71         },
72 };
73
74 /* The array is initialized by line_init, at initcall time.  The
75  * elements are locked individually as needed.
76  */
77 static struct line serial_lines[NR_PORTS] =
78         { [0 ... NR_PORTS - 1] = LINE_INIT(CONFIG_SSL_CHAN, &driver) };
79
80 static int ssl_config(char *str, char **error_out)
81 {
82         return line_config(serial_lines, ARRAY_SIZE(serial_lines), str, &opts,
83                            error_out);
84 }
85
86 static int ssl_get_config(char *dev, char *str, int size, char **error_out)
87 {
88         return line_get_config(dev, serial_lines, ARRAY_SIZE(serial_lines), str,
89                                size, error_out);
90 }
91
92 static int ssl_remove(int n, char **error_out)
93 {
94         return line_remove(serial_lines, ARRAY_SIZE(serial_lines), n,
95                            error_out);
96 }
97
98 static int ssl_open(struct tty_struct *tty, struct file *filp)
99 {
100         int err = line_open(serial_lines, tty);
101
102         if (err)
103                 printk(KERN_ERR "Failed to open serial line %d, err = %d\n",
104                        tty->index, err);
105
106         return err;
107 }
108
109 #if 0
110 static void ssl_flush_buffer(struct tty_struct *tty)
111 {
112         return;
113 }
114
115 static void ssl_stop(struct tty_struct *tty)
116 {
117         printk(KERN_ERR "Someone should implement ssl_stop\n");
118 }
119
120 static void ssl_start(struct tty_struct *tty)
121 {
122         printk(KERN_ERR "Someone should implement ssl_start\n");
123 }
124
125 void ssl_hangup(struct tty_struct *tty)
126 {
127 }
128 #endif
129
130 static const struct tty_operations ssl_ops = {
131         .open                   = ssl_open,
132         .close                  = line_close,
133         .write                  = line_write,
134         .put_char               = line_put_char,
135         .write_room             = line_write_room,
136         .chars_in_buffer        = line_chars_in_buffer,
137         .flush_buffer           = line_flush_buffer,
138         .flush_chars            = line_flush_chars,
139         .set_termios            = line_set_termios,
140         .ioctl                  = line_ioctl,
141         .throttle               = line_throttle,
142         .unthrottle             = line_unthrottle,
143 #if 0
144         .stop                   = ssl_stop,
145         .start                  = ssl_start,
146         .hangup                 = ssl_hangup,
147 #endif
148 };
149
150 /* Changed by ssl_init and referenced by ssl_exit, which are both serialized
151  * by being an initcall and exitcall, respectively.
152  */
153 static int ssl_init_done = 0;
154
155 static void ssl_console_write(struct console *c, const char *string,
156                               unsigned len)
157 {
158         struct line *line = &serial_lines[c->index];
159         unsigned long flags;
160
161         spin_lock_irqsave(&line->lock, flags);
162         console_write_chan(&line->chan_list, string, len);
163         spin_unlock_irqrestore(&line->lock, flags);
164 }
165
166 static struct tty_driver *ssl_console_device(struct console *c, int *index)
167 {
168         *index = c->index;
169         return ssl_driver;
170 }
171
172 static int ssl_console_setup(struct console *co, char *options)
173 {
174         struct line *line = &serial_lines[co->index];
175
176         return console_open_chan(line, co);
177 }
178
179 /* No locking for register_console call - relies on single-threaded initcalls */
180 static struct console ssl_cons = {
181         .name           = "ttyS",
182         .write          = ssl_console_write,
183         .device         = ssl_console_device,
184         .setup          = ssl_console_setup,
185         .flags          = CON_PRINTBUFFER|CON_ANYTIME,
186         .index          = -1,
187 };
188
189 static int ssl_init(void)
190 {
191         char *new_title;
192
193         printk(KERN_INFO "Initializing software serial port version %d\n",
194                ssl_version);
195         ssl_driver = register_lines(&driver, &ssl_ops, serial_lines,
196                                     ARRAY_SIZE(serial_lines));
197
198         new_title = add_xterm_umid(opts.xterm_title);
199         if (new_title != NULL)
200                 opts.xterm_title = new_title;
201
202         lines_init(serial_lines, ARRAY_SIZE(serial_lines), &opts);
203
204         ssl_init_done = 1;
205         register_console(&ssl_cons);
206         return 0;
207 }
208 late_initcall(ssl_init);
209
210 static void ssl_exit(void)
211 {
212         if (!ssl_init_done)
213                 return;
214         close_lines(serial_lines, ARRAY_SIZE(serial_lines));
215 }
216 __uml_exitcall(ssl_exit);
217
218 static int ssl_chan_setup(char *str)
219 {
220         char *error;
221         int ret;
222
223         ret = line_setup(serial_lines, ARRAY_SIZE(serial_lines), str, &error);
224         if(ret < 0)
225                 printk(KERN_ERR "Failed to set up serial line with "
226                        "configuration string \"%s\" : %s\n", str, error);
227
228         return 1;
229 }
230
231 __setup("ssl", ssl_chan_setup);
232 __channel_help(ssl_chan_setup, "ssl");