drivers/usb/serial/ftdi_sio.c

   1 /*
   2  * USB FTDI SIO driver
   3  *
   4  *      Copyright (C) 1999 - 2001
   5  *          Greg Kroah-Hartman (greg@kroah.com)
   6  *          Bill Ryder (bryder@sgi.com)
   7  *      Copyright (C) 2002
   8  *          Kuba Ober (kuba@mareimbrium.org)
   9  *
  10  *      This program is free software; you can redistribute it and/or modify
  11  *      it under the terms of the GNU General Public License as published by
  12  *      the Free Software Foundation; either version 2 of the License, or
  13  *      (at your option) any later version.
  14  *
  15  * See Documentation/usb/usb-serial.txt for more information on using this driver
  16  *
  17  * See http://ftdi-usb-sio.sourceforge.net for upto date testing info
  18  *      and extra documentation
  19  *
  20  * (27/May/2004) Ian Abbott
  21  *      Improved throttling code, mostly stolen from the WhiteHEAT driver.
  22  *
  23  * (26/Mar/2004) Jan Capek
  24  *      Added PID's for ICD-U20/ICD-U40 - incircuit PIC debuggers from CCS Inc.
  25  *
  26  * (09/Feb/2004) Ian Abbott
  27  *      Changed full name of USB-UIRT device to avoid "/" character.
  28  *      Added FTDI's alternate PID (0x6006) for FT232/245 devices.
  29  *      Added PID for "ELV USB Module UO100" from Stefan Frings.
  30  *
  31  * (21/Oct/2003) Ian Abbott
  32  *      Renamed some VID/PID macros for Matrix Orbital and Perle Systems
  33  *      devices.  Removed Matrix Orbital and Perle Systems devices from the
  34  *      8U232AM device table, but left them in the FT232BM table, as they are
  35  *      known to use only FT232BM.
  36  *
  37  * (17/Oct/2003) Scott Allen
  38  *      Added vid/pid for Perle Systems UltraPort USB serial converters
  39  *
  40  * (21/Sep/2003) Ian Abbott
  41  *      Added VID/PID for Omnidirectional Control Technology US101 USB to
  42  *      RS-232 adapter (also rebadged as Dick Smith Electronics XH6381).
  43  *      VID/PID supplied by Donald Gordon.
  44  *
  45  * (19/Aug/2003) Ian Abbott
  46  *      Freed urb's transfer buffer in write bulk callback.
  47  *      Omitted some paranoid checks in write bulk callback that don't matter.
  48  *      Scheduled work in write bulk callback regardless of port's open count.
  49  *
  50  * (05/Aug/2003) Ian Abbott
  51  *      Added VID/PID for ID TECH IDT1221U USB to RS-232 adapter.
  52  *      VID/PID provided by Steve Briggs.
  53  *
  54  * (23/Jul/2003) Ian Abbott
  55  *      Added PIDs for CrystalFontz 547, 633, 631, 635, 640 and 640 from
  56  *      Wayne Wylupski.
  57  *
  58  * (10/Jul/2003) David Glance
  59  *      Added PID for DSS-20 SyncStation cradle for Sony-Ericsson P800.
  60  *
  61  * (27/Jun/2003) Ian Abbott
  62  *      Reworked the urb handling logic.  We have no more pool, but dynamically
  63  *      allocate the urb and the transfer buffer on the fly.  In testing this
  64  *      does not incure any measurable overhead.  This also relies on the fact
  65  *      that we have proper reference counting logic for urbs.  I nicked this
  66  *      from Greg KH's Visor driver.
  67  *
  68  * (23/Jun/2003) Ian Abbott
  69  *      Reduced flip buffer pushes and corrected a data length test in
  70  *      ftdi_read_bulk_callback.
  71  *      Defererence pointers after any paranoid checks, not before.
  72  *
  73  * (21/Jun/2003) Erik Nygren
  74  *      Added support for Home Electronics Tira-1 IR tranceiver using FT232BM chip.
  75  *      See <http://www.home-electro.com/tira1.htm>.  Only operates properly
  76  *      at 100000 and RTS-CTS, so set custom divisor mode on startup.
  77  *      Also force the Tira-1 and USB-UIRT to only use their custom baud rates.
  78  *
  79  * (18/Jun/2003) Ian Abbott
  80  *      Added Device ID of the USB relais from Rudolf Gugler (backported from
  81  *      Philipp Gühring's patch for 2.5.x kernel).
  82  *      Moved read transfer buffer reallocation into startup function.
  83  *      Free existing write urb and transfer buffer in startup function.
  84  *      Only use urbs in write urb pool that were successfully allocated.
  85  *      Moved some constant macros out of functions.
  86  *      Minor whitespace and comment changes.
  87  *
  88  * (12/Jun/2003) David Norwood
  89  *      Added support for USB-UIRT IR tranceiver using 8U232AM chip.
  90  *      See <http://home.earthlink.net/~jrhees/USBUIRT/index.htm>.  Only
  91  *      operates properly at 312500, so set custom divisor mode on startup.
  92  *
  93  * (12/Jun/2003) Ian Abbott
  94  *      Added Sealevel SeaLINK+ 210x, 220x, 240x, 280x vid/pids from Tuan Hoang
  95  *      - I've eliminated some that don't seem to exist!
  96  *      Added Home Electronics Tira-1 IR transceiver pid from Chris Horn
  97  *      Some whitespace/coding-style cleanups
  98  *
  99  * (11/Jun/2003) Ian Abbott
 100  *      Fixed unsafe spinlock usage in ftdi_write
 101  *
 102  * (24/Feb/2003) Richard Shooter
 103  *      Increase read buffer size to improve read speeds at higher baud rates
 104  *      (specifically tested with up to 1Mb/sec at 1.5M baud)
 105  *
 106  * (23/Feb/2003) John Wilkins
 107  *      Added Xon/xoff flow control (activating support in the ftdi device)
 108  *      Added vid/pid for Videonetworks/Homechoice (UK ISP)
 109  *
 110  * (23/Feb/2003) Bill Ryder
 111  *      Added matrix orb device vid/pids from Wayne Wylupski
 112  *
 113  * (19/Feb/2003) Ian Abbott
 114  *      For TIOCSSERIAL, set alt_speed to 0 when ASYNC_SPD_MASK value has
 115  *      changed to something other than ASYNC_SPD_HI, ASYNC_SPD_VHI,
 116  *      ASYNC_SPD_SHI or ASYNC_SPD_WARP.  Also, unless ASYNC_SPD_CUST is in
 117  *      force, don't bother changing baud rate when custom_divisor has changed.
 118  *
 119  * (18/Feb/2003) Ian Abbott
 120  *      Fixed TIOCMGET handling to include state of DTR and RTS, the state
 121  *      of which are now saved by set_dtr() and set_rts().
 122  *      Fixed improper storage class for buf in set_dtr() and set_rts().
 123  *      Added FT232BM chip type and support for its extra baud rates (compared
 124  *      to FT8U232AM).
 125  *      Took account of special case divisor values for highest baud rates of
 126  *      FT8U232AM and FT232BM.
 127  *      For TIOCSSERIAL, forced alt_speed to 0 when ASYNC_SPD_CUST kludge used,
 128  *      as previous alt_speed setting is now stale.
 129  *      Moved startup code common between the startup routines for the
 130  *      different chip types into a common subroutine.
 131  *
 132  * (17/Feb/2003) Bill Ryder
 133  *      Added write urb buffer pool on a per device basis
 134  *      Added more checking for open file on callbacks (fixed OOPS)
 135  *      Added CrystalFontz 632 and 634 PIDs
 136  *         (thanx to CrystalFontz for the sample devices - they flushed out
 137  *           some driver bugs)
 138  *      Minor debugging message changes
 139  *      Added throttle, unthrottle and chars_in_buffer functions
 140  *      Fixed FTDI_SIO (the original device) bug
 141  *      Fixed some shutdown handling
 142  *
 143  *
 144  *
 145  *
 146  * (07/Jun/2002) Kuba Ober
 147  *      Changed FTDI_SIO_BASE_BAUD_TO_DIVISOR macro into ftdi_baud_to_divisor
 148  *      function. It was getting too complex.
 149  *      Fix the divisor calculation logic which was setting divisor of 0.125
 150  *      instead of 0.5 for fractional parts of divisor equal to 5/8, 6/8, 7/8.
 151  *      Also make it bump up the divisor to next integer in case of 7/8 - it's
 152  *      a better approximation.
 153  *
 154  * (25/Jul/2002) Bill Ryder inserted Dmitri's TIOCMIWAIT patch
 155  *      Not tested by me but it doesn't break anything I use.
 156  *
 157  * (04/Jan/2002) Kuba Ober
 158  *      Implemented 38400 baudrate kludge, where it can be substituted with other
 159  *        values. That's the only way to set custom baudrates.
 160  *      Implemented TIOCSSERIAL, TIOCGSERIAL ioctl's so that setserial is happy.
 161  *      FIXME: both baudrate things should eventually go to usbserial.c as other
 162  *        devices may need that functionality too. Actually, it can probably be
 163  *        merged in serial.c somehow - too many drivers repeat this code over
 164  *        and over.
 165  *      Fixed baudrate forgetfulness - open() used to reset baudrate to 9600 every time.
 166  *      Divisors for baudrates are calculated by a macro.
 167  *      Small code cleanups. Ugly whitespace changes for Plato's sake only ;-].
 168  *
 169  * (04/Nov/2001) Bill Ryder
 170  *      Fixed bug in read_bulk_callback where incorrect urb buffer was used.
 171  *      Cleaned up write offset calculation
 172  *      Added write_room since default values can be incorrect for sio
 173  *      Changed write_bulk_callback to use same queue_task as other drivers
 174  *        (the previous version caused panics)
 175  *      Removed port iteration code since the device only has one I/O port and it
 176  *        was wrong anyway.
 177  *
 178  * (31/May/2001) gkh
 179  *      Switched from using spinlock to a semaphore, which fixes lots of problems.
 180  *
 181  * (23/May/2001)   Bill Ryder
 182  *      Added runtime debug patch (thanx Tyson D Sawyer).
 183  *      Cleaned up comments for 8U232
 184  *      Added parity, framing and overrun error handling
 185  *      Added receive break handling.
 186  *
 187  * (04/08/2001) gb
 188  *      Identify version on module load.
 189  *
 190  * (18/March/2001) Bill Ryder
 191  *      (Not released)
 192  *      Added send break handling. (requires kernel patch too)
 193  *      Fixed 8U232AM hardware RTS/CTS etc status reporting.
 194  *      Added flipbuf fix copied from generic device
 195  *
 196  * (12/3/2000) Bill Ryder
 197  *      Added support for 8U232AM device.
 198  *      Moved PID and VIDs into header file only.
 199  *      Turned on low-latency for the tty (device will do high baudrates)
 200  *      Added shutdown routine to close files when device removed.
 201  *      More debug and error message cleanups.
 202  *
 203  * (11/13/2000) Bill Ryder
 204  *      Added spinlock protected open code and close code.
 205  *      Multiple opens work (sort of - see webpage mentioned above).
 206  *      Cleaned up comments. Removed multiple PID/VID definitions.
 207  *      Factorised cts/dtr code
 208  *      Made use of __FUNCTION__ in dbg's
 209  *
 210  * (11/01/2000) Adam J. Richter
 211  *      usb_device_id table support
 212  *
 213  * (10/05/2000) gkh
 214  *      Fixed bug with urb->dev not being set properly, now that the usb
 215  *      core needs it.
 216  *
 217  * (09/11/2000) gkh
 218  *      Removed DEBUG #ifdefs with call to usb_serial_debug_data
 219  *
 220  * (07/19/2000) gkh
 221  *      Added module_init and module_exit functions to handle the fact that this
 222  *      driver is a loadable module now.
 223  *
 224  * (04/04/2000) Bill Ryder
 225  *      Fixed bugs in TCGET/TCSET ioctls (by removing them - they are
 226  *        handled elsewhere in the tty io driver chain).
 227  *
 228  * (03/30/2000) Bill Ryder
 229  *      Implemented lots of ioctls
 230  *      Fixed a race condition in write
 231  *      Changed some dbg's to errs
 232  *
 233  * (03/26/2000) gkh
 234  *      Split driver up into device specific pieces.
 235  *
 236  */
 237
 238 /* Bill Ryder - bryder@sgi.com - wrote the FTDI_SIO implementation */
 239 /* Thanx to FTDI for so kindly providing details of the protocol required */
 240 /*   to talk to the device */
 241 /* Thanx to gkh and the rest of the usb dev group for all code I have assimilated :-) */
 242
 243 #include <linux/config.h>
 244 #include <linux/kernel.h>
 245 #include <linux/errno.h>
 246 #include <linux/init.h>
 247 #include <linux/slab.h>
 248 #include <linux/tty.h>
 249 #include <linux/tty_driver.h>
 250 #include <linux/tty_flip.h>
 251 #include <linux/module.h>
 252 #include <linux/spinlock.h>
 253 #include <asm/uaccess.h>
 254 #include <linux/usb.h>
 255 #include <linux/serial.h>
 256 #include "usb-serial.h"
 257 #include "ftdi_sio.h"
 258
 259 /*
 260  * Version Information
 261  */
 262 #define DRIVER_VERSION "v1.4.0"
 263 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
 264 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
 265
 266 static int debug;
 267
 268 static struct usb_device_id id_table_sio [] = {
 269         { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
 270         { }                                             /* Terminating entry */
 271 };
 272
 273 /*
 274  * The 8U232AM has the same API as the sio except for:
 275  * - it can support MUCH higher baudrates; up to:
 276  *   o 921600 for RS232 and 2000000 for RS422/485 at 48MHz
 277  *   o 230400 at 12MHz
 278  *   so .. 8U232AM's baudrate setting codes are different
 279  * - it has a two byte status code.
 280  * - it returns characters every 16ms (the FTDI does it every 40ms)
 281  *
 282  * the bcdDevice value is used to differentiate FT232BM and FT245BM from
 283  * the earlier FT8U232AM and FT8U232BM.  For now, include all known VID/PID
 284  * combinations in both tables.
 285  * FIXME: perhaps bcdDevice can also identify 12MHz devices, but I don't know
 286  * if those ever went into mass production. [Ian Abbott]
 287  */
 288
 289
 290 static struct usb_device_id id_table_8U232AM [] = {
 291         { USB_DEVICE_VER(FTDI_VID, FTDI_IRTRANS_PID, 0, 0x3ff) },
 292         { USB_DEVICE_VER(FTDI_VID, FTDI_8U232AM_PID, 0, 0x3ff) },
 293         { USB_DEVICE_VER(FTDI_VID, FTDI_8U232AM_ALT_PID, 0, 0x3ff) },
 294         { USB_DEVICE_VER(FTDI_VID, FTDI_RELAIS_PID, 0, 0x3ff) },
 295         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
 296         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
 297         { USB_DEVICE_VER(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID, 0, 0x3ff) },
 298         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_632_PID, 0, 0x3ff) },
 299         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_634_PID, 0, 0x3ff) },
 300         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_547_PID, 0, 0x3ff) },
 301         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_633_PID, 0, 0x3ff) },
 302         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_631_PID, 0, 0x3ff) },
 303         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_635_PID, 0, 0x3ff) },
 304         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_640_PID, 0, 0x3ff) },
 305         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_642_PID, 0, 0x3ff) },
 306         { USB_DEVICE_VER(FTDI_VID, FTDI_VNHCPCUSB_D_PID, 0, 0x3ff) },
 307         { USB_DEVICE_VER(FTDI_VID, FTDI_DSS20_PID, 0, 0x3ff) },
 308         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2101_PID, 0, 0x3ff) },
 309         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2102_PID, 0, 0x3ff) },
 310         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2103_PID, 0, 0x3ff) },
 311         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2104_PID, 0, 0x3ff) },
 312         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2201_1_PID, 0, 0x3ff) },
 313         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2201_2_PID, 0, 0x3ff) },
 314         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2202_1_PID, 0, 0x3ff) },
 315         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2202_2_PID, 0, 0x3ff) },
 316         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2203_1_PID, 0, 0x3ff) },
 317         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2203_2_PID, 0, 0x3ff) },
 318         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_1_PID, 0, 0x3ff) },
 319         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_2_PID, 0, 0x3ff) },
 320         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_3_PID, 0, 0x3ff) },
 321         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_4_PID, 0, 0x3ff) },
 322         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_1_PID, 0, 0x3ff) },
 323         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_2_PID, 0, 0x3ff) },
 324         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_3_PID, 0, 0x3ff) },
 325         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_4_PID, 0, 0x3ff) },
 326         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_1_PID, 0, 0x3ff) },
 327         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_2_PID, 0, 0x3ff) },
 328         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_3_PID, 0, 0x3ff) },
 329         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_4_PID, 0, 0x3ff) },
 330         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_1_PID, 0, 0x3ff) },
 331         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_2_PID, 0, 0x3ff) },
 332         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_3_PID, 0, 0x3ff) },
 333         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_4_PID, 0, 0x3ff) },
 334         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_5_PID, 0, 0x3ff) },
 335         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_6_PID, 0, 0x3ff) },
 336         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_7_PID, 0, 0x3ff) },
 337         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_8_PID, 0, 0x3ff) },
 338         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_1_PID, 0, 0x3ff) },
 339         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_2_PID, 0, 0x3ff) },
 340         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_3_PID, 0, 0x3ff) },
 341         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_4_PID, 0, 0x3ff) },
 342         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_5_PID, 0, 0x3ff) },
 343         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_6_PID, 0, 0x3ff) },
 344         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_7_PID, 0, 0x3ff) },
 345         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_8_PID, 0, 0x3ff) },
 346         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_1_PID, 0, 0x3ff) },
 347         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_2_PID, 0, 0x3ff) },
 348         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_3_PID, 0, 0x3ff) },
 349         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_4_PID, 0, 0x3ff) },
 350         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_5_PID, 0, 0x3ff) },
 351         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_6_PID, 0, 0x3ff) },
 352         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_7_PID, 0, 0x3ff) },
 353         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_8_PID, 0, 0x3ff) },
 354         { USB_DEVICE_VER(IDTECH_VID, IDTECH_IDT1221U_PID, 0, 0x3ff) },
 355         { USB_DEVICE_VER(OCT_VID, OCT_US101_PID, 0, 0x3ff) },
 356         { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_1, 0, 0x3ff) },
 357         { USB_DEVICE_VER(FTDI_VID, PROTEGO_R2X0, 0, 0x3ff) },
 358         { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_3, 0, 0x3ff) },
 359         { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_4, 0, 0x3ff) },
 360         { USB_DEVICE_VER(FTDI_VID, FTDI_ELV_UO100_PID, 0, 0x3ff) },
 361         { USB_DEVICE_VER(FTDI_VID, INSIDE_ACCESSO, 0, 0x3ff) },
 362         { USB_DEVICE_VER(INTREPID_VID, INTREPID_VALUECAN_PID, 0, 0x3ff) },
 363         { USB_DEVICE_VER(INTREPID_VID, INTREPID_NEOVI_PID, 0, 0x3ff) },
 364         { USB_DEVICE_VER(FALCOM_VID, FALCOM_TWIST_PID, 0, 0x3ff) },
 365         { USB_DEVICE_VER(FTDI_VID, FTDI_SUUNTO_SPORTS_PID, 0, 0x3ff) },
 366         { }                                             /* Terminating entry */
 367 };
 368
 369
 370 static struct usb_device_id id_table_FT232BM [] = {
 371         { USB_DEVICE_VER(FTDI_VID, FTDI_IRTRANS_PID, 0x400, 0xffff) },
 372         { USB_DEVICE_VER(FTDI_VID, FTDI_8U232AM_PID, 0x400, 0xffff) },
 373         { USB_DEVICE_VER(FTDI_VID, FTDI_8U232AM_ALT_PID, 0x400, 0xffff) },
 374         { USB_DEVICE_VER(FTDI_VID, FTDI_RELAIS_PID, 0x400, 0xffff) },
 375         { USB_DEVICE_VER(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID, 0x400, 0xffff) },
 376         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_632_PID, 0x400, 0xffff) },
 377         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_634_PID, 0x400, 0xffff) },
 378         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_547_PID, 0x400, 0xffff) },
 379         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_633_PID, 0x400, 0xffff) },
 380         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_631_PID, 0x400, 0xffff) },
 381         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_635_PID, 0x400, 0xffff) },
 382         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_640_PID, 0x400, 0xffff) },
 383         { USB_DEVICE_VER(FTDI_VID, FTDI_XF_642_PID, 0x400, 0xffff) },
 384         { USB_DEVICE_VER(FTDI_VID, FTDI_VNHCPCUSB_D_PID, 0x400, 0xffff) },
 385         { USB_DEVICE_VER(FTDI_VID, FTDI_DSS20_PID, 0x400, 0xffff) },
 386         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_0_PID, 0x400, 0xffff) },
 387         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_1_PID, 0x400, 0xffff) },
 388         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_2_PID, 0x400, 0xffff) },
 389         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_3_PID, 0x400, 0xffff) },
 390         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_4_PID, 0x400, 0xffff) },
 391         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_5_PID, 0x400, 0xffff) },
 392         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_6_PID, 0x400, 0xffff) },
 393         { USB_DEVICE_VER(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID, 0x400, 0xffff) },
 394         { USB_DEVICE_VER(FTDI_VID, FTDI_PIEGROUP_PID, 0x400, 0xffff) },
 395         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2101_PID, 0x400, 0xffff) },
 396         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2102_PID, 0x400, 0xffff) },
 397         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2103_PID, 0x400, 0xffff) },
 398         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2104_PID, 0x400, 0xffff) },
 399         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2201_1_PID, 0x400, 0xffff) },
 400         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2201_2_PID, 0x400, 0xffff) },
 401         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2202_1_PID, 0x400, 0xffff) },
 402         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2202_2_PID, 0x400, 0xffff) },
 403         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2203_1_PID, 0x400, 0xffff) },
 404         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2203_2_PID, 0x400, 0xffff) },
 405         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_1_PID, 0x400, 0xffff) },
 406         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_2_PID, 0x400, 0xffff) },
 407         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_3_PID, 0x400, 0xffff) },
 408         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2401_4_PID, 0x400, 0xffff) },
 409         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_1_PID, 0x400, 0xffff) },
 410         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_2_PID, 0x400, 0xffff) },
 411         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_3_PID, 0x400, 0xffff) },
 412         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2402_4_PID, 0x400, 0xffff) },
 413         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_1_PID, 0x400, 0xffff) },
 414         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_2_PID, 0x400, 0xffff) },
 415         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_3_PID, 0x400, 0xffff) },
 416         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2403_4_PID, 0x400, 0xffff) },
 417         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_1_PID, 0x400, 0xffff) },
 418         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_2_PID, 0x400, 0xffff) },
 419         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_3_PID, 0x400, 0xffff) },
 420         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_4_PID, 0x400, 0xffff) },
 421         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_5_PID, 0x400, 0xffff) },
 422         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_6_PID, 0x400, 0xffff) },
 423         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_7_PID, 0x400, 0xffff) },
 424         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2801_8_PID, 0x400, 0xffff) },
 425         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_1_PID, 0x400, 0xffff) },
 426         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_2_PID, 0x400, 0xffff) },
 427         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_3_PID, 0x400, 0xffff) },
 428         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_4_PID, 0x400, 0xffff) },
 429         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_5_PID, 0x400, 0xffff) },
 430         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_6_PID, 0x400, 0xffff) },
 431         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_7_PID, 0x400, 0xffff) },
 432         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2802_8_PID, 0x400, 0xffff) },
 433         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_1_PID, 0x400, 0xffff) },
 434         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_2_PID, 0x400, 0xffff) },
 435         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_3_PID, 0x400, 0xffff) },
 436         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_4_PID, 0x400, 0xffff) },
 437         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_5_PID, 0x400, 0xffff) },
 438         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_6_PID, 0x400, 0xffff) },
 439         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_7_PID, 0x400, 0xffff) },
 440         { USB_DEVICE_VER(SEALEVEL_VID, SEALEVEL_2803_8_PID, 0x400, 0xffff) },
 441         { USB_DEVICE_VER(IDTECH_VID, IDTECH_IDT1221U_PID, 0x400, 0xffff) },
 442         { USB_DEVICE_VER(OCT_VID, OCT_US101_PID, 0x400, 0xffff) },
 443         { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_1, 0x400, 0xffff) },
 444         { USB_DEVICE_VER(FTDI_VID, PROTEGO_R2X0, 0x400, 0xffff) },
 445         { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_3, 0x400, 0xffff) },
 446         { USB_DEVICE_VER(FTDI_VID, PROTEGO_SPECIAL_4, 0x400, 0xffff) },
 447         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E808_PID, 0x400, 0xffff) },
 448         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E809_PID, 0x400, 0xffff) },
 449         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E80A_PID, 0x400, 0xffff) },
 450         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E80B_PID, 0x400, 0xffff) },
 451         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E80C_PID, 0x400, 0xffff) },
 452         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E80D_PID, 0x400, 0xffff) },
 453         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E80E_PID, 0x400, 0xffff) },
 454         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E80F_PID, 0x400, 0xffff) },
 455         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E888_PID, 0x400, 0xffff) },
 456         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E889_PID, 0x400, 0xffff) },
 457         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88A_PID, 0x400, 0xffff) },
 458         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88B_PID, 0x400, 0xffff) },
 459         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88C_PID, 0x400, 0xffff) },
 460         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88D_PID, 0x400, 0xffff) },
 461         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88E_PID, 0x400, 0xffff) },
 462         { USB_DEVICE_VER(FTDI_VID, FTDI_GUDEADS_E88F_PID, 0x400, 0xffff) },
 463         { USB_DEVICE_VER(FTDI_VID, FTDI_ELV_UO100_PID, 0x400, 0xffff) },
 464         { USB_DEVICE_VER(FTDI_VID, LINX_SDMUSBQSS_PID, 0x400, 0xffff) },
 465         { USB_DEVICE_VER(FTDI_VID, LINX_MASTERDEVEL2_PID, 0x400, 0xffff) },
 466         { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_0_PID, 0x400, 0xffff) },
 467         { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_1_PID, 0x400, 0xffff) },
 468         { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_2_PID, 0x400, 0xffff) },
 469         { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
 470         { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
 471         { USB_DEVICE_VER(FTDI_VID, INSIDE_ACCESSO, 0x400, 0xffff) },
 472         { USB_DEVICE_VER(INTREPID_VID, INTREPID_VALUECAN_PID, 0x400, 0xffff) },
 473         { USB_DEVICE_VER(INTREPID_VID, INTREPID_NEOVI_PID, 0x400, 0xffff) },
 474         { USB_DEVICE_VER(FALCOM_VID, FALCOM_TWIST_PID, 0x400, 0xffff) },
 475         { USB_DEVICE_VER(FTDI_VID, FTDI_SUUNTO_SPORTS_PID, 0x400, 0xffff) },
 476         { }                                             /* Terminating entry */
 477 };
 478
 479
 480 static struct usb_device_id id_table_USB_UIRT [] = {
 481         { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID) },
 482         { }                                             /* Terminating entry */
 483 };
 484
 485
 486 static struct usb_device_id id_table_HE_TIRA1 [] = {
 487         { USB_DEVICE_VER(FTDI_VID, FTDI_HE_TIRA1_PID, 0x400, 0xffff) },
 488         { }                                             /* Terminating entry */
 489 };
 490
 491
 492 static struct usb_device_id id_table_combined [] = {
 493         { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
 494         { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
 495         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
 496         { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
 497         { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
 498         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
 499         { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
 500         { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
 501         { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
 502         { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
 503         { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
 504         { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
 505         { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
 506         { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
 507         { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
 508         { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
 509         { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
 510         { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
 511         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_0_PID, 0x400, 0xffff) },
 512         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_1_PID, 0x400, 0xffff) },
 513         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_2_PID, 0x400, 0xffff) },
 514         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_3_PID, 0x400, 0xffff) },
 515         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_4_PID, 0x400, 0xffff) },
 516         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_5_PID, 0x400, 0xffff) },
 517         { USB_DEVICE_VER(FTDI_VID, FTDI_MTXORB_6_PID, 0x400, 0xffff) },
 518         { USB_DEVICE_VER(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID, 0x400, 0xffff) },
 519         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
 520         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
 521         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
 522         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
 523         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
 524         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
 525         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
 526         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
 527         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
 528         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
 529         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
 530         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
 531         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
 532         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
 533         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
 534         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
 535         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
 536         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
 537         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
 538         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
 539         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
 540         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
 541         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
 542         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
 543         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
 544         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
 545         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
 546         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
 547         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
 548         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
 549         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
 550         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
 551         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
 552         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
 553         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
 554         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
 555         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
 556         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
 557         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
 558         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
 559         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
 560         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
 561         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
 562         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
 563         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
 564         { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
 565         { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
 566         { USB_DEVICE(OCT_VID, OCT_US101_PID) },
 567         { USB_DEVICE_VER(FTDI_VID, FTDI_HE_TIRA1_PID, 0x400, 0xffff) },
 568         { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID) },
 569         { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
 570         { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
 571         { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
 572         { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
 573         { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
 574         { USB_DEVICE_VER(FTDI_VID, LINX_SDMUSBQSS_PID, 0x400, 0xffff) },
 575         { USB_DEVICE_VER(FTDI_VID, LINX_MASTERDEVEL2_PID, 0x400, 0xffff) },
 576         { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_0_PID, 0x400, 0xffff) },
 577         { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_1_PID, 0x400, 0xffff) },
 578         { USB_DEVICE_VER(FTDI_VID, LINX_FUTURE_2_PID, 0x400, 0xffff) },
 579         { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
 580         { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
 581         { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
 582         { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
 583         { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
 584         { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
 585         { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
 586         { }                                             /* Terminating entry */
 587 };
 588
 589 MODULE_DEVICE_TABLE (usb, id_table_combined);
 590
 591 static struct usb_driver ftdi_driver = {
 592         .name =         "ftdi_sio",
 593         .probe =        usb_serial_probe,
 594         .disconnect =   usb_serial_disconnect,
 595         .id_table =     id_table_combined,
 596 };
 597
 598
 599 /* Constants for read urb and write urb */
 600 #define BUFSZ 512
 601 #define PKTSZ 64
 602
 603 /* rx_flags */
 604 #define THROTTLED               0x01
 605 #define ACTUALLY_THROTTLED      0x02
 606
 607 struct ftdi_private {
 608         ftdi_chip_type_t chip_type;
 609                                 /* type of the device, either SIO or FT8U232AM */
 610         int baud_base;          /* baud base clock for divisor setting */
 611         int custom_divisor;     /* custom_divisor kludge, this is for baud_base (different from what goes to the chip!) */
 612         __u16 last_set_data_urb_value ;
 613                                 /* the last data state set - needed for doing a break */
 614         int write_offset;       /* This is the offset in the usb data block to write the serial data -
 615                                  * it is different between devices
 616                                  */
 617         int flags;              /* some ASYNC_xxxx flags are supported */
 618         unsigned long last_dtr_rts;     /* saved modem control outputs */
 619         wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
 620         char prev_status, diff_status;        /* Used for TIOCMIWAIT */
 621         __u8 rx_flags;          /* receive state flags (throttling) */
 622         spinlock_t rx_lock;     /* spinlock for receive state */
 623
 624         int force_baud;         /* if non-zero, force the baud rate to this value */
 625         int force_rtscts;       /* if non-zero, force RTS-CTS to always be enabled */
 626 };
 627
 628 /* Used for TIOCMIWAIT */
 629 #define FTDI_STATUS_B0_MASK     (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
 630 #define FTDI_STATUS_B1_MASK     (FTDI_RS_BI)
 631 /* End TIOCMIWAIT */
 632
 633 #define FTDI_IMPL_ASYNC_FLAGS = ( ASYNC_SPD_HI | ASYNC_SPD_VHI \
 634  ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP )
 635
 636 /* function prototypes for a FTDI serial converter */
 637 static int  ftdi_SIO_startup            (struct usb_serial *serial);
 638 static int  ftdi_8U232AM_startup        (struct usb_serial *serial);
 639 static int  ftdi_FT232BM_startup        (struct usb_serial *serial);
 640 static int  ftdi_USB_UIRT_startup       (struct usb_serial *serial);
 641 static int  ftdi_HE_TIRA1_startup       (struct usb_serial *serial);
 642 static void ftdi_shutdown               (struct usb_serial *serial);
 643 static int  ftdi_open                   (struct usb_serial_port *port, struct file *filp);
 644 static void ftdi_close                  (struct usb_serial_port *port, struct file *filp);
 645 static int  ftdi_write                  (struct usb_serial_port *port, int from_user, const unsigned char *buf, int count);
 646 static int  ftdi_write_room             (struct usb_serial_port *port);
 647 static int  ftdi_chars_in_buffer        (struct usb_serial_port *port);
 648 static void ftdi_write_bulk_callback    (struct urb *urb, struct pt_regs *regs);
 649 static void ftdi_read_bulk_callback     (struct urb *urb, struct pt_regs *regs);
 650 static void ftdi_process_read           (struct usb_serial_port *port);
 651 static void ftdi_set_termios            (struct usb_serial_port *port, struct termios * old);
 652 static int  ftdi_tiocmget               (struct usb_serial_port *port, struct file *file);
 653 static int  ftdi_tiocmset               (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
 654 static int  ftdi_ioctl                  (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
 655 static void ftdi_break_ctl              (struct usb_serial_port *port, int break_state );
 656 static void ftdi_throttle               (struct usb_serial_port *port);
 657 static void ftdi_unthrottle             (struct usb_serial_port *port);
 658
 659 static unsigned short int ftdi_232am_baud_base_to_divisor (int baud, int base);
 660 static unsigned short int ftdi_232am_baud_to_divisor (int baud);
 661 static __u32 ftdi_232bm_baud_base_to_divisor (int baud, int base);
 662 static __u32 ftdi_232bm_baud_to_divisor (int baud);
 663
 664 static struct usb_serial_device_type ftdi_SIO_device = {
 665         .owner =                THIS_MODULE,
 666         .name =                 "FTDI SIO",
 667         .id_table =             id_table_sio,
 668         .num_interrupt_in =     0,
 669         .num_bulk_in =          1,
 670         .num_bulk_out =         1,
 671         .num_ports =            1,
 672         .open =                 ftdi_open,
 673         .close =                ftdi_close,
 674         .throttle =             ftdi_throttle,
 675         .unthrottle =           ftdi_unthrottle,
 676         .write =                ftdi_write,
 677         .write_room =           ftdi_write_room,
 678         .chars_in_buffer =      ftdi_chars_in_buffer,
 679         .read_bulk_callback =   ftdi_read_bulk_callback,
 680         .write_bulk_callback =  ftdi_write_bulk_callback,
 681         .tiocmget =             ftdi_tiocmget,
 682         .tiocmset =             ftdi_tiocmset,
 683         .ioctl =                ftdi_ioctl,
 684         .set_termios =          ftdi_set_termios,
 685         .break_ctl =            ftdi_break_ctl,
 686         .attach =               ftdi_SIO_startup,
 687         .shutdown =             ftdi_shutdown,
 688 };
 689
 690 static struct usb_serial_device_type ftdi_8U232AM_device = {
 691         .owner =                THIS_MODULE,
 692         .name =                 "FTDI 8U232AM Compatible",
 693         .id_table =             id_table_8U232AM,
 694         .num_interrupt_in =     0,
 695         .num_bulk_in =          1,
 696         .num_bulk_out =         1,
 697         .num_ports =            1,
 698         .open =                 ftdi_open,
 699         .close =                ftdi_close,
 700         .throttle =             ftdi_throttle,
 701         .unthrottle =           ftdi_unthrottle,
 702         .write =                ftdi_write,
 703         .write_room =           ftdi_write_room,
 704         .chars_in_buffer =      ftdi_chars_in_buffer,
 705         .read_bulk_callback =   ftdi_read_bulk_callback,
 706         .write_bulk_callback =  ftdi_write_bulk_callback,
 707         .tiocmget =             ftdi_tiocmget,
 708         .tiocmset =             ftdi_tiocmset,
 709         .ioctl =                ftdi_ioctl,
 710         .set_termios =          ftdi_set_termios,
 711         .break_ctl =            ftdi_break_ctl,
 712         .attach =               ftdi_8U232AM_startup,
 713         .shutdown =             ftdi_shutdown,
 714 };
 715
 716 static struct usb_serial_device_type ftdi_FT232BM_device = {
 717         .owner =                THIS_MODULE,
 718         .name =                 "FTDI FT232BM Compatible",
 719         .id_table =             id_table_FT232BM,
 720         .num_interrupt_in =     0,
 721         .num_bulk_in =          1,
 722         .num_bulk_out =         1,
 723         .num_ports =            1,
 724         .open =                 ftdi_open,
 725         .close =                ftdi_close,
 726         .throttle =             ftdi_throttle,
 727         .unthrottle =           ftdi_unthrottle,
 728         .write =                ftdi_write,
 729         .write_room =           ftdi_write_room,
 730         .chars_in_buffer =      ftdi_chars_in_buffer,
 731         .read_bulk_callback =   ftdi_read_bulk_callback,
 732         .write_bulk_callback =  ftdi_write_bulk_callback,
 733         .tiocmget =             ftdi_tiocmget,
 734         .tiocmset =             ftdi_tiocmset,
 735         .ioctl =                ftdi_ioctl,
 736         .set_termios =          ftdi_set_termios,
 737         .break_ctl =            ftdi_break_ctl,
 738         .attach =               ftdi_FT232BM_startup,
 739         .shutdown =             ftdi_shutdown,
 740 };
 741
 742 static struct usb_serial_device_type ftdi_USB_UIRT_device = {
 743         .owner =                THIS_MODULE,
 744         .name =                 "USB-UIRT Infrared Tranceiver",
 745         .id_table =             id_table_USB_UIRT,
 746         .num_interrupt_in =     0,
 747         .num_bulk_in =          1,
 748         .num_bulk_out =         1,
 749         .num_ports =            1,
 750         .open =                 ftdi_open,
 751         .close =                ftdi_close,
 752         .throttle =             ftdi_throttle,
 753         .unthrottle =           ftdi_unthrottle,
 754         .write =                ftdi_write,
 755         .write_room =           ftdi_write_room,
 756         .chars_in_buffer =      ftdi_chars_in_buffer,
 757         .read_bulk_callback =   ftdi_read_bulk_callback,
 758         .write_bulk_callback =  ftdi_write_bulk_callback,
 759         .tiocmget =             ftdi_tiocmget,
 760         .tiocmset =             ftdi_tiocmset,
 761         .ioctl =                ftdi_ioctl,
 762         .set_termios =          ftdi_set_termios,
 763         .break_ctl =            ftdi_break_ctl,
 764         .attach =               ftdi_USB_UIRT_startup,
 765         .shutdown =             ftdi_shutdown,
 766 };
 767
 768 /* The TIRA1 is based on a  FT232BM which requires a fixed baud rate of 100000
 769  * and which requires RTS-CTS to be enabled. */
 770 static struct usb_serial_device_type ftdi_HE_TIRA1_device = {
 771         .owner =                THIS_MODULE,
 772         .name =                 "Home-Electronics TIRA-1 IR Transceiver",
 773         .id_table =             id_table_HE_TIRA1,
 774         .num_interrupt_in =     0,
 775         .num_bulk_in =          1,
 776         .num_bulk_out =         1,
 777         .num_ports =            1,
 778         .open =                 ftdi_open,
 779         .close =                ftdi_close,
 780         .throttle =             ftdi_throttle,
 781         .unthrottle =           ftdi_unthrottle,
 782         .write =                ftdi_write,
 783         .write_room =           ftdi_write_room,
 784         .chars_in_buffer =      ftdi_chars_in_buffer,
 785         .read_bulk_callback =   ftdi_read_bulk_callback,
 786         .write_bulk_callback =  ftdi_write_bulk_callback,
 787         .tiocmget =             ftdi_tiocmget,
 788         .tiocmset =             ftdi_tiocmset,
 789         .ioctl =                ftdi_ioctl,
 790         .set_termios =          ftdi_set_termios,
 791         .break_ctl =            ftdi_break_ctl,
 792         .attach =               ftdi_HE_TIRA1_startup,
 793         .shutdown =             ftdi_shutdown,
 794 };
 795
 796
 797
 798 #define WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */
 799
 800 /* High and low are for DTR, RTS etc etc */
 801 #define HIGH 1
 802 #define LOW 0
 803
 804 /*
 805  * ***************************************************************************
 806  * Utlity functions
 807  * ***************************************************************************
 808  */
 809
 810 static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
 811 {
 812         unsigned short int divisor;
 813         int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
 814         if ((divisor3 & 0x7) == 7) divisor3 ++; // round x.7/8 up to x+1
 815         divisor = divisor3 >> 3;
 816         divisor3 &= 0x7;
 817         if (divisor3 == 1) divisor |= 0xc000; else // 0.125
 818         if (divisor3 >= 4) divisor |= 0x4000; else // 0.5
 819         if (divisor3 != 0) divisor |= 0x8000;      // 0.25
 820         if (divisor == 1) divisor = 0;  /* special case for maximum baud rate */
 821         return divisor;
 822 }
 823
 824 static unsigned short int ftdi_232am_baud_to_divisor(int baud)
 825 {
 826          return(ftdi_232am_baud_base_to_divisor(baud, 48000000));
 827 }
 828
 829 static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
 830 {
 831         static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
 832         __u32 divisor;
 833         int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
 834         divisor = divisor3 >> 3;
 835         divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
 836         /* Deal with special cases for highest baud rates. */
 837         if (divisor == 1) divisor = 0; else     // 1.0
 838         if (divisor == 0x4001) divisor = 1;     // 1.5
 839         return divisor;
 840 }
 841
 842 static __u32 ftdi_232bm_baud_to_divisor(int baud)
 843 {
 844          return(ftdi_232bm_baud_base_to_divisor(baud, 48000000));
 845 }
 846
 847 static int set_rts(struct usb_serial_port *port, int high_or_low)
 848 {
 849         struct ftdi_private *priv = usb_get_serial_port_data(port);
 850         char *buf;
 851         unsigned ftdi_high_or_low;
 852         int rv;
 853
 854         buf = kmalloc(1, GFP_NOIO);
 855         if (!buf)
 856                 return -ENOMEM;
 857
 858         if (high_or_low) {
 859                 ftdi_high_or_low = FTDI_SIO_SET_RTS_HIGH;
 860                 priv->last_dtr_rts |= TIOCM_RTS;
 861         } else {
 862                 ftdi_high_or_low = FTDI_SIO_SET_RTS_LOW;
 863                 priv->last_dtr_rts &= ~TIOCM_RTS;
 864         }
 865         rv = usb_control_msg(port->serial->dev,
 866                                usb_sndctrlpipe(port->serial->dev, 0),
 867                                FTDI_SIO_SET_MODEM_CTRL_REQUEST,
 868                                FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
 869                                ftdi_high_or_low, 0,
 870                                buf, 0, WDR_TIMEOUT);
 871
 872         kfree(buf);
 873         return rv;
 874 }
 875
 876
 877 static int set_dtr(struct usb_serial_port *port, int high_or_low)
 878 {
 879         struct ftdi_private *priv = usb_get_serial_port_data(port);
 880         char *buf;
 881         unsigned ftdi_high_or_low;
 882         int rv;
 883
 884         buf = kmalloc(1, GFP_NOIO);
 885         if (!buf)
 886                 return -ENOMEM;
 887
 888         if (high_or_low) {
 889                 ftdi_high_or_low = FTDI_SIO_SET_DTR_HIGH;
 890                 priv->last_dtr_rts |= TIOCM_DTR;
 891         } else {
 892                 ftdi_high_or_low = FTDI_SIO_SET_DTR_LOW;
 893                 priv->last_dtr_rts &= ~TIOCM_DTR;
 894         }
 895         rv = usb_control_msg(port->serial->dev,
 896                                usb_sndctrlpipe(port->serial->dev, 0),
 897                                FTDI_SIO_SET_MODEM_CTRL_REQUEST,
 898                                FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
 899                                ftdi_high_or_low, 0,
 900                                buf, 0, WDR_TIMEOUT);
 901
 902         kfree(buf);
 903         return rv;
 904 }
 905
 906
 907 static __u32 get_ftdi_divisor(struct usb_serial_port * port);
 908
 909
 910 static int change_speed(struct usb_serial_port *port)
 911 {
 912         char *buf;
 913         __u16 urb_value;
 914         __u16 urb_index;
 915         __u32 urb_index_value;
 916         int rv;
 917
 918         buf = kmalloc(1, GFP_NOIO);
 919         if (!buf)
 920                 return -ENOMEM;
 921
 922         urb_index_value = get_ftdi_divisor(port);
 923         urb_value = (__u16)urb_index_value;
 924         urb_index = (__u16)(urb_index_value >> 16);
 925
 926         rv = usb_control_msg(port->serial->dev,
 927                             usb_sndctrlpipe(port->serial->dev, 0),
 928                             FTDI_SIO_SET_BAUDRATE_REQUEST,
 929                             FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
 930                             urb_value, urb_index,
 931                             buf, 0, 100);
 932
 933         kfree(buf);
 934         return rv;
 935 }
 936
 937
 938 static __u32 get_ftdi_divisor(struct usb_serial_port * port)
 939 { /* get_ftdi_divisor */
 940         struct ftdi_private *priv = usb_get_serial_port_data(port);
 941         __u32 div_value = 0;
 942         int div_okay = 1;
 943         char *chip_name = "";
 944         int baud;
 945
 946         /*
 947          * The logic involved in setting the baudrate can be cleanly split in 3 steps.
 948          * Obtaining the actual baud rate is a little tricky since unix traditionally
 949          * somehow ignored the possibility to set non-standard baud rates.
 950          * 1. Standard baud rates are set in tty->termios->c_cflag
 951          * 2. If these are not enough, you can set any speed using alt_speed as follows:
 952          *    - set tty->termios->c_cflag speed to B38400
 953          *    - set your real speed in tty->alt_speed; it gets ignored when
 954          *      alt_speed==0, (or)
 955          *    - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
 956          *      flags & ASYNC_SPD_MASK == ASYNC_SPD_[HI, VHI, SHI, WARP], this just
 957          *      sets alt_speed to (HI: 57600, VHI: 115200, SHI: 230400, WARP: 460800)
 958          * ** Steps 1, 2 are done courtesy of tty_get_baud_rate
 959          * 3. You can also set baud rate by setting custom divisor as follows
 960          *    - set tty->termios->c_cflag speed to B38400
 961          *    - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
 962          *      o flags & ASYNC_SPD_MASK == ASYNC_SPD_CUST
 963          *      o custom_divisor set to baud_base / your_new_baudrate
 964          * ** Step 3 is done courtesy of code borrowed from serial.c - I should really
 965          *    spend some time and separate+move this common code to serial.c, it is
 966          *    replicated in nearly every serial driver you see.
 967          */
 968
 969         /* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
 970
 971         baud = tty_get_baud_rate(port->tty);
 972         dbg("%s - tty_get_baud_rate reports speed %d", __FUNCTION__, baud);
 973
 974         /* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
 975
 976         if (baud == 38400 &&
 977             ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
 978              (priv->custom_divisor)) {
 979                 baud = priv->baud_base / priv->custom_divisor;
 980                 dbg("%s - custom divisor %d sets baud rate to %d", __FUNCTION__, priv->custom_divisor, baud);
 981         }
 982
 983         /* 3. Convert baudrate to device-specific divisor */
 984
 985         if (!baud) baud = 9600;
 986         switch(priv->chip_type) {
 987         case SIO: /* SIO chip */
 988                 chip_name = "SIO";
 989                 switch(baud) {
 990                 case 300: div_value = ftdi_sio_b300; break;
 991                 case 600: div_value = ftdi_sio_b600; break;
 992                 case 1200: div_value = ftdi_sio_b1200; break;
 993                 case 2400: div_value = ftdi_sio_b2400; break;
 994                 case 4800: div_value = ftdi_sio_b4800; break;
 995                 case 9600: div_value = ftdi_sio_b9600; break;
 996                 case 19200: div_value = ftdi_sio_b19200; break;
 997                 case 38400: div_value = ftdi_sio_b38400; break;
 998                 case 57600: div_value = ftdi_sio_b57600;  break;
 999                 case 115200: div_value = ftdi_sio_b115200; break;
1000                 } /* baud */
1001                 if (div_value == 0) {
1002                         dbg("%s - Baudrate (%d) requested is not supported", __FUNCTION__,  baud);
1003                         div_value = ftdi_sio_b9600;
1004                         div_okay = 0;
1005                 }
1006                 break;
1007         case FT8U232AM: /* 8U232AM chip */
1008                 chip_name = "FT8U232AM";
1009                 if (baud <= 3000000) {
1010                         div_value = ftdi_232am_baud_to_divisor(baud);
1011                 } else {
1012                         dbg("%s - Baud rate too high!", __FUNCTION__);
1013                         div_value = ftdi_232am_baud_to_divisor(9600);
1014                         div_okay = 0;
1015                 }
1016                 break;
1017         case FT232BM: /* FT232BM chip */
1018                 chip_name = "FT232BM";
1019                 if (baud <= 3000000) {
1020                         div_value = ftdi_232bm_baud_to_divisor(baud);
1021                 } else {
1022                         dbg("%s - Baud rate too high!", __FUNCTION__);
1023                         div_value = ftdi_232bm_baud_to_divisor(9600);
1024                         div_okay = 0;
1025                 }
1026                 break;
1027         } /* priv->chip_type */
1028
1029         if (div_okay) {
1030                 dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",
1031                         __FUNCTION__, baud, (unsigned long)div_value, chip_name);
1032         }
1033
1034         return(div_value);
1035 }
1036
1037
1038 static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
1039 {
1040         struct ftdi_private *priv = usb_get_serial_port_data(port);
1041         struct serial_struct tmp;
1042
1043         if (!retinfo)
1044                 return -EFAULT;
1045         memset(&tmp, 0, sizeof(tmp));
1046         tmp.flags = priv->flags;
1047         tmp.baud_base = priv->baud_base;
1048         tmp.custom_divisor = priv->custom_divisor;
1049         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1050                 return -EFAULT;
1051         return 0;
1052 } /* get_serial_info */
1053
1054
1055 static int set_serial_info(struct usb_serial_port * port, struct serial_struct __user * newinfo)
1056 { /* set_serial_info */
1057         struct ftdi_private *priv = usb_get_serial_port_data(port);
1058         struct serial_struct new_serial;
1059         struct ftdi_private old_priv;
1060
1061         if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1062                 return -EFAULT;
1063         old_priv = * priv;
1064
1065         /* Do error checking and permission checking */
1066
1067         if (!capable(CAP_SYS_ADMIN)) {
1068                 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
1069                      (priv->flags & ~ASYNC_USR_MASK)))
1070                         return -EPERM;
1071                 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
1072                                (new_serial.flags & ASYNC_USR_MASK));
1073                 priv->custom_divisor = new_serial.custom_divisor;
1074                 goto check_and_exit;
1075         }
1076
1077         if ((new_serial.baud_base != priv->baud_base) ||
1078             (new_serial.baud_base < 9600))
1079                 return -EINVAL;
1080
1081         /* Make the changes - these are privileged changes! */
1082
1083         priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
1084                        (new_serial.flags & ASYNC_FLAGS));
1085         priv->custom_divisor = new_serial.custom_divisor;
1086
1087         port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1088
1089 check_and_exit:
1090         if ((old_priv.flags & ASYNC_SPD_MASK) !=
1091              (priv->flags & ASYNC_SPD_MASK)) {
1092                 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1093                         port->tty->alt_speed = 57600;
1094                 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1095                         port->tty->alt_speed = 115200;
1096                 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1097                         port->tty->alt_speed = 230400;
1098                 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1099                         port->tty->alt_speed = 460800;
1100                 else
1101                         port->tty->alt_speed = 0;
1102         }
1103         if (((old_priv.flags & ASYNC_SPD_MASK) !=
1104              (priv->flags & ASYNC_SPD_MASK)) ||
1105             (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1106              (old_priv.custom_divisor != priv->custom_divisor))) {
1107                 change_speed(port);
1108         }
1109
1110         return (0);
1111
1112 } /* set_serial_info */
1113
1114 /*
1115  * ***************************************************************************
1116  * FTDI driver specific functions
1117  * ***************************************************************************
1118  */
1119
1120 /* Common startup subroutine */
1121 /* Called from ftdi_SIO_startup, etc. */
1122 static int ftdi_common_startup (struct usb_serial *serial)
1123 {
1124         struct usb_serial_port *port = serial->port[0];
1125         struct ftdi_private *priv;
1126
1127         dbg("%s",__FUNCTION__);
1128
1129         priv = kmalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1130         if (!priv){
1131                 err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
1132                 return -ENOMEM;
1133         }
1134         memset(priv, 0, sizeof(*priv));
1135
1136         spin_lock_init(&priv->rx_lock);
1137         init_waitqueue_head(&priv->delta_msr_wait);
1138         /* This will push the characters through immediately rather
1139            than queue a task to deliver them */
1140         priv->flags = ASYNC_LOW_LATENCY;
1141
1142         /* Increase the size of read buffers */
1143         if (port->bulk_in_buffer) {
1144                 kfree (port->bulk_in_buffer);
1145         }
1146         port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL);
1147         if (!port->bulk_in_buffer) {
1148                 kfree (priv);
1149                 return -ENOMEM;
1150         }
1151         if (port->read_urb) {
1152                 port->read_urb->transfer_buffer = port->bulk_in_buffer;
1153                 port->read_urb->transfer_buffer_length = BUFSZ;
1154         }
1155
1156         /* Free port's existing write urb and transfer buffer. */
1157         if (port->write_urb) {
1158                 usb_free_urb (port->write_urb);
1159                 port->write_urb = NULL;
1160         }
1161         if (port->bulk_out_buffer) {
1162                 kfree (port->bulk_out_buffer);
1163                 port->bulk_out_buffer = NULL;
1164         }
1165
1166         usb_set_serial_port_data(serial->port[0], priv);
1167
1168         return (0);
1169 }
1170
1171
1172 /* Startup for the SIO chip */
1173 /* Called from usbserial:serial_probe */
1174 static int ftdi_SIO_startup (struct usb_serial *serial)
1175 {
1176         struct ftdi_private *priv;
1177         int err;
1178
1179         dbg("%s",__FUNCTION__);
1180
1181         err = ftdi_common_startup(serial);
1182         if (err){
1183                 return (err);
1184         }
1185
1186         priv = usb_get_serial_port_data(serial->port[0]);
1187         priv->chip_type = SIO;
1188         priv->baud_base = 12000000 / 16;
1189         priv->write_offset = 1;
1190
1191         return (0);
1192 }
1193
1194 /* Startup for the 8U232AM chip */
1195 /* Called from usbserial:serial_probe */
1196 static int ftdi_8U232AM_startup (struct usb_serial *serial)
1197 { /* ftdi_8U232AM_startup */
1198         struct ftdi_private *priv;
1199         int err;
1200
1201         dbg("%s",__FUNCTION__);
1202         err = ftdi_common_startup(serial);
1203         if (err){
1204                 return (err);
1205         }
1206
1207         priv = usb_get_serial_port_data(serial->port[0]);
1208         priv->chip_type = FT8U232AM;
1209         priv->baud_base = 48000000 / 2; /* Would be / 16, but FTDI supports 0.125, 0.25 and 0.5 divisor fractions! */
1210
1211         return (0);
1212 } /* ftdi_8U232AM_startup */
1213
1214 /* Startup for the FT232BM chip */
1215 /* Called from usbserial:serial_probe */
1216 static int ftdi_FT232BM_startup (struct usb_serial *serial)
1217 { /* ftdi_FT232BM_startup */
1218         struct ftdi_private *priv;
1219         int err;
1220
1221         dbg("%s",__FUNCTION__);
1222         err = ftdi_common_startup(serial);
1223         if (err){
1224                 return (err);
1225         }
1226
1227         priv = usb_get_serial_port_data(serial->port[0]);
1228         priv->chip_type = FT232BM;
1229         priv->baud_base = 48000000 / 2; /* Would be / 16, but FT232BM supports multiple of 0.125 divisor fractions! */
1230
1231         return (0);
1232 } /* ftdi_FT232BM_startup */
1233
1234 /* Startup for the USB-UIRT device, which requires hardwired baudrate (38400 gets mapped to 312500) */
1235 /* Called from usbserial:serial_probe */
1236 static int ftdi_USB_UIRT_startup (struct usb_serial *serial)
1237 { /* ftdi_USB_UIRT_startup */
1238         struct ftdi_private *priv;
1239         int err;
1240
1241         dbg("%s",__FUNCTION__);
1242         err = ftdi_8U232AM_startup(serial);
1243         if (err){
1244                 return (err);
1245         }
1246
1247         priv = usb_get_serial_port_data(serial->port[0]);
1248         priv->flags |= ASYNC_SPD_CUST;
1249         priv->custom_divisor = 77;
1250         priv->force_baud = B38400;
1251
1252         return (0);
1253 } /* ftdi_USB_UIRT_startup */
1254
1255 /* Startup for the HE-TIRA1 device, which requires hardwired
1256  * baudrate (38400 gets mapped to 100000) */
1257 static int ftdi_HE_TIRA1_startup (struct usb_serial *serial)
1258 { /* ftdi_HE_TIRA1_startup */
1259         struct ftdi_private *priv;
1260         int err;
1261
1262         dbg("%s",__FUNCTION__);
1263         err = ftdi_FT232BM_startup(serial);
1264         if (err){
1265                 return (err);
1266         }
1267
1268         priv = usb_get_serial_port_data(serial->port[0]);
1269         priv->flags |= ASYNC_SPD_CUST;
1270         priv->custom_divisor = 240;
1271         priv->force_baud = B38400;
1272         priv->force_rtscts = 1;
1273
1274         return (0);
1275 } /* ftdi_HE_TIRA1_startup */
1276
1277
1278 /* ftdi_shutdown is called from usbserial:usb_serial_disconnect
1279  *   it is called when the usb device is disconnected
1280  *
1281  *   usbserial:usb_serial_disconnect
1282  *      calls __serial_close for each open of the port
1283  *      shutdown is called then (ie ftdi_shutdown)
1284  */
1285
1286
1287 static void ftdi_shutdown (struct usb_serial *serial)
1288 { /* ftdi_shutdown */
1289
1290         struct usb_serial_port *port = serial->port[0];
1291         struct ftdi_private *priv = usb_get_serial_port_data(port);
1292
1293         dbg("%s", __FUNCTION__);
1294
1295         /* all open ports are closed at this point
1296          *    (by usbserial.c:__serial_close, which calls ftdi_close)
1297          */
1298
1299         if (priv) {
1300                 usb_set_serial_port_data(port, NULL);
1301                 kfree(priv);
1302         }
1303 } /* ftdi_shutdown */
1304
1305
1306 static int  ftdi_open (struct usb_serial_port *port, struct file *filp)
1307 { /* ftdi_open */
1308         struct termios tmp_termios;
1309         struct usb_device *dev = port->serial->dev;
1310         struct ftdi_private *priv = usb_get_serial_port_data(port);
1311         unsigned long flags;
1312
1313         int result = 0;
1314         char buf[1]; /* Needed for the usb_control_msg I think */
1315
1316         dbg("%s", __FUNCTION__);
1317
1318
1319         port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1320
1321         /* No error checking for this (will get errors later anyway) */
1322         /* See ftdi_sio.h for description of what is reset */
1323         usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1324                         FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
1325                         FTDI_SIO_RESET_SIO,
1326                         0, buf, 0, WDR_TIMEOUT);
1327
1328         /* Termios defaults are set by usb_serial_init. We don't change
1329            port->tty->termios - this would loose speed settings, etc.
1330            This is same behaviour as serial.c/rs_open() - Kuba */
1331
1332         /* ftdi_set_termios  will send usb control messages */
1333         ftdi_set_termios(port, &tmp_termios);
1334
1335         /* FIXME: Flow control might be enabled, so it should be checked -
1336            we have no control of defaults! */
1337         /* Turn on RTS and DTR since we are not flow controlling by default */
1338         if (set_dtr(port, HIGH) < 0) {
1339                 err("%s Error from DTR HIGH urb", __FUNCTION__);
1340         }
1341         if (set_rts(port, HIGH) < 0){
1342                 err("%s Error from RTS HIGH urb", __FUNCTION__);
1343         }
1344
1345         /* Not throttled */
1346         spin_lock_irqsave(&priv->rx_lock, flags);
1347         priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
1348         spin_unlock_irqrestore(&priv->rx_lock, flags);
1349
1350         /* Start reading from the device */
1351         usb_fill_bulk_urb(port->read_urb, dev,
1352                       usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress),
1353                       port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
1354                       ftdi_read_bulk_callback, port);
1355         result = usb_submit_urb(port->read_urb, GFP_KERNEL);
1356         if (result)
1357                 err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
1358
1359
1360         return result;
1361 } /* ftdi_open */
1362
1363
1364
1365 /*
1366  * usbserial:__serial_close  only calls ftdi_close if the point is open
1367  *
1368  *   This only gets called when it is the last close
1369  *
1370  *
1371  */
1372
1373 static void ftdi_close (struct usb_serial_port *port, struct file *filp)
1374 { /* ftdi_close */
1375         unsigned int c_cflag = port->tty->termios->c_cflag;
1376         char buf[1];
1377
1378         dbg("%s", __FUNCTION__);
1379
1380         if (c_cflag & HUPCL){
1381                 /* Disable flow control */
1382                 if (usb_control_msg(port->serial->dev,
1383                                     usb_sndctrlpipe(port->serial->dev, 0),
1384                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1385                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1386                                     0, 0, buf, 0, WDR_TIMEOUT) < 0) {
1387                         err("error from flowcontrol urb");
1388                 }
1389
1390                 /* drop DTR */
1391                 if (set_dtr(port, LOW) < 0){
1392                         err("Error from DTR LOW urb");
1393                 }
1394                 /* drop RTS */
1395                 if (set_rts(port, LOW) < 0) {
1396                         err("Error from RTS LOW urb");
1397                 }
1398         } /* Note change no line if hupcl is off */
1399
1400         /* shutdown our bulk read */
1401         if (port->read_urb) {
1402                 if (usb_unlink_urb (port->read_urb) < 0) {
1403                         /* Generally, this isn't an error.  If the previous
1404                            read bulk callback occurred (or is about to occur)
1405                            while the port was being closed or was throtted
1406                            (and is still throttled), the read urb will not
1407                            have been submitted. */
1408                         dbg("%s - failed to unlink read urb (generally not an error)", __FUNCTION__);
1409                 }
1410         }
1411 } /* ftdi_close */
1412
1413
1414
1415 /* The SIO requires the first byte to have:
1416  *  B0 1
1417  *  B1 0
1418  *  B2..7 length of message excluding byte 0
1419  *
1420  * The new devices do not require this byte
1421  */
1422 static int ftdi_write (struct usb_serial_port *port, int from_user,
1423                            const unsigned char *buf, int count)
1424 { /* ftdi_write */
1425         struct ftdi_private *priv = usb_get_serial_port_data(port);
1426         struct urb *urb;
1427         unsigned char *buffer;
1428         int data_offset ;       /* will be 1 for the SIO and 0 otherwise */
1429         int status;
1430         int transfer_size;
1431
1432         dbg("%s port %d, %d bytes", __FUNCTION__, port->number, count);
1433
1434         if (count == 0) {
1435                 err("write request of 0 bytes");
1436                 return 0;
1437         }
1438
1439         data_offset = priv->write_offset;
1440         dbg("data_offset set to %d",data_offset);
1441
1442         /* Determine total transfer size */
1443         transfer_size = count;
1444         if (data_offset > 0) {
1445                 /* Original sio needs control bytes too... */
1446                 transfer_size += (data_offset *
1447                                 ((count + (PKTSZ - 1 - data_offset)) /
1448                                  (PKTSZ - data_offset)));
1449         }
1450
1451         buffer = kmalloc (transfer_size, GFP_ATOMIC);
1452         if (!buffer) {
1453                 err("%s ran out of kernel memory for urb ...", __FUNCTION__);
1454                 return -ENOMEM;
1455         }
1456
1457         urb = usb_alloc_urb(0, GFP_ATOMIC);
1458         if (!urb) {
1459                 err("%s - no more free urbs", __FUNCTION__);
1460                 kfree (buffer);
1461                 return -ENOMEM;
1462         }
1463
1464         /* Copy data */
1465         if (data_offset > 0) {
1466                 /* Original sio requires control byte at start of each packet. */
1467                 int user_pktsz = PKTSZ - data_offset;
1468                 int todo = count;
1469                 unsigned char *first_byte = buffer;
1470                 const unsigned char *current_position = buf;
1471
1472                 while (todo > 0) {
1473                         if (user_pktsz > todo) {
1474                                 user_pktsz = todo;
1475                         }
1476                         /* Write the control byte at the front of the packet*/
1477                         *first_byte = 1 | ((user_pktsz) << 2);
1478                         /* Copy data for packet */
1479                         if (from_user) {
1480                                 if (copy_from_user (first_byte + data_offset,
1481                                                     current_position, user_pktsz)){
1482                                         kfree (buffer);
1483                                         usb_free_urb (urb);
1484                                         return -EFAULT;
1485                                 }
1486                         } else {
1487                                 memcpy (first_byte + data_offset,
1488                                         current_position, user_pktsz);
1489                         }
1490                         first_byte += user_pktsz + data_offset;
1491                         current_position += user_pktsz;
1492                         todo -= user_pktsz;
1493                 }
1494         } else {
1495                 /* No control byte required. */
1496                 /* Copy in the data to send */
1497                 if (from_user) {
1498                         if (copy_from_user (buffer, buf, count)) {
1499                                 kfree (buffer);
1500                                 usb_free_urb (urb);
1501                                 return -EFAULT;
1502                         }
1503                 } else {
1504                         memcpy (buffer, buf, count);
1505                 }
1506         }
1507
1508         usb_serial_debug_data(debug, &port->dev, __FUNCTION__, transfer_size, buffer);
1509
1510         /* fill the buffer and send it */
1511         usb_fill_bulk_urb(urb, port->serial->dev,
1512                       usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
1513                       buffer, transfer_size,
1514                       ftdi_write_bulk_callback, port);
1515
1516         status = usb_submit_urb(urb, GFP_ATOMIC);
1517         if (status) {
1518                 err("%s - failed submitting write urb, error %d", __FUNCTION__, status);
1519                 count = status;
1520                 kfree (buffer);
1521         }
1522
1523         /* we are done with this urb, so let the host driver
1524          * really free it when it is finished with it */
1525         usb_free_urb (urb);
1526
1527         dbg("%s write returning: %d", __FUNCTION__, count);
1528         return count;
1529 } /* ftdi_write */
1530
1531
1532 /* This function may get called when the device is closed */
1533
1534 static void ftdi_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
1535 {
1536         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1537
1538         /* free up the transfer buffer, as usb_free_urb() does not do this */
1539         kfree (urb->transfer_buffer);
1540
1541         dbg("%s - port %d", __FUNCTION__, port->number);
1542
1543         if (urb->status) {
1544                 dbg("nonzero write bulk status received: %d", urb->status);
1545                 return;
1546         }
1547
1548         schedule_work(&port->work);
1549 } /* ftdi_write_bulk_callback */
1550
1551
1552 static int ftdi_write_room( struct usb_serial_port *port )
1553 {
1554         dbg("%s - port %d", __FUNCTION__, port->number);
1555
1556         /*
1557          * We really can take anything the user throws at us
1558          * but let's pick a nice big number to tell the tty
1559          * layer that we have lots of free space
1560          */
1561         return 2048;
1562 } /* ftdi_write_room */
1563
1564
1565 static int ftdi_chars_in_buffer (struct usb_serial_port *port)
1566 { /* ftdi_chars_in_buffer */
1567         dbg("%s - port %d", __FUNCTION__, port->number);
1568
1569         /*
1570          * We can't really account for how much data we
1571          * have sent out, but hasn't made it through to the
1572          * device, so just tell the tty layer that everything
1573          * is flushed.
1574          */
1575         return 0;
1576 } /* ftdi_chars_in_buffer */
1577
1578
1579
1580 static void ftdi_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
1581 { /* ftdi_read_bulk_callback */
1582         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1583         struct tty_struct *tty;
1584         struct ftdi_private *priv;
1585
1586         if (urb->number_of_packets > 0) {
1587                 err("%s transfer_buffer_length %d actual_length %d number of packets %d",__FUNCTION__,
1588                     urb->transfer_buffer_length, urb->actual_length, urb->number_of_packets );
1589                 err("%s transfer_flags %x ", __FUNCTION__,urb->transfer_flags );
1590         }
1591
1592         dbg("%s - port %d", __FUNCTION__, port->number);
1593
1594         if (port->open_count <= 0)
1595                 return;
1596
1597         tty = port->tty;
1598         if (!tty) {
1599                 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1600                 return;
1601         }
1602
1603         priv = usb_get_serial_port_data(port);
1604         if (!priv) {
1605                 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1606                 return;
1607         }
1608
1609         if (urb != port->read_urb) {
1610                 err("%s - Not my urb!", __FUNCTION__);
1611         }
1612
1613         if (urb->status) {
1614                 /* This will happen at close every time so it is a dbg not an err */
1615                 dbg("(this is ok on close) nonzero read bulk status received: %d", urb->status);
1616                 return;
1617         }
1618
1619         /* If throttled, delay receive processing until unthrottled. */
1620         spin_lock(&priv->rx_lock);
1621         if (priv->rx_flags & THROTTLED) {
1622                 dbg("Deferring read urb processing until unthrottled");
1623                 priv->rx_flags |= ACTUALLY_THROTTLED;
1624                 spin_unlock(&priv->rx_lock);
1625                 return;
1626         }
1627         spin_unlock(&priv->rx_lock);
1628
1629         ftdi_process_read(port);
1630
1631 } /* ftdi_read_bulk_callback */
1632
1633
1634 static void ftdi_process_read (struct usb_serial_port *port)
1635 { /* ftdi_process_read */
1636         struct urb *urb;
1637         struct tty_struct *tty;
1638         struct ftdi_private *priv;
1639         char error_flag;
1640         unsigned char *data;
1641
1642         int i;
1643         int result;
1644         int need_flip;
1645         int packet_offset;
1646
1647         dbg("%s - port %d", __FUNCTION__, port->number);
1648
1649         if (port->open_count <= 0)
1650                 return;
1651
1652         tty = port->tty;
1653         if (!tty) {
1654                 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1655                 return;
1656         }
1657
1658         priv = usb_get_serial_port_data(port);
1659         if (!priv) {
1660                 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1661                 return;
1662         }
1663
1664         urb = port->read_urb;
1665         if (!urb) {
1666                 dbg("%s - bad read_urb pointer - exiting", __FUNCTION__);
1667                 return;
1668         }
1669
1670         data = urb->transfer_buffer;
1671
1672         /* The first two bytes of every read packet are status */
1673         if (urb->actual_length > 2) {
1674                 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
1675         } else {
1676                 dbg("Status only: %03oo %03oo",data[0],data[1]);
1677         }
1678
1679
1680         /* TO DO -- check for hung up line and handle appropriately: */
1681         /*   send hangup  */
1682         /* See acm.c - you do a tty_hangup  - eg tty_hangup(tty) */
1683         /* if CD is dropped and the line is not CLOCAL then we should hangup */
1684
1685         need_flip = 0;
1686         for (packet_offset=0; packet_offset < urb->actual_length; packet_offset += PKTSZ) {
1687                 /* Compare new line status to the old one, signal if different */
1688                 if (priv != NULL) {
1689                         char new_status = data[packet_offset+0] & FTDI_STATUS_B0_MASK;
1690                         if (new_status != priv->prev_status) {
1691                                 priv->diff_status |= new_status ^ priv->prev_status;
1692                                 wake_up_interruptible(&priv->delta_msr_wait);
1693                                 priv->prev_status = new_status;
1694                         }
1695                 }
1696
1697                 /* Handle errors and break */
1698                 error_flag = TTY_NORMAL;
1699                 /* Although the device uses a bitmask and hence can have multiple */
1700                 /* errors on a packet - the order here sets the priority the */
1701                 /* error is returned to the tty layer  */
1702
1703                 if ( data[packet_offset+1] & FTDI_RS_OE ) {
1704                         error_flag = TTY_OVERRUN;
1705                         dbg("OVERRRUN error");
1706                 }
1707                 if ( data[packet_offset+1] & FTDI_RS_BI ) {
1708                         error_flag = TTY_BREAK;
1709                         dbg("BREAK received");
1710                 }
1711                 if ( data[packet_offset+1] & FTDI_RS_PE ) {
1712                         error_flag = TTY_PARITY;
1713                         dbg("PARITY error");
1714                 }
1715                 if ( data[packet_offset+1] & FTDI_RS_FE ) {
1716                         error_flag = TTY_FRAME;
1717                         dbg("FRAMING error");
1718                 }
1719                 if (urb->actual_length > packet_offset + 2) {
1720                         for (i = 2; (i < PKTSZ) && ((i+packet_offset) < urb->actual_length); ++i) {
1721                                 /* have to make sure we don't overflow the buffer
1722                                   with tty_insert_flip_char's */
1723                                 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1724                                         tty_flip_buffer_push(tty);
1725                                 }
1726                                 /* Note that the error flag is duplicated for
1727                                    every character received since we don't know
1728                                    which character it applied to */
1729                                 tty_insert_flip_char(tty, data[packet_offset+i], error_flag);
1730                         }
1731                         need_flip = 1;
1732                 }
1733
1734 #ifdef NOT_CORRECT_BUT_KEEPING_IT_FOR_NOW
1735                 /* if a parity error is detected you get status packets forever
1736                    until a character is sent without a parity error.
1737                    This doesn't work well since the application receives a never
1738                    ending stream of bad data - even though new data hasn't been sent.
1739                    Therefore I (bill) have taken this out.
1740                    However - this might make sense for framing errors and so on
1741                    so I am leaving the code in for now.
1742                 */
1743                 else {
1744                         if (error_flag != TTY_NORMAL){
1745                                 dbg("error_flag is not normal");
1746                                 /* In this case it is just status - if that is an error send a bad character */
1747                                 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1748                                         tty_flip_buffer_push(tty);
1749                                 }
1750                                 tty_insert_flip_char(tty, 0xff, error_flag);
1751                                 need_flip = 1;
1752                         }
1753                 }
1754 #endif
1755         } /* "for(packet_offset=0..." */
1756
1757         /* Low latency */
1758         if (need_flip) {
1759                 tty_flip_buffer_push(tty);
1760         }
1761
1762         /* if the port is closed stop trying to read */
1763         if (port->open_count > 0){
1764                 /* Continue trying to always read  */
1765                 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
1766                               usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
1767                               port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
1768                               ftdi_read_bulk_callback, port);
1769
1770                 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1771                 if (result)
1772                         err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
1773         }
1774
1775         return;
1776 } /* ftdi_process_read */
1777
1778
1779 static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
1780 {
1781         struct ftdi_private *priv = usb_get_serial_port_data(port);
1782         __u16 urb_value = 0;
1783         char buf[1];
1784
1785         /* break_state = -1 to turn on break, and 0 to turn off break */
1786         /* see drivers/char/tty_io.c to see it used */
1787         /* last_set_data_urb_value NEVER has the break bit set in it */
1788
1789         if (break_state) {
1790                 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
1791         } else {
1792                 urb_value = priv->last_set_data_urb_value;
1793         }
1794
1795
1796         if (usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
1797                             FTDI_SIO_SET_DATA_REQUEST,
1798                             FTDI_SIO_SET_DATA_REQUEST_TYPE,
1799                             urb_value , 0,
1800                             buf, 0, WDR_TIMEOUT) < 0) {
1801                 err("%s FAILED to enable/disable break state (state was %d)", __FUNCTION__,break_state);
1802         }
1803
1804         dbg("%s break state is %d - urb is %d", __FUNCTION__,break_state, urb_value);
1805
1806 }
1807
1808
1809 /* old_termios contains the original termios settings and tty->termios contains
1810  * the new setting to be used
1811  * WARNING: set_termios calls this with old_termios in kernel space
1812  */
1813
1814 static void ftdi_set_termios (struct usb_serial_port *port, struct termios *old_termios)
1815 { /* ftdi_termios */
1816         struct usb_device *dev = port->serial->dev;
1817         unsigned int cflag = port->tty->termios->c_cflag;
1818         struct ftdi_private *priv = usb_get_serial_port_data(port);
1819         __u16 urb_value; /* will hold the new flags */
1820         char buf[1]; /* Perhaps I should dynamically alloc this? */
1821
1822         // Added for xon/xoff support
1823         unsigned int iflag = port->tty->termios->c_iflag;
1824         unsigned char vstop;
1825         unsigned char vstart;
1826
1827         dbg("%s", __FUNCTION__);
1828
1829         /* Force baud rate if this device requires it, unless it is set to B0. */
1830         if (priv->force_baud && ((port->tty->termios->c_cflag & CBAUD) != B0)) {
1831                 dbg("%s: forcing baud rate for this device", __FUNCTION__);
1832                 port->tty->termios->c_cflag &= ~CBAUD;
1833                 port->tty->termios->c_cflag |= priv->force_baud;
1834         }
1835
1836         /* Force RTS-CTS if this device requires it. */
1837         if (priv->force_rtscts) {
1838                 dbg("%s: forcing rtscts for this device", __FUNCTION__);
1839                 port->tty->termios->c_cflag |= CRTSCTS;
1840         }
1841
1842         cflag = port->tty->termios->c_cflag;
1843
1844         /* FIXME -For this cut I don't care if the line is really changing or
1845            not  - so just do the change regardless  - should be able to
1846            compare old_termios and tty->termios */
1847         /* NOTE These routines can get interrupted by
1848            ftdi_sio_read_bulk_callback  - need to examine what this
1849            means - don't see any problems yet */
1850
1851         /* Set number of data bits, parity, stop bits */
1852
1853         urb_value = 0;
1854         urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
1855                       FTDI_SIO_SET_DATA_STOP_BITS_1);
1856         urb_value |= (cflag & PARENB ?
1857                       (cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
1858                        FTDI_SIO_SET_DATA_PARITY_EVEN) :
1859                       FTDI_SIO_SET_DATA_PARITY_NONE);
1860         if (cflag & CSIZE) {
1861                 switch (cflag & CSIZE) {
1862                 case CS5: urb_value |= 5; dbg("Setting CS5"); break;
1863                 case CS6: urb_value |= 6; dbg("Setting CS6"); break;
1864                 case CS7: urb_value |= 7; dbg("Setting CS7"); break;
1865                 case CS8: urb_value |= 8; dbg("Setting CS8"); break;
1866                 default:
1867                         err("CSIZE was set but not CS5-CS8");
1868                 }
1869         }
1870
1871         /* This is needed by the break command since it uses the same command - but is
1872          *  or'ed with this value  */
1873         priv->last_set_data_urb_value = urb_value;
1874
1875         if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1876                             FTDI_SIO_SET_DATA_REQUEST,
1877                             FTDI_SIO_SET_DATA_REQUEST_TYPE,
1878                             urb_value , 0,
1879                             buf, 0, 100) < 0) {
1880                 err("%s FAILED to set databits/stopbits/parity", __FUNCTION__);
1881         }
1882
1883         /* Now do the baudrate */
1884         if ((cflag & CBAUD) == B0 ) {
1885                 /* Disable flow control */
1886                 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1887                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1888                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1889                                     0, 0,
1890                                     buf, 0, WDR_TIMEOUT) < 0) {
1891                         err("%s error from disable flowcontrol urb", __FUNCTION__);
1892                 }
1893                 /* Drop RTS and DTR */
1894                 if (set_dtr(port, LOW) < 0){
1895                         err("%s Error from DTR LOW urb", __FUNCTION__);
1896                 }
1897                 if (set_rts(port, LOW) < 0){
1898                         err("%s Error from RTS LOW urb", __FUNCTION__);
1899                 }
1900
1901         } else {
1902                 /* set the baudrate determined before */
1903                 if (change_speed(port)) {
1904                         err("%s urb failed to set baurdrate", __FUNCTION__);
1905                 }
1906         }
1907
1908         /* Set flow control */
1909         /* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
1910         if (cflag & CRTSCTS) {
1911                 dbg("%s Setting to CRTSCTS flow control", __FUNCTION__);
1912                 if (usb_control_msg(dev,
1913                                     usb_sndctrlpipe(dev, 0),
1914                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1915                                     FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1916                                     0 , FTDI_SIO_RTS_CTS_HS,
1917                                     buf, 0, WDR_TIMEOUT) < 0) {
1918                         err("urb failed to set to rts/cts flow control");
1919                 }
1920
1921         } else {
1922                 /*
1923                  * Xon/Xoff code
1924                  *
1925                  * Check the IXOFF status in the iflag component of the termios structure
1926                  * if IXOFF is not set, the pre-xon/xoff code is executed.
1927                 */
1928                 if (iflag & IXOFF) {
1929                         dbg("%s  request to enable xonxoff iflag=%04x",__FUNCTION__,iflag);
1930                         // Try to enable the XON/XOFF on the ftdi_sio
1931                         // Set the vstart and vstop -- could have been done up above where
1932                         // a lot of other dereferencing is done but that would be very
1933                         // inefficient as vstart and vstop are not always needed
1934                         vstart=port->tty->termios->c_cc[VSTART];
1935                         vstop=port->tty->termios->c_cc[VSTOP];
1936                         urb_value=(vstop << 8) | (vstart);
1937
1938                         if (usb_control_msg(dev,
1939                                             usb_sndctrlpipe(dev, 0),
1940                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1941                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1942                                             urb_value , FTDI_SIO_XON_XOFF_HS,
1943                                             buf, 0, WDR_TIMEOUT) < 0) {
1944                                 err("urb failed to set to xon/xoff flow control");
1945                         }
1946                 } else {
1947                         /* else clause to only run if cfag ! CRTSCTS and iflag ! XOFF */
1948                         /* CHECKME Assuming XON/XOFF handled by tty stack - not by device */
1949                         dbg("%s Turning off hardware flow control", __FUNCTION__);
1950                         if (usb_control_msg(dev,
1951                                             usb_sndctrlpipe(dev, 0),
1952                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1953                                             FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1954                                             0, 0,
1955                                             buf, 0, WDR_TIMEOUT) < 0) {
1956                                 err("urb failed to clear flow control");
1957                         }
1958                 }
1959
1960         }
1961         return;
1962 } /* ftdi_termios */
1963
1964
1965 static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
1966 {
1967         struct ftdi_private *priv = usb_get_serial_port_data(port);
1968         unsigned char buf[2];
1969         int ret;
1970
1971         dbg("%s TIOCMGET", __FUNCTION__);
1972         switch (priv->chip_type) {
1973         case SIO:
1974                 /* Request the status from the device */
1975                 if ((ret = usb_control_msg(port->serial->dev,
1976                                            usb_rcvctrlpipe(port->serial->dev, 0),
1977                                            FTDI_SIO_GET_MODEM_STATUS_REQUEST,
1978                                            FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
1979                                            0, 0,
1980                                            buf, 1, WDR_TIMEOUT)) < 0 ) {
1981                         err("%s Could not get modem status of device - err: %d", __FUNCTION__,
1982                             ret);
1983                         return(ret);
1984                 }
1985                 break;
1986         case FT8U232AM:
1987         case FT232BM:
1988                 /* the 8U232AM returns a two byte value (the sio is a 1 byte value) - in the same
1989                    format as the data returned from the in point */
1990                 if ((ret = usb_control_msg(port->serial->dev,
1991                                            usb_rcvctrlpipe(port->serial->dev, 0),
1992                                            FTDI_SIO_GET_MODEM_STATUS_REQUEST,
1993                                            FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
1994                                            0, 0,
1995                                            buf, 2, WDR_TIMEOUT)) < 0 ) {
1996                         err("%s Could not get modem status of device - err: %d", __FUNCTION__,
1997                             ret);
1998                         return(ret);
1999                 }
2000                 break;
2001         default:
2002                 return -EFAULT;
2003                 break;
2004         }
2005
2006         return  (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
2007                 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
2008                 (buf[0]  & FTDI_SIO_RI_MASK  ? TIOCM_RI  : 0) |
2009                 (buf[0]  & FTDI_SIO_RLSD_MASK ? TIOCM_CD  : 0) |
2010                 priv->last_dtr_rts;
2011 }
2012
2013 static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
2014 {
2015         int ret;
2016
2017         dbg("%s TIOCMSET", __FUNCTION__);
2018         if (set & TIOCM_DTR){
2019                 if ((ret = set_dtr(port, HIGH)) < 0) {
2020                         err("Urb to set DTR failed");
2021                         return(ret);
2022                 }
2023         }
2024         if (set & TIOCM_RTS) {
2025                 if ((ret = set_rts(port, HIGH)) < 0){
2026                         err("Urb to set RTS failed");
2027                         return(ret);
2028                 }
2029         }
2030
2031         if (clear & TIOCM_DTR){
2032                 if ((ret = set_dtr(port, LOW)) < 0){
2033                         err("Urb to unset DTR failed");
2034                         return(ret);
2035                 }
2036         }
2037         if (clear & TIOCM_RTS) {
2038                 if ((ret = set_rts(port, LOW)) < 0){
2039                         err("Urb to unset RTS failed");
2040                         return(ret);
2041                 }
2042         }
2043         return(0);
2044 }
2045
2046
2047 static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
2048 {
2049         struct ftdi_private *priv = usb_get_serial_port_data(port);
2050
2051         int  ret, mask;
2052
2053         dbg("%s cmd 0x%04x", __FUNCTION__, cmd);
2054
2055         /* Based on code from acm.c and others */
2056         switch (cmd) {
2057
2058         case TIOCMBIS: /* turns on (Sets) the lines as specified by the mask */
2059                 dbg("%s TIOCMBIS", __FUNCTION__);
2060                 if (get_user(mask, (unsigned long __user *) arg))
2061                         return -EFAULT;
2062                 if (mask & TIOCM_DTR){
2063                         if ((ret = set_dtr(port, HIGH)) < 0) {
2064                                 err("Urb to set DTR failed");
2065                                 return(ret);
2066                         }
2067                 }
2068                 if (mask & TIOCM_RTS) {
2069                         if ((ret = set_rts(port, HIGH)) < 0){
2070                                 err("Urb to set RTS failed");
2071                                 return(ret);
2072                         }
2073                 }
2074                 return(0);
2075                 break;
2076
2077         case TIOCMBIC: /* turns off (Clears) the lines as specified by the mask */
2078                 dbg("%s TIOCMBIC", __FUNCTION__);
2079                 if (get_user(mask, (unsigned long __user *) arg))
2080                         return -EFAULT;
2081                 if (mask & TIOCM_DTR){
2082                         if ((ret = set_dtr(port, LOW)) < 0){
2083                                 err("Urb to unset DTR failed");
2084                                 return(ret);
2085                         }
2086                 }
2087                 if (mask & TIOCM_RTS) {
2088                         if ((ret = set_rts(port, LOW)) < 0){
2089                                 err("Urb to unset RTS failed");
2090                                 return(ret);
2091                         }
2092                 }
2093                 return(0);
2094                 break;
2095
2096                 /*
2097                  * I had originally implemented TCSET{A,S}{,F,W} and
2098                  * TCGET{A,S} here separately, however when testing I
2099                  * found that the higher layers actually do the termios
2100                  * conversions themselves and pass the call onto
2101                  * ftdi_sio_set_termios.
2102                  *
2103                  */
2104
2105         case TIOCGSERIAL: /* gets serial port data */
2106                 return get_serial_info(port, (struct serial_struct __user *) arg);
2107
2108         case TIOCSSERIAL: /* sets serial port data */
2109                 return set_serial_info(port, (struct serial_struct __user *) arg);
2110
2111         /*
2112          * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2113          * - mask passed in arg for lines of interest
2114          *   (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2115          * Caller should use TIOCGICOUNT to see which one it was.
2116          *
2117          * This code is borrowed from linux/drivers/char/serial.c
2118          */
2119         case TIOCMIWAIT:
2120                 while (priv != NULL) {
2121                         interruptible_sleep_on(&priv->delta_msr_wait);
2122                         /* see if a signal did it */
2123                         if (signal_pending(current))
2124                                 return -ERESTARTSYS;
2125                         else {
2126                                 char diff = priv->diff_status;
2127
2128                                 if (diff == 0) {
2129                                         return -EIO; /* no change => error */
2130                                 }
2131
2132                                 /* Consume all events */
2133                                 priv->diff_status = 0;
2134
2135                                 /* Return 0 if caller wanted to know about these bits */
2136                                 if ( ((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
2137                                      ((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
2138                                      ((arg & TIOCM_CD)  && (diff & FTDI_RS0_RLSD)) ||
2139                                      ((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS)) ) {
2140                                         return 0;
2141                                 }
2142                                 /*
2143                                  * Otherwise caller can't care less about what happened,
2144                                  * and so we continue to wait for more events.
2145                                  */
2146                         }
2147                 }
2148                 return(0);
2149                 break;
2150         default:
2151                 break;
2152
2153         }
2154
2155
2156         /* This is not necessarily an error - turns out the higher layers will do
2157          *  some ioctls itself (see comment above)
2158          */
2159         dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __FUNCTION__, cmd);
2160
2161         return(-ENOIOCTLCMD);
2162 } /* ftdi_ioctl */
2163
2164
2165 static void ftdi_throttle (struct usb_serial_port *port)
2166 {
2167         struct ftdi_private *priv = usb_get_serial_port_data(port);
2168         unsigned long flags;
2169
2170         dbg("%s - port %d", __FUNCTION__, port->number);
2171
2172         spin_lock_irqsave(&priv->rx_lock, flags);
2173         priv->rx_flags |= THROTTLED;
2174         spin_unlock_irqrestore(&priv->rx_lock, flags);
2175 }
2176
2177
2178 static void ftdi_unthrottle (struct usb_serial_port *port)
2179 {
2180         struct ftdi_private *priv = usb_get_serial_port_data(port);
2181         int actually_throttled;
2182         unsigned long flags;
2183
2184         dbg("%s - port %d", __FUNCTION__, port->number);
2185
2186         spin_lock_irqsave(&priv->rx_lock, flags);
2187         actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
2188         priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
2189         spin_unlock_irqrestore(&priv->rx_lock, flags);
2190
2191         if (actually_throttled)
2192                 ftdi_process_read(port);
2193 }
2194
2195 static int __init ftdi_init (void)
2196 {
2197         int retval;
2198
2199         dbg("%s", __FUNCTION__);
2200         retval = usb_serial_register(&ftdi_SIO_device);
2201         if (retval)
2202                 goto failed_SIO_register;
2203         retval = usb_serial_register(&ftdi_8U232AM_device);
2204         if (retval)
2205                 goto failed_8U232AM_register;
2206         retval = usb_serial_register(&ftdi_FT232BM_device);
2207         if (retval)
2208                 goto failed_FT232BM_register;
2209         retval = usb_serial_register(&ftdi_USB_UIRT_device);
2210         if (retval)
2211                 goto failed_USB_UIRT_register;
2212         retval = usb_serial_register(&ftdi_HE_TIRA1_device);
2213         if (retval)
2214                 goto failed_HE_TIRA1_register;
2215         retval = usb_register(&ftdi_driver);
2216         if (retval)
2217                 goto failed_usb_register;
2218
2219         info(DRIVER_VERSION ":" DRIVER_DESC);
2220         return 0;
2221 failed_usb_register:
2222         usb_serial_deregister(&ftdi_HE_TIRA1_device);
2223 failed_HE_TIRA1_register:
2224         usb_serial_deregister(&ftdi_USB_UIRT_device);
2225 failed_USB_UIRT_register:
2226         usb_serial_deregister(&ftdi_FT232BM_device);
2227 failed_FT232BM_register:
2228         usb_serial_deregister(&ftdi_8U232AM_device);
2229 failed_8U232AM_register:
2230         usb_serial_deregister(&ftdi_SIO_device);
2231 failed_SIO_register:
2232         return retval;
2233 }
2234
2235
2236 static void __exit ftdi_exit (void)
2237 {
2238
2239         dbg("%s", __FUNCTION__);
2240
2241         usb_deregister (&ftdi_driver);
2242         usb_serial_deregister (&ftdi_HE_TIRA1_device);
2243         usb_serial_deregister (&ftdi_USB_UIRT_device);
2244         usb_serial_deregister (&ftdi_FT232BM_device);
2245         usb_serial_deregister (&ftdi_8U232AM_device);
2246         usb_serial_deregister (&ftdi_SIO_device);
2247
2248 }
2249
2250
2251 module_init(ftdi_init);
2252 module_exit(ftdi_exit);
2253
2254 MODULE_AUTHOR( DRIVER_AUTHOR );
2255 MODULE_DESCRIPTION( DRIVER_DESC );
2256 MODULE_LICENSE("GPL");
2257
2258 module_param(debug, bool, S_IRUGO | S_IWUSR);
2259 MODULE_PARM_DESC(debug, "Debug enabled or not");
2260