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 < 1) {
1443 dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
1444 if (rv >= 0)
1445 rv = -EIO;
1446 } else {
1447 priv->latency = buf[0];
1448 }
1449
1450 kfree(buf);
1451
1452 return rv;
1453}
1454
1455static int get_serial_info(struct usb_serial_port *port,
1456 struct serial_struct __user *retinfo)
1457{
1458 struct ftdi_private *priv = usb_get_serial_port_data(port);
1459 struct serial_struct tmp;
1460
1461 memset(&tmp, 0, sizeof(tmp));
1462 tmp.flags = priv->flags;
1463 tmp.baud_base = priv->baud_base;
1464 tmp.custom_divisor = priv->custom_divisor;
1465 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1466 return -EFAULT;
1467 return 0;
1468}
1469
1470static int set_serial_info(struct tty_struct *tty,
1471 struct usb_serial_port *port, struct serial_struct __user *newinfo)
1472{
1473 struct ftdi_private *priv = usb_get_serial_port_data(port);
1474 struct serial_struct new_serial;
1475 struct ftdi_private old_priv;
1476
1477 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1478 return -EFAULT;
1479
1480 mutex_lock(&priv->cfg_lock);
1481 old_priv = *priv;
1482
1483
1484
1485 if (!capable(CAP_SYS_ADMIN)) {
1486 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
1487 (priv->flags & ~ASYNC_USR_MASK))) {
1488 mutex_unlock(&priv->cfg_lock);
1489 return -EPERM;
1490 }
1491 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
1492 (new_serial.flags & ASYNC_USR_MASK));
1493 priv->custom_divisor = new_serial.custom_divisor;
1494 goto check_and_exit;
1495 }
1496
1497 if (new_serial.baud_base != priv->baud_base) {
1498 mutex_unlock(&priv->cfg_lock);
1499 return -EINVAL;
1500 }
1501
1502
1503
1504 priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
1505 (new_serial.flags & ASYNC_FLAGS));
1506 priv->custom_divisor = new_serial.custom_divisor;
1507
1508 write_latency_timer(port);
1509
1510check_and_exit:
1511 if ((old_priv.flags & ASYNC_SPD_MASK) !=
1512 (priv->flags & ASYNC_SPD_MASK)) {
1513 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1514 tty->alt_speed = 57600;
1515 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1516 tty->alt_speed = 115200;
1517 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1518 tty->alt_speed = 230400;
1519 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1520 tty->alt_speed = 460800;
1521 else
1522 tty->alt_speed = 0;
1523 }
1524 if (((old_priv.flags & ASYNC_SPD_MASK) !=
1525 (priv->flags & ASYNC_SPD_MASK)) ||
1526 (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1527 (old_priv.custom_divisor != priv->custom_divisor))) {
1528 change_speed(tty, port);
1529 mutex_unlock(&priv->cfg_lock);
1530 }
1531 else
1532 mutex_unlock(&priv->cfg_lock);
1533 return 0;
1534}
1535
1536static int get_lsr_info(struct usb_serial_port *port,
1537 unsigned int __user *retinfo)
1538{
1539 struct ftdi_private *priv = usb_get_serial_port_data(port);
1540 unsigned int result = 0;
1541
1542 if (priv->transmit_empty)
1543 result = TIOCSER_TEMT;
1544
1545 if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
1546 return -EFAULT;
1547 return 0;
1548}
1549
1550
1551
1552static void ftdi_determine_type(struct usb_serial_port *port)
1553{
1554 struct ftdi_private *priv = usb_get_serial_port_data(port);
1555 struct usb_serial *serial = port->serial;
1556 struct usb_device *udev = serial->dev;
1557 unsigned version;
1558 unsigned interfaces;
1559
1560
1561 priv->baud_base = 48000000 / 2;
1562
1563 version = le16_to_cpu(udev->descriptor.bcdDevice);
1564 interfaces = udev->actconfig->desc.bNumInterfaces;
1565 dev_dbg(&port->dev, "%s: bcdDevice = 0x%x, bNumInterfaces = %u\n", __func__,
1566 version, interfaces);
1567 if (interfaces > 1) {
1568 int inter;
1569
1570
1571 if (version == 0x0800) {
1572 priv->chip_type = FT4232H;
1573
1574 priv->baud_base = 120000000 / 2;
1575 } else if (version == 0x0700) {
1576 priv->chip_type = FT2232H;
1577
1578 priv->baud_base = 120000000 / 2;
1579 } else
1580 priv->chip_type = FT2232C;
1581
1582
1583 inter = serial->interface->altsetting->desc.bInterfaceNumber;
1584 if (inter == 0) {
1585 priv->interface = INTERFACE_A;
1586 } else if (inter == 1) {
1587 priv->interface = INTERFACE_B;
1588 } else if (inter == 2) {
1589 priv->interface = INTERFACE_C;
1590 } else if (inter == 3) {
1591 priv->interface = INTERFACE_D;
1592 }
1593
1594
1595 if (version < 0x500) {
1596 dev_dbg(&port->dev,
1597 "%s: something fishy - bcdDevice too low for multi-interface device\n",
1598 __func__);
1599 }
1600 } else if (version < 0x200) {
1601
1602 priv->chip_type = SIO;
1603 priv->baud_base = 12000000 / 16;
1604 } else if (version < 0x400) {
1605
1606
1607
1608 priv->chip_type = FT8U232AM;
1609 } else if (version < 0x600) {
1610
1611 priv->chip_type = FT232BM;
1612 } else if (version < 0x900) {
1613
1614 priv->chip_type = FT232RL;
1615 } else if (version < 0x1000) {
1616
1617 priv->chip_type = FT232H;
1618 } else {
1619
1620 priv->chip_type = FTX;
1621 }
1622
1623 dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
1624}
1625
1626
1627
1628
1629
1630
1631
1632static void ftdi_set_max_packet_size(struct usb_serial_port *port)
1633{
1634 struct ftdi_private *priv = usb_get_serial_port_data(port);
1635 struct usb_interface *interface = port->serial->interface;
1636 struct usb_endpoint_descriptor *ep_desc;
1637 unsigned num_endpoints;
1638 unsigned i;
1639
1640 num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
1641 if (!num_endpoints)
1642 return;
1643
1644
1645
1646
1647
1648
1649
1650 for (i = 0; i < num_endpoints; i++) {
1651 ep_desc = &interface->cur_altsetting->endpoint[i].desc;
1652 if (!ep_desc->wMaxPacketSize) {
1653 ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
1654 dev_warn(&port->dev, "Overriding wMaxPacketSize on endpoint %d\n",
1655 usb_endpoint_num(ep_desc));
1656 }
1657 }
1658
1659
1660 priv->max_packet_size = usb_endpoint_maxp(ep_desc);
1661}
1662
1663
1664
1665
1666
1667
1668
1669
1670static ssize_t latency_timer_show(struct device *dev,
1671 struct device_attribute *attr, char *buf)
1672{
1673 struct usb_serial_port *port = to_usb_serial_port(dev);
1674 struct ftdi_private *priv = usb_get_serial_port_data(port);
1675 if (priv->flags & ASYNC_LOW_LATENCY)
1676 return sprintf(buf, "1\n");
1677 else
1678 return sprintf(buf, "%i\n", priv->latency);
1679}
1680
1681
1682static ssize_t latency_timer_store(struct device *dev,
1683 struct device_attribute *attr,
1684 const char *valbuf, size_t count)
1685{
1686 struct usb_serial_port *port = to_usb_serial_port(dev);
1687 struct ftdi_private *priv = usb_get_serial_port_data(port);
1688 int v = simple_strtoul(valbuf, NULL, 10);
1689 int rv;
1690
1691 priv->latency = v;
1692 rv = write_latency_timer(port);
1693 if (rv < 0)
1694 return -EIO;
1695 return count;
1696}
1697static DEVICE_ATTR_RW(latency_timer);
1698
1699
1700
1701static ssize_t store_event_char(struct device *dev,
1702 struct device_attribute *attr, const char *valbuf, size_t count)
1703{
1704 struct usb_serial_port *port = to_usb_serial_port(dev);
1705 struct ftdi_private *priv = usb_get_serial_port_data(port);
1706 struct usb_device *udev = port->serial->dev;
1707 int v = simple_strtoul(valbuf, NULL, 10);
1708 int rv;
1709
1710 dev_dbg(&port->dev, "%s: setting event char = %i\n", __func__, v);
1711
1712 rv = usb_control_msg(udev,
1713 usb_sndctrlpipe(udev, 0),
1714 FTDI_SIO_SET_EVENT_CHAR_REQUEST,
1715 FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
1716 v, priv->interface,
1717 NULL, 0, WDR_TIMEOUT);
1718 if (rv < 0) {
1719 dev_dbg(&port->dev, "Unable to write event character: %i\n", rv);
1720 return -EIO;
1721 }
1722
1723 return count;
1724}
1725static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
1726
1727static int create_sysfs_attrs(struct usb_serial_port *port)
1728{
1729 struct ftdi_private *priv = usb_get_serial_port_data(port);
1730 int retval = 0;
1731
1732
1733
1734 if (priv->chip_type != SIO) {
1735 dev_dbg(&port->dev, "sysfs attributes for %s\n", ftdi_chip_name[priv->chip_type]);
1736 retval = device_create_file(&port->dev, &dev_attr_event_char);
1737 if ((!retval) &&
1738 (priv->chip_type == FT232BM ||
1739 priv->chip_type == FT2232C ||
1740 priv->chip_type == FT232RL ||
1741 priv->chip_type == FT2232H ||
1742 priv->chip_type == FT4232H ||
1743 priv->chip_type == FT232H ||
1744 priv->chip_type == FTX)) {
1745 retval = device_create_file(&port->dev,
1746 &dev_attr_latency_timer);
1747 }
1748 }
1749 return retval;
1750}
1751
1752static void remove_sysfs_attrs(struct usb_serial_port *port)
1753{
1754 struct ftdi_private *priv = usb_get_serial_port_data(port);
1755
1756
1757 if (priv->chip_type != SIO) {
1758 device_remove_file(&port->dev, &dev_attr_event_char);
1759 if (priv->chip_type == FT232BM ||
1760 priv->chip_type == FT2232C ||
1761 priv->chip_type == FT232RL ||
1762 priv->chip_type == FT2232H ||
1763 priv->chip_type == FT4232H ||
1764 priv->chip_type == FT232H ||
1765 priv->chip_type == FTX) {
1766 device_remove_file(&port->dev, &dev_attr_latency_timer);
1767 }
1768 }
1769
1770}
1771
1772
1773
1774
1775
1776
1777
1778
1779static int ftdi_sio_probe(struct usb_serial *serial,
1780 const struct usb_device_id *id)
1781{
1782 const struct ftdi_sio_quirk *quirk =
1783 (struct ftdi_sio_quirk *)id->driver_info;
1784
1785 if (quirk && quirk->probe) {
1786 int ret = quirk->probe(serial);
1787 if (ret != 0)
1788 return ret;
1789 }
1790
1791 usb_set_serial_data(serial, (void *)id->driver_info);
1792
1793 return 0;
1794}
1795
1796static int ftdi_sio_port_probe(struct usb_serial_port *port)
1797{
1798 struct ftdi_private *priv;
1799 const struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
1800
1801
1802 priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1803 if (!priv)
1804 return -ENOMEM;
1805
1806 mutex_init(&priv->cfg_lock);
1807
1808 if (quirk && quirk->port_probe)
1809 quirk->port_probe(priv);
1810
1811 usb_set_serial_port_data(port, priv);
1812
1813 ftdi_determine_type(port);
1814 ftdi_set_max_packet_size(port);
1815 if (read_latency_timer(port) < 0)
1816 priv->latency = 16;
1817 write_latency_timer(port);
1818 create_sysfs_attrs(port);
1819 return 0;
1820}
1821
1822
1823
1824
1825static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
1826{
1827 priv->flags |= ASYNC_SPD_CUST;
1828 priv->custom_divisor = 77;
1829 priv->force_baud = 38400;
1830}
1831
1832
1833
1834
1835static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv)
1836{
1837 priv->flags |= ASYNC_SPD_CUST;
1838 priv->custom_divisor = 240;
1839 priv->force_baud = 38400;
1840 priv->force_rtscts = 1;
1841}
1842
1843
1844
1845
1846
1847
1848static int ndi_latency_timer = 1;
1849
1850
1851
1852
1853
1854
1855static int ftdi_NDI_device_setup(struct usb_serial *serial)
1856{
1857 struct usb_device *udev = serial->dev;
1858 int latency = ndi_latency_timer;
1859
1860 if (latency == 0)
1861 latency = 1;
1862 if (latency > 99)
1863 latency = 99;
1864
1865 dev_dbg(&udev->dev, "%s setting NDI device latency to %d\n", __func__, latency);
1866 dev_info(&udev->dev, "NDI device with a latency value of %d\n", latency);
1867
1868
1869 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1870 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1871 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1872 latency, 0, NULL, 0, WDR_TIMEOUT);
1873 return 0;
1874}
1875
1876
1877
1878
1879
1880
1881static int ftdi_jtag_probe(struct usb_serial *serial)
1882{
1883 struct usb_device *udev = serial->dev;
1884 struct usb_interface *interface = serial->interface;
1885
1886 if (interface == udev->actconfig->interface[0]) {
1887 dev_info(&udev->dev,
1888 "Ignoring serial port reserved for JTAG\n");
1889 return -ENODEV;
1890 }
1891
1892 return 0;
1893}
1894
1895static int ftdi_8u2232c_probe(struct usb_serial *serial)
1896{
1897 struct usb_device *udev = serial->dev;
1898
1899 if (udev->manufacturer && !strcmp(udev->manufacturer, "CALAO Systems"))
1900 return ftdi_jtag_probe(serial);
1901
1902 if (udev->product &&
1903 (!strcmp(udev->product, "BeagleBone/XDS100V2") ||
1904 !strcmp(udev->product, "SNAP Connect E10")))
1905 return ftdi_jtag_probe(serial);
1906
1907 return 0;
1908}
1909
1910
1911
1912
1913
1914
1915
1916
1917static int ftdi_stmclite_probe(struct usb_serial *serial)
1918{
1919 struct usb_device *udev = serial->dev;
1920 struct usb_interface *interface = serial->interface;
1921
1922 if (interface == udev->actconfig->interface[0] ||
1923 interface == udev->actconfig->interface[1]) {
1924 dev_info(&udev->dev, "Ignoring serial port reserved for JTAG\n");
1925 return -ENODEV;
1926 }
1927
1928 return 0;
1929}
1930
1931static int ftdi_sio_port_remove(struct usb_serial_port *port)
1932{
1933 struct ftdi_private *priv = usb_get_serial_port_data(port);
1934
1935 remove_sysfs_attrs(port);
1936
1937 kfree(priv);
1938
1939 return 0;
1940}
1941
1942static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
1943{
1944 struct usb_device *dev = port->serial->dev;
1945 struct ftdi_private *priv = usb_get_serial_port_data(port);
1946
1947
1948
1949 usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1950 FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
1951 FTDI_SIO_RESET_SIO,
1952 priv->interface, NULL, 0, WDR_TIMEOUT);
1953
1954
1955
1956
1957
1958
1959 if (tty)
1960 ftdi_set_termios(tty, port, NULL);
1961
1962 return usb_serial_generic_open(tty, port);
1963}
1964
1965static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
1966{
1967 struct ftdi_private *priv = usb_get_serial_port_data(port);
1968
1969
1970 if (!on) {
1971 if (usb_control_msg(port->serial->dev,
1972 usb_sndctrlpipe(port->serial->dev, 0),
1973 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1974 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1975 0, priv->interface, NULL, 0,
1976 WDR_TIMEOUT) < 0) {
1977 dev_err(&port->dev, "error from flowcontrol urb\n");
1978 }
1979 }
1980
1981 if (on)
1982 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1983 else
1984 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1985}
1986
1987
1988
1989
1990
1991
1992
1993
1994static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
1995 void *dest, size_t size)
1996{
1997 struct ftdi_private *priv;
1998 int count;
1999 unsigned long flags;
2000
2001 priv = usb_get_serial_port_data(port);
2002
2003 if (priv->chip_type == SIO) {
2004 unsigned char *buffer = dest;
2005 int i, len, c;
2006
2007 count = 0;
2008 spin_lock_irqsave(&port->lock, flags);
2009 for (i = 0; i < size - 1; i += priv->max_packet_size) {
2010 len = min_t(int, size - i, priv->max_packet_size) - 1;
2011 c = kfifo_out(&port->write_fifo, &buffer[i + 1], len);
2012 if (!c)
2013 break;
2014 port->icount.tx += c;
2015 buffer[i] = (c << 2) + 1;
2016 count += c + 1;
2017 }
2018 spin_unlock_irqrestore(&port->lock, flags);
2019 } else {
2020 count = kfifo_out_locked(&port->write_fifo, dest, size,
2021 &port->lock);
2022 port->icount.tx += count;
2023 }
2024
2025 return count;
2026}
2027
2028#define FTDI_RS_ERR_MASK (FTDI_RS_BI | FTDI_RS_PE | FTDI_RS_FE | FTDI_RS_OE)
2029
2030static int ftdi_process_packet(struct usb_serial_port *port,
2031 struct ftdi_private *priv, char *packet, int len)
2032{
2033 int i;
2034 char status;
2035 char flag;
2036 char *ch;
2037
2038 if (len < 2) {
2039 dev_dbg(&port->dev, "malformed packet\n");
2040 return 0;
2041 }
2042
2043
2044
2045
2046 status = packet[0] & FTDI_STATUS_B0_MASK;
2047 if (status != priv->prev_status) {
2048 char diff_status = status ^ priv->prev_status;
2049
2050 if (diff_status & FTDI_RS0_CTS)
2051 port->icount.cts++;
2052 if (diff_status & FTDI_RS0_DSR)
2053 port->icount.dsr++;
2054 if (diff_status & FTDI_RS0_RI)
2055 port->icount.rng++;
2056 if (diff_status & FTDI_RS0_RLSD) {
2057 struct tty_struct *tty;
2058
2059 port->icount.dcd++;
2060 tty = tty_port_tty_get(&port->port);
2061 if (tty)
2062 usb_serial_handle_dcd_change(port, tty,
2063 status & FTDI_RS0_RLSD);
2064 tty_kref_put(tty);
2065 }
2066
2067 wake_up_interruptible(&port->port.delta_msr_wait);
2068 priv->prev_status = status;
2069 }
2070
2071
2072 if (packet[1] & FTDI_RS_TEMT)
2073 priv->transmit_empty = 1;
2074 else
2075 priv->transmit_empty = 0;
2076
2077 len -= 2;
2078 if (!len)
2079 return 0;
2080
2081
2082
2083
2084
2085 flag = TTY_NORMAL;
2086 if (packet[1] & FTDI_RS_ERR_MASK) {
2087
2088
2089 if (packet[1] & FTDI_RS_BI) {
2090 flag = TTY_BREAK;
2091 port->icount.brk++;
2092 usb_serial_handle_break(port);
2093 } else if (packet[1] & FTDI_RS_PE) {
2094 flag = TTY_PARITY;
2095 port->icount.parity++;
2096 } else if (packet[1] & FTDI_RS_FE) {
2097 flag = TTY_FRAME;
2098 port->icount.frame++;
2099 }
2100
2101 if (packet[1] & FTDI_RS_OE) {
2102 port->icount.overrun++;
2103 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
2104 }
2105 }
2106
2107 port->icount.rx += len;
2108 ch = packet + 2;
2109
2110 if (port->port.console && port->sysrq) {
2111 for (i = 0; i < len; i++, ch++) {
2112 if (!usb_serial_handle_sysrq_char(port, *ch))
2113 tty_insert_flip_char(&port->port, *ch, flag);
2114 }
2115 } else {
2116 tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
2117 }
2118
2119 return len;
2120}
2121
2122static void ftdi_process_read_urb(struct urb *urb)
2123{
2124 struct usb_serial_port *port = urb->context;
2125 struct ftdi_private *priv = usb_get_serial_port_data(port);
2126 char *data = (char *)urb->transfer_buffer;
2127 int i;
2128 int len;
2129 int count = 0;
2130
2131 for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
2132 len = min_t(int, urb->actual_length - i, priv->max_packet_size);
2133 count += ftdi_process_packet(port, priv, &data[i], len);
2134 }
2135
2136 if (count)
2137 tty_flip_buffer_push(&port->port);
2138}
2139
2140static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
2141{
2142 struct usb_serial_port *port = tty->driver_data;
2143 struct ftdi_private *priv = usb_get_serial_port_data(port);
2144 __u16 urb_value;
2145
2146
2147
2148
2149
2150 if (break_state)
2151 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
2152 else
2153 urb_value = priv->last_set_data_urb_value;
2154
2155 if (usb_control_msg(port->serial->dev,
2156 usb_sndctrlpipe(port->serial->dev, 0),
2157 FTDI_SIO_SET_DATA_REQUEST,
2158 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2159 urb_value , priv->interface,
2160 NULL, 0, WDR_TIMEOUT) < 0) {
2161 dev_err(&port->dev, "%s FAILED to enable/disable break state (state was %d)\n",
2162 __func__, break_state);
2163 }
2164
2165 dev_dbg(&port->dev, "%s break state is %d - urb is %d\n", __func__,
2166 break_state, urb_value);
2167
2168}
2169
2170static bool ftdi_tx_empty(struct usb_serial_port *port)
2171{
2172 unsigned char buf[2];
2173 int ret;
2174
2175 ret = ftdi_get_modem_status(port, buf);
2176 if (ret == 2) {
2177 if (!(buf[1] & FTDI_RS_TEMT))
2178 return false;
2179 }
2180
2181 return true;
2182}
2183
2184
2185
2186
2187
2188static void ftdi_set_termios(struct tty_struct *tty,
2189 struct usb_serial_port *port, struct ktermios *old_termios)
2190{
2191 struct usb_device *dev = port->serial->dev;
2192 struct device *ddev = &port->dev;
2193 struct ftdi_private *priv = usb_get_serial_port_data(port);
2194 struct ktermios *termios = &tty->termios;
2195 unsigned int cflag = termios->c_cflag;
2196 __u16 urb_value;
2197
2198
2199 unsigned int iflag = termios->c_iflag;
2200 unsigned char vstop;
2201 unsigned char vstart;
2202
2203
2204
2205 if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
2206 dev_dbg(ddev, "%s: forcing baud rate for this device\n", __func__);
2207 tty_encode_baud_rate(tty, priv->force_baud,
2208 priv->force_baud);
2209 }
2210
2211
2212 if (priv->force_rtscts) {
2213 dev_dbg(ddev, "%s: forcing rtscts for this device\n", __func__);
2214 termios->c_cflag |= CRTSCTS;
2215 }
2216
2217
2218
2219
2220
2221
2222
2223
2224
2225
2226
2227
2228
2229
2230
2231 if (C_CSIZE(tty) == CS6) {
2232 dev_warn(ddev, "requested CSIZE setting not supported\n");
2233
2234 termios->c_cflag &= ~CSIZE;
2235 if (old_termios)
2236 termios->c_cflag |= old_termios->c_cflag & CSIZE;
2237 else
2238 termios->c_cflag |= CS8;
2239 }
2240
2241 cflag = termios->c_cflag;
2242
2243 if (!old_termios)
2244 goto no_skip;
2245
2246 if (old_termios->c_cflag == termios->c_cflag
2247 && old_termios->c_ispeed == termios->c_ispeed
2248 && old_termios->c_ospeed == termios->c_ospeed)
2249 goto no_c_cflag_changes;
2250
2251
2252
2253
2254
2255 if ((old_termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)) ==
2256 (termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)))
2257 goto no_data_parity_stop_changes;
2258
2259no_skip:
2260
2261
2262 urb_value = 0;
2263 urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
2264 FTDI_SIO_SET_DATA_STOP_BITS_1);
2265 if (cflag & PARENB) {
2266 if (cflag & CMSPAR)
2267 urb_value |= cflag & PARODD ?
2268 FTDI_SIO_SET_DATA_PARITY_MARK :
2269 FTDI_SIO_SET_DATA_PARITY_SPACE;
2270 else
2271 urb_value |= cflag & PARODD ?
2272 FTDI_SIO_SET_DATA_PARITY_ODD :
2273 FTDI_SIO_SET_DATA_PARITY_EVEN;
2274 } else {
2275 urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
2276 }
2277 switch (cflag & CSIZE) {
2278 case CS5:
2279 dev_dbg(ddev, "Setting CS5 quirk\n");
2280 break;
2281 case CS7:
2282 urb_value |= 7;
2283 dev_dbg(ddev, "Setting CS7\n");
2284 break;
2285 default:
2286 case CS8:
2287 urb_value |= 8;
2288 dev_dbg(ddev, "Setting CS8\n");
2289 break;
2290 }
2291
2292
2293
2294 priv->last_set_data_urb_value = urb_value;
2295
2296 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2297 FTDI_SIO_SET_DATA_REQUEST,
2298 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2299 urb_value , priv->interface,
2300 NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
2301 dev_err(ddev, "%s FAILED to set databits/stopbits/parity\n",
2302 __func__);
2303 }
2304
2305
2306no_data_parity_stop_changes:
2307 if ((cflag & CBAUD) == B0) {
2308
2309 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2310 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2311 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2312 0, priv->interface,
2313 NULL, 0, WDR_TIMEOUT) < 0) {
2314 dev_err(ddev, "%s error from disable flowcontrol urb\n",
2315 __func__);
2316 }
2317
2318 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2319 } else {
2320
2321 mutex_lock(&priv->cfg_lock);
2322 if (change_speed(tty, port))
2323 dev_err(ddev, "%s urb failed to set baudrate\n", __func__);
2324 mutex_unlock(&priv->cfg_lock);
2325
2326 if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
2327 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2328 }
2329
2330
2331
2332no_c_cflag_changes:
2333 if (cflag & CRTSCTS) {
2334 dev_dbg(ddev, "%s Setting to CRTSCTS flow control\n", __func__);
2335 if (usb_control_msg(dev,
2336 usb_sndctrlpipe(dev, 0),
2337 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2338 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2339 0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
2340 NULL, 0, WDR_TIMEOUT) < 0) {
2341 dev_err(ddev, "urb failed to set to rts/cts flow control\n");
2342 }
2343 } else {
2344
2345
2346
2347
2348
2349
2350
2351 if (iflag & IXOFF) {
2352 dev_dbg(ddev, "%s request to enable xonxoff iflag=%04x\n",
2353 __func__, iflag);
2354
2355
2356
2357
2358
2359
2360 vstart = termios->c_cc[VSTART];
2361 vstop = termios->c_cc[VSTOP];
2362 urb_value = (vstop << 8) | (vstart);
2363
2364 if (usb_control_msg(dev,
2365 usb_sndctrlpipe(dev, 0),
2366 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2367 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2368 urb_value , (FTDI_SIO_XON_XOFF_HS
2369 | priv->interface),
2370 NULL, 0, WDR_TIMEOUT) < 0) {
2371 dev_err(&port->dev, "urb failed to set to "
2372 "xon/xoff flow control\n");
2373 }
2374 } else {
2375
2376
2377
2378 dev_dbg(ddev, "%s Turning off hardware flow control\n", __func__);
2379 if (usb_control_msg(dev,
2380 usb_sndctrlpipe(dev, 0),
2381 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2382 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2383 0, priv->interface,
2384 NULL, 0, WDR_TIMEOUT) < 0) {
2385 dev_err(ddev, "urb failed to clear flow control\n");
2386 }
2387 }
2388 }
2389}
2390
2391
2392
2393
2394
2395
2396
2397static int ftdi_get_modem_status(struct usb_serial_port *port,
2398 unsigned char status[2])
2399{
2400 struct ftdi_private *priv = usb_get_serial_port_data(port);
2401 unsigned char *buf;
2402 int len;
2403 int ret;
2404
2405 buf = kmalloc(2, GFP_KERNEL);
2406 if (!buf)
2407 return -ENOMEM;
2408
2409
2410
2411
2412 switch (priv->chip_type) {
2413 case SIO:
2414 len = 1;
2415 break;
2416 case FT8U232AM:
2417 case FT232BM:
2418 case FT2232C:
2419 case FT232RL:
2420 case FT2232H:
2421 case FT4232H:
2422 case FT232H:
2423 case FTX:
2424 len = 2;
2425 break;
2426 default:
2427 ret = -EFAULT;
2428 goto out;
2429 }
2430
2431 ret = usb_control_msg(port->serial->dev,
2432 usb_rcvctrlpipe(port->serial->dev, 0),
2433 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
2434 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
2435 0, priv->interface,
2436 buf, len, WDR_TIMEOUT);
2437
2438
2439 if (ret < 1) {
2440 dev_err(&port->dev, "failed to get modem status: %d\n", ret);
2441 if (ret >= 0)
2442 ret = -EIO;
2443 ret = usb_translate_errors(ret);
2444 goto out;
2445 }
2446
2447 status[0] = buf[0];
2448 if (ret > 1)
2449 status[1] = buf[1];
2450 else
2451 status[1] = 0;
2452
2453 dev_dbg(&port->dev, "%s - 0x%02x%02x\n", __func__, status[0],
2454 status[1]);
2455out:
2456 kfree(buf);
2457
2458 return ret;
2459}
2460
2461static int ftdi_tiocmget(struct tty_struct *tty)
2462{
2463 struct usb_serial_port *port = tty->driver_data;
2464 struct ftdi_private *priv = usb_get_serial_port_data(port);
2465 unsigned char buf[2];
2466 int ret;
2467
2468 ret = ftdi_get_modem_status(port, buf);
2469 if (ret < 0)
2470 return ret;
2471
2472 ret = (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
2473 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
2474 (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
2475 (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
2476 priv->last_dtr_rts;
2477
2478 return ret;
2479}
2480
2481static int ftdi_tiocmset(struct tty_struct *tty,
2482 unsigned int set, unsigned int clear)
2483{
2484 struct usb_serial_port *port = tty->driver_data;
2485
2486 return update_mctrl(port, set, clear);
2487}
2488
2489static int ftdi_ioctl(struct tty_struct *tty,
2490 unsigned int cmd, unsigned long arg)
2491{
2492 struct usb_serial_port *port = tty->driver_data;
2493 void __user *argp = (void __user *)arg;
2494
2495 switch (cmd) {
2496 case TIOCGSERIAL:
2497 return get_serial_info(port, argp);
2498 case TIOCSSERIAL:
2499 return set_serial_info(tty, port, argp);
2500 case TIOCSERGETLSR:
2501 return get_lsr_info(port, argp);
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
