tty-usb-iuu-phoenix: Clean up to coding style
[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         if (serial == NULL)
126                 return;
127
128         for (i = 0; i < serial->num_ports; ++i)
129                 serial_table[serial->minor + i] = NULL;
130 }
131
132 static void destroy_serial(struct kref *kref)
133 {
134         struct usb_serial *serial;
135         struct usb_serial_port *port;
136         int i;
137
138         serial = to_usb_serial(kref);
139
140         dbg("%s - %s", __func__, serial->type->description);
141
142         serial->type->shutdown(serial);
143
144         /* return the minor range that this device had */
145         return_serial(serial);
146
147         for (i = 0; i < serial->num_ports; ++i)
148                 serial->port[i]->port.count = 0;
149
150         /* the ports are cleaned up and released in port_release() */
151         for (i = 0; i < serial->num_ports; ++i)
152                 if (serial->port[i]->dev.parent != NULL) {
153                         device_unregister(&serial->port[i]->dev);
154                         serial->port[i] = NULL;
155                 }
156
157         /* If this is a "fake" port, we have to clean it up here, as it will
158          * not get cleaned up in port_release() as it was never registered with
159          * the driver core */
160         if (serial->num_ports < serial->num_port_pointers) {
161                 for (i = serial->num_ports;
162                                         i < serial->num_port_pointers; ++i) {
163                         port = serial->port[i];
164                         if (!port)
165                                 continue;
166                         port_free(port);
167                 }
168         }
169
170         usb_put_dev(serial->dev);
171
172         /* free up any memory that we allocated */
173         kfree(serial);
174 }
175
176 void usb_serial_put(struct usb_serial *serial)
177 {
178         mutex_lock(&table_lock);
179         kref_put(&serial->kref, destroy_serial);
180         mutex_unlock(&table_lock);
181 }
182
183 /*****************************************************************************
184  * Driver tty interface functions
185  *****************************************************************************/
186 static int serial_open (struct tty_struct *tty, struct file *filp)
187 {
188         struct usb_serial *serial;
189         struct usb_serial_port *port;
190         unsigned int portNumber;
191         int retval;
192
193         dbg("%s", __func__);
194
195         /* get the serial object associated with this tty pointer */
196         serial = usb_serial_get_by_index(tty->index);
197         if (!serial) {
198                 tty->driver_data = NULL;
199                 return -ENODEV;
200         }
201
202         portNumber = tty->index - serial->minor;
203         port = serial->port[portNumber];
204         if (!port) {
205                 retval = -ENODEV;
206                 goto bailout_kref_put;
207         }
208
209         if (mutex_lock_interruptible(&port->mutex)) {
210                 retval = -ERESTARTSYS;
211                 goto bailout_kref_put;
212         }
213
214         ++port->port.count;
215
216         /* set up our port structure making the tty driver
217          * remember our port object, and us it */
218         tty->driver_data = port;
219         port->port.tty = tty;
220
221         if (port->port.count == 1) {
222
223                 /* lock this module before we call it
224                  * this may fail, which means we must bail out,
225                  * safe because we are called with BKL held */
226                 if (!try_module_get(serial->type->driver.owner)) {
227                         retval = -ENODEV;
228                         goto bailout_mutex_unlock;
229                 }
230
231                 retval = usb_autopm_get_interface(serial->interface);
232                 if (retval)
233                         goto bailout_module_put;
234                 /* only call the device specific open if this
235                  * is the first time the port is opened */
236                 retval = serial->type->open(tty, port, filp);
237                 if (retval)
238                         goto bailout_interface_put;
239         }
240
241         mutex_unlock(&port->mutex);
242         return 0;
243
244 bailout_interface_put:
245         usb_autopm_put_interface(serial->interface);
246 bailout_module_put:
247         module_put(serial->type->driver.owner);
248 bailout_mutex_unlock:
249         port->port.count = 0;
250         tty->driver_data = NULL;
251         port->port.tty = NULL;
252         mutex_unlock(&port->mutex);
253 bailout_kref_put:
254         usb_serial_put(serial);
255         return retval;
256 }
257
258 static void serial_close(struct tty_struct *tty, struct file *filp)
259 {
260         struct usb_serial_port *port = tty->driver_data;
261
262         if (!port)
263                 return;
264
265         dbg("%s - port %d", __func__, port->number);
266
267         mutex_lock(&port->mutex);
268
269         if (port->port.count == 0) {
270                 mutex_unlock(&port->mutex);
271                 return;
272         }
273
274         --port->port.count;
275         if (port->port.count == 0)
276                 /* only call the device specific close if this
277                  * port is being closed by the last owner */
278                 port->serial->type->close(tty, port, filp);
279
280         if (port->port.count == (port->console? 1 : 0)) {
281                 if (port->port.tty) {
282                         if (port->port.tty->driver_data)
283                                 port->port.tty->driver_data = NULL;
284                         port->port.tty = NULL;
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 void 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 }
413
414 static int serial_read_proc(char *page, char **start, off_t off, int count,
415                                                         int *eof, void *data)
416 {
417         struct usb_serial *serial;
418         int length = 0;
419         int i;
420         off_t begin = 0;
421         char tmp[40];
422
423         dbg("%s", __func__);
424         length += sprintf(page, "usbserinfo:1.0 driver:2.0\n");
425         for (i = 0; i < SERIAL_TTY_MINORS && length < PAGE_SIZE; ++i) {
426                 serial = usb_serial_get_by_index(i);
427                 if (serial == NULL)
428                         continue;
429
430                 length += sprintf(page+length, "%d:", i);
431                 if (serial->type->driver.owner)
432                         length += sprintf(page+length, " module:%s",
433                                 module_name(serial->type->driver.owner));
434                 length += sprintf(page+length, " name:\"%s\"",
435                                 serial->type->description);
436                 length += sprintf(page+length, " vendor:%04x product:%04x",
437                         le16_to_cpu(serial->dev->descriptor.idVendor),
438                         le16_to_cpu(serial->dev->descriptor.idProduct));
439                 length += sprintf(page+length, " num_ports:%d",
440                                                         serial->num_ports);
441                 length += sprintf(page+length, " port:%d",
442                                                         i - serial->minor + 1);
443                 usb_make_path(serial->dev, tmp, sizeof(tmp));
444                 length += sprintf(page+length, " path:%s", tmp);
445
446                 length += sprintf(page+length, "\n");
447                 if ((length + begin) > (off + count)) {
448                         usb_serial_put(serial);
449                         goto done;
450                 }
451                 if ((length + begin) < off) {
452                         begin += length;
453                         length = 0;
454                 }
455                 usb_serial_put(serial);
456         }
457         *eof = 1;
458 done:
459         if (off >= (length + begin))
460                 return 0;
461         *start = page + (off-begin);
462         return (count < begin+length-off) ? count : begin+length-off;
463 }
464
465 static int serial_tiocmget(struct tty_struct *tty, struct file *file)
466 {
467         struct usb_serial_port *port = tty->driver_data;
468
469         dbg("%s - port %d", __func__, port->number);
470
471         WARN_ON(!port->port.count);
472         if (port->serial->type->tiocmget)
473                 return port->serial->type->tiocmget(tty, file);
474         return -EINVAL;
475 }
476
477 static int serial_tiocmset(struct tty_struct *tty, struct file *file,
478                             unsigned int set, unsigned int clear)
479 {
480         struct usb_serial_port *port = tty->driver_data;
481
482         dbg("%s - port %d", __func__, port->number);
483
484         WARN_ON(!port->port.count);
485         if (port->serial->type->tiocmset)
486                 return port->serial->type->tiocmset(tty, file, set, clear);
487         return -EINVAL;
488 }
489
490 /*
491  * We would be calling tty_wakeup here, but unfortunately some line
492  * disciplines have an annoying habit of calling tty->write from
493  * the write wakeup callback (e.g. n_hdlc.c).
494  */
495 void usb_serial_port_softint(struct usb_serial_port *port)
496 {
497         schedule_work(&port->work);
498 }
499 EXPORT_SYMBOL_GPL(usb_serial_port_softint);
500
501 static void usb_serial_port_work(struct work_struct *work)
502 {
503         struct usb_serial_port *port =
504                 container_of(work, struct usb_serial_port, work);
505         struct tty_struct *tty;
506
507         dbg("%s - port %d", __func__, port->number);
508
509         if (!port)
510                 return;
511
512         tty = port->port.tty;
513         if (!tty)
514                 return;
515
516         tty_wakeup(tty);
517 }
518
519 static void port_release(struct device *dev)
520 {
521         struct usb_serial_port *port = to_usb_serial_port(dev);
522
523         dbg ("%s - %s", __func__, dev_name(dev));
524         port_free(port);
525 }
526
527 static void kill_traffic(struct usb_serial_port *port)
528 {
529         usb_kill_urb(port->read_urb);
530         usb_kill_urb(port->write_urb);
531         /*
532          * This is tricky.
533          * Some drivers submit the read_urb in the
534          * handler for the write_urb or vice versa
535          * this order determines the order in which
536          * usb_kill_urb() must be used to reliably
537          * kill the URBs. As it is unknown here,
538          * both orders must be used in turn.
539          * The call below is not redundant.
540          */
541         usb_kill_urb(port->read_urb);
542         usb_kill_urb(port->interrupt_in_urb);
543         usb_kill_urb(port->interrupt_out_urb);
544 }
545
546 static void port_free(struct usb_serial_port *port)
547 {
548         kill_traffic(port);
549         usb_free_urb(port->read_urb);
550         usb_free_urb(port->write_urb);
551         usb_free_urb(port->interrupt_in_urb);
552         usb_free_urb(port->interrupt_out_urb);
553         kfree(port->bulk_in_buffer);
554         kfree(port->bulk_out_buffer);
555         kfree(port->interrupt_in_buffer);
556         kfree(port->interrupt_out_buffer);
557         flush_scheduled_work();         /* port->work */
558         kfree(port);
559 }
560
561 static struct usb_serial *create_serial(struct usb_device *dev,
562                                         struct usb_interface *interface,
563                                         struct usb_serial_driver *driver)
564 {
565         struct usb_serial *serial;
566
567         serial = kzalloc(sizeof(*serial), GFP_KERNEL);
568         if (!serial) {
569                 dev_err(&dev->dev, "%s - out of memory\n", __func__);
570                 return NULL;
571         }
572         serial->dev = usb_get_dev(dev);
573         serial->type = driver;
574         serial->interface = interface;
575         kref_init(&serial->kref);
576         mutex_init(&serial->disc_mutex);
577
578         return serial;
579 }
580
581 static const struct usb_device_id *match_dynamic_id(struct usb_interface *intf,
582                                             struct usb_serial_driver *drv)
583 {
584         struct usb_dynid *dynid;
585
586         spin_lock(&drv->dynids.lock);
587         list_for_each_entry(dynid, &drv->dynids.list, node) {
588                 if (usb_match_one_id(intf, &dynid->id)) {
589                         spin_unlock(&drv->dynids.lock);
590                         return &dynid->id;
591                 }
592         }
593         spin_unlock(&drv->dynids.lock);
594         return NULL;
595 }
596
597 static const struct usb_device_id *get_iface_id(struct usb_serial_driver *drv,
598                                                 struct usb_interface *intf)
599 {
600         const struct usb_device_id *id;
601
602         id = usb_match_id(intf, drv->id_table);
603         if (id) {
604                 dbg("static descriptor matches");
605                 goto exit;
606         }
607         id = match_dynamic_id(intf, drv);
608         if (id)
609                 dbg("dynamic descriptor matches");
610 exit:
611         return id;
612 }
613
614 static struct usb_serial_driver *search_serial_device(
615                                         struct usb_interface *iface)
616 {
617         const struct usb_device_id *id;
618         struct usb_serial_driver *drv;
619
620         /* Check if the usb id matches a known device */
621         list_for_each_entry(drv, &usb_serial_driver_list, driver_list) {
622                 id = get_iface_id(drv, iface);
623                 if (id)
624                         return drv;
625         }
626
627         return NULL;
628 }
629
630 int usb_serial_probe(struct usb_interface *interface,
631                                const struct usb_device_id *id)
632 {
633         struct usb_device *dev = interface_to_usbdev(interface);
634         struct usb_serial *serial = NULL;
635         struct usb_serial_port *port;
636         struct usb_host_interface *iface_desc;
637         struct usb_endpoint_descriptor *endpoint;
638         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
639         struct usb_endpoint_descriptor *interrupt_out_endpoint[MAX_NUM_PORTS];
640         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
641         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
642         struct usb_serial_driver *type = NULL;
643         int retval;
644         unsigned int minor;
645         int buffer_size;
646         int i;
647         int num_interrupt_in = 0;
648         int num_interrupt_out = 0;
649         int num_bulk_in = 0;
650         int num_bulk_out = 0;
651         int num_ports = 0;
652         int max_endpoints;
653
654         lock_kernel(); /* guard against unloading a serial driver module */
655         type = search_serial_device(interface);
656         if (!type) {
657                 unlock_kernel();
658                 dbg("none matched");
659                 return -ENODEV;
660         }
661
662         serial = create_serial(dev, interface, type);
663         if (!serial) {
664                 unlock_kernel();
665                 dev_err(&interface->dev, "%s - out of memory\n", __func__);
666                 return -ENOMEM;
667         }
668
669         /* if this device type has a probe function, call it */
670         if (type->probe) {
671                 const struct usb_device_id *id;
672
673                 if (!try_module_get(type->driver.owner)) {
674                         unlock_kernel();
675                         dev_err(&interface->dev,
676                                 "module get failed, exiting\n");
677                         kfree(serial);
678                         return -EIO;
679                 }
680
681                 id = get_iface_id(type, interface);
682                 retval = type->probe(serial, id);
683                 module_put(type->driver.owner);
684
685                 if (retval) {
686                         unlock_kernel();
687                         dbg("sub driver rejected device");
688                         kfree(serial);
689                         return retval;
690                 }
691         }
692
693         /* descriptor matches, let's find the endpoints needed */
694         /* check out the endpoints */
695         iface_desc = interface->cur_altsetting;
696         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
697                 endpoint = &iface_desc->endpoint[i].desc;
698
699                 if (usb_endpoint_is_bulk_in(endpoint)) {
700                         /* we found a bulk in endpoint */
701                         dbg("found bulk in on endpoint %d", i);
702                         bulk_in_endpoint[num_bulk_in] = endpoint;
703                         ++num_bulk_in;
704                 }
705
706                 if (usb_endpoint_is_bulk_out(endpoint)) {
707                         /* we found a bulk out endpoint */
708                         dbg("found bulk out on endpoint %d", i);
709                         bulk_out_endpoint[num_bulk_out] = endpoint;
710                         ++num_bulk_out;
711                 }
712
713                 if (usb_endpoint_is_int_in(endpoint)) {
714                         /* we found a interrupt in endpoint */
715                         dbg("found interrupt in on endpoint %d", i);
716                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
717                         ++num_interrupt_in;
718                 }
719
720                 if (usb_endpoint_is_int_out(endpoint)) {
721                         /* we found an interrupt out endpoint */
722                         dbg("found interrupt out on endpoint %d", i);
723                         interrupt_out_endpoint[num_interrupt_out] = endpoint;
724                         ++num_interrupt_out;
725                 }
726         }
727
728 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
729         /* BEGIN HORRIBLE HACK FOR PL2303 */
730         /* this is needed due to the looney way its endpoints are set up */
731         if (((le16_to_cpu(dev->descriptor.idVendor) == PL2303_VENDOR_ID) &&
732              (le16_to_cpu(dev->descriptor.idProduct) == PL2303_PRODUCT_ID)) ||
733             ((le16_to_cpu(dev->descriptor.idVendor) == ATEN_VENDOR_ID) &&
734              (le16_to_cpu(dev->descriptor.idProduct) == ATEN_PRODUCT_ID)) ||
735             ((le16_to_cpu(dev->descriptor.idVendor) == ALCOR_VENDOR_ID) &&
736              (le16_to_cpu(dev->descriptor.idProduct) == ALCOR_PRODUCT_ID))) {
737                 if (interface != dev->actconfig->interface[0]) {
738                         /* check out the endpoints of the other interface*/
739                         iface_desc = dev->actconfig->interface[0]->cur_altsetting;
740                         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
741                                 endpoint = &iface_desc->endpoint[i].desc;
742                                 if (usb_endpoint_is_int_in(endpoint)) {
743                                         /* we found a interrupt in endpoint */
744                                         dbg("found interrupt in for Prolific device on separate interface");
745                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
746                                         ++num_interrupt_in;
747                                 }
748                         }
749                 }
750
751                 /* Now make sure the PL-2303 is configured correctly.
752                  * If not, give up now and hope this hack will work
753                  * properly during a later invocation of usb_serial_probe
754                  */
755                 if (num_bulk_in == 0 || num_bulk_out == 0) {
756                         unlock_kernel();
757                         dev_info(&interface->dev, "PL-2303 hack: descriptors matched but endpoints did not\n");
758                         kfree(serial);
759                         return -ENODEV;
760                 }
761         }
762         /* END HORRIBLE HACK FOR PL2303 */
763 #endif
764
765 #ifdef CONFIG_USB_SERIAL_GENERIC
766         if (type == &usb_serial_generic_device) {
767                 num_ports = num_bulk_out;
768                 if (num_ports == 0) {
769                         unlock_kernel();
770                         dev_err(&interface->dev,
771                             "Generic device with no bulk out, not allowed.\n");
772                         kfree(serial);
773                         return -EIO;
774                 }
775         }
776 #endif
777         if (!num_ports) {
778                 /* if this device type has a calc_num_ports function, call it */
779                 if (type->calc_num_ports) {
780                         if (!try_module_get(type->driver.owner)) {
781                                 unlock_kernel();
782                                 dev_err(&interface->dev,
783                                         "module get failed, exiting\n");
784                                 kfree(serial);
785                                 return -EIO;
786                         }
787                         num_ports = type->calc_num_ports(serial);
788                         module_put(type->driver.owner);
789                 }
790                 if (!num_ports)
791                         num_ports = type->num_ports;
792         }
793
794         serial->num_ports = num_ports;
795         serial->num_bulk_in = num_bulk_in;
796         serial->num_bulk_out = num_bulk_out;
797         serial->num_interrupt_in = num_interrupt_in;
798         serial->num_interrupt_out = num_interrupt_out;
799
800         /* found all that we need */
801         dev_info(&interface->dev, "%s converter detected\n",
802                         type->description);
803
804         /* create our ports, we need as many as the max endpoints */
805         /* we don't use num_ports here because some devices have more
806            endpoint pairs than ports */
807         max_endpoints = max(num_bulk_in, num_bulk_out);
808         max_endpoints = max(max_endpoints, num_interrupt_in);
809         max_endpoints = max(max_endpoints, num_interrupt_out);
810         max_endpoints = max(max_endpoints, (int)serial->num_ports);
811         serial->num_port_pointers = max_endpoints;
812         unlock_kernel();
813
814         dbg("%s - setting up %d port structures for this device",
815                                                 __func__, max_endpoints);
816         for (i = 0; i < max_endpoints; ++i) {
817                 port = kzalloc(sizeof(struct usb_serial_port), GFP_KERNEL);
818                 if (!port)
819                         goto probe_error;
820                 port->serial = serial;
821                 spin_lock_init(&port->lock);
822                 mutex_init(&port->mutex);
823                 INIT_WORK(&port->work, usb_serial_port_work);
824                 serial->port[i] = port;
825         }
826
827         /* set up the endpoint information */
828         for (i = 0; i < num_bulk_in; ++i) {
829                 endpoint = bulk_in_endpoint[i];
830                 port = serial->port[i];
831                 port->read_urb = usb_alloc_urb(0, GFP_KERNEL);
832                 if (!port->read_urb) {
833                         dev_err(&interface->dev, "No free urbs available\n");
834                         goto probe_error;
835                 }
836                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
837                 port->bulk_in_size = buffer_size;
838                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
839                 port->bulk_in_buffer = kmalloc(buffer_size, GFP_KERNEL);
840                 if (!port->bulk_in_buffer) {
841                         dev_err(&interface->dev,
842                                         "Couldn't allocate bulk_in_buffer\n");
843                         goto probe_error;
844                 }
845                 usb_fill_bulk_urb(port->read_urb, dev,
846                                 usb_rcvbulkpipe(dev,
847                                                 endpoint->bEndpointAddress),
848                                 port->bulk_in_buffer, buffer_size,
849                                 serial->type->read_bulk_callback, port);
850         }
851
852         for (i = 0; i < num_bulk_out; ++i) {
853                 endpoint = bulk_out_endpoint[i];
854                 port = serial->port[i];
855                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
856                 if (!port->write_urb) {
857                         dev_err(&interface->dev, "No free urbs available\n");
858                         goto probe_error;
859                 }
860                 buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
861                 port->bulk_out_size = buffer_size;
862                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
863                 port->bulk_out_buffer = kmalloc(buffer_size, GFP_KERNEL);
864                 if (!port->bulk_out_buffer) {
865                         dev_err(&interface->dev,
866                                         "Couldn't allocate bulk_out_buffer\n");
867                         goto probe_error;
868                 }
869                 usb_fill_bulk_urb(port->write_urb, dev,
870                                 usb_sndbulkpipe(dev,
871                                         endpoint->bEndpointAddress),
872                                 port->bulk_out_buffer, buffer_size,
873                                 serial->type->write_bulk_callback, port);
874         }
875
876         if (serial->type->read_int_callback) {
877                 for (i = 0; i < num_interrupt_in; ++i) {
878                         endpoint = interrupt_in_endpoint[i];
879                         port = serial->port[i];
880                         port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
881                         if (!port->interrupt_in_urb) {
882                                 dev_err(&interface->dev,
883                                                 "No free urbs available\n");
884                                 goto probe_error;
885                         }
886                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
887                         port->interrupt_in_endpointAddress =
888                                                 endpoint->bEndpointAddress;
889                         port->interrupt_in_buffer = kmalloc(buffer_size,
890                                                                 GFP_KERNEL);
891                         if (!port->interrupt_in_buffer) {
892                                 dev_err(&interface->dev,
893                                     "Couldn't allocate interrupt_in_buffer\n");
894                                 goto probe_error;
895                         }
896                         usb_fill_int_urb(port->interrupt_in_urb, dev,
897                                 usb_rcvintpipe(dev,
898                                                 endpoint->bEndpointAddress),
899                                 port->interrupt_in_buffer, buffer_size,
900                                 serial->type->read_int_callback, port,
901                                 endpoint->bInterval);
902                 }
903         } else if (num_interrupt_in) {
904                 dbg("the device claims to support interrupt in transfers, but read_int_callback is not defined");
905         }
906
907         if (serial->type->write_int_callback) {
908                 for (i = 0; i < num_interrupt_out; ++i) {
909                         endpoint = interrupt_out_endpoint[i];
910                         port = serial->port[i];
911                         port->interrupt_out_urb = usb_alloc_urb(0, GFP_KERNEL);
912                         if (!port->interrupt_out_urb) {
913                                 dev_err(&interface->dev,
914                                                 "No free urbs available\n");
915                                 goto probe_error;
916                         }
917                         buffer_size = le16_to_cpu(endpoint->wMaxPacketSize);
918                         port->interrupt_out_size = buffer_size;
919                         port->interrupt_out_endpointAddress =
920                                                 endpoint->bEndpointAddress;
921                         port->interrupt_out_buffer = kmalloc(buffer_size,
922                                                                 GFP_KERNEL);
923                         if (!port->interrupt_out_buffer) {
924                                 dev_err(&interface->dev,
925                                   "Couldn't allocate interrupt_out_buffer\n");
926                                 goto probe_error;
927                         }
928                         usb_fill_int_urb(port->interrupt_out_urb, dev,
929                                 usb_sndintpipe(dev,
930                                                   endpoint->bEndpointAddress),
931                                 port->interrupt_out_buffer, buffer_size,
932                                 serial->type->write_int_callback, port,
933                                 endpoint->bInterval);
934                 }
935         } else if (num_interrupt_out) {
936                 dbg("the device claims to support interrupt out transfers, but write_int_callback is not defined");
937         }
938
939         /* if this device type has an attach function, call it */
940         if (type->attach) {
941                 if (!try_module_get(type->driver.owner)) {
942                         dev_err(&interface->dev,
943                                         "module get failed, exiting\n");
944                         goto probe_error;
945                 }
946                 retval = type->attach(serial);
947                 module_put(type->driver.owner);
948                 if (retval < 0)
949                         goto probe_error;
950                 if (retval > 0) {
951                         /* quietly accept this device, but don't bind to a
952                            serial port as it's about to disappear */
953                         goto exit;
954                 }
955         }
956
957         if (get_free_serial(serial, num_ports, &minor) == NULL) {
958                 dev_err(&interface->dev, "No more free serial devices\n");
959                 goto probe_error;
960         }
961         serial->minor = minor;
962
963         /* register all of the individual ports with the driver core */
964         for (i = 0; i < num_ports; ++i) {
965                 port = serial->port[i];
966                 port->dev.parent = &interface->dev;
967                 port->dev.driver = NULL;
968                 port->dev.bus = &usb_serial_bus_type;
969                 port->dev.release = &port_release;
970
971                 dev_set_name(&port->dev, "ttyUSB%d", port->number);
972                 dbg ("%s - registering %s", __func__, dev_name(&port->dev));
973                 retval = device_register(&port->dev);
974                 if (retval)
975                         dev_err(&port->dev, "Error registering port device, "
976                                 "continuing\n");
977         }
978
979         usb_serial_console_init(debug, minor);
980
981 exit:
982         /* success */
983         usb_set_intfdata(interface, serial);
984         return 0;
985
986 probe_error:
987         for (i = 0; i < num_bulk_in; ++i) {
988                 port = serial->port[i];
989                 if (!port)
990                         continue;
991                 usb_free_urb(port->read_urb);
992                 kfree(port->bulk_in_buffer);
993         }
994         for (i = 0; i < num_bulk_out; ++i) {
995                 port = serial->port[i];
996                 if (!port)
997                         continue;
998                 usb_free_urb(port->write_urb);
999                 kfree(port->bulk_out_buffer);
1000         }
1001         for (i = 0; i < num_interrupt_in; ++i) {
1002                 port = serial->port[i];
1003                 if (!port)
1004                         continue;
1005                 usb_free_urb(port->interrupt_in_urb);
1006                 kfree(port->interrupt_in_buffer);
1007         }
1008         for (i = 0; i < num_interrupt_out; ++i) {
1009                 port = serial->port[i];
1010                 if (!port)
1011                         continue;
1012                 usb_free_urb(port->interrupt_out_urb);
1013                 kfree(port->interrupt_out_buffer);
1014         }
1015
1016         /* free up any memory that we allocated */
1017         for (i = 0; i < serial->num_port_pointers; ++i)
1018                 kfree(serial->port[i]);
1019         kfree(serial);
1020         return -EIO;
1021 }
1022 EXPORT_SYMBOL_GPL(usb_serial_probe);
1023
1024 void usb_serial_disconnect(struct usb_interface *interface)
1025 {
1026         int i;
1027         struct usb_serial *serial = usb_get_intfdata(interface);
1028         struct device *dev = &interface->dev;
1029         struct usb_serial_port *port;
1030
1031         usb_serial_console_disconnect(serial);
1032         dbg("%s", __func__);
1033
1034         mutex_lock(&serial->disc_mutex);
1035         usb_set_intfdata(interface, NULL);
1036         /* must set a flag, to signal subdrivers */
1037         serial->disconnected = 1;
1038         for (i = 0; i < serial->num_ports; ++i) {
1039                 port = serial->port[i];
1040                 if (port) {
1041                         if (port->port.tty)
1042                                 tty_hangup(port->port.tty);
1043                         kill_traffic(port);
1044                 }
1045         }
1046         /* let the last holder of this object
1047          * cause it to be cleaned up */
1048         mutex_unlock(&serial->disc_mutex);
1049         usb_serial_put(serial);
1050         dev_info(dev, "device disconnected\n");
1051 }
1052 EXPORT_SYMBOL_GPL(usb_serial_disconnect);
1053
1054 int usb_serial_suspend(struct usb_interface *intf, pm_message_t message)
1055 {
1056         struct usb_serial *serial = usb_get_intfdata(intf);
1057         struct usb_serial_port *port;
1058         int i, r = 0;
1059
1060         for (i = 0; i < serial->num_ports; ++i) {
1061                 port = serial->port[i];
1062                 if (port)
1063                         kill_traffic(port);
1064         }
1065
1066         if (serial->type->suspend)
1067                 r = serial->type->suspend(serial, message);
1068
1069         return r;
1070 }
1071 EXPORT_SYMBOL(usb_serial_suspend);
1072
1073 int usb_serial_resume(struct usb_interface *intf)
1074 {
1075         struct usb_serial *serial = usb_get_intfdata(intf);
1076
1077         if (serial->type->resume)
1078                 return serial->type->resume(serial);
1079         return 0;
1080 }
1081 EXPORT_SYMBOL(usb_serial_resume);
1082
1083 static const struct tty_operations serial_ops = {
1084         .open =                 serial_open,
1085         .close =                serial_close,
1086         .write =                serial_write,
1087         .write_room =           serial_write_room,
1088         .ioctl =                serial_ioctl,
1089         .set_termios =          serial_set_termios,
1090         .throttle =             serial_throttle,
1091         .unthrottle =           serial_unthrottle,
1092         .break_ctl =            serial_break,
1093         .chars_in_buffer =      serial_chars_in_buffer,
1094         .read_proc =            serial_read_proc,
1095         .tiocmget =             serial_tiocmget,
1096         .tiocmset =             serial_tiocmset,
1097 };
1098
1099 struct tty_driver *usb_serial_tty_driver;
1100
1101 static int __init usb_serial_init(void)
1102 {
1103         int i;
1104         int result;
1105
1106         usb_serial_tty_driver = alloc_tty_driver(SERIAL_TTY_MINORS);
1107         if (!usb_serial_tty_driver)
1108                 return -ENOMEM;
1109
1110         /* Initialize our global data */
1111         for (i = 0; i < SERIAL_TTY_MINORS; ++i)
1112                 serial_table[i] = NULL;
1113
1114         result = bus_register(&usb_serial_bus_type);
1115         if (result) {
1116                 err("%s - registering bus driver failed", __func__);
1117                 goto exit_bus;
1118         }
1119
1120         usb_serial_tty_driver->owner = THIS_MODULE;
1121         usb_serial_tty_driver->driver_name = "usbserial";
1122         usb_serial_tty_driver->name =   "ttyUSB";
1123         usb_serial_tty_driver->major = SERIAL_TTY_MAJOR;
1124         usb_serial_tty_driver->minor_start = 0;
1125         usb_serial_tty_driver->type = TTY_DRIVER_TYPE_SERIAL;
1126         usb_serial_tty_driver->subtype = SERIAL_TYPE_NORMAL;
1127         usb_serial_tty_driver->flags = TTY_DRIVER_REAL_RAW |
1128                                                 TTY_DRIVER_DYNAMIC_DEV;
1129         usb_serial_tty_driver->init_termios = tty_std_termios;
1130         usb_serial_tty_driver->init_termios.c_cflag = B9600 | CS8 | CREAD
1131                                                         | HUPCL | CLOCAL;
1132         usb_serial_tty_driver->init_termios.c_ispeed = 9600;
1133         usb_serial_tty_driver->init_termios.c_ospeed = 9600;
1134         tty_set_operations(usb_serial_tty_driver, &serial_ops);
1135         result = tty_register_driver(usb_serial_tty_driver);
1136         if (result) {
1137                 err("%s - tty_register_driver failed", __func__);
1138                 goto exit_reg_driver;
1139         }
1140
1141         /* register the USB driver */
1142         result = usb_register(&usb_serial_driver);
1143         if (result < 0) {
1144                 err("%s - usb_register failed", __func__);
1145                 goto exit_tty;
1146         }
1147
1148         /* register the generic driver, if we should */
1149         result = usb_serial_generic_register(debug);
1150         if (result < 0) {
1151                 err("%s - registering generic driver failed", __func__);
1152                 goto exit_generic;
1153         }
1154
1155         info(DRIVER_DESC);
1156
1157         return result;
1158
1159 exit_generic:
1160         usb_deregister(&usb_serial_driver);
1161
1162 exit_tty:
1163         tty_unregister_driver(usb_serial_tty_driver);
1164
1165 exit_reg_driver:
1166         bus_unregister(&usb_serial_bus_type);
1167
1168 exit_bus:
1169         err("%s - returning with error %d", __func__, result);
1170         put_tty_driver(usb_serial_tty_driver);
1171         return result;
1172 }
1173
1174
1175 static void __exit usb_serial_exit(void)
1176 {
1177         usb_serial_console_exit();
1178
1179         usb_serial_generic_deregister();
1180
1181         usb_deregister(&usb_serial_driver);
1182         tty_unregister_driver(usb_serial_tty_driver);
1183         put_tty_driver(usb_serial_tty_driver);
1184         bus_unregister(&usb_serial_bus_type);
1185 }
1186
1187
1188 module_init(usb_serial_init);
1189 module_exit(usb_serial_exit);
1190
1191 #define set_to_generic_if_null(type, function)                          \
1192         do {                                                            \
1193                 if (!type->function) {                                  \
1194                         type->function = usb_serial_generic_##function; \
1195                         dbg("Had to override the " #function            \
1196                                 " usb serial operation with the generic one.");\
1197                         }                                               \
1198         } while (0)
1199
1200 static void fixup_generic(struct usb_serial_driver *device)
1201 {
1202         set_to_generic_if_null(device, open);
1203         set_to_generic_if_null(device, write);
1204         set_to_generic_if_null(device, close);
1205         set_to_generic_if_null(device, write_room);
1206         set_to_generic_if_null(device, chars_in_buffer);
1207         set_to_generic_if_null(device, read_bulk_callback);
1208         set_to_generic_if_null(device, write_bulk_callback);
1209         set_to_generic_if_null(device, shutdown);
1210         set_to_generic_if_null(device, resume);
1211 }
1212
1213 int usb_serial_register(struct usb_serial_driver *driver)
1214 {
1215         /* must be called with BKL held */
1216         int retval;
1217
1218         fixup_generic(driver);
1219
1220         if (!driver->description)
1221                 driver->description = driver->driver.name;
1222
1223         /* Add this device to our list of devices */
1224         list_add(&driver->driver_list, &usb_serial_driver_list);
1225
1226         retval = usb_serial_bus_register(driver);
1227         if (retval) {
1228                 err("problem %d when registering driver %s",
1229                                                 retval, driver->description);
1230                 list_del(&driver->driver_list);
1231         } else
1232                 info("USB Serial support registered for %s",
1233                                                 driver->description);
1234
1235         return retval;
1236 }
1237 EXPORT_SYMBOL_GPL(usb_serial_register);
1238
1239
1240 void usb_serial_deregister(struct usb_serial_driver *device)
1241 {
1242         /* must be called with BKL held */
1243         info("USB Serial deregistering driver %s", device->description);
1244         list_del(&device->driver_list);
1245         usb_serial_bus_deregister(device);
1246 }
1247 EXPORT_SYMBOL_GPL(usb_serial_deregister);
1248
1249 /* Module information */
1250 MODULE_AUTHOR(DRIVER_AUTHOR);
1251 MODULE_DESCRIPTION(DRIVER_DESC);
1252 MODULE_LICENSE("GPL");
1253
1254 module_param(debug, bool, S_IRUGO | S_IWUSR);
1255 MODULE_PARM_DESC(debug, "Debug enabled or not");