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