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