]> git.proxmox.com Git - mirror_ubuntu-bionic-kernel.git/blob - drivers/usb/serial/usb-serial.c
projects / mirror_ubuntu-bionic-kernel.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Pull c2 into release branch
[mirror_ubuntu-bionic-kernel.git] / drivers / usb / serial / usb-serial.c
1 /*
2 * USB Serial Converter driver
3 *
4 * Copyright (C) 1999 - 2005 Greg Kroah-Hartman (greg@kroah.com)
5 * Copyright (C) 2000 Peter Berger (pberger@brimson.com)
6 * Copyright (C) 2000 Al Borchers (borchers@steinerpoint.com)
7 *
8 * This program is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU General Public License version
10 * 2 as published by the Free Software Foundation.
11 *
12 * This driver was originally based on the ACM driver by Armin Fuerst (which was
13 * based on a driver by Brad Keryan)
14 *
15 * See Documentation/usb/usb-serial.txt for more information on using this driver
16 *
17 */
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/spinlock.h>
29 #include <linux/mutex.h>
30 #include <linux/list.h>
31 #include <linux/smp_lock.h>
32 #include <asm/uaccess.h>
33 #include <linux/usb.h>
34 #include <linux/usb/serial.h>
35 #include "pl2303.h"
36
37 /*
38 * Version Information
39 */
40 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux/"
41 #define DRIVER_DESC "USB Serial Driver core"
42
43 static void port_free(struct usb_serial_port *port);
44
45 /* Driver structure we register with the USB core */
46 static struct usb_driver usb_serial_driver = {
47 .name = "usbserial",
48 .probe = usb_serial_probe,
49 .disconnect = usb_serial_disconnect,
50 .no_dynamic_id = 1,
51 };
52
53 /* There is no MODULE_DEVICE_TABLE for usbserial.c. Instead
54 the MODULE_DEVICE_TABLE declarations in each serial driver
55 cause the "hotplug" program to pull in whatever module is necessary
56 via modprobe, and modprobe will load usbserial because the serial
57 drivers depend on it.
58 */
59
60 static int debug;
61 static struct usb_serial *serial_table[SERIAL_TTY_MINORS]; /* initially all NULL */
62 static spinlock_t table_lock;
63 static LIST_HEAD(usb_serial_driver_list);
64
65 struct usb_serial *usb_serial_get_by_index(unsigned index)
66 {
67 struct usb_serial *serial;
68
69 spin_lock(&table_lock);
70 serial = serial_table[index];
71
72 if (serial)
73 kref_get(&serial->kref);
74 spin_unlock(&table_lock);
75 return serial;
76 }
77
78 static struct usb_serial *get_free_serial (struct usb_serial *serial, int num_ports, unsigned int *minor)
79 {
80 unsigned int i, j;
81 int good_spot;
82
83 dbg("%s %d", __FUNCTION__, num_ports);
84
85 *minor = 0;
86 spin_lock(&table_lock);
87 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
88 if (serial_table[i])
89 continue;
90
91 good_spot = 1;
92 for (j = 1; j <= num_ports-1; ++j)
93 if ((i+j >= SERIAL_TTY_MINORS) || (serial_table[i+j])) {
94 good_spot = 0;
95 i += j;
96 break;
97 }
98 if (good_spot == 0)
99 continue;
100
101 *minor = i;
102 j = 0;
103 dbg("%s - minor base = %d", __FUNCTION__, *minor);
104 for (i = *minor; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i) {
105 serial_table[i] = serial;
106 serial->port[j++]->number = i;
107 }
108 spin_unlock(&table_lock);
109 return serial;
110 }
111 spin_unlock(&table_lock);
112 return NULL;
113 }
114
115 static void return_serial(struct usb_serial *serial)
116 {
117 int i;
118
119 dbg("%s", __FUNCTION__);
120
121 if (serial == NULL)
122 return;
123
124 spin_lock(&table_lock);
125 for (i = 0; i < serial->num_ports; ++i) {
126 serial_table[serial->minor + i] = NULL;
127 }
128 spin_unlock(&table_lock);
129 }
130
131 static void destroy_serial(struct kref *kref)
132 {
133 struct usb_serial *serial;
134 struct usb_serial_port *port;
135 int i;
136
137 serial = to_usb_serial(kref);
138
139 dbg("%s - %s", __FUNCTION__, serial->type->description);
140
141 serial->type->shutdown(serial);
142
143 /* return the minor range that this device had */
144 return_serial(serial);
145
146 for (i = 0; i < serial->num_ports; ++i)
147 serial->port[i]->open_count = 0;
148
149 /* the ports are cleaned up and released in port_release() */
150 for (i = 0; i < serial->num_ports; ++i)
151 if (serial->port[i]->dev.parent != NULL) {
152 device_unregister(&serial->port[i]->dev);
153 serial->port[i] = NULL;
154 }
155
156 /* If this is a "fake" port, we have to clean it up here, as it will
157 * not get cleaned up in port_release() as it was never registered with
158 * the driver core */
159 if (serial->num_ports < serial->num_port_pointers) {
160 for (i = serial->num_ports; i < serial->num_port_pointers; ++i) {
161 port = serial->port[i];
162 if (!port)
163 continue;
164 port_free(port);
165 }
166 }
167
168 usb_put_dev(serial->dev);
169
170 /* free up any memory that we allocated */
171 kfree (serial);
172 }
173
174 void usb_serial_put(struct usb_serial *serial)
175 {
176 kref_put(&serial->kref, destroy_serial);
177 }
178
179 /*****************************************************************************
180 * Driver tty interface functions
181 *****************************************************************************/
182 static int serial_open (struct tty_struct *tty, struct file * filp)
183 {
184 struct usb_serial *serial;
185 struct usb_serial_port *port;
186 unsigned int portNumber;
187 int retval;
188
189 dbg("%s", __FUNCTION__);
190
191 /* get the serial object associated with this tty pointer */
192 serial = usb_serial_get_by_index(tty->index);
193 if (!serial) {
194 tty->driver_data = NULL;
195 return -ENODEV;
196 }
197
198 portNumber = tty->index - serial->minor;
199 port = serial->port[portNumber];
200 if (!port) {
201 retval = -ENODEV;
202 goto bailout_kref_put;
203 }
204
205 if (mutex_lock_interruptible(&port->mutex)) {
206 retval = -ERESTARTSYS;
207 goto bailout_kref_put;
208 }
209
210 ++port->open_count;
211
212 /* set up our port structure making the tty driver
213 * remember our port object, and us it */
214 tty->driver_data = port;
215 port->tty = tty;
216
217 if (port->open_count == 1) {
218
219 /* lock this module before we call it
220 * this may fail, which means we must bail out,
221 * safe because we are called with BKL held */
222 if (!try_module_get(serial->type->driver.owner)) {
223 retval = -ENODEV;
224 goto bailout_mutex_unlock;
225 }
226
227 /* only call the device specific open if this
228 * is the first time the port is opened */
229 retval = serial->type->open(port, filp);
230 if (retval)
231 goto bailout_module_put;
232 }
233
234 mutex_unlock(&port->mutex);
235 return 0;
236
237 bailout_module_put:
238 module_put(serial->type->driver.owner);
239 bailout_mutex_unlock:
240 port->open_count = 0;
241 tty->driver_data = NULL;
242 port->tty = NULL;
243 mutex_unlock(&port->mutex);
244 bailout_kref_put:
245 usb_serial_put(serial);
246 return retval;
247 }
248
249 static void serial_close(struct tty_struct *tty, struct file * filp)
250 {
251 struct usb_serial_port *port = tty->driver_data;
252
253 if (!port)
254 return;
255
256 dbg("%s - port %d", __FUNCTION__, port->number);
257
258 mutex_lock(&port->mutex);
259
260 if (port->open_count == 0) {
261 mutex_unlock(&port->mutex);
262 return;
263 }
264
265 --port->open_count;
266 if (port->open_count == 0) {
267 /* only call the device specific close if this
268 * port is being closed by the last owner */
269 port->serial->type->close(port, filp);
270
271 if (port->tty) {
272 if (port->tty->driver_data)
273 port->tty->driver_data = NULL;
274 port->tty = NULL;
275 }
276
277 module_put(port->serial->type->driver.owner);
278 }
279
280 mutex_unlock(&port->mutex);
281 usb_serial_put(port->serial);
282 }
283
284 static int serial_write (struct tty_struct * tty, const unsigned char *buf, int count)
285 {
286 struct usb_serial_port *port = tty->driver_data;
287 int retval = -ENODEV;
288
289 if (!port || port->serial->dev->state == USB_STATE_NOTATTACHED)
290 goto exit;
291
292 dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
293
294 if (!port->open_count) {
295 retval = -EINVAL;
296 dbg("%s - port not opened", __FUNCTION__);
297 goto exit;
298 }
299
300 /* pass on to the driver specific version of this function */
301 retval = port->serial->type->write(port, buf, count);
302
303 exit:
304 return retval;
305 }
306
307 static int serial_write_room (struct tty_struct *tty)
308 {
309 struct usb_serial_port *port = tty->driver_data;
310 int retval = -ENODEV;
311
312 if (!port)
313 goto exit;
314
315 dbg("%s - port %d", __FUNCTION__, port->number);
316
317 if (!port->open_count) {
318 dbg("%s - port not open", __FUNCTION__);
319 goto exit;
320 }
321
322 /* pass on to the driver specific version of this function */
323 retval = port->serial->type->write_room(port);
324
325 exit:
326 return retval;
327 }
328
329 static int serial_chars_in_buffer (struct tty_struct *tty)
330 {
331 struct usb_serial_port *port = tty->driver_data;
332 int retval = -ENODEV;
333
334 if (!port)
335 goto exit;
336
337 dbg("%s = port %d", __FUNCTION__, port->number);
338
339 if (!port->open_count) {
340 dbg("%s - port not open", __FUNCTION__);
341 goto exit;
342 }
343
344 /* pass on to the driver specific version of this function */
345 retval = port->serial->type->chars_in_buffer(port);
346
347 exit:
348 return retval;
349 }
350
351 static void serial_throttle (struct tty_struct * tty)
352 {
353 struct usb_serial_port *port = tty->driver_data;
354
355 if (!port)
356 return;
357
358 dbg("%s - port %d", __FUNCTION__, port->number);
359
360 if (!port->open_count) {
361 dbg ("%s - port not open", __FUNCTION__);
362 return;
363 }
364
365 /* pass on to the driver specific version of this function */
366 if (port->serial->type->throttle)
367 port->serial->type->throttle(port);
368 }
369
370 static void serial_unthrottle (struct tty_struct * tty)
371 {
372 struct usb_serial_port *port = tty->driver_data;
373
374 if (!port)
375 return;
376
377 dbg("%s - port %d", __FUNCTION__, port->number);
378
379 if (!port->open_count) {
380 dbg("%s - port not open", __FUNCTION__);
381 return;
382 }
383
384 /* pass on to the driver specific version of this function */
385 if (port->serial->type->unthrottle)
386 port->serial->type->unthrottle(port);
387 }
388
389 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
390 {
391 struct usb_serial_port *port = tty->driver_data;
392 int retval = -ENODEV;
393
394 if (!port)
395 goto exit;
396
397 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
398
399 if (!port->open_count) {
400 dbg ("%s - port not open", __FUNCTION__);
401 goto exit;
402 }
403
404 /* pass on to the driver specific version of this function if it is available */
405 if (port->serial->type->ioctl)
406 retval = port->serial->type->ioctl(port, file, cmd, arg);
407 else
408 retval = -ENOIOCTLCMD;
409
410 exit:
411 return retval;
412 }
413
414 static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
415 {
416 struct usb_serial_port *port = tty->driver_data;
417
418 if (!port)
419 return;
420
421 dbg("%s - port %d", __FUNCTION__, port->number);
422
423 if (!port->open_count) {
424 dbg("%s - port not open", __FUNCTION__);
425 return;
426 }
427
428 /* pass on to the driver specific version of this function if it is available */
429 if (port->serial->type->set_termios)
430 port->serial->type->set_termios(port, old);
431 }
432
433 static void serial_break (struct tty_struct *tty, int break_state)
434 {
435 struct usb_serial_port *port = tty->driver_data;
436
437 if (!port)
438 return;
439
440 dbg("%s - port %d", __FUNCTION__, port->number);
441
442 if (!port->open_count) {
443 dbg("%s - port not open", __FUNCTION__);
444 return;
445 }
446
447 /* pass on to the driver specific version of this function if it is available */
448 if (port->serial->type->break_ctl)
449 port->serial->type->break_ctl(port, break_state);
450 }
451
452 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
453 {
454 struct usb_serial *serial;
455 int length = 0;
456 int i;
457 off_t begin = 0;
458 char tmp[40];
459
460 dbg("%s", __FUNCTION__);
461 length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
462 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
463 serial = usb_serial_get_by_index(i);
464 if (serial == NULL)
465 continue;
466
467 length += sprintf (page+length, "%d:", i);
468 if (serial->type->driver.owner)
469 length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
470 length += sprintf (page+length, " name:\"%s\"", serial->type->description);
471 length += sprintf (page+length, " vendor:%04x product:%04x",
472 le16_to_cpu(serial->dev->descriptor.idVendor),
473 le16_to_cpu(serial->dev->descriptor.idProduct));
474 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
475 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
476
477 usb_make_path(serial->dev, tmp, sizeof(tmp));
478 length += sprintf (page+length, " path:%s", tmp);
479
480 length += sprintf (page+length, "\n");
481 if ((length + begin) > (off + count)) {
482 usb_serial_put(serial);
483 goto done;
484 }
485 if ((length + begin) < off) {
486 begin += length;
487 length = 0;
488 }
489 usb_serial_put(serial);
490 }
491 *eof = 1;
492 done:
493 if (off >= (length + begin))
494 return 0;
495 *start = page + (off-begin);
496 return ((count < begin+length-off) ? count : begin+length-off);
497 }
498
499 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
500 {
501 struct usb_serial_port *port = tty->driver_data;
502
503 if (!port)
504 return -ENODEV;
505
506 dbg("%s - port %d", __FUNCTION__, port->number);
507
508 if (!port->open_count) {
509 dbg("%s - port not open", __FUNCTION__);
510 return -ENODEV;
511 }
512
513 if (port->serial->type->tiocmget)
514 return port->serial->type->tiocmget(port, file);
515
516 return -EINVAL;
517 }
518
519 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
520 unsigned int set, unsigned int clear)
521 {
522 struct usb_serial_port *port = tty->driver_data;
523
524 if (!port)
525 return -ENODEV;
526
527 dbg("%s - port %d", __FUNCTION__, port->number);
528
529 if (!port->open_count) {
530 dbg("%s - port not open", __FUNCTION__);
531 return -ENODEV;
532 }
533
534 if (port->serial->type->tiocmset)
535 return port->serial->type->tiocmset(port, file, set, clear);
536
537 return -EINVAL;
538 }
539
540 /*
541 * We would be calling tty_wakeup here, but unfortunately some line
542 * disciplines have an annoying habit of calling tty->write from
543 * the write wakeup callback (e.g. n_hdlc.c).
544 */
545 void usb_serial_port_softint(struct usb_serial_port *port)
546 {
547 schedule_work(&port->work);
548 }
549
550 static void usb_serial_port_work(struct work_struct *work)
551 {
552 struct usb_serial_port *port =
553 container_of(work, struct usb_serial_port, work);
554 struct tty_struct *tty;
555
556 dbg("%s - port %d", __FUNCTION__, port->number);
557
558 if (!port)
559 return;
560
561 tty = port->tty;
562 if (!tty)
563 return;
564
565 tty_wakeup(tty);
566 }
567
568 static void port_release(struct device *dev)
569 {
570 struct usb_serial_port *port = to_usb_serial_port(dev);
571
572 dbg ("%s - %s", __FUNCTION__, dev->bus_id);
573 port_free(port);
574 }
575
576 static void kill_traffic(struct usb_serial_port *port)
577 {
578 usb_kill_urb(port->read_urb);
579 usb_kill_urb(port->write_urb);
580 usb_kill_urb(port->interrupt_in_urb);
581 usb_kill_urb(port->interrupt_out_urb);
582 }
583
584 static void port_free(struct usb_serial_port *port)
585 {
586 kill_traffic(port);
587 usb_free_urb(port->read_urb);
588 usb_free_urb(port->write_urb);
589 usb_free_urb(port->interrupt_in_urb);
590 usb_free_urb(port->interrupt_out_urb);
591 kfree(port->bulk_in_buffer);
592 kfree(port->bulk_out_buffer);
593 kfree(port->interrupt_in_buffer);
594 kfree(port->interrupt_out_buffer);
595 flush_scheduled_work(); /* port->work */
596 kfree(port);
597 }
598
599 static struct usb_serial * create_serial (struct usb_device *dev,
600 struct usb_interface *interface,
601 struct usb_serial_driver *driver)
602 {
603 struct usb_serial *serial;
604
605 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
606 if (!serial) {
607 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
608 return NULL;
609 }
610 serial->dev = usb_get_dev(dev);
611 serial->type = driver;
612 serial->interface = interface;
613 kref_init(&serial->kref);
614
615 return serial;
616 }
617
618 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
619 struct usb_serial_driver *drv)
620 {
621 struct usb_dynid *dynid;
622
623 spin_lock(&drv->dynids.lock);
624 list_for_each_entry(dynid, &drv->dynids.list, node) {
625 if (usb_match_one_id(intf, &dynid->id)) {
626 spin_unlock(&drv->dynids.lock);
627 return &dynid->id;
628 }
629 }
630 spin_unlock(&drv->dynids.lock);
631 return NULL;
632 }
633
634 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
635 struct usb_interface *intf)
636 {
637 const struct usb_device_id *id;
638
639 id = usb_match_id(intf, drv->id_table);
640 if (id) {
641 dbg("static descriptor matches");
642 goto exit;
643 }
644 id = match_dynamic_id(intf, drv);
645 if (id)
646 dbg("dynamic descriptor matches");
647 exit:
648 return id;
649 }
650
651 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
652 {
653 struct list_head *p;
654 const struct usb_device_id *id;
655 struct usb_serial_driver *t;
656
657 /* Check if the usb id matches a known device */
658 list_for_each(p, &usb_serial_driver_list) {
659 t = list_entry(p, struct usb_serial_driver, driver_list);
660 id = get_iface_id(t, iface);
661 if (id)
662 return t;
663 }
664
665 return NULL;
666 }
667
668 int usb_serial_probe(struct usb_interface *interface,
669 const struct usb_device_id *id)
670 {
671 struct usb_device *dev = interface_to_usbdev (interface);
672 struct usb_serial *serial = NULL;
673 struct usb_serial_port *port;
674 struct usb_host_interface *iface_desc;
675 struct usb_endpoint_descriptor *endpoint;
676 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
677 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
678 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
679 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
680 struct usb_serial_driver *type = NULL;
681 int retval;
682 int minor;
683 int buffer_size;
684 int i;
685 int num_interrupt_in = 0;
686 int num_interrupt_out = 0;
687 int num_bulk_in = 0;
688 int num_bulk_out = 0;
689 int num_ports = 0;
690 int max_endpoints;
691
692 lock_kernel(); /* guard against unloading a serial driver module */
693 type = search_serial_device(interface);
694 if (!type) {
695 unlock_kernel();
696 dbg("none matched");
697 return -ENODEV;
698 }
699
700 serial = create_serial (dev, interface, type);
701 if (!serial) {
702 unlock_kernel();
703 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
704 return -ENOMEM;
705 }
706
707 /* if this device type has a probe function, call it */
708 if (type->probe) {
709 const struct usb_device_id *id;
710
711 if (!try_module_get(type->driver.owner)) {
712 unlock_kernel();
713 dev_err(&interface->dev, "module get failed, exiting\n");
714 kfree (serial);
715 return -EIO;
716 }
717
718 id = get_iface_id(type, interface);
719 retval = type->probe(serial, id);
720 module_put(type->driver.owner);
721
722 if (retval) {
723 unlock_kernel();
724 dbg ("sub driver rejected device");
725 kfree (serial);
726 return retval;
727 }
728 }
729
730 /* descriptor matches, let's find the endpoints needed */
731 /* check out the endpoints */
732 iface_desc = interface->cur_altsetting;
733 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
734 endpoint = &iface_desc->endpoint[i].desc;
735
736 if (usb_endpoint_is_bulk_in(endpoint)) {
737 /* we found a bulk in endpoint */
738 dbg("found bulk in on endpoint %d", i);
739 bulk_in_endpoint[num_bulk_in] = endpoint;
740 ++num_bulk_in;
741 }
742
743 if (usb_endpoint_is_bulk_out(endpoint)) {
744 /* we found a bulk out endpoint */
745 dbg("found bulk out on endpoint %d", i);
746 bulk_out_endpoint[num_bulk_out] = endpoint;
747 ++num_bulk_out;
748 }
749
750 if (usb_endpoint_is_int_in(endpoint)) {
751 /* we found a interrupt in endpoint */
752 dbg("found interrupt in on endpoint %d", i);
753 interrupt_in_endpoint[num_interrupt_in] = endpoint;
754 ++num_interrupt_in;
755 }
756
757 if (usb_endpoint_is_int_out(endpoint)) {
758 /* we found an interrupt out endpoint */
759 dbg("found interrupt out on endpoint %d", i);
760 interrupt_out_endpoint[num_interrupt_out] = endpoint;
761 ++num_interrupt_out;
762 }
763 }
764
765 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
766 /* BEGIN HORRIBLE HACK FOR PL2303 */
767 /* this is needed due to the looney way its endpoints are set up */
768 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
769 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
770 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
771 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
772 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
773 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
774 if (interface != dev->actconfig->interface[0]) {
775 /* check out the endpoints of the other interface*/
776 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
777 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
778 endpoint = &iface_desc->endpoint[i].desc;
779 if (usb_endpoint_is_int_in(endpoint)) {
780 /* we found a interrupt in endpoint */
781 dbg("found interrupt in for Prolific device on separate interface");
782 interrupt_in_endpoint[num_interrupt_in] = endpoint;
783 ++num_interrupt_in;
784 }
785 }
786 }
787
788 /* Now make sure the PL-2303 is configured correctly.
789 * If not, give up now and hope this hack will work
790 * properly during a later invocation of usb_serial_probe
791 */
792 if (num_bulk_in == 0 || num_bulk_out == 0) {
793 unlock_kernel();
794 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
795 kfree (serial);
796 return -ENODEV;
797 }
798 }
799 /* END HORRIBLE HACK FOR PL2303 */
800 #endif
801
802 /* found all that we need */
803 dev_info(&interface->dev, "%s converter detected\n", type->description);
804
805 #ifdef CONFIG_USB_SERIAL_GENERIC
806 if (type == &usb_serial_generic_device) {
807 num_ports = num_bulk_out;
808 if (num_ports == 0) {
809 unlock_kernel();
810 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
811 kfree (serial);
812 return -EIO;
813 }
814 }
815 #endif
816 if (!num_ports) {
817 /* if this device type has a calc_num_ports function, call it */
818 if (type->calc_num_ports) {
819 if (!try_module_get(type->driver.owner)) {
820 unlock_kernel();
821 dev_err(&interface->dev, "module get failed, exiting\n");
822 kfree (serial);
823 return -EIO;
824 }
825 num_ports = type->calc_num_ports (serial);
826 module_put(type->driver.owner);
827 }
828 if (!num_ports)
829 num_ports = type->num_ports;
830 }
831
832 serial->num_ports = num_ports;
833 serial->num_bulk_in = num_bulk_in;
834 serial->num_bulk_out = num_bulk_out;
835 serial->num_interrupt_in = num_interrupt_in;
836 serial->num_interrupt_out = num_interrupt_out;
837
838 /* create our ports, we need as many as the max endpoints */
839 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
840 max_endpoints = max(num_bulk_in, num_bulk_out);
841 max_endpoints = max(max_endpoints, num_interrupt_in);
842 max_endpoints = max(max_endpoints, num_interrupt_out);
843 max_endpoints = max(max_endpoints, (int)serial->num_ports);
844 serial->num_port_pointers = max_endpoints;
845 unlock_kernel();
846
847 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
848 for (i = 0; i < max_endpoints; ++i) {
849 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
850 if (!port)
851 goto probe_error;
852 port->serial = serial;
853 spin_lock_init(&port->lock);
854 mutex_init(&port->mutex);
855 INIT_WORK(&port->work, usb_serial_port_work);
856 serial->port[i] = port;
857 }
858
859 /* set up the endpoint information */
860 for (i = 0; i < num_bulk_in; ++i) {
861 endpoint = bulk_in_endpoint[i];
862 port = serial->port[i];
863 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
864 if (!port->read_urb) {
865 dev_err(&interface->dev, "No free urbs available\n");
866 goto probe_error;
867 }
868 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
869 port->bulk_in_size = buffer_size;
870 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
871 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
872 if (!port->bulk_in_buffer) {
873 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
874 goto probe_error;
875 }
876 usb_fill_bulk_urb (port->read_urb, dev,
877 usb_rcvbulkpipe (dev,
878 endpoint->bEndpointAddress),
879 port->bulk_in_buffer, buffer_size,
880 serial->type->read_bulk_callback,
881 port);
882 }
883
884 for (i = 0; i < num_bulk_out; ++i) {
885 endpoint = bulk_out_endpoint[i];
886 port = serial->port[i];
887 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
888 if (!port->write_urb) {
889 dev_err(&interface->dev, "No free urbs available\n");
890 goto probe_error;
891 }
892 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
893 port->bulk_out_size = buffer_size;
894 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
895 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
896 if (!port->bulk_out_buffer) {
897 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
898 goto probe_error;
899 }
900 usb_fill_bulk_urb (port->write_urb, dev,
901 usb_sndbulkpipe (dev,
902 endpoint->bEndpointAddress),
903 port->bulk_out_buffer, buffer_size,
904 serial->type->write_bulk_callback,
905 port);
906 }
907
908 if (serial->type->read_int_callback) {
909 for (i = 0; i < num_interrupt_in; ++i) {
910 endpoint = interrupt_in_endpoint[i];
911 port = serial->port[i];
912 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
913 if (!port->interrupt_in_urb) {
914 dev_err(&interface->dev, "No free urbs available\n");
915 goto probe_error;
916 }
917 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
918 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
919 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
920 if (!port->interrupt_in_buffer) {
921 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
922 goto probe_error;
923 }
924 usb_fill_int_urb (port->interrupt_in_urb, dev,
925 usb_rcvintpipe (dev,
926 endpoint->bEndpointAddress),
927 port->interrupt_in_buffer, buffer_size,
928 serial->type->read_int_callback, port,
929 endpoint->bInterval);
930 }
931 } else if (num_interrupt_in) {
932 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
933 }
934
935 if (serial->type->write_int_callback) {
936 for (i = 0; i < num_interrupt_out; ++i) {
937 endpoint = interrupt_out_endpoint[i];
938 port = serial->port[i];
939 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
940 if (!port->interrupt_out_urb) {
941 dev_err(&interface->dev, "No free urbs available\n");
942 goto probe_error;
943 }
944 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
945 port->interrupt_out_size = buffer_size;
946 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
947 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
948 if (!port->interrupt_out_buffer) {
949 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
950 goto probe_error;
951 }
952 usb_fill_int_urb (port->interrupt_out_urb, dev,
953 usb_sndintpipe (dev,
954 endpoint->bEndpointAddress),
955 port->interrupt_out_buffer, buffer_size,
956 serial->type->write_int_callback, port,
957 endpoint->bInterval);
958 }
959 } else if (num_interrupt_out) {
960 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
961 }
962
963 /* if this device type has an attach function, call it */
964 if (type->attach) {
965 if (!try_module_get(type->driver.owner)) {
966 dev_err(&interface->dev, "module get failed, exiting\n");
967 goto probe_error;
968 }
969 retval = type->attach (serial);
970 module_put(type->driver.owner);
971 if (retval < 0)
972 goto probe_error;
973 if (retval > 0) {
974 /* quietly accept this device, but don't bind to a serial port
975 * as it's about to disappear */
976 goto exit;
977 }
978 }
979
980 if (get_free_serial (serial, num_ports, &minor) == NULL) {
981 dev_err(&interface->dev, "No more free serial devices\n");
982 goto probe_error;
983 }
984 serial->minor = minor;
985
986 /* register all of the individual ports with the driver core */
987 for (i = 0; i < num_ports; ++i) {
988 port = serial->port[i];
989 port->dev.parent = &interface->dev;
990 port->dev.driver = NULL;
991 port->dev.bus = &usb_serial_bus_type;
992 port->dev.release = &port_release;
993
994 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
995 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
996 retval = device_register(&port->dev);
997 if (retval)
998 dev_err(&port->dev, "Error registering port device, "
999 "continuing\n");
1000 }
1001
1002 usb_serial_console_init (debug, minor);
1003
1004 exit:
1005 /* success */
1006 usb_set_intfdata (interface, serial);
1007 return 0;
1008
1009 probe_error:
1010 for (i = 0; i < num_bulk_in; ++i) {
1011 port = serial->port[i];
1012 if (!port)
1013 continue;
1014 usb_free_urb(port->read_urb);
1015 kfree(port->bulk_in_buffer);
1016 }
1017 for (i = 0; i < num_bulk_out; ++i) {
1018 port = serial->port[i];
1019 if (!port)
1020 continue;
1021 usb_free_urb(port->write_urb);
1022 kfree(port->bulk_out_buffer);
1023 }
1024 for (i = 0; i < num_interrupt_in; ++i) {
1025 port = serial->port[i];
1026 if (!port)
1027 continue;
1028 usb_free_urb(port->interrupt_in_urb);
1029 kfree(port->interrupt_in_buffer);
1030 }
1031 for (i = 0; i < num_interrupt_out; ++i) {
1032 port = serial->port[i];
1033 if (!port)
1034 continue;
1035 usb_free_urb(port->interrupt_out_urb);
1036 kfree(port->interrupt_out_buffer);
1037 }
1038
1039 /* free up any memory that we allocated */
1040 for (i = 0; i < serial->num_port_pointers; ++i)
1041 kfree(serial->port[i]);
1042 kfree (serial);
1043 return -EIO;
1044 }
1045
1046 void usb_serial_disconnect(struct usb_interface *interface)
1047 {
1048 int i;
1049 struct usb_serial *serial = usb_get_intfdata (interface);
1050 struct device *dev = &interface->dev;
1051 struct usb_serial_port *port;
1052
1053 usb_serial_console_disconnect(serial);
1054 dbg ("%s", __FUNCTION__);
1055
1056 usb_set_intfdata (interface, NULL);
1057 if (serial) {
1058 for (i = 0; i < serial->num_ports; ++i) {
1059 port = serial->port[i];
1060 if (port) {
1061 if (port->tty)
1062 tty_hangup(port->tty);
1063 kill_traffic(port);
1064 }
1065 }
1066 /* let the last holder of this object
1067 * cause it to be cleaned up */
1068 usb_serial_put(serial);
1069 }
1070 dev_info(dev, "device disconnected\n");
1071 }
1072
1073 static const struct tty_operations serial_ops = {
1074 .open = serial_open,
1075 .close = serial_close,
1076 .write = serial_write,
1077 .write_room = serial_write_room,
1078 .ioctl = serial_ioctl,
1079 .set_termios = serial_set_termios,
1080 .throttle = serial_throttle,
1081 .unthrottle = serial_unthrottle,
1082 .break_ctl = serial_break,
1083 .chars_in_buffer = serial_chars_in_buffer,
1084 .read_proc = serial_read_proc,
1085 .tiocmget = serial_tiocmget,
1086 .tiocmset = serial_tiocmset,
1087 };
1088
1089 struct tty_driver *usb_serial_tty_driver;
1090
1091 static int __init usb_serial_init(void)
1092 {
1093 int i;
1094 int result;
1095
1096 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1097 if (!usb_serial_tty_driver)
1098 return -ENOMEM;
1099
1100 /* Initialize our global data */
1101 spin_lock_init(&table_lock);
1102 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1103 serial_table[i] = NULL;
1104 }
1105
1106 result = bus_register(&usb_serial_bus_type);
1107 if (result) {
1108 err("%s - registering bus driver failed", __FUNCTION__);
1109 goto exit_bus;
1110 }
1111
1112 usb_serial_tty_driver->owner = THIS_MODULE;
1113 usb_serial_tty_driver->driver_name = "usbserial";
1114 usb_serial_tty_driver->name = "ttyUSB";
1115 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1116 usb_serial_tty_driver->minor_start = 0;
1117 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1118 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1119 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1120 usb_serial_tty_driver->init_termios = tty_std_termios;
1121 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1122 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1123 result = tty_register_driver(usb_serial_tty_driver);
1124 if (result) {
1125 err("%s - tty_register_driver failed", __FUNCTION__);
1126 goto exit_reg_driver;
1127 }
1128
1129 /* register the USB driver */
1130 result = usb_register(&usb_serial_driver);
1131 if (result < 0) {
1132 err("%s - usb_register failed", __FUNCTION__);
1133 goto exit_tty;
1134 }
1135
1136 /* register the generic driver, if we should */
1137 result = usb_serial_generic_register(debug);
1138 if (result < 0) {
1139 err("%s - registering generic driver failed", __FUNCTION__);
1140 goto exit_generic;
1141 }
1142
1143 info(DRIVER_DESC);
1144
1145 return result;
1146
1147 exit_generic:
1148 usb_deregister(&usb_serial_driver);
1149
1150 exit_tty:
1151 tty_unregister_driver(usb_serial_tty_driver);
1152
1153 exit_reg_driver:
1154 bus_unregister(&usb_serial_bus_type);
1155
1156 exit_bus:
1157 err ("%s - returning with error %d", __FUNCTION__, result);
1158 put_tty_driver(usb_serial_tty_driver);
1159 return result;
1160 }
1161
1162
1163 static void __exit usb_serial_exit(void)
1164 {
1165 usb_serial_console_exit();
1166
1167 usb_serial_generic_deregister();
1168
1169 usb_deregister(&usb_serial_driver);
1170 tty_unregister_driver(usb_serial_tty_driver);
1171 put_tty_driver(usb_serial_tty_driver);
1172 bus_unregister(&usb_serial_bus_type);
1173 }
1174
1175
1176 module_init(usb_serial_init);
1177 module_exit(usb_serial_exit);
1178
1179 #define set_to_generic_if_null(type, function) \
1180 do { \
1181 if (!type->function) { \
1182 type->function = usb_serial_generic_##function; \
1183 dbg("Had to override the " #function \
1184 " usb serial operation with the generic one.");\
1185 } \
1186 } while (0)
1187
1188 static void fixup_generic(struct usb_serial_driver *device)
1189 {
1190 set_to_generic_if_null(device, open);
1191 set_to_generic_if_null(device, write);
1192 set_to_generic_if_null(device, close);
1193 set_to_generic_if_null(device, write_room);
1194 set_to_generic_if_null(device, chars_in_buffer);
1195 set_to_generic_if_null(device, read_bulk_callback);
1196 set_to_generic_if_null(device, write_bulk_callback);
1197 set_to_generic_if_null(device, shutdown);
1198 }
1199
1200 int usb_serial_register(struct usb_serial_driver *driver) /* must be called with BKL held */
1201 {
1202 int retval;
1203
1204 fixup_generic(driver);
1205
1206 if (!driver->description)
1207 driver->description = driver->driver.name;
1208
1209 /* Add this device to our list of devices */
1210 list_add(&driver->driver_list, &usb_serial_driver_list);
1211
1212 retval = usb_serial_bus_register(driver);
1213 if (retval) {
1214 err("problem %d when registering driver %s", retval, driver->description);
1215 list_del(&driver->driver_list);
1216 }
1217 else
1218 info("USB Serial support registered for %s", driver->description);
1219
1220 return retval;
1221 }
1222
1223
1224 void usb_serial_deregister(struct usb_serial_driver *device) /* must be called with BKL held */
1225 {
1226 info("USB Serial deregistering driver %s", device->description);
1227 list_del(&device->driver_list);
1228 usb_serial_bus_deregister(device);
1229 }
1230
1231
1232
1233 /* If the usb-serial core is built into the core, the usb-serial drivers
1234 need these symbols to load properly as modules. */
1235 EXPORT_SYMBOL_GPL(usb_serial_register);
1236 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1237 EXPORT_SYMBOL_GPL(usb_serial_probe);
1238 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1239 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1240
1241
1242 /* Module information */
1243 MODULE_AUTHOR( DRIVER_AUTHOR );
1244 MODULE_DESCRIPTION( DRIVER_DESC );
1245 MODULE_LICENSE("GPL");
1246
1247 module_param(debug, bool, S_IRUGO | S_IWUSR);
1248 MODULE_PARM_DESC(debug, "Debug enabled or not");
ubuntu-bionic-kernel mirror