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