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