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