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

  1// SPDX-License-Identifier: GPL-2.0
  2/* 
  3 * Copyright (C) 2000, 2002 Jeff Dike (jdike@karaya.com)
 
  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 "chan.h"
 16#include <init.h>
 17#include <irq_user.h>
 18#include "mconsole_kern.h"
 19
 20static const int ssl_version = 1;
 21
 22#define NR_PORTS 64
 23
 24static void ssl_announce(char *dev_name, int dev)
 25{
 26	printk(KERN_INFO "Serial line %d assigned device '%s'\n", dev,
 27	       dev_name);
 28}
 29
 30/* Almost const, except that xterm_title may be changed in an initcall */
 31static struct chan_opts opts = {
 32	.announce 	= ssl_announce,
 33	.xterm_title	= "Serial Line #%d",
 34	.raw		= 1,
 35};
 36
 37static int ssl_config(char *str, char **error_out);
 38static int ssl_get_config(char *dev, char *str, int size, char **error_out);
 39static int ssl_remove(int n, char **error_out);
 40
 41
 42/* Const, except for .mc.list */
 43static struct line_driver driver = {
 44	.name 			= "UML serial line",
 45	.device_name 		= "ttyS",
 46	.major 			= TTY_MAJOR,
 47	.minor_start 		= 64,
 48	.type 		 	= TTY_DRIVER_TYPE_SERIAL,
 49	.subtype 	 	= 0,
 50	.read_irq 		= SSL_IRQ,
 51	.read_irq_name 		= "ssl",
 52	.write_irq 		= SSL_WRITE_IRQ,
 53	.write_irq_name 	= "ssl-write",
 54	.mc  = {
 55		.list		= LIST_HEAD_INIT(driver.mc.list),
 56		.name  		= "ssl",
 57		.config 	= ssl_config,
 58		.get_config 	= ssl_get_config,
 59		.id		= line_id,
 60		.remove 	= ssl_remove,
 61	},
 62};
 63
 64/* The array is initialized by line_init, at initcall time.  The
 65 * elements are locked individually as needed.
 66 */
 67static char *conf[NR_PORTS];
 68static char *def_conf = CONFIG_SSL_CHAN;
 69static struct line serial_lines[NR_PORTS];
 70
 71static int ssl_config(char *str, char **error_out)
 72{
 73	return line_config(serial_lines, ARRAY_SIZE(serial_lines), str, &opts,
 74			   error_out);
 75}
 76
 77static int ssl_get_config(char *dev, char *str, int size, char **error_out)
 78{
 79	return line_get_config(dev, serial_lines, ARRAY_SIZE(serial_lines), str,
 80			       size, error_out);
 81}
 82
 83static int ssl_remove(int n, char **error_out)
 84{
 85	return line_remove(serial_lines, ARRAY_SIZE(serial_lines), n,
 86			   error_out);
 87}
 88
 89static int ssl_install(struct tty_driver *driver, struct tty_struct *tty)
 90{
 91	return line_install(driver, tty, &serial_lines[tty->index]);
 
 
 
 
 
 
 
 
 
 
 
 
 92}
 93
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 94static const struct tty_operations ssl_ops = {
 95	.open 	 		= line_open,
 96	.close 	 		= line_close,
 97	.write 	 		= line_write,
 
 98	.write_room		= line_write_room,
 99	.chars_in_buffer 	= line_chars_in_buffer,
100	.flush_buffer 		= line_flush_buffer,
101	.flush_chars 		= line_flush_chars,
 
 
102	.throttle 		= line_throttle,
103	.unthrottle 		= line_unthrottle,
104	.install		= ssl_install,
105	.hangup			= line_hangup,
 
 
 
106};
107
108/* Changed by ssl_init and referenced by ssl_exit, which are both serialized
109 * by being an initcall and exitcall, respectively.
110 */
111static int ssl_init_done = 0;
112
113static void ssl_console_write(struct console *c, const char *string,
114			      unsigned len)
115{
116	struct line *line = &serial_lines[c->index];
117	unsigned long flags;
118
119	spin_lock_irqsave(&line->lock, flags);
120	console_write_chan(line->chan_out, string, len);
121	spin_unlock_irqrestore(&line->lock, flags);
122}
123
124static struct tty_driver *ssl_console_device(struct console *c, int *index)
125{
126	*index = c->index;
127	return driver.driver;
128}
129
130static int ssl_console_setup(struct console *co, char *options)
131{
132	struct line *line = &serial_lines[co->index];
133
134	return console_open_chan(line, co);
135}
136
137/* No locking for register_console call - relies on single-threaded initcalls */
138static struct console ssl_cons = {
139	.name		= "ttyS",
140	.write		= ssl_console_write,
141	.device		= ssl_console_device,
142	.setup		= ssl_console_setup,
143	.flags		= CON_PRINTBUFFER|CON_ANYTIME,
144	.index		= -1,
145};
146
147static int ssl_init(void)
148{
149	char *new_title;
150	int err;
151	int i;
152
153	printk(KERN_INFO "Initializing software serial port version %d\n",
154	       ssl_version);
155
156	err = register_lines(&driver, &ssl_ops, serial_lines,
157				    ARRAY_SIZE(serial_lines));
158	if (err)
159		return err;
160
161	new_title = add_xterm_umid(opts.xterm_title);
162	if (new_title != NULL)
163		opts.xterm_title = new_title;
164
165	for (i = 0; i < NR_PORTS; i++) {
166		char *error;
167		char *s = conf[i];
168		if (!s)
169			s = def_conf;
170		if (setup_one_line(serial_lines, i, s, &opts, &error))
171			printk(KERN_ERR "setup_one_line failed for "
172			       "device %d : %s\n", i, error);
173	}
174
175	ssl_init_done = 1;
176	register_console(&ssl_cons);
177	return 0;
178}
179late_initcall(ssl_init);
180
181static void ssl_exit(void)
182{
183	if (!ssl_init_done)
184		return;
185	close_lines(serial_lines, ARRAY_SIZE(serial_lines));
186}
187__uml_exitcall(ssl_exit);
188
189static int ssl_chan_setup(char *str)
190{
191	line_setup(conf, NR_PORTS, &def_conf, str, "serial line");
192	return 1;
193}
194
195__setup("ssl", ssl_chan_setup);
196__channel_help(ssl_chan_setup, "ssl");
197
198static int ssl_non_raw_setup(char *str)
199{
200	opts.raw = 0;
201	return 1;
202}
203__setup("ssl-non-raw", ssl_non_raw_setup);
204__channel_help(ssl_non_raw_setup, "set serial lines to non-raw mode");