drivers/usb/serial/ftdi_sio.c

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