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