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