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	.set_termios 		= line_set_termios,
 
103	.throttle 		= line_throttle,
104	.unthrottle 		= line_unthrottle,
105	.install		= ssl_install,
106	.hangup			= line_hangup,
 
 
 
107};
108
109/* Changed by ssl_init and referenced by ssl_exit, which are both serialized
110 * by being an initcall and exitcall, respectively.
111 */
112static int ssl_init_done = 0;
113
114static void ssl_console_write(struct console *c, const char *string,
115			      unsigned len)
116{
117	struct line *line = &serial_lines[c->index];
118	unsigned long flags;
119
120	spin_lock_irqsave(&line->lock, flags);
121	console_write_chan(line->chan_out, string, len);
122	spin_unlock_irqrestore(&line->lock, flags);
123}
124
125static struct tty_driver *ssl_console_device(struct console *c, int *index)
126{
127	*index = c->index;
128	return driver.driver;
129}
130
131static int ssl_console_setup(struct console *co, char *options)
132{
133	struct line *line = &serial_lines[co->index];
134
135	return console_open_chan(line, co);
136}
137
138/* No locking for register_console call - relies on single-threaded initcalls */
139static struct console ssl_cons = {
140	.name		= "ttyS",
141	.write		= ssl_console_write,
142	.device		= ssl_console_device,
143	.setup		= ssl_console_setup,
144	.flags		= CON_PRINTBUFFER|CON_ANYTIME,
145	.index		= -1,
146};
147
148static int ssl_init(void)
149{
150	char *new_title;
151	int err;
152	int i;
153
154	printk(KERN_INFO "Initializing software serial port version %d\n",
155	       ssl_version);
156
157	err = register_lines(&driver, &ssl_ops, serial_lines,
158				    ARRAY_SIZE(serial_lines));
159	if (err)
160		return err;
161
162	new_title = add_xterm_umid(opts.xterm_title);
163	if (new_title != NULL)
164		opts.xterm_title = new_title;
165
166	for (i = 0; i < NR_PORTS; i++) {
167		char *error;
168		char *s = conf[i];
169		if (!s)
170			s = def_conf;
171		if (setup_one_line(serial_lines, i, s, &opts, &error))
172			printk(KERN_ERR "setup_one_line failed for "
173			       "device %d : %s\n", i, error);
174	}
175
176	ssl_init_done = 1;
177	register_console(&ssl_cons);
178	return 0;
179}
180late_initcall(ssl_init);
181
182static void ssl_exit(void)
183{
184	if (!ssl_init_done)
185		return;
186	close_lines(serial_lines, ARRAY_SIZE(serial_lines));
187}
188__uml_exitcall(ssl_exit);
189
190static int ssl_chan_setup(char *str)
191{
192	line_setup(conf, NR_PORTS, &def_conf, str, "serial line");
193	return 1;
194}
195
196__setup("ssl", ssl_chan_setup);
197__channel_help(ssl_chan_setup, "ssl");
198
199static int ssl_non_raw_setup(char *str)
200{
201	opts.raw = 0;
202	return 1;
203}
204__setup("ssl-non-raw", ssl_non_raw_setup);
205__channel_help(ssl_non_raw_setup, "set serial lines to non-raw mode");