projects / deliverable / linux.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Merge commit master.kernel.org:/pub/scm/linux/kernel/git/gregkh/i2c-2.6 of HEAD
[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 goto done;
469 if ((length + begin) < off) {
470 begin += length;
471 length = 0;
472 }
473 usb_serial_put(serial);
474 }
475 *eof = 1;
476 done:
477 if (off >= (length + begin))
478 return 0;
479 *start = page + (off-begin);
480 return ((count < begin+length-off) ? count : begin+length-off);
481 }
482
483 static int serial_tiocmget (struct tty_struct *tty, struct file *file)
484 {
485 struct usb_serial_port *port = tty->driver_data;
486
487 if (!port)
488 return -ENODEV;
489
490 dbg("%s - port %d", __FUNCTION__, port->number);
491
492 if (!port->open_count) {
493 dbg("%s - port not open", __FUNCTION__);
494 return -ENODEV;
495 }
496
497 if (port->serial->type->tiocmget)
498 return port->serial->type->tiocmget(port, file);
499
500 return -EINVAL;
501 }
502
503 static int serial_tiocmset (struct tty_struct *tty, struct file *file,
504 unsigned int set, unsigned int clear)
505 {
506 struct usb_serial_port *port = tty->driver_data;
507
508 if (!port)
509 return -ENODEV;
510
511 dbg("%s - port %d", __FUNCTION__, port->number);
512
513 if (!port->open_count) {
514 dbg("%s - port not open", __FUNCTION__);
515 return -ENODEV;
516 }
517
518 if (port->serial->type->tiocmset)
519 return port->serial->type->tiocmset(port, file, set, clear);
520
521 return -EINVAL;
522 }
523
524 /*
525 * We would be calling tty_wakeup here, but unfortunately some line
526 * disciplines have an annoying habit of calling tty->write from
527 * the write wakeup callback (e.g. n_hdlc.c).
528 */
529 void usb_serial_port_softint(struct usb_serial_port *port)
530 {
531 schedule_work(&port->work);
532 }
533
534 static void usb_serial_port_work(void *private)
535 {
536 struct usb_serial_port *port = private;
537 struct tty_struct *tty;
538
539 dbg("%s - port %d", __FUNCTION__, port->number);
540
541 if (!port)
542 return;
543
544 tty = port->tty;
545 if (!tty)
546 return;
547
548 tty_wakeup(tty);
549 }
550
551 static void port_release(struct device *dev)
552 {
553 struct usb_serial_port *port = to_usb_serial_port(dev);
554
555 dbg ("%s - %s", __FUNCTION__, dev->bus_id);
556 port_free(port);
557 }
558
559 static void port_free(struct usb_serial_port *port)
560 {
561 usb_kill_urb(port->read_urb);
562 usb_free_urb(port->read_urb);
563 usb_kill_urb(port->write_urb);
564 usb_free_urb(port->write_urb);
565 usb_kill_urb(port->interrupt_in_urb);
566 usb_free_urb(port->interrupt_in_urb);
567 usb_kill_urb(port->interrupt_out_urb);
568 usb_free_urb(port->interrupt_out_urb);
569 kfree(port->bulk_in_buffer);
570 kfree(port->bulk_out_buffer);
571 kfree(port->interrupt_in_buffer);
572 kfree(port->interrupt_out_buffer);
573 flush_scheduled_work(); /* port->work */
574 kfree(port);
575 }
576
577 static struct usb_serial * create_serial (struct usb_device *dev,
578 struct usb_interface *interface,
579 struct usb_serial_driver *driver)
580 {
581 struct usb_serial *serial;
582
583 serial = kzalloc(sizeof(*serial), GFP_KERNEL);
584 if (!serial) {
585 dev_err(&dev->dev, "%s - out of memory\n", __FUNCTION__);
586 return NULL;
587 }
588 serial->dev = usb_get_dev(dev);
589 serial->type = driver;
590 serial->interface = interface;
591 kref_init(&serial->kref);
592
593 return serial;
594 }
595
596 static struct usb_serial_driver *search_serial_device(struct usb_interface *iface)
597 {
598 struct list_head *p;
599 const struct usb_device_id *id;
600 struct usb_serial_driver *t;
601
602 /* Check if the usb id matches a known device */
603 list_for_each(p, &usb_serial_driver_list) {
604 t = list_entry(p, struct usb_serial_driver, driver_list);
605 id = usb_match_id(iface, t->id_table);
606 if (id != NULL) {
607 dbg("descriptor matches");
608 return t;
609 }
610 }
611
612 return NULL;
613 }
614
615 int usb_serial_probe(struct usb_interface *interface,
616 const struct usb_device_id *id)
617 {
618 struct usb_device *dev = interface_to_usbdev (interface);
619 struct usb_serial *serial = NULL;
620 struct usb_serial_port *port;
621 struct usb_host_interface *iface_desc;
622 struct usb_endpoint_descriptor *endpoint;
623 struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
624 struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
625 struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
626 struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
627 struct usb_serial_driver *type = NULL;
628 int retval;
629 int minor;
630 int buffer_size;
631 int i;
632 int num_interrupt_in = 0;
633 int num_interrupt_out = 0;
634 int num_bulk_in = 0;
635 int num_bulk_out = 0;
636 int num_ports = 0;
637 int max_endpoints;
638
639 type = search_serial_device(interface);
640 if (!type) {
641 dbg("none matched");
642 return -ENODEV;
643 }
644
645 serial = create_serial (dev, interface, type);
646 if (!serial) {
647 dev_err(&interface->dev, "%s - out of memory\n", __FUNCTION__);
648 return -ENOMEM;
649 }
650
651 /* if this device type has a probe function, call it */
652 if (type->probe) {
653 const struct usb_device_id *id;
654
655 if (!try_module_get(type->driver.owner)) {
656 dev_err(&interface->dev, "module get failed, exiting\n");
657 kfree (serial);
658 return -EIO;
659 }
660
661 id = usb_match_id(interface, type->id_table);
662 retval = type->probe(serial, id);
663 module_put(type->driver.owner);
664
665 if (retval) {
666 dbg ("sub driver rejected device");
667 kfree (serial);
668 return retval;
669 }
670 }
671
672 /* descriptor matches, let's find the endpoints needed */
673 /* check out the endpoints */
674 iface_desc = interface->cur_altsetting;
675 for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
676 endpoint = &iface_desc->endpoint[i].desc;
677
678 if ((endpoint->bEndpointAddress & 0x80) &&
679 ((endpoint->bmAttributes & 3) == 0x02)) {
680 /* we found a bulk in endpoint */
681 dbg("found bulk in on endpoint %d", i);
682 bulk_in_endpoint[num_bulk_in] = endpoint;
683 ++num_bulk_in;
684 }
685
686 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
687 ((endpoint->bmAttributes & 3) == 0x02)) {
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 ((endpoint->bEndpointAddress & 0x80) &&
695 ((endpoint->bmAttributes & 3) == 0x03)) {
696 /* we found a interrupt in endpoint */
697 dbg("found interrupt in on endpoint %d", i);
698 interrupt_in_endpoint[num_interrupt_in] = endpoint;
699 ++num_interrupt_in;
700 }
701
702 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
703 ((endpoint->bmAttributes & 3) == 0x03)) {
704 /* we found an interrupt out endpoint */
705 dbg("found interrupt out on endpoint %d", i);
706 interrupt_out_endpoint[num_interrupt_out] = endpoint;
707 ++num_interrupt_out;
708 }
709 }
710
711 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
712 /* BEGIN HORRIBLE HACK FOR PL2303 */
713 /* this is needed due to the looney way its endpoints are set up */
714 if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
715 (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
716 ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
717 (le16_to_cpu(dev->descriptor.idProduct) == ATEN_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 ((endpoint->bEndpointAddress & 0x80) &&
724 ((endpoint->bmAttributes & 3) == 0x03)) {
725 /* we found a interrupt in endpoint */
726 dbg("found interrupt in for Prolific device on separate interface");
727 interrupt_in_endpoint[num_interrupt_in] = endpoint;
728 ++num_interrupt_in;
729 }
730 }
731 }
732
733 /* Now make sure the PL-2303 is configured correctly.
734 * If not, give up now and hope this hack will work
735 * properly during a later invocation of usb_serial_probe
736 */
737 if (num_bulk_in == 0 || num_bulk_out == 0) {
738 dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
739 kfree (serial);
740 return -ENODEV;
741 }
742 }
743 /* END HORRIBLE HACK FOR PL2303 */
744 #endif
745
746 /* found all that we need */
747 dev_info(&interface->dev, "%s converter detected\n", type->description);
748
749 #ifdef CONFIG_USB_SERIAL_GENERIC
750 if (type == &usb_serial_generic_device) {
751 num_ports = num_bulk_out;
752 if (num_ports == 0) {
753 dev_err(&interface->dev, "Generic device with no bulk out, not allowed.\n");
754 kfree (serial);
755 return -EIO;
756 }
757 }
758 #endif
759 if (!num_ports) {
760 /* if this device type has a calc_num_ports function, call it */
761 if (type->calc_num_ports) {
762 if (!try_module_get(type->driver.owner)) {
763 dev_err(&interface->dev, "module get failed, exiting\n");
764 kfree (serial);
765 return -EIO;
766 }
767 num_ports = type->calc_num_ports (serial);
768 module_put(type->driver.owner);
769 }
770 if (!num_ports)
771 num_ports = type->num_ports;
772 }
773
774 if (get_free_serial (serial, num_ports, &minor) == NULL) {
775 dev_err(&interface->dev, "No more free serial devices\n");
776 kfree (serial);
777 return -ENOMEM;
778 }
779
780 serial->minor = minor;
781 serial->num_ports = num_ports;
782 serial->num_bulk_in = num_bulk_in;
783 serial->num_bulk_out = num_bulk_out;
784 serial->num_interrupt_in = num_interrupt_in;
785 serial->num_interrupt_out = num_interrupt_out;
786
787 /* create our ports, we need as many as the max endpoints */
788 /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
789 max_endpoints = max(num_bulk_in, num_bulk_out);
790 max_endpoints = max(max_endpoints, num_interrupt_in);
791 max_endpoints = max(max_endpoints, num_interrupt_out);
792 max_endpoints = max(max_endpoints, (int)serial->num_ports);
793 serial->num_port_pointers = max_endpoints;
794 dbg("%s - setting up %d port structures for this device", __FUNCTION__, max_endpoints);
795 for (i = 0; i < max_endpoints; ++i) {
796 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
797 if (!port)
798 goto probe_error;
799 port->number = i + serial->minor;
800 port->serial = serial;
801 spin_lock_init(&port->lock);
802 mutex_init(&port->mutex);
803 INIT_WORK(&port->work, usb_serial_port_work, port);
804 serial->port[i] = port;
805 }
806
807 /* set up the endpoint information */
808 for (i = 0; i < num_bulk_in; ++i) {
809 endpoint = bulk_in_endpoint[i];
810 port = serial->port[i];
811 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
812 if (!port->read_urb) {
813 dev_err(&interface->dev, "No free urbs available\n");
814 goto probe_error;
815 }
816 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
817 port->bulk_in_size = buffer_size;
818 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
819 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
820 if (!port->bulk_in_buffer) {
821 dev_err(&interface->dev, "Couldn't allocate bulk_in_buffer\n");
822 goto probe_error;
823 }
824 usb_fill_bulk_urb (port->read_urb, dev,
825 usb_rcvbulkpipe (dev,
826 endpoint->bEndpointAddress),
827 port->bulk_in_buffer, buffer_size,
828 serial->type->read_bulk_callback,
829 port);
830 }
831
832 for (i = 0; i < num_bulk_out; ++i) {
833 endpoint = bulk_out_endpoint[i];
834 port = serial->port[i];
835 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
836 if (!port->write_urb) {
837 dev_err(&interface->dev, "No free urbs available\n");
838 goto probe_error;
839 }
840 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
841 port->bulk_out_size = buffer_size;
842 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
843 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
844 if (!port->bulk_out_buffer) {
845 dev_err(&interface->dev, "Couldn't allocate bulk_out_buffer\n");
846 goto probe_error;
847 }
848 usb_fill_bulk_urb (port->write_urb, dev,
849 usb_sndbulkpipe (dev,
850 endpoint->bEndpointAddress),
851 port->bulk_out_buffer, buffer_size,
852 serial->type->write_bulk_callback,
853 port);
854 }
855
856 if (serial->type->read_int_callback) {
857 for (i = 0; i < num_interrupt_in; ++i) {
858 endpoint = interrupt_in_endpoint[i];
859 port = serial->port[i];
860 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
861 if (!port->interrupt_in_urb) {
862 dev_err(&interface->dev, "No free urbs available\n");
863 goto probe_error;
864 }
865 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
866 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
867 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
868 if (!port->interrupt_in_buffer) {
869 dev_err(&interface->dev, "Couldn't allocate interrupt_in_buffer\n");
870 goto probe_error;
871 }
872 usb_fill_int_urb (port->interrupt_in_urb, dev,
873 usb_rcvintpipe (dev,
874 endpoint->bEndpointAddress),
875 port->interrupt_in_buffer, buffer_size,
876 serial->type->read_int_callback, port,
877 endpoint->bInterval);
878 }
879 } else if (num_interrupt_in) {
880 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
881 }
882
883 if (serial->type->write_int_callback) {
884 for (i = 0; i < num_interrupt_out; ++i) {
885 endpoint = interrupt_out_endpoint[i];
886 port = serial->port[i];
887 port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
888 if (!port->interrupt_out_urb) {
889 dev_err(&interface->dev, "No free urbs available\n");
890 goto probe_error;
891 }
892 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
893 port->interrupt_out_size = buffer_size;
894 port->interrupt_out_endpointAddress = endpoint->bEndpointAddress;
895 port->interrupt_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
896 if (!port->interrupt_out_buffer) {
897 dev_err(&interface->dev, "Couldn't allocate interrupt_out_buffer\n");
898 goto probe_error;
899 }
900 usb_fill_int_urb (port->interrupt_out_urb, dev,
901 usb_sndintpipe (dev,
902 endpoint->bEndpointAddress),
903 port->interrupt_out_buffer, buffer_size,
904 serial->type->write_int_callback, port,
905 endpoint->bInterval);
906 }
907 } else if (num_interrupt_out) {
908 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
909 }
910
911 /* if this device type has an attach function, call it */
912 if (type->attach) {
913 if (!try_module_get(type->driver.owner)) {
914 dev_err(&interface->dev, "module get failed, exiting\n");
915 goto probe_error;
916 }
917 retval = type->attach (serial);
918 module_put(type->driver.owner);
919 if (retval < 0)
920 goto probe_error;
921 if (retval > 0) {
922 /* quietly accept this device, but don't bind to a serial port
923 * as it's about to disappear */
924 goto exit;
925 }
926 }
927
928 /* register all of the individual ports with the driver core */
929 for (i = 0; i < num_ports; ++i) {
930 port = serial->port[i];
931 port->dev.parent = &interface->dev;
932 port->dev.driver = NULL;
933 port->dev.bus = &usb_serial_bus_type;
934 port->dev.release = &port_release;
935
936 snprintf (&port->dev.bus_id[0], sizeof(port->dev.bus_id), "ttyUSB%d", port->number);
937 dbg ("%s - registering %s", __FUNCTION__, port->dev.bus_id);
938 device_register (&port->dev);
939 }
940
941 usb_serial_console_init (debug, minor);
942
943 exit:
944 /* success */
945 usb_set_intfdata (interface, serial);
946 return 0;
947
948 probe_error:
949 for (i = 0; i < num_bulk_in; ++i) {
950 port = serial->port[i];
951 if (!port)
952 continue;
953 if (port->read_urb)
954 usb_free_urb (port->read_urb);
955 kfree(port->bulk_in_buffer);
956 }
957 for (i = 0; i < num_bulk_out; ++i) {
958 port = serial->port[i];
959 if (!port)
960 continue;
961 if (port->write_urb)
962 usb_free_urb (port->write_urb);
963 kfree(port->bulk_out_buffer);
964 }
965 for (i = 0; i < num_interrupt_in; ++i) {
966 port = serial->port[i];
967 if (!port)
968 continue;
969 if (port->interrupt_in_urb)
970 usb_free_urb (port->interrupt_in_urb);
971 kfree(port->interrupt_in_buffer);
972 }
973 for (i = 0; i < num_interrupt_out; ++i) {
974 port = serial->port[i];
975 if (!port)
976 continue;
977 if (port->interrupt_out_urb)
978 usb_free_urb (port->interrupt_out_urb);
979 kfree(port->interrupt_out_buffer);
980 }
981
982 /* return the minor range that this device had */
983 return_serial (serial);
984
985 /* free up any memory that we allocated */
986 for (i = 0; i < serial->num_port_pointers; ++i)
987 kfree(serial->port[i]);
988 kfree (serial);
989 return -EIO;
990 }
991
992 void usb_serial_disconnect(struct usb_interface *interface)
993 {
994 int i;
995 struct usb_serial *serial = usb_get_intfdata (interface);
996 struct device *dev = &interface->dev;
997 struct usb_serial_port *port;
998
999 usb_serial_console_disconnect(serial);
1000 dbg ("%s", __FUNCTION__);
1001
1002 usb_set_intfdata (interface, NULL);
1003 if (serial) {
1004 for (i = 0; i < serial->num_ports; ++i) {
1005 port = serial->port[i];
1006 if (port && port->tty)
1007 tty_hangup(port->tty);
1008 }
1009 /* let the last holder of this object
1010 * cause it to be cleaned up */
1011 usb_serial_put(serial);
1012 }
1013 dev_info(dev, "device disconnected\n");
1014 }
1015
1016 static struct tty_operations serial_ops = {
1017 .open = serial_open,
1018 .close = serial_close,
1019 .write = serial_write,
1020 .write_room = serial_write_room,
1021 .ioctl = serial_ioctl,
1022 .set_termios = serial_set_termios,
1023 .throttle = serial_throttle,
1024 .unthrottle = serial_unthrottle,
1025 .break_ctl = serial_break,
1026 .chars_in_buffer = serial_chars_in_buffer,
1027 .read_proc = serial_read_proc,
1028 .tiocmget = serial_tiocmget,
1029 .tiocmset = serial_tiocmset,
1030 };
1031
1032 struct tty_driver *usb_serial_tty_driver;
1033
1034 static int __init usb_serial_init(void)
1035 {
1036 int i;
1037 int result;
1038
1039 usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1040 if (!usb_serial_tty_driver)
1041 return -ENOMEM;
1042
1043 /* Initialize our global data */
1044 for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1045 serial_table[i] = NULL;
1046 }
1047
1048 result = bus_register(&usb_serial_bus_type);
1049 if (result) {
1050 err("%s - registering bus driver failed", __FUNCTION__);
1051 goto exit_bus;
1052 }
1053
1054 usb_serial_tty_driver->owner = THIS_MODULE;
1055 usb_serial_tty_driver->driver_name = "usbserial";
1056 usb_serial_tty_driver->name = "ttyUSB";
1057 usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1058 usb_serial_tty_driver->minor_start = 0;
1059 usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1060 usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1061 usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW | TTY_DRIVER_DYNAMIC_DEV;
1062 usb_serial_tty_driver->init_termios = tty_std_termios;
1063 usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1064 tty_set_operations(usb_serial_tty_driver, &serial_ops);
1065 result = tty_register_driver(usb_serial_tty_driver);
1066 if (result) {
1067 err("%s - tty_register_driver failed", __FUNCTION__);
1068 goto exit_reg_driver;
1069 }
1070
1071 /* register the USB driver */
1072 result = usb_register(&usb_serial_driver);
1073 if (result < 0) {
1074 err("%s - usb_register failed", __FUNCTION__);
1075 goto exit_tty;
1076 }
1077
1078 /* register the generic driver, if we should */
1079 result = usb_serial_generic_register(debug);
1080 if (result < 0) {
1081 err("%s - registering generic driver failed", __FUNCTION__);
1082 goto exit_generic;
1083 }
1084
1085 info(DRIVER_DESC);
1086
1087 return result;
1088
1089 exit_generic:
1090 usb_deregister(&usb_serial_driver);
1091
1092 exit_tty:
1093 tty_unregister_driver(usb_serial_tty_driver);
1094
1095 exit_reg_driver:
1096 bus_unregister(&usb_serial_bus_type);
1097
1098 exit_bus:
1099 err ("%s - returning with error %d", __FUNCTION__, result);
1100 put_tty_driver(usb_serial_tty_driver);
1101 return result;
1102 }
1103
1104
1105 static void __exit usb_serial_exit(void)
1106 {
1107 usb_serial_console_exit();
1108
1109 usb_serial_generic_deregister();
1110
1111 usb_deregister(&usb_serial_driver);
1112 tty_unregister_driver(usb_serial_tty_driver);
1113 put_tty_driver(usb_serial_tty_driver);
1114 bus_unregister(&usb_serial_bus_type);
1115 }
1116
1117
1118 module_init(usb_serial_init);
1119 module_exit(usb_serial_exit);
1120
1121 #define set_to_generic_if_null(type, function) \
1122 do { \
1123 if (!type->function) { \
1124 type->function = usb_serial_generic_##function; \
1125 dbg("Had to override the " #function \
1126 " usb serial operation with the generic one.");\
1127 } \
1128 } while (0)
1129
1130 static void fixup_generic(struct usb_serial_driver *device)
1131 {
1132 set_to_generic_if_null(device, open);
1133 set_to_generic_if_null(device, write);
1134 set_to_generic_if_null(device, close);
1135 set_to_generic_if_null(device, write_room);
1136 set_to_generic_if_null(device, chars_in_buffer);
1137 set_to_generic_if_null(device, read_bulk_callback);
1138 set_to_generic_if_null(device, write_bulk_callback);
1139 set_to_generic_if_null(device, shutdown);
1140 }
1141
1142 int usb_serial_register(struct usb_serial_driver *driver)
1143 {
1144 int retval;
1145
1146 fixup_generic(driver);
1147
1148 if (!driver->description)
1149 driver->description = driver->driver.name;
1150
1151 /* Add this device to our list of devices */
1152 list_add(&driver->driver_list, &usb_serial_driver_list);
1153
1154 retval = usb_serial_bus_register(driver);
1155 if (retval) {
1156 err("problem %d when registering driver %s", retval, driver->description);
1157 list_del(&driver->driver_list);
1158 }
1159 else
1160 info("USB Serial support registered for %s", driver->description);
1161
1162 return retval;
1163 }
1164
1165
1166 void usb_serial_deregister(struct usb_serial_driver *device)
1167 {
1168 info("USB Serial deregistering driver %s", device->description);
1169 list_del(&device->driver_list);
1170 usb_serial_bus_deregister(device);
1171 }
1172
1173
1174
1175 /* If the usb-serial core is built into the core, the usb-serial drivers
1176 need these symbols to load properly as modules. */
1177 EXPORT_SYMBOL_GPL(usb_serial_register);
1178 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1179 EXPORT_SYMBOL_GPL(usb_serial_probe);
1180 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1181 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
1182
1183
1184 /* Module information */
1185 MODULE_AUTHOR( DRIVER_AUTHOR );
1186 MODULE_DESCRIPTION( DRIVER_DESC );
1187 MODULE_LICENSE("GPL");
1188
1189 module_param(debug, bool, S_IRUGO | S_IWUSR);
1190 MODULE_PARM_DESC(debug, "Debug enabled or not");
Linux kernel - Deliverables
This page took 0.058621 seconds and 6 git commands to generate.