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_INTERFACE_NUMBER(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID, 1) },
813 { USB_DEVICE_INTERFACE_NUMBER(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID, 1) },
814 { USB_DEVICE_INTERFACE_NUMBER(OLIMEX_VID, OLIMEX_ARM_USB_TINY_PID, 1) },
815 { USB_DEVICE_INTERFACE_NUMBER(OLIMEX_VID, OLIMEX_ARM_USB_TINY_H_PID, 1) },
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_INTERFACE_NUMBER(ACTEL_VID, MICROSEMI_ARROW_SF2PLUS_BOARD_PID, 2) },
877 { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
878 { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID),
879 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
880 { USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) },
881 { USB_DEVICE(GN_OTOMETRICS_VID, AURICAL_USB_PID) },
882 { USB_DEVICE(FTDI_VID, PI_C865_PID) },
883 { USB_DEVICE(FTDI_VID, PI_C857_PID) },
884 { USB_DEVICE(PI_VID, PI_C866_PID) },
885 { USB_DEVICE(PI_VID, PI_C663_PID) },
886 { USB_DEVICE(PI_VID, PI_C725_PID) },
887 { USB_DEVICE(PI_VID, PI_E517_PID) },
888 { USB_DEVICE(PI_VID, PI_C863_PID) },
889 { USB_DEVICE(PI_VID, PI_E861_PID) },
890 { USB_DEVICE(PI_VID, PI_C867_PID) },
891 { USB_DEVICE(PI_VID, PI_E609_PID) },
892 { USB_DEVICE(PI_VID, PI_E709_PID) },
893 { USB_DEVICE(PI_VID, PI_100F_PID) },
894 { USB_DEVICE(PI_VID, PI_1011_PID) },
895 { USB_DEVICE(PI_VID, PI_1012_PID) },
896 { USB_DEVICE(PI_VID, PI_1013_PID) },
897 { USB_DEVICE(PI_VID, PI_1014_PID) },
898 { USB_DEVICE(PI_VID, PI_1015_PID) },
899 { USB_DEVICE(PI_VID, PI_1016_PID) },
900 { USB_DEVICE(KONDO_VID, KONDO_USB_SERIAL_PID) },
901 { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
902 { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
903 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
904 { USB_DEVICE(FTDI_VID, TI_XDS100V2_PID),
905 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
906 { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
907 { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
908 { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
909 { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
910 { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
911 { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
912 { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
913 { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
914 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_ST_PID),
915 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
916 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SLITE_PID),
917 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
918 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH2_PID),
919 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
920 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID),
921 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
922 { USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
923 { USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
924 { USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID),
925 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
926 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
927 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_PC_WING_PID) },
928 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_USB_DMX_PID) },
929 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MIDI_TIMECODE_PID) },
930 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MINI_WING_PID) },
931 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
932 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
933 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
934 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
935 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
936 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
937 { USB_DEVICE(FTDI_VID, FTDI_CINTERION_MC55I_PID) },
938 { USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
939 { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID),
940 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
941 { USB_DEVICE(ST_VID, ST_STMCLT_2232_PID),
942 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
943 { USB_DEVICE(ST_VID, ST_STMCLT_4232_PID),
944 .driver_info = (kernel_ulong_t)&ftdi_stmclite_quirk },
945 { USB_DEVICE(FTDI_VID, FTDI_RF_R106) },
946 { USB_DEVICE(FTDI_VID, FTDI_DISTORTEC_JTAG_LOCK_PICK_PID),
947 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
948 { USB_DEVICE(FTDI_VID, FTDI_LUMEL_PD12_PID) },
949
950 { USB_DEVICE(FTDI_VID, FTDI_CT_COMET_PID) },
951 { USB_DEVICE(FTDI_VID, FTDI_Z3X_PID) },
952
953 { USB_DEVICE(FTDI_VID, FTDI_CRESSI_PID) },
954
955 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_001_PID) },
956 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_012_PID) },
957 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_023_PID) },
958 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_VX_034_PID) },
959 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_101_PID) },
960 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_1_PID) },
961 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_2_PID) },
962 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_3_PID) },
963 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_4_PID) },
964 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_5_PID) },
965 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_6_PID) },
966 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_7_PID) },
967 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_160_8_PID) },
968 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_257_PID) },
969 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_1_PID) },
970 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_2_PID) },
971 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_3_PID) },
972 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_279_4_PID) },
973 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_313_PID) },
974 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_324_PID) },
975 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_346_1_PID) },
976 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_346_2_PID) },
977 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_357_PID) },
978 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_1_PID) },
979 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_2_PID) },
980 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_606_3_PID) },
981 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_701_1_PID) },
982 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_701_2_PID) },
983 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_1_PID) },
984 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_2_PID) },
985 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_3_PID) },
986 { USB_DEVICE(BRAINBOXES_VID, BRAINBOXES_US_842_4_PID) },
987
988 { USB_DEVICE(FTDI_VID, FTDI_EKEY_CONV_USB_PID) },
989
990 { USB_DEVICE_INTERFACE_NUMBER(INFINEON_VID, INFINEON_TRIBOARD_TC1798_PID, 1) },
991 { USB_DEVICE_INTERFACE_NUMBER(INFINEON_VID, INFINEON_TRIBOARD_TC2X7_PID, 1) },
992
993 { USB_DEVICE(GE_HEALTHCARE_VID, GE_HEALTHCARE_NEMO_TRACKER_PID) },
994
995 { USB_DEVICE(FTDI_VID, ACTISENSE_NDC_PID) },
996 { USB_DEVICE(FTDI_VID, ACTISENSE_USG_PID) },
997 { USB_DEVICE(FTDI_VID, ACTISENSE_NGT_PID) },
998 { USB_DEVICE(FTDI_VID, ACTISENSE_NGW_PID) },
999 { USB_DEVICE(FTDI_VID, ACTISENSE_D9AC_PID) },
1000 { USB_DEVICE(FTDI_VID, ACTISENSE_D9AD_PID) },
1001 { USB_DEVICE(FTDI_VID, ACTISENSE_D9AE_PID) },
1002 { USB_DEVICE(FTDI_VID, ACTISENSE_D9AF_PID) },
1003 { USB_DEVICE(FTDI_VID, CHETCO_SEAGAUGE_PID) },
1004 { USB_DEVICE(FTDI_VID, CHETCO_SEASWITCH_PID) },
1005 { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_NMEA2000_PID) },
1006 { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_ETHERNET_PID) },
1007 { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_WIFI_PID) },
1008 { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_DISPLAY_PID) },
1009 { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_LITE_PID) },
1010 { USB_DEVICE(FTDI_VID, CHETCO_SEASMART_ANALOG_PID) },
1011
1012 { USB_DEVICE(ICPDAS_VID, ICPDAS_I7560U_PID) },
1013 { USB_DEVICE(ICPDAS_VID, ICPDAS_I7561U_PID) },
1014 { USB_DEVICE(ICPDAS_VID, ICPDAS_I7563U_PID) },
1015 { USB_DEVICE(WICED_VID, WICED_USB20706V2_PID) },
1016 { USB_DEVICE(TI_VID, TI_CC3200_LAUNCHPAD_PID),
1017 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
1018 { }
1019};
1020
1021MODULE_DEVICE_TABLE(usb, id_table_combined);
1022
1023static const char *ftdi_chip_name[] = {
1024 [SIO] = "SIO",
1025 [FT8U232AM] = "FT8U232AM",
1026 [FT232BM] = "FT232BM",
1027 [FT2232C] = "FT2232C",
1028 [FT232RL] = "FT232RL",
1029 [FT2232H] = "FT2232H",
1030 [FT4232H] = "FT4232H",
1031 [FT232H] = "FT232H",
1032 [FTX] = "FT-X"
1033};
1034
1035
1036
1037#define FTDI_STATUS_B0_MASK (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
1038#define FTDI_STATUS_B1_MASK (FTDI_RS_BI)
1039
1040
1041
1042static int ftdi_sio_probe(struct usb_serial *serial,
1043 const struct usb_device_id *id);
1044static int ftdi_sio_port_probe(struct usb_serial_port *port);
1045static int ftdi_sio_port_remove(struct usb_serial_port *port);
1046static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
1047static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
1048static void ftdi_process_read_urb(struct urb *urb);
1049static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
1050 void *dest, size_t size);
1051static void ftdi_set_termios(struct tty_struct *tty,
1052 struct usb_serial_port *port, struct ktermios *old);
1053static int ftdi_tiocmget(struct tty_struct *tty);
1054static int ftdi_tiocmset(struct tty_struct *tty,
1055 unsigned int set, unsigned int clear);
1056static int ftdi_ioctl(struct tty_struct *tty,
1057 unsigned int cmd, unsigned long arg);
1058static void ftdi_break_ctl(struct tty_struct *tty, int break_state);
1059static bool ftdi_tx_empty(struct usb_serial_port *port);
1060static int ftdi_get_modem_status(struct usb_serial_port *port,
1061 unsigned char status[2]);
1062
1063static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base);
1064static unsigned short int ftdi_232am_baud_to_divisor(int baud);
1065static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base);
1066static __u32 ftdi_232bm_baud_to_divisor(int baud);
1067static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base);
1068static __u32 ftdi_2232h_baud_to_divisor(int baud);
1069
1070static struct usb_serial_driver ftdi_sio_device = {
1071 .driver = {
1072 .owner = THIS_MODULE,
1073 .name = "ftdi_sio",
1074 },
1075 .description = "FTDI USB Serial Device",
1076 .id_table = id_table_combined,
1077 .num_ports = 1,
1078 .bulk_in_size = 512,
1079 .bulk_out_size = 256,
1080 .probe = ftdi_sio_probe,
1081 .port_probe = ftdi_sio_port_probe,
1082 .port_remove = ftdi_sio_port_remove,
1083 .open = ftdi_open,
1084 .dtr_rts = ftdi_dtr_rts,
1085 .throttle = usb_serial_generic_throttle,
1086 .unthrottle = usb_serial_generic_unthrottle,
1087 .process_read_urb = ftdi_process_read_urb,
1088 .prepare_write_buffer = ftdi_prepare_write_buffer,
1089 .tiocmget = ftdi_tiocmget,
1090 .tiocmset = ftdi_tiocmset,
1091 .tiocmiwait = usb_serial_generic_tiocmiwait,
1092 .get_icount = usb_serial_generic_get_icount,
1093 .ioctl = ftdi_ioctl,
1094 .set_termios = ftdi_set_termios,
1095 .break_ctl = ftdi_break_ctl,
1096 .tx_empty = ftdi_tx_empty,
1097};
1098
1099static struct usb_serial_driver * const serial_drivers[] = {
1100 &ftdi_sio_device, NULL
1101};
1102
1103
1104#define WDR_TIMEOUT 5000
1105#define WDR_SHORT_TIMEOUT 1000
1106
1107
1108
1109
1110
1111
1112
1113static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
1114{
1115 unsigned short int divisor;
1116
1117 int divisor3 = base / 2 / baud;
1118 if ((divisor3 & 0x7) == 7)
1119 divisor3++;
1120 divisor = divisor3 >> 3;
1121 divisor3 &= 0x7;
1122 if (divisor3 == 1)
1123 divisor |= 0xc000;
1124 else if (divisor3 >= 4)
1125 divisor |= 0x4000;
1126 else if (divisor3 != 0)
1127 divisor |= 0x8000;
1128 else if (divisor == 1)
1129 divisor = 0;
1130 return divisor;
1131}
1132
1133static unsigned short int ftdi_232am_baud_to_divisor(int baud)
1134{
1135 return ftdi_232am_baud_base_to_divisor(baud, 48000000);
1136}
1137
1138static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
1139{
1140 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
1141 __u32 divisor;
1142
1143 int divisor3 = base / 2 / baud;
1144 divisor = divisor3 >> 3;
1145 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
1146
1147 if (divisor == 1)
1148 divisor = 0;
1149 else if (divisor == 0x4001)
1150 divisor = 1;
1151 return divisor;
1152}
1153
1154static __u32 ftdi_232bm_baud_to_divisor(int baud)
1155{
1156 return ftdi_232bm_baud_base_to_divisor(baud, 48000000);
1157}
1158
1159static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base)
1160{
1161 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
1162 __u32 divisor;
1163 int divisor3;
1164
1165
1166 divisor3 = base * 8 / (baud * 10);
1167
1168 divisor = divisor3 >> 3;
1169 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
1170
1171 if (divisor == 1)
1172 divisor = 0;
1173 else if (divisor == 0x4001)
1174 divisor = 1;
1175
1176
1177
1178
1179
1180 divisor |= 0x00020000;
1181 return divisor;
1182}
1183
1184static __u32 ftdi_2232h_baud_to_divisor(int baud)
1185{
1186 return ftdi_2232h_baud_base_to_divisor(baud, 120000000);
1187}
1188
1189#define set_mctrl(port, set) update_mctrl((port), (set), 0)
1190#define clear_mctrl(port, clear) update_mctrl((port), 0, (clear))
1191
1192static int update_mctrl(struct usb_serial_port *port, unsigned int set,
1193 unsigned int clear)
1194{
1195 struct ftdi_private *priv = usb_get_serial_port_data(port);
1196 struct device *dev = &port->dev;
1197 unsigned urb_value;
1198 int rv;
1199
1200 if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
1201 dev_dbg(dev, "%s - DTR|RTS not being set|cleared\n", __func__);
1202 return 0;
1203 }
1204
1205 clear &= ~set;
1206 urb_value = 0;
1207 if (clear & TIOCM_DTR)
1208 urb_value |= FTDI_SIO_SET_DTR_LOW;
1209 if (clear & TIOCM_RTS)
1210 urb_value |= FTDI_SIO_SET_RTS_LOW;
1211 if (set & TIOCM_DTR)
1212 urb_value |= FTDI_SIO_SET_DTR_HIGH;
1213 if (set & TIOCM_RTS)
1214 urb_value |= FTDI_SIO_SET_RTS_HIGH;
1215 rv = usb_control_msg(port->serial->dev,
1216 usb_sndctrlpipe(port->serial->dev, 0),
1217 FTDI_SIO_SET_MODEM_CTRL_REQUEST,
1218 FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1219 urb_value, priv->interface,
1220 NULL, 0, WDR_TIMEOUT);
1221 if (rv < 0) {
1222 dev_dbg(dev, "%s Error from MODEM_CTRL urb: DTR %s, RTS %s\n",
1223 __func__,
1224 (set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
1225 (set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
1226 rv = usb_translate_errors(rv);
1227 } else {
1228 dev_dbg(dev, "%s - DTR %s, RTS %s\n", __func__,
1229 (set & TIOCM_DTR) ? "HIGH" : (clear & TIOCM_DTR) ? "LOW" : "unchanged",
1230 (set & TIOCM_RTS) ? "HIGH" : (clear & TIOCM_RTS) ? "LOW" : "unchanged");
1231
1232 priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
1233 }
1234 return rv;
1235}
1236
1237
1238static __u32 get_ftdi_divisor(struct tty_struct *tty,
1239 struct usb_serial_port *port)
1240{
1241 struct ftdi_private *priv = usb_get_serial_port_data(port);
1242 struct device *dev = &port->dev;
1243 __u32 div_value = 0;
1244 int div_okay = 1;
1245 int baud;
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
1277 baud = tty_get_baud_rate(tty);
1278 dev_dbg(dev, "%s - tty_get_baud_rate reports speed %d\n", __func__, baud);
1279
1280
1281
1282
1283 if (baud == 38400 &&
1284 ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1285 (priv->custom_divisor)) {
1286 baud = priv->baud_base / priv->custom_divisor;
1287 dev_dbg(dev, "%s - custom divisor %d sets baud rate to %d\n",
1288 __func__, priv->custom_divisor, baud);
1289 }
1290
1291
1292
1293 if (!baud)
1294 baud = 9600;
1295 switch (priv->chip_type) {
1296 case SIO:
1297 switch (baud) {
1298 case 300: div_value = ftdi_sio_b300; break;
1299 case 600: div_value = ftdi_sio_b600; break;
1300 case 1200: div_value = ftdi_sio_b1200; break;
1301 case 2400: div_value = ftdi_sio_b2400; break;
1302 case 4800: div_value = ftdi_sio_b4800; break;
1303 case 9600: div_value = ftdi_sio_b9600; break;
1304 case 19200: div_value = ftdi_sio_b19200; break;
1305 case 38400: div_value = ftdi_sio_b38400; break;
1306 case 57600: div_value = ftdi_sio_b57600; break;
1307 case 115200: div_value = ftdi_sio_b115200; break;
1308 }
1309 if (div_value == 0) {
1310 dev_dbg(dev, "%s - Baudrate (%d) requested is not supported\n",
1311 __func__, baud);
1312 div_value = ftdi_sio_b9600;
1313 baud = 9600;
1314 div_okay = 0;
1315 }
1316 break;
1317 case FT8U232AM:
1318 if (baud <= 3000000) {
1319 div_value = ftdi_232am_baud_to_divisor(baud);
1320 } else {
1321 dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
1322 baud = 9600;
1323 div_value = ftdi_232am_baud_to_divisor(9600);
1324 div_okay = 0;
1325 }
1326 break;
1327 case FT232BM:
1328 case FT2232C:
1329 case FT232RL:
1330 case FTX:
1331 if (baud <= 3000000) {
1332 __u16 product_id = le16_to_cpu(
1333 port->serial->dev->descriptor.idProduct);
1334 if (((product_id == FTDI_NDI_HUC_PID) ||
1335 (product_id == FTDI_NDI_SPECTRA_SCU_PID) ||
1336 (product_id == FTDI_NDI_FUTURE_2_PID) ||
1337 (product_id == FTDI_NDI_FUTURE_3_PID) ||
1338 (product_id == FTDI_NDI_AURORA_SCU_PID)) &&
1339 (baud == 19200)) {
1340 baud = 1200000;
1341 }
1342 div_value = ftdi_232bm_baud_to_divisor(baud);
1343 } else {
1344 dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
1345 div_value = ftdi_232bm_baud_to_divisor(9600);
1346 div_okay = 0;
1347 baud = 9600;
1348 }
1349 break;
1350 case FT2232H:
1351 case FT4232H:
1352 case FT232H:
1353 if ((baud <= 12000000) && (baud >= 1200)) {
1354 div_value = ftdi_2232h_baud_to_divisor(baud);
1355 } else if (baud < 1200) {
1356 div_value = ftdi_232bm_baud_to_divisor(baud);
1357 } else {
1358 dev_dbg(dev, "%s - Baud rate too high!\n", __func__);
1359 div_value = ftdi_232bm_baud_to_divisor(9600);
1360 div_okay = 0;
1361 baud = 9600;
1362 }
1363 break;
1364 }
1365
1366 if (div_okay) {
1367 dev_dbg(dev, "%s - Baud rate set to %d (divisor 0x%lX) on chip %s\n",
1368 __func__, baud, (unsigned long)div_value,
1369 ftdi_chip_name[priv->chip_type]);
1370 }
1371
1372 tty_encode_baud_rate(tty, baud, baud);
1373 return div_value;
1374}
1375
1376static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
1377{
1378 struct ftdi_private *priv = usb_get_serial_port_data(port);
1379 __u16 urb_value;
1380 __u16 urb_index;
1381 __u32 urb_index_value;
1382 int rv;
1383
1384 urb_index_value = get_ftdi_divisor(tty, port);
1385 urb_value = (__u16)urb_index_value;
1386 urb_index = (__u16)(urb_index_value >> 16);
1387 if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
1388 (priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
1389
1390
1391 urb_index = (__u16)((urb_index << 8) | priv->interface);
1392 }
1393
1394 rv = usb_control_msg(port->serial->dev,
1395 usb_sndctrlpipe(port->serial->dev, 0),
1396 FTDI_SIO_SET_BAUDRATE_REQUEST,
1397 FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
1398 urb_value, urb_index,
1399 NULL, 0, WDR_SHORT_TIMEOUT);
1400 return rv;
1401}
1402
1403static int write_latency_timer(struct usb_serial_port *port)
1404{
1405 struct ftdi_private *priv = usb_get_serial_port_data(port);
1406 struct usb_device *udev = port->serial->dev;
1407 int rv;
1408 int l = priv->latency;
1409
1410 if (priv->chip_type == SIO || priv->chip_type == FT8U232AM)
1411 return -EINVAL;
1412
1413 if (priv->flags & ASYNC_LOW_LATENCY)
1414 l = 1;
1415
1416 dev_dbg(&port->dev, "%s: setting latency timer = %i\n", __func__, l);
1417
1418 rv = usb_control_msg(udev,
1419 usb_sndctrlpipe(udev, 0),
1420 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1421 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1422 l, priv->interface,
1423 NULL, 0, WDR_TIMEOUT);
1424 if (rv < 0)
1425 dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
1426 return rv;
1427}
1428
1429static int _read_latency_timer(struct usb_serial_port *port)
1430{
1431 struct ftdi_private *priv = usb_get_serial_port_data(port);
1432 struct usb_device *udev = port->serial->dev;
1433 unsigned char *buf;
1434 int rv;
1435
1436 buf = kmalloc(1, GFP_KERNEL);
1437 if (!buf)
1438 return -ENOMEM;
1439
1440 rv = usb_control_msg(udev,
1441 usb_rcvctrlpipe(udev, 0),
1442 FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
1443 FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
1444 0, priv->interface,
1445 buf, 1, WDR_TIMEOUT);
1446 if (rv < 1) {
1447 if (rv >= 0)
1448 rv = -EIO;
1449 } else {
1450 rv = buf[0];
1451 }
1452
1453 kfree(buf);
1454
1455 return rv;
1456}
1457
1458static int read_latency_timer(struct usb_serial_port *port)
1459{
1460 struct ftdi_private *priv = usb_get_serial_port_data(port);
1461 int rv;
1462
1463 if (priv->chip_type == SIO || priv->chip_type == FT8U232AM)
1464 return -EINVAL;
1465
1466 rv = _read_latency_timer(port);
1467 if (rv < 0) {
1468 dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
1469 return rv;
1470 }
1471
1472 priv->latency = rv;
1473
1474 return 0;
1475}
1476
1477static int get_serial_info(struct usb_serial_port *port,
1478 struct serial_struct __user *retinfo)
1479{
1480 struct ftdi_private *priv = usb_get_serial_port_data(port);
1481 struct serial_struct tmp;
1482
1483 memset(&tmp, 0, sizeof(tmp));
1484 tmp.flags = priv->flags;
1485 tmp.baud_base = priv->baud_base;
1486 tmp.custom_divisor = priv->custom_divisor;
1487 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1488 return -EFAULT;
1489 return 0;
1490}
1491
1492static int set_serial_info(struct tty_struct *tty,
1493 struct usb_serial_port *port, struct serial_struct __user *newinfo)
1494{
1495 struct ftdi_private *priv = usb_get_serial_port_data(port);
1496 struct serial_struct new_serial;
1497 struct ftdi_private old_priv;
1498
1499 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1500 return -EFAULT;
1501
1502 mutex_lock(&priv->cfg_lock);
1503 old_priv = *priv;
1504
1505
1506
1507 if (!capable(CAP_SYS_ADMIN)) {
1508 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
1509 (priv->flags & ~ASYNC_USR_MASK))) {
1510 mutex_unlock(&priv->cfg_lock);
1511 return -EPERM;
1512 }
1513 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
1514 (new_serial.flags & ASYNC_USR_MASK));
1515 priv->custom_divisor = new_serial.custom_divisor;
1516 goto check_and_exit;
1517 }
1518
1519 if (new_serial.baud_base != priv->baud_base) {
1520 mutex_unlock(&priv->cfg_lock);
1521 return -EINVAL;
1522 }
1523
1524
1525
1526 priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
1527 (new_serial.flags & ASYNC_FLAGS));
1528 priv->custom_divisor = new_serial.custom_divisor;
1529
1530check_and_exit:
1531 write_latency_timer(port);
1532
1533 if ((old_priv.flags & ASYNC_SPD_MASK) !=
1534 (priv->flags & ASYNC_SPD_MASK)) {
1535 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1536 tty->alt_speed = 57600;
1537 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1538 tty->alt_speed = 115200;
1539 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1540 tty->alt_speed = 230400;
1541 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1542 tty->alt_speed = 460800;
1543 else
1544 tty->alt_speed = 0;
1545 }
1546 if (((old_priv.flags & ASYNC_SPD_MASK) !=
1547 (priv->flags & ASYNC_SPD_MASK)) ||
1548 (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1549 (old_priv.custom_divisor != priv->custom_divisor))) {
1550 change_speed(tty, port);
1551 mutex_unlock(&priv->cfg_lock);
1552 }
1553 else
1554 mutex_unlock(&priv->cfg_lock);
1555 return 0;
1556}
1557
1558static int get_lsr_info(struct usb_serial_port *port,
1559 unsigned int __user *retinfo)
1560{
1561 struct ftdi_private *priv = usb_get_serial_port_data(port);
1562 unsigned int result = 0;
1563
1564 if (priv->transmit_empty)
1565 result = TIOCSER_TEMT;
1566
1567 if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
1568 return -EFAULT;
1569 return 0;
1570}
1571
1572
1573
1574static void ftdi_determine_type(struct usb_serial_port *port)
1575{
1576 struct ftdi_private *priv = usb_get_serial_port_data(port);
1577 struct usb_serial *serial = port->serial;
1578 struct usb_device *udev = serial->dev;
1579 unsigned version;
1580 unsigned interfaces;
1581
1582
1583 priv->baud_base = 48000000 / 2;
1584
1585 version = le16_to_cpu(udev->descriptor.bcdDevice);
1586 interfaces = udev->actconfig->desc.bNumInterfaces;
1587 dev_dbg(&port->dev, "%s: bcdDevice = 0x%x, bNumInterfaces = %u\n", __func__,
1588 version, interfaces);
1589 if (interfaces > 1) {
1590 int inter;
1591
1592
1593 if (version == 0x0800) {
1594 priv->chip_type = FT4232H;
1595
1596 priv->baud_base = 120000000 / 2;
1597 } else if (version == 0x0700) {
1598 priv->chip_type = FT2232H;
1599
1600 priv->baud_base = 120000000 / 2;
1601 } else
1602 priv->chip_type = FT2232C;
1603
1604
1605 inter = serial->interface->altsetting->desc.bInterfaceNumber;
1606 if (inter == 0) {
1607 priv->interface = INTERFACE_A;
1608 } else if (inter == 1) {
1609 priv->interface = INTERFACE_B;
1610 } else if (inter == 2) {
1611 priv->interface = INTERFACE_C;
1612 } else if (inter == 3) {
1613 priv->interface = INTERFACE_D;
1614 }
1615
1616
1617 if (version < 0x500) {
1618 dev_dbg(&port->dev,
1619 "%s: something fishy - bcdDevice too low for multi-interface device\n",
1620 __func__);
1621 }
1622 } else if (version < 0x200) {
1623
1624 priv->chip_type = SIO;
1625 priv->baud_base = 12000000 / 16;
1626 } else if (version < 0x400) {
1627
1628 priv->chip_type = FT8U232AM;
1629
1630
1631
1632
1633
1634 if (udev->descriptor.iSerialNumber == 0 &&
1635 _read_latency_timer(port) >= 0) {
1636 dev_dbg(&port->dev,
1637 "%s: has latency timer so not an AM type\n",
1638 __func__);
1639 priv->chip_type = FT232BM;
1640 }
1641 } else if (version < 0x600) {
1642
1643 priv->chip_type = FT232BM;
1644 } else if (version < 0x900) {
1645
1646 priv->chip_type = FT232RL;
1647 } else if (version < 0x1000) {
1648
1649 priv->chip_type = FT232H;
1650 } else {
1651
1652 priv->chip_type = FTX;
1653 }
1654
1655 dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
1656}
1657
1658
1659
1660
1661
1662
1663
1664static void ftdi_set_max_packet_size(struct usb_serial_port *port)
1665{
1666 struct ftdi_private *priv = usb_get_serial_port_data(port);
1667 struct usb_interface *interface = port->serial->interface;
1668 struct usb_endpoint_descriptor *ep_desc;
1669 unsigned num_endpoints;
1670 unsigned i;
1671
1672 num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
1673 if (!num_endpoints)
1674 return;
1675
1676
1677
1678
1679
1680
1681
1682 for (i = 0; i < num_endpoints; i++) {
1683 ep_desc = &interface->cur_altsetting->endpoint[i].desc;
1684 if (!ep_desc->wMaxPacketSize) {
1685 ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
1686 dev_warn(&port->dev, "Overriding wMaxPacketSize on endpoint %d\n",
1687 usb_endpoint_num(ep_desc));
1688 }
1689 }
1690
1691
1692 priv->max_packet_size = usb_endpoint_maxp(ep_desc);
1693}
1694
1695
1696
1697
1698
1699
1700
1701
1702static ssize_t latency_timer_show(struct device *dev,
1703 struct device_attribute *attr, char *buf)
1704{
1705 struct usb_serial_port *port = to_usb_serial_port(dev);
1706 struct ftdi_private *priv = usb_get_serial_port_data(port);
1707 if (priv->flags & ASYNC_LOW_LATENCY)
1708 return sprintf(buf, "1\n");
1709 else
1710 return sprintf(buf, "%i\n", priv->latency);
1711}
1712
1713
1714static ssize_t latency_timer_store(struct device *dev,
1715 struct device_attribute *attr,
1716 const char *valbuf, size_t count)
1717{
1718 struct usb_serial_port *port = to_usb_serial_port(dev);
1719 struct ftdi_private *priv = usb_get_serial_port_data(port);
1720 u8 v;
1721 int rv;
1722
1723 if (kstrtou8(valbuf, 10, &v))
1724 return -EINVAL;
1725
1726 priv->latency = v;
1727 rv = write_latency_timer(port);
1728 if (rv < 0)
1729 return -EIO;
1730 return count;
1731}
1732static DEVICE_ATTR_RW(latency_timer);
1733
1734
1735
1736static ssize_t store_event_char(struct device *dev,
1737 struct device_attribute *attr, const char *valbuf, size_t count)
1738{
1739 struct usb_serial_port *port = to_usb_serial_port(dev);
1740 struct ftdi_private *priv = usb_get_serial_port_data(port);
1741 struct usb_device *udev = port->serial->dev;
1742 unsigned int v;
1743 int rv;
1744
1745 if (kstrtouint(valbuf, 0, &v) || v >= 0x200)
1746 return -EINVAL;
1747
1748 dev_dbg(&port->dev, "%s: setting event char = 0x%03x\n", __func__, v);
1749
1750 rv = usb_control_msg(udev,
1751 usb_sndctrlpipe(udev, 0),
1752 FTDI_SIO_SET_EVENT_CHAR_REQUEST,
1753 FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
1754 v, priv->interface,
1755 NULL, 0, WDR_TIMEOUT);
1756 if (rv < 0) {
1757 dev_dbg(&port->dev, "Unable to write event character: %i\n", rv);
1758 return -EIO;
1759 }
1760
1761 return count;
1762}
1763static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
1764
1765static int create_sysfs_attrs(struct usb_serial_port *port)
1766{
1767 struct ftdi_private *priv = usb_get_serial_port_data(port);
1768 int retval = 0;
1769
1770
1771
1772 if (priv->chip_type != SIO) {
1773 dev_dbg(&port->dev, "sysfs attributes for %s\n", ftdi_chip_name[priv->chip_type]);
1774 retval = device_create_file(&port->dev, &dev_attr_event_char);
1775 if ((!retval) &&
1776 (priv->chip_type == FT232BM ||
1777 priv->chip_type == FT2232C ||
1778 priv->chip_type == FT232RL ||
1779 priv->chip_type == FT2232H ||
1780 priv->chip_type == FT4232H ||
1781 priv->chip_type == FT232H ||
1782 priv->chip_type == FTX)) {
1783 retval = device_create_file(&port->dev,
1784 &dev_attr_latency_timer);
1785 }
1786 }
1787 return retval;
1788}
1789
1790static void remove_sysfs_attrs(struct usb_serial_port *port)
1791{
1792 struct ftdi_private *priv = usb_get_serial_port_data(port);
1793
1794
1795 if (priv->chip_type != SIO) {
1796 device_remove_file(&port->dev, &dev_attr_event_char);
1797 if (priv->chip_type == FT232BM ||
1798 priv->chip_type == FT2232C ||
1799 priv->chip_type == FT232RL ||
1800 priv->chip_type == FT2232H ||
1801 priv->chip_type == FT4232H ||
1802 priv->chip_type == FT232H ||
1803 priv->chip_type == FTX) {
1804 device_remove_file(&port->dev, &dev_attr_latency_timer);
1805 }
1806 }
1807
1808}
1809
1810
1811
1812
1813
1814
1815
1816
1817static int ftdi_sio_probe(struct usb_serial *serial,
1818 const struct usb_device_id *id)
1819{
1820 const struct ftdi_sio_quirk *quirk =
1821 (struct ftdi_sio_quirk *)id->driver_info;
1822
1823 if (quirk && quirk->probe) {
1824 int ret = quirk->probe(serial);
1825 if (ret != 0)
1826 return ret;
1827 }
1828
1829 usb_set_serial_data(serial, (void *)id->driver_info);
1830
1831 return 0;
1832}
1833
1834static int ftdi_sio_port_probe(struct usb_serial_port *port)
1835{
1836 struct ftdi_private *priv;
1837 const struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
1838
1839
1840 priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1841 if (!priv)
1842 return -ENOMEM;
1843
1844 mutex_init(&priv->cfg_lock);
1845
1846 if (quirk && quirk->port_probe)
1847 quirk->port_probe(priv);
1848
1849 usb_set_serial_port_data(port, priv);
1850
1851 ftdi_determine_type(port);
1852 ftdi_set_max_packet_size(port);
1853 if (read_latency_timer(port) < 0)
1854 priv->latency = 16;
1855 write_latency_timer(port);
1856 create_sysfs_attrs(port);
1857 return 0;
1858}
1859
1860
1861
1862
1863static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
1864{
1865 priv->flags |= ASYNC_SPD_CUST;
1866 priv->custom_divisor = 77;
1867 priv->force_baud = 38400;
1868}
1869
1870
1871
1872
1873static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv)
1874{
1875 priv->flags |= ASYNC_SPD_CUST;
1876 priv->custom_divisor = 240;
1877 priv->force_baud = 38400;
1878 priv->force_rtscts = 1;
1879}
1880
1881
1882
1883
1884
1885
1886static int ndi_latency_timer = 1;
1887
1888
1889
1890
1891
1892
1893static int ftdi_NDI_device_setup(struct usb_serial *serial)
1894{
1895 struct usb_device *udev = serial->dev;
1896 int latency = ndi_latency_timer;
1897
1898 if (latency == 0)
1899 latency = 1;
1900 if (latency > 99)
1901 latency = 99;
1902
1903 dev_dbg(&udev->dev, "%s setting NDI device latency to %d\n", __func__, latency);
1904 dev_info(&udev->dev, "NDI device with a latency value of %d\n", latency);
1905
1906
1907 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1908 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1909 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1910 latency, 0, NULL, 0, WDR_TIMEOUT);
1911 return 0;
1912}
1913
1914
1915
1916
1917
1918
1919static int ftdi_jtag_probe(struct usb_serial *serial)
1920{
1921 struct usb_device *udev = serial->dev;
1922 struct usb_interface *interface = serial->interface;
1923
1924 if (interface == udev->actconfig->interface[0]) {
1925 dev_info(&udev->dev,
1926 "Ignoring serial port reserved for JTAG\n");
1927 return -ENODEV;
1928 }
1929
1930 return 0;
1931}
1932
1933static int ftdi_8u2232c_probe(struct usb_serial *serial)
1934{
1935 struct usb_device *udev = serial->dev;
1936
1937 if (udev->manufacturer && !strcmp(udev->manufacturer, "CALAO Systems"))
1938 return ftdi_jtag_probe(serial);
1939
1940 if (udev->product &&
1941 (!strcmp(udev->product, "BeagleBone/XDS100V2") ||
1942 !strcmp(udev->product, "SNAP Connect E10")))
1943 return ftdi_jtag_probe(serial);
1944
1945 return 0;
1946}
1947
1948
1949
1950
1951
1952
1953
1954
1955static int ftdi_stmclite_probe(struct usb_serial *serial)
1956{
1957 struct usb_device *udev = serial->dev;
1958 struct usb_interface *interface = serial->interface;
1959
1960 if (interface == udev->actconfig->interface[0] ||
1961 interface == udev->actconfig->interface[1]) {
1962 dev_info(&udev->dev, "Ignoring serial port reserved for JTAG\n");
1963 return -ENODEV;
1964 }
1965
1966 return 0;
1967}
1968
1969static int ftdi_sio_port_remove(struct usb_serial_port *port)
1970{
1971 struct ftdi_private *priv = usb_get_serial_port_data(port);
1972
1973 remove_sysfs_attrs(port);
1974
1975 kfree(priv);
1976
1977 return 0;
1978}
1979
1980static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
1981{
1982 struct usb_device *dev = port->serial->dev;
1983 struct ftdi_private *priv = usb_get_serial_port_data(port);
1984
1985
1986
1987 usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1988 FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
1989 FTDI_SIO_RESET_SIO,
1990 priv->interface, NULL, 0, WDR_TIMEOUT);
1991
1992
1993
1994
1995
1996
1997 if (tty)
1998 ftdi_set_termios(tty, port, NULL);
1999
2000 return usb_serial_generic_open(tty, port);
2001}
2002
2003static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
2004{
2005 struct ftdi_private *priv = usb_get_serial_port_data(port);
2006
2007
2008 if (!on) {
2009 if (usb_control_msg(port->serial->dev,
2010 usb_sndctrlpipe(port->serial->dev, 0),
2011 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2012 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2013 0, priv->interface, NULL, 0,
2014 WDR_TIMEOUT) < 0) {
2015 dev_err(&port->dev, "error from flowcontrol urb\n");
2016 }
2017 }
2018
2019 if (on)
2020 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2021 else
2022 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2023}
2024
2025
2026
2027
2028
2029
2030
2031
2032static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
2033 void *dest, size_t size)
2034{
2035 struct ftdi_private *priv;
2036 int count;
2037 unsigned long flags;
2038
2039 priv = usb_get_serial_port_data(port);
2040
2041 if (priv->chip_type == SIO) {
2042 unsigned char *buffer = dest;
2043 int i, len, c;
2044
2045 count = 0;
2046 spin_lock_irqsave(&port->lock, flags);
2047 for (i = 0; i < size - 1; i += priv->max_packet_size) {
2048 len = min_t(int, size - i, priv->max_packet_size) - 1;
2049 c = kfifo_out(&port->write_fifo, &buffer[i + 1], len);
2050 if (!c)
2051 break;
2052 port->icount.tx += c;
2053 buffer[i] = (c << 2) + 1;
2054 count += c + 1;
2055 }
2056 spin_unlock_irqrestore(&port->lock, flags);
2057 } else {
2058 count = kfifo_out_locked(&port->write_fifo, dest, size,
2059 &port->lock);
2060 port->icount.tx += count;
2061 }
2062
2063 return count;
2064}
2065
2066#define FTDI_RS_ERR_MASK (FTDI_RS_BI | FTDI_RS_PE | FTDI_RS_FE | FTDI_RS_OE)
2067
2068static int ftdi_process_packet(struct usb_serial_port *port,
2069 struct ftdi_private *priv, char *packet, int len)
2070{
2071 int i;
2072 char status;
2073 char flag;
2074 char *ch;
2075
2076 if (len < 2) {
2077 dev_dbg(&port->dev, "malformed packet\n");
2078 return 0;
2079 }
2080
2081
2082
2083
2084 status = packet[0] & FTDI_STATUS_B0_MASK;
2085 if (status != priv->prev_status) {
2086 char diff_status = status ^ priv->prev_status;
2087
2088 if (diff_status & FTDI_RS0_CTS)
2089 port->icount.cts++;
2090 if (diff_status & FTDI_RS0_DSR)
2091 port->icount.dsr++;
2092 if (diff_status & FTDI_RS0_RI)
2093 port->icount.rng++;
2094 if (diff_status & FTDI_RS0_RLSD) {
2095 struct tty_struct *tty;
2096
2097 port->icount.dcd++;
2098 tty = tty_port_tty_get(&port->port);
2099 if (tty)
2100 usb_serial_handle_dcd_change(port, tty,
2101 status & FTDI_RS0_RLSD);
2102 tty_kref_put(tty);
2103 }
2104
2105 wake_up_interruptible(&port->port.delta_msr_wait);
2106 priv->prev_status = status;
2107 }
2108
2109
2110 if (packet[1] & FTDI_RS_TEMT)
2111 priv->transmit_empty = 1;
2112 else
2113 priv->transmit_empty = 0;
2114
2115 len -= 2;
2116 if (!len)
2117 return 0;
2118
2119
2120
2121
2122
2123 flag = TTY_NORMAL;
2124 if (packet[1] & FTDI_RS_ERR_MASK) {
2125
2126
2127 if (packet[1] & FTDI_RS_BI) {
2128 flag = TTY_BREAK;
2129 port->icount.brk++;
2130 usb_serial_handle_break(port);
2131 } else if (packet[1] & FTDI_RS_PE) {
2132 flag = TTY_PARITY;
2133 port->icount.parity++;
2134 } else if (packet[1] & FTDI_RS_FE) {
2135 flag = TTY_FRAME;
2136 port->icount.frame++;
2137 }
2138
2139 if (packet[1] & FTDI_RS_OE) {
2140 port->icount.overrun++;
2141 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
2142 }
2143 }
2144
2145 port->icount.rx += len;
2146 ch = packet + 2;
2147
2148 if (port->port.console && port->sysrq) {
2149 for (i = 0; i < len; i++, ch++) {
2150 if (!usb_serial_handle_sysrq_char(port, *ch))
2151 tty_insert_flip_char(&port->port, *ch, flag);
2152 }
2153 } else {
2154 tty_insert_flip_string_fixed_flag(&port->port, ch, flag, len);
2155 }
2156
2157 return len;
2158}
2159
2160static void ftdi_process_read_urb(struct urb *urb)
2161{
2162 struct usb_serial_port *port = urb->context;
2163 struct ftdi_private *priv = usb_get_serial_port_data(port);
2164 char *data = (char *)urb->transfer_buffer;
2165 int i;
2166 int len;
2167 int count = 0;
2168
2169 for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
2170 len = min_t(int, urb->actual_length - i, priv->max_packet_size);
2171 count += ftdi_process_packet(port, priv, &data[i], len);
2172 }
2173
2174 if (count)
2175 tty_flip_buffer_push(&port->port);
2176}
2177
2178static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
2179{
2180 struct usb_serial_port *port = tty->driver_data;
2181 struct ftdi_private *priv = usb_get_serial_port_data(port);
2182 __u16 urb_value;
2183
2184
2185
2186
2187
2188 if (break_state)
2189 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
2190 else
2191 urb_value = priv->last_set_data_urb_value;
2192
2193 if (usb_control_msg(port->serial->dev,
2194 usb_sndctrlpipe(port->serial->dev, 0),
2195 FTDI_SIO_SET_DATA_REQUEST,
2196 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2197 urb_value , priv->interface,
2198 NULL, 0, WDR_TIMEOUT) < 0) {
2199 dev_err(&port->dev, "%s FAILED to enable/disable break state (state was %d)\n",
2200 __func__, break_state);
2201 }
2202
2203 dev_dbg(&port->dev, "%s break state is %d - urb is %d\n", __func__,
2204 break_state, urb_value);
2205
2206}
2207
2208static bool ftdi_tx_empty(struct usb_serial_port *port)
2209{
2210 unsigned char buf[2];
2211 int ret;
2212
2213 ret = ftdi_get_modem_status(port, buf);
2214 if (ret == 2) {
2215 if (!(buf[1] & FTDI_RS_TEMT))
2216 return false;
2217 }
2218
2219 return true;
2220}
2221
2222
2223
2224
2225
2226static void ftdi_set_termios(struct tty_struct *tty,
2227 struct usb_serial_port *port, struct ktermios *old_termios)
2228{
2229 struct usb_device *dev = port->serial->dev;
2230 struct device *ddev = &port->dev;
2231 struct ftdi_private *priv = usb_get_serial_port_data(port);
2232 struct ktermios *termios = &tty->termios;
2233 unsigned int cflag = termios->c_cflag;
2234 __u16 urb_value;
2235
2236
2237 unsigned int iflag = termios->c_iflag;
2238 unsigned char vstop;
2239 unsigned char vstart;
2240
2241
2242
2243 if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
2244 dev_dbg(ddev, "%s: forcing baud rate for this device\n", __func__);
2245 tty_encode_baud_rate(tty, priv->force_baud,
2246 priv->force_baud);
2247 }
2248
2249
2250 if (priv->force_rtscts) {
2251 dev_dbg(ddev, "%s: forcing rtscts for this device\n", __func__);
2252 termios->c_cflag |= CRTSCTS;
2253 }
2254
2255
2256
2257
2258
2259
2260
2261
2262
2263
2264
2265
2266
2267
2268
2269 if (C_CSIZE(tty) == CS6) {
2270 dev_warn(ddev, "requested CSIZE setting not supported\n");
2271
2272 termios->c_cflag &= ~CSIZE;
2273 if (old_termios)
2274 termios->c_cflag |= old_termios->c_cflag & CSIZE;
2275 else
2276 termios->c_cflag |= CS8;
2277 }
2278
2279 cflag = termios->c_cflag;
2280
2281 if (!old_termios)
2282 goto no_skip;
2283
2284 if (old_termios->c_cflag == termios->c_cflag
2285 && old_termios->c_ispeed == termios->c_ispeed
2286 && old_termios->c_ospeed == termios->c_ospeed)
2287 goto no_c_cflag_changes;
2288
2289
2290
2291
2292
2293 if ((old_termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)) ==
2294 (termios->c_cflag & (CSIZE|PARODD|PARENB|CMSPAR|CSTOPB)))
2295 goto no_data_parity_stop_changes;
2296
2297no_skip:
2298
2299
2300 urb_value = 0;
2301 urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
2302 FTDI_SIO_SET_DATA_STOP_BITS_1);
2303 if (cflag & PARENB) {
2304 if (cflag & CMSPAR)
2305 urb_value |= cflag & PARODD ?
2306 FTDI_SIO_SET_DATA_PARITY_MARK :
2307 FTDI_SIO_SET_DATA_PARITY_SPACE;
2308 else
2309 urb_value |= cflag & PARODD ?
2310 FTDI_SIO_SET_DATA_PARITY_ODD :
2311 FTDI_SIO_SET_DATA_PARITY_EVEN;
2312 } else {
2313 urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
2314 }
2315 switch (cflag & CSIZE) {
2316 case CS5:
2317 dev_dbg(ddev, "Setting CS5 quirk\n");
2318 break;
2319 case CS7:
2320 urb_value |= 7;
2321 dev_dbg(ddev, "Setting CS7\n");
2322 break;
2323 default:
2324 case CS8:
2325 urb_value |= 8;
2326 dev_dbg(ddev, "Setting CS8\n");
2327 break;
2328 }
2329
2330
2331
2332 priv->last_set_data_urb_value = urb_value;
2333
2334 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2335 FTDI_SIO_SET_DATA_REQUEST,
2336 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2337 urb_value , priv->interface,
2338 NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
2339 dev_err(ddev, "%s FAILED to set databits/stopbits/parity\n",
2340 __func__);
2341 }
2342
2343
2344no_data_parity_stop_changes:
2345 if ((cflag & CBAUD) == B0) {
2346
2347 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2348 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2349 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2350 0, priv->interface,
2351 NULL, 0, WDR_TIMEOUT) < 0) {
2352 dev_err(ddev, "%s error from disable flowcontrol urb\n",
2353 __func__);
2354 }
2355
2356 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2357 } else {
2358
2359 mutex_lock(&priv->cfg_lock);
2360 if (change_speed(tty, port))
2361 dev_err(ddev, "%s urb failed to set baudrate\n", __func__);
2362 mutex_unlock(&priv->cfg_lock);
2363
2364 if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
2365 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2366 }
2367
2368
2369
2370no_c_cflag_changes:
2371 if (cflag & CRTSCTS) {
2372 dev_dbg(ddev, "%s Setting to CRTSCTS 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 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
2378 NULL, 0, WDR_TIMEOUT) < 0) {
2379 dev_err(ddev, "urb failed to set to rts/cts flow control\n");
2380 }
2381 } else {
2382
2383
2384
2385
2386
2387
2388
2389 if (iflag & IXOFF) {
2390 dev_dbg(ddev, "%s request to enable xonxoff iflag=%04x\n",
2391 __func__, iflag);
2392
2393
2394
2395
2396
2397
2398 vstart = termios->c_cc[VSTART];
2399 vstop = termios->c_cc[VSTOP];
2400 urb_value = (vstop << 8) | (vstart);
2401
2402 if (usb_control_msg(dev,
2403 usb_sndctrlpipe(dev, 0),
2404 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2405 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2406 urb_value , (FTDI_SIO_XON_XOFF_HS
2407 | priv->interface),
2408 NULL, 0, WDR_TIMEOUT) < 0) {
2409 dev_err(&port->dev, "urb failed to set to "
2410 "xon/xoff flow control\n");
2411 }
2412 } else {
2413
2414
2415
2416 dev_dbg(ddev, "%s Turning off hardware flow control\n", __func__);
2417 if (usb_control_msg(dev,
2418 usb_sndctrlpipe(dev, 0),
2419 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2420 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2421 0, priv->interface,
2422 NULL, 0, WDR_TIMEOUT) < 0) {
2423 dev_err(ddev, "urb failed to clear flow control\n");
2424 }
2425 }
2426 }
2427}
2428
2429
2430
2431
2432
2433
2434
2435static int ftdi_get_modem_status(struct usb_serial_port *port,
2436 unsigned char status[2])
2437{
2438 struct ftdi_private *priv = usb_get_serial_port_data(port);
2439 unsigned char *buf;
2440 int len;
2441 int ret;
2442
2443 buf = kmalloc(2, GFP_KERNEL);
2444 if (!buf)
2445 return -ENOMEM;
2446
2447
2448
2449
2450 switch (priv->chip_type) {
2451 case SIO:
2452 len = 1;
2453 break;
2454 case FT8U232AM:
2455 case FT232BM:
2456 case FT2232C:
2457 case FT232RL:
2458 case FT2232H:
2459 case FT4232H:
2460 case FT232H:
2461 case FTX:
2462 len = 2;
2463 break;
2464 default:
2465 ret = -EFAULT;
2466 goto out;
2467 }
2468
2469 ret = usb_control_msg(port->serial->dev,
2470 usb_rcvctrlpipe(port->serial->dev, 0),
2471 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
2472 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
2473 0, priv->interface,
2474 buf, len, WDR_TIMEOUT);
2475
2476
2477 if (ret < 1) {
2478 dev_err(&port->dev, "failed to get modem status: %d\n", ret);
2479 if (ret >= 0)
2480 ret = -EIO;
2481 ret = usb_translate_errors(ret);
2482 goto out;
2483 }
2484
2485 status[0] = buf[0];
2486 if (ret > 1)
2487 status[1] = buf[1];
2488 else
2489 status[1] = 0;
2490
2491 dev_dbg(&port->dev, "%s - 0x%02x%02x\n", __func__, status[0],
2492 status[1]);
2493out:
2494 kfree(buf);
2495
2496 return ret;
2497}
2498
2499static int ftdi_tiocmget(struct tty_struct *tty)
2500{
2501 struct usb_serial_port *port = tty->driver_data;
2502 struct ftdi_private *priv = usb_get_serial_port_data(port);
2503 unsigned char buf[2];
2504 int ret;
2505
2506 ret = ftdi_get_modem_status(port, buf);
2507 if (ret < 0)
2508 return ret;
2509
2510 ret = (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
2511 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
2512 (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
2513 (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
2514 priv->last_dtr_rts;
2515
2516 return ret;
2517}
2518
2519static int ftdi_tiocmset(struct tty_struct *tty,
2520 unsigned int set, unsigned int clear)
2521{
2522 struct usb_serial_port *port = tty->driver_data;
2523
2524 return update_mctrl(port, set, clear);
2525}
2526
2527static int ftdi_ioctl(struct tty_struct *tty,
2528 unsigned int cmd, unsigned long arg)
2529{
2530 struct usb_serial_port *port = tty->driver_data;
2531 void __user *argp = (void __user *)arg;
2532
2533 switch (cmd) {
2534 case TIOCGSERIAL:
2535 return get_serial_info(port, argp);
2536 case TIOCSSERIAL:
2537 return set_serial_info(tty, port, argp);
2538 case TIOCSERGETLSR:
2539 return get_lsr_info(port, argp);
2540 default:
2541 break;
2542 }
2543
2544 return -ENOIOCTLCMD;
2545}
2546
2547module_usb_serial_driver(serial_drivers, id_table_combined);
2548
2549MODULE_AUTHOR(DRIVER_AUTHOR);
2550MODULE_DESCRIPTION(DRIVER_DESC);
2551MODULE_LICENSE("GPL");
2552
2553module_param(ndi_latency_timer, int, S_IRUGO | S_IWUSR);
2554MODULE_PARM_DESC(ndi_latency_timer, "NDI device latency timer override");
2555
