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/init.h>
37#include <linux/slab.h>
38#include <linux/tty.h>
39#include <linux/tty_driver.h>
40#include <linux/tty_flip.h>
41#include <linux/module.h>
42#include <linux/spinlock.h>
43#include <linux/mutex.h>
44#include <linux/uaccess.h>
45#include <linux/usb.h>
46#include <linux/serial.h>
47#include <linux/usb/serial.h>
48#include "ftdi_sio.h"
49#include "ftdi_sio_ids.h"
50
51
52
53
54#define DRIVER_VERSION "v1.6.0"
55#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>"
56#define DRIVER_DESC "USB FTDI Serial Converters Driver"
57
58static int debug;
59static __u16 vendor = FTDI_VID;
60static __u16 product;
61
62struct ftdi_private {
63 struct kref kref;
64 enum ftdi_chip_type chip_type;
65
66 int baud_base;
67 int custom_divisor;
68
69
70 __u16 last_set_data_urb_value ;
71
72
73
74 int flags;
75 unsigned long last_dtr_rts;
76 wait_queue_head_t delta_msr_wait;
77 char prev_status, diff_status;
78 char transmit_empty;
79 struct usb_serial_port *port;
80 __u16 interface;
81
82
83 speed_t force_baud;
84
85 int force_rtscts;
86
87
88 unsigned int latency;
89 unsigned short max_packet_size;
90 struct mutex cfg_lock;
91};
92
93
94struct ftdi_sio_quirk {
95 int (*probe)(struct usb_serial *);
96
97 void (*port_probe)(struct ftdi_private *);
98};
99
100static int ftdi_jtag_probe(struct usb_serial *serial);
101static int ftdi_mtxorb_hack_setup(struct usb_serial *serial);
102static int ftdi_NDI_device_setup(struct usb_serial *serial);
103static int ftdi_stmclite_probe(struct usb_serial *serial);
104static int ftdi_8u2232c_probe(struct usb_serial *serial);
105static void ftdi_USB_UIRT_setup(struct ftdi_private *priv);
106static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv);
107
108static struct ftdi_sio_quirk ftdi_jtag_quirk = {
109 .probe = ftdi_jtag_probe,
110};
111
112static struct ftdi_sio_quirk ftdi_mtxorb_hack_quirk = {
113 .probe = ftdi_mtxorb_hack_setup,
114};
115
116static struct ftdi_sio_quirk ftdi_NDI_device_quirk = {
117 .probe = ftdi_NDI_device_setup,
118};
119
120static struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
121 .port_probe = ftdi_USB_UIRT_setup,
122};
123
124static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
125 .port_probe = ftdi_HE_TIRA1_setup,
126};
127
128static struct ftdi_sio_quirk ftdi_stmclite_quirk = {
129 .probe = ftdi_stmclite_probe,
130};
131
132static struct ftdi_sio_quirk ftdi_8u2232c_quirk = {
133 .probe = ftdi_8u2232c_probe,
134};
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158static struct usb_device_id id_table_combined [] = {
159 { USB_DEVICE(FTDI_VID, FTDI_ZEITCONTROL_TAGTRACE_MIFARE_PID) },
160 { USB_DEVICE(FTDI_VID, FTDI_CTI_MINI_PID) },
161 { USB_DEVICE(FTDI_VID, FTDI_CTI_NANO_PID) },
162 { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
163 { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
164 { USB_DEVICE(FTDI_VID, FTDI_CANDAPTER_PID) },
165 { USB_DEVICE(FTDI_VID, FTDI_NXTCAM_PID) },
166 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_0_PID) },
167 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_1_PID) },
168 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_2_PID) },
169 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_3_PID) },
170 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_4_PID) },
171 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_5_PID) },
172 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_6_PID) },
173 { USB_DEVICE(FTDI_VID, FTDI_SCS_DEVICE_7_PID) },
174 { USB_DEVICE(FTDI_VID, FTDI_USINT_CAT_PID) },
175 { USB_DEVICE(FTDI_VID, FTDI_USINT_WKEY_PID) },
176 { USB_DEVICE(FTDI_VID, FTDI_USINT_RS232_PID) },
177 { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
178 { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
179 { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
180 { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
181 { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
182 { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
183 { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
184 { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
185 { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
186 { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) ,
187 .driver_info = (kernel_ulong_t)&ftdi_8u2232c_quirk },
188 { USB_DEVICE(FTDI_VID, FTDI_4232H_PID) },
189 { USB_DEVICE(FTDI_VID, FTDI_232H_PID) },
190 { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
191 { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
192 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
193 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_SNIFFER_PID) },
194 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_THROTTLE_PID) },
195 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GATEWAY_PID) },
196 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_GBM_PID) },
197 { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
198 { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
199 { USB_DEVICE(FTDI_VID, FTDI_SPROG_II) },
200 { USB_DEVICE(FTDI_VID, FTDI_LENZ_LIUSB_PID) },
201 { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
202 { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
203 { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
204 { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
205 { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
206 { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
207 { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
208 { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
209 { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
210 { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
211 { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
212 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
213 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
214 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
215 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
216 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
217 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
218 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
219 { USB_DEVICE(FTDI_VID, FTDI_R2000KU_TRUE_RNG) },
220 { USB_DEVICE(FTDI_VID, FTDI_VARDAAN_PID) },
221 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0100_PID) },
222 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0101_PID) },
223 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0102_PID) },
224 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0103_PID) },
225 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0104_PID) },
226 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0105_PID) },
227 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0106_PID) },
228 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0107_PID) },
229 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0108_PID) },
230 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0109_PID) },
231 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010A_PID) },
232 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010B_PID) },
233 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010C_PID) },
234 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010D_PID) },
235 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010E_PID) },
236 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_010F_PID) },
237 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0110_PID) },
238 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0111_PID) },
239 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0112_PID) },
240 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0113_PID) },
241 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0114_PID) },
242 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0115_PID) },
243 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0116_PID) },
244 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0117_PID) },
245 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0118_PID) },
246 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0119_PID) },
247 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011A_PID) },
248 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011B_PID) },
249 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011C_PID) },
250 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011D_PID) },
251 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011E_PID) },
252 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_011F_PID) },
253 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0120_PID) },
254 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0121_PID) },
255 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0122_PID) },
256 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0123_PID) },
257 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0124_PID) },
258 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0125_PID) },
259 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0126_PID) },
260 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0127_PID),
261 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
262 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0128_PID) },
263 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0129_PID) },
264 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012A_PID) },
265 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012B_PID) },
266 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012C_PID),
267 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
268 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012D_PID) },
269 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012E_PID) },
270 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_012F_PID) },
271 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0130_PID) },
272 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0131_PID) },
273 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0132_PID) },
274 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0133_PID) },
275 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0134_PID) },
276 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0135_PID) },
277 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0136_PID) },
278 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0137_PID) },
279 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0138_PID) },
280 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0139_PID) },
281 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013A_PID) },
282 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013B_PID) },
283 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013C_PID) },
284 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013D_PID) },
285 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013E_PID) },
286 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_013F_PID) },
287 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0140_PID) },
288 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0141_PID) },
289 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0142_PID) },
290 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0143_PID) },
291 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0144_PID) },
292 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0145_PID) },
293 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0146_PID) },
294 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0147_PID) },
295 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0148_PID) },
296 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0149_PID) },
297 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014A_PID) },
298 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014B_PID) },
299 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014C_PID) },
300 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014D_PID) },
301 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014E_PID) },
302 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_014F_PID) },
303 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0150_PID) },
304 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0151_PID) },
305 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0152_PID) },
306 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0153_PID),
307 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
308 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0154_PID),
309 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
310 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0155_PID),
311 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
312 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0156_PID),
313 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
314 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0157_PID),
315 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
316 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0158_PID),
317 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
318 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0159_PID) },
319 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015A_PID) },
320 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015B_PID) },
321 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015C_PID) },
322 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015D_PID) },
323 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015E_PID) },
324 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_015F_PID) },
325 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0160_PID) },
326 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0161_PID) },
327 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0162_PID) },
328 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0163_PID) },
329 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0164_PID) },
330 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0165_PID) },
331 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0166_PID) },
332 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0167_PID) },
333 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0168_PID) },
334 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0169_PID) },
335 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016A_PID) },
336 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016B_PID) },
337 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016C_PID) },
338 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016D_PID) },
339 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016E_PID) },
340 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_016F_PID) },
341 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0170_PID) },
342 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0171_PID) },
343 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0172_PID) },
344 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0173_PID) },
345 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0174_PID) },
346 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0175_PID) },
347 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0176_PID) },
348 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0177_PID) },
349 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0178_PID) },
350 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0179_PID) },
351 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017A_PID) },
352 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017B_PID) },
353 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017C_PID) },
354 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017D_PID) },
355 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017E_PID) },
356 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_017F_PID) },
357 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0180_PID) },
358 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0181_PID) },
359 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0182_PID) },
360 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0183_PID) },
361 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0184_PID) },
362 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0185_PID) },
363 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0186_PID) },
364 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0187_PID) },
365 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0188_PID) },
366 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0189_PID) },
367 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018A_PID) },
368 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018B_PID) },
369 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018C_PID) },
370 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018D_PID) },
371 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018E_PID) },
372 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_018F_PID) },
373 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0190_PID) },
374 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0191_PID) },
375 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0192_PID) },
376 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0193_PID) },
377 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0194_PID) },
378 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0195_PID) },
379 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0196_PID) },
380 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0197_PID) },
381 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0198_PID) },
382 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_0199_PID) },
383 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019A_PID) },
384 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019B_PID) },
385 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019C_PID) },
386 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019D_PID) },
387 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019E_PID) },
388 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_019F_PID) },
389 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A0_PID) },
390 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A1_PID) },
391 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A2_PID) },
392 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A3_PID) },
393 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A4_PID) },
394 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A5_PID) },
395 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A6_PID) },
396 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A7_PID) },
397 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A8_PID) },
398 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01A9_PID) },
399 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AA_PID) },
400 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AB_PID) },
401 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AC_PID) },
402 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AD_PID) },
403 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AE_PID) },
404 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01AF_PID) },
405 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B0_PID) },
406 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B1_PID) },
407 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B2_PID) },
408 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B3_PID) },
409 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B4_PID) },
410 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B5_PID) },
411 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B6_PID) },
412 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B7_PID) },
413 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B8_PID) },
414 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01B9_PID) },
415 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BA_PID) },
416 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BB_PID) },
417 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BC_PID) },
418 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BD_PID) },
419 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BE_PID) },
420 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01BF_PID) },
421 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C0_PID) },
422 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C1_PID) },
423 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C2_PID) },
424 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C3_PID) },
425 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C4_PID) },
426 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C5_PID) },
427 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C6_PID) },
428 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C7_PID) },
429 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C8_PID) },
430 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01C9_PID) },
431 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CA_PID) },
432 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CB_PID) },
433 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CC_PID) },
434 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CD_PID) },
435 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CE_PID) },
436 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01CF_PID) },
437 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D0_PID) },
438 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D1_PID) },
439 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D2_PID) },
440 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D3_PID) },
441 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D4_PID) },
442 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D5_PID) },
443 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D6_PID) },
444 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D7_PID) },
445 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D8_PID) },
446 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01D9_PID) },
447 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DA_PID) },
448 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DB_PID) },
449 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DC_PID) },
450 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DD_PID) },
451 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DE_PID) },
452 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01DF_PID) },
453 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E0_PID) },
454 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E1_PID) },
455 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E2_PID) },
456 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E3_PID) },
457 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E4_PID) },
458 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E5_PID) },
459 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E6_PID) },
460 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E7_PID) },
461 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E8_PID) },
462 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01E9_PID) },
463 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EA_PID) },
464 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EB_PID) },
465 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EC_PID) },
466 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01ED_PID) },
467 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EE_PID) },
468 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01EF_PID) },
469 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F0_PID) },
470 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F1_PID) },
471 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F2_PID) },
472 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F3_PID) },
473 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F4_PID) },
474 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F5_PID) },
475 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F6_PID) },
476 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F7_PID) },
477 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F8_PID) },
478 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01F9_PID) },
479 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FA_PID) },
480 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FB_PID) },
481 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FC_PID) },
482 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FD_PID) },
483 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FE_PID) },
484 { USB_DEVICE(MTXORB_VID, MTXORB_FTDI_RANGE_01FF_PID) },
485 { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
486 { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
487 { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
488 { USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
489 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
490 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
491 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
492 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
493 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
494 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
495 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
496 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
497 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
498 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
499 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
500 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
501 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
502 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
503 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
504 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
505 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
506 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
507 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
508 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
509 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
510 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
511 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
512 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
513 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
514 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
515 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
516 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
517 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
518 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
519 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
520 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
521 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
522 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
523 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
524 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
525 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
526 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
527 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
528 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
529 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
530 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
531 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
532 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
533 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
534 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
535 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
536 { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
537 { USB_DEVICE(OCT_VID, OCT_US101_PID) },
538 { USB_DEVICE(OCT_VID, OCT_DK201_PID) },
539 { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
540 .driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
541 { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
542 .driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
543 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
544 { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
545 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
546 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
547 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
548 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
549 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
550 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
551 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
552 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
553 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
554 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
555 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
556 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
557 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
558 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
559 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
560 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
561 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
562 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
563 { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
564 { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
565 { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
566 { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
567 { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
568 { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
569 { USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
570 { USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
571 { USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
572 { USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
573 { USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
574 { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
575 { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
576 { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
577 { USB_DEVICE(FTDI_VID, FTDI_TAVIR_STK500_PID) },
578
579
580
581 { USB_DEVICE(FTDI_VID, FTDI_ELV_USR_PID) },
582 { USB_DEVICE(FTDI_VID, FTDI_ELV_MSM1_PID) },
583 { USB_DEVICE(FTDI_VID, FTDI_ELV_KL100_PID) },
584 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS550_PID) },
585 { USB_DEVICE(FTDI_VID, FTDI_ELV_EC3000_PID) },
586 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS888_PID) },
587 { USB_DEVICE(FTDI_VID, FTDI_ELV_TWS550_PID) },
588 { USB_DEVICE(FTDI_VID, FTDI_ELV_FEM_PID) },
589 { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
590 { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
591 { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
592 { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
593 { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
594 { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
595 { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
596 { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
597 { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
598 { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
599 { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
600 { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
601 { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
602 { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
603 { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
604 { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
605 { USB_DEVICE(FTDI_VID, FTDI_ELV_UTP8_PID) },
606 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
607 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS444PC_PID) },
608 { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
609 { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
610 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
611 { USB_DEVICE(FTDI_VID, FTDI_ELV_HS485_PID) },
612 { USB_DEVICE(FTDI_VID, FTDI_ELV_UMS100_PID) },
613 { USB_DEVICE(FTDI_VID, FTDI_ELV_TFD128_PID) },
614 { USB_DEVICE(FTDI_VID, FTDI_ELV_FM3RX_PID) },
615 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS777_PID) },
616 { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
617 { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
618 { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
619 { USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
620 { USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
621 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
622 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
623 { USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
624 { USB_DEVICE(FTDI_VID, FTDI_CCSLOAD_N_GO_3_PID) },
625 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU64_4_PID) },
626 { USB_DEVICE(FTDI_VID, FTDI_CCSPRIME8_5_PID) },
627 { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
628 { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
629 { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
630 { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
631 { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
632 { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
633 { USB_DEVICE(FTDI_VID, FTDI_OCEANIC_PID) },
634 { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
635 { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
636 { USB_DEVICE(ACTON_VID, ACTON_SPECTRAPRO_PID) },
637 { USB_DEVICE(CONTEC_VID, CONTEC_COM1USBH_PID) },
638 { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
639 { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
640 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
641 { USB_DEVICE(BANDB_VID, BANDB_USOPTL4_PID) },
642 { USB_DEVICE(BANDB_VID, BANDB_USPTL4_PID) },
643 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_2_PID) },
644 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2DR_PID) },
645 { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR2_PID) },
646 { USB_DEVICE(BANDB_VID, BANDB_USOPTL4DR_PID) },
647 { USB_DEVICE(BANDB_VID, BANDB_485USB9F_2W_PID) },
648 { USB_DEVICE(BANDB_VID, BANDB_485USB9F_4W_PID) },
649 { USB_DEVICE(BANDB_VID, BANDB_232USB9M_PID) },
650 { USB_DEVICE(BANDB_VID, BANDB_485USBTB_2W_PID) },
651 { USB_DEVICE(BANDB_VID, BANDB_485USBTB_4W_PID) },
652 { USB_DEVICE(BANDB_VID, BANDB_TTL5USB9M_PID) },
653 { USB_DEVICE(BANDB_VID, BANDB_TTL3USB9M_PID) },
654 { USB_DEVICE(BANDB_VID, BANDB_ZZ_PROG1_USB_PID) },
655 { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
656 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
657 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
658 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_3_PID) },
659 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
660 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
661 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
662 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
663 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
664 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
665 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
666 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
667 { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
668 { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
669 { USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
670 { USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
671 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
672 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
673 { USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
674 { USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
675 { USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
676 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
677 { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
678 { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
679 { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
680 { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
681 { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
682 { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
683 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
684 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
685 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
686 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
687 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
688 { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
689 { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
690 { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
691 { USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
692 { USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
693 { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
694 { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
695 { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
696 { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
697 { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
698 { USB_DEVICE(ICOM_VID, ICOM_ID_1_PID) },
699 { USB_DEVICE(ICOM_VID, ICOM_OPC_U_UC_PID) },
700 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C1_PID) },
701 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2C2_PID) },
702 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2D_PID) },
703 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VT_PID) },
704 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2VR_PID) },
705 { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVT_PID) },
706 { USB_DEVICE(ICOM_VID, ICOM_ID_RP4KVR_PID) },
707 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVT_PID) },
708 { USB_DEVICE(ICOM_VID, ICOM_ID_RP2KVR_PID) },
709 { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
710 { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
711 { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
712 { USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
713 { USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
714 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
715 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
716 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
717 { USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
718 { USB_DEVICE(FTDI_VID, FTDI_NDI_HUC_PID),
719 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
720 { USB_DEVICE(FTDI_VID, FTDI_NDI_SPECTRA_SCU_PID),
721 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
722 { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_2_PID),
723 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
724 { USB_DEVICE(FTDI_VID, FTDI_NDI_FUTURE_3_PID),
725 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
726 { USB_DEVICE(FTDI_VID, FTDI_NDI_AURORA_SCU_PID),
727 .driver_info = (kernel_ulong_t)&ftdi_NDI_device_quirk },
728 { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
729 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_SERIAL_VX7_PID) },
730 { USB_DEVICE(RTSYSTEMS_VID, RTSYSTEMS_CT29B_PID) },
731 { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
732 { USB_DEVICE(FTDI_VID, FTDI_PHI_FISCO_PID) },
733 { USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
734 { USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
735 { USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
736 { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
737 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
738 { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_H_PID),
739 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
740 { USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID),
741 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
742 { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
743 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
744 { USB_DEVICE(FTDI_VID, LMI_LM3S_DEVEL_BOARD_PID),
745 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
746 { USB_DEVICE(FTDI_VID, LMI_LM3S_EVAL_BOARD_PID),
747 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
748 { USB_DEVICE(FTDI_VID, FTDI_TURTELIZER_PID),
749 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
750 { USB_DEVICE(RATOC_VENDOR_ID, RATOC_PRODUCT_ID_USB60F) },
751 { USB_DEVICE(FTDI_VID, FTDI_REU_TINY_PID) },
752
753
754 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_PID) },
755 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_PID) },
756 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_PID) },
757 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485_2_PID) },
758 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AP485_2_PID) },
759 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB422_2_PID) },
760 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485S_PID) },
761 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB485C_PID) },
762 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_LEC_PID) },
763 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SB232_PID) },
764 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
765 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_IRAMP_PID) },
766 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK5_PID) },
767 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO8x8_PID) },
768 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO4x4_PID) },
769 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x2_PID) },
770 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO10x1_PID) },
771 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO30x3_PID) },
772 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO60x3_PID) },
773 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO2x16_PID) },
774 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_QUIDO3x32_PID) },
775 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_DRAK6_PID) },
776 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_UPSUSB_PID) },
777 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_MU_PID) },
778 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_SIMUKEY_PID) },
779 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_AD4USB_PID) },
780 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMUX_PID) },
781 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_GMSR_PID) },
782
783 { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DGQG_PID) },
784 { USB_DEVICE(FTDI_VID, FTDI_DOMINTELL_DUSB_PID) },
785 { USB_DEVICE(ALTI2_VID, ALTI2_N3_PID) },
786 { USB_DEVICE(FTDI_VID, DIEBOLD_BCS_SE923_PID) },
787 { USB_DEVICE(ATMEL_VID, STK541_PID) },
788 { USB_DEVICE(DE_VID, STB_PID) },
789 { USB_DEVICE(DE_VID, WHT_PID) },
790 { USB_DEVICE(ADI_VID, ADI_GNICE_PID),
791 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
792 { USB_DEVICE(ADI_VID, ADI_GNICEPLUS_PID),
793 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
794 { USB_DEVICE(JETI_VID, JETI_SPC1201_PID) },
795 { USB_DEVICE(MARVELL_VID, MARVELL_SHEEVAPLUG_PID),
796 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
797 { USB_DEVICE(LARSENBRUSGAARD_VID, LB_ALTITRACK_PID) },
798 { USB_DEVICE(GN_OTOMETRICS_VID, AURICAL_USB_PID) },
799 { USB_DEVICE(BAYER_VID, BAYER_CONTOUR_CABLE_PID) },
800 { USB_DEVICE(FTDI_VID, MARVELL_OPENRD_PID),
801 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
802 { USB_DEVICE(FTDI_VID, HAMEG_HO820_PID) },
803 { USB_DEVICE(FTDI_VID, HAMEG_HO720_PID) },
804 { USB_DEVICE(FTDI_VID, HAMEG_HO730_PID) },
805 { USB_DEVICE(FTDI_VID, HAMEG_HO870_PID) },
806 { USB_DEVICE(FTDI_VID, MJSG_GENERIC_PID) },
807 { USB_DEVICE(FTDI_VID, MJSG_SR_RADIO_PID) },
808 { USB_DEVICE(FTDI_VID, MJSG_HD_RADIO_PID) },
809 { USB_DEVICE(FTDI_VID, MJSG_XM_RADIO_PID) },
810 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_ST_PID),
811 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
812 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SLITE_PID),
813 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
814 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH2_PID),
815 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
816 { USB_DEVICE(FTDI_VID, XVERVE_SIGNALYZER_SH4_PID),
817 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
818 { USB_DEVICE(FTDI_VID, SEGWAY_RMP200_PID) },
819 { USB_DEVICE(FTDI_VID, ACCESIO_COM4SM_PID) },
820 { USB_DEVICE(IONICS_VID, IONICS_PLUGCOMPUTER_PID),
821 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
822 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_24_MASTER_WING_PID) },
823 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_PC_WING_PID) },
824 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_USB_DMX_PID) },
825 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MIDI_TIMECODE_PID) },
826 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MINI_WING_PID) },
827 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MAXI_WING_PID) },
828 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_MEDIA_WING_PID) },
829 { USB_DEVICE(FTDI_VID, FTDI_CHAMSYS_WING_PID) },
830 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LOGBOOKML_PID) },
831 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_LS_LOGBOOK_PID) },
832 { USB_DEVICE(FTDI_VID, FTDI_SCIENCESCOPE_HS_LOGBOOK_PID) },
833 { USB_DEVICE(FTDI_VID, FTDI_DOTEC_PID) },
834 { USB_DEVICE(QIHARDWARE_VID, MILKYMISTONE_JTAGSERIAL_PID),
835 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
836 { USB_DEVICE(ST_VID, ST_STMCLT1030_PID),
837 .driver_info = (kernel_ulong_t)&ftdi_stmclite_quirk },
838 { },
839 { }
840};
841
842MODULE_DEVICE_TABLE(usb, id_table_combined);
843
844static struct usb_driver ftdi_driver = {
845 .name = "ftdi_sio",
846 .probe = usb_serial_probe,
847 .disconnect = usb_serial_disconnect,
848 .id_table = id_table_combined,
849 .no_dynamic_id = 1,
850};
851
852static const char *ftdi_chip_name[] = {
853 [SIO] = "SIO",
854 [FT8U232AM] = "FT8U232AM",
855 [FT232BM] = "FT232BM",
856 [FT2232C] = "FT2232C",
857 [FT232RL] = "FT232RL",
858 [FT2232H] = "FT2232H",
859 [FT4232H] = "FT4232H",
860 [FT232H] = "FT232H"
861};
862
863
864
865#define FTDI_STATUS_B0_MASK (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
866#define FTDI_STATUS_B1_MASK (FTDI_RS_BI)
867
868
869#define FTDI_IMPL_ASYNC_FLAGS = (ASYNC_SPD_HI | ASYNC_SPD_VHI \
870 | ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP)
871
872
873static int ftdi_sio_probe(struct usb_serial *serial,
874 const struct usb_device_id *id);
875static int ftdi_sio_port_probe(struct usb_serial_port *port);
876static int ftdi_sio_port_remove(struct usb_serial_port *port);
877static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port);
878static void ftdi_close(struct usb_serial_port *port);
879static void ftdi_dtr_rts(struct usb_serial_port *port, int on);
880static void ftdi_process_read_urb(struct urb *urb);
881static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
882 void *dest, size_t size);
883static void ftdi_set_termios(struct tty_struct *tty,
884 struct usb_serial_port *port, struct ktermios *old);
885static int ftdi_tiocmget(struct tty_struct *tty);
886static int ftdi_tiocmset(struct tty_struct *tty,
887 unsigned int set, unsigned int clear);
888static int ftdi_ioctl(struct tty_struct *tty,
889 unsigned int cmd, unsigned long arg);
890static void ftdi_break_ctl(struct tty_struct *tty, int break_state);
891
892static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base);
893static unsigned short int ftdi_232am_baud_to_divisor(int baud);
894static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base);
895static __u32 ftdi_232bm_baud_to_divisor(int baud);
896static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base);
897static __u32 ftdi_2232h_baud_to_divisor(int baud);
898
899static struct usb_serial_driver ftdi_sio_device = {
900 .driver = {
901 .owner = THIS_MODULE,
902 .name = "ftdi_sio",
903 },
904 .description = "FTDI USB Serial Device",
905 .usb_driver = &ftdi_driver,
906 .id_table = id_table_combined,
907 .num_ports = 1,
908 .bulk_in_size = 512,
909 .bulk_out_size = 256,
910 .probe = ftdi_sio_probe,
911 .port_probe = ftdi_sio_port_probe,
912 .port_remove = ftdi_sio_port_remove,
913 .open = ftdi_open,
914 .close = ftdi_close,
915 .dtr_rts = ftdi_dtr_rts,
916 .throttle = usb_serial_generic_throttle,
917 .unthrottle = usb_serial_generic_unthrottle,
918 .process_read_urb = ftdi_process_read_urb,
919 .prepare_write_buffer = ftdi_prepare_write_buffer,
920 .tiocmget = ftdi_tiocmget,
921 .tiocmset = ftdi_tiocmset,
922 .ioctl = ftdi_ioctl,
923 .set_termios = ftdi_set_termios,
924 .break_ctl = ftdi_break_ctl,
925};
926
927
928#define WDR_TIMEOUT 5000
929#define WDR_SHORT_TIMEOUT 1000
930
931
932#define HIGH 1
933#define LOW 0
934
935
936
937
938
939
940
941static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
942{
943 unsigned short int divisor;
944
945 int divisor3 = base / 2 / baud;
946 if ((divisor3 & 0x7) == 7)
947 divisor3++;
948 divisor = divisor3 >> 3;
949 divisor3 &= 0x7;
950 if (divisor3 == 1)
951 divisor |= 0xc000;
952 else if (divisor3 >= 4)
953 divisor |= 0x4000;
954 else if (divisor3 != 0)
955 divisor |= 0x8000;
956 else if (divisor == 1)
957 divisor = 0;
958 return divisor;
959}
960
961static unsigned short int ftdi_232am_baud_to_divisor(int baud)
962{
963 return ftdi_232am_baud_base_to_divisor(baud, 48000000);
964}
965
966static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
967{
968 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
969 __u32 divisor;
970
971 int divisor3 = base / 2 / baud;
972 divisor = divisor3 >> 3;
973 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
974
975 if (divisor == 1)
976 divisor = 0;
977 else if (divisor == 0x4001)
978 divisor = 1;
979 return divisor;
980}
981
982static __u32 ftdi_232bm_baud_to_divisor(int baud)
983{
984 return ftdi_232bm_baud_base_to_divisor(baud, 48000000);
985}
986
987static __u32 ftdi_2232h_baud_base_to_divisor(int baud, int base)
988{
989 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
990 __u32 divisor;
991 int divisor3;
992
993
994 divisor3 = base * 8 / (baud * 10);
995
996 divisor = divisor3 >> 3;
997 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
998
999 if (divisor == 1)
1000 divisor = 0;
1001 else if (divisor == 0x4001)
1002 divisor = 1;
1003
1004
1005
1006
1007
1008 divisor |= 0x00020000;
1009 return divisor;
1010}
1011
1012static __u32 ftdi_2232h_baud_to_divisor(int baud)
1013{
1014 return ftdi_2232h_baud_base_to_divisor(baud, 120000000);
1015}
1016
1017#define set_mctrl(port, set) update_mctrl((port), (set), 0)
1018#define clear_mctrl(port, clear) update_mctrl((port), 0, (clear))
1019
1020static int update_mctrl(struct usb_serial_port *port, unsigned int set,
1021 unsigned int clear)
1022{
1023 struct ftdi_private *priv = usb_get_serial_port_data(port);
1024 unsigned urb_value;
1025 int rv;
1026
1027 if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
1028 dbg("%s - DTR|RTS not being set|cleared", __func__);
1029 return 0;
1030 }
1031
1032 clear &= ~set;
1033 urb_value = 0;
1034 if (clear & TIOCM_DTR)
1035 urb_value |= FTDI_SIO_SET_DTR_LOW;
1036 if (clear & TIOCM_RTS)
1037 urb_value |= FTDI_SIO_SET_RTS_LOW;
1038 if (set & TIOCM_DTR)
1039 urb_value |= FTDI_SIO_SET_DTR_HIGH;
1040 if (set & TIOCM_RTS)
1041 urb_value |= FTDI_SIO_SET_RTS_HIGH;
1042 rv = usb_control_msg(port->serial->dev,
1043 usb_sndctrlpipe(port->serial->dev, 0),
1044 FTDI_SIO_SET_MODEM_CTRL_REQUEST,
1045 FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
1046 urb_value, priv->interface,
1047 NULL, 0, WDR_TIMEOUT);
1048 if (rv < 0) {
1049 dbg("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
1050 __func__,
1051 (set & TIOCM_DTR) ? "HIGH" :
1052 (clear & TIOCM_DTR) ? "LOW" : "unchanged",
1053 (set & TIOCM_RTS) ? "HIGH" :
1054 (clear & TIOCM_RTS) ? "LOW" : "unchanged");
1055 } else {
1056 dbg("%s - DTR %s, RTS %s", __func__,
1057 (set & TIOCM_DTR) ? "HIGH" :
1058 (clear & TIOCM_DTR) ? "LOW" : "unchanged",
1059 (set & TIOCM_RTS) ? "HIGH" :
1060 (clear & TIOCM_RTS) ? "LOW" : "unchanged");
1061
1062 priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
1063 }
1064 return rv;
1065}
1066
1067
1068static __u32 get_ftdi_divisor(struct tty_struct *tty,
1069 struct usb_serial_port *port)
1070{
1071 struct ftdi_private *priv = usb_get_serial_port_data(port);
1072 __u32 div_value = 0;
1073 int div_okay = 1;
1074 int baud;
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084
1085
1086
1087
1088
1089
1090
1091
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106 baud = tty_get_baud_rate(tty);
1107 dbg("%s - tty_get_baud_rate reports speed %d", __func__, baud);
1108
1109
1110
1111
1112 if (baud == 38400 &&
1113 ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1114 (priv->custom_divisor)) {
1115 baud = priv->baud_base / priv->custom_divisor;
1116 dbg("%s - custom divisor %d sets baud rate to %d",
1117 __func__, priv->custom_divisor, baud);
1118 }
1119
1120
1121
1122 if (!baud)
1123 baud = 9600;
1124 switch (priv->chip_type) {
1125 case SIO:
1126 switch (baud) {
1127 case 300: div_value = ftdi_sio_b300; break;
1128 case 600: div_value = ftdi_sio_b600; break;
1129 case 1200: div_value = ftdi_sio_b1200; break;
1130 case 2400: div_value = ftdi_sio_b2400; break;
1131 case 4800: div_value = ftdi_sio_b4800; break;
1132 case 9600: div_value = ftdi_sio_b9600; break;
1133 case 19200: div_value = ftdi_sio_b19200; break;
1134 case 38400: div_value = ftdi_sio_b38400; break;
1135 case 57600: div_value = ftdi_sio_b57600; break;
1136 case 115200: div_value = ftdi_sio_b115200; break;
1137 }
1138 if (div_value == 0) {
1139 dbg("%s - Baudrate (%d) requested is not supported",
1140 __func__, baud);
1141 div_value = ftdi_sio_b9600;
1142 baud = 9600;
1143 div_okay = 0;
1144 }
1145 break;
1146 case FT8U232AM:
1147 if (baud <= 3000000) {
1148 div_value = ftdi_232am_baud_to_divisor(baud);
1149 } else {
1150 dbg("%s - Baud rate too high!", __func__);
1151 baud = 9600;
1152 div_value = ftdi_232am_baud_to_divisor(9600);
1153 div_okay = 0;
1154 }
1155 break;
1156 case FT232BM:
1157 case FT2232C:
1158 case FT232RL:
1159 if (baud <= 3000000) {
1160 __u16 product_id = le16_to_cpu(
1161 port->serial->dev->descriptor.idProduct);
1162 if (((FTDI_NDI_HUC_PID == product_id) ||
1163 (FTDI_NDI_SPECTRA_SCU_PID == product_id) ||
1164 (FTDI_NDI_FUTURE_2_PID == product_id) ||
1165 (FTDI_NDI_FUTURE_3_PID == product_id) ||
1166 (FTDI_NDI_AURORA_SCU_PID == product_id)) &&
1167 (baud == 19200)) {
1168 baud = 1200000;
1169 }
1170 div_value = ftdi_232bm_baud_to_divisor(baud);
1171 } else {
1172 dbg("%s - Baud rate too high!", __func__);
1173 div_value = ftdi_232bm_baud_to_divisor(9600);
1174 div_okay = 0;
1175 baud = 9600;
1176 }
1177 break;
1178 case FT2232H:
1179 case FT4232H:
1180 case FT232H:
1181 if ((baud <= 12000000) && (baud >= 1200)) {
1182 div_value = ftdi_2232h_baud_to_divisor(baud);
1183 } else if (baud < 1200) {
1184 div_value = ftdi_232bm_baud_to_divisor(baud);
1185 } else {
1186 dbg("%s - Baud rate too high!", __func__);
1187 div_value = ftdi_232bm_baud_to_divisor(9600);
1188 div_okay = 0;
1189 baud = 9600;
1190 }
1191 break;
1192 }
1193
1194 if (div_okay) {
1195 dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",
1196 __func__, baud, (unsigned long)div_value,
1197 ftdi_chip_name[priv->chip_type]);
1198 }
1199
1200 tty_encode_baud_rate(tty, baud, baud);
1201 return div_value;
1202}
1203
1204static int change_speed(struct tty_struct *tty, struct usb_serial_port *port)
1205{
1206 struct ftdi_private *priv = usb_get_serial_port_data(port);
1207 __u16 urb_value;
1208 __u16 urb_index;
1209 __u32 urb_index_value;
1210 int rv;
1211
1212 urb_index_value = get_ftdi_divisor(tty, port);
1213 urb_value = (__u16)urb_index_value;
1214 urb_index = (__u16)(urb_index_value >> 16);
1215 if ((priv->chip_type == FT2232C) || (priv->chip_type == FT2232H) ||
1216 (priv->chip_type == FT4232H) || (priv->chip_type == FT232H)) {
1217
1218
1219 urb_index = (__u16)((urb_index << 8) | priv->interface);
1220 }
1221
1222 rv = usb_control_msg(port->serial->dev,
1223 usb_sndctrlpipe(port->serial->dev, 0),
1224 FTDI_SIO_SET_BAUDRATE_REQUEST,
1225 FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
1226 urb_value, urb_index,
1227 NULL, 0, WDR_SHORT_TIMEOUT);
1228 return rv;
1229}
1230
1231static int write_latency_timer(struct usb_serial_port *port)
1232{
1233 struct ftdi_private *priv = usb_get_serial_port_data(port);
1234 struct usb_device *udev = port->serial->dev;
1235 int rv;
1236 int l = priv->latency;
1237
1238 if (priv->flags & ASYNC_LOW_LATENCY)
1239 l = 1;
1240
1241 dbg("%s: setting latency timer = %i", __func__, l);
1242
1243 rv = usb_control_msg(udev,
1244 usb_sndctrlpipe(udev, 0),
1245 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1246 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1247 l, priv->interface,
1248 NULL, 0, WDR_TIMEOUT);
1249 if (rv < 0)
1250 dev_err(&port->dev, "Unable to write latency timer: %i\n", rv);
1251 return rv;
1252}
1253
1254static int read_latency_timer(struct usb_serial_port *port)
1255{
1256 struct ftdi_private *priv = usb_get_serial_port_data(port);
1257 struct usb_device *udev = port->serial->dev;
1258 unsigned char *buf;
1259 int rv;
1260
1261 dbg("%s", __func__);
1262
1263 buf = kmalloc(1, GFP_KERNEL);
1264 if (!buf)
1265 return -ENOMEM;
1266
1267 rv = usb_control_msg(udev,
1268 usb_rcvctrlpipe(udev, 0),
1269 FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
1270 FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
1271 0, priv->interface,
1272 buf, 1, WDR_TIMEOUT);
1273 if (rv < 0)
1274 dev_err(&port->dev, "Unable to read latency timer: %i\n", rv);
1275 else
1276 priv->latency = buf[0];
1277
1278 kfree(buf);
1279
1280 return rv;
1281}
1282
1283static int get_serial_info(struct usb_serial_port *port,
1284 struct serial_struct __user *retinfo)
1285{
1286 struct ftdi_private *priv = usb_get_serial_port_data(port);
1287 struct serial_struct tmp;
1288
1289 if (!retinfo)
1290 return -EFAULT;
1291 memset(&tmp, 0, sizeof(tmp));
1292 tmp.flags = priv->flags;
1293 tmp.baud_base = priv->baud_base;
1294 tmp.custom_divisor = priv->custom_divisor;
1295 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
1296 return -EFAULT;
1297 return 0;
1298}
1299
1300static int set_serial_info(struct tty_struct *tty,
1301 struct usb_serial_port *port, struct serial_struct __user *newinfo)
1302{
1303 struct ftdi_private *priv = usb_get_serial_port_data(port);
1304 struct serial_struct new_serial;
1305 struct ftdi_private old_priv;
1306
1307 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
1308 return -EFAULT;
1309
1310 mutex_lock(&priv->cfg_lock);
1311 old_priv = *priv;
1312
1313
1314
1315 if (!capable(CAP_SYS_ADMIN)) {
1316 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
1317 (priv->flags & ~ASYNC_USR_MASK))) {
1318 mutex_unlock(&priv->cfg_lock);
1319 return -EPERM;
1320 }
1321 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
1322 (new_serial.flags & ASYNC_USR_MASK));
1323 priv->custom_divisor = new_serial.custom_divisor;
1324 goto check_and_exit;
1325 }
1326
1327 if ((new_serial.baud_base != priv->baud_base) &&
1328 (new_serial.baud_base < 9600)) {
1329 mutex_unlock(&priv->cfg_lock);
1330 return -EINVAL;
1331 }
1332
1333
1334
1335 priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
1336 (new_serial.flags & ASYNC_FLAGS));
1337 priv->custom_divisor = new_serial.custom_divisor;
1338
1339 write_latency_timer(port);
1340
1341check_and_exit:
1342 if ((old_priv.flags & ASYNC_SPD_MASK) !=
1343 (priv->flags & ASYNC_SPD_MASK)) {
1344 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
1345 tty->alt_speed = 57600;
1346 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
1347 tty->alt_speed = 115200;
1348 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
1349 tty->alt_speed = 230400;
1350 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
1351 tty->alt_speed = 460800;
1352 else
1353 tty->alt_speed = 0;
1354 }
1355 if (((old_priv.flags & ASYNC_SPD_MASK) !=
1356 (priv->flags & ASYNC_SPD_MASK)) ||
1357 (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
1358 (old_priv.custom_divisor != priv->custom_divisor))) {
1359 change_speed(tty, port);
1360 mutex_unlock(&priv->cfg_lock);
1361 }
1362 else
1363 mutex_unlock(&priv->cfg_lock);
1364 return 0;
1365}
1366
1367static int get_lsr_info(struct usb_serial_port *port,
1368 struct serial_struct __user *retinfo)
1369{
1370 struct ftdi_private *priv = usb_get_serial_port_data(port);
1371 unsigned int result = 0;
1372
1373 if (!retinfo)
1374 return -EFAULT;
1375
1376 if (priv->transmit_empty)
1377 result = TIOCSER_TEMT;
1378
1379 if (copy_to_user(retinfo, &result, sizeof(unsigned int)))
1380 return -EFAULT;
1381 return 0;
1382}
1383
1384
1385
1386static void ftdi_determine_type(struct usb_serial_port *port)
1387{
1388 struct ftdi_private *priv = usb_get_serial_port_data(port);
1389 struct usb_serial *serial = port->serial;
1390 struct usb_device *udev = serial->dev;
1391 unsigned version;
1392 unsigned interfaces;
1393
1394
1395 priv->baud_base = 48000000 / 2;
1396
1397 version = le16_to_cpu(udev->descriptor.bcdDevice);
1398 interfaces = udev->actconfig->desc.bNumInterfaces;
1399 dbg("%s: bcdDevice = 0x%x, bNumInterfaces = %u", __func__,
1400 version, interfaces);
1401 if (interfaces > 1) {
1402 int inter;
1403
1404
1405 if (version == 0x0800) {
1406 priv->chip_type = FT4232H;
1407
1408 priv->baud_base = 120000000 / 2;
1409 } else if (version == 0x0700) {
1410 priv->chip_type = FT2232H;
1411
1412 priv->baud_base = 120000000 / 2;
1413 } else
1414 priv->chip_type = FT2232C;
1415
1416
1417 inter = serial->interface->altsetting->desc.bInterfaceNumber;
1418 if (inter == 0) {
1419 priv->interface = INTERFACE_A;
1420 } else if (inter == 1) {
1421 priv->interface = INTERFACE_B;
1422 } else if (inter == 2) {
1423 priv->interface = INTERFACE_C;
1424 } else if (inter == 3) {
1425 priv->interface = INTERFACE_D;
1426 }
1427
1428
1429 if (version < 0x500) {
1430 dbg("%s: something fishy - bcdDevice too low for multi-interface device",
1431 __func__);
1432 }
1433 } else if (version < 0x200) {
1434
1435 priv->chip_type = SIO;
1436 priv->baud_base = 12000000 / 16;
1437 } else if (version < 0x400) {
1438
1439
1440
1441 priv->chip_type = FT8U232AM;
1442 } else if (version < 0x600) {
1443
1444 priv->chip_type = FT232BM;
1445 } else if (version < 0x900) {
1446
1447 priv->chip_type = FT232RL;
1448 } else {
1449
1450 priv->chip_type = FT232H;
1451 }
1452 dev_info(&udev->dev, "Detected %s\n", ftdi_chip_name[priv->chip_type]);
1453}
1454
1455
1456
1457
1458
1459static void ftdi_set_max_packet_size(struct usb_serial_port *port)
1460{
1461 struct ftdi_private *priv = usb_get_serial_port_data(port);
1462 struct usb_serial *serial = port->serial;
1463 struct usb_device *udev = serial->dev;
1464
1465 struct usb_interface *interface = serial->interface;
1466 struct usb_endpoint_descriptor *ep_desc = &interface->cur_altsetting->endpoint[1].desc;
1467
1468 unsigned num_endpoints;
1469 int i;
1470
1471 num_endpoints = interface->cur_altsetting->desc.bNumEndpoints;
1472 dev_info(&udev->dev, "Number of endpoints %d\n", num_endpoints);
1473
1474
1475
1476
1477
1478 for (i = 0; i < num_endpoints; i++) {
1479 dev_info(&udev->dev, "Endpoint %d MaxPacketSize %d\n", i+1,
1480 interface->cur_altsetting->endpoint[i].desc.wMaxPacketSize);
1481 ep_desc = &interface->cur_altsetting->endpoint[i].desc;
1482 if (ep_desc->wMaxPacketSize == 0) {
1483 ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
1484 dev_info(&udev->dev, "Overriding wMaxPacketSize on endpoint %d\n", i);
1485 }
1486 }
1487
1488
1489 priv->max_packet_size = le16_to_cpu(ep_desc->wMaxPacketSize);
1490
1491 dev_info(&udev->dev, "Setting MaxPacketSize %d\n", priv->max_packet_size);
1492}
1493
1494
1495
1496
1497
1498
1499
1500
1501static ssize_t show_latency_timer(struct device *dev,
1502 struct device_attribute *attr, char *buf)
1503{
1504 struct usb_serial_port *port = to_usb_serial_port(dev);
1505 struct ftdi_private *priv = usb_get_serial_port_data(port);
1506 if (priv->flags & ASYNC_LOW_LATENCY)
1507 return sprintf(buf, "1\n");
1508 else
1509 return sprintf(buf, "%i\n", priv->latency);
1510}
1511
1512
1513
1514static ssize_t store_latency_timer(struct device *dev,
1515 struct device_attribute *attr, const char *valbuf,
1516 size_t count)
1517{
1518 struct usb_serial_port *port = to_usb_serial_port(dev);
1519 struct ftdi_private *priv = usb_get_serial_port_data(port);
1520 int v = simple_strtoul(valbuf, NULL, 10);
1521 int rv;
1522
1523 priv->latency = v;
1524 rv = write_latency_timer(port);
1525 if (rv < 0)
1526 return -EIO;
1527 return count;
1528}
1529
1530
1531
1532static ssize_t store_event_char(struct device *dev,
1533 struct device_attribute *attr, const char *valbuf, size_t count)
1534{
1535 struct usb_serial_port *port = to_usb_serial_port(dev);
1536 struct ftdi_private *priv = usb_get_serial_port_data(port);
1537 struct usb_device *udev = port->serial->dev;
1538 int v = simple_strtoul(valbuf, NULL, 10);
1539 int rv;
1540
1541 dbg("%s: setting event char = %i", __func__, v);
1542
1543 rv = usb_control_msg(udev,
1544 usb_sndctrlpipe(udev, 0),
1545 FTDI_SIO_SET_EVENT_CHAR_REQUEST,
1546 FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
1547 v, priv->interface,
1548 NULL, 0, WDR_TIMEOUT);
1549 if (rv < 0) {
1550 dbg("Unable to write event character: %i", rv);
1551 return -EIO;
1552 }
1553
1554 return count;
1555}
1556
1557static DEVICE_ATTR(latency_timer, S_IWUSR | S_IRUGO, show_latency_timer,
1558 store_latency_timer);
1559static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
1560
1561static int create_sysfs_attrs(struct usb_serial_port *port)
1562{
1563 struct ftdi_private *priv = usb_get_serial_port_data(port);
1564 int retval = 0;
1565
1566 dbg("%s", __func__);
1567
1568
1569
1570 if (priv->chip_type != SIO) {
1571 dbg("sysfs attributes for %s", ftdi_chip_name[priv->chip_type]);
1572 retval = device_create_file(&port->dev, &dev_attr_event_char);
1573 if ((!retval) &&
1574 (priv->chip_type == FT232BM ||
1575 priv->chip_type == FT2232C ||
1576 priv->chip_type == FT232RL ||
1577 priv->chip_type == FT2232H ||
1578 priv->chip_type == FT4232H ||
1579 priv->chip_type == FT232H)) {
1580 retval = device_create_file(&port->dev,
1581 &dev_attr_latency_timer);
1582 }
1583 }
1584 return retval;
1585}
1586
1587static void remove_sysfs_attrs(struct usb_serial_port *port)
1588{
1589 struct ftdi_private *priv = usb_get_serial_port_data(port);
1590
1591 dbg("%s", __func__);
1592
1593
1594 if (priv->chip_type != SIO) {
1595 device_remove_file(&port->dev, &dev_attr_event_char);
1596 if (priv->chip_type == FT232BM ||
1597 priv->chip_type == FT2232C ||
1598 priv->chip_type == FT232RL ||
1599 priv->chip_type == FT2232H ||
1600 priv->chip_type == FT4232H ||
1601 priv->chip_type == FT232H) {
1602 device_remove_file(&port->dev, &dev_attr_latency_timer);
1603 }
1604 }
1605
1606}
1607
1608
1609
1610
1611
1612
1613
1614
1615static int ftdi_sio_probe(struct usb_serial *serial,
1616 const struct usb_device_id *id)
1617{
1618 struct ftdi_sio_quirk *quirk =
1619 (struct ftdi_sio_quirk *)id->driver_info;
1620
1621 if (quirk && quirk->probe) {
1622 int ret = quirk->probe(serial);
1623 if (ret != 0)
1624 return ret;
1625 }
1626
1627 usb_set_serial_data(serial, (void *)id->driver_info);
1628
1629 return 0;
1630}
1631
1632static int ftdi_sio_port_probe(struct usb_serial_port *port)
1633{
1634 struct ftdi_private *priv;
1635 struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
1636
1637
1638 dbg("%s", __func__);
1639
1640 priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1641 if (!priv) {
1642 dev_err(&port->dev, "%s- kmalloc(%Zd) failed.\n", __func__,
1643 sizeof(struct ftdi_private));
1644 return -ENOMEM;
1645 }
1646
1647 kref_init(&priv->kref);
1648 mutex_init(&priv->cfg_lock);
1649 init_waitqueue_head(&priv->delta_msr_wait);
1650
1651 priv->flags = ASYNC_LOW_LATENCY;
1652
1653 if (quirk && quirk->port_probe)
1654 quirk->port_probe(priv);
1655
1656 priv->port = port;
1657 usb_set_serial_port_data(port, priv);
1658
1659 ftdi_determine_type(port);
1660 ftdi_set_max_packet_size(port);
1661 if (read_latency_timer(port) < 0)
1662 priv->latency = 16;
1663 write_latency_timer(port);
1664 create_sysfs_attrs(port);
1665 return 0;
1666}
1667
1668
1669
1670
1671static void ftdi_USB_UIRT_setup(struct ftdi_private *priv)
1672{
1673 dbg("%s", __func__);
1674
1675 priv->flags |= ASYNC_SPD_CUST;
1676 priv->custom_divisor = 77;
1677 priv->force_baud = 38400;
1678}
1679
1680
1681
1682
1683static void ftdi_HE_TIRA1_setup(struct ftdi_private *priv)
1684{
1685 dbg("%s", __func__);
1686
1687 priv->flags |= ASYNC_SPD_CUST;
1688 priv->custom_divisor = 240;
1689 priv->force_baud = 38400;
1690 priv->force_rtscts = 1;
1691}
1692
1693
1694
1695
1696
1697static int ndi_latency_timer = 1;
1698
1699
1700
1701
1702
1703
1704static int ftdi_NDI_device_setup(struct usb_serial *serial)
1705{
1706 struct usb_device *udev = serial->dev;
1707 int latency = ndi_latency_timer;
1708
1709 if (latency == 0)
1710 latency = 1;
1711 if (latency > 99)
1712 latency = 99;
1713
1714 dbg("%s setting NDI device latency to %d", __func__, latency);
1715 dev_info(&udev->dev, "NDI device with a latency value of %d", latency);
1716
1717
1718 usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
1719 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
1720 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
1721 latency, 0, NULL, 0, WDR_TIMEOUT);
1722 return 0;
1723}
1724
1725
1726
1727
1728
1729
1730static int ftdi_jtag_probe(struct usb_serial *serial)
1731{
1732 struct usb_device *udev = serial->dev;
1733 struct usb_interface *interface = serial->interface;
1734
1735 dbg("%s", __func__);
1736
1737 if (interface == udev->actconfig->interface[0]) {
1738 dev_info(&udev->dev,
1739 "Ignoring serial port reserved for JTAG\n");
1740 return -ENODEV;
1741 }
1742
1743 return 0;
1744}
1745
1746static int ftdi_8u2232c_probe(struct usb_serial *serial)
1747{
1748 struct usb_device *udev = serial->dev;
1749
1750 dbg("%s", __func__);
1751
1752 if (strcmp(udev->manufacturer, "CALAO Systems") == 0)
1753 return ftdi_jtag_probe(serial);
1754
1755 return 0;
1756}
1757
1758
1759
1760
1761
1762static int ftdi_stmclite_probe(struct usb_serial *serial)
1763{
1764 struct usb_device *udev = serial->dev;
1765 struct usb_interface *interface = serial->interface;
1766
1767 dbg("%s", __func__);
1768
1769 if (interface == udev->actconfig->interface[2])
1770 return 0;
1771
1772 dev_info(&udev->dev, "Ignoring serial port reserved for JTAG\n");
1773
1774 return -ENODEV;
1775}
1776
1777
1778
1779
1780
1781static int ftdi_mtxorb_hack_setup(struct usb_serial *serial)
1782{
1783 struct usb_host_endpoint *ep = serial->dev->ep_in[1];
1784 struct usb_endpoint_descriptor *ep_desc = &ep->desc;
1785
1786 if (ep->enabled && ep_desc->wMaxPacketSize == 0) {
1787 ep_desc->wMaxPacketSize = cpu_to_le16(0x40);
1788 dev_info(&serial->dev->dev,
1789 "Fixing invalid wMaxPacketSize on read pipe\n");
1790 }
1791
1792 return 0;
1793}
1794
1795static void ftdi_sio_priv_release(struct kref *k)
1796{
1797 struct ftdi_private *priv = container_of(k, struct ftdi_private, kref);
1798
1799 kfree(priv);
1800}
1801
1802static int ftdi_sio_port_remove(struct usb_serial_port *port)
1803{
1804 struct ftdi_private *priv = usb_get_serial_port_data(port);
1805
1806 dbg("%s", __func__);
1807
1808 remove_sysfs_attrs(port);
1809
1810 kref_put(&priv->kref, ftdi_sio_priv_release);
1811
1812 return 0;
1813}
1814
1815static int ftdi_open(struct tty_struct *tty, struct usb_serial_port *port)
1816{
1817 struct usb_device *dev = port->serial->dev;
1818 struct ftdi_private *priv = usb_get_serial_port_data(port);
1819 int result;
1820
1821 dbg("%s", __func__);
1822
1823
1824
1825 usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1826 FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
1827 FTDI_SIO_RESET_SIO,
1828 priv->interface, NULL, 0, WDR_TIMEOUT);
1829
1830
1831
1832
1833
1834
1835 if (tty)
1836 ftdi_set_termios(tty, port, tty->termios);
1837
1838
1839 result = usb_serial_generic_open(tty, port);
1840 if (!result)
1841 kref_get(&priv->kref);
1842
1843 return result;
1844}
1845
1846static void ftdi_dtr_rts(struct usb_serial_port *port, int on)
1847{
1848 struct ftdi_private *priv = usb_get_serial_port_data(port);
1849
1850 mutex_lock(&port->serial->disc_mutex);
1851 if (!port->serial->disconnected) {
1852
1853 if (!on && usb_control_msg(port->serial->dev,
1854 usb_sndctrlpipe(port->serial->dev, 0),
1855 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1856 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1857 0, priv->interface, NULL, 0,
1858 WDR_TIMEOUT) < 0) {
1859 dev_err(&port->dev, "error from flowcontrol urb\n");
1860 }
1861
1862 if (on)
1863 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1864 else
1865 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1866 }
1867 mutex_unlock(&port->serial->disc_mutex);
1868}
1869
1870
1871
1872
1873
1874
1875static void ftdi_close(struct usb_serial_port *port)
1876{
1877 struct ftdi_private *priv = usb_get_serial_port_data(port);
1878
1879 dbg("%s", __func__);
1880
1881 usb_serial_generic_close(port);
1882 kref_put(&priv->kref, ftdi_sio_priv_release);
1883}
1884
1885
1886
1887
1888
1889
1890
1891
1892static int ftdi_prepare_write_buffer(struct usb_serial_port *port,
1893 void *dest, size_t size)
1894{
1895 struct ftdi_private *priv;
1896 int count;
1897 unsigned long flags;
1898
1899 priv = usb_get_serial_port_data(port);
1900
1901 if (priv->chip_type == SIO) {
1902 unsigned char *buffer = dest;
1903 int i, len, c;
1904
1905 count = 0;
1906 spin_lock_irqsave(&port->lock, flags);
1907 for (i = 0; i < size - 1; i += priv->max_packet_size) {
1908 len = min_t(int, size - i, priv->max_packet_size) - 1;
1909 c = kfifo_out(&port->write_fifo, &buffer[i + 1], len);
1910 if (!c)
1911 break;
1912 buffer[i] = (c << 2) + 1;
1913 count += c + 1;
1914 }
1915 spin_unlock_irqrestore(&port->lock, flags);
1916 } else {
1917 count = kfifo_out_locked(&port->write_fifo, dest, size,
1918 &port->lock);
1919 }
1920
1921 return count;
1922}
1923
1924#define FTDI_RS_ERR_MASK (FTDI_RS_BI | FTDI_RS_PE | FTDI_RS_FE | FTDI_RS_OE)
1925
1926static int ftdi_process_packet(struct tty_struct *tty,
1927 struct usb_serial_port *port, struct ftdi_private *priv,
1928 char *packet, int len)
1929{
1930 int i;
1931 char status;
1932 char flag;
1933 char *ch;
1934
1935 dbg("%s - port %d", __func__, port->number);
1936
1937 if (len < 2) {
1938 dbg("malformed packet");
1939 return 0;
1940 }
1941
1942
1943
1944
1945 status = packet[0] & FTDI_STATUS_B0_MASK;
1946 if (status != priv->prev_status) {
1947 priv->diff_status |= status ^ priv->prev_status;
1948 wake_up_interruptible(&priv->delta_msr_wait);
1949 priv->prev_status = status;
1950 }
1951
1952 flag = TTY_NORMAL;
1953 if (packet[1] & FTDI_RS_ERR_MASK) {
1954
1955
1956 if (packet[1] & FTDI_RS_BI) {
1957 flag = TTY_BREAK;
1958 usb_serial_handle_break(port);
1959 } else if (packet[1] & FTDI_RS_PE) {
1960 flag = TTY_PARITY;
1961 } else if (packet[1] & FTDI_RS_FE) {
1962 flag = TTY_FRAME;
1963 }
1964
1965 if (packet[1] & FTDI_RS_OE)
1966 tty_insert_flip_char(tty, 0, TTY_OVERRUN);
1967 }
1968
1969
1970 if (packet[1] & FTDI_RS_TEMT)
1971 priv->transmit_empty = 1;
1972 else
1973 priv->transmit_empty = 0;
1974
1975 len -= 2;
1976 if (!len)
1977 return 0;
1978 ch = packet + 2;
1979
1980 if (port->port.console && port->sysrq) {
1981 for (i = 0; i < len; i++, ch++) {
1982 if (!usb_serial_handle_sysrq_char(port, *ch))
1983 tty_insert_flip_char(tty, *ch, flag);
1984 }
1985 } else {
1986 tty_insert_flip_string_fixed_flag(tty, ch, flag, len);
1987 }
1988
1989 return len;
1990}
1991
1992static void ftdi_process_read_urb(struct urb *urb)
1993{
1994 struct usb_serial_port *port = urb->context;
1995 struct tty_struct *tty;
1996 struct ftdi_private *priv = usb_get_serial_port_data(port);
1997 char *data = (char *)urb->transfer_buffer;
1998 int i;
1999 int len;
2000 int count = 0;
2001
2002 tty = tty_port_tty_get(&port->port);
2003 if (!tty)
2004 return;
2005
2006 for (i = 0; i < urb->actual_length; i += priv->max_packet_size) {
2007 len = min_t(int, urb->actual_length - i, priv->max_packet_size);
2008 count += ftdi_process_packet(tty, port, priv, &data[i], len);
2009 }
2010
2011 if (count)
2012 tty_flip_buffer_push(tty);
2013 tty_kref_put(tty);
2014}
2015
2016static void ftdi_break_ctl(struct tty_struct *tty, int break_state)
2017{
2018 struct usb_serial_port *port = tty->driver_data;
2019 struct ftdi_private *priv = usb_get_serial_port_data(port);
2020 __u16 urb_value;
2021
2022
2023
2024
2025
2026 if (break_state)
2027 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
2028 else
2029 urb_value = priv->last_set_data_urb_value;
2030
2031 if (usb_control_msg(port->serial->dev,
2032 usb_sndctrlpipe(port->serial->dev, 0),
2033 FTDI_SIO_SET_DATA_REQUEST,
2034 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2035 urb_value , priv->interface,
2036 NULL, 0, WDR_TIMEOUT) < 0) {
2037 dev_err(&port->dev, "%s FAILED to enable/disable break state "
2038 "(state was %d)\n", __func__, break_state);
2039 }
2040
2041 dbg("%s break state is %d - urb is %d", __func__,
2042 break_state, urb_value);
2043
2044}
2045
2046
2047
2048
2049
2050static void ftdi_set_termios(struct tty_struct *tty,
2051 struct usb_serial_port *port, struct ktermios *old_termios)
2052{
2053 struct usb_device *dev = port->serial->dev;
2054 struct ftdi_private *priv = usb_get_serial_port_data(port);
2055 struct ktermios *termios = tty->termios;
2056 unsigned int cflag = termios->c_cflag;
2057 __u16 urb_value;
2058
2059
2060 unsigned int iflag = termios->c_iflag;
2061 unsigned char vstop;
2062 unsigned char vstart;
2063
2064 dbg("%s", __func__);
2065
2066
2067
2068 if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
2069 dbg("%s: forcing baud rate for this device", __func__);
2070 tty_encode_baud_rate(tty, priv->force_baud,
2071 priv->force_baud);
2072 }
2073
2074
2075 if (priv->force_rtscts) {
2076 dbg("%s: forcing rtscts for this device", __func__);
2077 termios->c_cflag |= CRTSCTS;
2078 }
2079
2080 cflag = termios->c_cflag;
2081
2082
2083
2084
2085
2086
2087
2088
2089
2090
2091 urb_value = 0;
2092 urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
2093 FTDI_SIO_SET_DATA_STOP_BITS_1);
2094 if (cflag & PARENB) {
2095 if (cflag & CMSPAR)
2096 urb_value |= cflag & PARODD ?
2097 FTDI_SIO_SET_DATA_PARITY_MARK :
2098 FTDI_SIO_SET_DATA_PARITY_SPACE;
2099 else
2100 urb_value |= cflag & PARODD ?
2101 FTDI_SIO_SET_DATA_PARITY_ODD :
2102 FTDI_SIO_SET_DATA_PARITY_EVEN;
2103 } else {
2104 urb_value |= FTDI_SIO_SET_DATA_PARITY_NONE;
2105 }
2106 if (cflag & CSIZE) {
2107 switch (cflag & CSIZE) {
2108 case CS7: urb_value |= 7; dbg("Setting CS7"); break;
2109 case CS8: urb_value |= 8; dbg("Setting CS8"); break;
2110 default:
2111 dev_err(&port->dev, "CSIZE was set but not CS7-CS8\n");
2112 }
2113 }
2114
2115
2116
2117 priv->last_set_data_urb_value = urb_value;
2118
2119 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2120 FTDI_SIO_SET_DATA_REQUEST,
2121 FTDI_SIO_SET_DATA_REQUEST_TYPE,
2122 urb_value , priv->interface,
2123 NULL, 0, WDR_SHORT_TIMEOUT) < 0) {
2124 dev_err(&port->dev, "%s FAILED to set "
2125 "databits/stopbits/parity\n", __func__);
2126 }
2127
2128
2129 if ((cflag & CBAUD) == B0) {
2130
2131 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
2132 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2133 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2134 0, priv->interface,
2135 NULL, 0, WDR_TIMEOUT) < 0) {
2136 dev_err(&port->dev,
2137 "%s error from disable flowcontrol urb\n",
2138 __func__);
2139 }
2140
2141 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2142 } else {
2143
2144 mutex_lock(&priv->cfg_lock);
2145 if (change_speed(tty, port))
2146 dev_err(&port->dev, "%s urb failed to set baudrate\n",
2147 __func__);
2148 mutex_unlock(&priv->cfg_lock);
2149
2150 if (!old_termios || (old_termios->c_cflag & CBAUD) == B0)
2151 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
2152 }
2153
2154
2155
2156 if (cflag & CRTSCTS) {
2157 dbg("%s Setting to CRTSCTS flow control", __func__);
2158 if (usb_control_msg(dev,
2159 usb_sndctrlpipe(dev, 0),
2160 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2161 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2162 0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
2163 NULL, 0, WDR_TIMEOUT) < 0) {
2164 dev_err(&port->dev,
2165 "urb failed to set to rts/cts flow control\n");
2166 }
2167
2168 } else {
2169
2170
2171
2172
2173
2174
2175
2176 if (iflag & IXOFF) {
2177 dbg("%s request to enable xonxoff iflag=%04x",
2178 __func__, iflag);
2179
2180
2181
2182
2183
2184
2185 vstart = termios->c_cc[VSTART];
2186 vstop = termios->c_cc[VSTOP];
2187 urb_value = (vstop << 8) | (vstart);
2188
2189 if (usb_control_msg(dev,
2190 usb_sndctrlpipe(dev, 0),
2191 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2192 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2193 urb_value , (FTDI_SIO_XON_XOFF_HS
2194 | priv->interface),
2195 NULL, 0, WDR_TIMEOUT) < 0) {
2196 dev_err(&port->dev, "urb failed to set to "
2197 "xon/xoff flow control\n");
2198 }
2199 } else {
2200
2201
2202
2203 dbg("%s Turning off hardware flow control", __func__);
2204 if (usb_control_msg(dev,
2205 usb_sndctrlpipe(dev, 0),
2206 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
2207 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
2208 0, priv->interface,
2209 NULL, 0, WDR_TIMEOUT) < 0) {
2210 dev_err(&port->dev,
2211 "urb failed to clear flow control\n");
2212 }
2213 }
2214
2215 }
2216}
2217
2218static int ftdi_tiocmget(struct tty_struct *tty)
2219{
2220 struct usb_serial_port *port = tty->driver_data;
2221 struct ftdi_private *priv = usb_get_serial_port_data(port);
2222 unsigned char *buf;
2223 int len;
2224 int ret;
2225
2226 dbg("%s TIOCMGET", __func__);
2227
2228 buf = kmalloc(2, GFP_KERNEL);
2229 if (!buf)
2230 return -ENOMEM;
2231
2232
2233
2234
2235 switch (priv->chip_type) {
2236 case SIO:
2237 len = 1;
2238 break;
2239 case FT8U232AM:
2240 case FT232BM:
2241 case FT2232C:
2242 case FT232RL:
2243 case FT2232H:
2244 case FT4232H:
2245 case FT232H:
2246 len = 2;
2247 break;
2248 default:
2249 ret = -EFAULT;
2250 goto out;
2251 }
2252
2253 ret = usb_control_msg(port->serial->dev,
2254 usb_rcvctrlpipe(port->serial->dev, 0),
2255 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
2256 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
2257 0, priv->interface,
2258 buf, len, WDR_TIMEOUT);
2259 if (ret < 0)
2260 goto out;
2261
2262 ret = (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
2263 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
2264 (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
2265 (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
2266 priv->last_dtr_rts;
2267out:
2268 kfree(buf);
2269 return ret;
2270}
2271
2272static int ftdi_tiocmset(struct tty_struct *tty,
2273 unsigned int set, unsigned int clear)
2274{
2275 struct usb_serial_port *port = tty->driver_data;
2276 dbg("%s TIOCMSET", __func__);
2277 return update_mctrl(port, set, clear);
2278}
2279
2280static int ftdi_ioctl(struct tty_struct *tty,
2281 unsigned int cmd, unsigned long arg)
2282{
2283 struct usb_serial_port *port = tty->driver_data;
2284 struct ftdi_private *priv = usb_get_serial_port_data(port);
2285
2286 dbg("%s cmd 0x%04x", __func__, cmd);
2287
2288
2289 switch (cmd) {
2290
2291 case TIOCGSERIAL:
2292 return get_serial_info(port,
2293 (struct serial_struct __user *) arg);
2294
2295 case TIOCSSERIAL:
2296 return set_serial_info(tty, port,
2297 (struct serial_struct __user *) arg);
2298
2299
2300
2301
2302
2303
2304
2305
2306
2307
2308 case TIOCMIWAIT:
2309 while (priv != NULL) {
2310 interruptible_sleep_on(&priv->delta_msr_wait);
2311
2312 if (signal_pending(current))
2313 return -ERESTARTSYS;
2314 else {
2315 char diff = priv->diff_status;
2316
2317 if (diff == 0)
2318 return -EIO;
2319
2320
2321 priv->diff_status = 0;
2322
2323
2324
2325 if (((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
2326 ((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
2327 ((arg & TIOCM_CD) && (diff & FTDI_RS0_RLSD)) ||
2328 ((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS))) {
2329 return 0;
2330 }
2331
2332
2333
2334
2335
2336 }
2337 }
2338 return 0;
2339 case TIOCSERGETLSR:
2340 return get_lsr_info(port, (struct serial_struct __user *)arg);
2341 break;
2342 default:
2343 break;
2344 }
2345
2346
2347
2348 dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __func__, cmd);
2349 return -ENOIOCTLCMD;
2350}
2351
2352static int __init ftdi_init(void)
2353{
2354 int retval;
2355
2356 dbg("%s", __func__);
2357 if (vendor > 0 && product > 0) {
2358
2359 int i;
2360 for (i = 0; id_table_combined[i].idVendor; i++)
2361 ;
2362 id_table_combined[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
2363 id_table_combined[i].idVendor = vendor;
2364 id_table_combined[i].idProduct = product;
2365 }
2366 retval = usb_serial_register(&ftdi_sio_device);
2367 if (retval)
2368 goto failed_sio_register;
2369 retval = usb_register(&ftdi_driver);
2370 if (retval)
2371 goto failed_usb_register;
2372
2373 printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
2374 DRIVER_DESC "\n");
2375 return 0;
2376failed_usb_register:
2377 usb_serial_deregister(&ftdi_sio_device);
2378failed_sio_register:
2379 return retval;
2380}
2381
2382static void __exit ftdi_exit(void)
2383{
2384 dbg("%s", __func__);
2385
2386 usb_deregister(&ftdi_driver);
2387 usb_serial_deregister(&ftdi_sio_device);
2388}
2389
2390
2391module_init(ftdi_init);
2392module_exit(ftdi_exit);
2393
2394MODULE_AUTHOR(DRIVER_AUTHOR);
2395MODULE_DESCRIPTION(DRIVER_DESC);
2396MODULE_LICENSE("GPL");
2397
2398module_param(debug, bool, S_IRUGO | S_IWUSR);
2399MODULE_PARM_DESC(debug, "Debug enabled or not");
2400module_param(vendor, ushort, 0);
2401MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
2402 __MODULE_STRING(FTDI_VID)")");
2403module_param(product, ushort, 0);
2404MODULE_PARM_DESC(product, "User specified product ID");
2405
2406module_param(ndi_latency_timer, int, S_IRUGO | S_IWUSR);
2407MODULE_PARM_DESC(ndi_latency_timer, "NDI device latency timer override");
2408