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