USB serial console support added
[opensuse:kernel.git] / drivers / usb / serial / usbserial.c
1 /*
2  * USB Serial Converter driver
3  *
4  * Copyright (C) 1999 - 2002 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 modify
9  *      it under the terms of the GNU General Public License as published by
10  *      the Free Software Foundation; either version 2 of the License, or
11  *      (at your option) any later version.
12  *
13  * This driver was originally based on the ACM driver by Armin Fuerst (which was 
14  * based on a driver by Brad Keryan)
15  *
16  * See Documentation/usb/usb-serial.txt for more information on using this driver
17  *
18  * (03/27/2002) gkh
19  *      Got USB serial console code working properly and merged into the main
20  *      version of the tree.  Thanks to Randy Dunlap for the initial version
21  *      of this code, and for pushing me to finish it up.
22  *      The USB serial console works with any usb serial driver device.
23  *
24  * (03/21/2002) gkh
25  *      Moved all manipulation of port->open_count into the core.  Now the
26  *      individual driver's open and close functions are called only when the
27  *      first open() and last close() is called.  Making the drivers a bit
28  *      smaller and simpler.
29  *      Fixed a bug if a driver didn't have the owner field set.
30  *
31  * (02/26/2002) gkh
32  *      Moved all locking into the main serial_* functions, instead of having 
33  *      the individual drivers have to grab the port semaphore.  This should
34  *      reduce races.
35  *      Reworked the MOD_INC logic a bit to always increment and decrement, even
36  *      if the generic driver is being used.
37  *
38  * (10/10/2001) gkh
39  *      usb_serial_disconnect() now sets the serial->dev pointer is to NULL to
40  *      help prevent child drivers from accessing the device since it is now
41  *      gone.
42  *
43  * (09/13/2001) gkh
44  *      Moved generic driver initialize after we have registered with the USB
45  *      core.  Thanks to Randy Dunlap for pointing this problem out.
46  *
47  * (07/03/2001) gkh
48  *      Fixed module paramater size.  Thanks to John Brockmeyer for the pointer.
49  *      Fixed vendor and product getting defined through the MODULE_PARM macro
50  *      if the Generic driver wasn't compiled in.
51  *      Fixed problem with generic_shutdown() not being called for drivers that
52  *      don't have a shutdown() function.
53  *
54  * (06/06/2001) gkh
55  *      added evil hack that is needed for the prolific pl2303 device due to the
56  *      crazy way its endpoints are set up.
57  *
58  * (05/30/2001) gkh
59  *      switched from using spinlock to a semaphore, which fixes lots of problems.
60  *
61  * (04/08/2001) gb
62  *      Identify version on module load.
63  *
64  * 2001_02_05 gkh
65  *      Fixed buffer overflows bug with the generic serial driver.  Thanks to
66  *      Todd Squires <squirest@ct0.com> for fixing this.
67  *
68  * (01/10/2001) gkh
69  *      Fixed bug where the generic serial adaptor grabbed _any_ device that was
70  *      offered to it.
71  *
72  * (12/12/2000) gkh
73  *      Removed MOD_INC and MOD_DEC from poll and disconnect functions, and
74  *      moved them to the serial_open and serial_close functions.
75  *      Also fixed bug with there not being a MOD_DEC for the generic driver
76  *      (thanks to Gary Brubaker for finding this.)
77  *
78  * (11/29/2000) gkh
79  *      Small NULL pointer initialization cleanup which saves a bit of disk image
80  *
81  * (11/01/2000) Adam J. Richter
82  *      instead of using idVendor/idProduct pairs, usb serial drivers
83  *      now identify their hardware interest with usb_device_id tables,
84  *      which they usually have anyhow for use with MODULE_DEVICE_TABLE.
85  *
86  * (10/05/2000) gkh
87  *      Fixed bug with urb->dev not being set properly, now that the usb
88  *      core needs it.
89  * 
90  * (09/11/2000) gkh
91  *      Removed DEBUG #ifdefs with call to usb_serial_debug_data
92  *
93  * (08/28/2000) gkh
94  *      Added port_lock to port structure.
95  *      Added locks for SMP safeness to generic driver
96  *      Fixed the ability to open a generic device's port more than once.
97  *
98  * (07/23/2000) gkh
99  *      Added bulk_out_endpointAddress to port structure.
100  *
101  * (07/19/2000) gkh, pberger, and borchers
102  *      Modifications to allow usb-serial drivers to be modules.
103  *
104  * (07/03/2000) gkh
105  *      Added more debugging to serial_ioctl call
106  * 
107  * (06/25/2000) gkh
108  *      Changed generic_write_bulk_callback to not call wake_up_interruptible
109  *      directly, but to have port_softint do it at a safer time.
110  *
111  * (06/23/2000) gkh
112  *      Cleaned up debugging statements in a quest to find UHCI timeout bug.
113  *
114  * (05/22/2000) gkh
115  *      Changed the makefile, enabling the big CONFIG_USB_SERIAL_SOMTHING to be 
116  *      removed from the individual device source files.
117  *
118  * (05/03/2000) gkh
119  *      Added the Digi Acceleport driver from Al Borchers and Peter Berger.
120  * 
121  * (05/02/2000) gkh
122  *      Changed devfs and tty register code to work properly now. This was based on
123  *      the ACM driver changes by Vojtech Pavlik.
124  *
125  * (04/27/2000) Ryan VanderBijl
126  *      Put calls to *_paranoia_checks into one function.
127  * 
128  * (04/23/2000) gkh
129  *      Fixed bug that Randy Dunlap found for Generic devices with no bulk out ports.
130  *      Moved when the startup code printed out the devices that are supported.
131  *
132  * (04/19/2000) gkh
133  *      Added driver for ZyXEL omni.net lcd plus ISDN TA
134  *      Made startup info message specify which drivers were compiled in.
135  *
136  * (04/03/2000) gkh
137  *      Changed the probe process to remove the module unload races.
138  *      Changed where the tty layer gets initialized to have devfs work nicer.
139  *      Added initial devfs support.
140  *
141  * (03/26/2000) gkh
142  *      Split driver up into device specific pieces.
143  * 
144  * (03/19/2000) gkh
145  *      Fixed oops that could happen when device was removed while a program
146  *      was talking to the device.
147  *      Removed the static urbs and now all urbs are created and destroyed
148  *      dynamically.
149  *      Reworked the internal interface. Now everything is based on the 
150  *      usb_serial_port structure instead of the larger usb_serial structure.
151  *      This fixes the bug that a multiport device could not have more than
152  *      one port open at one time.
153  *
154  * (03/17/2000) gkh
155  *      Added config option for debugging messages.
156  *      Added patch for keyspan pda from Brian Warner.
157  *
158  * (03/06/2000) gkh
159  *      Added the keyspan pda code from Brian Warner <warner@lothar.com>
160  *      Moved a bunch of the port specific stuff into its own structure. This
161  *      is in anticipation of the true multiport devices (there's a bug if you
162  *      try to access more than one port of any multiport device right now)
163  *
164  * (02/21/2000) gkh
165  *      Made it so that any serial devices only have to specify which functions
166  *      they want to overload from the generic function calls (great, 
167  *      inheritance in C, in a driver, just what I wanted...)
168  *      Added support for set_termios and ioctl function calls. No drivers take
169  *      advantage of this yet.
170  *      Removed the #ifdef MODULE, now there is no module specific code.
171  *      Cleaned up a few comments in usb-serial.h that were wrong (thanks again
172  *      to Miles Lott).
173  *      Small fix to get_free_serial.
174  *
175  * (02/14/2000) gkh
176  *      Removed the Belkin and Peracom functionality from the driver due to
177  *      the lack of support from the vendor, and me not wanting people to 
178  *      accidenatly buy the device, expecting it to work with Linux.
179  *      Added read_bulk_callback and write_bulk_callback to the type structure
180  *      for the needs of the FTDI and WhiteHEAT driver.
181  *      Changed all reverences to FTDI to FTDI_SIO at the request of Bill
182  *      Ryder.
183  *      Changed the output urb size back to the max endpoint size to make
184  *      the ftdi_sio driver have it easier, and due to the fact that it didn't
185  *      really increase the speed any.
186  *
187  * (02/11/2000) gkh
188  *      Added VISOR_FUNCTION_CONSOLE to the visor startup function. This was a
189  *      patch from Miles Lott (milos@insync.net).
190  *      Fixed bug with not restoring the minor range that a device grabs, if
191  *      the startup function fails (thanks Miles for finding this).
192  *
193  * (02/05/2000) gkh
194  *      Added initial framework for the Keyspan PDA serial converter so that
195  *      Brian Warner has a place to put his code.
196  *      Made the ezusb specific functions generic enough that different
197  *      devices can use them (whiteheat and keyspan_pda both need them).
198  *      Split out a whole bunch of structure and other stuff to a seperate
199  *      usb-serial.h file.
200  *      Made the Visor connection messages a little more understandable, now
201  *      that Miles Lott (milos@insync.net) has gotten the Generic channel to
202  *      work. Also made them always show up in the log file.
203  * 
204  * (01/25/2000) gkh
205  *      Added initial framework for FTDI serial converter so that Bill Ryder
206  *      has a place to put his code.
207  *      Added the vendor specific info from Handspring. Now we can print out
208  *      informational debug messages as well as understand what is happening.
209  *
210  * (01/23/2000) gkh
211  *      Fixed problem of crash when trying to open a port that didn't have a
212  *      device assigned to it. Made the minor node finding a little smarter,
213  *      now it looks to find a continous space for the new device.
214  *
215  * (01/21/2000) gkh
216  *      Fixed bug in visor_startup with patch from Miles Lott (milos@insync.net)
217  *      Fixed get_serial_by_minor which was all messed up for multi port 
218  *      devices. Fixed multi port problem for generic devices. Now the number
219  *      of ports is determined by the number of bulk out endpoints for the
220  *      generic device.
221  *
222  * (01/19/2000) gkh
223  *      Removed lots of cruft that was around from the old (pre urb) driver 
224  *      interface.
225  *      Made the serial_table dynamic. This should save lots of memory when
226  *      the number of minor nodes goes up to 256.
227  *      Added initial support for devices that have more than one port. 
228  *      Added more debugging comments for the Visor, and added a needed 
229  *      set_configuration call.
230  *
231  * (01/17/2000) gkh
232  *      Fixed the WhiteHEAT firmware (my processing tool had a bug)
233  *      and added new debug loader firmware for it.
234  *      Removed the put_char function as it isn't really needed.
235  *      Added visor startup commands as found by the Win98 dump.
236  * 
237  * (01/13/2000) gkh
238  *      Fixed the vendor id for the generic driver to the one I meant it to be.
239  *
240  * (01/12/2000) gkh
241  *      Forget the version numbering...that's pretty useless...
242  *      Made the driver able to be compiled so that the user can select which
243  *      converter they want to use. This allows people who only want the Visor
244  *      support to not pay the memory size price of the WhiteHEAT.
245  *      Fixed bug where the generic driver (idVendor=0000 and idProduct=0000)
246  *      grabbed the root hub. Not good.
247  * 
248  * version 0.4.0 (01/10/2000) gkh
249  *      Added whiteheat.h containing the firmware for the ConnectTech WhiteHEAT
250  *      device. Added startup function to allow firmware to be downloaded to
251  *      a device if it needs to be.
252  *      Added firmware download logic to the WhiteHEAT device.
253  *      Started to add #defines to split up the different drivers for potential
254  *      configuration option.
255  *      
256  * version 0.3.1 (12/30/99) gkh
257  *      Fixed problems with urb for bulk out.
258  *      Added initial support for multiple sets of endpoints. This enables
259  *      the Handspring Visor to be attached successfully. Only the first
260  *      bulk in / bulk out endpoint pair is being used right now.
261  *
262  * version 0.3.0 (12/27/99) gkh
263  *      Added initial support for the Handspring Visor based on a patch from
264  *      Miles Lott (milos@sneety.insync.net)
265  *      Cleaned up the code a bunch and converted over to using urbs only.
266  *
267  * version 0.2.3 (12/21/99) gkh
268  *      Added initial support for the Connect Tech WhiteHEAT converter.
269  *      Incremented the number of ports in expectation of getting the
270  *      WhiteHEAT to work properly (4 ports per connection).
271  *      Added notification on insertion and removal of what port the
272  *      device is/was connected to (and what kind of device it was).
273  *
274  * version 0.2.2 (12/16/99) gkh
275  *      Changed major number to the new allocated number. We're legal now!
276  *
277  * version 0.2.1 (12/14/99) gkh
278  *      Fixed bug that happens when device node is opened when there isn't a
279  *      device attached to it. Thanks to marek@webdesign.no for noticing this.
280  *
281  * version 0.2.0 (11/10/99) gkh
282  *      Split up internals to make it easier to add different types of serial 
283  *      converters to the code.
284  *      Added a "generic" driver that gets it's vendor and product id
285  *      from when the module is loaded. Thanks to David E. Nelson (dnelson@jump.net)
286  *      for the idea and sample code (from the usb scanner driver.)
287  *      Cleared up any licensing questions by releasing it under the GNU GPL.
288  *
289  * version 0.1.2 (10/25/99) gkh
290  *      Fixed bug in detecting device.
291  *
292  * version 0.1.1 (10/05/99) gkh
293  *      Changed the major number to not conflict with anything else.
294  *
295  * version 0.1 (09/28/99) gkh
296  *      Can recognize the two different devices and start up a read from
297  *      device when asked to. Writes also work. No control signals yet, this
298  *      all is vendor specific data (i.e. no spec), also no control for
299  *      different baud rates or other bit settings.
300  *      Currently we are using the same devid as the acm driver. This needs
301  *      to change.
302  * 
303  */
304
305 #include <linux/config.h>
306 #include <linux/kernel.h>
307 #include <linux/sched.h>
308 #include <linux/signal.h>
309 #include <linux/errno.h>
310 #include <linux/poll.h>
311 #include <linux/init.h>
312 #include <linux/slab.h>
313 #include <linux/fcntl.h>
314 #include <linux/tty.h>
315 #include <linux/tty_driver.h>
316 #include <linux/tty_flip.h>
317 #include <linux/module.h>
318 #include <linux/spinlock.h>
319 #include <linux/list.h>
320 #include <linux/smp_lock.h>
321 #include <linux/usb.h>
322
323 #ifdef MODULE
324 #undef CONFIG_USB_SERIAL_CONSOLE
325 #endif
326 #ifdef CONFIG_USB_SERIAL_CONSOLE
327 #include <linux/console.h>
328 #include <linux/serial.h>
329 #endif
330
331 #ifdef CONFIG_USB_SERIAL_DEBUG
332         static int debug = 1;
333 #else
334         static int debug;
335 #endif
336
337 #include "usb-serial.h"
338 #include "pl2303.h"
339
340 /*
341  * Version Information
342  */
343 #define DRIVER_VERSION "v1.4"
344 #define DRIVER_AUTHOR "Greg Kroah-Hartman, greg@kroah.com, http://www.kroah.com/linux-usb/"
345 #define DRIVER_DESC "USB Serial Driver core"
346
347 /* function prototypes for a "generic" type serial converter (no flow control, not all endpoints needed) */
348 /* need to always compile these in, as some of the other devices use these functions as their own. */
349 /* if a driver does not provide a function pointer, the generic function will be called. */
350 static int  generic_open                (struct usb_serial_port *port, struct file *filp);
351 static void generic_close               (struct usb_serial_port *port, struct file *filp);
352 static int  generic_write               (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
353 static int  generic_write_room          (struct usb_serial_port *port);
354 static int  generic_chars_in_buffer     (struct usb_serial_port *port);
355 static void generic_read_bulk_callback  (struct urb *urb);
356 static void generic_write_bulk_callback (struct urb *urb);
357 static void generic_shutdown            (struct usb_serial *serial);
358
359
360 #ifdef CONFIG_USB_SERIAL_GENERIC
361 static __u16    vendor  = 0x05f9;
362 static __u16    product = 0xffff;
363
364 static struct usb_device_id generic_device_ids[2]; /* Initially all zeroes. */
365
366 /* All of the device info needed for the Generic Serial Converter */
367 static struct usb_serial_device_type generic_device = {
368         owner:                  THIS_MODULE,
369         name:                   "Generic",
370         id_table:               generic_device_ids,
371         num_interrupt_in:       NUM_DONT_CARE,
372         num_bulk_in:            NUM_DONT_CARE,
373         num_bulk_out:           NUM_DONT_CARE,
374         num_ports:              1,
375         shutdown:               generic_shutdown,
376 };
377 #endif
378
379
380 /* local function prototypes */
381 static int  serial_open (struct tty_struct *tty, struct file * filp);
382 static void serial_close (struct tty_struct *tty, struct file * filp);
383 static int  serial_write (struct tty_struct * tty, int from_user, const unsigned char *buf, int count);
384 static int  serial_write_room (struct tty_struct *tty);
385 static int  serial_chars_in_buffer (struct tty_struct *tty);
386 static void serial_throttle (struct tty_struct * tty);
387 static void serial_unthrottle (struct tty_struct * tty);
388 static int  serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
389 static void serial_set_termios (struct tty_struct *tty, struct termios * old);
390 static void serial_shutdown (struct usb_serial *serial);
391
392 static void * usb_serial_probe(struct usb_device *dev, unsigned int ifnum,
393                                const struct usb_device_id *id);
394 static void usb_serial_disconnect(struct usb_device *dev, void *ptr);
395
396 static struct usb_driver usb_serial_driver = {
397         name:           "serial",
398         probe:          usb_serial_probe,
399         disconnect:     usb_serial_disconnect,
400         id_table:       NULL,                   /* check all devices */
401 };
402
403 /* There is no MODULE_DEVICE_TABLE for usbserial.c.  Instead
404    the MODULE_DEVICE_TABLE declarations in each serial driver
405    cause the "hotplug" program to pull in whatever module is necessary
406    via modprobe, and modprobe will load usbserial because the serial
407    drivers depend on it.
408 */
409
410
411 static int                      serial_refcount;
412 static struct tty_driver        serial_tty_driver;
413 static struct tty_struct *      serial_tty[SERIAL_TTY_MINORS];
414 static struct termios *         serial_termios[SERIAL_TTY_MINORS];
415 static struct termios *         serial_termios_locked[SERIAL_TTY_MINORS];
416 static struct usb_serial        *serial_table[SERIAL_TTY_MINORS];       /* initially all NULL */
417 static LIST_HEAD(usb_serial_driver_list);
418
419 #ifdef CONFIG_USB_SERIAL_CONSOLE
420 struct usbcons_info {
421         int                     magic;
422         int                     break_flag;
423         struct usb_serial_port  *port;
424 };
425
426 static struct usbcons_info usbcons_info;
427 static struct console usbcons;
428 #endif /* CONFIG_USB_SERIAL_CONSOLE */
429
430 static struct usb_serial *get_serial_by_minor (unsigned int minor)
431 {
432         return serial_table[minor];
433 }
434
435 static struct usb_serial *get_free_serial (int num_ports, unsigned int *minor)
436 {
437         struct usb_serial *serial = NULL;
438         unsigned int i, j;
439         int good_spot;
440
441         dbg(__FUNCTION__ " %d", num_ports);
442
443         *minor = 0;
444         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
445                 if (serial_table[i])
446                         continue;
447
448                 good_spot = 1;
449                 for (j = 1; j <= num_ports-1; ++j)
450                         if (serial_table[i+j])
451                                 good_spot = 0;
452                 if (good_spot == 0)
453                         continue;
454                         
455                 if (!(serial = kmalloc(sizeof(struct usb_serial), GFP_KERNEL))) {
456                         err(__FUNCTION__ " - Out of memory");
457                         return NULL;
458                 }
459                 memset(serial, 0, sizeof(struct usb_serial));
460                 serial->magic = USB_SERIAL_MAGIC;
461                 serial_table[i] = serial;
462                 *minor = i;
463                 dbg(__FUNCTION__ " - minor base = %d", *minor);
464                 for (i = *minor+1; (i < (*minor + num_ports)) && (i < SERIAL_TTY_MINORS); ++i)
465                         serial_table[i] = serial;
466                 return serial;
467         }
468         return NULL;
469 }
470
471 static void return_serial (struct usb_serial *serial)
472 {
473         int i;
474
475         dbg(__FUNCTION__);
476
477         if (serial == NULL)
478                 return;
479
480         for (i = 0; i < serial->num_ports; ++i) {
481                 serial_table[serial->minor + i] = NULL;
482         }
483
484         return;
485 }
486
487 #ifdef USES_EZUSB_FUNCTIONS
488 /* EZ-USB Control and Status Register.  Bit 0 controls 8051 reset */
489 #define CPUCS_REG    0x7F92
490
491 int ezusb_writememory (struct usb_serial *serial, int address, unsigned char *data, int length, __u8 bRequest)
492 {
493         int result;
494         unsigned char *transfer_buffer;
495
496         /* dbg("ezusb_writememory %x, %d", address, length); */
497         if (!serial->dev) {
498                 dbg(__FUNCTION__ " - no physical device present, failing.");
499                 return -ENODEV;
500         }
501
502         transfer_buffer =  kmalloc (length, GFP_KERNEL);
503         if (!transfer_buffer) {
504                 err(__FUNCTION__ " - kmalloc(%d) failed.", length);
505                 return -ENOMEM;
506         }
507         memcpy (transfer_buffer, data, length);
508         result = usb_control_msg (serial->dev, usb_sndctrlpipe(serial->dev, 0), bRequest, 0x40, address, 0, transfer_buffer, length, 300);
509         kfree (transfer_buffer);
510         return result;
511 }
512
513 int ezusb_set_reset (struct usb_serial *serial, unsigned char reset_bit)
514 {
515         int     response;
516         dbg(__FUNCTION__ " - %d", reset_bit);
517         response = ezusb_writememory (serial, CPUCS_REG, &reset_bit, 1, 0xa0);
518         if (response < 0) {
519                 err(__FUNCTION__ "- %d failed", reset_bit);
520         }
521         return response;
522 }
523
524 #endif  /* USES_EZUSB_FUNCTIONS */
525
526 /*****************************************************************************
527  * Driver tty interface functions
528  *****************************************************************************/
529 static int serial_open (struct tty_struct *tty, struct file * filp)
530 {
531         struct usb_serial *serial;
532         struct usb_serial_port *port;
533         unsigned int portNumber;
534         int retval = 0;
535         
536         dbg(__FUNCTION__);
537
538         /* initialize the pointer incase something fails */
539         tty->driver_data = NULL;
540
541         /* get the serial object associated with this tty pointer */
542         serial = get_serial_by_minor (minor(tty->device));
543
544         if (serial_paranoia_check (serial, __FUNCTION__))
545                 return -ENODEV;
546
547         /* set up our port structure making the tty driver remember our port object, and us it */
548         portNumber = minor(tty->device) - serial->minor;
549         port = &serial->port[portNumber];
550         tty->driver_data = port;
551
552         down (&port->sem);
553         port->tty = tty;
554          
555         /* lock this module before we call it */
556         if (serial->type->owner)
557                 __MOD_INC_USE_COUNT(serial->type->owner);
558
559         ++port->open_count;
560         if (port->open_count == 1) {
561                 /* only call the device specific open if this 
562                  * is the first time the port is opened */
563                 if (serial->type->open)
564                         retval = serial->type->open(port, filp);
565                 else
566                         retval = generic_open(port, filp);
567         }
568
569         if (retval) {
570                 port->open_count = 0;
571                 if (serial->type->owner)
572                         __MOD_DEC_USE_COUNT(serial->type->owner);
573         }
574
575         up (&port->sem);
576         return retval;
577 }
578
579 static void serial_close(struct tty_struct *tty, struct file * filp)
580 {
581         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
582         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
583
584         if (!serial)
585                 return;
586
587         down (&port->sem);
588
589         dbg(__FUNCTION__ " - port %d", port->number);
590
591         if (tty->driver_data == NULL) {
592                 /* disconnect beat us to the punch here, so handle it gracefully */
593                 goto exit;
594         }
595         if (!port->open_count) {
596                 dbg (__FUNCTION__ " - port not opened");
597                 goto exit_no_mod_dec;
598         }
599
600         --port->open_count;
601         if (port->open_count <= 0) {
602                 /* only call the device specific close if this 
603                  * port is being closed by the last owner */
604                 if (serial->type->close)
605                         serial->type->close(port, filp);
606                 else
607                         generic_close(port, filp);
608                 port->open_count = 0;
609         }
610
611 exit:
612         if (serial->type->owner)
613                 __MOD_DEC_USE_COUNT(serial->type->owner);
614
615 exit_no_mod_dec:
616         up (&port->sem);
617 }
618
619 static int serial_write (struct tty_struct * tty, int from_user, const unsigned char *buf, int count)
620 {
621         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
622         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
623         int retval = -EINVAL;
624
625         if (!serial)
626                 return -ENODEV;
627
628         down (&port->sem);
629
630         dbg(__FUNCTION__ " - port %d, %d byte(s)", port->number, count);
631
632         if (!port->open_count) {
633                 dbg (__FUNCTION__ " - port not opened");
634                 goto exit;
635         }
636
637         /* pass on to the driver specific version of this function if it is available */
638         if (serial->type->write)
639                 retval = serial->type->write(port, from_user, buf, count);
640         else
641                 retval = generic_write(port, from_user, buf, count);
642
643 exit:
644         up (&port->sem);
645         return retval;
646 }
647
648 static int serial_write_room (struct tty_struct *tty) 
649 {
650         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
651         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
652         int retval = -EINVAL;
653
654         if (!serial)
655                 return -ENODEV;
656
657         down (&port->sem);
658
659         dbg(__FUNCTION__ " - port %d", port->number);
660
661         if (!port->open_count) {
662                 dbg (__FUNCTION__ " - port not open");
663                 goto exit;
664         }
665
666         /* pass on to the driver specific version of this function if it is available */
667         if (serial->type->write_room)
668                 retval = serial->type->write_room(port);
669         else
670                 retval = generic_write_room(port);
671
672 exit:
673         up (&port->sem);
674         return retval;
675 }
676
677 static int serial_chars_in_buffer (struct tty_struct *tty) 
678 {
679         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
680         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
681         int retval = -EINVAL;
682
683         if (!serial)
684                 return -ENODEV;
685
686         down (&port->sem);
687
688         dbg(__FUNCTION__ " - port %d", port->number);
689
690         if (!port->open_count) {
691                 dbg (__FUNCTION__ " - port not open");
692                 goto exit;
693         }
694
695         /* pass on to the driver specific version of this function if it is available */
696         if (serial->type->chars_in_buffer)
697                 retval = serial->type->chars_in_buffer(port);
698         else
699                 retval = generic_chars_in_buffer(port);
700
701 exit:
702         up (&port->sem);
703         return retval;
704 }
705
706 static void serial_throttle (struct tty_struct * tty)
707 {
708         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
709         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
710
711         if (!serial)
712                 return;
713
714         down (&port->sem);
715
716         dbg(__FUNCTION__ " - port %d", port->number);
717
718         if (!port->open_count) {
719                 dbg (__FUNCTION__ " - port not open");
720                 goto exit;
721         }
722
723         /* pass on to the driver specific version of this function */
724         if (serial->type->throttle)
725                 serial->type->throttle(port);
726
727 exit:
728         up (&port->sem);
729 }
730
731 static void serial_unthrottle (struct tty_struct * tty)
732 {
733         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
734         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
735
736         if (!serial)
737                 return;
738
739         down (&port->sem);
740
741         dbg(__FUNCTION__ " - port %d", port->number);
742
743         if (!port->open_count) {
744                 dbg (__FUNCTION__ " - port not open");
745                 goto exit;
746         }
747
748         /* pass on to the driver specific version of this function */
749         if (serial->type->unthrottle)
750                 serial->type->unthrottle(port);
751
752 exit:
753         up (&port->sem);
754 }
755
756 static int serial_ioctl (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg)
757 {
758         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
759         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
760         int retval = -ENODEV;
761
762         if (!serial)
763                 return -ENODEV;
764
765         down (&port->sem);
766
767         dbg(__FUNCTION__ " - port %d, cmd 0x%.4x", port->number, cmd);
768
769         if (!port->open_count) {
770                 dbg (__FUNCTION__ " - port not open");
771                 goto exit;
772         }
773
774         /* pass on to the driver specific version of this function if it is available */
775         if (serial->type->ioctl)
776                 retval = serial->type->ioctl(port, file, cmd, arg);
777         else
778                 retval = -ENOIOCTLCMD;
779
780 exit:
781         up (&port->sem);
782         return retval;
783 }
784
785 static void serial_set_termios (struct tty_struct *tty, struct termios * old)
786 {
787         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
788         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
789
790         if (!serial)
791                 return;
792
793         down (&port->sem);
794
795         dbg(__FUNCTION__ " - port %d", port->number);
796
797         if (!port->open_count) {
798                 dbg (__FUNCTION__ " - port not open");
799                 goto exit;
800         }
801
802         /* pass on to the driver specific version of this function if it is available */
803         if (serial->type->set_termios)
804                 serial->type->set_termios(port, old);
805
806 exit:
807         up (&port->sem);
808 }
809
810 static void serial_break (struct tty_struct *tty, int break_state)
811 {
812         struct usb_serial_port *port = (struct usb_serial_port *) tty->driver_data;
813         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
814
815         if (!serial)
816                 return;
817
818         down (&port->sem);
819
820         dbg(__FUNCTION__ " - port %d", port->number);
821
822         if (!port->open_count) {
823                 dbg (__FUNCTION__ " - port not open");
824                 goto exit;
825         }
826
827         /* pass on to the driver specific version of this function if it is available */
828         if (serial->type->break_ctl)
829                 serial->type->break_ctl(port, break_state);
830
831 exit:
832         up (&port->sem);
833 }
834
835 static void serial_shutdown (struct usb_serial *serial)
836 {
837         dbg(__FUNCTION__);
838
839         if (serial->type->shutdown)
840                 serial->type->shutdown(serial);
841         else
842                 generic_shutdown(serial);
843 }
844
845 /*****************************************************************************
846  * generic devices specific driver functions
847  *****************************************************************************/
848 static int generic_open (struct usb_serial_port *port, struct file *filp)
849 {
850         struct usb_serial *serial = port->serial;
851         int result = 0;
852
853         if (port_paranoia_check (port, __FUNCTION__))
854                 return -ENODEV;
855
856         dbg(__FUNCTION__ " - port %d", port->number);
857
858         /* force low_latency on so that our tty_push actually forces the data through, 
859            otherwise it is scheduled, and with high data rates (like with OHCI) data
860            can get lost. */
861         if (port->tty)
862                 port->tty->low_latency = 1;
863
864         /* if we have a bulk interrupt, start reading from it */
865         if (serial->num_bulk_in) {
866                 /* Start reading from the device */
867                 usb_fill_bulk_urb (port->read_urb, serial->dev,
868                                    usb_rcvbulkpipe(serial->dev, port->bulk_in_endpointAddress),
869                                    port->read_urb->transfer_buffer,
870                                    port->read_urb->transfer_buffer_length,
871                                    ((serial->type->read_bulk_callback) ?
872                                      serial->type->read_bulk_callback :
873                                      generic_read_bulk_callback),
874                                    port);
875                 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
876                 if (result)
877                         err(__FUNCTION__ " - failed resubmitting read urb, error %d", result);
878         }
879
880         return result;
881 }
882
883 static void generic_cleanup (struct usb_serial_port *port)
884 {
885         struct usb_serial *serial = port->serial;
886
887         dbg(__FUNCTION__ " - port %d", port->number);
888
889         if (serial->dev) {
890                 /* shutdown any bulk reads that might be going on */
891                 if (serial->num_bulk_out)
892                         usb_unlink_urb (port->write_urb);
893                 if (serial->num_bulk_in)
894                         usb_unlink_urb (port->read_urb);
895         }
896 }
897
898 static void generic_close (struct usb_serial_port *port, struct file * filp)
899 {
900         dbg(__FUNCTION__ " - port %d", port->number);
901         generic_cleanup (port);
902 }
903
904 static int generic_write (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count)
905 {
906         struct usb_serial *serial = port->serial;
907         int result;
908
909         dbg(__FUNCTION__ " - port %d", port->number);
910
911         if (count == 0) {
912                 dbg(__FUNCTION__ " - write request of 0 bytes");
913                 return (0);
914         }
915
916         /* only do something if we have a bulk out endpoint */
917         if (serial->num_bulk_out) {
918                 if (port->write_urb->status == -EINPROGRESS) {
919                         dbg (__FUNCTION__ " - already writing");
920                         return (0);
921                 }
922
923                 count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
924
925                 if (from_user) {
926                         if (copy_from_user(port->write_urb->transfer_buffer, buf, count))
927                                 return -EFAULT;
928                 }
929                 else {
930                         memcpy (port->write_urb->transfer_buffer, buf, count);
931                 }
932
933                 usb_serial_debug_data (__FILE__, __FUNCTION__, count, port->write_urb->transfer_buffer);
934
935                 /* set up our urb */
936                 usb_fill_bulk_urb (port->write_urb, serial->dev,
937                                    usb_sndbulkpipe (serial->dev,
938                                                     port->bulk_out_endpointAddress),
939                                    port->write_urb->transfer_buffer, count,
940                                    ((serial->type->write_bulk_callback) ? 
941                                      serial->type->write_bulk_callback :
942                                      generic_write_bulk_callback), port);
943
944                 /* send the data out the bulk port */
945                 result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
946                 if (result)
947                         err(__FUNCTION__ " - failed submitting write urb, error %d", result);
948                 else
949                         result = count;
950
951                 return result;
952         }
953
954         /* no bulk out, so return 0 bytes written */
955         return (0);
956 }
957
958 static int generic_write_room (struct usb_serial_port *port)
959 {
960         struct usb_serial *serial = port->serial;
961         int room = 0;
962
963         dbg(__FUNCTION__ " - port %d", port->number);
964         
965         if (serial->num_bulk_out) {
966                 if (port->write_urb->status != -EINPROGRESS)
967                         room = port->bulk_out_size;
968         }
969
970         dbg(__FUNCTION__ " - returns %d", room);
971         return (room);
972 }
973
974 static int generic_chars_in_buffer (struct usb_serial_port *port)
975 {
976         struct usb_serial *serial = port->serial;
977         int chars = 0;
978
979         dbg(__FUNCTION__ " - port %d", port->number);
980
981         if (serial->num_bulk_out) {
982                 if (port->write_urb->status == -EINPROGRESS)
983                         chars = port->write_urb->transfer_buffer_length;
984         }
985
986         dbg (__FUNCTION__ " - returns %d", chars);
987         return (chars);
988 }
989
990 static void generic_read_bulk_callback (struct urb *urb)
991 {
992         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
993         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
994         struct tty_struct *tty;
995         unsigned char *data = urb->transfer_buffer;
996         int i;
997         int result;
998
999         dbg(__FUNCTION__ " - port %d", port->number);
1000
1001         if (!serial) {
1002                 dbg(__FUNCTION__ " - bad serial pointer, exiting");
1003                 return;
1004         }
1005
1006         if (urb->status) {
1007                 dbg(__FUNCTION__ " - nonzero read bulk status received: %d", urb->status);
1008                 return;
1009         }
1010
1011         usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
1012
1013         tty = port->tty;
1014         if (tty && urb->actual_length) {
1015                 for (i = 0; i < urb->actual_length ; ++i) {
1016                         /* if we insert more than TTY_FLIPBUF_SIZE characters, we drop them. */
1017                         if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1018                                 tty_flip_buffer_push(tty);
1019                         }
1020                         /* this doesn't actually push the data through unless tty->low_latency is set */
1021                         tty_insert_flip_char(tty, data[i], 0);
1022                 }
1023                 tty_flip_buffer_push(tty);
1024         }
1025
1026         /* Continue trying to always read  */
1027         usb_fill_bulk_urb (port->read_urb, serial->dev,
1028                            usb_rcvbulkpipe (serial->dev,
1029                                             port->bulk_in_endpointAddress),
1030                            port->read_urb->transfer_buffer,
1031                            port->read_urb->transfer_buffer_length,
1032                            ((serial->type->read_bulk_callback) ? 
1033                              serial->type->read_bulk_callback : 
1034                              generic_read_bulk_callback), port);
1035         result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1036         if (result)
1037                 err(__FUNCTION__ " - failed resubmitting read urb, error %d", result);
1038 }
1039
1040 static void generic_write_bulk_callback (struct urb *urb)
1041 {
1042         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1043         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
1044
1045         dbg(__FUNCTION__ " - port %d", port->number);
1046
1047         if (!serial) {
1048                 dbg(__FUNCTION__ " - bad serial pointer, exiting");
1049                 return;
1050         }
1051
1052         if (urb->status) {
1053                 dbg(__FUNCTION__ " - nonzero write bulk status received: %d", urb->status);
1054                 return;
1055         }
1056
1057         queue_task(&port->tqueue, &tq_immediate);
1058         mark_bh(IMMEDIATE_BH);
1059
1060         return;
1061 }
1062
1063 static void generic_shutdown (struct usb_serial *serial)
1064 {
1065         int i;
1066
1067         dbg (__FUNCTION__);
1068
1069         /* stop reads and writes on all ports */
1070         for (i=0; i < serial->num_ports; ++i) {
1071                 generic_cleanup (&serial->port[i]);
1072         }
1073 }
1074
1075 static void port_softint(void *private)
1076 {
1077         struct usb_serial_port *port = (struct usb_serial_port *)private;
1078         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
1079         struct tty_struct *tty;
1080
1081         dbg(__FUNCTION__ " - port %d", port->number);
1082         
1083         if (!serial)
1084                 return;
1085
1086         tty = port->tty;
1087         if (!tty)
1088                 return;
1089
1090         if ((tty->flags & (1 << TTY_DO_WRITE_WAKEUP)) && tty->ldisc.write_wakeup) {
1091                 dbg(__FUNCTION__ " - write wakeup call.");
1092                 (tty->ldisc.write_wakeup)(tty);
1093         }
1094
1095         wake_up_interruptible(&tty->write_wait);
1096 }
1097
1098 static void * usb_serial_probe(struct usb_device *dev, unsigned int ifnum,
1099                                const struct usb_device_id *id)
1100 {
1101         struct usb_serial *serial = NULL;
1102         struct usb_serial_port *port;
1103         struct usb_interface *interface;
1104         struct usb_interface_descriptor *iface_desc;
1105         struct usb_endpoint_descriptor *endpoint;
1106         struct usb_endpoint_descriptor *interrupt_in_endpoint[MAX_NUM_PORTS];
1107         struct usb_endpoint_descriptor *bulk_in_endpoint[MAX_NUM_PORTS];
1108         struct usb_endpoint_descriptor *bulk_out_endpoint[MAX_NUM_PORTS];
1109         struct usb_serial_device_type *type = NULL;
1110         struct list_head *tmp;
1111         int retval;
1112         int found;
1113         int minor;
1114         int buffer_size;
1115         int i;
1116         int num_interrupt_in = 0;
1117         int num_bulk_in = 0;
1118         int num_bulk_out = 0;
1119         int num_ports;
1120         int max_endpoints;
1121         const struct usb_device_id *id_pattern = NULL;
1122
1123         /* loop through our list of known serial converters, and see if this
1124            device matches. */
1125         found = 0;
1126         interface = &dev->actconfig->interface[ifnum];
1127         list_for_each (tmp, &usb_serial_driver_list) {
1128                 type = list_entry(tmp, struct usb_serial_device_type, driver_list);
1129                 id_pattern = usb_match_id(dev, interface, type->id_table);
1130                 if (id_pattern != NULL) {
1131                         dbg("descriptor matches");
1132                         found = 1;
1133                         break;
1134                 }
1135         }
1136         if (!found) {
1137                 /* no match */
1138                 dbg("none matched");
1139                 return(NULL);
1140         }
1141
1142         /* descriptor matches, let's find the endpoints needed */
1143         /* check out the endpoints */
1144         iface_desc = &interface->altsetting[0];
1145         for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
1146                 endpoint = &iface_desc->endpoint[i];
1147                 
1148                 if ((endpoint->bEndpointAddress & 0x80) &&
1149                     ((endpoint->bmAttributes & 3) == 0x02)) {
1150                         /* we found a bulk in endpoint */
1151                         dbg("found bulk in");
1152                         bulk_in_endpoint[num_bulk_in] = endpoint;
1153                         ++num_bulk_in;
1154                 }
1155
1156                 if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
1157                     ((endpoint->bmAttributes & 3) == 0x02)) {
1158                         /* we found a bulk out endpoint */
1159                         dbg("found bulk out");
1160                         bulk_out_endpoint[num_bulk_out] = endpoint;
1161                         ++num_bulk_out;
1162                 }
1163                 
1164                 if ((endpoint->bEndpointAddress & 0x80) &&
1165                     ((endpoint->bmAttributes & 3) == 0x03)) {
1166                         /* we found a interrupt in endpoint */
1167                         dbg("found interrupt in");
1168                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
1169                         ++num_interrupt_in;
1170                 }
1171         }
1172
1173 #if defined(CONFIG_USB_SERIAL_PL2303) || defined(CONFIG_USB_SERIAL_PL2303_MODULE)
1174         /* BEGIN HORRIBLE HACK FOR PL2303 */ 
1175         /* this is needed due to the looney way its endpoints are set up */
1176         if (ifnum == 1) {
1177                 if (((dev->descriptor.idVendor == PL2303_VENDOR_ID) &&
1178                      (dev->descriptor.idProduct == PL2303_PRODUCT_ID)) ||
1179                     ((dev->descriptor.idVendor == ATEN_VENDOR_ID) &&
1180                      (dev->descriptor.idProduct == ATEN_PRODUCT_ID))) {
1181                         /* check out the endpoints of the other interface*/
1182                         interface = &dev->actconfig->interface[ifnum ^ 1];
1183                         iface_desc = &interface->altsetting[0];
1184                         for (i = 0; i < iface_desc->bNumEndpoints; ++i) {
1185                                 endpoint = &iface_desc->endpoint[i];
1186                                 if ((endpoint->bEndpointAddress & 0x80) &&
1187                                     ((endpoint->bmAttributes & 3) == 0x03)) {
1188                                         /* we found a interrupt in endpoint */
1189                                         dbg("found interrupt in for Prolific device on separate interface");
1190                                         interrupt_in_endpoint[num_interrupt_in] = endpoint;
1191                                         ++num_interrupt_in;
1192                                 }
1193                         }
1194                 }
1195         }
1196         /* END HORRIBLE HACK FOR PL2303 */
1197 #endif
1198
1199         /* found all that we need */
1200         info("%s converter detected", type->name);
1201
1202 #ifdef CONFIG_USB_SERIAL_GENERIC
1203         if (type == &generic_device) {
1204                 num_ports = num_bulk_out;
1205                 if (num_ports == 0) {
1206                         err("Generic device with no bulk out, not allowed.");
1207                         return NULL;
1208                 }
1209         } else
1210 #endif
1211                 num_ports = type->num_ports;
1212
1213         serial = get_free_serial (num_ports, &minor);
1214         if (serial == NULL) {
1215                 err("No more free serial devices");
1216                 return NULL;
1217         }
1218
1219         serial->dev = dev;
1220         serial->type = type;
1221         serial->interface = interface;
1222         serial->minor = minor;
1223         serial->num_ports = num_ports;
1224         serial->num_bulk_in = num_bulk_in;
1225         serial->num_bulk_out = num_bulk_out;
1226         serial->num_interrupt_in = num_interrupt_in;
1227         serial->vendor = dev->descriptor.idVendor;
1228         serial->product = dev->descriptor.idProduct;
1229
1230         /* if this device type has a startup function, call it */
1231         if (type->startup) {
1232                 if (type->owner)
1233                         __MOD_INC_USE_COUNT(type->owner);
1234                 retval = type->startup (serial);
1235                 if (type->owner)
1236                         __MOD_DEC_USE_COUNT(type->owner);
1237                 if (retval)
1238                         goto probe_error;
1239         }
1240
1241         /* set up the endpoint information */
1242         for (i = 0; i < num_bulk_in; ++i) {
1243                 endpoint = bulk_in_endpoint[i];
1244                 port = &serial->port[i];
1245                 port->read_urb = usb_alloc_urb (0, GFP_KERNEL);
1246                 if (!port->read_urb) {
1247                         err("No free urbs available");
1248                         goto probe_error;
1249                 }
1250                 buffer_size = endpoint->wMaxPacketSize;
1251                 port->bulk_in_endpointAddress = endpoint->bEndpointAddress;
1252                 port->bulk_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1253                 if (!port->bulk_in_buffer) {
1254                         err("Couldn't allocate bulk_in_buffer");
1255                         goto probe_error;
1256                 }
1257                 usb_fill_bulk_urb (port->read_urb, dev,
1258                                    usb_rcvbulkpipe (dev,
1259                                                     endpoint->bEndpointAddress),
1260                                    port->bulk_in_buffer, buffer_size,
1261                                    ((serial->type->read_bulk_callback) ? 
1262                                      serial->type->read_bulk_callback : 
1263                                      generic_read_bulk_callback),
1264                                    port);
1265         }
1266
1267         for (i = 0; i < num_bulk_out; ++i) {
1268                 endpoint = bulk_out_endpoint[i];
1269                 port = &serial->port[i];
1270                 port->write_urb = usb_alloc_urb(0, GFP_KERNEL);
1271                 if (!port->write_urb) {
1272                         err("No free urbs available");
1273                         goto probe_error;
1274                 }
1275                 buffer_size = endpoint->wMaxPacketSize;
1276                 port->bulk_out_size = buffer_size;
1277                 port->bulk_out_endpointAddress = endpoint->bEndpointAddress;
1278                 port->bulk_out_buffer = kmalloc (buffer_size, GFP_KERNEL);
1279                 if (!port->bulk_out_buffer) {
1280                         err("Couldn't allocate bulk_out_buffer");
1281                         goto probe_error;
1282                 }
1283                 usb_fill_bulk_urb (port->write_urb, dev,
1284                                    usb_sndbulkpipe (dev,
1285                                                     endpoint->bEndpointAddress),
1286                                    port->bulk_out_buffer, buffer_size, 
1287                                    ((serial->type->write_bulk_callback) ? 
1288                                      serial->type->write_bulk_callback : 
1289                                      generic_write_bulk_callback),
1290                                    port);
1291         }
1292
1293         for (i = 0; i < num_interrupt_in; ++i) {
1294                 endpoint = interrupt_in_endpoint[i];
1295                 port = &serial->port[i];
1296                 port->interrupt_in_urb = usb_alloc_urb(0, GFP_KERNEL);
1297                 if (!port->interrupt_in_urb) {
1298                         err("No free urbs available");
1299                         goto probe_error;
1300                 }
1301                 buffer_size = endpoint->wMaxPacketSize;
1302                 port->interrupt_in_endpointAddress = endpoint->bEndpointAddress;
1303                 port->interrupt_in_buffer = kmalloc (buffer_size, GFP_KERNEL);
1304                 if (!port->interrupt_in_buffer) {
1305                         err("Couldn't allocate interrupt_in_buffer");
1306                         goto probe_error;
1307                 }
1308                 usb_fill_int_urb (port->interrupt_in_urb, dev, 
1309                                   usb_rcvintpipe (dev,
1310                                                   endpoint->bEndpointAddress),
1311                                   port->interrupt_in_buffer, buffer_size, 
1312                                   serial->type->read_int_callback, port, 
1313                                   endpoint->bInterval);
1314         }
1315
1316         /* initialize some parts of the port structures */
1317         /* we don't use num_ports here cauz some devices have more endpoint pairs than ports */
1318         max_endpoints = max(num_bulk_in, num_bulk_out);
1319         max_endpoints = max(max_endpoints, num_interrupt_in);
1320         max_endpoints = max(max_endpoints, (int)serial->num_ports);
1321         dbg (__FUNCTION__ " - setting up %d port structures for this device", max_endpoints);
1322         for (i = 0; i < max_endpoints; ++i) {
1323                 port = &serial->port[i];
1324                 port->number = i + serial->minor;
1325                 port->serial = serial;
1326                 port->magic = USB_SERIAL_PORT_MAGIC;
1327                 port->tqueue.routine = port_softint;
1328                 port->tqueue.data = port;
1329                 init_MUTEX (&port->sem);
1330         }
1331
1332         /* initialize the devfs nodes for this device and let the user know what ports we are bound to */
1333         for (i = 0; i < serial->num_ports; ++i) {
1334                 tty_register_devfs (&serial_tty_driver, 0, serial->port[i].number);
1335                 info("%s converter now attached to ttyUSB%d (or usb/tts/%d for devfs)", 
1336                      type->name, serial->port[i].number, serial->port[i].number);
1337         }
1338
1339 #ifdef CONFIG_USB_SERIAL_CONSOLE
1340         if (minor == 0) {
1341                 /* 
1342                  * Call register_console() if this is the first device plugged
1343                  * in.  If we call it earlier, then the callback to
1344                  * console_setup() will fail, as there is not a device seen by
1345                  * the USB subsystem yet.
1346                  */
1347                 /*
1348                  * Register console.
1349                  * NOTES:
1350                  * console_setup() is called (back) immediately (from register_console).
1351                  * console_write() is called immediately from register_console iff
1352                  * CON_PRINTBUFFER is set in flags.
1353                  */
1354                 dbg ("registering the USB serial console.");
1355                 register_console(&usbcons);
1356         }
1357 #endif
1358
1359         return serial; /* success */
1360
1361
1362 probe_error:
1363         for (i = 0; i < num_bulk_in; ++i) {
1364                 port = &serial->port[i];
1365                 if (port->read_urb)
1366                         usb_free_urb (port->read_urb);
1367                 if (port->bulk_in_buffer)
1368                         kfree (port->bulk_in_buffer);
1369         }
1370         for (i = 0; i < num_bulk_out; ++i) {
1371                 port = &serial->port[i];
1372                 if (port->write_urb)
1373                         usb_free_urb (port->write_urb);
1374                 if (port->bulk_out_buffer)
1375                         kfree (port->bulk_out_buffer);
1376         }
1377         for (i = 0; i < num_interrupt_in; ++i) {
1378                 port = &serial->port[i];
1379                 if (port->interrupt_in_urb)
1380                         usb_free_urb (port->interrupt_in_urb);
1381                 if (port->interrupt_in_buffer)
1382                         kfree (port->interrupt_in_buffer);
1383         }
1384
1385         /* return the minor range that this device had */
1386         return_serial (serial);
1387
1388         /* free up any memory that we allocated */
1389         kfree (serial);
1390         return NULL;
1391 }
1392
1393 static void usb_serial_disconnect(struct usb_device *dev, void *ptr)
1394 {
1395         struct usb_serial *serial = (struct usb_serial *) ptr;
1396         struct usb_serial_port *port;
1397         int i;
1398
1399         dbg(__FUNCTION__);
1400         if (serial) {
1401                 /* fail all future close/read/write/ioctl/etc calls */
1402                 for (i = 0; i < serial->num_ports; ++i) {
1403                         down (&serial->port[i].sem);
1404                         if (serial->port[i].tty != NULL)
1405                                 serial->port[i].tty->driver_data = NULL;
1406                         up (&serial->port[i].sem);
1407                 }
1408
1409                 serial->dev = NULL;
1410                 serial_shutdown (serial);
1411
1412                 for (i = 0; i < serial->num_ports; ++i)
1413                         serial->port[i].open_count = 0;
1414
1415                 for (i = 0; i < serial->num_bulk_in; ++i) {
1416                         port = &serial->port[i];
1417                         if (port->read_urb) {
1418                                 usb_unlink_urb (port->read_urb);
1419                                 usb_free_urb (port->read_urb);
1420                         }
1421                         if (port->bulk_in_buffer)
1422                                 kfree (port->bulk_in_buffer);
1423                 }
1424                 for (i = 0; i < serial->num_bulk_out; ++i) {
1425                         port = &serial->port[i];
1426                         if (port->write_urb) {
1427                                 usb_unlink_urb (port->write_urb);
1428                                 usb_free_urb (port->write_urb);
1429                         }
1430                         if (port->bulk_out_buffer)
1431                                 kfree (port->bulk_out_buffer);
1432                 }
1433                 for (i = 0; i < serial->num_interrupt_in; ++i) {
1434                         port = &serial->port[i];
1435                         if (port->interrupt_in_urb) {
1436                                 usb_unlink_urb (port->interrupt_in_urb);
1437                                 usb_free_urb (port->interrupt_in_urb);
1438                         }
1439                         if (port->interrupt_in_buffer)
1440                                 kfree (port->interrupt_in_buffer);
1441                 }
1442
1443                 for (i = 0; i < serial->num_ports; ++i) {
1444                         tty_unregister_devfs (&serial_tty_driver, serial->port[i].number);
1445                         info("%s converter now disconnected from ttyUSB%d", serial->type->name, serial->port[i].number);
1446                 }
1447
1448                 /* return the minor range that this device had */
1449                 return_serial (serial);
1450
1451                 /* free up any memory that we allocated */
1452                 kfree (serial);
1453
1454         } else {
1455                 info("device disconnected");
1456         }
1457
1458 }
1459
1460
1461 static struct tty_driver serial_tty_driver = {
1462         magic:                  TTY_DRIVER_MAGIC,
1463         driver_name:            "usb-serial",
1464         name:                   "usb/tts/%d",
1465         major:                  SERIAL_TTY_MAJOR,
1466         minor_start:            0,
1467         num:                    SERIAL_TTY_MINORS,
1468         type:                   TTY_DRIVER_TYPE_SERIAL,
1469         subtype:                SERIAL_TYPE_NORMAL,
1470         flags:                  TTY_DRIVER_REAL_RAW | TTY_DRIVER_NO_DEVFS,
1471
1472         refcount:               &serial_refcount,
1473         table:                  serial_tty,
1474         termios:                serial_termios,
1475         termios_locked:         serial_termios_locked,
1476
1477         open:                   serial_open,
1478         close:                  serial_close,
1479         write:                  serial_write,
1480         write_room:             serial_write_room,
1481         ioctl:                  serial_ioctl,
1482         set_termios:            serial_set_termios,
1483         throttle:               serial_throttle,
1484         unthrottle:             serial_unthrottle,
1485         break_ctl:              serial_break,
1486         chars_in_buffer:        serial_chars_in_buffer,
1487 };
1488
1489
1490 static int __init usb_serial_init(void)
1491 {
1492         int i;
1493         int result;
1494
1495         /* Initalize our global data */
1496         for (i = 0; i < SERIAL_TTY_MINORS; ++i) {
1497                 serial_table[i] = NULL;
1498         }
1499
1500         /* register the tty driver */
1501         serial_tty_driver.init_termios          = tty_std_termios;
1502         serial_tty_driver.init_termios.c_cflag  = B9600 | CS8 | CREAD | HUPCL | CLOCAL;
1503         if (tty_register_driver (&serial_tty_driver)) {
1504                 err(__FUNCTION__ " - failed to register tty driver");
1505                 return -1;
1506         }
1507
1508         /* register the USB driver */
1509         result = usb_register(&usb_serial_driver);
1510         if (result < 0) {
1511                 tty_unregister_driver(&serial_tty_driver);
1512                 err("usb_register failed for the usb-serial driver. Error number %d", result);
1513                 return -1;
1514         }
1515
1516 #ifdef CONFIG_USB_SERIAL_GENERIC
1517         generic_device_ids[0].idVendor = vendor;
1518         generic_device_ids[0].idProduct = product;
1519         generic_device_ids[0].match_flags = USB_DEVICE_ID_MATCH_VENDOR | USB_DEVICE_ID_MATCH_PRODUCT;
1520         /* register our generic driver with ourselves */
1521         usb_serial_register (&generic_device);
1522 #endif
1523
1524         info(DRIVER_DESC " " DRIVER_VERSION);
1525
1526         return 0;
1527 }
1528
1529
1530 static void __exit usb_serial_exit(void)
1531 {
1532 #ifdef CONFIG_USB_SERIAL_CONSOLE
1533         unregister_console(&usbcons);
1534 #endif
1535
1536 #ifdef CONFIG_USB_SERIAL_GENERIC
1537         /* remove our generic driver */
1538         usb_serial_deregister (&generic_device);
1539 #endif
1540         
1541         usb_deregister(&usb_serial_driver);
1542         tty_unregister_driver(&serial_tty_driver);
1543 }
1544
1545
1546 module_init(usb_serial_init);
1547 module_exit(usb_serial_exit);
1548
1549
1550 int usb_serial_register(struct usb_serial_device_type *new_device)
1551 {
1552         /* Add this device to our list of devices */
1553         list_add(&new_device->driver_list, &usb_serial_driver_list);
1554
1555         info ("USB Serial support registered for %s", new_device->name);
1556
1557         usb_scan_devices();
1558
1559         return 0;
1560 }
1561
1562
1563 void usb_serial_deregister(struct usb_serial_device_type *device)
1564 {
1565         struct usb_serial *serial;
1566         int i;
1567
1568         info("USB Serial deregistering driver %s", device->name);
1569
1570         /* clear out the serial_table if the device is attached to a port */
1571         for(i = 0; i < SERIAL_TTY_MINORS; ++i) {
1572                 serial = serial_table[i];
1573                 if ((serial != NULL) && (serial->type == device)) {
1574                         usb_driver_release_interface (&usb_serial_driver, serial->interface);
1575                         usb_serial_disconnect (NULL, serial);
1576                 }
1577         }
1578
1579         list_del(&device->driver_list);
1580 }
1581
1582
1583
1584 /* If the usb-serial core is built into the core, the usb-serial drivers
1585    need these symbols to load properly as modules. */
1586 EXPORT_SYMBOL(usb_serial_register);
1587 EXPORT_SYMBOL(usb_serial_deregister);
1588 #ifdef USES_EZUSB_FUNCTIONS
1589         EXPORT_SYMBOL(ezusb_writememory);
1590         EXPORT_SYMBOL(ezusb_set_reset);
1591 #endif
1592
1593
1594 #ifdef CONFIG_USB_SERIAL_CONSOLE
1595 /*
1596  * ------------------------------------------------------------
1597  * USB Serial console driver
1598  *
1599  * Much of the code here is copied from drivers/char/serial.c
1600  * and implements a phony serial console in the same way that
1601  * serial.c does so that in case some software queries it,
1602  * it will get the same results.
1603  *
1604  * Things that are different from the way the serial port code
1605  * does things, is that we call the lower level usb-serial
1606  * driver code to initialize the device, and we set the initial
1607  * console speeds based on the command line arguments.
1608  * ------------------------------------------------------------
1609  */
1610
1611 #if 0
1612 static kdev_t usb_console_device(struct console *co)
1613 {
1614         return MKDEV(SERIAL_TTY_MAJOR, co->index);      /* TBD */
1615 }
1616 #endif
1617
1618 /*
1619  * The parsing of the command line works exactly like the
1620  * serial.c code, except that the specifier is "ttyUSB" instead
1621  * of "ttyS".
1622  */
1623 static int __init usb_console_setup(struct console *co, char *options)
1624 {
1625         struct usbcons_info *info = &usbcons_info;
1626         int baud = 9600;
1627         int bits = 8;
1628         int parity = 'n';
1629         int doflow = 0;
1630         int cflag = CREAD | HUPCL | CLOCAL;
1631         char *s;
1632         struct usb_serial *serial;
1633         struct usb_serial_port *port;
1634         int retval = 0;
1635         struct tty_struct *tty;
1636         struct termios *termios;
1637
1638         dbg ("%s", __FUNCTION__);
1639
1640         if (options) {
1641                 baud = simple_strtoul(options, NULL, 10);
1642                 s = options;
1643                 while (*s >= '0' && *s <= '9')
1644                         s++;
1645                 if (*s) parity = *s++;
1646                 if (*s) bits   = *s++ - '0';
1647                 if (*s) doflow = (*s++ == 'r');
1648         }
1649
1650         /* build a cflag setting */
1651         switch (baud) {
1652                 case 1200:
1653                         cflag |= B1200;
1654                         break;
1655                 case 2400:
1656                         cflag |= B2400;
1657                         break;
1658                 case 4800:
1659                         cflag |= B4800;
1660                         break;
1661                 case 19200:
1662                         cflag |= B19200;
1663                         break;
1664                 case 38400:
1665                         cflag |= B38400;
1666                         break;
1667                 case 57600:
1668                         cflag |= B57600;
1669                         break;
1670                 case 115200:
1671                         cflag |= B115200;
1672                         break;
1673                 case 9600:
1674                 default:
1675                         cflag |= B9600;
1676                         /*
1677                          * Set this to a sane value to prevent a divide error
1678                          */
1679                         baud  = 9600;
1680                         break;
1681         }
1682         switch (bits) {
1683                 case 7:
1684                         cflag |= CS7;
1685                         break;
1686                 default:
1687                 case 8:
1688                         cflag |= CS8;
1689                         break;
1690         }
1691         switch (parity) {
1692                 case 'o': case 'O':
1693                         cflag |= PARODD;
1694                         break;
1695                 case 'e': case 'E':
1696                         cflag |= PARENB;
1697                         break;
1698         }
1699         co->cflag = cflag;
1700
1701         /* grab the first serial port that happens to be connected */
1702         serial = get_serial_by_minor (0);
1703         if (serial_paranoia_check (serial, __FUNCTION__)) {
1704                 /* no device is connected yet, sorry :( */
1705                 err ("No USB device connected to ttyUSB0");
1706                 return -ENODEV;
1707         }
1708
1709         port = &serial->port[0];
1710         down (&port->sem);
1711         port->tty = NULL;
1712
1713         info->port = port;
1714          
1715         ++port->open_count;
1716         if (port->open_count == 1) {
1717                 /* only call the device specific open if this 
1718                  * is the first time the port is opened */
1719                 if (serial->type->open)
1720                         retval = serial->type->open(port, NULL);
1721                 else
1722                         retval = generic_open(port, NULL);
1723                 if (retval)
1724                         port->open_count = 0;
1725         }
1726
1727         up (&port->sem);
1728
1729         if (retval) {
1730                 err ("could not open USB console port");
1731                 return retval;
1732         }
1733
1734         if (serial->type->set_termios) {
1735                 /* build up a fake tty structure so that the open call has something
1736                  * to look at to get the cflag value */
1737                 tty = kmalloc (sizeof (*tty), GFP_KERNEL);
1738                 if (!tty) {
1739                         err ("no more memory");
1740                         return -ENOMEM;
1741                 }
1742                 termios = kmalloc (sizeof (*termios), GFP_KERNEL);
1743                 if (!termios) {
1744                         err ("no more memory");
1745                         kfree (tty);
1746                         return -ENOMEM;
1747                 }
1748                 memset (tty, 0x00, sizeof(*tty));
1749                 memset (termios, 0x00, sizeof(*termios));
1750                 termios->c_cflag = cflag;
1751                 tty->termios = termios;
1752                 port->tty = tty;
1753
1754                 /* set up the initial termios settings */
1755                 serial->type->set_termios(port, NULL);
1756                 port->tty = NULL;
1757                 kfree (termios);
1758                 kfree (tty);
1759         }
1760
1761         return retval;
1762 }
1763
1764 static void usb_console_write(struct console *co, const char *buf, unsigned count)
1765 {
1766         static struct usbcons_info *info = &usbcons_info;
1767         struct usb_serial_port *port = info->port;
1768         struct usb_serial *serial = get_usb_serial (port, __FUNCTION__);
1769         int retval = -ENODEV;
1770
1771         if (!serial || !port)
1772                 return;
1773
1774         if (count == 0)
1775                 return;
1776
1777         down (&port->sem);
1778
1779         dbg("%s - port %d, %d byte(s)", __FUNCTION__, port->number, count);
1780
1781         if (!port->open_count) {
1782                 dbg (__FUNCTION__ " - port not opened");
1783                 goto exit;
1784         }
1785
1786         /* pass on to the driver specific version of this function if it is available */
1787         if (serial->type->write)
1788                 retval = serial->type->write(port, 0, buf, count);
1789         else
1790                 retval = generic_write(port, 0, buf, count);
1791
1792 exit:
1793         up (&port->sem);
1794         dbg("%s - return value (if we had one): %d", __FUNCTION__, retval);
1795 }
1796
1797 #if 0
1798 /*
1799  * Receive character from the serial port
1800  */
1801 static int usb_console_wait_key(struct console *co)
1802 {
1803         static struct usbcons_info *info = &usbcons_info;
1804         int c = 0;
1805
1806         dbg("%s", __FUNCTION__);
1807
1808         /* maybe use generic_read_bulk_callback ??? */
1809
1810         return c;
1811 }
1812 #endif
1813
1814 static struct console usbcons = {
1815         name:           "ttyUSB",                       /* only [8] */
1816         write:          usb_console_write,
1817 #if 0
1818         device:         usb_console_device,             /* TBD */
1819         wait_key:       usb_console_wait_key,           /* TBD */
1820 #endif
1821         setup:          usb_console_setup,
1822         flags:          CON_PRINTBUFFER,
1823         index:          -1,
1824 };
1825
1826 #endif /* CONFIG_USB_SERIAL_CONSOLE */
1827
1828
1829 /* Module information */
1830 MODULE_AUTHOR( DRIVER_AUTHOR );
1831 MODULE_DESCRIPTION( DRIVER_DESC );
1832 MODULE_LICENSE("GPL");
1833
1834 MODULE_PARM(debug, "i");
1835 MODULE_PARM_DESC(debug, "Debug enabled or not");
1836
1837 #ifdef CONFIG_USB_SERIAL_GENERIC
1838 MODULE_PARM(vendor, "h");
1839 MODULE_PARM_DESC(vendor, "User specified USB idVendor");
1840
1841 MODULE_PARM(product, "h");
1842 MODULE_PARM_DESC(product, "User specified USB idProduct");
1843 #endif