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