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