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