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