1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34#include <linux/kernel.h>
35#include <linux/errno.h>
36#include <linux/init.h>
37#include <linux/slab.h>
38#include <linux/tty.h>
39#include <linux/tty_driver.h>
40#include <linux/tty_flip.h>
41#include <linux/module.h>
42#include <linux/spinlock.h>
43#include <linux/mutex.h>
44#include <linux/uaccess.h>
45#include <linux/usb.h>
46#include <linux/serial.h>
47#include <linux/usb/serial.h>
48#include "ftdi_sio.h"
49#include "ftdi_sio_ids.h"
50
51#define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>, Andreas Mohr, Johan Hovold <jhovold@gmail.com>"
52#define DRIVER_DESC "USB FTDI Serial Converters Driver"
53
54static __u16 vendor = FTDI_VID;
55static __u16 product;
56
57struct ftdi_private {
58 enum ftdi_chip_type chip_type;
59
60 int baud_base;
61 int custom_divisor;
62
63
64 __u16 last_set_data_urb_value ;
65
66
67
68 int flags;
69 unsigned long last_dtr_rts;
70 char prev_status;
71 char transmit_empty;
72 __u16 interface;
73
74
75 speed_t force_baud;
76
77 int force_rtscts;
78
79
80 unsigned int latency;
81 unsigned short max_packet_size;
82 struct mutex cfg_lock;
83};
84
85
86struct ftdi_sio_quirk {
87 int (*probe)(struct usb_serial *);
88
89 void (*port_probe)(struct ftdi_private *);
90};
91
92static int ftdi_jtag_probe(struct usb_serial *serial);
93static int ftdi_mtxorb_hack_setup(struct usb_serial *serial);
94static int ftdi_NDI_device_setup(struct usb_serial *serial);
95static int ftdi_stmclite_probe(struct usb_serial *serial);
96static int ftdi_8u2232c_probe(struct usb_serial *serial);
97static void ftdi_USB_UIRT_setup(struct ftdi_private *priv);
98static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv);
99
100static struct ftdi_sio_quirk ftdi_jtag_quirk = {
101 .probe = ftdi_jtag_probe,
102};
103
104static struct ftdi_sio_quirk ftdi_mtxorb_hack_quirk = {
105 .probe = ftdi_mtxorb_hack_setup,
106};
107
108static struct ftdi_sio_quirk ftdi_NDI_device_quirk = {
109 .probe = ftdi_NDI_device_setup,
110};
111
112static struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
113 .port_probe = ftdi_USB_UIRT_setup,
114};
115
116static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
117 .port_probe = ftdi_HE_TIRA1_setup,
118};
119
120static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
121 .probe = ftdi_stmclite_probe,
122};
123
124static struct ftdi_sio_quirk ftdi_8u2232c_quirk = {
125 .probe = ftdi_8u2232c_probe,
126};
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150static struct usb_device_id id_table_combined [] = {
151 { USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
152 { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
153 { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
154 { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
155 { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
156 { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
157 { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
158 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
159 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
160 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
161 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_3_PID) },
162 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_4_PID) },
163 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_5_PID) },
164 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_6_PID) },
165 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_7_PID) },
166 { USB_DEVICE(FTDI_VID, FTDI_USINT_CAT_PID) },
167 { USB_DEVICE(FTDI_VID, FTDI_USINT_WKEY_PID) },
168 { USB_DEVICE(FTDI_VID, FTDI_USINT_RS232_PID) },
169 { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
170 { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
171 { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
172 { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
173 { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
174 { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
175 { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
176 { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
177 { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
178 { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) ,
179 .driver_info = (kernel_ulong_t)&ftdi_8u2232c_quirk },
180 { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
181 { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
182 { USB_DEVICE(FTDI_VID, FTDI_FTX_PID) },
183 { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
184 { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
185 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
186 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
187 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
188 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
189 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
190 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_BOOST_PID) },
191 { USB_DEVICE(NEWPORT_VID, NEWPORT_AGILIS_PID) },
192 { USB_DEVICE(NEWPORT_VID, NEWPORT_CONEX_CC_PID) },
193 { USB_DEVICE(NEWPORT_VID, NEWPORT_CONEX_AGP_PID) },
194 { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
195 { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
196 { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
197 { USB_DEVICE(FTDI_VID, FTDI_LENZ_LIUSB_PID) },
198 { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
199 { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
200 { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
201 { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
202 { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
203 { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
204 { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
205 { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
206 { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
207 { USB_DEVICE(FTDI_VID, FTDI_URBAN_0_PID) },
208 { USB_DEVICE(FTDI_VID, FTDI_URBAN_1_PID) },
209 { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
210 { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
211 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
212 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
213 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
214 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
215 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
216 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
217 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
218 { USB_DEVICE(FTDI_VID, FTDI_R2000KU_TRUE_RNG) },
219 { USB_DEVICE(FTDI_VID, FTDI_VARDAAN_PID) },
220 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0100_PID) },
221 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0101_PID) },
222 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0102_PID) },
223 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0103_PID) },
224 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0104_PID) },
225 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0105_PID) },
226 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0106_PID) },
227 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0107_PID) },
228 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0108_PID) },
229 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0109_PID) },
230 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010A_PID) },
231 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010B_PID) },
232 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010C_PID) },
233 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010D_PID) },
234 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010E_PID) },
235 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010F_PID) },
236 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0110_PID) },
237 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0111_PID) },
238 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0112_PID) },
239 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0113_PID) },
240 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0114_PID) },
241 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0115_PID) },
242 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0116_PID) },
243 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0117_PID) },
244 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0118_PID) },
245 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0119_PID) },
246 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011A_PID) },
247 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011B_PID) },
248 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011C_PID) },
249 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011D_PID) },
250 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011E_PID) },
251 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011F_PID) },
252 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0120_PID) },
253 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0121_PID) },
254 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0122_PID) },
255 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0123_PID) },
256 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0124_PID) },
257 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0125_PID) },
258 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0126_PID) },
259 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0127_PID),
260 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
261 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0128_PID) },
262 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0129_PID) },
263 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012A_PID) },
264 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012B_PID) },
265 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012C_PID),
266 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
267 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012D_PID) },
268 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012E_PID) },
269 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012F_PID) },
270 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0130_PID) },
271 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0131_PID) },
272 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0132_PID) },
273 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0133_PID) },
274 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0134_PID) },
275 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0135_PID) },
276 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0136_PID) },
277 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0137_PID) },
278 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0138_PID) },
279 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0139_PID) },
280 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013A_PID) },
281 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013B_PID) },
282 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013C_PID) },
283 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013D_PID) },
284 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013E_PID) },
285 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013F_PID) },
286 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0140_PID) },
287 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0141_PID) },
288 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0142_PID) },
289 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0143_PID) },
290 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0144_PID) },
291 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0145_PID) },
292 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0146_PID) },
293 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0147_PID) },
294 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0148_PID) },
295 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0149_PID) },
296 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014A_PID) },
297 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014B_PID) },
298 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014C_PID) },
299 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014D_PID) },
300 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014E_PID) },
301 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014F_PID) },
302 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0150_PID) },
303 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0151_PID) },
304 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0152_PID) },
305 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0153_PID),
306 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
307 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0154_PID),
308 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
309 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0155_PID),
310 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
311 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0156_PID),
312 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
313 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0157_PID),
314 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
315 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0158_PID),
316 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
317 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0159_PID) },
318 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015A_PID) },
319 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015B_PID) },
320 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015C_PID) },
321 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015D_PID) },
322 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015E_PID) },
323 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015F_PID) },
324 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0160_PID) },
325 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0161_PID) },
326 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0162_PID) },
327 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0163_PID) },
328 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0164_PID) },
329 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0165_PID) },
330 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0166_PID) },
331 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0167_PID) },
332 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0168_PID) },
333 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0169_PID) },
334 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016A_PID) },
335 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016B_PID) },
336 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016C_PID) },
337 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016D_PID) },
338 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016E_PID) },
339 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016F_PID) },
340 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0170_PID) },
341 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0171_PID) },
342 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0172_PID) },
343 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0173_PID) },
344 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0174_PID) },
345 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0175_PID) },
346 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0176_PID) },
347 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0177_PID) },
348 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0178_PID) },
349 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0179_PID) },
350 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017A_PID) },
351 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017B_PID) },
352 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017C_PID) },
353 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017D_PID) },
354 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017E_PID) },
355 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017F_PID) },
356 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0180_PID) },
357 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0181_PID) },
358 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0182_PID) },
359 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0183_PID) },
360 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0184_PID) },
361 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0185_PID) },
362 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0186_PID) },
363 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0187_PID) },
364 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0188_PID) },
365 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0189_PID) },
366 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018A_PID) },
367 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018B_PID) },
368 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018C_PID) },
369 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018D_PID) },
370 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018E_PID) },
371 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018F_PID) },
372 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0190_PID) },
373 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0191_PID) },
374 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0192_PID) },
375 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0193_PID) },
376 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0194_PID) },
377 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0195_PID) },
378 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0196_PID) },
379 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0197_PID) },
380 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0198_PID) },
381 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0199_PID) },
382 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019A_PID) },
383 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019B_PID) },
384 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019C_PID) },
385 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019D_PID) },
386 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019E_PID) },
387 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019F_PID) },
388 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A0_PID) },
389 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A1_PID) },
390 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A2_PID) },
391 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A3_PID) },
392 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A4_PID) },
393 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A5_PID) },
394 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A6_PID) },
395 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A7_PID) },
396 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A8_PID) },
397 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A9_PID) },
398 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AA_PID) },
399 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AB_PID) },
400 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AC_PID) },
401 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AD_PID) },
402 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AE_PID) },
403 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AF_PID) },
404 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B0_PID) },
405 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B1_PID) },
406 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B2_PID) },
407 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B3_PID) },
408 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B4_PID) },
409 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B5_PID) },
410 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B6_PID) },
411 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B7_PID) },
412 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B8_PID) },
413 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B9_PID) },
414 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BA_PID) },
415 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BB_PID) },
416 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BC_PID) },
417 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BD_PID) },
418 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BE_PID) },
419 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BF_PID) },
420 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C0_PID) },
421 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C1_PID) },
422 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C2_PID) },
423 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C3_PID) },
424 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C4_PID) },
425 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C5_PID) },
426 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C6_PID) },
427 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C7_PID) },
428 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C8_PID) },
429 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C9_PID) },
430 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CA_PID) },
431 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CB_PID) },
432 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CC_PID) },
433 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CD_PID) },
434 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CE_PID) },
435 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CF_PID) },
436 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D0_PID) },
437 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D1_PID) },
438 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D2_PID) },
439 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D3_PID) },
440 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D4_PID) },
441 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D5_PID) },
442 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D6_PID) },
443 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D7_PID) },
444 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D8_PID) },
445 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D9_PID) },
446 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DA_PID) },
447 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DB_PID) },
448 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DC_PID) },
449 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DD_PID) },
450 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DE_PID) },
451 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DF_PID) },
452 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E0_PID) },
453 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E1_PID) },
454 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E2_PID) },
455 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E3_PID) },
456 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E4_PID) },
457 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E5_PID) },
458 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E6_PID) },
459 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E7_PID) },
460 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E8_PID) },
461 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E9_PID) },
462 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EA_PID) },
463 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EB_PID) },
464 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EC_PID) },
465 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01ED_PID) },
466 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EE_PID) },
467 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EF_PID) },
468 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F0_PID) },
469 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F1_PID) },
470 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F2_PID) },
471 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F3_PID) },
472 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F4_PID) },
473 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F5_PID) },
474 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F6_PID) },
475 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F7_PID) },
476 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F8_PID) },
477 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F9_PID) },
478 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FA_PID) },
479 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FB_PID) },
480 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FC_PID) },
481 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FD_PID) },
482 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FE_PID) },
483 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FF_PID) },
484 { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
485 { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
486 { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
487 { USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
488 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
489 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
490 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
491 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
492 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
493 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
494 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
495 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
496 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
497 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
498 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
499 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
500 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
501 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
502 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
503 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
504 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
505 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
506 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
507 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
508 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
509 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
510 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
511 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
512 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
513 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
514 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
515 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
516 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
517 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
518 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
519 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
520 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
521 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
522 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
523 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
524 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
525 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
526 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
527 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
528 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
529 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
530 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
531 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
532 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
533 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
534 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
535 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_1_PID) },
536 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_2_PID) },
537 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_3_PID) },
538 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803R_4_PID) },
539 { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
540 { USB_DEVICE(OCT_VID, OCT_US101_PID) },
541 { USB_DEVICE(OCT_VID, OCT_DK201_PID) },
542 { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
543 .driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
544 { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
545 .driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
546 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
547 { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
548 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
549 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
550 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
551 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
552 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
553 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
554 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
555 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
556 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
557 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
558 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
559 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
560 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
561 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
562 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
563 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
564 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
565 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
566 { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
567 { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
568 { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
569 { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
570 { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
571 { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
572 { USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
573 { USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
574 { USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
575 { USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
576 { USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
577 { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
578 { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
579 { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
580 { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
581 { USB_DEVICE(FTDI_VID, FTDI_TIAO_UMPA_PID),
582 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
583
584
585
586 { USB_DEVICE(FTDI_ELV_VID, FTDI_ELV_WS300_PID) },
587 { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
588 { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
589 { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
590 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
591 { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
592 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
593 { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
594 { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
595 { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
596 { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
597 { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
598 { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
599 { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
600 { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
601 { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
602 { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
603 { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
604 { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
605 { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
606 { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
607 { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
608 { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
609 { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
610 { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
611 { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
612 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
613 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
614 { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
615 { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
616 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
617 { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
618 { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
619 { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
620 { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
621 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
622 { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
623 { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
624 { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
625 { USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
626 { USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
627 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
628 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
629 { USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
630 { USB_DEVICE(FTDI_VID, FTDI_CCSLOAD_N_GO_3_PID) },
631 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU64_4_PID) },
632 { USB_DEVICE(FTDI_VID, FTDI_CCSPRIME8_5_PID) },
633 { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
634 { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
635 { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
636 { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
637 { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
638 { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
639 { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
640 { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
641 { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
642 { USB_DEVICE(ACTON_VID, ACTON_SPECTRAPRO_PID) },
643 { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
644 { USB_DEVICE(MITSUBISHI_VID, MITSUBISHI_FXUSB_PID) },
645 { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
646 { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
647 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
648 { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
649 { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
650 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
651 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
652 { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
653 { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
654 { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
655 { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
656 { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
657 { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
658 { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
659 { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
660 { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
661 { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
662 { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
663 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
664 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
665 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
666 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
667 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
668 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
669 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
670 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
671 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
672 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
673 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
674 { USB_DEVICE(FTDI_VID, FTDI_OMNI1509) },
675 { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
676 { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
677 { USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
678 { USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
679 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
680 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
681 { USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
682 { USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
683 { USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
684 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
685 { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
686 { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
687 { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
688 { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
689 { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
690 { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
691 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
692 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
693 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
694 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
695 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
696 { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
697 { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
698 { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
699 { USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
700 { USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
701 { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
702 { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
703 { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
704 { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
705 { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
706 { USB_DEVICE(FTDI_VID, FTDI_NZR_SEM_USB_PID) },
707 { USB_DEVICE(ICOM_VID, ICOM_ID_1_PID) },
708 { USB_DEVICE(ICOM_VID, ICOM_OPC_U_UC_PID) },
709 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C1_PID) },
710 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C2_PID) },
711 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2D_PID) },
712 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VT_PID) },
713 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VR_PID) },
714 { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVT_PID) },
715 { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVR_PID) },
716 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVT_PID) },
717 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVR_PID) },
718 { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
719 { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
720 { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
721 { USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
722 { USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
723 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
724 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
725 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
726 { USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
727 { USB_DEVICE(FTDI_VID, FTDI_NDI_HUC_PID),
728 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
729 { USB_DEVICE(FTDI_VID, FTDI_NDI_SPECTRA_SCU_PID),
730 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
731 { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_2_PID),
732 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
733 { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_3_PID),
734 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
735 { USB_DEVICE(FTDI_VID, FTDI_NDI_AURORA_SCU_PID),
736 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
737 { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
738 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S03_PID) },
739 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_59_PID) },
740 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_57A_PID) },
741 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_57B_PID) },
742 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29A_PID) },
743 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29B_PID) },
744 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29F_PID) },
745 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_62B_PID) },
746 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S01_PID) },
747 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_63_PID) },
748 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_29C_PID) },
749 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_81B_PID) },
750 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_82B_PID) },
751 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_K5D_PID) },
752 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_K4Y_PID) },
753 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_K5G_PID) },
754 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_S05_PID) },
755 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_60_PID) },
756 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_61_PID) },
757 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_62_PID) },
758 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_63B_PID) },
759 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_64_PID) },
760 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_65_PID) },
761 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_92_PID) },
762 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_92D_PID) },
763 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_W5R_PID) },
764 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_A5R_PID) },
765 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_USB_PW1_PID) },
766 { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
767 { USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
768 { USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
769 { USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
770 { USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
771 { USB_DEVICE(FTDI_VID, FTDI_PROPOX_ISPCABLEIII_PID) },
772 { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
773 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
774 { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID),
775 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
776 { USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID),
777 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
778 { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
779 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
780 { USB_DEVICE(FTDI_VID, LMI_LM3S_DEVEL_BOARD_PID),
781 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
782 { USB_DEVICE(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID),
783 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
784 { USB_DEVICE(FTDI_VID, LMI_LM3S_ICDI_BOARD_PID),
785 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
786 { USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID),
787 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
788 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
789 { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
790
791
792 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
793 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
794 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
795 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
796 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
797 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
798 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
799 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
800 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
801 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
802 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
803 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
804 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
805 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
806 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
807 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
808 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
809 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
810 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
811 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
812 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
813 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
814 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
815 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
816 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
817 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
818 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
819 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
820
821 { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
822 { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
823 { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
824 { USB_DEVICE(FTDI_VID, DIEBOLD_BCS_SE923_PID) },
825 { USB_DEVICE(ATMEL_VID, STK541_PID) },
826 { USB_DEVICE(DE_VID, STB_PID) },
827 { USB_DEVICE(DE_VID, WHT_PID) },
828 { USB_DEVICE(ADI_VID, ADI_GNICE_PID),
829 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
830 { USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID),
831 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
832 { USB_DEVICE_AND_INTERFACE_INFO(MICROCHIP_VID, MICROCHIP_USB_BOARD_PID,
833 USB_CLASS_VENDOR_SPEC,
834 USB_SUBCLASS_VENDOR_SPEC, 0x00) },
835 { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
836 { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID),
837 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
838 { USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) },
839 { USB_DEVICE(GN_OTOMETRICS_VID, AURICAL_USB_PID) },
840 { USB_DEVICE(FTDI_VID, PI_C865_PID) },
841 { USB_DEVICE(FTDI_VID, PI_C857_PID) },
842 { USB_DEVICE(PI_VID, PI_C866_PID) },
843 { USB_DEVICE(PI_VID, PI_C663_PID) },
844 { USB_DEVICE(PI_VID, PI_C725_PID) },
845 { USB_DEVICE(PI_VID, PI_E517_PID) },
846 { USB_DEVICE(PI_VID, PI_C863_PID) },
847 { USB_DEVICE(PI_VID, PI_E861_PID) },
848 { USB_DEVICE(PI_VID, PI_C867_PID) },
849 { USB_DEVICE(PI_VID, PI_E609_PID) },
850 { USB_DEVICE(PI_VID, PI_E709_PID) },
851 { USB_DEVICE(PI_VID, PI_100F_PID) },
852 { USB_DEVICE(PI_VID, PI_1011_PID) },
853 { USB_DEVICE(PI_VID, PI_1012_PID) },
854 { USB_DEVICE(PI_VID, PI_1013_PID) },
855 { USB_DEVICE(PI_VID, PI_1014_PID) },
856 { USB_DEVICE(PI_VID, PI_1015_PID) },
857 { USB_DEVICE(PI_VID, PI_1016_PID) },
858 { USB_DEVICE(KONDO_VID, KONDO_USB_SERIAL_PID) },
859 { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
860 { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
861 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
862 { USB_DEVICE(FTDI_VID, TI_XDS100V2_PID),
863 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
864 { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
865 { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
866 { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
867 { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
868 { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
869 { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
870 { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
871 { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
872 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_ST_PID),
873 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
874 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SLITE_PID),
875 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
876 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH2_PID),
877 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
878 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID),
879 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
880 { USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
881 { USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
882 { USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID),
883 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
884 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
885 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_PC_WING_PID) },
886 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_USB_DMX_PID) },
887 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MIDI_TIMECODE_PID) },
888 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MINI_WING_PID) },
889 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
890 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
891 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
892 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
893 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
894 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
895 { USB_DEVICE(FTDI_VID, FTDI_CINTERION_MC55I_PID) },
896 { USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
897 { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID),
898 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
899 { USB_DEVICE(ST_VID, ST_STMCLT_2232_PID),
900 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
901 { USB_DEVICE(ST_VID, ST_STMCLT_4232_PID),
902 .driver_info = (kernel_ulong_t)&ftdi_stmclite_quirk },
903 { USB_DEVICE(FTDI_VID, FTDI_RF_R106) },
904 { USB_DEVICE(FTDI_VID, FTDI_DISTORTEC_JTAG_LOCK_PICK_PID),
905 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
906 { USB_DEVICE(FTDI_VID, FTDI_LUMEL_PD12_PID) },
907
908 { USB_DEVICE(FTDI_VID, FTDI_CT_COMET_PID) },
909 { },
910 { }
911};
912
913MODULE_DEVICE_TABLE(usb, id_table_combined);
914
915static const char *ftdi_chip_name[] = {
916 [SIO] = "SIO",
917 [FT8U232AM] = "FT8U232AM",
918 [FT232BM] = "FT232BM",
919 [FT2232C] = "FT2232C",
920 [FT232RL] = "FT232RL",
921 [FT2232H] = "FT2232H",
922 [FT4232H] = "FT4232H",
923 [FT232H] = "FT232H",
924 [FTX] = "FT-X"
925};
926
927
928
929#define FTDI_STATUS_B0_MASK (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
930#define FTDI_STATUS_B1_MASK (FTDI_RS_BI)
931
932
933#define FTDI_IMPL_ASYNC_FLAGS = (ASYNC_SPD_HI | ASYNC_SPD_VHI \
934 | ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP)
935
936
937static int ftdi_sio_probe(struct usb_serial *serial,
938 const struct usb_device_id *id);
939static int ftdi_sio_port_probe(struct usb_serial_port *port);
940static int ftdi_sio_port_remove(struct usb_serial_port *port);
941static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
942static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
943static void ftdi_process_read_urb(struct urb *urb);
944static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
945 void *dest, size_t size);
946static void ftdi_set_termios(struct tty_struct *tty,
947 struct usb_serial_port *port, struct ktermios *old);
948static int ftdi_tiocmget(struct tty_struct *tty);
949static int ftdi_tiocmset(struct tty_struct *tty,
950 unsigned int set, unsigned int clear);
951static int ftdi_ioctl(struct tty_struct *tty,
952 unsigned int cmd, unsigned long arg);
953static void ftdi_break_ctl(struct tty_struct *tty, int break_state);
954static bool ftdi_tx_empty(struct usb_serial_port *port);
955static int ftdi_get_modem_status(struct usb_serial_port *port,
956 unsigned char status[2]);
957
958static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base);
959static unsigned short int ftdi_232am_baud_to_divisor(int baud);
960static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base);
961static __u32 ftdi_232bm_baud_to_divisor(int baud);
962static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base);
963static __u32 ftdi_2232h_baud_to_divisor(int baud);
964
965static struct usb_serial_driver ftdi_sio_device = {
966 .driver = {
967 .owner = THIS_MODULE,
968 .name = "ftdi_sio",
969 },
970 .description = "FTDI USB Serial Device",
971 .id_table = id_table_combined,
972 .num_ports = 1,
973 .bulk_in_size = 512,
974 .bulk_out_size = 256,
975 .probe = ftdi_sio_probe,
976 .port_probe = ftdi_sio_port_probe,
977 .port_remove = ftdi_sio_port_remove,
978 .open = ftdi_open,
979 .dtr_rts = ftdi_dtr_rts,
980 .throttle = usb_serial_generic_throttle,
981 .unthrottle = usb_serial_generic_unthrottle,
982 .process_read_urb = ftdi_process_read_urb,
983 .prepare_write_buffer = ftdi_prepare_write_buffer,
984 .tiocmget = ftdi_tiocmget,
985 .tiocmset = ftdi_tiocmset,
986 .tiocmiwait = usb_serial_generic_tiocmiwait,
987 .get_icount = usb_serial_generic_get_icount,
988 .ioctl = ftdi_ioctl,
989 .set_termios = ftdi_set_termios,
990 .break_ctl = ftdi_break_ctl,
991 .tx_empty = ftdi_tx_empty,
992};
993
994static struct usb_serial_driver * const serial_drivers[] = {
995 &ftdi_sio_device, NULL
996};
997
998
999#define WDR_TIMEOUT 5000
1000#define WDR_SHORT_TIMEOUT 1000
1001
1002
1003#define HIGH 1
1004#define LOW 0
1005
1006
1007
1008
1009
1010
1011
1012static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
1013{
1014 unsigned short int divisor;
1015
1016 int divisor3 = base / 2 / baud;
1017 if ((divisor3 & 0x7) == 7)
1018 divisor3++;
1019 divisor = divisor3 >> 3;
1020 divisor3 &= 0x7;
1021 if (divisor3 == 1)
1022 divisor |= 0xc000;
1023 else if (divisor3 >= 4)
1024 divisor |= 0x4000;
1025 else if (divisor3 != 0)
1026 divisor |= 0x8000;
1027 else if (divisor == 1)
1028 divisor = 0;
1029 return divisor;
1030}
1031
1032static unsigned short int ftdi_232am_baud_to_divisor(int baud)
1033{
1034 return ftdi_232am_baud_base_to_divisor(baud, 48000000);
1035}
1036
1037static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
1038{
1039 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
1040 __u32 divisor;
1041
1042 int divisor3 = base / 2 / baud;
1043 divisor = divisor3 >> 3;
1044 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
1045
1046 if (divisor == 1)
1047 divisor = 0;
1048 else if (divisor == 0x4001)
1049 divisor = 1;
1050 return divisor;
1051}
1052
1053static __u32 ftdi_232bm_baud_to_divisor(int baud)
1054{
1055 return ftdi_232bm_baud_base_to_divisor(baud, 48000000);
1056}
1057
1058static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base)
1059{
1060 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
1061 __u32 divisor;
1062 int divisor3;
1063
1064
1065 divisor3 = base * 8 / (baud * 10);
1066
1067 divisor = divisor3 >> 3;
1068 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
1069
1070 if (divisor == 1)
1071 divisor = 0;
1072 else if (divisor == 0x4001)
1073 divisor = 1;
1074
1075
1076
1077
1078
1079 divisor |= 0x00020000;
1080 return divisor;
1081}
1082
1083static __u32 ftdi_2232h_baud_to_divisor(int baud)
1084{
1085 return ftdi_2232h_baud_base_to_divisor(baud, 120000000);
1086}
1087
1088#define set_mctrl(port, set) update_mctrl((port), (set), 0)
1089#define clear_mctrl(port, clear) update_mctrl((port), 0, (clear))
1090
1091static int update_mctrl(struct usb_serial_port *port, unsigned int set,
1092 unsigned int clear)
1093{
1094 struct ftdi_private *priv = usb_get_serial_port_data(port);
1095 struct device *dev = &port->dev;
1096 unsigned urb_value;
1097 int rv;
1098
1099 if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
1100 dev_dbg(dev, "%s - DTR|RTS not being set|cleared\n", __func__);
1101 return 0;
1102 }
1103
1104 clear &= ~set;
1105 urb_value = 0;
1106 if (clear & TIOCM_DTR)
1107 urb_value |= FTDI_SIO_SET_DTR_LOW;
1108 if (clear & TIOCM_RTS)
1109 urb_value |= FTDI_SIO_SET_RTS_LOW;
1110 if (set & TIOCM_DTR)
1111 urb_value |= FTDI_SIO_SET_DTR_HIGH;
1112 if (set & TIOCM_RTS)
1113 urb_value |= FTDI_SIO_SET_RTS_HIGH;
1114 rv = usb_control_msg(port->serial->dev,
1115 usb_sndctrlpipe(port->serial->dev, 0),
1116 FTDI_SIO_SET_MODEM_CTRL_REQUEST,
1117 FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1118 urb_value, priv->interface,
1119 NULL, 0, WDR_TIMEOUT);
1120 if (rv < 0) {
1121 dev_dbg(dev, "%s Error from MODEM_CTRL urb: DTR %s, RTS %s\n",
1122 __func__,
1123 (set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
1124 (set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
1125 rv = usb_translate_errors(rv);
1126 } else {
1127 dev_dbg(dev, "%s - DTR %s, RTS %s\n", __func__,
1128 (set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
1129 (set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
1130
1131 priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
1132 }
1133 return rv;
1134}
1135
1136
1137static __u32 get_ftdi_divisor(struct tty_struct *tty,
1138 struct usb_serial_port *port)
1139{
1140 struct ftdi_private *priv = usb_get_serial_port_data(port);
1141 struct device *dev = &port->dev;
1142 __u32 div_value = 0;
1143 int div_okay = 1;
1144 int baud;
1145
1146
1147
1148
1149
1150
1151
1152
1153
1154
1155
1156
1157
1158
1159
1160
1161
1162
1163
1164
1165
1166
1167
1168
1169
1170
1171
1172
1173
1174
1175
1176 baud = tty_get_baud_rate(tty);
1177 dev_dbg(dev, "%s - tty_get_baud_rate reports speed %d\n", __func__, baud);
1178
1179
1180
1181
1182 if (baud == 38400 &&
1183 ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1184 (priv->custom_divisor)) {
1185 baud = priv->baud_base / priv->custom_divisor;
1186 dev_dbg(dev, "%s - custom divisor %d sets baud rate to %d\n",
1187 __func__, priv->custom_divisor, baud);
1188 }
1189
1190
1191
1192 if (!baud)
1193 baud = 9600;
1194 switch (priv->chip_type) {
1195 case SIO:
1196 switch (baud) {
1197 case 300: div_value = ftdi_sio_b300; break;
1198 case 600: div_value = ftdi_sio_b600; break;
1199 case 1200: div_value = ftdi_sio_b1200; break;
1200 case 2400: div_value = ftdi_sio_b2400; break;
1201 case 4800: div_value = ftdi_sio_b4800; break;
1202 case 9600: div_value = ftdi_sio_b9600; break;
1203 case 19200: div_value = ftdi_sio_b19200; break;
1204 case 38400: div_value = ftdi_sio_b38400; break;
1205 case 57600: div_value = ftdi_sio_b57600; break;
1206 case 115200: div_value = ftdi_sio_b115200; break;
1207 }
1208 if (div_value == 0) {
1209 dev_dbg(dev, "%s - Baudrate (%d) requested is not supported\n",
1210 __func__, baud);
1211 div_value = ftdi_sio_b9600;
1212 baud = 9600;
1213 div_okay = 0;
1214 }
1215 break;
1216 case FT8U232AM:
1217 if (baud <= 3000000) {
1218 div_value = ftdi_232am_baud_to_divisor(baud);
1219 } else {
1220 dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
1221 baud = 9600;
1222 div_value = ftdi_232am_baud_to_divisor(9600);
1223 div_okay = 0;
1224 }
1225 break;
1226 case FT232BM:
1227 case FT2232C:
1228 case FT232RL:
1229 case FTX:
1230 if (baud <= 3000000) {
1231 __u16 product_id = le16_to_cpu(
1232 port->serial->dev->descriptor.idProduct);
1233 if (((FTDI_NDI_HUC_PID == product_id) ||
1234 (FTDI_NDI_SPECTRA_SCU_PID == product_id) ||
1235 (FTDI_NDI_FUTURE_2_PID == product_id) ||
1236 (FTDI_NDI_FUTURE_3_PID == product_id) ||
1237 (FTDI_NDI_AURORA_SCU_PID == product_id)) &&
1238 (baud == 19200)) {
1239 baud = 1200000;
1240 }
1241 div_value = ftdi_232bm_baud_to_divisor(baud);
1242 } else {
1243 dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
1244 div_value = ftdi_232bm_baud_to_divisor(9600);
1245 div_okay = 0;
1246 baud = 9600;
1247 }
1248 break;
1249 case FT2232H:
1250 case FT4232H:
1251 case FT232H:
1252 if ((baud <= 12000000) && (baud >= 1200)) {
1253 div_value = ftdi_2232h_baud_to_divisor(baud);
1254 } else if (baud < 1200) {
1255 div_value = ftdi_232bm_baud_to_divisor(baud);
1256 } else {
1257 dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
1258 div_value = ftdi_232bm_baud_to_divisor(9600);
1259 div_okay = 0;
1260 baud = 9600;
1261 }
1262 break;
1263 }
1264
1265 if (div_okay) {
1266 dev_dbg(dev, "%s - Baud rate set to %d (divisor 0x%lX) on chip %s\n",
1267 __func__, baud, (unsigned long)div_value,
1268 ftdi_chip_name[priv->chip_type]);
1269 }
1270
1271 tty_encode_baud_rate(tty, baud, baud);
1272 return div_value;
1273}
1274
1275static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
1276{
1277 struct ftdi_private *priv = usb_get_serial_port_data(port);
1278 __u16 urb_value;
1279 __u16 urb_index;
1280 __u32 urb_index_value;
1281 int rv;
1282
1283 urb_index_value = get_ftdi_divisor(tty, port);
1284 urb_value = (__u16)urb_index_value;
1285 urb_index = (__u16)(urb_index_value >> 16);
1286 if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
1287 (priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
1288
1289
1290 urb_index = (__u16)((urb_index << 8) | priv->interface);
1291 }
1292
1293 rv = usb_control_msg(port->serial->dev,
1294 usb_sndctrlpipe(port->serial->dev, 0),
1295 FTDI_SIO_SET_BAUDRATE_REQUEST,
1296 FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
1297 urb_value, urb_index,
1298 NULL, 0, WDR_SHORT_TIMEOUT);
1299 return rv;
1300}
1301
1302static int write_latency_timer(struct usb_serial_port *port)
1303{
1304 struct ftdi_private *priv = usb_get_serial_port_data(port);
1305 struct usb_device *udev = port->serial->dev;
1306 int rv;
1307 int l = priv->latency;
1308
1309 if (priv->flags & ASYNC_LOW_LATENCY)
1310 l = 1;
1311
1312 dev_dbg(&port->dev, "%s: setting latency timer = %i\n", __func__, l);
1313
1314 rv = usb_control_msg(udev,
1315 usb_sndctrlpipe(udev, 0),
1316 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1317 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1318 l, priv->interface,
1319 NULL, 0, WDR_TIMEOUT);
1320 if (rv < 0)
1321 dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
1322 return rv;
1323}
1324
1325static int read_latency_timer(struct usb_serial_port *port)
1326{
1327 struct ftdi_private *priv = usb_get_serial_port_data(port);
1328 struct usb_device *udev = port->serial->dev;
1329 unsigned char *buf;
1330 int rv;
1331
1332 buf = kmalloc(1, GFP_KERNEL);
1333 if (!buf)
1334 return -ENOMEM;
1335
1336 rv = usb_control_msg(udev,
1337 usb_rcvctrlpipe(udev, 0),
1338 FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
1339 FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
1340 0, priv->interface,
1341 buf, 1, WDR_TIMEOUT);
1342 if (rv < 0)
1343 dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
1344 else
1345 priv->latency = buf[0];
1346
1347 kfree(buf);
1348
1349 return rv;
1350}
1351
1352static int get_serial_info(struct usb_serial_port *port,
1353 struct serial_struct __user *retinfo)
1354{
1355 struct ftdi_private *priv = usb_get_serial_port_data(port);
1356 struct serial_struct tmp;
1357
1358 if (!retinfo)
1359 return -EFAULT;
1360 memset(&tmp, 0, sizeof(tmp));
1361 tmp.flags = priv->flags;
1362 tmp.baud_base = priv->baud_base;
1363 tmp.custom_divisor = priv->custom_divisor;
1364 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1365 return -EFAULT;
1366 return 0;
1367}
1368
1369static int set_serial_info(struct tty_struct *tty,
1370 struct usb_serial_port *port, struct serial_struct __user *newinfo)
1371{
1372 struct ftdi_private *priv = usb_get_serial_port_data(port);
1373 struct serial_struct new_serial;
1374 struct ftdi_private old_priv;
1375
1376 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1377 return -EFAULT;
1378
1379 mutex_lock(&priv->cfg_lock);
1380 old_priv = *priv;
1381
1382
1383
1384 if (!capable(CAP_SYS_ADMIN)) {
1385 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
1386 (priv->flags & ~ASYNC_USR_MASK))) {
1387 mutex_unlock(&priv->cfg_lock);
1388 return -EPERM;
1389 }
1390 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
1391 (new_serial.flags & ASYNC_USR_MASK));
1392 priv->custom_divisor = new_serial.custom_divisor;
1393 goto check_and_exit;
1394 }
1395
1396 if (new_serial.baud_base != priv->baud_base) {
1397 mutex_unlock(&priv->cfg_lock);
1398 return -EINVAL;
1399 }
1400
1401
1402
1403 priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
1404 (new_serial.flags & ASYNC_FLAGS));
1405 priv->custom_divisor = new_serial.custom_divisor;
1406
1407 write_latency_timer(port);
1408
1409check_and_exit:
1410 if ((old_priv.flags & ASYNC_SPD_MASK) !=
1411 (priv->flags & ASYNC_SPD_MASK)) {
1412 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1413 tty->alt_speed = 57600;
1414 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1415 tty->alt_speed = 115200;
1416 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1417 tty->alt_speed = 230400;
1418 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1419 tty->alt_speed = 460800;
1420 else
1421 tty->alt_speed = 0;
1422 }
1423 if (((old_priv.flags & ASYNC_SPD_MASK) !=
1424 (priv->flags & ASYNC_SPD_MASK)) ||
1425 (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1426 (old_priv.custom_divisor != priv->custom_divisor))) {
1427 change_speed(tty, port);
1428 mutex_unlock(&priv->cfg_lock);
1429 }
1430 else
1431 mutex_unlock(&priv->cfg_lock);
1432 return 0;
1433}
1434
1435static int get_lsr_info(struct usb_serial_port *port,
1436 struct serial_struct __user *retinfo)
1437{
1438 struct ftdi_private *priv = usb_get_serial_port_data(port);
1439 unsigned int result = 0;
1440
1441 if (!retinfo)
1442 return -EFAULT;
1443
1444 if (priv->transmit_empty)
1445 result = TIOCSER_TEMT;
1446
1447 if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
1448 return -EFAULT;
1449 return 0;
1450}
1451
1452
1453
1454static void ftdi_determine_type(struct usb_serial_port *port)
1455{
1456 struct ftdi_private *priv = usb_get_serial_port_data(port);
1457 struct usb_serial *serial = port->serial;
1458 struct usb_device *udev = serial->dev;
1459 unsigned version;
1460 unsigned interfaces;
1461
1462
1463 priv->baud_base = 48000000 / 2;
1464
1465 version = le16_to_cpu(udev->descriptor.bcdDevice);
1466 interfaces = udev->actconfig->desc.bNumInterfaces;
1467 dev_dbg(&port->dev, "%s: bcdDevice = 0x%x, bNumInterfaces = %u\n", __func__,
1468 version, interfaces);
1469 if (interfaces > 1) {
1470 int inter;
1471
1472
1473 if (version == 0x0800) {
1474 priv->chip_type = FT4232H;
1475
1476 priv->baud_base = 120000000 / 2;
1477 } else if (version == 0x0700) {
1478 priv->chip_type = FT2232H;
1479
1480 priv->baud_base = 120000000 / 2;
1481 } else
1482 priv->chip_type = FT2232C;
1483
1484
1485 inter = serial->interface->altsetting->desc.bInterfaceNumber;
1486 if (inter == 0) {
1487 priv->interface = INTERFACE_A;
1488 } else if (inter == 1) {
1489 priv->interface = INTERFACE_B;
1490 } else if (inter == 2) {
1491 priv->interface = INTERFACE_C;
1492 } else if (inter == 3) {
1493 priv->interface = INTERFACE_D;
1494 }
1495
1496
1497 if (version < 0x500) {
1498 dev_dbg(&port->dev,
1499 "%s: something fishy - bcdDevice too low for multi-interface device\n",
1500 __func__);
1501 }
1502 } else if (version < 0x200) {
1503
1504 priv->chip_type = SIO;
1505 priv->baud_base = 12000000 / 16;
1506 } else if (version < 0x400) {
1507
1508
1509
1510 priv->chip_type = FT8U232AM;
1511 } else if (version < 0x600) {
1512
1513 priv->chip_type = FT232BM;
1514 } else if (version < 0x900) {
1515
1516 priv->chip_type = FT232RL;
1517 } else if (version < 0x1000) {
1518
1519 priv->chip_type = FT232H;
1520 } else {
1521
1522 priv->chip_type = FTX;
1523 }
1524
1525 dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
1526}
1527
1528
1529
1530
1531
1532static void ftdi_set_max_packet_size(struct usb_serial_port *port)
1533{
1534 struct ftdi_private *priv = usb_get_serial_port_data(port);
1535 struct usb_serial *serial = port->serial;
1536 struct usb_device *udev = serial->dev;
1537
1538 struct usb_interface *interface = serial->interface;
1539 struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
1540
1541 unsigned num_endpoints;
1542 int i;
1543
1544 num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
1545 dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
1546
1547
1548
1549
1550
1551 for (i = 0; i < num_endpoints; i++) {
1552 dev_info(&udev->dev, "Endpoint %d MaxPacketSize %d\n", i+1,
1553 interface->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
1554 ep_desc = &interface->cur_altsetting->endpoint[i].desc;
1555 if (ep_desc->wMaxPacketSize == 0) {
1556 ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
1557 dev_info(&udev->dev, "Overriding wMaxPacketSize on endpoint %d\n", i);
1558 }
1559 }
1560
1561
1562 priv->max_packet_size = usb_endpoint_maxp(ep_desc);
1563
1564 dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size);
1565}
1566
1567
1568
1569
1570
1571
1572
1573
1574static ssize_t show_latency_timer(struct device *dev,
1575 struct device_attribute *attr, char *buf)
1576{
1577 struct usb_serial_port *port = to_usb_serial_port(dev);
1578 struct ftdi_private *priv = usb_get_serial_port_data(port);
1579 if (priv->flags & ASYNC_LOW_LATENCY)
1580 return sprintf(buf, "1\n");
1581 else
1582 return sprintf(buf, "%i\n", priv->latency);
1583}
1584
1585
1586
1587static ssize_t store_latency_timer(struct device *dev,
1588 struct device_attribute *attr, const char *valbuf,
1589 size_t count)
1590{
1591 struct usb_serial_port *port = to_usb_serial_port(dev);
1592 struct ftdi_private *priv = usb_get_serial_port_data(port);
1593 int v = simple_strtoul(valbuf, NULL, 10);
1594 int rv;
1595
1596 priv->latency = v;
1597 rv = write_latency_timer(port);
1598 if (rv < 0)
1599 return -EIO;
1600 return count;
1601}
1602
1603
1604
1605static ssize_t store_event_char(struct device *dev,
1606 struct device_attribute *attr, const char *valbuf, size_t count)
1607{
1608 struct usb_serial_port *port = to_usb_serial_port(dev);
1609 struct ftdi_private *priv = usb_get_serial_port_data(port);
1610 struct usb_device *udev = port->serial->dev;
1611 int v = simple_strtoul(valbuf, NULL, 10);
1612 int rv;
1613
1614 dev_dbg(&port->dev, "%s: setting event char = %i\n", __func__, v);
1615
1616 rv = usb_control_msg(udev,
1617 usb_sndctrlpipe(udev, 0),
1618 FTDI_SIO_SET_EVENT_CHAR_REQUEST,
1619 FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
1620 v, priv->interface,
1621 NULL, 0, WDR_TIMEOUT);
1622 if (rv < 0) {
1623 dev_dbg(&port->dev, "Unable to write event character: %i\n", rv);
1624 return -EIO;
1625 }
1626
1627 return count;
1628}
1629
1630static DEVICE_ATTR(latency_timer, S_IWUSR | S_IRUGO, show_latency_timer,
1631 store_latency_timer);
1632static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
1633
1634static int create_sysfs_attrs(struct usb_serial_port *port)
1635{
1636 struct ftdi_private *priv = usb_get_serial_port_data(port);
1637 int retval = 0;
1638
1639
1640
1641 if (priv->chip_type != SIO) {
1642 dev_dbg(&port->dev, "sysfs attributes for %s\n", ftdi_chip_name[priv->chip_type]);
1643 retval = device_create_file(&port->dev, &dev_attr_event_char);
1644 if ((!retval) &&
1645 (priv->chip_type == FT232BM ||
1646 priv->chip_type == FT2232C ||
1647 priv->chip_type == FT232RL ||
1648 priv->chip_type == FT2232H ||
1649 priv->chip_type == FT4232H ||
1650 priv->chip_type == FT232H ||
1651 priv->chip_type == FTX)) {
1652 retval = device_create_file(&port->dev,
1653 &dev_attr_latency_timer);
1654 }
1655 }
1656 return retval;
1657}
1658
1659static void remove_sysfs_attrs(struct usb_serial_port *port)
1660{
1661 struct ftdi_private *priv = usb_get_serial_port_data(port);
1662
1663
1664 if (priv->chip_type != SIO) {
1665 device_remove_file(&port->dev, &dev_attr_event_char);
1666 if (priv->chip_type == FT232BM ||
1667 priv->chip_type == FT2232C ||
1668 priv->chip_type == FT232RL ||
1669 priv->chip_type == FT2232H ||
1670 priv->chip_type == FT4232H ||
1671 priv->chip_type == FT232H ||
1672 priv->chip_type == FTX) {
1673 device_remove_file(&port->dev, &dev_attr_latency_timer);
1674 }
1675 }
1676
1677}
1678
1679
1680
1681
1682
1683
1684
1685
1686static int ftdi_sio_probe(struct usb_serial *serial,
1687 const struct usb_device_id *id)
1688{
1689 struct ftdi_sio_quirk *quirk =
1690 (struct ftdi_sio_quirk *)id->driver_info;
1691
1692 if (quirk && quirk->probe) {
1693 int ret = quirk->probe(serial);
1694 if (ret != 0)
1695 return ret;
1696 }
1697
1698 usb_set_serial_data(serial, (void *)id->driver_info);
1699
1700 return 0;
1701}
1702
1703static int ftdi_sio_port_probe(struct usb_serial_port *port)
1704{
1705 struct ftdi_private *priv;
1706 struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
1707
1708
1709 priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1710 if (!priv) {
1711 dev_err(&port->dev, "%s- kmalloc(%Zd) failed.\n", __func__,
1712 sizeof(struct ftdi_private));
1713 return -ENOMEM;
1714 }
1715
1716 mutex_init(&priv->cfg_lock);
1717
1718 priv->flags = ASYNC_LOW_LATENCY;
1719
1720 if (quirk && quirk->port_probe)
1721 quirk->port_probe(priv);
1722
1723 usb_set_serial_port_data(port, priv);
1724
1725 ftdi_determine_type(port);
1726 ftdi_set_max_packet_size(port);
1727 if (read_latency_timer(port) < 0)
1728 priv->latency = 16;
1729 write_latency_timer(port);
1730 create_sysfs_attrs(port);
1731 return 0;
1732}
1733
1734
1735
1736
1737static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
1738{
1739 priv->flags |= ASYNC_SPD_CUST;
1740 priv->custom_divisor = 77;
1741 priv->force_baud = 38400;
1742}
1743
1744
1745
1746
1747static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv)
1748{
1749 priv->flags |= ASYNC_SPD_CUST;
1750 priv->custom_divisor = 240;
1751 priv->force_baud = 38400;
1752 priv->force_rtscts = 1;
1753}
1754
1755
1756
1757
1758
1759
1760static int ndi_latency_timer = 1;
1761
1762
1763
1764
1765
1766
1767static int ftdi_NDI_device_setup(struct usb_serial *serial)
1768{
1769 struct usb_device *udev = serial->dev;
1770 int latency = ndi_latency_timer;
1771
1772 if (latency == 0)
1773 latency = 1;
1774 if (latency > 99)
1775 latency = 99;
1776
1777 dev_dbg(&udev->dev, "%s setting NDI device latency to %d\n", __func__, latency);
1778 dev_info(&udev->dev, "NDI device with a latency value of %d\n", latency);
1779
1780
1781 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1782 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1783 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1784 latency, 0, NULL, 0, WDR_TIMEOUT);
1785 return 0;
1786}
1787
1788
1789
1790
1791
1792
1793static int ftdi_jtag_probe(struct usb_serial *serial)
1794{
1795 struct usb_device *udev = serial->dev;
1796 struct usb_interface *interface = serial->interface;
1797
1798 if (interface == udev->actconfig->interface[0]) {
1799 dev_info(&udev->dev,
1800 "Ignoring serial port reserved for JTAG\n");
1801 return -ENODEV;
1802 }
1803
1804 return 0;
1805}
1806
1807static int ftdi_8u2232c_probe(struct usb_serial *serial)
1808{
1809 struct usb_device *udev = serial->dev;
1810
1811 if ((udev->manufacturer && !strcmp(udev->manufacturer, "CALAO Systems")) ||
1812 (udev->product && !strcmp(udev->product, "BeagleBone/XDS100V2")))
1813 return ftdi_jtag_probe(serial);
1814
1815 return 0;
1816}
1817
1818
1819
1820
1821
1822
1823
1824
1825static int ftdi_stmclite_probe(struct usb_serial *serial)
1826{
1827 struct usb_device *udev = serial->dev;
1828 struct usb_interface *interface = serial->interface;
1829
1830 if (interface == udev->actconfig->interface[0] ||
1831 interface == udev->actconfig->interface[1]) {
1832 dev_info(&udev->dev, "Ignoring serial port reserved for JTAG\n");
1833 return -ENODEV;
1834 }
1835
1836 return 0;
1837}
1838
1839
1840
1841
1842
1843static int ftdi_mtxorb_hack_setup(struct usb_serial *serial)
1844{
1845 struct usb_host_endpoint *ep = serial->dev->ep_in[1];
1846 struct usb_endpoint_descriptor *ep_desc = &ep->desc;
1847
1848 if (ep->enabled && ep_desc->wMaxPacketSize == 0) {
1849 ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
1850 dev_info(&serial->dev->dev,
1851 "Fixing invalid wMaxPacketSize on read pipe\n");
1852 }
1853
1854 return 0;
1855}
1856
1857static int ftdi_sio_port_remove(struct usb_serial_port *port)
1858{
1859 struct ftdi_private *priv = usb_get_serial_port_data(port);
1860
1861 remove_sysfs_attrs(port);
1862
1863 kfree(priv);
1864
1865 return 0;
1866}
1867
1868static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
1869{
1870 struct ktermios dummy;
1871 struct usb_device *dev = port->serial->dev;
1872 struct ftdi_private *priv = usb_get_serial_port_data(port);
1873
1874
1875
1876 usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1877 FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
1878 FTDI_SIO_RESET_SIO,
1879 priv->interface, NULL, 0, WDR_TIMEOUT);
1880
1881
1882
1883
1884
1885
1886 if (tty) {
1887 memset(&dummy, 0, sizeof(dummy));
1888 ftdi_set_termios(tty, port, &dummy);
1889 }
1890
1891 return usb_serial_generic_open(tty, port);
1892}
1893
1894static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
1895{
1896 struct ftdi_private *priv = usb_get_serial_port_data(port);
1897
1898
1899 if (!on) {
1900 if (usb_control_msg(port->serial->dev,
1901 usb_sndctrlpipe(port->serial->dev, 0),
1902 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1903 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1904 0, priv->interface, NULL, 0,
1905 WDR_TIMEOUT) < 0) {
1906 dev_err(&port->dev, "error from flowcontrol urb\n");
1907 }
1908 }
1909
1910 if (on)
1911 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1912 else
1913 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1914}
1915
1916
1917
1918
1919
1920
1921
1922
1923static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
1924 void *dest, size_t size)
1925{
1926 struct ftdi_private *priv;
1927 int count;
1928 unsigned long flags;
1929
1930 priv = usb_get_serial_port_data(port);
1931
1932 if (priv->chip_type == SIO) {
1933 unsigned char *buffer = dest;
1934 int i, len, c;
1935
1936 count = 0;
1937 spin_lock_irqsave(&port->lock, flags);
1938 for (i = 0; i < size - 1; i += priv->max_packet_size) {
1939 len = min_t(int, size - i, priv->max_packet_size) - 1;
1940 c = kfifo_out(&port->write_fifo, &buffer[i + 1], len);
1941 if (!c)
1942 break;
1943 port->icount.tx += c;
1944 buffer[i] = (c << 2) + 1;
1945 count += c + 1;
1946 }
1947 spin_unlock_irqrestore(&port->lock, flags);
1948 } else {
1949 count = kfifo_out_locked(&port->write_fifo, dest, size,
1950 &port->lock);
1951 port->icount.tx += count;
1952 }
1953
1954 return count;
1955}
1956
1957#define FTDI_RS_ERR_MASK (FTDI_RS_BI | FTDI_RS_PE | FTDI_RS_FE | FTDI_RS_OE)
1958
1959static int ftdi_process_packet(struct usb_serial_port *port,
1960 struct ftdi_private *priv, char *packet, int len)
1961{
1962 int i;
1963 char status;
1964 char flag;
1965 char *ch;
1966
1967 if (len < 2) {
1968 dev_dbg(&port->dev, "malformed packet\n");
1969 return 0;
1970 }
1971
1972
1973
1974
1975 status = packet[0] & FTDI_STATUS_B0_MASK;
1976 if (status != priv->prev_status) {
1977 char diff_status = status ^ priv->prev_status;
1978
1979 if (diff_status & FTDI_RS0_CTS)
1980 port->icount.cts++;
1981 if (diff_status & FTDI_RS0_DSR)
1982 port->icount.dsr++;
1983 if (diff_status & FTDI_RS0_RI)
1984 port->icount.rng++;
1985 if (diff_status & FTDI_RS0_RLSD)
1986 port->icount.dcd++;
1987
1988 wake_up_interruptible(&port->port.delta_msr_wait);
1989 priv->prev_status = status;
1990 }
1991
1992 flag = TTY_NORMAL;
1993 if (packet[1] & FTDI_RS_ERR_MASK) {
1994
1995
1996 if (packet[1] & FTDI_RS_BI) {
1997 flag = TTY_BREAK;
1998 port->icount.brk++;
1999 usb_serial_handle_break(port);
2000 } else if (packet[1] & FTDI_RS_PE) {
2001 flag = TTY_PARITY;
2002 port->icount.parity++;
2003 } else if (packet[1] & FTDI_RS_FE) {
2004 flag = TTY_FRAME;
2005 port->icount.frame++;
2006 }
2007
2008 if (packet[1] & FTDI_RS_OE) {
2009 port->icount.overrun++;
2010 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
2011 }
2012 }
2013
2014
2015 if (packet[1] & FTDI_RS_TEMT)
2016 priv->transmit_empty = 1;
2017 else
2018 priv->transmit_empty = 0;
2019
2020 len -= 2;
2021 if (!len)
2022 return 0;
2023 port->icount.rx += len;
2024 ch = packet + 2;
2025
2026 if (port->port.console && port->sysrq) {
2027 for (i = 0; i < len; i++, ch++) {
2028 if (!usb_serial_handle_sysrq_char(port, *ch))
2029 tty_insert_flip_char(&port->port, *ch, flag);
2030 }
2031 } else {
2032 tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
2033 }
2034
2035 return len;
2036}
2037
2038static void ftdi_process_read_urb(struct urb *urb)
2039{
2040 struct usb_serial_port *port = urb->context;
2041 struct ftdi_private *priv = usb_get_serial_port_data(port);
2042 char *data = (char *)urb->transfer_buffer;
2043 int i;
2044 int len;
2045 int count = 0;
2046
2047 for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
2048 len = min_t(int, urb->actual_length - i, priv->max_packet_size);
2049 count += ftdi_process_packet(port, priv, &data[i], len);
2050 }
2051
2052 if (count)
2053 tty_flip_buffer_push(&port->port);
2054}
2055
2056static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
2057{
2058 struct usb_serial_port *port = tty->driver_data;
2059 struct ftdi_private *priv = usb_get_serial_port_data(port);
2060 __u16 urb_value;
2061
2062
2063
2064
2065
2066 if (break_state)
2067 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
2068 else
2069 urb_value = priv->last_set_data_urb_value;
2070
2071 if (usb_control_msg(port->serial->dev,
2072 usb_sndctrlpipe(port->serial->dev, 0),
2073 FTDI_SIO_SET_DATA_REQUEST,
2074 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2075 urb_value , priv->interface,
2076 NULL, 0, WDR_TIMEOUT) < 0) {
2077 dev_err(&port->dev, "%s FAILED to enable/disable break state (state was %d)\n",
2078 __func__, break_state);
2079 }
2080
2081 dev_dbg(&port->dev, "%s break state is %d - urb is %d\n", __func__,
2082 break_state, urb_value);
2083
2084}
2085
2086static bool ftdi_tx_empty(struct usb_serial_port *port)
2087{
2088 unsigned char buf[2];
2089 int ret;
2090
2091 ret = ftdi_get_modem_status(port, buf);
2092 if (ret == 2) {
2093 if (!(buf[1] & FTDI_RS_TEMT))
2094 return false;
2095 }
2096
2097 return true;
2098}
2099
2100
2101
2102
2103
2104static void ftdi_set_termios(struct tty_struct *tty,
2105 struct usb_serial_port *port, struct ktermios *old_termios)
2106{
2107 struct usb_device *dev = port->serial->dev;
2108 struct device *ddev = &port->dev;
2109 struct ftdi_private *priv = usb_get_serial_port_data(port);
2110 struct ktermios *termios = &tty->termios;
2111 unsigned int cflag = termios->c_cflag;
2112 __u16 urb_value;
2113
2114
2115 unsigned int iflag = termios->c_iflag;
2116 unsigned char vstop;
2117 unsigned char vstart;
2118
2119
2120
2121 if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
2122 dev_dbg(ddev, "%s: forcing baud rate for this device\n", __func__);
2123 tty_encode_baud_rate(tty, priv->force_baud,
2124 priv->force_baud);
2125 }
2126
2127
2128 if (priv->force_rtscts) {
2129 dev_dbg(ddev, "%s: forcing rtscts for this device\n", __func__);
2130 termios->c_cflag |= CRTSCTS;
2131 }
2132
2133 cflag = termios->c_cflag;
2134
2135 if (!old_termios)
2136 goto no_skip;
2137
2138 if (old_termios->c_cflag == termios->c_cflag
2139 && old_termios->c_ispeed == termios->c_ispeed
2140 && old_termios->c_ospeed == termios->c_ospeed)
2141 goto no_c_cflag_changes;
2142
2143
2144
2145
2146
2147 if ((old_termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)) ==
2148 (termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)))
2149 goto no_data_parity_stop_changes;
2150
2151no_skip:
2152
2153
2154 urb_value = 0;
2155 urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
2156 FTDI_SIO_SET_DATA_STOP_BITS_1);
2157 if (cflag & PARENB) {
2158 if (cflag & CMSPAR)
2159 urb_value |= cflag & PARODD ?
2160 FTDI_SIO_SET_DATA_PARITY_MARK :
2161 FTDI_SIO_SET_DATA_PARITY_SPACE;
2162 else
2163 urb_value |= cflag & PARODD ?
2164 FTDI_SIO_SET_DATA_PARITY_ODD :
2165 FTDI_SIO_SET_DATA_PARITY_EVEN;
2166 } else {
2167 urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
2168 }
2169 if (cflag & CSIZE) {
2170 switch (cflag & CSIZE) {
2171 case CS7:
2172 urb_value |= 7;
2173 dev_dbg(ddev, "Setting CS7\n");
2174 break;
2175 case CS8:
2176 urb_value |= 8;
2177 dev_dbg(ddev, "Setting CS8\n");
2178 break;
2179 default:
2180 dev_err(ddev, "CSIZE was set but not CS7-CS8\n");
2181 }
2182 }
2183
2184
2185
2186 priv->last_set_data_urb_value = urb_value;
2187
2188 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2189 FTDI_SIO_SET_DATA_REQUEST,
2190 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2191 urb_value , priv->interface,
2192 NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
2193 dev_err(ddev, "%s FAILED to set databits/stopbits/parity\n",
2194 __func__);
2195 }
2196
2197
2198no_data_parity_stop_changes:
2199 if ((cflag & CBAUD) == B0) {
2200
2201 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2202 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2203 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2204 0, priv->interface,
2205 NULL, 0, WDR_TIMEOUT) < 0) {
2206 dev_err(ddev, "%s error from disable flowcontrol urb\n",
2207 __func__);
2208 }
2209
2210 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2211 } else {
2212
2213 mutex_lock(&priv->cfg_lock);
2214 if (change_speed(tty, port))
2215 dev_err(ddev, "%s urb failed to set baudrate\n", __func__);
2216 mutex_unlock(&priv->cfg_lock);
2217
2218 if (!old_termios || (old_termios->c_cflag & CBAUD) == B0)
2219 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2220 }
2221
2222
2223
2224no_c_cflag_changes:
2225 if (cflag & CRTSCTS) {
2226 dev_dbg(ddev, "%s Setting to CRTSCTS flow control\n", __func__);
2227 if (usb_control_msg(dev,
2228 usb_sndctrlpipe(dev, 0),
2229 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2230 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2231 0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
2232 NULL, 0, WDR_TIMEOUT) < 0) {
2233 dev_err(ddev, "urb failed to set to rts/cts flow control\n");
2234 }
2235 } else {
2236
2237
2238
2239
2240
2241
2242
2243 if (iflag & IXOFF) {
2244 dev_dbg(ddev, "%s request to enable xonxoff iflag=%04x\n",
2245 __func__, iflag);
2246
2247
2248
2249
2250
2251
2252 vstart = termios->c_cc[VSTART];
2253 vstop = termios->c_cc[VSTOP];
2254 urb_value = (vstop << 8) | (vstart);
2255
2256 if (usb_control_msg(dev,
2257 usb_sndctrlpipe(dev, 0),
2258 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2259 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2260 urb_value , (FTDI_SIO_XON_XOFF_HS
2261 | priv->interface),
2262 NULL, 0, WDR_TIMEOUT) < 0) {
2263 dev_err(&port->dev, "urb failed to set to "
2264 "xon/xoff flow control\n");
2265 }
2266 } else {
2267
2268
2269
2270 dev_dbg(ddev, "%s Turning off hardware flow control\n", __func__);
2271 if (usb_control_msg(dev,
2272 usb_sndctrlpipe(dev, 0),
2273 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2274 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2275 0, priv->interface,
2276 NULL, 0, WDR_TIMEOUT) < 0) {
2277 dev_err(ddev, "urb failed to clear flow control\n");
2278 }
2279 }
2280 }
2281}
2282
2283
2284
2285
2286
2287
2288
2289static int ftdi_get_modem_status(struct usb_serial_port *port,
2290 unsigned char status[2])
2291{
2292 struct ftdi_private *priv = usb_get_serial_port_data(port);
2293 unsigned char *buf;
2294 int len;
2295 int ret;
2296
2297 buf = kmalloc(2, GFP_KERNEL);
2298 if (!buf)
2299 return -ENOMEM;
2300
2301
2302
2303
2304 switch (priv->chip_type) {
2305 case SIO:
2306 len = 1;
2307 break;
2308 case FT8U232AM:
2309 case FT232BM:
2310 case FT2232C:
2311 case FT232RL:
2312 case FT2232H:
2313 case FT4232H:
2314 case FT232H:
2315 case FTX:
2316 len = 2;
2317 break;
2318 default:
2319 ret = -EFAULT;
2320 goto out;
2321 }
2322
2323 ret = usb_control_msg(port->serial->dev,
2324 usb_rcvctrlpipe(port->serial->dev, 0),
2325 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
2326 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
2327 0, priv->interface,
2328 buf, len, WDR_TIMEOUT);
2329 if (ret < 0) {
2330 dev_err(&port->dev, "failed to get modem status: %d\n", ret);
2331 ret = usb_translate_errors(ret);
2332 goto out;
2333 }
2334
2335 status[0] = buf[0];
2336 if (ret > 1)
2337 status[1] = buf[1];
2338 else
2339 status[1] = 0;
2340
2341 dev_dbg(&port->dev, "%s - 0x%02x%02x\n", __func__, status[0],
2342 status[1]);
2343out:
2344 kfree(buf);
2345
2346 return ret;
2347}
2348
2349static int ftdi_tiocmget(struct tty_struct *tty)
2350{
2351 struct usb_serial_port *port = tty->driver_data;
2352 struct ftdi_private *priv = usb_get_serial_port_data(port);
2353 unsigned char buf[2];
2354 int ret;
2355
2356 ret = ftdi_get_modem_status(port, buf);
2357 if (ret < 0)
2358 return ret;
2359
2360 ret = (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
2361 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
2362 (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
2363 (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
2364 priv->last_dtr_rts;
2365
2366 return ret;
2367}
2368
2369static int ftdi_tiocmset(struct tty_struct *tty,
2370 unsigned int set, unsigned int clear)
2371{
2372 struct usb_serial_port *port = tty->driver_data;
2373
2374 return update_mctrl(port, set, clear);
2375}
2376
2377static int ftdi_ioctl(struct tty_struct *tty,
2378 unsigned int cmd, unsigned long arg)
2379{
2380 struct usb_serial_port *port = tty->driver_data;
2381
2382 dev_dbg(&port->dev, "%s cmd 0x%04x\n", __func__, cmd);
2383
2384
2385 switch (cmd) {
2386
2387 case TIOCGSERIAL:
2388 return get_serial_info(port,
2389 (struct serial_struct __user *) arg);
2390
2391 case TIOCSSERIAL:
2392 return set_serial_info(tty, port,
2393 (struct serial_struct __user *) arg);
2394 case TIOCSERGETLSR:
2395 return get_lsr_info(port, (struct serial_struct __user *)arg);
2396 break;
2397 default:
2398 break;
2399 }
2400
2401
2402
2403 dev_dbg(&port->dev, "%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h\n",
2404 __func__, cmd);
2405 return -ENOIOCTLCMD;
2406}
2407
2408static int __init ftdi_init(void)
2409{
2410 if (vendor > 0 && product > 0) {
2411
2412 int i;
2413 for (i = 0; id_table_combined[i].idVendor; i++)
2414 ;
2415 id_table_combined[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
2416 id_table_combined[i].idVendor = vendor;
2417 id_table_combined[i].idProduct = product;
2418 }
2419 return usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, id_table_combined);
2420}
2421
2422static void __exit ftdi_exit(void)
2423{
2424 usb_serial_deregister_drivers(serial_drivers);
2425}
2426
2427
2428module_init(ftdi_init);
2429module_exit(ftdi_exit);
2430
2431MODULE_AUTHOR(DRIVER_AUTHOR);
2432MODULE_DESCRIPTION(DRIVER_DESC);
2433MODULE_LICENSE("GPL");
2434
2435module_param(vendor, ushort, 0);
2436MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
2437 __MODULE_STRING(FTDI_VID)")");
2438module_param(product, ushort, 0);
2439MODULE_PARM_DESC(product, "User specified product ID");
2440
2441module_param(ndi_latency_timer, int, S_IRUGO | S_IWUSR);
2442MODULE_PARM_DESC(ndi_latency_timer, "NDI device latency timer override");
2443