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 * 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 * 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);
1509 /* we are done with this urb, so let the host driver
1510 * really free it when it is finished with it */
1513 dbg("%s write returning: %d", __FUNCTION__, count);
1518 /* This function may get called when the device is closed */
1520 static void ftdi_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
1522 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1524 /* free up the transfer buffer, as usb_free_urb() does not do this */
1525 kfree (urb->transfer_buffer);
1527 dbg("%s - port %d", __FUNCTION__, port->number);
1530 dbg("nonzero write bulk status received: %d", urb->status);
1534 schedule_work(&port->work);
1535 } /* ftdi_write_bulk_callback */
1538 static int ftdi_write_room( struct usb_serial_port *port )
1540 dbg("%s - port %d", __FUNCTION__, port->number);
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
1548 } /* ftdi_write_room */
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);
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
1562 } /* ftdi_chars_in_buffer */
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;
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 );
1578 dbg("%s - port %d", __FUNCTION__, port->number);
1580 if (port->open_count <= 0)
1585 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1589 priv = usb_get_serial_port_data(port);
1591 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1595 if (urb != port->read_urb) {
1596 err("%s - Not my urb!", __FUNCTION__);
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);
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);
1613 spin_unlock(&priv->rx_lock);
1615 ftdi_process_read(port);
1617 } /* ftdi_read_bulk_callback */
1620 static void ftdi_process_read (struct usb_serial_port *port)
1621 { /* ftdi_process_read */
1623 struct tty_struct *tty;
1624 struct ftdi_private *priv;
1626 unsigned char *data;
1633 dbg("%s - port %d", __FUNCTION__, port->number);
1635 if (port->open_count <= 0)
1640 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1644 priv = usb_get_serial_port_data(port);
1646 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1650 urb = port->read_urb;
1652 dbg("%s - bad read_urb pointer - exiting", __FUNCTION__);
1656 data = urb->transfer_buffer;
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);
1662 dbg("Status only: %03oo %03oo",data[0],data[1]);
1666 /* TO DO -- check for hung up line and handle appropriately: */
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 */
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 */
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;
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 */
1689 if ( data[packet_offset+1] & FTDI_RS_OE ) {
1690 error_flag = TTY_OVERRUN;
1691 dbg("OVERRRUN error");
1693 if ( data[packet_offset+1] & FTDI_RS_BI ) {
1694 error_flag = TTY_BREAK;
1695 dbg("BREAK received");
1697 if ( data[packet_offset+1] & FTDI_RS_PE ) {
1698 error_flag = TTY_PARITY;
1699 dbg("PARITY error");
1701 if ( data[packet_offset+1] & FTDI_RS_FE ) {
1702 error_flag = TTY_FRAME;
1703 dbg("FRAMING error");
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);
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);
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.
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);
1736 tty_insert_flip_char(tty, 0xff, error_flag);
1741 } /* "for(packet_offset=0..." */
1745 tty_flip_buffer_push(tty);
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);
1756 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1758 err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
1762 } /* ftdi_process_read */
1765 static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
1767 struct ftdi_private *priv = usb_get_serial_port_data(port);
1768 __u16 urb_value = 0;
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 */
1776 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
1778 urb_value = priv->last_set_data_urb_value;
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,
1786 buf, 0, WDR_TIMEOUT) < 0) {
1787 err("%s FAILED to enable/disable break state (state was %d)", __FUNCTION__,break_state);
1790 dbg("%s break state is %d - urb is %d", __FUNCTION__,break_state, urb_value);
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
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? */
1808 // Added for xon/xoff support
1809 unsigned int iflag = port->tty->termios->c_iflag;
1810 unsigned char vstop;
1811 unsigned char vstart;
1813 dbg("%s", __FUNCTION__);
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;
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;
1828 cflag = port->tty->termios->c_cflag;
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 */
1837 /* Set number of data bits, parity, stop bits */
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;
1853 err("CSIZE was set but not CS5-CS8");
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;
1861 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1862 FTDI_SIO_SET_DATA_REQUEST,
1863 FTDI_SIO_SET_DATA_REQUEST_TYPE,
1866 err("%s FAILED to set databits/stopbits/parity", __FUNCTION__);
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,
1876 buf, 0, WDR_TIMEOUT) < 0) {
1877 err("%s error from disable flowcontrol urb", __FUNCTION__);
1879 /* Drop RTS and DTR */
1880 if (set_dtr(port, LOW) < 0){
1881 err("%s Error from DTR LOW urb", __FUNCTION__);
1883 if (set_rts(port, LOW) < 0){
1884 err("%s Error from RTS LOW urb", __FUNCTION__);
1888 /* set the baudrate determined before */
1889 if (change_speed(port)) {
1890 err("%s urb failed to set baurdrate", __FUNCTION__);
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");
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.
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);
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");
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,
1941 buf, 0, WDR_TIMEOUT) < 0) {
1942 err("urb failed to clear flow control");
1948 } /* ftdi_termios */
1951 static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
1953 struct ftdi_private *priv = usb_get_serial_port_data(port);
1954 unsigned char buf[2];
1957 dbg("%s TIOCMGET", __FUNCTION__);
1958 switch (priv->chip_type) {
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,
1966 buf, 1, WDR_TIMEOUT)) < 0 ) {
1967 err("%s Could not get modem status of device - err: %d", __FUNCTION__,
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,
1981 buf, 2, WDR_TIMEOUT)) < 0 ) {
1982 err("%s Could not get modem status of device - err: %d", __FUNCTION__,
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) |
1999 static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
2003 if (set & TIOCM_DTR){
2004 if ((ret = set_dtr(port, HIGH)) < 0) {
2005 err("Urb to set DTR failed");
2009 if (set & TIOCM_RTS) {
2010 if ((ret = set_rts(port, HIGH)) < 0){
2011 err("Urb to set RTS failed");
2016 if (clear & TIOCM_DTR){
2017 if ((ret = set_dtr(port, LOW)) < 0){
2018 err("Urb to unset DTR failed");
2022 if (clear & TIOCM_RTS) {
2023 if ((ret = set_rts(port, LOW)) < 0){
2024 err("Urb to unset RTS failed");
2032 static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
2034 struct ftdi_private *priv = usb_get_serial_port_data(port);
2038 dbg("%s cmd 0x%04x", __FUNCTION__, cmd);
2040 /* Based on code from acm.c and others */
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))
2047 if (mask & TIOCM_DTR){
2048 if ((ret = set_dtr(port, HIGH)) < 0) {
2049 err("Urb to set DTR failed");
2053 if (mask & TIOCM_RTS) {
2054 if ((ret = set_rts(port, HIGH)) < 0){
2055 err("Urb to set RTS failed");
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))
2066 if (mask & TIOCM_DTR){
2067 if ((ret = set_dtr(port, LOW)) < 0){
2068 err("Urb to unset DTR failed");
2072 if (mask & TIOCM_RTS) {
2073 if ((ret = set_rts(port, LOW)) < 0){
2074 err("Urb to unset RTS failed");
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.
2090 case TIOCGSERIAL: /* gets serial port data */
2091 return get_serial_info(port, (struct serial_struct *) arg);
2093 case TIOCSSERIAL: /* sets serial port data */
2094 return set_serial_info(port, (struct serial_struct *) arg);
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.
2102 * This code is borrowed from linux/drivers/char/serial.c
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;
2111 char diff = priv->diff_status;
2114 return -EIO; /* no change => error */
2117 /* Consume all events */
2118 priv->diff_status = 0;
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)) ) {
2128 * Otherwise caller can't care less about what happened,
2129 * and so we continue to wait for more events.
2141 /* This is not necessarily an error - turns out the higher layers will do
2142 * some ioctls itself (see comment above)
2144 dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __FUNCTION__, cmd);
2146 return(-ENOIOCTLCMD);
2150 static void ftdi_throttle (struct usb_serial_port *port)
2152 struct ftdi_private *priv = usb_get_serial_port_data(port);
2153 unsigned long flags;
2155 dbg("%s - port %d", __FUNCTION__, port->number);
2157 spin_lock_irqsave(&priv->rx_lock, flags);
2158 priv->rx_flags |= THROTTLED;
2159 spin_unlock_irqrestore(&priv->rx_lock, flags);
2163 static void ftdi_unthrottle (struct usb_serial_port *port)
2165 struct ftdi_private *priv = usb_get_serial_port_data(port);
2166 int actually_throttled;
2167 unsigned long flags;
2169 dbg("%s - port %d", __FUNCTION__, port->number);
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);
2176 if (actually_throttled)
2177 ftdi_process_read(port);
2180 static int __init ftdi_init (void)
2184 dbg("%s", __FUNCTION__);
2185 retval = usb_serial_register(&ftdi_SIO_device);
2187 goto failed_SIO_register;
2188 retval = usb_serial_register(&ftdi_8U232AM_device);
2190 goto failed_8U232AM_register;
2191 retval = usb_serial_register(&ftdi_FT232BM_device);
2193 goto failed_FT232BM_register;
2194 retval = usb_serial_register(&ftdi_USB_UIRT_device);
2196 goto failed_USB_UIRT_register;
2197 retval = usb_serial_register(&ftdi_HE_TIRA1_device);
2199 goto failed_HE_TIRA1_register;
2200 retval = usb_register(&ftdi_driver);
2202 goto failed_usb_register;
2204 info(DRIVER_VERSION ":" DRIVER_DESC);
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:
2221 static void __exit ftdi_exit (void)
2224 dbg("%s", __FUNCTION__);
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);
2236 module_init(ftdi_init);
2237 module_exit(ftdi_exit);
2239 MODULE_AUTHOR( DRIVER_AUTHOR );
2240 MODULE_DESCRIPTION( DRIVER_DESC );
2241 MODULE_LICENSE("GPL");
2243 MODULE_PARM(debug, "i");
2244 MODULE_PARM_DESC(debug, "Debug enabled or not");