1 | // SPDX-License-Identifier: GPL-2.0 |
2 | /* |
3 | * USB Serial Converter driver |
4 | * |
5 | * Copyright (C) 2009 - 2013 Johan Hovold (jhovold@gmail.com) |
6 | * Copyright (C) 1999 - 2012 Greg Kroah-Hartman (greg@kroah.com) |
7 | * Copyright (C) 2000 Peter Berger (pberger@brimson.com) |
8 | * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com) |
9 | * |
10 | * This driver was originally based on the ACM driver by Armin Fuerst (which was |
11 | * based on a driver by Brad Keryan) |
12 | * |
13 | * See Documentation/usb/usb-serial.rst for more information on using this |
14 | * driver |
15 | */ |
16 | |
17 | #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt |
18 | |
19 | #include <linux/kernel.h> |
20 | #include <linux/errno.h> |
21 | #include <linux/init.h> |
22 | #include <linux/slab.h> |
23 | #include <linux/tty.h> |
24 | #include <linux/tty_driver.h> |
25 | #include <linux/tty_flip.h> |
26 | #include <linux/module.h> |
27 | #include <linux/moduleparam.h> |
28 | #include <linux/seq_file.h> |
29 | #include <linux/spinlock.h> |
30 | #include <linux/mutex.h> |
31 | #include <linux/list.h> |
32 | #include <linux/uaccess.h> |
33 | #include <linux/serial.h> |
34 | #include <linux/usb.h> |
35 | #include <linux/usb/serial.h> |
36 | #include <linux/kfifo.h> |
37 | #include <linux/idr.h> |
38 | |
39 | #define DRIVER_AUTHOR "Greg Kroah-Hartman <gregkh@linuxfoundation.org>" |
40 | #define DRIVER_DESC "USB Serial Driver core" |
41 | |
42 | #define USB_SERIAL_TTY_MAJOR 188 |
43 | #define USB_SERIAL_TTY_MINORS 512 /* should be enough for a while */ |
44 | |
45 | /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead |
46 | the MODULE_DEVICE_TABLE declarations in each serial driver |
47 | cause the "hotplug" program to pull in whatever module is necessary |
48 | via modprobe, and modprobe will load usbserial because the serial |
49 | drivers depend on it. |
50 | */ |
51 | |
52 | static DEFINE_IDR(serial_minors); |
53 | static DEFINE_MUTEX(table_lock); |
54 | static LIST_HEAD(usb_serial_driver_list); |
55 | |
56 | /* |
57 | * Look up the serial port structure. If it is found and it hasn't been |
58 | * disconnected, return with the parent usb_serial structure's disc_mutex held |
59 | * and its refcount incremented. Otherwise return NULL. |
60 | */ |
61 | struct usb_serial_port *usb_serial_port_get_by_minor(unsigned minor) |
62 | { |
63 | struct usb_serial *serial; |
64 | struct usb_serial_port *port; |
65 | |
66 | mutex_lock(&table_lock); |
67 | port = idr_find(&serial_minors, id: minor); |
68 | if (!port) |
69 | goto exit; |
70 | |
71 | serial = port->serial; |
72 | mutex_lock(&serial->disc_mutex); |
73 | if (serial->disconnected) { |
74 | mutex_unlock(lock: &serial->disc_mutex); |
75 | port = NULL; |
76 | } else { |
77 | kref_get(kref: &serial->kref); |
78 | } |
79 | exit: |
80 | mutex_unlock(lock: &table_lock); |
81 | return port; |
82 | } |
83 | |
84 | static int allocate_minors(struct usb_serial *serial, int num_ports) |
85 | { |
86 | struct usb_serial_port *port; |
87 | unsigned int i, j; |
88 | int minor; |
89 | |
90 | dev_dbg(&serial->interface->dev, "%s %d\n" , __func__, num_ports); |
91 | |
92 | mutex_lock(&table_lock); |
93 | for (i = 0; i < num_ports; ++i) { |
94 | port = serial->port[i]; |
95 | minor = idr_alloc(&serial_minors, ptr: port, start: 0, |
96 | USB_SERIAL_TTY_MINORS, GFP_KERNEL); |
97 | if (minor < 0) |
98 | goto error; |
99 | port->minor = minor; |
100 | port->port_number = i; |
101 | } |
102 | serial->minors_reserved = 1; |
103 | mutex_unlock(lock: &table_lock); |
104 | return 0; |
105 | error: |
106 | /* unwind the already allocated minors */ |
107 | for (j = 0; j < i; ++j) |
108 | idr_remove(&serial_minors, id: serial->port[j]->minor); |
109 | mutex_unlock(lock: &table_lock); |
110 | return minor; |
111 | } |
112 | |
113 | static void release_minors(struct usb_serial *serial) |
114 | { |
115 | int i; |
116 | |
117 | mutex_lock(&table_lock); |
118 | for (i = 0; i < serial->num_ports; ++i) |
119 | idr_remove(&serial_minors, id: serial->port[i]->minor); |
120 | mutex_unlock(lock: &table_lock); |
121 | serial->minors_reserved = 0; |
122 | } |
123 | |
124 | int usb_serial_claim_interface(struct usb_serial *serial, struct usb_interface *intf) |
125 | { |
126 | struct usb_driver *driver = serial->type->usb_driver; |
127 | int ret; |
128 | |
129 | if (serial->sibling) |
130 | return -EBUSY; |
131 | |
132 | ret = usb_driver_claim_interface(driver, iface: intf, data: serial); |
133 | if (ret) { |
134 | dev_err(&serial->interface->dev, |
135 | "failed to claim sibling interface: %d\n" , ret); |
136 | return ret; |
137 | } |
138 | |
139 | serial->sibling = intf; |
140 | |
141 | return 0; |
142 | } |
143 | EXPORT_SYMBOL_GPL(usb_serial_claim_interface); |
144 | |
145 | static void release_sibling(struct usb_serial *serial, struct usb_interface *intf) |
146 | { |
147 | struct usb_driver *driver = serial->type->usb_driver; |
148 | struct usb_interface *sibling; |
149 | |
150 | if (!serial->sibling) |
151 | return; |
152 | |
153 | if (intf == serial->sibling) |
154 | sibling = serial->interface; |
155 | else |
156 | sibling = serial->sibling; |
157 | |
158 | usb_set_intfdata(intf: sibling, NULL); |
159 | usb_driver_release_interface(driver, iface: sibling); |
160 | } |
161 | |
162 | static void destroy_serial(struct kref *kref) |
163 | { |
164 | struct usb_serial *serial; |
165 | struct usb_serial_port *port; |
166 | int i; |
167 | |
168 | serial = to_usb_serial(kref); |
169 | |
170 | /* return the minor range that this device had */ |
171 | if (serial->minors_reserved) |
172 | release_minors(serial); |
173 | |
174 | if (serial->attached && serial->type->release) |
175 | serial->type->release(serial); |
176 | |
177 | /* Now that nothing is using the ports, they can be freed */ |
178 | for (i = 0; i < serial->num_port_pointers; ++i) { |
179 | port = serial->port[i]; |
180 | if (port) { |
181 | port->serial = NULL; |
182 | put_device(dev: &port->dev); |
183 | } |
184 | } |
185 | |
186 | usb_put_intf(intf: serial->interface); |
187 | usb_put_dev(dev: serial->dev); |
188 | kfree(objp: serial); |
189 | } |
190 | |
191 | void usb_serial_put(struct usb_serial *serial) |
192 | { |
193 | kref_put(kref: &serial->kref, release: destroy_serial); |
194 | } |
195 | |
196 | /***************************************************************************** |
197 | * Driver tty interface functions |
198 | *****************************************************************************/ |
199 | |
200 | /** |
201 | * serial_install - install tty |
202 | * @driver: the driver (USB in our case) |
203 | * @tty: the tty being created |
204 | * |
205 | * Initialise the termios structure for this tty. We use the default |
206 | * USB serial settings but permit them to be overridden by |
207 | * serial->type->init_termios on first open. |
208 | * |
209 | * This is the first place a new tty gets used. Hence this is where we |
210 | * acquire references to the usb_serial structure and the driver module, |
211 | * where we store a pointer to the port. All these actions are reversed |
212 | * in serial_cleanup(). |
213 | */ |
214 | static int serial_install(struct tty_driver *driver, struct tty_struct *tty) |
215 | { |
216 | int idx = tty->index; |
217 | struct usb_serial *serial; |
218 | struct usb_serial_port *port; |
219 | bool init_termios; |
220 | int retval = -ENODEV; |
221 | |
222 | port = usb_serial_port_get_by_minor(minor: idx); |
223 | if (!port) |
224 | return retval; |
225 | |
226 | serial = port->serial; |
227 | if (!try_module_get(module: serial->type->driver.owner)) |
228 | goto err_put_serial; |
229 | |
230 | init_termios = (driver->termios[idx] == NULL); |
231 | |
232 | retval = tty_standard_install(driver, tty); |
233 | if (retval) |
234 | goto err_put_module; |
235 | |
236 | mutex_unlock(lock: &serial->disc_mutex); |
237 | |
238 | /* allow the driver to update the initial settings */ |
239 | if (init_termios && serial->type->init_termios) |
240 | serial->type->init_termios(tty); |
241 | |
242 | tty->driver_data = port; |
243 | |
244 | return retval; |
245 | |
246 | err_put_module: |
247 | module_put(module: serial->type->driver.owner); |
248 | err_put_serial: |
249 | usb_serial_put(serial); |
250 | mutex_unlock(lock: &serial->disc_mutex); |
251 | return retval; |
252 | } |
253 | |
254 | static int serial_port_activate(struct tty_port *tport, struct tty_struct *tty) |
255 | { |
256 | struct usb_serial_port *port = |
257 | container_of(tport, struct usb_serial_port, port); |
258 | struct usb_serial *serial = port->serial; |
259 | int retval; |
260 | |
261 | mutex_lock(&serial->disc_mutex); |
262 | if (serial->disconnected) { |
263 | retval = -ENODEV; |
264 | goto out_unlock; |
265 | } |
266 | |
267 | retval = usb_autopm_get_interface(intf: serial->interface); |
268 | if (retval) |
269 | goto out_unlock; |
270 | |
271 | retval = port->serial->type->open(tty, port); |
272 | if (retval) |
273 | usb_autopm_put_interface(intf: serial->interface); |
274 | out_unlock: |
275 | mutex_unlock(lock: &serial->disc_mutex); |
276 | |
277 | if (retval < 0) |
278 | retval = usb_translate_errors(error_code: retval); |
279 | |
280 | return retval; |
281 | } |
282 | |
283 | static int serial_open(struct tty_struct *tty, struct file *filp) |
284 | { |
285 | struct usb_serial_port *port = tty->driver_data; |
286 | |
287 | dev_dbg(&port->dev, "%s\n" , __func__); |
288 | |
289 | return tty_port_open(port: &port->port, tty, filp); |
290 | } |
291 | |
292 | /** |
293 | * serial_port_shutdown - shut down hardware |
294 | * @tport: tty port to shut down |
295 | * |
296 | * Shut down a USB serial port. Serialized against activate by the |
297 | * tport mutex and kept to matching open/close pairs |
298 | * of calls by the tty-port initialized flag. |
299 | * |
300 | * Not called if tty is console. |
301 | */ |
302 | static void serial_port_shutdown(struct tty_port *tport) |
303 | { |
304 | struct usb_serial_port *port = |
305 | container_of(tport, struct usb_serial_port, port); |
306 | struct usb_serial_driver *drv = port->serial->type; |
307 | |
308 | if (drv->close) |
309 | drv->close(port); |
310 | |
311 | usb_autopm_put_interface(intf: port->serial->interface); |
312 | } |
313 | |
314 | static void serial_hangup(struct tty_struct *tty) |
315 | { |
316 | struct usb_serial_port *port = tty->driver_data; |
317 | |
318 | dev_dbg(&port->dev, "%s\n" , __func__); |
319 | |
320 | tty_port_hangup(port: &port->port); |
321 | } |
322 | |
323 | static void serial_close(struct tty_struct *tty, struct file *filp) |
324 | { |
325 | struct usb_serial_port *port = tty->driver_data; |
326 | |
327 | dev_dbg(&port->dev, "%s\n" , __func__); |
328 | |
329 | tty_port_close(port: &port->port, tty, filp); |
330 | } |
331 | |
332 | /** |
333 | * serial_cleanup - free resources post close/hangup |
334 | * @tty: tty to clean up |
335 | * |
336 | * Do the resource freeing and refcount dropping for the port. |
337 | * Avoid freeing the console. |
338 | * |
339 | * Called asynchronously after the last tty kref is dropped. |
340 | */ |
341 | static void serial_cleanup(struct tty_struct *tty) |
342 | { |
343 | struct usb_serial_port *port = tty->driver_data; |
344 | struct usb_serial *serial; |
345 | struct module *owner; |
346 | |
347 | dev_dbg(&port->dev, "%s\n" , __func__); |
348 | |
349 | /* The console is magical. Do not hang up the console hardware |
350 | * or there will be tears. |
351 | */ |
352 | if (port->port.console) |
353 | return; |
354 | |
355 | tty->driver_data = NULL; |
356 | |
357 | serial = port->serial; |
358 | owner = serial->type->driver.owner; |
359 | |
360 | usb_serial_put(serial); |
361 | module_put(module: owner); |
362 | } |
363 | |
364 | static ssize_t serial_write(struct tty_struct *tty, const u8 *buf, size_t count) |
365 | { |
366 | struct usb_serial_port *port = tty->driver_data; |
367 | int retval = -ENODEV; |
368 | |
369 | if (port->serial->dev->state == USB_STATE_NOTATTACHED) |
370 | goto exit; |
371 | |
372 | dev_dbg(&port->dev, "%s - %zu byte(s)\n" , __func__, count); |
373 | |
374 | retval = port->serial->type->write(tty, port, buf, count); |
375 | if (retval < 0) |
376 | retval = usb_translate_errors(error_code: retval); |
377 | exit: |
378 | return retval; |
379 | } |
380 | |
381 | static unsigned int serial_write_room(struct tty_struct *tty) |
382 | { |
383 | struct usb_serial_port *port = tty->driver_data; |
384 | |
385 | dev_dbg(&port->dev, "%s\n" , __func__); |
386 | |
387 | return port->serial->type->write_room(tty); |
388 | } |
389 | |
390 | static unsigned int serial_chars_in_buffer(struct tty_struct *tty) |
391 | { |
392 | struct usb_serial_port *port = tty->driver_data; |
393 | struct usb_serial *serial = port->serial; |
394 | |
395 | dev_dbg(&port->dev, "%s\n" , __func__); |
396 | |
397 | if (serial->disconnected) |
398 | return 0; |
399 | |
400 | return serial->type->chars_in_buffer(tty); |
401 | } |
402 | |
403 | static void serial_wait_until_sent(struct tty_struct *tty, int timeout) |
404 | { |
405 | struct usb_serial_port *port = tty->driver_data; |
406 | struct usb_serial *serial = port->serial; |
407 | |
408 | dev_dbg(&port->dev, "%s\n" , __func__); |
409 | |
410 | if (!port->serial->type->wait_until_sent) |
411 | return; |
412 | |
413 | mutex_lock(&serial->disc_mutex); |
414 | if (!serial->disconnected) |
415 | port->serial->type->wait_until_sent(tty, timeout); |
416 | mutex_unlock(lock: &serial->disc_mutex); |
417 | } |
418 | |
419 | static void serial_throttle(struct tty_struct *tty) |
420 | { |
421 | struct usb_serial_port *port = tty->driver_data; |
422 | |
423 | dev_dbg(&port->dev, "%s\n" , __func__); |
424 | |
425 | if (port->serial->type->throttle) |
426 | port->serial->type->throttle(tty); |
427 | } |
428 | |
429 | static void serial_unthrottle(struct tty_struct *tty) |
430 | { |
431 | struct usb_serial_port *port = tty->driver_data; |
432 | |
433 | dev_dbg(&port->dev, "%s\n" , __func__); |
434 | |
435 | if (port->serial->type->unthrottle) |
436 | port->serial->type->unthrottle(tty); |
437 | } |
438 | |
439 | static int serial_get_serial(struct tty_struct *tty, struct serial_struct *ss) |
440 | { |
441 | struct usb_serial_port *port = tty->driver_data; |
442 | struct tty_port *tport = &port->port; |
443 | unsigned int close_delay, closing_wait; |
444 | |
445 | mutex_lock(&tport->mutex); |
446 | |
447 | close_delay = jiffies_to_msecs(j: tport->close_delay) / 10; |
448 | closing_wait = tport->closing_wait; |
449 | if (closing_wait != ASYNC_CLOSING_WAIT_NONE) |
450 | closing_wait = jiffies_to_msecs(j: closing_wait) / 10; |
451 | |
452 | ss->line = port->minor; |
453 | ss->close_delay = close_delay; |
454 | ss->closing_wait = closing_wait; |
455 | |
456 | if (port->serial->type->get_serial) |
457 | port->serial->type->get_serial(tty, ss); |
458 | |
459 | mutex_unlock(lock: &tport->mutex); |
460 | |
461 | return 0; |
462 | } |
463 | |
464 | static int serial_set_serial(struct tty_struct *tty, struct serial_struct *ss) |
465 | { |
466 | struct usb_serial_port *port = tty->driver_data; |
467 | struct tty_port *tport = &port->port; |
468 | unsigned int close_delay, closing_wait; |
469 | int ret = 0; |
470 | |
471 | close_delay = msecs_to_jiffies(m: ss->close_delay * 10); |
472 | closing_wait = ss->closing_wait; |
473 | if (closing_wait != ASYNC_CLOSING_WAIT_NONE) |
474 | closing_wait = msecs_to_jiffies(m: closing_wait * 10); |
475 | |
476 | mutex_lock(&tport->mutex); |
477 | |
478 | if (!capable(CAP_SYS_ADMIN)) { |
479 | if (close_delay != tport->close_delay || |
480 | closing_wait != tport->closing_wait) { |
481 | ret = -EPERM; |
482 | goto out_unlock; |
483 | } |
484 | } |
485 | |
486 | if (port->serial->type->set_serial) { |
487 | ret = port->serial->type->set_serial(tty, ss); |
488 | if (ret) |
489 | goto out_unlock; |
490 | } |
491 | |
492 | tport->close_delay = close_delay; |
493 | tport->closing_wait = closing_wait; |
494 | out_unlock: |
495 | mutex_unlock(lock: &tport->mutex); |
496 | |
497 | return ret; |
498 | } |
499 | |
500 | static int serial_ioctl(struct tty_struct *tty, |
501 | unsigned int cmd, unsigned long arg) |
502 | { |
503 | struct usb_serial_port *port = tty->driver_data; |
504 | int retval = -ENOIOCTLCMD; |
505 | |
506 | dev_dbg(&port->dev, "%s - cmd 0x%04x\n" , __func__, cmd); |
507 | |
508 | switch (cmd) { |
509 | case TIOCMIWAIT: |
510 | if (port->serial->type->tiocmiwait) |
511 | retval = port->serial->type->tiocmiwait(tty, arg); |
512 | break; |
513 | default: |
514 | if (port->serial->type->ioctl) |
515 | retval = port->serial->type->ioctl(tty, cmd, arg); |
516 | } |
517 | |
518 | return retval; |
519 | } |
520 | |
521 | static void serial_set_termios(struct tty_struct *tty, |
522 | const struct ktermios *old) |
523 | { |
524 | struct usb_serial_port *port = tty->driver_data; |
525 | |
526 | dev_dbg(&port->dev, "%s\n" , __func__); |
527 | |
528 | if (port->serial->type->set_termios) |
529 | port->serial->type->set_termios(tty, port, old); |
530 | else |
531 | tty_termios_copy_hw(new: &tty->termios, old); |
532 | } |
533 | |
534 | static int serial_break(struct tty_struct *tty, int break_state) |
535 | { |
536 | struct usb_serial_port *port = tty->driver_data; |
537 | |
538 | dev_dbg(&port->dev, "%s\n" , __func__); |
539 | |
540 | if (port->serial->type->break_ctl) |
541 | return port->serial->type->break_ctl(tty, break_state); |
542 | |
543 | return -ENOTTY; |
544 | } |
545 | |
546 | static int serial_proc_show(struct seq_file *m, void *v) |
547 | { |
548 | struct usb_serial *serial; |
549 | struct usb_serial_port *port; |
550 | int i; |
551 | char tmp[40]; |
552 | |
553 | seq_puts(m, s: "usbserinfo:1.0 driver:2.0\n" ); |
554 | for (i = 0; i < USB_SERIAL_TTY_MINORS; ++i) { |
555 | port = usb_serial_port_get_by_minor(minor: i); |
556 | if (port == NULL) |
557 | continue; |
558 | serial = port->serial; |
559 | |
560 | seq_printf(m, fmt: "%d:" , i); |
561 | if (serial->type->driver.owner) |
562 | seq_printf(m, fmt: " module:%s" , |
563 | module_name(serial->type->driver.owner)); |
564 | seq_printf(m, fmt: " name:\"%s\"" , |
565 | serial->type->description); |
566 | seq_printf(m, fmt: " vendor:%04x product:%04x" , |
567 | le16_to_cpu(serial->dev->descriptor.idVendor), |
568 | le16_to_cpu(serial->dev->descriptor.idProduct)); |
569 | seq_printf(m, fmt: " num_ports:%d" , serial->num_ports); |
570 | seq_printf(m, fmt: " port:%d" , port->port_number); |
571 | usb_make_path(dev: serial->dev, buf: tmp, size: sizeof(tmp)); |
572 | seq_printf(m, fmt: " path:%s" , tmp); |
573 | |
574 | seq_putc(m, c: '\n'); |
575 | usb_serial_put(serial); |
576 | mutex_unlock(lock: &serial->disc_mutex); |
577 | } |
578 | return 0; |
579 | } |
580 | |
581 | static int serial_tiocmget(struct tty_struct *tty) |
582 | { |
583 | struct usb_serial_port *port = tty->driver_data; |
584 | |
585 | dev_dbg(&port->dev, "%s\n" , __func__); |
586 | |
587 | if (port->serial->type->tiocmget) |
588 | return port->serial->type->tiocmget(tty); |
589 | return -ENOTTY; |
590 | } |
591 | |
592 | static int serial_tiocmset(struct tty_struct *tty, |
593 | unsigned int set, unsigned int clear) |
594 | { |
595 | struct usb_serial_port *port = tty->driver_data; |
596 | |
597 | dev_dbg(&port->dev, "%s\n" , __func__); |
598 | |
599 | if (port->serial->type->tiocmset) |
600 | return port->serial->type->tiocmset(tty, set, clear); |
601 | return -ENOTTY; |
602 | } |
603 | |
604 | static int serial_get_icount(struct tty_struct *tty, |
605 | struct serial_icounter_struct *icount) |
606 | { |
607 | struct usb_serial_port *port = tty->driver_data; |
608 | |
609 | dev_dbg(&port->dev, "%s\n" , __func__); |
610 | |
611 | if (port->serial->type->get_icount) |
612 | return port->serial->type->get_icount(tty, icount); |
613 | return -ENOTTY; |
614 | } |
615 | |
616 | /* |
617 | * We would be calling tty_wakeup here, but unfortunately some line |
618 | * disciplines have an annoying habit of calling tty->write from |
619 | * the write wakeup callback (e.g. n_hdlc.c). |
620 | */ |
621 | void usb_serial_port_softint(struct usb_serial_port *port) |
622 | { |
623 | schedule_work(work: &port->work); |
624 | } |
625 | EXPORT_SYMBOL_GPL(usb_serial_port_softint); |
626 | |
627 | static void usb_serial_port_work(struct work_struct *work) |
628 | { |
629 | struct usb_serial_port *port = |
630 | container_of(work, struct usb_serial_port, work); |
631 | |
632 | tty_port_tty_wakeup(port: &port->port); |
633 | } |
634 | |
635 | static void usb_serial_port_poison_urbs(struct usb_serial_port *port) |
636 | { |
637 | int i; |
638 | |
639 | for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) |
640 | usb_poison_urb(urb: port->read_urbs[i]); |
641 | for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) |
642 | usb_poison_urb(urb: port->write_urbs[i]); |
643 | |
644 | usb_poison_urb(urb: port->interrupt_in_urb); |
645 | usb_poison_urb(urb: port->interrupt_out_urb); |
646 | } |
647 | |
648 | static void usb_serial_port_unpoison_urbs(struct usb_serial_port *port) |
649 | { |
650 | int i; |
651 | |
652 | for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) |
653 | usb_unpoison_urb(urb: port->read_urbs[i]); |
654 | for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) |
655 | usb_unpoison_urb(urb: port->write_urbs[i]); |
656 | |
657 | usb_unpoison_urb(urb: port->interrupt_in_urb); |
658 | usb_unpoison_urb(urb: port->interrupt_out_urb); |
659 | } |
660 | |
661 | static void usb_serial_port_release(struct device *dev) |
662 | { |
663 | struct usb_serial_port *port = to_usb_serial_port(dev); |
664 | int i; |
665 | |
666 | dev_dbg(dev, "%s\n" , __func__); |
667 | |
668 | usb_free_urb(urb: port->interrupt_in_urb); |
669 | usb_free_urb(urb: port->interrupt_out_urb); |
670 | for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) { |
671 | usb_free_urb(urb: port->read_urbs[i]); |
672 | kfree(objp: port->bulk_in_buffers[i]); |
673 | } |
674 | for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) { |
675 | usb_free_urb(urb: port->write_urbs[i]); |
676 | kfree(objp: port->bulk_out_buffers[i]); |
677 | } |
678 | kfifo_free(&port->write_fifo); |
679 | kfree(objp: port->interrupt_in_buffer); |
680 | kfree(objp: port->interrupt_out_buffer); |
681 | tty_port_destroy(port: &port->port); |
682 | kfree(objp: port); |
683 | } |
684 | |
685 | static struct usb_serial *create_serial(struct usb_device *dev, |
686 | struct usb_interface *interface, |
687 | struct usb_serial_driver *driver) |
688 | { |
689 | struct usb_serial *serial; |
690 | |
691 | serial = kzalloc(size: sizeof(*serial), GFP_KERNEL); |
692 | if (!serial) |
693 | return NULL; |
694 | serial->dev = usb_get_dev(dev); |
695 | serial->type = driver; |
696 | serial->interface = usb_get_intf(intf: interface); |
697 | kref_init(kref: &serial->kref); |
698 | mutex_init(&serial->disc_mutex); |
699 | serial->minors_reserved = 0; |
700 | |
701 | return serial; |
702 | } |
703 | |
704 | static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf, |
705 | struct usb_serial_driver *drv) |
706 | { |
707 | struct usb_dynid *dynid; |
708 | |
709 | spin_lock(lock: &drv->dynids.lock); |
710 | list_for_each_entry(dynid, &drv->dynids.list, node) { |
711 | if (usb_match_one_id(interface: intf, id: &dynid->id)) { |
712 | spin_unlock(lock: &drv->dynids.lock); |
713 | return &dynid->id; |
714 | } |
715 | } |
716 | spin_unlock(lock: &drv->dynids.lock); |
717 | return NULL; |
718 | } |
719 | |
720 | static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv, |
721 | struct usb_interface *intf) |
722 | { |
723 | const struct usb_device_id *id; |
724 | |
725 | id = usb_match_id(interface: intf, id: drv->id_table); |
726 | if (id) { |
727 | dev_dbg(&intf->dev, "static descriptor matches\n" ); |
728 | goto exit; |
729 | } |
730 | id = match_dynamic_id(intf, drv); |
731 | if (id) |
732 | dev_dbg(&intf->dev, "dynamic descriptor matches\n" ); |
733 | exit: |
734 | return id; |
735 | } |
736 | |
737 | /* Caller must hold table_lock */ |
738 | static struct usb_serial_driver *search_serial_device( |
739 | struct usb_interface *iface) |
740 | { |
741 | const struct usb_device_id *id = NULL; |
742 | struct usb_serial_driver *drv; |
743 | struct usb_driver *driver = to_usb_driver(iface->dev.driver); |
744 | |
745 | /* Check if the usb id matches a known device */ |
746 | list_for_each_entry(drv, &usb_serial_driver_list, driver_list) { |
747 | if (drv->usb_driver == driver) |
748 | id = get_iface_id(drv, intf: iface); |
749 | if (id) |
750 | return drv; |
751 | } |
752 | |
753 | return NULL; |
754 | } |
755 | |
756 | static bool serial_port_carrier_raised(struct tty_port *port) |
757 | { |
758 | struct usb_serial_port *p = container_of(port, struct usb_serial_port, port); |
759 | struct usb_serial_driver *drv = p->serial->type; |
760 | |
761 | if (drv->carrier_raised) |
762 | return drv->carrier_raised(p); |
763 | /* No carrier control - don't block */ |
764 | return true; |
765 | } |
766 | |
767 | static void serial_port_dtr_rts(struct tty_port *port, bool on) |
768 | { |
769 | struct usb_serial_port *p = container_of(port, struct usb_serial_port, port); |
770 | struct usb_serial_driver *drv = p->serial->type; |
771 | |
772 | if (drv->dtr_rts) |
773 | drv->dtr_rts(p, on); |
774 | } |
775 | |
776 | static ssize_t port_number_show(struct device *dev, |
777 | struct device_attribute *attr, char *buf) |
778 | { |
779 | struct usb_serial_port *port = to_usb_serial_port(dev); |
780 | |
781 | return sprintf(buf, fmt: "%u\n" , port->port_number); |
782 | } |
783 | static DEVICE_ATTR_RO(port_number); |
784 | |
785 | static struct attribute *usb_serial_port_attrs[] = { |
786 | &dev_attr_port_number.attr, |
787 | NULL |
788 | }; |
789 | ATTRIBUTE_GROUPS(usb_serial_port); |
790 | |
791 | static const struct tty_port_operations serial_port_ops = { |
792 | .carrier_raised = serial_port_carrier_raised, |
793 | .dtr_rts = serial_port_dtr_rts, |
794 | .activate = serial_port_activate, |
795 | .shutdown = serial_port_shutdown, |
796 | }; |
797 | |
798 | static void store_endpoint(struct usb_serial *serial, |
799 | struct usb_serial_endpoints *epds, |
800 | struct usb_endpoint_descriptor *epd) |
801 | { |
802 | struct device *dev = &serial->interface->dev; |
803 | u8 addr = epd->bEndpointAddress; |
804 | |
805 | if (usb_endpoint_is_bulk_in(epd)) { |
806 | if (epds->num_bulk_in == ARRAY_SIZE(epds->bulk_in)) |
807 | return; |
808 | dev_dbg(dev, "found bulk in endpoint %02x\n" , addr); |
809 | epds->bulk_in[epds->num_bulk_in++] = epd; |
810 | } else if (usb_endpoint_is_bulk_out(epd)) { |
811 | if (epds->num_bulk_out == ARRAY_SIZE(epds->bulk_out)) |
812 | return; |
813 | dev_dbg(dev, "found bulk out endpoint %02x\n" , addr); |
814 | epds->bulk_out[epds->num_bulk_out++] = epd; |
815 | } else if (usb_endpoint_is_int_in(epd)) { |
816 | if (epds->num_interrupt_in == ARRAY_SIZE(epds->interrupt_in)) |
817 | return; |
818 | dev_dbg(dev, "found interrupt in endpoint %02x\n" , addr); |
819 | epds->interrupt_in[epds->num_interrupt_in++] = epd; |
820 | } else if (usb_endpoint_is_int_out(epd)) { |
821 | if (epds->num_interrupt_out == ARRAY_SIZE(epds->interrupt_out)) |
822 | return; |
823 | dev_dbg(dev, "found interrupt out endpoint %02x\n" , addr); |
824 | epds->interrupt_out[epds->num_interrupt_out++] = epd; |
825 | } |
826 | } |
827 | |
828 | static void find_endpoints(struct usb_serial *serial, |
829 | struct usb_serial_endpoints *epds, |
830 | struct usb_interface *intf) |
831 | { |
832 | struct usb_host_interface *iface_desc; |
833 | struct usb_endpoint_descriptor *epd; |
834 | unsigned int i; |
835 | |
836 | iface_desc = intf->cur_altsetting; |
837 | for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) { |
838 | epd = &iface_desc->endpoint[i].desc; |
839 | store_endpoint(serial, epds, epd); |
840 | } |
841 | } |
842 | |
843 | static int setup_port_bulk_in(struct usb_serial_port *port, |
844 | struct usb_endpoint_descriptor *epd) |
845 | { |
846 | struct usb_serial_driver *type = port->serial->type; |
847 | struct usb_device *udev = port->serial->dev; |
848 | int buffer_size; |
849 | int i; |
850 | |
851 | buffer_size = max_t(int, type->bulk_in_size, usb_endpoint_maxp(epd)); |
852 | port->bulk_in_size = buffer_size; |
853 | port->bulk_in_endpointAddress = epd->bEndpointAddress; |
854 | |
855 | for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) { |
856 | set_bit(nr: i, addr: &port->read_urbs_free); |
857 | port->read_urbs[i] = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
858 | if (!port->read_urbs[i]) |
859 | return -ENOMEM; |
860 | port->bulk_in_buffers[i] = kmalloc(size: buffer_size, GFP_KERNEL); |
861 | if (!port->bulk_in_buffers[i]) |
862 | return -ENOMEM; |
863 | usb_fill_bulk_urb(urb: port->read_urbs[i], dev: udev, |
864 | usb_rcvbulkpipe(udev, epd->bEndpointAddress), |
865 | transfer_buffer: port->bulk_in_buffers[i], buffer_length: buffer_size, |
866 | complete_fn: type->read_bulk_callback, context: port); |
867 | } |
868 | |
869 | port->read_urb = port->read_urbs[0]; |
870 | port->bulk_in_buffer = port->bulk_in_buffers[0]; |
871 | |
872 | return 0; |
873 | } |
874 | |
875 | static int setup_port_bulk_out(struct usb_serial_port *port, |
876 | struct usb_endpoint_descriptor *epd) |
877 | { |
878 | struct usb_serial_driver *type = port->serial->type; |
879 | struct usb_device *udev = port->serial->dev; |
880 | int buffer_size; |
881 | int i; |
882 | |
883 | if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL)) |
884 | return -ENOMEM; |
885 | if (type->bulk_out_size) |
886 | buffer_size = type->bulk_out_size; |
887 | else |
888 | buffer_size = usb_endpoint_maxp(epd); |
889 | port->bulk_out_size = buffer_size; |
890 | port->bulk_out_endpointAddress = epd->bEndpointAddress; |
891 | |
892 | for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) { |
893 | set_bit(nr: i, addr: &port->write_urbs_free); |
894 | port->write_urbs[i] = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
895 | if (!port->write_urbs[i]) |
896 | return -ENOMEM; |
897 | port->bulk_out_buffers[i] = kmalloc(size: buffer_size, GFP_KERNEL); |
898 | if (!port->bulk_out_buffers[i]) |
899 | return -ENOMEM; |
900 | usb_fill_bulk_urb(urb: port->write_urbs[i], dev: udev, |
901 | usb_sndbulkpipe(udev, epd->bEndpointAddress), |
902 | transfer_buffer: port->bulk_out_buffers[i], buffer_length: buffer_size, |
903 | complete_fn: type->write_bulk_callback, context: port); |
904 | } |
905 | |
906 | port->write_urb = port->write_urbs[0]; |
907 | port->bulk_out_buffer = port->bulk_out_buffers[0]; |
908 | |
909 | return 0; |
910 | } |
911 | |
912 | static int setup_port_interrupt_in(struct usb_serial_port *port, |
913 | struct usb_endpoint_descriptor *epd) |
914 | { |
915 | struct usb_serial_driver *type = port->serial->type; |
916 | struct usb_device *udev = port->serial->dev; |
917 | int buffer_size; |
918 | |
919 | port->interrupt_in_urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
920 | if (!port->interrupt_in_urb) |
921 | return -ENOMEM; |
922 | buffer_size = usb_endpoint_maxp(epd); |
923 | port->interrupt_in_endpointAddress = epd->bEndpointAddress; |
924 | port->interrupt_in_buffer = kmalloc(size: buffer_size, GFP_KERNEL); |
925 | if (!port->interrupt_in_buffer) |
926 | return -ENOMEM; |
927 | usb_fill_int_urb(urb: port->interrupt_in_urb, dev: udev, |
928 | usb_rcvintpipe(udev, epd->bEndpointAddress), |
929 | transfer_buffer: port->interrupt_in_buffer, buffer_length: buffer_size, |
930 | complete_fn: type->read_int_callback, context: port, |
931 | interval: epd->bInterval); |
932 | |
933 | return 0; |
934 | } |
935 | |
936 | static int setup_port_interrupt_out(struct usb_serial_port *port, |
937 | struct usb_endpoint_descriptor *epd) |
938 | { |
939 | struct usb_serial_driver *type = port->serial->type; |
940 | struct usb_device *udev = port->serial->dev; |
941 | int buffer_size; |
942 | |
943 | port->interrupt_out_urb = usb_alloc_urb(iso_packets: 0, GFP_KERNEL); |
944 | if (!port->interrupt_out_urb) |
945 | return -ENOMEM; |
946 | buffer_size = usb_endpoint_maxp(epd); |
947 | port->interrupt_out_size = buffer_size; |
948 | port->interrupt_out_endpointAddress = epd->bEndpointAddress; |
949 | port->interrupt_out_buffer = kmalloc(size: buffer_size, GFP_KERNEL); |
950 | if (!port->interrupt_out_buffer) |
951 | return -ENOMEM; |
952 | usb_fill_int_urb(urb: port->interrupt_out_urb, dev: udev, |
953 | usb_sndintpipe(udev, epd->bEndpointAddress), |
954 | transfer_buffer: port->interrupt_out_buffer, buffer_length: buffer_size, |
955 | complete_fn: type->write_int_callback, context: port, |
956 | interval: epd->bInterval); |
957 | |
958 | return 0; |
959 | } |
960 | |
961 | static int usb_serial_probe(struct usb_interface *interface, |
962 | const struct usb_device_id *id) |
963 | { |
964 | struct device *ddev = &interface->dev; |
965 | struct usb_device *dev = interface_to_usbdev(interface); |
966 | struct usb_serial *serial = NULL; |
967 | struct usb_serial_port *port; |
968 | struct usb_serial_endpoints *epds; |
969 | struct usb_serial_driver *type = NULL; |
970 | int retval; |
971 | int i; |
972 | int num_ports = 0; |
973 | unsigned char max_endpoints; |
974 | |
975 | mutex_lock(&table_lock); |
976 | type = search_serial_device(iface: interface); |
977 | if (!type) { |
978 | mutex_unlock(lock: &table_lock); |
979 | dev_dbg(ddev, "none matched\n" ); |
980 | return -ENODEV; |
981 | } |
982 | |
983 | if (!try_module_get(module: type->driver.owner)) { |
984 | mutex_unlock(lock: &table_lock); |
985 | dev_err(ddev, "module get failed, exiting\n" ); |
986 | return -EIO; |
987 | } |
988 | mutex_unlock(lock: &table_lock); |
989 | |
990 | serial = create_serial(dev, interface, driver: type); |
991 | if (!serial) { |
992 | retval = -ENOMEM; |
993 | goto err_put_module; |
994 | } |
995 | |
996 | /* if this device type has a probe function, call it */ |
997 | if (type->probe) { |
998 | const struct usb_device_id *id; |
999 | |
1000 | id = get_iface_id(drv: type, intf: interface); |
1001 | retval = type->probe(serial, id); |
1002 | |
1003 | if (retval) { |
1004 | dev_dbg(ddev, "sub driver rejected device\n" ); |
1005 | goto err_release_sibling; |
1006 | } |
1007 | } |
1008 | |
1009 | /* descriptor matches, let's find the endpoints needed */ |
1010 | epds = kzalloc(size: sizeof(*epds), GFP_KERNEL); |
1011 | if (!epds) { |
1012 | retval = -ENOMEM; |
1013 | goto err_release_sibling; |
1014 | } |
1015 | |
1016 | find_endpoints(serial, epds, intf: interface); |
1017 | if (serial->sibling) |
1018 | find_endpoints(serial, epds, intf: serial->sibling); |
1019 | |
1020 | if (epds->num_bulk_in < type->num_bulk_in || |
1021 | epds->num_bulk_out < type->num_bulk_out || |
1022 | epds->num_interrupt_in < type->num_interrupt_in || |
1023 | epds->num_interrupt_out < type->num_interrupt_out) { |
1024 | dev_err(ddev, "required endpoints missing\n" ); |
1025 | retval = -ENODEV; |
1026 | goto err_free_epds; |
1027 | } |
1028 | |
1029 | if (type->calc_num_ports) { |
1030 | retval = type->calc_num_ports(serial, epds); |
1031 | if (retval < 0) |
1032 | goto err_free_epds; |
1033 | num_ports = retval; |
1034 | } |
1035 | |
1036 | if (!num_ports) |
1037 | num_ports = type->num_ports; |
1038 | |
1039 | if (num_ports > MAX_NUM_PORTS) { |
1040 | dev_warn(ddev, "too many ports requested: %d\n" , num_ports); |
1041 | num_ports = MAX_NUM_PORTS; |
1042 | } |
1043 | |
1044 | serial->num_ports = (unsigned char)num_ports; |
1045 | serial->num_bulk_in = epds->num_bulk_in; |
1046 | serial->num_bulk_out = epds->num_bulk_out; |
1047 | serial->num_interrupt_in = epds->num_interrupt_in; |
1048 | serial->num_interrupt_out = epds->num_interrupt_out; |
1049 | |
1050 | /* found all that we need */ |
1051 | dev_info(ddev, "%s converter detected\n" , type->description); |
1052 | |
1053 | /* create our ports, we need as many as the max endpoints */ |
1054 | /* we don't use num_ports here because some devices have more |
1055 | endpoint pairs than ports */ |
1056 | max_endpoints = max(epds->num_bulk_in, epds->num_bulk_out); |
1057 | max_endpoints = max(max_endpoints, epds->num_interrupt_in); |
1058 | max_endpoints = max(max_endpoints, epds->num_interrupt_out); |
1059 | max_endpoints = max(max_endpoints, serial->num_ports); |
1060 | serial->num_port_pointers = max_endpoints; |
1061 | |
1062 | dev_dbg(ddev, "setting up %d port structure(s)\n" , max_endpoints); |
1063 | for (i = 0; i < max_endpoints; ++i) { |
1064 | port = kzalloc(size: sizeof(struct usb_serial_port), GFP_KERNEL); |
1065 | if (!port) { |
1066 | retval = -ENOMEM; |
1067 | goto err_free_epds; |
1068 | } |
1069 | tty_port_init(port: &port->port); |
1070 | port->port.ops = &serial_port_ops; |
1071 | port->serial = serial; |
1072 | spin_lock_init(&port->lock); |
1073 | /* Keep this for private driver use for the moment but |
1074 | should probably go away */ |
1075 | INIT_WORK(&port->work, usb_serial_port_work); |
1076 | serial->port[i] = port; |
1077 | port->dev.parent = &interface->dev; |
1078 | port->dev.driver = NULL; |
1079 | port->dev.bus = &usb_serial_bus_type; |
1080 | port->dev.release = &usb_serial_port_release; |
1081 | port->dev.groups = usb_serial_port_groups; |
1082 | device_initialize(dev: &port->dev); |
1083 | } |
1084 | |
1085 | /* set up the endpoint information */ |
1086 | for (i = 0; i < epds->num_bulk_in; ++i) { |
1087 | retval = setup_port_bulk_in(port: serial->port[i], epd: epds->bulk_in[i]); |
1088 | if (retval) |
1089 | goto err_free_epds; |
1090 | } |
1091 | |
1092 | for (i = 0; i < epds->num_bulk_out; ++i) { |
1093 | retval = setup_port_bulk_out(port: serial->port[i], |
1094 | epd: epds->bulk_out[i]); |
1095 | if (retval) |
1096 | goto err_free_epds; |
1097 | } |
1098 | |
1099 | if (serial->type->read_int_callback) { |
1100 | for (i = 0; i < epds->num_interrupt_in; ++i) { |
1101 | retval = setup_port_interrupt_in(port: serial->port[i], |
1102 | epd: epds->interrupt_in[i]); |
1103 | if (retval) |
1104 | goto err_free_epds; |
1105 | } |
1106 | } else if (epds->num_interrupt_in) { |
1107 | dev_dbg(ddev, "The device claims to support interrupt in transfers, but read_int_callback is not defined\n" ); |
1108 | } |
1109 | |
1110 | if (serial->type->write_int_callback) { |
1111 | for (i = 0; i < epds->num_interrupt_out; ++i) { |
1112 | retval = setup_port_interrupt_out(port: serial->port[i], |
1113 | epd: epds->interrupt_out[i]); |
1114 | if (retval) |
1115 | goto err_free_epds; |
1116 | } |
1117 | } else if (epds->num_interrupt_out) { |
1118 | dev_dbg(ddev, "The device claims to support interrupt out transfers, but write_int_callback is not defined\n" ); |
1119 | } |
1120 | |
1121 | usb_set_intfdata(intf: interface, data: serial); |
1122 | |
1123 | /* if this device type has an attach function, call it */ |
1124 | if (type->attach) { |
1125 | retval = type->attach(serial); |
1126 | if (retval < 0) |
1127 | goto err_free_epds; |
1128 | serial->attached = 1; |
1129 | if (retval > 0) { |
1130 | /* quietly accept this device, but don't bind to a |
1131 | serial port as it's about to disappear */ |
1132 | serial->num_ports = 0; |
1133 | goto exit; |
1134 | } |
1135 | } else { |
1136 | serial->attached = 1; |
1137 | } |
1138 | |
1139 | retval = allocate_minors(serial, num_ports); |
1140 | if (retval) { |
1141 | dev_err(ddev, "No more free serial minor numbers\n" ); |
1142 | goto err_free_epds; |
1143 | } |
1144 | |
1145 | /* register all of the individual ports with the driver core */ |
1146 | for (i = 0; i < num_ports; ++i) { |
1147 | port = serial->port[i]; |
1148 | dev_set_name(dev: &port->dev, name: "ttyUSB%d" , port->minor); |
1149 | dev_dbg(ddev, "registering %s\n" , dev_name(&port->dev)); |
1150 | device_enable_async_suspend(dev: &port->dev); |
1151 | |
1152 | retval = device_add(dev: &port->dev); |
1153 | if (retval) |
1154 | dev_err(ddev, "Error registering port device, continuing\n" ); |
1155 | } |
1156 | |
1157 | if (num_ports > 0) |
1158 | usb_serial_console_init(minor: serial->port[0]->minor); |
1159 | exit: |
1160 | kfree(objp: epds); |
1161 | module_put(module: type->driver.owner); |
1162 | return 0; |
1163 | |
1164 | err_free_epds: |
1165 | kfree(objp: epds); |
1166 | err_release_sibling: |
1167 | release_sibling(serial, intf: interface); |
1168 | usb_serial_put(serial); |
1169 | err_put_module: |
1170 | module_put(module: type->driver.owner); |
1171 | |
1172 | return retval; |
1173 | } |
1174 | |
1175 | static void usb_serial_disconnect(struct usb_interface *interface) |
1176 | { |
1177 | int i; |
1178 | struct usb_serial *serial = usb_get_intfdata(intf: interface); |
1179 | struct device *dev = &interface->dev; |
1180 | struct usb_serial_port *port; |
1181 | struct tty_struct *tty; |
1182 | |
1183 | /* sibling interface is cleaning up */ |
1184 | if (!serial) |
1185 | return; |
1186 | |
1187 | usb_serial_console_disconnect(serial); |
1188 | |
1189 | mutex_lock(&serial->disc_mutex); |
1190 | /* must set a flag, to signal subdrivers */ |
1191 | serial->disconnected = 1; |
1192 | mutex_unlock(lock: &serial->disc_mutex); |
1193 | |
1194 | for (i = 0; i < serial->num_ports; ++i) { |
1195 | port = serial->port[i]; |
1196 | tty = tty_port_tty_get(port: &port->port); |
1197 | if (tty) { |
1198 | tty_vhangup(tty); |
1199 | tty_kref_put(tty); |
1200 | } |
1201 | usb_serial_port_poison_urbs(port); |
1202 | wake_up_interruptible(&port->port.delta_msr_wait); |
1203 | cancel_work_sync(work: &port->work); |
1204 | if (device_is_registered(dev: &port->dev)) |
1205 | device_del(dev: &port->dev); |
1206 | } |
1207 | if (serial->type->disconnect) |
1208 | serial->type->disconnect(serial); |
1209 | |
1210 | release_sibling(serial, intf: interface); |
1211 | |
1212 | /* let the last holder of this object cause it to be cleaned up */ |
1213 | usb_serial_put(serial); |
1214 | dev_info(dev, "device disconnected\n" ); |
1215 | } |
1216 | |
1217 | int usb_serial_suspend(struct usb_interface *intf, pm_message_t message) |
1218 | { |
1219 | struct usb_serial *serial = usb_get_intfdata(intf); |
1220 | int i, r; |
1221 | |
1222 | /* suspend when called for first sibling interface */ |
1223 | if (serial->suspend_count++) |
1224 | return 0; |
1225 | |
1226 | /* |
1227 | * serial->type->suspend() MUST return 0 in system sleep context, |
1228 | * otherwise, the resume callback has to recover device from |
1229 | * previous suspend failure. |
1230 | */ |
1231 | if (serial->type->suspend) { |
1232 | r = serial->type->suspend(serial, message); |
1233 | if (r < 0) { |
1234 | serial->suspend_count--; |
1235 | return r; |
1236 | } |
1237 | } |
1238 | |
1239 | for (i = 0; i < serial->num_ports; ++i) |
1240 | usb_serial_port_poison_urbs(port: serial->port[i]); |
1241 | |
1242 | return 0; |
1243 | } |
1244 | EXPORT_SYMBOL(usb_serial_suspend); |
1245 | |
1246 | static void usb_serial_unpoison_port_urbs(struct usb_serial *serial) |
1247 | { |
1248 | int i; |
1249 | |
1250 | for (i = 0; i < serial->num_ports; ++i) |
1251 | usb_serial_port_unpoison_urbs(port: serial->port[i]); |
1252 | } |
1253 | |
1254 | int usb_serial_resume(struct usb_interface *intf) |
1255 | { |
1256 | struct usb_serial *serial = usb_get_intfdata(intf); |
1257 | int rv; |
1258 | |
1259 | /* resume when called for last sibling interface */ |
1260 | if (--serial->suspend_count) |
1261 | return 0; |
1262 | |
1263 | usb_serial_unpoison_port_urbs(serial); |
1264 | |
1265 | if (serial->type->resume) |
1266 | rv = serial->type->resume(serial); |
1267 | else |
1268 | rv = usb_serial_generic_resume(serial); |
1269 | |
1270 | return rv; |
1271 | } |
1272 | EXPORT_SYMBOL(usb_serial_resume); |
1273 | |
1274 | static int usb_serial_reset_resume(struct usb_interface *intf) |
1275 | { |
1276 | struct usb_serial *serial = usb_get_intfdata(intf); |
1277 | int rv; |
1278 | |
1279 | /* resume when called for last sibling interface */ |
1280 | if (--serial->suspend_count) |
1281 | return 0; |
1282 | |
1283 | usb_serial_unpoison_port_urbs(serial); |
1284 | |
1285 | if (serial->type->reset_resume) { |
1286 | rv = serial->type->reset_resume(serial); |
1287 | } else { |
1288 | rv = -EOPNOTSUPP; |
1289 | intf->needs_binding = 1; |
1290 | } |
1291 | |
1292 | return rv; |
1293 | } |
1294 | |
1295 | static const struct tty_operations serial_ops = { |
1296 | .open = serial_open, |
1297 | .close = serial_close, |
1298 | .write = serial_write, |
1299 | .hangup = serial_hangup, |
1300 | .write_room = serial_write_room, |
1301 | .ioctl = serial_ioctl, |
1302 | .set_termios = serial_set_termios, |
1303 | .throttle = serial_throttle, |
1304 | .unthrottle = serial_unthrottle, |
1305 | .break_ctl = serial_break, |
1306 | .chars_in_buffer = serial_chars_in_buffer, |
1307 | .wait_until_sent = serial_wait_until_sent, |
1308 | .tiocmget = serial_tiocmget, |
1309 | .tiocmset = serial_tiocmset, |
1310 | .get_icount = serial_get_icount, |
1311 | .set_serial = serial_set_serial, |
1312 | .get_serial = serial_get_serial, |
1313 | .cleanup = serial_cleanup, |
1314 | .install = serial_install, |
1315 | .proc_show = serial_proc_show, |
1316 | }; |
1317 | |
1318 | |
1319 | struct tty_driver *usb_serial_tty_driver; |
1320 | |
1321 | static int __init usb_serial_init(void) |
1322 | { |
1323 | int result; |
1324 | |
1325 | usb_serial_tty_driver = tty_alloc_driver(USB_SERIAL_TTY_MINORS, |
1326 | TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV); |
1327 | if (IS_ERR(ptr: usb_serial_tty_driver)) |
1328 | return PTR_ERR(ptr: usb_serial_tty_driver); |
1329 | |
1330 | /* Initialize our global data */ |
1331 | result = bus_register(bus: &usb_serial_bus_type); |
1332 | if (result) { |
1333 | pr_err("%s - registering bus driver failed\n" , __func__); |
1334 | goto err_put_driver; |
1335 | } |
1336 | |
1337 | usb_serial_tty_driver->driver_name = "usbserial" ; |
1338 | usb_serial_tty_driver->name = "ttyUSB" ; |
1339 | usb_serial_tty_driver->major = USB_SERIAL_TTY_MAJOR; |
1340 | usb_serial_tty_driver->minor_start = 0; |
1341 | usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL; |
1342 | usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL; |
1343 | usb_serial_tty_driver->init_termios = tty_std_termios; |
1344 | usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD |
1345 | | HUPCL | CLOCAL; |
1346 | usb_serial_tty_driver->init_termios.c_ispeed = 9600; |
1347 | usb_serial_tty_driver->init_termios.c_ospeed = 9600; |
1348 | tty_set_operations(driver: usb_serial_tty_driver, op: &serial_ops); |
1349 | result = tty_register_driver(driver: usb_serial_tty_driver); |
1350 | if (result) { |
1351 | pr_err("%s - tty_register_driver failed\n" , __func__); |
1352 | goto err_unregister_bus; |
1353 | } |
1354 | |
1355 | /* register the generic driver, if we should */ |
1356 | result = usb_serial_generic_register(); |
1357 | if (result < 0) { |
1358 | pr_err("%s - registering generic driver failed\n" , __func__); |
1359 | goto err_unregister_driver; |
1360 | } |
1361 | |
1362 | return result; |
1363 | |
1364 | err_unregister_driver: |
1365 | tty_unregister_driver(driver: usb_serial_tty_driver); |
1366 | err_unregister_bus: |
1367 | bus_unregister(bus: &usb_serial_bus_type); |
1368 | err_put_driver: |
1369 | pr_err("%s - returning with error %d\n" , __func__, result); |
1370 | tty_driver_kref_put(driver: usb_serial_tty_driver); |
1371 | return result; |
1372 | } |
1373 | |
1374 | |
1375 | static void __exit usb_serial_exit(void) |
1376 | { |
1377 | usb_serial_console_exit(); |
1378 | |
1379 | usb_serial_generic_deregister(); |
1380 | |
1381 | tty_unregister_driver(driver: usb_serial_tty_driver); |
1382 | tty_driver_kref_put(driver: usb_serial_tty_driver); |
1383 | bus_unregister(bus: &usb_serial_bus_type); |
1384 | idr_destroy(&serial_minors); |
1385 | } |
1386 | |
1387 | |
1388 | module_init(usb_serial_init); |
1389 | module_exit(usb_serial_exit); |
1390 | |
1391 | #define set_to_generic_if_null(type, function) \ |
1392 | do { \ |
1393 | if (!type->function) { \ |
1394 | type->function = usb_serial_generic_##function; \ |
1395 | pr_debug("%s: using generic " #function "\n", \ |
1396 | type->driver.name); \ |
1397 | } \ |
1398 | } while (0) |
1399 | |
1400 | static void usb_serial_operations_init(struct usb_serial_driver *device) |
1401 | { |
1402 | set_to_generic_if_null(device, open); |
1403 | set_to_generic_if_null(device, write); |
1404 | set_to_generic_if_null(device, close); |
1405 | set_to_generic_if_null(device, write_room); |
1406 | set_to_generic_if_null(device, chars_in_buffer); |
1407 | if (device->tx_empty) |
1408 | set_to_generic_if_null(device, wait_until_sent); |
1409 | set_to_generic_if_null(device, read_bulk_callback); |
1410 | set_to_generic_if_null(device, write_bulk_callback); |
1411 | set_to_generic_if_null(device, process_read_urb); |
1412 | set_to_generic_if_null(device, prepare_write_buffer); |
1413 | } |
1414 | |
1415 | static int usb_serial_register(struct usb_serial_driver *driver) |
1416 | { |
1417 | int retval; |
1418 | |
1419 | if (usb_disabled()) |
1420 | return -ENODEV; |
1421 | |
1422 | if (!driver->description) |
1423 | driver->description = driver->driver.name; |
1424 | if (!driver->usb_driver) { |
1425 | WARN(1, "Serial driver %s has no usb_driver\n" , |
1426 | driver->description); |
1427 | return -EINVAL; |
1428 | } |
1429 | |
1430 | /* Prevent individual ports from being unbound. */ |
1431 | driver->driver.suppress_bind_attrs = true; |
1432 | |
1433 | usb_serial_operations_init(device: driver); |
1434 | |
1435 | /* Add this device to our list of devices */ |
1436 | mutex_lock(&table_lock); |
1437 | list_add(new: &driver->driver_list, head: &usb_serial_driver_list); |
1438 | |
1439 | retval = usb_serial_bus_register(device: driver); |
1440 | if (retval) { |
1441 | pr_err("problem %d when registering driver %s\n" , retval, driver->description); |
1442 | list_del(entry: &driver->driver_list); |
1443 | } else { |
1444 | pr_info("USB Serial support registered for %s\n" , driver->description); |
1445 | } |
1446 | mutex_unlock(lock: &table_lock); |
1447 | return retval; |
1448 | } |
1449 | |
1450 | static void usb_serial_deregister(struct usb_serial_driver *device) |
1451 | { |
1452 | pr_info("USB Serial deregistering driver %s\n" , device->description); |
1453 | |
1454 | mutex_lock(&table_lock); |
1455 | list_del(entry: &device->driver_list); |
1456 | mutex_unlock(lock: &table_lock); |
1457 | |
1458 | usb_serial_bus_deregister(device); |
1459 | } |
1460 | |
1461 | /** |
1462 | * usb_serial_register_drivers - register drivers for a usb-serial module |
1463 | * @serial_drivers: NULL-terminated array of pointers to drivers to be registered |
1464 | * @name: name of the usb_driver for this set of @serial_drivers |
1465 | * @id_table: list of all devices this @serial_drivers set binds to |
1466 | * |
1467 | * Registers all the drivers in the @serial_drivers array, and dynamically |
1468 | * creates a struct usb_driver with the name @name and id_table of @id_table. |
1469 | */ |
1470 | int usb_serial_register_drivers(struct usb_serial_driver *const serial_drivers[], |
1471 | const char *name, |
1472 | const struct usb_device_id *id_table) |
1473 | { |
1474 | int rc; |
1475 | struct usb_driver *udriver; |
1476 | struct usb_serial_driver * const *sd; |
1477 | |
1478 | /* |
1479 | * udriver must be registered before any of the serial drivers, |
1480 | * because the store_new_id() routine for the serial drivers (in |
1481 | * bus.c) probes udriver. |
1482 | * |
1483 | * Performance hack: We don't want udriver to be probed until |
1484 | * the serial drivers are registered, because the probe would |
1485 | * simply fail for lack of a matching serial driver. |
1486 | * So we leave udriver's id_table set to NULL until we are all set. |
1487 | * |
1488 | * Suspend/resume support is implemented in the usb-serial core, |
1489 | * so fill in the PM-related fields in udriver. |
1490 | */ |
1491 | udriver = kzalloc(size: sizeof(*udriver), GFP_KERNEL); |
1492 | if (!udriver) |
1493 | return -ENOMEM; |
1494 | |
1495 | udriver->name = name; |
1496 | udriver->no_dynamic_id = 1; |
1497 | udriver->supports_autosuspend = 1; |
1498 | udriver->suspend = usb_serial_suspend; |
1499 | udriver->resume = usb_serial_resume; |
1500 | udriver->probe = usb_serial_probe; |
1501 | udriver->disconnect = usb_serial_disconnect; |
1502 | |
1503 | /* we only set the reset_resume field if the serial_driver has one */ |
1504 | for (sd = serial_drivers; *sd; ++sd) { |
1505 | if ((*sd)->reset_resume) { |
1506 | udriver->reset_resume = usb_serial_reset_resume; |
1507 | break; |
1508 | } |
1509 | } |
1510 | |
1511 | rc = usb_register(udriver); |
1512 | if (rc) |
1513 | goto err_free_driver; |
1514 | |
1515 | for (sd = serial_drivers; *sd; ++sd) { |
1516 | (*sd)->usb_driver = udriver; |
1517 | rc = usb_serial_register(driver: *sd); |
1518 | if (rc) |
1519 | goto err_deregister_drivers; |
1520 | } |
1521 | |
1522 | /* Now set udriver's id_table and look for matches */ |
1523 | udriver->id_table = id_table; |
1524 | rc = driver_attach(drv: &udriver->driver); |
1525 | return 0; |
1526 | |
1527 | err_deregister_drivers: |
1528 | while (sd-- > serial_drivers) |
1529 | usb_serial_deregister(device: *sd); |
1530 | usb_deregister(udriver); |
1531 | err_free_driver: |
1532 | kfree(objp: udriver); |
1533 | return rc; |
1534 | } |
1535 | EXPORT_SYMBOL_GPL(usb_serial_register_drivers); |
1536 | |
1537 | /** |
1538 | * usb_serial_deregister_drivers - deregister drivers for a usb-serial module |
1539 | * @serial_drivers: NULL-terminated array of pointers to drivers to be deregistered |
1540 | * |
1541 | * Deregisters all the drivers in the @serial_drivers array and deregisters and |
1542 | * frees the struct usb_driver that was created by the call to |
1543 | * usb_serial_register_drivers(). |
1544 | */ |
1545 | void usb_serial_deregister_drivers(struct usb_serial_driver *const serial_drivers[]) |
1546 | { |
1547 | struct usb_driver *udriver = (*serial_drivers)->usb_driver; |
1548 | |
1549 | for (; *serial_drivers; ++serial_drivers) |
1550 | usb_serial_deregister(device: *serial_drivers); |
1551 | usb_deregister(udriver); |
1552 | kfree(objp: udriver); |
1553 | } |
1554 | EXPORT_SYMBOL_GPL(usb_serial_deregister_drivers); |
1555 | |
1556 | MODULE_AUTHOR(DRIVER_AUTHOR); |
1557 | MODULE_DESCRIPTION(DRIVER_DESC); |
1558 | MODULE_LICENSE("GPL v2" ); |
1559 | |