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