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