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