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