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