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