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