4 * Copyright (C) 1999 - 2001
5 * Greg Kroah-Hartman (greg@kroah.com)
6 * Bill Ryder (bryder@sgi.com)
8 * Kuba Ober (kuba@mareimbrium.org)
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.
15 * See Documentation/usb/usb-serial.txt for more information on using this driver
17 * See http://ftdi-usb-sio.sourceforge.net for upto date testing info
18 * and extra documentation
20 * (27/May/2004) Ian Abbott
21 * Improved throttling code, mostly stolen from the WhiteHEAT driver.
23 * (26/Mar/2004) Jan Capek
24 * Added PID's for ICD-U20/ICD-U40 - incircuit PIC debuggers from CCS Inc.
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.
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.
37 * (17/Oct/2003) Scott Allen
38 * Added vid/pid for Perle Systems UltraPort USB serial converters
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.
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.
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.
54 * (23/Jul/2003) Ian Abbott
55 * Added PIDs for CrystalFontz 547, 633, 631, 635, 640 and 640 from
58 * (10/Jul/2003) David Glance
59 * Added PID for DSS-20 SyncStation cradle for Sony-Ericsson P800.
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.
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.
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.
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.
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.
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
99 * (11/Jun/2003) Ian Abbott
100 * Fixed unsafe spinlock usage in ftdi_write
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)
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)
110 * (23/Feb/2003) Bill Ryder
111 * Added matrix orb device vid/pids from Wayne Wylupski
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.
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
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.
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
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
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.
154 * (25/Jul/2002) Bill Ryder inserted Dmitri's TIOCMIWAIT patch
155 * Not tested by me but it doesn't break anything I use.
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
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 ;-].
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
179 * Switched from using spinlock to a semaphore, which fixes lots of problems.
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.
188 * Identify version on module load.
190 * (18/March/2001) Bill Ryder
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
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.
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
210 * (11/01/2000) Adam J. Richter
211 * usb_device_id table support
214 * Fixed bug with urb->dev not being set properly, now that the usb
218 * Removed DEBUG #ifdefs with call to usb_serial_debug_data
221 * Added module_init and module_exit functions to handle the fact that this
222 * driver is a loadable module now.
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).
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
234 * Split driver up into device specific pieces.
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 :-) */
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;
262 #include "usb-serial.h"
263 #include "ftdi_sio.h"
266 * Version Information
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"
272 static struct usb_device_id id_table_sio [] = {
273 { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
274 { } /* Terminating entry */
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
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)
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]
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 */
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 */
473 static struct usb_device_id id_table_USB_UIRT [] = {
474 { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID) },
475 { } /* Terminating entry */
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 */
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 */
576 MODULE_DEVICE_TABLE (usb, id_table_combined);
578 static struct usb_driver ftdi_driver = {
580 .probe = usb_serial_probe,
581 .disconnect = usb_serial_disconnect,
582 .id_table = id_table_combined,
586 /* Constants for read urb and write urb */
591 #define THROTTLED 0x01
592 #define ACTUALLY_THROTTLED 0x02
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
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 */
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 */
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)
620 #define FTDI_IMPL_ASYNC_FLAGS = ( ASYNC_SPD_HI | ASYNC_SPD_VHI \
621 ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP )
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);
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);
651 static struct usb_serial_device_type ftdi_SIO_device = {
652 .owner = THIS_MODULE,
654 .id_table = id_table_sio,
655 .num_interrupt_in = 0,
661 .throttle = ftdi_throttle,
662 .unthrottle = ftdi_unthrottle,
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,
671 .set_termios = ftdi_set_termios,
672 .break_ctl = ftdi_break_ctl,
673 .attach = ftdi_SIO_startup,
674 .shutdown = ftdi_shutdown,
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,
687 .throttle = ftdi_throttle,
688 .unthrottle = ftdi_unthrottle,
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,
697 .set_termios = ftdi_set_termios,
698 .break_ctl = ftdi_break_ctl,
699 .attach = ftdi_8U232AM_startup,
700 .shutdown = ftdi_shutdown,
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,
713 .throttle = ftdi_throttle,
714 .unthrottle = ftdi_unthrottle,
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,
723 .set_termios = ftdi_set_termios,
724 .break_ctl = ftdi_break_ctl,
725 .attach = ftdi_FT232BM_startup,
726 .shutdown = ftdi_shutdown,
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,
739 .throttle = ftdi_throttle,
740 .unthrottle = ftdi_unthrottle,
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,
749 .set_termios = ftdi_set_termios,
750 .break_ctl = ftdi_break_ctl,
751 .attach = ftdi_USB_UIRT_startup,
752 .shutdown = ftdi_shutdown,
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,
767 .throttle = ftdi_throttle,
768 .unthrottle = ftdi_unthrottle,
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,
777 .set_termios = ftdi_set_termios,
778 .break_ctl = ftdi_break_ctl,
779 .attach = ftdi_HE_TIRA1_startup,
780 .shutdown = ftdi_shutdown,
785 #define WDR_TIMEOUT (HZ * 5 ) /* default urb timeout */
787 /* High and low are for DTR, RTS etc etc */
792 * ***************************************************************************
794 * ***************************************************************************
797 static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
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;
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 */
811 static unsigned short int ftdi_232am_baud_to_divisor(int baud)
813 return(ftdi_232am_baud_base_to_divisor(baud, 48000000));
816 static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
818 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
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
829 static __u32 ftdi_232bm_baud_to_divisor(int baud)
831 return(ftdi_232bm_baud_base_to_divisor(baud, 48000000));
834 static int set_rts(struct usb_serial_port *port, int high_or_low)
836 struct ftdi_private *priv = usb_get_serial_port_data(port);
838 unsigned ftdi_high_or_low;
841 buf = kmalloc(1, GFP_NOIO);
846 ftdi_high_or_low = FTDI_SIO_SET_RTS_HIGH;
847 priv->last_dtr_rts |= TIOCM_RTS;
849 ftdi_high_or_low = FTDI_SIO_SET_RTS_LOW;
850 priv->last_dtr_rts &= ~TIOCM_RTS;
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,
857 buf, 0, WDR_TIMEOUT);
864 static int set_dtr(struct usb_serial_port *port, int high_or_low)
866 struct ftdi_private *priv = usb_get_serial_port_data(port);
868 unsigned ftdi_high_or_low;
871 buf = kmalloc(1, GFP_NOIO);
876 ftdi_high_or_low = FTDI_SIO_SET_DTR_HIGH;
877 priv->last_dtr_rts |= TIOCM_DTR;
879 ftdi_high_or_low = FTDI_SIO_SET_DTR_LOW;
880 priv->last_dtr_rts &= ~TIOCM_DTR;
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,
887 buf, 0, WDR_TIMEOUT);
894 static __u32 get_ftdi_divisor(struct usb_serial_port * port);
897 static int change_speed(struct usb_serial_port *port)
902 __u32 urb_index_value;
905 buf = kmalloc(1, GFP_NOIO);
909 urb_index_value = get_ftdi_divisor(port);
910 urb_value = (__u16)urb_index_value;
911 urb_index = (__u16)(urb_index_value >> 16);
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,
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);
930 char *chip_name = "";
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
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.
956 /* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
958 baud = tty_get_baud_rate(port->tty);
959 dbg("%s - tty_get_baud_rate reports speed %d", __FUNCTION__, baud);
961 /* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
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);
970 /* 3. Convert baudrate to device-specific divisor */
972 if (!baud) baud = 9600;
973 switch(priv->chip_type) {
974 case SIO: /* SIO chip */
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;
988 if (div_value == 0) {
989 dbg("%s - Baudrate (%d) requested is not supported", __FUNCTION__, baud);
990 div_value = ftdi_sio_b9600;
994 case FT8U232AM: /* 8U232AM chip */
995 chip_name = "FT8U232AM";
996 if (baud <= 3000000) {
997 div_value = ftdi_232am_baud_to_divisor(baud);
999 dbg("%s - Baud rate too high!", __FUNCTION__);
1000 div_value = ftdi_232am_baud_to_divisor(9600);
1004 case FT232BM: /* FT232BM chip */
1005 chip_name = "FT232BM";
1006 if (baud <= 3000000) {
1007 div_value = ftdi_232bm_baud_to_divisor(baud);
1009 dbg("%s - Baud rate too high!", __FUNCTION__);
1010 div_value = ftdi_232bm_baud_to_divisor(9600);
1014 } /* priv->chip_type */
1017 dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",
1018 __FUNCTION__, baud, (unsigned long)div_value, chip_name);
1025 static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
1027 struct ftdi_private *priv = usb_get_serial_port_data(port);
1028 struct serial_struct tmp;
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)))
1039 } /* get_serial_info */
1042 static int set_serial_info(struct usb_serial_port * port, struct serial_struct __user * 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;
1048 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1052 /* Do error checking and permission checking */
1054 if (!capable(CAP_SYS_ADMIN)) {
1055 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
1056 (priv->flags & ~ASYNC_USR_MASK)))
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;
1064 if ((new_serial.baud_base != priv->baud_base) ||
1065 (new_serial.baud_base < 9600))
1068 /* Make the changes - these are privileged changes! */
1070 priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
1071 (new_serial.flags & ASYNC_FLAGS));
1072 priv->custom_divisor = new_serial.custom_divisor;
1074 port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
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;
1088 port->tty->alt_speed = 0;
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))) {
1099 } /* set_serial_info */
1102 * ***************************************************************************
1103 * FTDI driver specific functions
1104 * ***************************************************************************
1107 /* Common startup subroutine */
1108 /* Called from ftdi_SIO_startup, etc. */
1109 static int ftdi_common_startup (struct usb_serial *serial)
1111 struct usb_serial_port *port = serial->port[0];
1112 struct ftdi_private *priv;
1114 dbg("%s",__FUNCTION__);
1116 priv = kmalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1118 err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
1121 memset(priv, 0, sizeof(*priv));
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;
1129 /* Increase the size of read buffers */
1130 if (port->bulk_in_buffer) {
1131 kfree (port->bulk_in_buffer);
1133 port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL);
1134 if (!port->bulk_in_buffer) {
1138 if (port->read_urb) {
1139 port->read_urb->transfer_buffer = port->bulk_in_buffer;
1140 port->read_urb->transfer_buffer_length = BUFSZ;
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;
1148 if (port->bulk_out_buffer) {
1149 kfree (port->bulk_out_buffer);
1150 port->bulk_out_buffer = NULL;
1153 usb_set_serial_port_data(serial->port[0], priv);
1159 /* Startup for the SIO chip */
1160 /* Called from usbserial:serial_probe */
1161 static int ftdi_SIO_startup (struct usb_serial *serial)
1163 struct ftdi_private *priv;
1166 dbg("%s",__FUNCTION__);
1168 err = ftdi_common_startup(serial);
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;
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;
1188 dbg("%s",__FUNCTION__);
1189 err = ftdi_common_startup(serial);
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! */
1199 } /* ftdi_8U232AM_startup */
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;
1208 dbg("%s",__FUNCTION__);
1209 err = ftdi_common_startup(serial);
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! */
1219 } /* ftdi_FT232BM_startup */
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;
1228 dbg("%s",__FUNCTION__);
1229 err = ftdi_8U232AM_startup(serial);
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;
1240 } /* ftdi_USB_UIRT_startup */
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;
1249 dbg("%s",__FUNCTION__);
1250 err = ftdi_FT232BM_startup(serial);
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;
1262 } /* ftdi_HE_TIRA1_startup */
1265 /* ftdi_shutdown is called from usbserial:usb_serial_disconnect
1266 * it is called when the usb device is disconnected
1268 * usbserial:usb_serial_disconnect
1269 * calls __serial_close for each open of the port
1270 * shutdown is called then (ie ftdi_shutdown)
1274 static void ftdi_shutdown (struct usb_serial *serial)
1275 { /* ftdi_shutdown */
1277 struct usb_serial_port *port = serial->port[0];
1278 struct ftdi_private *priv = usb_get_serial_port_data(port);
1280 dbg("%s", __FUNCTION__);
1282 /* all open ports are closed at this point
1283 * (by usbserial.c:__serial_close, which calls ftdi_close)
1287 usb_set_serial_port_data(port, NULL);
1290 } /* ftdi_shutdown */
1293 static int ftdi_open (struct usb_serial_port *port, struct file *filp)
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;
1301 char buf[1]; /* Needed for the usb_control_msg I think */
1303 dbg("%s", __FUNCTION__);
1306 port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
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,
1313 0, buf, 0, WDR_TIMEOUT);
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 */
1319 /* ftdi_set_termios will send usb control messages */
1320 ftdi_set_termios(port, &tmp_termios);
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__);
1328 if (set_rts(port, HIGH) < 0){
1329 err("%s Error from RTS HIGH urb", __FUNCTION__);
1333 spin_lock_irqsave(&priv->rx_lock, flags);
1334 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
1335 spin_unlock_irqrestore(&priv->rx_lock, flags);
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);
1344 err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
1353 * usbserial:__serial_close only calls ftdi_close if the point is open
1355 * This only gets called when it is the last close
1360 static void ftdi_close (struct usb_serial_port *port, struct file *filp)
1362 unsigned int c_cflag = port->tty->termios->c_cflag;
1365 dbg("%s", __FUNCTION__);
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");
1378 if (set_dtr(port, LOW) < 0){
1379 err("Error from DTR LOW urb");
1382 if (set_rts(port, LOW) < 0) {
1383 err("Error from RTS LOW urb");
1385 } /* Note change no line if hupcl is off */
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__);
1402 /* The SIO requires the first byte to have:
1405 * B2..7 length of message excluding byte 0
1407 * The new devices do not require this byte
1409 static int ftdi_write (struct usb_serial_port *port, int from_user,
1410 const unsigned char *buf, int count)
1412 struct ftdi_private *priv = usb_get_serial_port_data(port);
1414 unsigned char *buffer;
1415 int data_offset ; /* will be 1 for the SIO and 0 otherwise */
1419 dbg("%s port %d, %d bytes", __FUNCTION__, port->number, count);
1422 err("write request of 0 bytes");
1426 data_offset = priv->write_offset;
1427 dbg("data_offset set to %d",data_offset);
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)));
1438 buffer = kmalloc (transfer_size, GFP_ATOMIC);
1440 err("%s ran out of kernel memory for urb ...", __FUNCTION__);
1444 urb = usb_alloc_urb(0, GFP_ATOMIC);
1446 err("%s - no more free urbs", __FUNCTION__);
1452 if (data_offset > 0) {
1453 /* Original sio requires control byte at start of each packet. */
1454 int user_pktsz = PKTSZ - data_offset;
1456 unsigned char *first_byte = buffer;
1457 const unsigned char *current_position = buf;
1460 if (user_pktsz > todo) {
1463 /* Write the control byte at the front of the packet*/
1464 *first_byte = 1 | ((user_pktsz) << 2);
1465 /* Copy data for packet */
1467 if (copy_from_user (first_byte + data_offset,
1468 current_position, user_pktsz)){
1474 memcpy (first_byte + data_offset,
1475 current_position, user_pktsz);
1477 first_byte += user_pktsz + data_offset;
1478 current_position += user_pktsz;
1482 /* No control byte required. */
1483 /* Copy in the data to send */
1485 if (copy_from_user (buffer, buf, count)) {
1491 memcpy (buffer, buf, count);
1495 usb_serial_debug_data (__FILE__, __FUNCTION__, transfer_size, buffer);
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);
1503 status = usb_submit_urb(urb, GFP_ATOMIC);
1505 err("%s - failed submitting write urb, error %d", __FUNCTION__, status);
1510 /* we are done with this urb, so let the host driver
1511 * really free it when it is finished with it */
1514 dbg("%s write returning: %d", __FUNCTION__, count);
1519 /* This function may get called when the device is closed */
1521 static void ftdi_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
1523 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1525 /* free up the transfer buffer, as usb_free_urb() does not do this */
1526 kfree (urb->transfer_buffer);
1528 dbg("%s - port %d", __FUNCTION__, port->number);
1531 dbg("nonzero write bulk status received: %d", urb->status);
1535 schedule_work(&port->work);
1536 } /* ftdi_write_bulk_callback */
1539 static int ftdi_write_room( struct usb_serial_port *port )
1541 dbg("%s - port %d", __FUNCTION__, port->number);
1544 * We really can take anything the user throws at us
1545 * but let's pick a nice big number to tell the tty
1546 * layer that we have lots of free space
1549 } /* ftdi_write_room */
1552 static int ftdi_chars_in_buffer (struct usb_serial_port *port)
1553 { /* ftdi_chars_in_buffer */
1554 dbg("%s - port %d", __FUNCTION__, port->number);
1557 * We can't really account for how much data we
1558 * have sent out, but hasn't made it through to the
1559 * device, so just tell the tty layer that everything
1563 } /* ftdi_chars_in_buffer */
1567 static void ftdi_read_bulk_callback (struct urb *urb, struct pt_regs *regs)
1568 { /* ftdi_read_bulk_callback */
1569 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1570 struct tty_struct *tty;
1571 struct ftdi_private *priv;
1573 if (urb->number_of_packets > 0) {
1574 err("%s transfer_buffer_length %d actual_length %d number of packets %d",__FUNCTION__,
1575 urb->transfer_buffer_length, urb->actual_length, urb->number_of_packets );
1576 err("%s transfer_flags %x ", __FUNCTION__,urb->transfer_flags );
1579 dbg("%s - port %d", __FUNCTION__, port->number);
1581 if (port->open_count <= 0)
1586 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1590 priv = usb_get_serial_port_data(port);
1592 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1596 if (urb != port->read_urb) {
1597 err("%s - Not my urb!", __FUNCTION__);
1601 /* This will happen at close every time so it is a dbg not an err */
1602 dbg("(this is ok on close) nonzero read bulk status received: %d", urb->status);
1606 /* If throttled, delay receive processing until unthrottled. */
1607 spin_lock(&priv->rx_lock);
1608 if (priv->rx_flags & THROTTLED) {
1609 dbg("Deferring read urb processing until unthrottled");
1610 priv->rx_flags |= ACTUALLY_THROTTLED;
1611 spin_unlock(&priv->rx_lock);
1614 spin_unlock(&priv->rx_lock);
1616 ftdi_process_read(port);
1618 } /* ftdi_read_bulk_callback */
1621 static void ftdi_process_read (struct usb_serial_port *port)
1622 { /* ftdi_process_read */
1624 struct tty_struct *tty;
1625 struct ftdi_private *priv;
1627 unsigned char *data;
1634 dbg("%s - port %d", __FUNCTION__, port->number);
1636 if (port->open_count <= 0)
1641 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1645 priv = usb_get_serial_port_data(port);
1647 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1651 urb = port->read_urb;
1653 dbg("%s - bad read_urb pointer - exiting", __FUNCTION__);
1657 data = urb->transfer_buffer;
1659 /* The first two bytes of every read packet are status */
1660 if (urb->actual_length > 2) {
1661 usb_serial_debug_data (__FILE__, __FUNCTION__, urb->actual_length, data);
1663 dbg("Status only: %03oo %03oo",data[0],data[1]);
1667 /* TO DO -- check for hung up line and handle appropriately: */
1669 /* See acm.c - you do a tty_hangup - eg tty_hangup(tty) */
1670 /* if CD is dropped and the line is not CLOCAL then we should hangup */
1673 for (packet_offset=0; packet_offset < urb->actual_length; packet_offset += PKTSZ) {
1674 /* Compare new line status to the old one, signal if different */
1676 char new_status = data[packet_offset+0] & FTDI_STATUS_B0_MASK;
1677 if (new_status != priv->prev_status) {
1678 priv->diff_status |= new_status ^ priv->prev_status;
1679 wake_up_interruptible(&priv->delta_msr_wait);
1680 priv->prev_status = new_status;
1684 /* Handle errors and break */
1685 error_flag = TTY_NORMAL;
1686 /* Although the device uses a bitmask and hence can have multiple */
1687 /* errors on a packet - the order here sets the priority the */
1688 /* error is returned to the tty layer */
1690 if ( data[packet_offset+1] & FTDI_RS_OE ) {
1691 error_flag = TTY_OVERRUN;
1692 dbg("OVERRRUN error");
1694 if ( data[packet_offset+1] & FTDI_RS_BI ) {
1695 error_flag = TTY_BREAK;
1696 dbg("BREAK received");
1698 if ( data[packet_offset+1] & FTDI_RS_PE ) {
1699 error_flag = TTY_PARITY;
1700 dbg("PARITY error");
1702 if ( data[packet_offset+1] & FTDI_RS_FE ) {
1703 error_flag = TTY_FRAME;
1704 dbg("FRAMING error");
1706 if (urb->actual_length > packet_offset + 2) {
1707 for (i = 2; (i < PKTSZ) && ((i+packet_offset) < urb->actual_length); ++i) {
1708 /* have to make sure we don't overflow the buffer
1709 with tty_insert_flip_char's */
1710 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1711 tty_flip_buffer_push(tty);
1713 /* Note that the error flag is duplicated for
1714 every character received since we don't know
1715 which character it applied to */
1716 tty_insert_flip_char(tty, data[packet_offset+i], error_flag);
1721 #ifdef NOT_CORRECT_BUT_KEEPING_IT_FOR_NOW
1722 /* if a parity error is detected you get status packets forever
1723 until a character is sent without a parity error.
1724 This doesn't work well since the application receives a never
1725 ending stream of bad data - even though new data hasn't been sent.
1726 Therefore I (bill) have taken this out.
1727 However - this might make sense for framing errors and so on
1728 so I am leaving the code in for now.
1731 if (error_flag != TTY_NORMAL){
1732 dbg("error_flag is not normal");
1733 /* In this case it is just status - if that is an error send a bad character */
1734 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1735 tty_flip_buffer_push(tty);
1737 tty_insert_flip_char(tty, 0xff, error_flag);
1742 } /* "for(packet_offset=0..." */
1746 tty_flip_buffer_push(tty);
1749 /* if the port is closed stop trying to read */
1750 if (port->open_count > 0){
1751 /* Continue trying to always read */
1752 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
1753 usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
1754 port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
1755 ftdi_read_bulk_callback, port);
1757 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1759 err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
1763 } /* ftdi_process_read */
1766 static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
1768 struct ftdi_private *priv = usb_get_serial_port_data(port);
1769 __u16 urb_value = 0;
1772 /* break_state = -1 to turn on break, and 0 to turn off break */
1773 /* see drivers/char/tty_io.c to see it used */
1774 /* last_set_data_urb_value NEVER has the break bit set in it */
1777 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
1779 urb_value = priv->last_set_data_urb_value;
1783 if (usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
1784 FTDI_SIO_SET_DATA_REQUEST,
1785 FTDI_SIO_SET_DATA_REQUEST_TYPE,
1787 buf, 0, WDR_TIMEOUT) < 0) {
1788 err("%s FAILED to enable/disable break state (state was %d)", __FUNCTION__,break_state);
1791 dbg("%s break state is %d - urb is %d", __FUNCTION__,break_state, urb_value);
1796 /* old_termios contains the original termios settings and tty->termios contains
1797 * the new setting to be used
1798 * WARNING: set_termios calls this with old_termios in kernel space
1801 static void ftdi_set_termios (struct usb_serial_port *port, struct termios *old_termios)
1802 { /* ftdi_termios */
1803 struct usb_device *dev = port->serial->dev;
1804 unsigned int cflag = port->tty->termios->c_cflag;
1805 struct ftdi_private *priv = usb_get_serial_port_data(port);
1806 __u16 urb_value; /* will hold the new flags */
1807 char buf[1]; /* Perhaps I should dynamically alloc this? */
1809 // Added for xon/xoff support
1810 unsigned int iflag = port->tty->termios->c_iflag;
1811 unsigned char vstop;
1812 unsigned char vstart;
1814 dbg("%s", __FUNCTION__);
1816 /* Force baud rate if this device requires it, unless it is set to B0. */
1817 if (priv->force_baud && ((port->tty->termios->c_cflag & CBAUD) != B0)) {
1818 dbg("%s: forcing baud rate for this device", __FUNCTION__);
1819 port->tty->termios->c_cflag &= ~CBAUD;
1820 port->tty->termios->c_cflag |= priv->force_baud;
1823 /* Force RTS-CTS if this device requires it. */
1824 if (priv->force_rtscts) {
1825 dbg("%s: forcing rtscts for this device", __FUNCTION__);
1826 port->tty->termios->c_cflag |= CRTSCTS;
1829 cflag = port->tty->termios->c_cflag;
1831 /* FIXME -For this cut I don't care if the line is really changing or
1832 not - so just do the change regardless - should be able to
1833 compare old_termios and tty->termios */
1834 /* NOTE These routines can get interrupted by
1835 ftdi_sio_read_bulk_callback - need to examine what this
1836 means - don't see any problems yet */
1838 /* Set number of data bits, parity, stop bits */
1841 urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
1842 FTDI_SIO_SET_DATA_STOP_BITS_1);
1843 urb_value |= (cflag & PARENB ?
1844 (cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
1845 FTDI_SIO_SET_DATA_PARITY_EVEN) :
1846 FTDI_SIO_SET_DATA_PARITY_NONE);
1847 if (cflag & CSIZE) {
1848 switch (cflag & CSIZE) {
1849 case CS5: urb_value |= 5; dbg("Setting CS5"); break;
1850 case CS6: urb_value |= 6; dbg("Setting CS6"); break;
1851 case CS7: urb_value |= 7; dbg("Setting CS7"); break;
1852 case CS8: urb_value |= 8; dbg("Setting CS8"); break;
1854 err("CSIZE was set but not CS5-CS8");
1858 /* This is needed by the break command since it uses the same command - but is
1859 * or'ed with this value */
1860 priv->last_set_data_urb_value = urb_value;
1862 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1863 FTDI_SIO_SET_DATA_REQUEST,
1864 FTDI_SIO_SET_DATA_REQUEST_TYPE,
1867 err("%s FAILED to set databits/stopbits/parity", __FUNCTION__);
1870 /* Now do the baudrate */
1871 if ((cflag & CBAUD) == B0 ) {
1872 /* Disable flow control */
1873 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1874 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1875 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1877 buf, 0, WDR_TIMEOUT) < 0) {
1878 err("%s error from disable flowcontrol urb", __FUNCTION__);
1880 /* Drop RTS and DTR */
1881 if (set_dtr(port, LOW) < 0){
1882 err("%s Error from DTR LOW urb", __FUNCTION__);
1884 if (set_rts(port, LOW) < 0){
1885 err("%s Error from RTS LOW urb", __FUNCTION__);
1889 /* set the baudrate determined before */
1890 if (change_speed(port)) {
1891 err("%s urb failed to set baurdrate", __FUNCTION__);
1895 /* Set flow control */
1896 /* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
1897 if (cflag & CRTSCTS) {
1898 dbg("%s Setting to CRTSCTS flow control", __FUNCTION__);
1899 if (usb_control_msg(dev,
1900 usb_sndctrlpipe(dev, 0),
1901 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1902 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1903 0 , FTDI_SIO_RTS_CTS_HS,
1904 buf, 0, WDR_TIMEOUT) < 0) {
1905 err("urb failed to set to rts/cts flow control");
1912 * Check the IXOFF status in the iflag component of the termios structure
1913 * if IXOFF is not set, the pre-xon/xoff code is executed.
1915 if (iflag & IXOFF) {
1916 dbg("%s request to enable xonxoff iflag=%04x",__FUNCTION__,iflag);
1917 // Try to enable the XON/XOFF on the ftdi_sio
1918 // Set the vstart and vstop -- could have been done up above where
1919 // a lot of other dereferencing is done but that would be very
1920 // inefficient as vstart and vstop are not always needed
1921 vstart=port->tty->termios->c_cc[VSTART];
1922 vstop=port->tty->termios->c_cc[VSTOP];
1923 urb_value=(vstop << 8) | (vstart);
1925 if (usb_control_msg(dev,
1926 usb_sndctrlpipe(dev, 0),
1927 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1928 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1929 urb_value , FTDI_SIO_XON_XOFF_HS,
1930 buf, 0, WDR_TIMEOUT) < 0) {
1931 err("urb failed to set to xon/xoff flow control");
1934 /* else clause to only run if cfag ! CRTSCTS and iflag ! XOFF */
1935 /* CHECKME Assuming XON/XOFF handled by tty stack - not by device */
1936 dbg("%s Turning off hardware flow control", __FUNCTION__);
1937 if (usb_control_msg(dev,
1938 usb_sndctrlpipe(dev, 0),
1939 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1940 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1942 buf, 0, WDR_TIMEOUT) < 0) {
1943 err("urb failed to clear flow control");
1949 } /* ftdi_termios */
1952 static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
1954 struct ftdi_private *priv = usb_get_serial_port_data(port);
1955 unsigned char buf[2];
1958 dbg("%s TIOCMGET", __FUNCTION__);
1959 switch (priv->chip_type) {
1961 /* Request the status from the device */
1962 if ((ret = usb_control_msg(port->serial->dev,
1963 usb_rcvctrlpipe(port->serial->dev, 0),
1964 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
1965 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
1967 buf, 1, WDR_TIMEOUT)) < 0 ) {
1968 err("%s Could not get modem status of device - err: %d", __FUNCTION__,
1975 /* the 8U232AM returns a two byte value (the sio is a 1 byte value) - in the same
1976 format as the data returned from the in point */
1977 if ((ret = usb_control_msg(port->serial->dev,
1978 usb_rcvctrlpipe(port->serial->dev, 0),
1979 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
1980 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
1982 buf, 2, WDR_TIMEOUT)) < 0 ) {
1983 err("%s Could not get modem status of device - err: %d", __FUNCTION__,
1993 return (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
1994 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
1995 (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
1996 (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
2000 static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
2004 if (set & TIOCM_DTR){
2005 if ((ret = set_dtr(port, HIGH)) < 0) {
2006 err("Urb to set DTR failed");
2010 if (set & TIOCM_RTS) {
2011 if ((ret = set_rts(port, HIGH)) < 0){
2012 err("Urb to set RTS failed");
2017 if (clear & TIOCM_DTR){
2018 if ((ret = set_dtr(port, LOW)) < 0){
2019 err("Urb to unset DTR failed");
2023 if (clear & TIOCM_RTS) {
2024 if ((ret = set_rts(port, LOW)) < 0){
2025 err("Urb to unset RTS failed");
2033 static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
2035 struct ftdi_private *priv = usb_get_serial_port_data(port);
2039 dbg("%s cmd 0x%04x", __FUNCTION__, cmd);
2041 /* Based on code from acm.c and others */
2044 case TIOCMBIS: /* turns on (Sets) the lines as specified by the mask */
2045 dbg("%s TIOCMBIS", __FUNCTION__);
2046 if (get_user(mask, (unsigned long __user *) arg))
2048 if (mask & TIOCM_DTR){
2049 if ((ret = set_dtr(port, HIGH)) < 0) {
2050 err("Urb to set DTR failed");
2054 if (mask & TIOCM_RTS) {
2055 if ((ret = set_rts(port, HIGH)) < 0){
2056 err("Urb to set RTS failed");
2063 case TIOCMBIC: /* turns off (Clears) the lines as specified by the mask */
2064 dbg("%s TIOCMBIC", __FUNCTION__);
2065 if (get_user(mask, (unsigned long __user *) arg))
2067 if (mask & TIOCM_DTR){
2068 if ((ret = set_dtr(port, LOW)) < 0){
2069 err("Urb to unset DTR failed");
2073 if (mask & TIOCM_RTS) {
2074 if ((ret = set_rts(port, LOW)) < 0){
2075 err("Urb to unset RTS failed");
2083 * I had originally implemented TCSET{A,S}{,F,W} and
2084 * TCGET{A,S} here separately, however when testing I
2085 * found that the higher layers actually do the termios
2086 * conversions themselves and pass the call onto
2087 * ftdi_sio_set_termios.
2091 case TIOCGSERIAL: /* gets serial port data */
2092 return get_serial_info(port, (struct serial_struct __user *) arg);
2094 case TIOCSSERIAL: /* sets serial port data */
2095 return set_serial_info(port, (struct serial_struct __user *) arg);
2098 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2099 * - mask passed in arg for lines of interest
2100 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2101 * Caller should use TIOCGICOUNT to see which one it was.
2103 * This code is borrowed from linux/drivers/char/serial.c
2106 while (priv != NULL) {
2107 interruptible_sleep_on(&priv->delta_msr_wait);
2108 /* see if a signal did it */
2109 if (signal_pending(current))
2110 return -ERESTARTSYS;
2112 char diff = priv->diff_status;
2115 return -EIO; /* no change => error */
2118 /* Consume all events */
2119 priv->diff_status = 0;
2121 /* Return 0 if caller wanted to know about these bits */
2122 if ( ((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
2123 ((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
2124 ((arg & TIOCM_CD) && (diff & FTDI_RS0_RLSD)) ||
2125 ((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS)) ) {
2129 * Otherwise caller can't care less about what happened,
2130 * and so we continue to wait for more events.
2142 /* This is not necessarily an error - turns out the higher layers will do
2143 * some ioctls itself (see comment above)
2145 dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __FUNCTION__, cmd);
2147 return(-ENOIOCTLCMD);
2151 static void ftdi_throttle (struct usb_serial_port *port)
2153 struct ftdi_private *priv = usb_get_serial_port_data(port);
2154 unsigned long flags;
2156 dbg("%s - port %d", __FUNCTION__, port->number);
2158 spin_lock_irqsave(&priv->rx_lock, flags);
2159 priv->rx_flags |= THROTTLED;
2160 spin_unlock_irqrestore(&priv->rx_lock, flags);
2164 static void ftdi_unthrottle (struct usb_serial_port *port)
2166 struct ftdi_private *priv = usb_get_serial_port_data(port);
2167 int actually_throttled;
2168 unsigned long flags;
2170 dbg("%s - port %d", __FUNCTION__, port->number);
2172 spin_lock_irqsave(&priv->rx_lock, flags);
2173 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
2174 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
2175 spin_unlock_irqrestore(&priv->rx_lock, flags);
2177 if (actually_throttled)
2178 ftdi_process_read(port);
2181 static int __init ftdi_init (void)
2185 dbg("%s", __FUNCTION__);
2186 retval = usb_serial_register(&ftdi_SIO_device);
2188 goto failed_SIO_register;
2189 retval = usb_serial_register(&ftdi_8U232AM_device);
2191 goto failed_8U232AM_register;
2192 retval = usb_serial_register(&ftdi_FT232BM_device);
2194 goto failed_FT232BM_register;
2195 retval = usb_serial_register(&ftdi_USB_UIRT_device);
2197 goto failed_USB_UIRT_register;
2198 retval = usb_serial_register(&ftdi_HE_TIRA1_device);
2200 goto failed_HE_TIRA1_register;
2201 retval = usb_register(&ftdi_driver);
2203 goto failed_usb_register;
2205 info(DRIVER_VERSION ":" DRIVER_DESC);
2207 failed_usb_register:
2208 usb_serial_deregister(&ftdi_HE_TIRA1_device);
2209 failed_HE_TIRA1_register:
2210 usb_serial_deregister(&ftdi_USB_UIRT_device);
2211 failed_USB_UIRT_register:
2212 usb_serial_deregister(&ftdi_FT232BM_device);
2213 failed_FT232BM_register:
2214 usb_serial_deregister(&ftdi_8U232AM_device);
2215 failed_8U232AM_register:
2216 usb_serial_deregister(&ftdi_SIO_device);
2217 failed_SIO_register:
2222 static void __exit ftdi_exit (void)
2225 dbg("%s", __FUNCTION__);
2227 usb_deregister (&ftdi_driver);
2228 usb_serial_deregister (&ftdi_HE_TIRA1_device);
2229 usb_serial_deregister (&ftdi_USB_UIRT_device);
2230 usb_serial_deregister (&ftdi_FT232BM_device);
2231 usb_serial_deregister (&ftdi_8U232AM_device);
2232 usb_serial_deregister (&ftdi_SIO_device);
2237 module_init(ftdi_init);
2238 module_exit(ftdi_exit);
2240 MODULE_AUTHOR( DRIVER_AUTHOR );
2241 MODULE_DESCRIPTION( DRIVER_DESC );
2242 MODULE_LICENSE("GPL");
2244 MODULE_PARM(debug, "i");
2245 MODULE_PARM_DESC(debug, "Debug enabled or not");