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