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