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