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