xref: /linux/drivers/usb/serial/console.c (revision 4413e16d9d21673bb5048a2e542f1aaa00015c2e)
1 /*
2  * USB Serial Console driver
3  *
4  * Copyright (C) 2001 - 2002 Greg Kroah-Hartman (greg@kroah.com)
5  *
6  *	This program is free software; you can redistribute it and/or
7  *	modify it under the terms of the GNU General Public License version
8  *	2 as published by the Free Software Foundation.
9  *
10  * Thanks to Randy Dunlap for the original version of this code.
11  *
12  */
13 
14 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
15 
16 #include <linux/kernel.h>
17 #include <linux/init.h>
18 #include <linux/slab.h>
19 #include <linux/tty.h>
20 #include <linux/console.h>
21 #include <linux/serial.h>
22 #include <linux/usb.h>
23 #include <linux/usb/serial.h>
24 
25 struct usbcons_info {
26 	int			magic;
27 	int			break_flag;
28 	struct usb_serial_port	*port;
29 };
30 
31 static struct usbcons_info usbcons_info;
32 static struct console usbcons;
33 
34 /*
35  * ------------------------------------------------------------
36  * USB Serial console driver
37  *
38  * Much of the code here is copied from drivers/char/serial.c
39  * and implements a phony serial console in the same way that
40  * serial.c does so that in case some software queries it,
41  * it will get the same results.
42  *
43  * Things that are different from the way the serial port code
44  * does things, is that we call the lower level usb-serial
45  * driver code to initialize the device, and we set the initial
46  * console speeds based on the command line arguments.
47  * ------------------------------------------------------------
48  */
49 
50 
51 /*
52  * The parsing of the command line works exactly like the
53  * serial.c code, except that the specifier is "ttyUSB" instead
54  * of "ttyS".
55  */
56 static int usb_console_setup(struct console *co, char *options)
57 {
58 	struct usbcons_info *info = &usbcons_info;
59 	int baud = 9600;
60 	int bits = 8;
61 	int parity = 'n';
62 	int doflow = 0;
63 	int cflag = CREAD | HUPCL | CLOCAL;
64 	char *s;
65 	struct usb_serial *serial;
66 	struct usb_serial_port *port;
67 	int retval;
68 	struct tty_struct *tty = NULL;
69 	struct ktermios dummy;
70 
71 	if (options) {
72 		baud = simple_strtoul(options, NULL, 10);
73 		s = options;
74 		while (*s >= '0' && *s <= '9')
75 			s++;
76 		if (*s)
77 			parity = *s++;
78 		if (*s)
79 			bits   = *s++ - '0';
80 		if (*s)
81 			doflow = (*s++ == 'r');
82 	}
83 
84 	/* Sane default */
85 	if (baud == 0)
86 		baud = 9600;
87 
88 	switch (bits) {
89 	case 7:
90 		cflag |= CS7;
91 		break;
92 	default:
93 	case 8:
94 		cflag |= CS8;
95 		break;
96 	}
97 	switch (parity) {
98 	case 'o': case 'O':
99 		cflag |= PARODD;
100 		break;
101 	case 'e': case 'E':
102 		cflag |= PARENB;
103 		break;
104 	}
105 	co->cflag = cflag;
106 
107 	/*
108 	 * no need to check the index here: if the index is wrong, console
109 	 * code won't call us
110 	 */
111 	serial = usb_serial_get_by_index(co->index);
112 	if (serial == NULL) {
113 		/* no device is connected yet, sorry :( */
114 		pr_err("No USB device connected to ttyUSB%i\n", co->index);
115 		return -ENODEV;
116 	}
117 
118 	retval = usb_autopm_get_interface(serial->interface);
119 	if (retval)
120 		goto error_get_interface;
121 
122 	port = serial->port[co->index - serial->minor];
123 	tty_port_tty_set(&port->port, NULL);
124 
125 	info->port = port;
126 
127 	++port->port.count;
128 	if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags)) {
129 		if (serial->type->set_termios) {
130 			/*
131 			 * allocate a fake tty so the driver can initialize
132 			 * the termios structure, then later call set_termios to
133 			 * configure according to command line arguments
134 			 */
135 			tty = kzalloc(sizeof(*tty), GFP_KERNEL);
136 			if (!tty) {
137 				retval = -ENOMEM;
138 				dev_err(&port->dev, "no more memory\n");
139 				goto reset_open_count;
140 			}
141 			kref_init(&tty->kref);
142 			tty_port_tty_set(&port->port, tty);
143 			tty->driver = usb_serial_tty_driver;
144 			tty->index = co->index;
145 			if (tty_init_termios(tty)) {
146 				retval = -ENOMEM;
147 				dev_err(&port->dev, "no more memory\n");
148 				goto free_tty;
149 			}
150 		}
151 
152 		/* only call the device specific open if this
153 		 * is the first time the port is opened */
154 		if (serial->type->open)
155 			retval = serial->type->open(NULL, port);
156 		else
157 			retval = usb_serial_generic_open(NULL, port);
158 
159 		if (retval) {
160 			dev_err(&port->dev, "could not open USB console port\n");
161 			goto fail;
162 		}
163 
164 		if (serial->type->set_termios) {
165 			tty->termios.c_cflag = cflag;
166 			tty_termios_encode_baud_rate(&tty->termios, baud, baud);
167 			memset(&dummy, 0, sizeof(struct ktermios));
168 			serial->type->set_termios(tty, port, &dummy);
169 
170 			tty_port_tty_set(&port->port, NULL);
171 			kfree(tty);
172 		}
173 		set_bit(ASYNCB_INITIALIZED, &port->port.flags);
174 	}
175 	/* Now that any required fake tty operations are completed restore
176 	 * the tty port count */
177 	--port->port.count;
178 	/* The console is special in terms of closing the device so
179 	 * indicate this port is now acting as a system console. */
180 	port->port.console = 1;
181 
182 	mutex_unlock(&serial->disc_mutex);
183 	return retval;
184 
185  fail:
186 	tty_port_tty_set(&port->port, NULL);
187  free_tty:
188 	kfree(tty);
189  reset_open_count:
190 	port->port.count = 0;
191 	usb_autopm_put_interface(serial->interface);
192  error_get_interface:
193 	usb_serial_put(serial);
194 	mutex_unlock(&serial->disc_mutex);
195 	return retval;
196 }
197 
198 static void usb_console_write(struct console *co,
199 					const char *buf, unsigned count)
200 {
201 	static struct usbcons_info *info = &usbcons_info;
202 	struct usb_serial_port *port = info->port;
203 	struct usb_serial *serial;
204 	int retval = -ENODEV;
205 
206 	if (!port || port->serial->dev->state == USB_STATE_NOTATTACHED)
207 		return;
208 	serial = port->serial;
209 
210 	if (count == 0)
211 		return;
212 
213 	pr_debug("%s - port %d, %d byte(s)\n", __func__, port->number, count);
214 
215 	if (!port->port.console) {
216 		pr_debug("%s - port not opened\n", __func__);
217 		return;
218 	}
219 
220 	while (count) {
221 		unsigned int i;
222 		unsigned int lf;
223 		/* search for LF so we can insert CR if necessary */
224 		for (i = 0, lf = 0 ; i < count ; i++) {
225 			if (*(buf + i) == 10) {
226 				lf = 1;
227 				i++;
228 				break;
229 			}
230 		}
231 		/* pass on to the driver specific version of this function if
232 		   it is available */
233 		if (serial->type->write)
234 			retval = serial->type->write(NULL, port, buf, i);
235 		else
236 			retval = usb_serial_generic_write(NULL, port, buf, i);
237 		pr_debug("%s - return value : %d\n", __func__, retval);
238 		if (lf) {
239 			/* append CR after LF */
240 			unsigned char cr = 13;
241 			if (serial->type->write)
242 				retval = serial->type->write(NULL,
243 								port, &cr, 1);
244 			else
245 				retval = usb_serial_generic_write(NULL,
246 								port, &cr, 1);
247 			pr_debug("%s - return value : %d\n", __func__, retval);
248 		}
249 		buf += i;
250 		count -= i;
251 	}
252 }
253 
254 static struct tty_driver *usb_console_device(struct console *co, int *index)
255 {
256 	struct tty_driver **p = (struct tty_driver **)co->data;
257 
258 	if (!*p)
259 		return NULL;
260 
261 	*index = co->index;
262 	return *p;
263 }
264 
265 static struct console usbcons = {
266 	.name =		"ttyUSB",
267 	.write =	usb_console_write,
268 	.device =	usb_console_device,
269 	.setup =	usb_console_setup,
270 	.flags =	CON_PRINTBUFFER,
271 	.index =	-1,
272 	.data = 	&usb_serial_tty_driver,
273 };
274 
275 void usb_serial_console_disconnect(struct usb_serial *serial)
276 {
277 	if (serial && serial->port && serial->port[0]
278 				&& serial->port[0] == usbcons_info.port) {
279 		usb_serial_console_exit();
280 		usb_serial_put(serial);
281 	}
282 }
283 
284 void usb_serial_console_init(int minor)
285 {
286 	if (minor == 0) {
287 		/*
288 		 * Call register_console() if this is the first device plugged
289 		 * in.  If we call it earlier, then the callback to
290 		 * console_setup() will fail, as there is not a device seen by
291 		 * the USB subsystem yet.
292 		 */
293 		/*
294 		 * Register console.
295 		 * NOTES:
296 		 * console_setup() is called (back) immediately (from
297 		 * register_console). console_write() is called immediately
298 		 * from register_console iff CON_PRINTBUFFER is set in flags.
299 		 */
300 		pr_debug("registering the USB serial console.\n");
301 		register_console(&usbcons);
302 	}
303 }
304 
305 void usb_serial_console_exit(void)
306 {
307 	if (usbcons_info.port) {
308 		unregister_console(&usbcons);
309 		usbcons_info.port->port.console = 0;
310 		usbcons_info.port = NULL;
311 	}
312 }
313 
314