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