projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge branch 'master' of git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[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", __FUNCTION__, 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", __FUNCTION__, *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", __FUNCTION__);
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", __FUNCTION__, 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", __FUNCTION__);
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", __FUNCTION__, 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)", __FUNCTION__, port->number, count);
303
304 if (!port->open_count) {
305 retval = -EINVAL;
306 dbg("%s - port not opened", __FUNCTION__);
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", __FUNCTION__, port->number);
326
327 if (!port->open_count) {
328 dbg("%s - port not open", __FUNCTION__);
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", __FUNCTION__, port->number);
348
349 if (!port->open_count) {
350 dbg("%s - port not open", __FUNCTION__);
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", __FUNCTION__, port->number);
369
370 if (!port->open_count) {
371 dbg ("%s - port not open", __FUNCTION__);
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", __FUNCTION__, port->number);
388
389 if (!port->open_count) {
390 dbg("%s - port not open", __FUNCTION__);
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 if (!port)
405 goto exit;
406
407 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__, port->number, cmd);
408
409 if (!port->open_count) {
410 dbg ("%s - port not open", __FUNCTION__);
411 goto exit;
412 }
413
414 /* pass on to the driver specific version of this function if it is available */
415 if (port->serial->type->ioctl)
416 retval = port->serial->type->ioctl(port, file, cmd, arg);
417 else
418 retval = -ENOIOCTLCMD;
419
420 exit:
421 return retval;
422 }
423
424 static void serial_set_termios (struct tty_struct *tty, struct ktermios * old)
425 {
426 struct usb_serial_port *port = tty->driver_data;
427
428 if (!port)
429 return;
430
431 dbg("%s - port %d", __FUNCTION__, port->number);
432
433 if (!port->open_count) {
434 dbg("%s - port not open", __FUNCTION__);
435 return;
436 }
437
438 /* pass on to the driver specific version of this function if it is available */
439 if (port->serial->type->set_termios)
440 port->serial->type->set_termios(port, old);
441 else
442 tty_termios_copy_hw(tty->termios, old);
443 }
444
445 static void serial_break (struct tty_struct *tty, int break_state)
446 {
447 struct usb_serial_port *port = tty->driver_data;
448
449 if (!port)
450 return;
451
452 dbg("%s - port %d", __FUNCTION__, port->number);
453
454 if (!port->open_count) {
455 dbg("%s - port not open", __FUNCTION__);
456 return;
457 }
458
459 /* pass on to the driver specific version of this function if it is available */
460 if (port->serial->type->break_ctl)
461 port->serial->type->break_ctl(port, break_state);
462 }
463
464 static int serial_read_proc (char *page, char **start, off_t off, int count, int *eof, void *data)
465 {
466 struct usb_serial *serial;
467 int length = 0;
468 int i;
469 off_t begin = 0;
470 char tmp[40];
471
472 dbg("%s", __FUNCTION__);
473 length += sprintf (page, "usbserinfo:1.0 driver:2.0\n");
474 for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
475 serial = usb_serial_get_by_index(i);
476 if (serial == NULL)
477 continue;
478
479 length += sprintf (page+length, "%d:", i);
480 if (serial->type->driver.owner)
481 length += sprintf (page+length, " module:%s", module_name(serial->type->driver.owner));
482 length += sprintf (page+length, " name:\"%s\"", serial->type->description);
483 length += sprintf (page+length, " vendor:%04x product:%04x",
484 le16_to_cpu(serial->dev->descriptor.idVendor),
485 le16_to_cpu(serial->dev->descriptor.idProduct));
486 length += sprintf (page+length, " num_ports:%d", serial->num_ports);
487 length += sprintf (page+length, " port:%d", i - serial->minor + 1);
488
489 usb_make_path(serial->dev, tmp, sizeof(tmp));
490 length += sprintf (page+length, " path:%s", tmp);
491
492 length += sprintf (page+length, "\n");
493 if ((length + begin) > (off + count)) {
494 usb_serial_put(serial);
495 goto done;
496 }
497 if ((length + begin) < off) {
498 begin += length;
499 length = 0;
500 }
501 usb_serial_put(serial);
502 }
503 *eof = 1;
504 done:
505 if (off >= (length + begin))
506 return 0;
507 *start = page + (off-begin);
508 return ((count < begin+length-off) ? count : begin+length-off);
509 }
510
511 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
512 {
513 struct usb_serial_port *port = tty->driver_data;
514
515 if (!port)
516 return -ENODEV;
517
518 dbg("%s - port %d", __FUNCTION__, port->number);
519
520 if (!port->open_count) {
521 dbg("%s - port not open", __FUNCTION__);
522 return -ENODEV;
523 }
524
525 if (port->serial->type->tiocmget)
526 return port->serial->type->tiocmget(port, file);
527
528 return -EINVAL;
529 }
530
531 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
532 unsigned int set, unsigned int clear)
533 {
534 struct usb_serial_port *port = tty->driver_data;
535
536 if (!port)
537 return -ENODEV;
538
539 dbg("%s - port %d", __FUNCTION__, port->number);
540
541 if (!port->open_count) {
542 dbg("%s - port not open", __FUNCTION__);
543 return -ENODEV;
544 }
545
546 if (port->serial->type->tiocmset)
547 return port->serial->type->tiocmset(port, file, set, clear);
548
549 return -EINVAL;
550 }
551
552 /*
553 * We would be calling tty_wakeup here, but unfortunately some line
554 * disciplines have an annoying habit of calling tty->write from
555 * the write wakeup callback (e.g. n_hdlc.c).
556 */
557 void usb_serial_port_softint(struct usb_serial_port *port)
558 {
559 schedule_work(&port->work);
560 }
561
562 static void usb_serial_port_work(struct work_struct *work)
563 {
564 struct usb_serial_port *port =
565 container_of(work, struct usb_serial_port, work);
566 struct tty_struct *tty;
567
568 dbg("%s - port %d", __FUNCTION__, port->number);
569
570 if (!port)
571 return;
572
573 tty = port->tty;
574 if (!tty)
575 return;
576
577 tty_wakeup(tty);
578 }
579
580 static void port_release(struct device *dev)
581 {
582 struct usb_serial_port *port = to_usb_serial_port(dev);
583
584 dbg ("%s - %s", __FUNCTION__, dev->bus_id);
585 port_free(port);
586 }
587
588 static void kill_traffic(struct usb_serial_port *port)
589 {
590 usb_kill_urb(port->read_urb);
591 usb_kill_urb(port->write_urb);
592 /*
593 * This is tricky.
594 * Some drivers submit the read_urb in the
595 * handler for the write_urb or vice versa
596 * this order determines the order in which
597 * usb_kill_urb() must be used to reliably
598 * kill the URBs. As it is unknown here,
599 * both orders must be used in turn.
600 * The call below is not redundant.
601 */
602 usb_kill_urb(port->read_urb);
603 usb_kill_urb(port->interrupt_in_urb);
604 usb_kill_urb(port->interrupt_out_urb);
605 }
606
607 static void port_free(struct usb_serial_port *port)
608 {
609 kill_traffic(port);
610 usb_free_urb(port->read_urb);
611 usb_free_urb(port->write_urb);
612 usb_free_urb(port->interrupt_in_urb);
613 usb_free_urb(port->interrupt_out_urb);
614 kfree(port->bulk_in_buffer);
615 kfree(port->bulk_out_buffer);
616 kfree(port->interrupt_in_buffer);
617 kfree(port->interrupt_out_buffer);
618 flush_scheduled_work(); /* port->work */
619 kfree(port);
620 }
621
622 static struct usb_serial * create_serial (struct usb_device *dev,
623 struct usb_interface *interface,
624 struct usb_serial_driver *driver)
625 {
626 struct usb_serial *serial;
627
628 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
629 if (!serial) {
630 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
631 return NULL;
632 }
633 serial->dev = usb_get_dev(dev);
634 serial->type = driver;
635 serial->interface = interface;
636 kref_init(&serial->kref);
637 mutex_init(&serial->disc_mutex);
638
639 return serial;
640 }
641
642 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
643 struct usb_serial_driver *drv)
644 {
645 struct usb_dynid *dynid;
646
647 spin_lock(&drv->dynids.lock);
648 list_for_each_entry(dynid, &drv->dynids.list, node) {
649 if (usb_match_one_id(intf, &dynid->id)) {
650 spin_unlock(&drv->dynids.lock);
651 return &dynid->id;
652 }
653 }
654 spin_unlock(&drv->dynids.lock);
655 return NULL;
656 }
657
658 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
659 struct usb_interface *intf)
660 {
661 const struct usb_device_id *id;
662
663 id = usb_match_id(intf, drv->id_table);
664 if (id) {
665 dbg("static descriptor matches");
666 goto exit;
667 }
668 id = match_dynamic_id(intf, drv);
669 if (id)
670 dbg("dynamic descriptor matches");
671 exit:
672 return id;
673 }
674
675 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
676 {
677 const struct usb_device_id *id;
678 struct usb_serial_driver *drv;
679
680 /* Check if the usb id matches a known device */
681 list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
682 id = get_iface_id(drv, iface);
683 if (id)
684 return drv;
685 }
686
687 return NULL;
688 }
689
690 int usb_serial_probe(struct usb_interface *interface,
691 const struct usb_device_id *id)
692 {
693 struct usb_device *dev = interface_to_usbdev (interface);
694 struct usb_serial *serial = NULL;
695 struct usb_serial_port *port;
696 struct usb_host_interface *iface_desc;
697 struct usb_endpoint_descriptor *endpoint;
698 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
699 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
700 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
701 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
702 struct usb_serial_driver *type = NULL;
703 int retval;
704 int minor;
705 int buffer_size;
706 int i;
707 int num_interrupt_in = 0;
708 int num_interrupt_out = 0;
709 int num_bulk_in = 0;
710 int num_bulk_out = 0;
711 int num_ports = 0;
712 int max_endpoints;
713
714 lock_kernel(); /* guard against unloading a serial driver module */
715 type = search_serial_device(interface);
716 if (!type) {
717 unlock_kernel();
718 dbg("none matched");
719 return -ENODEV;
720 }
721
722 serial = create_serial (dev, interface, type);
723 if (!serial) {
724 unlock_kernel();
725 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
726 return -ENOMEM;
727 }
728
729 /* if this device type has a probe function, call it */
730 if (type->probe) {
731 const struct usb_device_id *id;
732
733 if (!try_module_get(type->driver.owner)) {
734 unlock_kernel();
735 dev_err(&interface->dev, "module get failed, exiting\n");
736 kfree (serial);
737 return -EIO;
738 }
739
740 id = get_iface_id(type, interface);
741 retval = type->probe(serial, id);
742 module_put(type->driver.owner);
743
744 if (retval) {
745 unlock_kernel();
746 dbg ("sub driver rejected device");
747 kfree (serial);
748 return retval;
749 }
750 }
751
752 /* descriptor matches, let's find the endpoints needed */
753 /* check out the endpoints */
754 iface_desc = interface->cur_altsetting;
755 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
756 endpoint = &iface_desc->endpoint[i].desc;
757
758 if (usb_endpoint_is_bulk_in(endpoint)) {
759 /* we found a bulk in endpoint */
760 dbg("found bulk in on endpoint %d", i);
761 bulk_in_endpoint[num_bulk_in] = endpoint;
762 ++num_bulk_in;
763 }
764
765 if (usb_endpoint_is_bulk_out(endpoint)) {
766 /* we found a bulk out endpoint */
767 dbg("found bulk out on endpoint %d", i);
768 bulk_out_endpoint[num_bulk_out] = endpoint;
769 ++num_bulk_out;
770 }
771
772 if (usb_endpoint_is_int_in(endpoint)) {
773 /* we found a interrupt in endpoint */
774 dbg("found interrupt in on endpoint %d", i);
775 interrupt_in_endpoint[num_interrupt_in] = endpoint;
776 ++num_interrupt_in;
777 }
778
779 if (usb_endpoint_is_int_out(endpoint)) {
780 /* we found an interrupt out endpoint */
781 dbg("found interrupt out on endpoint %d", i);
782 interrupt_out_endpoint[num_interrupt_out] = endpoint;
783 ++num_interrupt_out;
784 }
785 }
786
787 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
788 /* BEGIN HORRIBLE HACK FOR PL2303 */
789 /* this is needed due to the looney way its endpoints are set up */
790 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
791 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
792 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
793 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
794 ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
795 (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
796 if (interface != dev->actconfig->interface[0]) {
797 /* check out the endpoints of the other interface*/
798 iface_desc = dev->actconfig->interface[0]->cur_altsetting;
799 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
800 endpoint = &iface_desc->endpoint[i].desc;
801 if (usb_endpoint_is_int_in(endpoint)) {
802 /* we found a interrupt in endpoint */
803 dbg("found interrupt in for Prolific device on separate interface");
804 interrupt_in_endpoint[num_interrupt_in] = endpoint;
805 ++num_interrupt_in;
806 }
807 }
808 }
809
810 /* Now make sure the PL-2303 is configured correctly.
811 * If not, give up now and hope this hack will work
812 * properly during a later invocation of usb_serial_probe
813 */
814 if (num_bulk_in == 0 || num_bulk_out == 0) {
815 unlock_kernel();
816 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
817 kfree (serial);
818 return -ENODEV;
819 }
820 }
821 /* END HORRIBLE HACK FOR PL2303 */
822 #endif
823
824 #ifdef CONFIG_USB_SERIAL_GENERIC
825 if (type == &usb_serial_generic_device) {
826 num_ports = num_bulk_out;
827 if (num_ports == 0) {
828 unlock_kernel();
829 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
830 kfree (serial);
831 return -EIO;
832 }
833 }
834 #endif
835 if (!num_ports) {
836 /* if this device type has a calc_num_ports function, call it */
837 if (type->calc_num_ports) {
838 if (!try_module_get(type->driver.owner)) {
839 unlock_kernel();
840 dev_err(&interface->dev, "module get failed, exiting\n");
841 kfree (serial);
842 return -EIO;
843 }
844 num_ports = type->calc_num_ports (serial);
845 module_put(type->driver.owner);
846 }
847 if (!num_ports)
848 num_ports = type->num_ports;
849 }
850
851 serial->num_ports = num_ports;
852 serial->num_bulk_in = num_bulk_in;
853 serial->num_bulk_out = num_bulk_out;
854 serial->num_interrupt_in = num_interrupt_in;
855 serial->num_interrupt_out = num_interrupt_out;
856
857 #if 0
858 /* check that the device meets the driver's requirements */
859 if ((type->num_interrupt_in != NUM_DONT_CARE &&
860 type->num_interrupt_in != num_interrupt_in)
861 || (type->num_interrupt_out != NUM_DONT_CARE &&
862 type->num_interrupt_out != num_interrupt_out)
863 || (type->num_bulk_in != NUM_DONT_CARE &&
864 type->num_bulk_in != num_bulk_in)
865 || (type->num_bulk_out != NUM_DONT_CARE &&
866 type->num_bulk_out != num_bulk_out)) {
867 dbg("wrong number of endpoints");
868 kfree(serial);
869 return -EIO;
870 }
871 #endif
872
873 /* found all that we need */
874 dev_info(&interface->dev, "%s converter detected\n",
875 type->description);
876
877 /* create our ports, we need as many as the max endpoints */
878 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
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 unlock_kernel();
885
886 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
887 for (i = 0; i < max_endpoints; ++i) {
888 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
889 if (!port)
890 goto probe_error;
891 port->serial = serial;
892 spin_lock_init(&port->lock);
893 mutex_init(&port->mutex);
894 INIT_WORK(&port->work, usb_serial_port_work);
895 serial->port[i] = port;
896 }
897
898 /* set up the endpoint information */
899 for (i = 0; i < num_bulk_in; ++i) {
900 endpoint = bulk_in_endpoint[i];
901 port = serial->port[i];
902 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
903 if (!port->read_urb) {
904 dev_err(&interface->dev, "No free urbs available\n");
905 goto probe_error;
906 }
907 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
908 port->bulk_in_size = buffer_size;
909 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
910 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
911 if (!port->bulk_in_buffer) {
912 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
913 goto probe_error;
914 }
915 usb_fill_bulk_urb (port->read_urb, dev,
916 usb_rcvbulkpipe (dev,
917 endpoint->bEndpointAddress),
918 port->bulk_in_buffer, buffer_size,
919 serial->type->read_bulk_callback,
920 port);
921 }
922
923 for (i = 0; i < num_bulk_out; ++i) {
924 endpoint = bulk_out_endpoint[i];
925 port = serial->port[i];
926 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
927 if (!port->write_urb) {
928 dev_err(&interface->dev, "No free urbs available\n");
929 goto probe_error;
930 }
931 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
932 port->bulk_out_size = buffer_size;
933 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
934 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
935 if (!port->bulk_out_buffer) {
936 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
937 goto probe_error;
938 }
939 usb_fill_bulk_urb (port->write_urb, dev,
940 usb_sndbulkpipe (dev,
941 endpoint->bEndpointAddress),
942 port->bulk_out_buffer, buffer_size,
943 serial->type->write_bulk_callback,
944 port);
945 }
946
947 if (serial->type->read_int_callback) {
948 for (i = 0; i < num_interrupt_in; ++i) {
949 endpoint = interrupt_in_endpoint[i];
950 port = serial->port[i];
951 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
952 if (!port->interrupt_in_urb) {
953 dev_err(&interface->dev, "No free urbs available\n");
954 goto probe_error;
955 }
956 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
957 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
958 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
959 if (!port->interrupt_in_buffer) {
960 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
961 goto probe_error;
962 }
963 usb_fill_int_urb (port->interrupt_in_urb, dev,
964 usb_rcvintpipe (dev,
965 endpoint->bEndpointAddress),
966 port->interrupt_in_buffer, buffer_size,
967 serial->type->read_int_callback, port,
968 endpoint->bInterval);
969 }
970 } else if (num_interrupt_in) {
971 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
972 }
973
974 if (serial->type->write_int_callback) {
975 for (i = 0; i < num_interrupt_out; ++i) {
976 endpoint = interrupt_out_endpoint[i];
977 port = serial->port[i];
978 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
979 if (!port->interrupt_out_urb) {
980 dev_err(&interface->dev, "No free urbs available\n");
981 goto probe_error;
982 }
983 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
984 port->interrupt_out_size = buffer_size;
985 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
986 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
987 if (!port->interrupt_out_buffer) {
988 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
989 goto probe_error;
990 }
991 usb_fill_int_urb (port->interrupt_out_urb, dev,
992 usb_sndintpipe (dev,
993 endpoint->bEndpointAddress),
994 port->interrupt_out_buffer, buffer_size,
995 serial->type->write_int_callback, port,
996 endpoint->bInterval);
997 }
998 } else if (num_interrupt_out) {
999 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
1000 }
1001
1002 /* if this device type has an attach function, call it */
1003 if (type->attach) {
1004 if (!try_module_get(type->driver.owner)) {
1005 dev_err(&interface->dev, "module get failed, exiting\n");
1006 goto probe_error;
1007 }
1008 retval = type->attach (serial);
1009 module_put(type->driver.owner);
1010 if (retval < 0)
1011 goto probe_error;
1012 if (retval > 0) {
1013 /* quietly accept this device, but don't bind to a serial port
1014 * as it's about to disappear */
1015 goto exit;
1016 }
1017 }
1018
1019 if (get_free_serial (serial, num_ports, &minor) == NULL) {
1020 dev_err(&interface->dev, "No more free serial devices\n");
1021 goto probe_error;
1022 }
1023 serial->minor = minor;
1024
1025 /* register all of the individual ports with the driver core */
1026 for (i = 0; i < num_ports; ++i) {
1027 port = serial->port[i];
1028 port->dev.parent = &interface->dev;
1029 port->dev.driver = NULL;
1030 port->dev.bus = &usb_serial_bus_type;
1031 port->dev.release = &port_release;
1032
1033 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
1034 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
1035 retval = device_register(&port->dev);
1036 if (retval)
1037 dev_err(&port->dev, "Error registering port device, "
1038 "continuing\n");
1039 }
1040
1041 usb_serial_console_init (debug, minor);
1042
1043 exit:
1044 /* success */
1045 usb_set_intfdata (interface, serial);
1046 return 0;
1047
1048 probe_error:
1049 for (i = 0; i < num_bulk_in; ++i) {
1050 port = serial->port[i];
1051 if (!port)
1052 continue;
1053 usb_free_urb(port->read_urb);
1054 kfree(port->bulk_in_buffer);
1055 }
1056 for (i = 0; i < num_bulk_out; ++i) {
1057 port = serial->port[i];
1058 if (!port)
1059 continue;
1060 usb_free_urb(port->write_urb);
1061 kfree(port->bulk_out_buffer);
1062 }
1063 for (i = 0; i < num_interrupt_in; ++i) {
1064 port = serial->port[i];
1065 if (!port)
1066 continue;
1067 usb_free_urb(port->interrupt_in_urb);
1068 kfree(port->interrupt_in_buffer);
1069 }
1070 for (i = 0; i < num_interrupt_out; ++i) {
1071 port = serial->port[i];
1072 if (!port)
1073 continue;
1074 usb_free_urb(port->interrupt_out_urb);
1075 kfree(port->interrupt_out_buffer);
1076 }
1077
1078 /* free up any memory that we allocated */
1079 for (i = 0; i < serial->num_port_pointers; ++i)
1080 kfree(serial->port[i]);
1081 kfree (serial);
1082 return -EIO;
1083 }
1084
1085 void usb_serial_disconnect(struct usb_interface *interface)
1086 {
1087 int i;
1088 struct usb_serial *serial = usb_get_intfdata (interface);
1089 struct device *dev = &interface->dev;
1090 struct usb_serial_port *port;
1091
1092 usb_serial_console_disconnect(serial);
1093 dbg ("%s", __FUNCTION__);
1094
1095 mutex_lock(&serial->disc_mutex);
1096 usb_set_intfdata (interface, NULL);
1097 /* must set a flag, to signal subdrivers */
1098 serial->disconnected = 1;
1099 for (i = 0; i < serial->num_ports; ++i) {
1100 port = serial->port[i];
1101 if (port) {
1102 if (port->tty)
1103 tty_hangup(port->tty);
1104 kill_traffic(port);
1105 }
1106 }
1107 /* let the last holder of this object
1108 * cause it to be cleaned up */
1109 mutex_unlock(&serial->disc_mutex);
1110 usb_serial_put(serial);
1111 dev_info(dev, "device disconnected\n");
1112 }
1113
1114 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1115 {
1116 struct usb_serial *serial = usb_get_intfdata(intf);
1117 struct usb_serial_port *port;
1118 int i, r = 0;
1119
1120 for (i = 0; i < serial->num_ports; ++i) {
1121 port = serial->port[i];
1122 if (port)
1123 kill_traffic(port);
1124 }
1125
1126 if (serial->type->suspend)
1127 r = serial->type->suspend(serial, message);
1128
1129 return r;
1130 }
1131 EXPORT_SYMBOL(usb_serial_suspend);
1132
1133 int usb_serial_resume(struct usb_interface *intf)
1134 {
1135 struct usb_serial *serial = usb_get_intfdata(intf);
1136
1137 if (serial->type->resume)
1138 return serial->type->resume(serial);
1139 return 0;
1140 }
1141 EXPORT_SYMBOL(usb_serial_resume);
1142
1143 static const struct tty_operations serial_ops = {
1144 .open = serial_open,
1145 .close = serial_close,
1146 .write = serial_write,
1147 .write_room = serial_write_room,
1148 .ioctl = serial_ioctl,
1149 .set_termios = serial_set_termios,
1150 .throttle = serial_throttle,
1151 .unthrottle = serial_unthrottle,
1152 .break_ctl = serial_break,
1153 .chars_in_buffer = serial_chars_in_buffer,
1154 .read_proc = serial_read_proc,
1155 .tiocmget = serial_tiocmget,
1156 .tiocmset = serial_tiocmset,
1157 };
1158
1159 struct tty_driver *usb_serial_tty_driver;
1160
1161 static int __init usb_serial_init(void)
1162 {
1163 int i;
1164 int result;
1165
1166 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1167 if (!usb_serial_tty_driver)
1168 return -ENOMEM;
1169
1170 /* Initialize our global data */
1171 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1172 serial_table[i] = NULL;
1173 }
1174
1175 result = bus_register(&usb_serial_bus_type);
1176 if (result) {
1177 err("%s - registering bus driver failed", __FUNCTION__);
1178 goto exit_bus;
1179 }
1180
1181 usb_serial_tty_driver->owner = THIS_MODULE;
1182 usb_serial_tty_driver->driver_name = "usbserial";
1183 usb_serial_tty_driver->name = "ttyUSB";
1184 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1185 usb_serial_tty_driver->minor_start = 0;
1186 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1187 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1188 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1189 usb_serial_tty_driver->init_termios = tty_std_termios;
1190 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1191 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1192 result = tty_register_driver(usb_serial_tty_driver);
1193 if (result) {
1194 err("%s - tty_register_driver failed", __FUNCTION__);
1195 goto exit_reg_driver;
1196 }
1197
1198 /* register the USB driver */
1199 result = usb_register(&usb_serial_driver);
1200 if (result < 0) {
1201 err("%s - usb_register failed", __FUNCTION__);
1202 goto exit_tty;
1203 }
1204
1205 /* register the generic driver, if we should */
1206 result = usb_serial_generic_register(debug);
1207 if (result < 0) {
1208 err("%s - registering generic driver failed", __FUNCTION__);
1209 goto exit_generic;
1210 }
1211
1212 info(DRIVER_DESC);
1213
1214 return result;
1215
1216 exit_generic:
1217 usb_deregister(&usb_serial_driver);
1218
1219 exit_tty:
1220 tty_unregister_driver(usb_serial_tty_driver);
1221
1222 exit_reg_driver:
1223 bus_unregister(&usb_serial_bus_type);
1224
1225 exit_bus:
1226 err ("%s - returning with error %d", __FUNCTION__, result);
1227 put_tty_driver(usb_serial_tty_driver);
1228 return result;
1229 }
1230
1231
1232 static void __exit usb_serial_exit(void)
1233 {
1234 usb_serial_console_exit();
1235
1236 usb_serial_generic_deregister();
1237
1238 usb_deregister(&usb_serial_driver);
1239 tty_unregister_driver(usb_serial_tty_driver);
1240 put_tty_driver(usb_serial_tty_driver);
1241 bus_unregister(&usb_serial_bus_type);
1242 }
1243
1244
1245 module_init(usb_serial_init);
1246 module_exit(usb_serial_exit);
1247
1248 #define set_to_generic_if_null(type, function) \
1249 do { \
1250 if (!type->function) { \
1251 type->function = usb_serial_generic_##function; \
1252 dbg("Had to override the " #function \
1253 " usb serial operation with the generic one.");\
1254 } \
1255 } while (0)
1256
1257 static void fixup_generic(struct usb_serial_driver *device)
1258 {
1259 set_to_generic_if_null(device, open);
1260 set_to_generic_if_null(device, write);
1261 set_to_generic_if_null(device, close);
1262 set_to_generic_if_null(device, write_room);
1263 set_to_generic_if_null(device, chars_in_buffer);
1264 set_to_generic_if_null(device, read_bulk_callback);
1265 set_to_generic_if_null(device, write_bulk_callback);
1266 set_to_generic_if_null(device, shutdown);
1267 set_to_generic_if_null(device, resume);
1268 }
1269
1270 int usb_serial_register(struct usb_serial_driver *driver) /* must be called with BKL held */
1271 {
1272 int retval;
1273
1274 fixup_generic(driver);
1275
1276 if (!driver->description)
1277 driver->description = driver->driver.name;
1278
1279 /* Add this device to our list of devices */
1280 list_add(&driver->driver_list, &usb_serial_driver_list);
1281
1282 retval = usb_serial_bus_register(driver);
1283 if (retval) {
1284 err("problem %d when registering driver %s", retval, driver->description);
1285 list_del(&driver->driver_list);
1286 }
1287 else
1288 info("USB Serial support registered for %s", driver->description);
1289
1290 return retval;
1291 }
1292
1293
1294 void usb_serial_deregister(struct usb_serial_driver *device) /* must be called with BKL held */
1295 {
1296 info("USB Serial deregistering driver %s", device->description);
1297 list_del(&device->driver_list);
1298 usb_serial_bus_deregister(device);
1299 }
1300
1301
1302
1303 /* If the usb-serial core is built into the core, the usb-serial drivers
1304 need these symbols to load properly as modules. */
1305 EXPORT_SYMBOL_GPL(usb_serial_register);
1306 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1307 EXPORT_SYMBOL_GPL(usb_serial_probe);
1308 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1309 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1310
1311
1312 /* Module information */
1313 MODULE_AUTHOR( DRIVER_AUTHOR );
1314 MODULE_DESCRIPTION( DRIVER_DESC );
1315 MODULE_LICENSE("GPL");
1316
1317 module_param(debug, bool, S_IRUGO | S_IWUSR);
1318 MODULE_PARM_DESC(debug, "Debug enabled or not");
Linux kernel - Deliverables
This page took 0.06594 seconds and 6 git commands to generate.