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