?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6
[wrt350n-kernel.git] / drivers / usb / serial / ftdi_sio.c
blob7d797ab9b5d0055efc36d2c2407ea53ffaa17831
1 /*
2 * USB FTDI SIO driver
3 *
4 * Copyright (C) 1999 - 2001
5 * Greg Kroah-Hartman (greg@kroah.com)
6 * Bill Ryder (bryder@sgi.com)
7 * Copyright (C) 2002
8 * Kuba Ober (kuba@mareimbrium.org)
9 *
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the GNU General Public License as published by
12 * the Free Software Foundation; either version 2 of the License, or
13 * (at your option) any later version.
14 *
15 * See Documentation/usb/usb-serial.txt for more information on using this driver
16 *
17 * See http://ftdi-usb-sio.sourceforge.net for upto date testing info
18 * and extra documentation
19 *
20 * Change entries from 2004 and earlier can be found in versions of this
21 * file in kernel versions prior to the 2.6.24 release.
22 *
23 */
24
25 /* Bill Ryder - bryder@sgi.com - wrote the FTDI_SIO implementation */
26 /* Thanx to FTDI for so kindly providing details of the protocol required */
27 /* to talk to the device */
28 /* Thanx to gkh and the rest of the usb dev group for all code I have assimilated :-) */
29
30 #include <linux/kernel.h>
31 #include <linux/errno.h>
32 #include <linux/init.h>
33 #include <linux/slab.h>
34 #include <linux/tty.h>
35 #include <linux/tty_driver.h>
36 #include <linux/tty_flip.h>
37 #include <linux/module.h>
38 #include <linux/spinlock.h>
39 #include <asm/uaccess.h>
40 #include <linux/usb.h>
41 #include <linux/serial.h>
42 #include <linux/usb/serial.h>
43 #include "ftdi_sio.h"
44
45 /*
46 * Version Information
47 */
48 #define DRIVER_VERSION "v1.4.3"
49 #define DRIVER_AUTHOR "Greg Kroah-Hartman <greg@kroah.com>, Bill Ryder <bryder@sgi.com>, Kuba Ober <kuba@mareimbrium.org>"
50 #define DRIVER_DESC "USB FTDI Serial Converters Driver"
51
52 static int debug;
53 static __u16 vendor = FTDI_VID;
54 static __u16 product;
55
56 struct ftdi_private {
57 ftdi_chip_type_t chip_type;
58 /* type of the device, either SIO or FT8U232AM */
59 int baud_base; /* baud base clock for divisor setting */
60 int custom_divisor; /* custom_divisor kludge, this is for baud_base (different from what goes to the chip!) */
61 __u16 last_set_data_urb_value ;
62 /* the last data state set - needed for doing a break */
63 int write_offset; /* This is the offset in the usb data block to write the serial data -
64 * it is different between devices
65 */
66 int flags; /* some ASYNC_xxxx flags are supported */
67 unsigned long last_dtr_rts; /* saved modem control outputs */
68 wait_queue_head_t delta_msr_wait; /* Used for TIOCMIWAIT */
69 char prev_status, diff_status; /* Used for TIOCMIWAIT */
70 __u8 rx_flags; /* receive state flags (throttling) */
71 spinlock_t rx_lock; /* spinlock for receive state */
72 struct delayed_work rx_work;
73 struct usb_serial_port *port;
74 int rx_processed;
75 unsigned long rx_bytes;
76
77 __u16 interface; /* FT2232C port interface (0 for FT232/245) */
78
79 speed_t force_baud; /* if non-zero, force the baud rate to this value */
80 int force_rtscts; /* if non-zero, force RTS-CTS to always be enabled */
81
82 spinlock_t tx_lock; /* spinlock for transmit state */
83 unsigned long tx_bytes;
84 unsigned long tx_outstanding_bytes;
85 unsigned long tx_outstanding_urbs;
86 };
87
88 /* struct ftdi_sio_quirk is used by devices requiring special attention. */
89 struct ftdi_sio_quirk {
90 int (*probe)(struct usb_serial *);
91 void (*port_probe)(struct ftdi_private *); /* Special settings for probed ports. */
92 };
93
94 static int ftdi_jtag_probe (struct usb_serial *serial);
95 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
96 =======
97 static int ftdi_mtxorb_hack_setup (struct usb_serial *serial);
98 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
99 static void ftdi_USB_UIRT_setup (struct ftdi_private *priv);
100 static void ftdi_HE_TIRA1_setup (struct ftdi_private *priv);
101
102 static struct ftdi_sio_quirk ftdi_jtag_quirk = {
103 .probe = ftdi_jtag_probe,
104 };
105
106 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
107 =======
108 static struct ftdi_sio_quirk ftdi_mtxorb_hack_quirk = {
109 .probe = ftdi_mtxorb_hack_setup,
110 };
111
112 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
113 static struct ftdi_sio_quirk ftdi_USB_UIRT_quirk = {
114 .port_probe = ftdi_USB_UIRT_setup,
115 };
116
117 static struct ftdi_sio_quirk ftdi_HE_TIRA1_quirk = {
118 .port_probe = ftdi_HE_TIRA1_setup,
119 };
120
121 /*
122 * The 8U232AM has the same API as the sio except for:
123 * - it can support MUCH higher baudrates; up to:
124 * o 921600 for RS232 and 2000000 for RS422/485 at 48MHz
125 * o 230400 at 12MHz
126 * so .. 8U232AM's baudrate setting codes are different
127 * - it has a two byte status code.
128 * - it returns characters every 16ms (the FTDI does it every 40ms)
129 *
130 * the bcdDevice value is used to differentiate FT232BM and FT245BM from
131 * the earlier FT8U232AM and FT8U232BM. For now, include all known VID/PID
132 * combinations in both tables.
133 * FIXME: perhaps bcdDevice can also identify 12MHz FT8U232AM devices,
134 * but I don't know if those ever went into mass production. [Ian Abbott]
135 */
136
137
138
139 static struct usb_device_id id_table_combined [] = {
140 { USB_DEVICE(FTDI_VID, FTDI_AMC232_PID) },
141 { USB_DEVICE(FTDI_VID, FTDI_CANUSB_PID) },
142 { USB_DEVICE(FTDI_VID, FTDI_ACTZWAVE_PID) },
143 { USB_DEVICE(FTDI_VID, FTDI_IRTRANS_PID) },
144 { USB_DEVICE(FTDI_VID, FTDI_IPLUS_PID) },
145 { USB_DEVICE(FTDI_VID, FTDI_IPLUS2_PID) },
146 { USB_DEVICE(FTDI_VID, FTDI_DMX4ALL) },
147 { USB_DEVICE(FTDI_VID, FTDI_SIO_PID) },
148 { USB_DEVICE(FTDI_VID, FTDI_8U232AM_PID) },
149 { USB_DEVICE(FTDI_VID, FTDI_8U232AM_ALT_PID) },
150 { USB_DEVICE(FTDI_VID, FTDI_232RL_PID) },
151 { USB_DEVICE(FTDI_VID, FTDI_8U2232C_PID) },
152 { USB_DEVICE(FTDI_VID, FTDI_MICRO_CHAMELEON_PID) },
153 { USB_DEVICE(FTDI_VID, FTDI_RELAIS_PID) },
154 { USB_DEVICE(FTDI_VID, FTDI_OPENDCC_PID) },
155 { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_IOBOARD_PID) },
156 { USB_DEVICE(INTERBIOMETRICS_VID, INTERBIOMETRICS_MINI_IOBOARD_PID) },
157 { USB_DEVICE(FTDI_VID, FTDI_XF_632_PID) },
158 { USB_DEVICE(FTDI_VID, FTDI_XF_634_PID) },
159 { USB_DEVICE(FTDI_VID, FTDI_XF_547_PID) },
160 { USB_DEVICE(FTDI_VID, FTDI_XF_633_PID) },
161 { USB_DEVICE(FTDI_VID, FTDI_XF_631_PID) },
162 { USB_DEVICE(FTDI_VID, FTDI_XF_635_PID) },
163 { USB_DEVICE(FTDI_VID, FTDI_XF_640_PID) },
164 { USB_DEVICE(FTDI_VID, FTDI_XF_642_PID) },
165 { USB_DEVICE(FTDI_VID, FTDI_DSS20_PID) },
166 { USB_DEVICE(FTDI_NF_RIC_VID, FTDI_NF_RIC_PID) },
167 { USB_DEVICE(FTDI_VID, FTDI_VNHCPCUSB_D_PID) },
168 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_0_PID) },
169 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_1_PID) },
170 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_2_PID) },
171 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_3_PID) },
172 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_4_PID) },
173 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_5_PID) },
174 { USB_DEVICE(FTDI_VID, FTDI_MTXORB_6_PID) },
175 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
176 =======
177 { USB_DEVICE(MTXORB_VK_VID, MTXORB_VK_PID),
178 .driver_info = (kernel_ulong_t)&ftdi_mtxorb_hack_quirk },
179 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
180 { USB_DEVICE(FTDI_VID, FTDI_PERLE_ULTRAPORT_PID) },
181 { USB_DEVICE(FTDI_VID, FTDI_PIEGROUP_PID) },
182 { USB_DEVICE(FTDI_VID, FTDI_TNC_X_PID) },
183 { USB_DEVICE(FTDI_VID, FTDI_USBX_707_PID) },
184 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2101_PID) },
185 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2102_PID) },
186 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2103_PID) },
187 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2104_PID) },
188 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2106_PID) },
189 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_1_PID) },
190 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2201_2_PID) },
191 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_1_PID) },
192 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2202_2_PID) },
193 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_1_PID) },
194 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2203_2_PID) },
195 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_1_PID) },
196 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_2_PID) },
197 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_3_PID) },
198 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2401_4_PID) },
199 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_1_PID) },
200 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_2_PID) },
201 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_3_PID) },
202 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2402_4_PID) },
203 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_1_PID) },
204 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_2_PID) },
205 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_3_PID) },
206 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2403_4_PID) },
207 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_1_PID) },
208 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_2_PID) },
209 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_3_PID) },
210 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_4_PID) },
211 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_5_PID) },
212 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_6_PID) },
213 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_7_PID) },
214 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2801_8_PID) },
215 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_1_PID) },
216 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_2_PID) },
217 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_3_PID) },
218 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_4_PID) },
219 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_5_PID) },
220 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_6_PID) },
221 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_7_PID) },
222 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2802_8_PID) },
223 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_1_PID) },
224 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_2_PID) },
225 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_3_PID) },
226 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_4_PID) },
227 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_5_PID) },
228 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_6_PID) },
229 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_7_PID) },
230 { USB_DEVICE(SEALEVEL_VID, SEALEVEL_2803_8_PID) },
231 { USB_DEVICE(IDTECH_VID, IDTECH_IDT1221U_PID) },
232 { USB_DEVICE(OCT_VID, OCT_US101_PID) },
233 { USB_DEVICE(FTDI_VID, FTDI_HE_TIRA1_PID),
234 .driver_info = (kernel_ulong_t)&ftdi_HE_TIRA1_quirk },
235 { USB_DEVICE(FTDI_VID, FTDI_USB_UIRT_PID),
236 .driver_info = (kernel_ulong_t)&ftdi_USB_UIRT_quirk },
237 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_1) },
238 { USB_DEVICE(FTDI_VID, PROTEGO_R2X0) },
239 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_3) },
240 { USB_DEVICE(FTDI_VID, PROTEGO_SPECIAL_4) },
241 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E808_PID) },
242 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E809_PID) },
243 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80A_PID) },
244 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80B_PID) },
245 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80C_PID) },
246 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80D_PID) },
247 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80E_PID) },
248 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E80F_PID) },
249 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E888_PID) },
250 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E889_PID) },
251 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88A_PID) },
252 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88B_PID) },
253 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88C_PID) },
254 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88D_PID) },
255 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88E_PID) },
256 { USB_DEVICE(FTDI_VID, FTDI_GUDEADS_E88F_PID) },
257 { USB_DEVICE(FTDI_VID, FTDI_ELV_UO100_PID) },
258 { USB_DEVICE(FTDI_VID, FTDI_ELV_UM100_PID) },
259 { USB_DEVICE(FTDI_VID, FTDI_ELV_UR100_PID) },
260 { USB_DEVICE(FTDI_VID, FTDI_ELV_ALC8500_PID) },
261 { USB_DEVICE(FTDI_VID, FTDI_PYRAMID_PID) },
262 { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1000PC_PID) },
263 { USB_DEVICE(FTDI_VID, FTDI_IBS_US485_PID) },
264 { USB_DEVICE(FTDI_VID, FTDI_IBS_PICPRO_PID) },
265 { USB_DEVICE(FTDI_VID, FTDI_IBS_PCMCIA_PID) },
266 { USB_DEVICE(FTDI_VID, FTDI_IBS_PK1_PID) },
267 { USB_DEVICE(FTDI_VID, FTDI_IBS_RS232MON_PID) },
268 { USB_DEVICE(FTDI_VID, FTDI_IBS_APP70_PID) },
269 { USB_DEVICE(FTDI_VID, FTDI_IBS_PEDO_PID) },
270 { USB_DEVICE(FTDI_VID, FTDI_IBS_PROD_PID) },
271 /*
272 * Due to many user requests for multiple ELV devices we enable
273 * them by default.
274 */
275 { USB_DEVICE(FTDI_VID, FTDI_ELV_CLI7000_PID) },
276 { USB_DEVICE(FTDI_VID, FTDI_ELV_PPS7330_PID) },
277 { USB_DEVICE(FTDI_VID, FTDI_ELV_TFM100_PID) },
278 { USB_DEVICE(FTDI_VID, FTDI_ELV_UDF77_PID) },
279 { USB_DEVICE(FTDI_VID, FTDI_ELV_UIO88_PID) },
280 { USB_DEVICE(FTDI_VID, FTDI_ELV_UAD8_PID) },
281 { USB_DEVICE(FTDI_VID, FTDI_ELV_UDA7_PID) },
282 { USB_DEVICE(FTDI_VID, FTDI_ELV_USI2_PID) },
283 { USB_DEVICE(FTDI_VID, FTDI_ELV_T1100_PID) },
284 { USB_DEVICE(FTDI_VID, FTDI_ELV_PCD200_PID) },
285 { USB_DEVICE(FTDI_VID, FTDI_ELV_ULA200_PID) },
286 { USB_DEVICE(FTDI_VID, FTDI_ELV_CSI8_PID) },
287 { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1000DL_PID) },
288 { USB_DEVICE(FTDI_VID, FTDI_ELV_PCK100_PID) },
289 { USB_DEVICE(FTDI_VID, FTDI_ELV_RFP500_PID) },
290 { USB_DEVICE(FTDI_VID, FTDI_ELV_FS20SIG_PID) },
291 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS300PC_PID) },
292 { USB_DEVICE(FTDI_VID, FTDI_ELV_FHZ1300PC_PID) },
293 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
294 =======
295 { USB_DEVICE(FTDI_VID, FTDI_ELV_EM1010PC_PID) },
296 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
297 { USB_DEVICE(FTDI_VID, FTDI_ELV_WS500_PID) },
298 { USB_DEVICE(FTDI_VID, LINX_SDMUSBQSS_PID) },
299 { USB_DEVICE(FTDI_VID, LINX_MASTERDEVEL2_PID) },
300 { USB_DEVICE(FTDI_VID, LINX_FUTURE_0_PID) },
301 { USB_DEVICE(FTDI_VID, LINX_FUTURE_1_PID) },
302 { USB_DEVICE(FTDI_VID, LINX_FUTURE_2_PID) },
303 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU20_0_PID) },
304 { USB_DEVICE(FTDI_VID, FTDI_CCSICDU40_1_PID) },
305 { USB_DEVICE(FTDI_VID, FTDI_CCSMACHX_2_PID) },
306 { USB_DEVICE(FTDI_VID, INSIDE_ACCESSO) },
307 { USB_DEVICE(INTREPID_VID, INTREPID_VALUECAN_PID) },
308 { USB_DEVICE(INTREPID_VID, INTREPID_NEOVI_PID) },
309 { USB_DEVICE(FALCOM_VID, FALCOM_TWIST_PID) },
310 { USB_DEVICE(FALCOM_VID, FALCOM_SAMBA_PID) },
311 { USB_DEVICE(FTDI_VID, FTDI_SUUNTO_SPORTS_PID) },
312 { USB_DEVICE(TTI_VID, TTI_QL355P_PID) },
313 { USB_DEVICE(FTDI_VID, FTDI_RM_CANVIEW_PID) },
314 { USB_DEVICE(BANDB_VID, BANDB_USOTL4_PID) },
315 { USB_DEVICE(BANDB_VID, BANDB_USTL4_PID) },
316 { USB_DEVICE(BANDB_VID, BANDB_USO9ML2_PID) },
317 { USB_DEVICE(FTDI_VID, EVER_ECO_PRO_CDS) },
318 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_1_PID) },
319 { USB_DEVICE(FTDI_VID, FTDI_4N_GALAXY_DE_2_PID) },
320 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_0_PID) },
321 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_1_PID) },
322 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_2_PID) },
323 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_3_PID) },
324 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_4_PID) },
325 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_5_PID) },
326 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_6_PID) },
327 { USB_DEVICE(FTDI_VID, XSENS_CONVERTER_7_PID) },
328 { USB_DEVICE(MOBILITY_VID, MOBILITY_USB_SERIAL_PID) },
329 { USB_DEVICE(FTDI_VID, FTDI_ACTIVE_ROBOTS_PID) },
330 { USB_DEVICE(FTDI_VID, FTDI_MHAM_KW_PID) },
331 { USB_DEVICE(FTDI_VID, FTDI_MHAM_YS_PID) },
332 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y6_PID) },
333 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y8_PID) },
334 { USB_DEVICE(FTDI_VID, FTDI_MHAM_IC_PID) },
335 { USB_DEVICE(FTDI_VID, FTDI_MHAM_DB9_PID) },
336 { USB_DEVICE(FTDI_VID, FTDI_MHAM_RS232_PID) },
337 { USB_DEVICE(FTDI_VID, FTDI_MHAM_Y9_PID) },
338 { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_VCP_PID) },
339 { USB_DEVICE(FTDI_VID, FTDI_TERATRONIK_D2XX_PID) },
340 { USB_DEVICE(EVOLUTION_VID, EVOLUTION_ER1_PID) },
341 { USB_DEVICE(EVOLUTION_VID, EVO_HYBRID_PID) },
342 { USB_DEVICE(EVOLUTION_VID, EVO_RCM4_PID) },
343 { USB_DEVICE(FTDI_VID, FTDI_ARTEMIS_PID) },
344 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16_PID) },
345 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16C_PID) },
346 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HR_PID) },
347 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16HRC_PID) },
348 { USB_DEVICE(FTDI_VID, FTDI_ATIK_ATK16IC_PID) },
349 { USB_DEVICE(KOBIL_VID, KOBIL_CONV_B1_PID) },
350 { USB_DEVICE(KOBIL_VID, KOBIL_CONV_KAAN_PID) },
351 { USB_DEVICE(POSIFLEX_VID, POSIFLEX_PP7000_PID) },
352 { USB_DEVICE(FTDI_VID, FTDI_TTUSB_PID) },
353 { USB_DEVICE(FTDI_VID, FTDI_ECLO_COM_1WIRE_PID) },
354 { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_777_PID) },
355 { USB_DEVICE(FTDI_VID, FTDI_WESTREX_MODEL_8900F_PID) },
356 { USB_DEVICE(FTDI_VID, FTDI_PCDJ_DAC2_PID) },
357 { USB_DEVICE(FTDI_VID, FTDI_RRCIRKITS_LOCOBUFFER_PID) },
358 { USB_DEVICE(FTDI_VID, FTDI_ASK_RDR400_PID) },
359 { USB_DEVICE(ICOM_ID1_VID, ICOM_ID1_PID) },
360 { USB_DEVICE(PAPOUCH_VID, PAPOUCH_TMU_PID) },
361 { USB_DEVICE(FTDI_VID, FTDI_ACG_HFDUAL_PID) },
362 { USB_DEVICE(FTDI_VID, FTDI_YEI_SERVOCENTER31_PID) },
363 { USB_DEVICE(FTDI_VID, FTDI_THORLABS_PID) },
364 { USB_DEVICE(TESTO_VID, TESTO_USB_INTERFACE_PID) },
365 { USB_DEVICE(FTDI_VID, FTDI_GAMMA_SCOUT_PID) },
366 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13M_PID) },
367 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13S_PID) },
368 { USB_DEVICE(FTDI_VID, FTDI_TACTRIX_OPENPORT_13U_PID) },
369 { USB_DEVICE(ELEKTOR_VID, ELEKTOR_FT323R_PID) },
370 { USB_DEVICE(TELLDUS_VID, TELLDUS_TELLSTICK_PID) },
371 { USB_DEVICE(FTDI_VID, FTDI_MAXSTREAM_PID) },
372 { USB_DEVICE(TML_VID, TML_USB_SERIAL_PID) },
373 { USB_DEVICE(FTDI_VID, FTDI_ELSTER_UNICOM_PID) },
374 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
375 =======
376 { USB_DEVICE(FTDI_VID, FTDI_PROPOX_JTAGCABLEII_PID) },
377 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
378 { USB_DEVICE(OLIMEX_VID, OLIMEX_ARM_USB_OCD_PID),
379 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
380 { USB_DEVICE(FIC_VID, FIC_NEO1973_DEBUG_PID),
381 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
382 { USB_DEVICE(FTDI_VID, FTDI_OOCDLINK_PID),
383 .driver_info = (kernel_ulong_t)&ftdi_jtag_quirk },
384 { }, /* Optional parameter entry */
385 { } /* Terminating entry */
386 };
387
388 MODULE_DEVICE_TABLE (usb, id_table_combined);
389
390 static struct usb_driver ftdi_driver = {
391 .name = "ftdi_sio",
392 .probe = usb_serial_probe,
393 .disconnect = usb_serial_disconnect,
394 .id_table = id_table_combined,
395 .no_dynamic_id = 1,
396 };
397
398 static const char *ftdi_chip_name[] = {
399 [SIO] = "SIO", /* the serial part of FT8U100AX */
400 [FT8U232AM] = "FT8U232AM",
401 [FT232BM] = "FT232BM",
402 [FT2232C] = "FT2232C",
403 [FT232RL] = "FT232RL",
404 };
405
406
407 /* Constants for read urb and write urb */
408 #define BUFSZ 512
409 #define PKTSZ 64
410
411 /* rx_flags */
412 #define THROTTLED 0x01
413 #define ACTUALLY_THROTTLED 0x02
414
415 /* Used for TIOCMIWAIT */
416 #define FTDI_STATUS_B0_MASK (FTDI_RS0_CTS | FTDI_RS0_DSR | FTDI_RS0_RI | FTDI_RS0_RLSD)
417 #define FTDI_STATUS_B1_MASK (FTDI_RS_BI)
418 /* End TIOCMIWAIT */
419
420 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
421 #define FTDI_IMPL_ASYNC_FLAGS = ( ASYNC_SPD_HI | ASYNC_SPD_VHI \
422 ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP )
423 =======
424 #define FTDI_IMPL_ASYNC_FLAGS = (ASYNC_SPD_HI | ASYNC_SPD_VHI \
425 | ASYNC_SPD_CUST | ASYNC_SPD_SHI | ASYNC_SPD_WARP)
426 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
427
428 /* function prototypes for a FTDI serial converter */
429 static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_id *id);
430 static void ftdi_shutdown (struct usb_serial *serial);
431 static int ftdi_sio_port_probe (struct usb_serial_port *port);
432 static int ftdi_sio_port_remove (struct usb_serial_port *port);
433 static int ftdi_open (struct usb_serial_port *port, struct file *filp);
434 static void ftdi_close (struct usb_serial_port *port, struct file *filp);
435 static int ftdi_write (struct usb_serial_port *port, const unsigned char *buf, int count);
436 static int ftdi_write_room (struct usb_serial_port *port);
437 static int ftdi_chars_in_buffer (struct usb_serial_port *port);
438 static void ftdi_write_bulk_callback (struct urb *urb);
439 static void ftdi_read_bulk_callback (struct urb *urb);
440 static void ftdi_process_read (struct work_struct *work);
441 static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios * old);
442 static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file);
443 static int ftdi_tiocmset (struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear);
444 static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg);
445 static void ftdi_break_ctl (struct usb_serial_port *port, int break_state );
446 static void ftdi_throttle (struct usb_serial_port *port);
447 static void ftdi_unthrottle (struct usb_serial_port *port);
448
449 static unsigned short int ftdi_232am_baud_base_to_divisor (int baud, int base);
450 static unsigned short int ftdi_232am_baud_to_divisor (int baud);
451 static __u32 ftdi_232bm_baud_base_to_divisor (int baud, int base);
452 static __u32 ftdi_232bm_baud_to_divisor (int baud);
453
454 static struct usb_serial_driver ftdi_sio_device = {
455 .driver = {
456 .owner = THIS_MODULE,
457 .name = "ftdi_sio",
458 },
459 .description = "FTDI USB Serial Device",
460 .usb_driver = &ftdi_driver ,
461 .id_table = id_table_combined,
462 .num_interrupt_in = 0,
463 .num_bulk_in = 1,
464 .num_bulk_out = 1,
465 .num_ports = 1,
466 .probe = ftdi_sio_probe,
467 .port_probe = ftdi_sio_port_probe,
468 .port_remove = ftdi_sio_port_remove,
469 .open = ftdi_open,
470 .close = ftdi_close,
471 .throttle = ftdi_throttle,
472 .unthrottle = ftdi_unthrottle,
473 .write = ftdi_write,
474 .write_room = ftdi_write_room,
475 .chars_in_buffer = ftdi_chars_in_buffer,
476 .read_bulk_callback = ftdi_read_bulk_callback,
477 .write_bulk_callback = ftdi_write_bulk_callback,
478 .tiocmget = ftdi_tiocmget,
479 .tiocmset = ftdi_tiocmset,
480 .ioctl = ftdi_ioctl,
481 .set_termios = ftdi_set_termios,
482 .break_ctl = ftdi_break_ctl,
483 .shutdown = ftdi_shutdown,
484 };
485
486
487 #define WDR_TIMEOUT 5000 /* default urb timeout */
488 #define WDR_SHORT_TIMEOUT 1000 /* shorter urb timeout */
489
490 /* High and low are for DTR, RTS etc etc */
491 #define HIGH 1
492 #define LOW 0
493
494 /* number of outstanding urbs to prevent userspace DoS from happening */
495 #define URB_UPPER_LIMIT 42
496
497 /*
498 * ***************************************************************************
499 * Utility functions
500 * ***************************************************************************
501 */
502
503 static unsigned short int ftdi_232am_baud_base_to_divisor(int baud, int base)
504 {
505 unsigned short int divisor;
506 int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
507 if ((divisor3 & 0x7) == 7) divisor3 ++; // round x.7/8 up to x+1
508 divisor = divisor3 >> 3;
509 divisor3 &= 0x7;
510 if (divisor3 == 1) divisor |= 0xc000; else // 0.125
511 if (divisor3 >= 4) divisor |= 0x4000; else // 0.5
512 if (divisor3 != 0) divisor |= 0x8000; // 0.25
513 if (divisor == 1) divisor = 0; /* special case for maximum baud rate */
514 return divisor;
515 }
516
517 static unsigned short int ftdi_232am_baud_to_divisor(int baud)
518 {
519 return(ftdi_232am_baud_base_to_divisor(baud, 48000000));
520 }
521
522 static __u32 ftdi_232bm_baud_base_to_divisor(int baud, int base)
523 {
524 static const unsigned char divfrac[8] = { 0, 3, 2, 4, 1, 5, 6, 7 };
525 __u32 divisor;
526 int divisor3 = base / 2 / baud; // divisor shifted 3 bits to the left
527 divisor = divisor3 >> 3;
528 divisor |= (__u32)divfrac[divisor3 & 0x7] << 14;
529 /* Deal with special cases for highest baud rates. */
530 if (divisor == 1) divisor = 0; else // 1.0
531 if (divisor == 0x4001) divisor = 1; // 1.5
532 return divisor;
533 }
534
535 static __u32 ftdi_232bm_baud_to_divisor(int baud)
536 {
537 return(ftdi_232bm_baud_base_to_divisor(baud, 48000000));
538 }
539
540 #define set_mctrl(port, set) update_mctrl((port), (set), 0)
541 #define clear_mctrl(port, clear) update_mctrl((port), 0, (clear))
542
543 static int update_mctrl(struct usb_serial_port *port, unsigned int set, unsigned int clear)
544 {
545 struct ftdi_private *priv = usb_get_serial_port_data(port);
546 char *buf;
547 unsigned urb_value;
548 int rv;
549
550 if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) {
551 dbg("%s - DTR|RTS not being set|cleared", __FUNCTION__);
552 return 0; /* no change */
553 }
554
555 buf = kmalloc(1, GFP_NOIO);
556 if (!buf) {
557 return -ENOMEM;
558 }
559
560 clear &= ~set; /* 'set' takes precedence over 'clear' */
561 urb_value = 0;
562 if (clear & TIOCM_DTR)
563 urb_value |= FTDI_SIO_SET_DTR_LOW;
564 if (clear & TIOCM_RTS)
565 urb_value |= FTDI_SIO_SET_RTS_LOW;
566 if (set & TIOCM_DTR)
567 urb_value |= FTDI_SIO_SET_DTR_HIGH;
568 if (set & TIOCM_RTS)
569 urb_value |= FTDI_SIO_SET_RTS_HIGH;
570 rv = usb_control_msg(port->serial->dev,
571 usb_sndctrlpipe(port->serial->dev, 0),
572 FTDI_SIO_SET_MODEM_CTRL_REQUEST,
573 FTDI_SIO_SET_MODEM_CTRL_REQUEST_TYPE,
574 urb_value, priv->interface,
575 buf, 0, WDR_TIMEOUT);
576
577 kfree(buf);
578 if (rv < 0) {
579 err("%s Error from MODEM_CTRL urb: DTR %s, RTS %s",
580 __FUNCTION__,
581 (set & TIOCM_DTR) ? "HIGH" :
582 (clear & TIOCM_DTR) ? "LOW" : "unchanged",
583 (set & TIOCM_RTS) ? "HIGH" :
584 (clear & TIOCM_RTS) ? "LOW" : "unchanged");
585 } else {
586 dbg("%s - DTR %s, RTS %s", __FUNCTION__,
587 (set & TIOCM_DTR) ? "HIGH" :
588 (clear & TIOCM_DTR) ? "LOW" : "unchanged",
589 (set & TIOCM_RTS) ? "HIGH" :
590 (clear & TIOCM_RTS) ? "LOW" : "unchanged");
591 priv->last_dtr_rts = (priv->last_dtr_rts & ~clear) | set;
592 }
593 return rv;
594 }
595
596
597 static __u32 get_ftdi_divisor(struct usb_serial_port * port);
598
599
600 static int change_speed(struct usb_serial_port *port)
601 {
602 struct ftdi_private *priv = usb_get_serial_port_data(port);
603 char *buf;
604 __u16 urb_value;
605 __u16 urb_index;
606 __u32 urb_index_value;
607 int rv;
608
609 buf = kmalloc(1, GFP_NOIO);
610 if (!buf)
611 return -ENOMEM;
612
613 urb_index_value = get_ftdi_divisor(port);
614 urb_value = (__u16)urb_index_value;
615 urb_index = (__u16)(urb_index_value >> 16);
616 if (priv->interface) { /* FT2232C */
617 urb_index = (__u16)((urb_index << 8) | priv->interface);
618 }
619
620 rv = usb_control_msg(port->serial->dev,
621 usb_sndctrlpipe(port->serial->dev, 0),
622 FTDI_SIO_SET_BAUDRATE_REQUEST,
623 FTDI_SIO_SET_BAUDRATE_REQUEST_TYPE,
624 urb_value, urb_index,
625 buf, 0, WDR_SHORT_TIMEOUT);
626
627 kfree(buf);
628 return rv;
629 }
630
631
632 static __u32 get_ftdi_divisor(struct usb_serial_port * port)
633 { /* get_ftdi_divisor */
634 struct ftdi_private *priv = usb_get_serial_port_data(port);
635 __u32 div_value = 0;
636 int div_okay = 1;
637 int baud;
638
639 /*
640 * The logic involved in setting the baudrate can be cleanly split in 3 steps.
641 * Obtaining the actual baud rate is a little tricky since unix traditionally
642 * somehow ignored the possibility to set non-standard baud rates.
643 * 1. Standard baud rates are set in tty->termios->c_cflag
644 * 2. If these are not enough, you can set any speed using alt_speed as follows:
645 * - set tty->termios->c_cflag speed to B38400
646 * - set your real speed in tty->alt_speed; it gets ignored when
647 * alt_speed==0, (or)
648 * - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
649 * flags & ASYNC_SPD_MASK == ASYNC_SPD_[HI, VHI, SHI, WARP], this just
650 * sets alt_speed to (HI: 57600, VHI: 115200, SHI: 230400, WARP: 460800)
651 * ** Steps 1, 2 are done courtesy of tty_get_baud_rate
652 * 3. You can also set baud rate by setting custom divisor as follows
653 * - set tty->termios->c_cflag speed to B38400
654 * - call TIOCSSERIAL ioctl with (struct serial_struct) set as follows:
655 * o flags & ASYNC_SPD_MASK == ASYNC_SPD_CUST
656 * o custom_divisor set to baud_base / your_new_baudrate
657 * ** Step 3 is done courtesy of code borrowed from serial.c - I should really
658 * spend some time and separate+move this common code to serial.c, it is
659 * replicated in nearly every serial driver you see.
660 */
661
662 /* 1. Get the baud rate from the tty settings, this observes alt_speed hack */
663
664 baud = tty_get_baud_rate(port->tty);
665 dbg("%s - tty_get_baud_rate reports speed %d", __FUNCTION__, baud);
666
667 /* 2. Observe async-compatible custom_divisor hack, update baudrate if needed */
668
669 if (baud == 38400 &&
670 ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
671 (priv->custom_divisor)) {
672 baud = priv->baud_base / priv->custom_divisor;
673 dbg("%s - custom divisor %d sets baud rate to %d", __FUNCTION__, priv->custom_divisor, baud);
674 }
675
676 /* 3. Convert baudrate to device-specific divisor */
677
678 if (!baud) baud = 9600;
679 switch(priv->chip_type) {
680 case SIO: /* SIO chip */
681 switch(baud) {
682 case 300: div_value = ftdi_sio_b300; break;
683 case 600: div_value = ftdi_sio_b600; break;
684 case 1200: div_value = ftdi_sio_b1200; break;
685 case 2400: div_value = ftdi_sio_b2400; break;
686 case 4800: div_value = ftdi_sio_b4800; break;
687 case 9600: div_value = ftdi_sio_b9600; break;
688 case 19200: div_value = ftdi_sio_b19200; break;
689 case 38400: div_value = ftdi_sio_b38400; break;
690 case 57600: div_value = ftdi_sio_b57600; break;
691 case 115200: div_value = ftdi_sio_b115200; break;
692 } /* baud */
693 if (div_value == 0) {
694 dbg("%s - Baudrate (%d) requested is not supported", __FUNCTION__, baud);
695 div_value = ftdi_sio_b9600;
696 baud = 9600;
697 div_okay = 0;
698 }
699 break;
700 case FT8U232AM: /* 8U232AM chip */
701 if (baud <= 3000000) {
702 div_value = ftdi_232am_baud_to_divisor(baud);
703 } else {
704 dbg("%s - Baud rate too high!", __FUNCTION__);
705 baud = 9600;
706 div_value = ftdi_232am_baud_to_divisor(9600);
707 div_okay = 0;
708 }
709 break;
710 case FT232BM: /* FT232BM chip */
711 case FT2232C: /* FT2232C chip */
712 case FT232RL:
713 if (baud <= 3000000) {
714 div_value = ftdi_232bm_baud_to_divisor(baud);
715 } else {
716 dbg("%s - Baud rate too high!", __FUNCTION__);
717 div_value = ftdi_232bm_baud_to_divisor(9600);
718 div_okay = 0;
719 baud = 9600;
720 }
721 break;
722 } /* priv->chip_type */
723
724 if (div_okay) {
725 dbg("%s - Baud rate set to %d (divisor 0x%lX) on chip %s",
726 __FUNCTION__, baud, (unsigned long)div_value,
727 ftdi_chip_name[priv->chip_type]);
728 }
729
730 tty_encode_baud_rate(port->tty, baud, baud);
731 return(div_value);
732 }
733
734
735 static int get_serial_info(struct usb_serial_port * port, struct serial_struct __user * retinfo)
736 {
737 struct ftdi_private *priv = usb_get_serial_port_data(port);
738 struct serial_struct tmp;
739
740 if (!retinfo)
741 return -EFAULT;
742 memset(&tmp, 0, sizeof(tmp));
743 tmp.flags = priv->flags;
744 tmp.baud_base = priv->baud_base;
745 tmp.custom_divisor = priv->custom_divisor;
746 if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
747 return -EFAULT;
748 return 0;
749 } /* get_serial_info */
750
751
752 static int set_serial_info(struct usb_serial_port * port, struct serial_struct __user * newinfo)
753 { /* set_serial_info */
754 struct ftdi_private *priv = usb_get_serial_port_data(port);
755 struct serial_struct new_serial;
756 struct ftdi_private old_priv;
757
758 if (copy_from_user(&new_serial, newinfo, sizeof(new_serial)))
759 return -EFAULT;
760 old_priv = * priv;
761
762 /* Do error checking and permission checking */
763
764 if (!capable(CAP_SYS_ADMIN)) {
765 if (((new_serial.flags & ~ASYNC_USR_MASK) !=
766 (priv->flags & ~ASYNC_USR_MASK)))
767 return -EPERM;
768 priv->flags = ((priv->flags & ~ASYNC_USR_MASK) |
769 (new_serial.flags & ASYNC_USR_MASK));
770 priv->custom_divisor = new_serial.custom_divisor;
771 goto check_and_exit;
772 }
773
774 if ((new_serial.baud_base != priv->baud_base) &&
775 (new_serial.baud_base < 9600))
776 return -EINVAL;
777
778 /* Make the changes - these are privileged changes! */
779
780 priv->flags = ((priv->flags & ~ASYNC_FLAGS) |
781 (new_serial.flags & ASYNC_FLAGS));
782 priv->custom_divisor = new_serial.custom_divisor;
783
784 port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
785
786 check_and_exit:
787 if ((old_priv.flags & ASYNC_SPD_MASK) !=
788 (priv->flags & ASYNC_SPD_MASK)) {
789 if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_HI)
790 port->tty->alt_speed = 57600;
791 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_VHI)
792 port->tty->alt_speed = 115200;
793 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_SHI)
794 port->tty->alt_speed = 230400;
795 else if ((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_WARP)
796 port->tty->alt_speed = 460800;
797 else
798 port->tty->alt_speed = 0;
799 }
800 if (((old_priv.flags & ASYNC_SPD_MASK) !=
801 (priv->flags & ASYNC_SPD_MASK)) ||
802 (((priv->flags & ASYNC_SPD_MASK) == ASYNC_SPD_CUST) &&
803 (old_priv.custom_divisor != priv->custom_divisor))) {
804 change_speed(port);
805 }
806
807 return (0);
808
809 } /* set_serial_info */
810
811
812 /* Determine type of FTDI chip based on USB config and descriptor. */
813 static void ftdi_determine_type(struct usb_serial_port *port)
814 {
815 struct ftdi_private *priv = usb_get_serial_port_data(port);
816 struct usb_serial *serial = port->serial;
817 struct usb_device *udev = serial->dev;
818 unsigned version;
819 unsigned interfaces;
820
821 /* Assume it is not the original SIO device for now. */
822 priv->baud_base = 48000000 / 2;
823 priv->write_offset = 0;
824
825 version = le16_to_cpu(udev->descriptor.bcdDevice);
826 interfaces = udev->actconfig->desc.bNumInterfaces;
827 dbg("%s: bcdDevice = 0x%x, bNumInterfaces = %u", __FUNCTION__,
828 version, interfaces);
829 if (interfaces > 1) {
830 int inter;
831
832 /* Multiple interfaces. Assume FT2232C. */
833 priv->chip_type = FT2232C;
834 /* Determine interface code. */
835 inter = serial->interface->altsetting->desc.bInterfaceNumber;
836 if (inter == 0) {
837 priv->interface = PIT_SIOA;
838 } else {
839 priv->interface = PIT_SIOB;
840 }
841 /* BM-type devices have a bug where bcdDevice gets set
842 * to 0x200 when iSerialNumber is 0. */
843 if (version < 0x500) {
844 dbg("%s: something fishy - bcdDevice too low for multi-interface device",
845 __FUNCTION__);
846 }
847 } else if (version < 0x200) {
848 /* Old device. Assume its the original SIO. */
849 priv->chip_type = SIO;
850 priv->baud_base = 12000000 / 16;
851 priv->write_offset = 1;
852 } else if (version < 0x400) {
853 /* Assume its an FT8U232AM (or FT8U245AM) */
854 /* (It might be a BM because of the iSerialNumber bug,
855 * but it will still work as an AM device.) */
856 priv->chip_type = FT8U232AM;
857 } else if (version < 0x600) {
858 /* Assume its an FT232BM (or FT245BM) */
859 priv->chip_type = FT232BM;
860 } else {
861 /* Assume its an FT232R */
862 priv->chip_type = FT232RL;
863 }
864 info("Detected %s", ftdi_chip_name[priv->chip_type]);
865 }
866
867
868 /*
869 * ***************************************************************************
870 * Sysfs Attribute
871 * ***************************************************************************
872 */
873
874 static ssize_t show_latency_timer(struct device *dev, struct device_attribute *attr, char *buf)
875 {
876 struct usb_serial_port *port = to_usb_serial_port(dev);
877 struct ftdi_private *priv = usb_get_serial_port_data(port);
878 struct usb_device *udev = port->serial->dev;
879 unsigned short latency = 0;
880 int rv = 0;
881
882
883 dbg("%s",__FUNCTION__);
884
885 rv = usb_control_msg(udev,
886 usb_rcvctrlpipe(udev, 0),
887 FTDI_SIO_GET_LATENCY_TIMER_REQUEST,
888 FTDI_SIO_GET_LATENCY_TIMER_REQUEST_TYPE,
889 0, priv->interface,
890 (char*) &latency, 1, WDR_TIMEOUT);
891
892 if (rv < 0) {
893 dev_err(dev, "Unable to read latency timer: %i\n", rv);
894 return -EIO;
895 }
896 return sprintf(buf, "%i\n", latency);
897 }
898
899 /* Write a new value of the latency timer, in units of milliseconds. */
900 static ssize_t store_latency_timer(struct device *dev, struct device_attribute *attr, const char *valbuf,
901 size_t count)
902 {
903 struct usb_serial_port *port = to_usb_serial_port(dev);
904 struct ftdi_private *priv = usb_get_serial_port_data(port);
905 struct usb_device *udev = port->serial->dev;
906 char buf[1];
907 int v = simple_strtoul(valbuf, NULL, 10);
908 int rv = 0;
909
910 dbg("%s: setting latency timer = %i", __FUNCTION__, v);
911
912 rv = usb_control_msg(udev,
913 usb_sndctrlpipe(udev, 0),
914 FTDI_SIO_SET_LATENCY_TIMER_REQUEST,
915 FTDI_SIO_SET_LATENCY_TIMER_REQUEST_TYPE,
916 v, priv->interface,
917 buf, 0, WDR_TIMEOUT);
918
919 if (rv < 0) {
920 dev_err(dev, "Unable to write latency timer: %i\n", rv);
921 return -EIO;
922 }
923
924 return count;
925 }
926
927 /* Write an event character directly to the FTDI register. The ASCII
928 value is in the low 8 bits, with the enable bit in the 9th bit. */
929 static ssize_t store_event_char(struct device *dev, struct device_attribute *attr, const char *valbuf,
930 size_t count)
931 {
932 struct usb_serial_port *port = to_usb_serial_port(dev);
933 struct ftdi_private *priv = usb_get_serial_port_data(port);
934 struct usb_device *udev = port->serial->dev;
935 char buf[1];
936 int v = simple_strtoul(valbuf, NULL, 10);
937 int rv = 0;
938
939 dbg("%s: setting event char = %i", __FUNCTION__, v);
940
941 rv = usb_control_msg(udev,
942 usb_sndctrlpipe(udev, 0),
943 FTDI_SIO_SET_EVENT_CHAR_REQUEST,
944 FTDI_SIO_SET_EVENT_CHAR_REQUEST_TYPE,
945 v, priv->interface,
946 buf, 0, WDR_TIMEOUT);
947
948 if (rv < 0) {
949 dbg("Unable to write event character: %i", rv);
950 return -EIO;
951 }
952
953 return count;
954 }
955
956 static DEVICE_ATTR(latency_timer, S_IWUSR | S_IRUGO, show_latency_timer, store_latency_timer);
957 static DEVICE_ATTR(event_char, S_IWUSR, NULL, store_event_char);
958
959 static int create_sysfs_attrs(struct usb_serial_port *port)
960 {
961 struct ftdi_private *priv = usb_get_serial_port_data(port);
962 int retval = 0;
963
964 dbg("%s",__FUNCTION__);
965
966 /* XXX I've no idea if the original SIO supports the event_char
967 * sysfs parameter, so I'm playing it safe. */
968 if (priv->chip_type != SIO) {
969 dbg("sysfs attributes for %s", ftdi_chip_name[priv->chip_type]);
970 retval = device_create_file(&port->dev, &dev_attr_event_char);
971 if ((!retval) &&
972 (priv->chip_type == FT232BM ||
973 priv->chip_type == FT2232C ||
974 priv->chip_type == FT232RL)) {
975 retval = device_create_file(&port->dev,
976 &dev_attr_latency_timer);
977 }
978 }
979 return retval;
980 }
981
982 static void remove_sysfs_attrs(struct usb_serial_port *port)
983 {
984 struct ftdi_private *priv = usb_get_serial_port_data(port);
985
986 dbg("%s",__FUNCTION__);
987
988 /* XXX see create_sysfs_attrs */
989 if (priv->chip_type != SIO) {
990 device_remove_file(&port->dev, &dev_attr_event_char);
991 if (priv->chip_type == FT232BM ||
992 priv->chip_type == FT2232C ||
993 priv->chip_type == FT232RL) {
994 device_remove_file(&port->dev, &dev_attr_latency_timer);
995 }
996 }
997
998 }
999
1000 /*
1001 * ***************************************************************************
1002 * FTDI driver specific functions
1003 * ***************************************************************************
1004 */
1005
1006 /* Probe function to check for special devices */
1007 static int ftdi_sio_probe (struct usb_serial *serial, const struct usb_device_id *id)
1008 {
1009 struct ftdi_sio_quirk *quirk = (struct ftdi_sio_quirk *)id->driver_info;
1010
1011 if (quirk && quirk->probe) {
1012 int ret = quirk->probe(serial);
1013 if (ret != 0)
1014 return ret;
1015 }
1016
1017 usb_set_serial_data(serial, (void *)id->driver_info);
1018
1019 return 0;
1020 }
1021
1022 static int ftdi_sio_port_probe(struct usb_serial_port *port)
1023 {
1024 struct ftdi_private *priv;
1025 struct ftdi_sio_quirk *quirk = usb_get_serial_data(port->serial);
1026
1027
1028 dbg("%s",__FUNCTION__);
1029
1030 priv = kzalloc(sizeof(struct ftdi_private), GFP_KERNEL);
1031 if (!priv){
1032 err("%s- kmalloc(%Zd) failed.", __FUNCTION__, sizeof(struct ftdi_private));
1033 return -ENOMEM;
1034 }
1035
1036 spin_lock_init(&priv->rx_lock);
1037 spin_lock_init(&priv->tx_lock);
1038 init_waitqueue_head(&priv->delta_msr_wait);
1039 /* This will push the characters through immediately rather
1040 than queue a task to deliver them */
1041 priv->flags = ASYNC_LOW_LATENCY;
1042
1043 if (quirk && quirk->port_probe)
1044 quirk->port_probe(priv);
1045
1046 /* Increase the size of read buffers */
1047 kfree(port->bulk_in_buffer);
1048 port->bulk_in_buffer = kmalloc (BUFSZ, GFP_KERNEL);
1049 if (!port->bulk_in_buffer) {
1050 kfree (priv);
1051 return -ENOMEM;
1052 }
1053 if (port->read_urb) {
1054 port->read_urb->transfer_buffer = port->bulk_in_buffer;
1055 port->read_urb->transfer_buffer_length = BUFSZ;
1056 }
1057
1058 INIT_DELAYED_WORK(&priv->rx_work, ftdi_process_read);
1059 priv->port = port;
1060
1061 /* Free port's existing write urb and transfer buffer. */
1062 if (port->write_urb) {
1063 usb_free_urb (port->write_urb);
1064 port->write_urb = NULL;
1065 }
1066 kfree(port->bulk_out_buffer);
1067 port->bulk_out_buffer = NULL;
1068
1069 usb_set_serial_port_data(port, priv);
1070
1071 ftdi_determine_type (port);
1072 create_sysfs_attrs(port);
1073 return 0;
1074 }
1075
1076 /* Setup for the USB-UIRT device, which requires hardwired
1077 * baudrate (38400 gets mapped to 312500) */
1078 /* Called from usbserial:serial_probe */
1079 static void ftdi_USB_UIRT_setup (struct ftdi_private *priv)
1080 {
1081 dbg("%s",__FUNCTION__);
1082
1083 priv->flags |= ASYNC_SPD_CUST;
1084 priv->custom_divisor = 77;
1085 priv->force_baud = 38400;
1086 } /* ftdi_USB_UIRT_setup */
1087
1088 /* Setup for the HE-TIRA1 device, which requires hardwired
1089 * baudrate (38400 gets mapped to 100000) and RTS-CTS enabled. */
1090 static void ftdi_HE_TIRA1_setup (struct ftdi_private *priv)
1091 {
1092 dbg("%s",__FUNCTION__);
1093
1094 priv->flags |= ASYNC_SPD_CUST;
1095 priv->custom_divisor = 240;
1096 priv->force_baud = 38400;
1097 priv->force_rtscts = 1;
1098 } /* ftdi_HE_TIRA1_setup */
1099
1100 /*
1101 * First port on JTAG adaptors such as Olimex arm-usb-ocd or the FIC/OpenMoko
1102 * Neo1973 Debug Board is reserved for JTAG interface and can be accessed from
1103 * userspace using openocd.
1104 */
1105 static int ftdi_jtag_probe(struct usb_serial *serial)
1106 {
1107 struct usb_device *udev = serial->dev;
1108 struct usb_interface *interface = serial->interface;
1109
1110 dbg("%s",__FUNCTION__);
1111
1112 if (interface == udev->actconfig->interface[0]) {
1113 info("Ignoring serial port reserved for JTAG");
1114 return -ENODEV;
1115 }
1116
1117 return 0;
1118 }
1119
1120 <<<<<<< HEAD:drivers/usb/serial/ftdi_sio.c
1121 =======
1122 /*
1123 * The Matrix Orbital VK204-25-USB has an invalid IN endpoint.
1124 * We have to correct it if we want to read from it.
1125 */
1126 static int ftdi_mtxorb_hack_setup(struct usb_serial *serial)
1127 {
1128 struct usb_host_endpoint *ep = serial->dev->ep_in[1];
1129 struct usb_endpoint_descriptor *ep_desc = &ep->desc;
1130
1131 if (ep->enabled && ep_desc->wMaxPacketSize == 0) {
1132 ep_desc->wMaxPacketSize = 0x40;
1133 info("Fixing invalid wMaxPacketSize on read pipe");
1134 }
1135
1136 return 0;
1137 }
1138
1139 >>>>>>> 264e3e889d86e552b4191d69bb60f4f3b383135a:drivers/usb/serial/ftdi_sio.c
1140 /* ftdi_shutdown is called from usbserial:usb_serial_disconnect
1141 * it is called when the usb device is disconnected
1142 *
1143 * usbserial:usb_serial_disconnect
1144 * calls __serial_close for each open of the port
1145 * shutdown is called then (ie ftdi_shutdown)
1146 */
1147 static void ftdi_shutdown (struct usb_serial *serial)
1148 {
1149 dbg("%s", __FUNCTION__);
1150 }
1151
1152 static int ftdi_sio_port_remove(struct usb_serial_port *port)
1153 {
1154 struct ftdi_private *priv = usb_get_serial_port_data(port);
1155
1156 dbg("%s", __FUNCTION__);
1157
1158 remove_sysfs_attrs(port);
1159
1160 /* all open ports are closed at this point
1161 * (by usbserial.c:__serial_close, which calls ftdi_close)
1162 */
1163
1164 if (priv) {
1165 usb_set_serial_port_data(port, NULL);
1166 kfree(priv);
1167 }
1168
1169 return 0;
1170 }
1171
1172 static int ftdi_open (struct usb_serial_port *port, struct file *filp)
1173 { /* ftdi_open */
1174 struct usb_device *dev = port->serial->dev;
1175 struct ftdi_private *priv = usb_get_serial_port_data(port);
1176 unsigned long flags;
1177
1178 int result = 0;
1179 char buf[1]; /* Needed for the usb_control_msg I think */
1180
1181 dbg("%s", __FUNCTION__);
1182
1183 spin_lock_irqsave(&priv->tx_lock, flags);
1184 priv->tx_bytes = 0;
1185 spin_unlock_irqrestore(&priv->tx_lock, flags);
1186 spin_lock_irqsave(&priv->rx_lock, flags);
1187 priv->rx_bytes = 0;
1188 spin_unlock_irqrestore(&priv->rx_lock, flags);
1189
1190 if (port->tty)
1191 port->tty->low_latency = (priv->flags & ASYNC_LOW_LATENCY) ? 1 : 0;
1192
1193 /* No error checking for this (will get errors later anyway) */
1194 /* See ftdi_sio.h for description of what is reset */
1195 usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1196 FTDI_SIO_RESET_REQUEST, FTDI_SIO_RESET_REQUEST_TYPE,
1197 FTDI_SIO_RESET_SIO,
1198 priv->interface, buf, 0, WDR_TIMEOUT);
1199
1200 /* Termios defaults are set by usb_serial_init. We don't change
1201 port->tty->termios - this would loose speed settings, etc.
1202 This is same behaviour as serial.c/rs_open() - Kuba */
1203
1204 /* ftdi_set_termios will send usb control messages */
1205 if (port->tty)
1206 ftdi_set_termios(port, port->tty->termios);
1207
1208 /* FIXME: Flow control might be enabled, so it should be checked -
1209 we have no control of defaults! */
1210 /* Turn on RTS and DTR since we are not flow controlling by default */
1211 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1212
1213 /* Not throttled */
1214 spin_lock_irqsave(&priv->rx_lock, flags);
1215 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
1216 spin_unlock_irqrestore(&priv->rx_lock, flags);
1217
1218 /* Start reading from the device */
1219 priv->rx_processed = 0;
1220 usb_fill_bulk_urb(port->read_urb, dev,
1221 usb_rcvbulkpipe(dev, port->bulk_in_endpointAddress),
1222 port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
1223 ftdi_read_bulk_callback, port);
1224 result = usb_submit_urb(port->read_urb, GFP_KERNEL);
1225 if (result)
1226 err("%s - failed submitting read urb, error %d", __FUNCTION__, result);
1227
1228
1229 return result;
1230 } /* ftdi_open */
1231
1232
1233
1234 /*
1235 * usbserial:__serial_close only calls ftdi_close if the point is open
1236 *
1237 * This only gets called when it is the last close
1238 *
1239 *
1240 */
1241
1242 static void ftdi_close (struct usb_serial_port *port, struct file *filp)
1243 { /* ftdi_close */
1244 unsigned int c_cflag = port->tty->termios->c_cflag;
1245 struct ftdi_private *priv = usb_get_serial_port_data(port);
1246 char buf[1];
1247
1248 dbg("%s", __FUNCTION__);
1249
1250 mutex_lock(&port->serial->disc_mutex);
1251 if (c_cflag & HUPCL && !port->serial->disconnected){
1252 /* Disable flow control */
1253 if (usb_control_msg(port->serial->dev,
1254 usb_sndctrlpipe(port->serial->dev, 0),
1255 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1256 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1257 0, priv->interface, buf, 0,
1258 WDR_TIMEOUT) < 0) {
1259 err("error from flowcontrol urb");
1260 }
1261
1262 /* drop RTS and DTR */
1263 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1264 } /* Note change no line if hupcl is off */
1265 mutex_unlock(&port->serial->disc_mutex);
1266
1267 /* cancel any scheduled reading */
1268 cancel_delayed_work(&priv->rx_work);
1269 flush_scheduled_work();
1270
1271 /* shutdown our bulk read */
1272 usb_kill_urb(port->read_urb);
1273 } /* ftdi_close */
1274
1275
1276
1277 /* The SIO requires the first byte to have:
1278 * B0 1
1279 * B1 0
1280 * B2..7 length of message excluding byte 0
1281 *
1282 * The new devices do not require this byte
1283 */
1284 static int ftdi_write (struct usb_serial_port *port,
1285 const unsigned char *buf, int count)
1286 { /* ftdi_write */
1287 struct ftdi_private *priv = usb_get_serial_port_data(port);
1288 struct urb *urb;
1289 unsigned char *buffer;
1290 int data_offset ; /* will be 1 for the SIO and 0 otherwise */
1291 int status;
1292 int transfer_size;
1293 unsigned long flags;
1294
1295 dbg("%s port %d, %d bytes", __FUNCTION__, port->number, count);
1296
1297 if (count == 0) {
1298 dbg("write request of 0 bytes");
1299 return 0;
1300 }
1301 spin_lock_irqsave(&priv->tx_lock, flags);
1302 if (priv->tx_outstanding_urbs > URB_UPPER_LIMIT) {
1303 spin_unlock_irqrestore(&priv->tx_lock, flags);
1304 dbg("%s - write limit hit\n", __FUNCTION__);
1305 return 0;
1306 }
1307 priv->tx_outstanding_urbs++;
1308 spin_unlock_irqrestore(&priv->tx_lock, flags);
1309
1310 data_offset = priv->write_offset;
1311 dbg("data_offset set to %d",data_offset);
1312
1313 /* Determine total transfer size */
1314 transfer_size = count;
1315 if (data_offset > 0) {
1316 /* Original sio needs control bytes too... */
1317 transfer_size += (data_offset *
1318 ((count + (PKTSZ - 1 - data_offset)) /
1319 (PKTSZ - data_offset)));
1320 }
1321
1322 buffer = kmalloc (transfer_size, GFP_ATOMIC);
1323 if (!buffer) {
1324 err("%s ran out of kernel memory for urb ...", __FUNCTION__);
1325 count = -ENOMEM;
1326 goto error_no_buffer;
1327 }
1328
1329 urb = usb_alloc_urb(0, GFP_ATOMIC);
1330 if (!urb) {
1331 err("%s - no more free urbs", __FUNCTION__);
1332 count = -ENOMEM;
1333 goto error_no_urb;
1334 }
1335
1336 /* Copy data */
1337 if (data_offset > 0) {
1338 /* Original sio requires control byte at start of each packet. */
1339 int user_pktsz = PKTSZ - data_offset;
1340 int todo = count;
1341 unsigned char *first_byte = buffer;
1342 const unsigned char *current_position = buf;
1343
1344 while (todo > 0) {
1345 if (user_pktsz > todo) {
1346 user_pktsz = todo;
1347 }
1348 /* Write the control byte at the front of the packet*/
1349 *first_byte = 1 | ((user_pktsz) << 2);
1350 /* Copy data for packet */
1351 memcpy (first_byte + data_offset,
1352 current_position, user_pktsz);
1353 first_byte += user_pktsz + data_offset;
1354 current_position += user_pktsz;
1355 todo -= user_pktsz;
1356 }
1357 } else {
1358 /* No control byte required. */
1359 /* Copy in the data to send */
1360 memcpy (buffer, buf, count);
1361 }
1362
1363 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, transfer_size, buffer);
1364
1365 /* fill the buffer and send it */
1366 usb_fill_bulk_urb(urb, port->serial->dev,
1367 usb_sndbulkpipe(port->serial->dev, port->bulk_out_endpointAddress),
1368 buffer, transfer_size,
1369 ftdi_write_bulk_callback, port);
1370
1371 status = usb_submit_urb(urb, GFP_ATOMIC);
1372 if (status) {
1373 err("%s - failed submitting write urb, error %d", __FUNCTION__, status);
1374 count = status;
1375 goto error;
1376 } else {
1377 spin_lock_irqsave(&priv->tx_lock, flags);
1378 priv->tx_outstanding_bytes += count;
1379 priv->tx_bytes += count;
1380 spin_unlock_irqrestore(&priv->tx_lock, flags);
1381 }
1382
1383 /* we are done with this urb, so let the host driver
1384 * really free it when it is finished with it */
1385 usb_free_urb(urb);
1386
1387 dbg("%s write returning: %d", __FUNCTION__, count);
1388 return count;
1389 error:
1390 usb_free_urb(urb);
1391 error_no_urb:
1392 kfree (buffer);
1393 error_no_buffer:
1394 spin_lock_irqsave(&priv->tx_lock, flags);
1395 priv->tx_outstanding_urbs--;
1396 spin_unlock_irqrestore(&priv->tx_lock, flags);
1397 return count;
1398 } /* ftdi_write */
1399
1400
1401 /* This function may get called when the device is closed */
1402
1403 static void ftdi_write_bulk_callback (struct urb *urb)
1404 {
1405 unsigned long flags;
1406 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1407 struct ftdi_private *priv;
1408 int data_offset; /* will be 1 for the SIO and 0 otherwise */
1409 unsigned long countback;
1410 int status = urb->status;
1411
1412 /* free up the transfer buffer, as usb_free_urb() does not do this */
1413 kfree (urb->transfer_buffer);
1414
1415 dbg("%s - port %d", __FUNCTION__, port->number);
1416
1417 if (status) {
1418 dbg("nonzero write bulk status received: %d", status);
1419 return;
1420 }
1421
1422 priv = usb_get_serial_port_data(port);
1423 if (!priv) {
1424 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1425 return;
1426 }
1427 /* account for transferred data */
1428 countback = urb->actual_length;
1429 data_offset = priv->write_offset;
1430 if (data_offset > 0) {
1431 /* Subtract the control bytes */
1432 countback -= (data_offset * ((countback + (PKTSZ - 1)) / PKTSZ));
1433 }
1434 spin_lock_irqsave(&priv->tx_lock, flags);
1435 --priv->tx_outstanding_urbs;
1436 priv->tx_outstanding_bytes -= countback;
1437 spin_unlock_irqrestore(&priv->tx_lock, flags);
1438
1439 usb_serial_port_softint(port);
1440 } /* ftdi_write_bulk_callback */
1441
1442
1443 static int ftdi_write_room( struct usb_serial_port *port )
1444 {
1445 struct ftdi_private *priv = usb_get_serial_port_data(port);
1446 int room;
1447 unsigned long flags;
1448
1449 dbg("%s - port %d", __FUNCTION__, port->number);
1450
1451 spin_lock_irqsave(&priv->tx_lock, flags);
1452 if (priv->tx_outstanding_urbs < URB_UPPER_LIMIT) {
1453 /*
1454 * We really can take anything the user throws at us
1455 * but let's pick a nice big number to tell the tty
1456 * layer that we have lots of free space
1457 */
1458 room = 2048;
1459 } else {
1460 room = 0;
1461 }
1462 spin_unlock_irqrestore(&priv->tx_lock, flags);
1463 return room;
1464 } /* ftdi_write_room */
1465
1466
1467 static int ftdi_chars_in_buffer (struct usb_serial_port *port)
1468 { /* ftdi_chars_in_buffer */
1469 struct ftdi_private *priv = usb_get_serial_port_data(port);
1470 int buffered;
1471 unsigned long flags;
1472
1473 dbg("%s - port %d", __FUNCTION__, port->number);
1474
1475 spin_lock_irqsave(&priv->tx_lock, flags);
1476 buffered = (int)priv->tx_outstanding_bytes;
1477 spin_unlock_irqrestore(&priv->tx_lock, flags);
1478 if (buffered < 0) {
1479 err("%s outstanding tx bytes is negative!", __FUNCTION__);
1480 buffered = 0;
1481 }
1482 return buffered;
1483 } /* ftdi_chars_in_buffer */
1484
1485
1486
1487 static void ftdi_read_bulk_callback (struct urb *urb)
1488 { /* ftdi_read_bulk_callback */
1489 struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
1490 struct tty_struct *tty;
1491 struct ftdi_private *priv;
1492 unsigned long countread;
1493 unsigned long flags;
1494 int status = urb->status;
1495
1496 if (urb->number_of_packets > 0) {
1497 err("%s transfer_buffer_length %d actual_length %d number of packets %d",__FUNCTION__,
1498 urb->transfer_buffer_length, urb->actual_length, urb->number_of_packets );
1499 err("%s transfer_flags %x ", __FUNCTION__,urb->transfer_flags );
1500 }
1501
1502 dbg("%s - port %d", __FUNCTION__, port->number);
1503
1504 if (port->open_count <= 0)
1505 return;
1506
1507 tty = port->tty;
1508 if (!tty) {
1509 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1510 return;
1511 }
1512
1513 priv = usb_get_serial_port_data(port);
1514 if (!priv) {
1515 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1516 return;
1517 }
1518
1519 if (urb != port->read_urb) {
1520 err("%s - Not my urb!", __FUNCTION__);
1521 }
1522
1523 if (status) {
1524 /* This will happen at close every time so it is a dbg not an err */
1525 dbg("(this is ok on close) nonzero read bulk status received: "
1526 "%d", status);
1527 return;
1528 }
1529
1530 /* count data bytes, but not status bytes */
1531 countread = urb->actual_length;
1532 countread -= 2 * ((countread + (PKTSZ - 1)) / PKTSZ);
1533 spin_lock_irqsave(&priv->rx_lock, flags);
1534 priv->rx_bytes += countread;
1535 spin_unlock_irqrestore(&priv->rx_lock, flags);
1536
1537 ftdi_process_read(&priv->rx_work.work);
1538
1539 } /* ftdi_read_bulk_callback */
1540
1541
1542 static void ftdi_process_read (struct work_struct *work)
1543 { /* ftdi_process_read */
1544 struct ftdi_private *priv =
1545 container_of(work, struct ftdi_private, rx_work.work);
1546 struct usb_serial_port *port = priv->port;
1547 struct urb *urb;
1548 struct tty_struct *tty;
1549 char error_flag;
1550 unsigned char *data;
1551
1552 int i;
1553 int result;
1554 int need_flip;
1555 int packet_offset;
1556 unsigned long flags;
1557
1558 dbg("%s - port %d", __FUNCTION__, port->number);
1559
1560 if (port->open_count <= 0)
1561 return;
1562
1563 tty = port->tty;
1564 if (!tty) {
1565 dbg("%s - bad tty pointer - exiting",__FUNCTION__);
1566 return;
1567 }
1568
1569 priv = usb_get_serial_port_data(port);
1570 if (!priv) {
1571 dbg("%s - bad port private data pointer - exiting", __FUNCTION__);
1572 return;
1573 }
1574
1575 urb = port->read_urb;
1576 if (!urb) {
1577 dbg("%s - bad read_urb pointer - exiting", __FUNCTION__);
1578 return;
1579 }
1580
1581 data = urb->transfer_buffer;
1582
1583 if (priv->rx_processed) {
1584 dbg("%s - already processed: %d bytes, %d remain", __FUNCTION__,
1585 priv->rx_processed,
1586 urb->actual_length - priv->rx_processed);
1587 } else {
1588 /* The first two bytes of every read packet are status */
1589 if (urb->actual_length > 2) {
1590 usb_serial_debug_data(debug, &port->dev, __FUNCTION__, urb->actual_length, data);
1591 } else {
1592 dbg("Status only: %03oo %03oo",data[0],data[1]);
1593 }
1594 }
1595
1596
1597 /* TO DO -- check for hung up line and handle appropriately: */
1598 /* send hangup */
1599 /* See acm.c - you do a tty_hangup - eg tty_hangup(tty) */
1600 /* if CD is dropped and the line is not CLOCAL then we should hangup */
1601
1602 need_flip = 0;
1603 for (packet_offset = priv->rx_processed; packet_offset < urb->actual_length; packet_offset += PKTSZ) {
1604 int length;
1605
1606 /* Compare new line status to the old one, signal if different */
1607 /* N.B. packet may be processed more than once, but differences
1608 * are only processed once. */
1609 if (priv != NULL) {
1610 char new_status = data[packet_offset+0] & FTDI_STATUS_B0_MASK;
1611 if (new_status != priv->prev_status) {
1612 priv->diff_status |= new_status ^ priv->prev_status;
1613 wake_up_interruptible(&priv->delta_msr_wait);
1614 priv->prev_status = new_status;
1615 }
1616 }
1617
1618 length = min(PKTSZ, urb->actual_length-packet_offset)-2;
1619 if (length < 0) {
1620 err("%s - bad packet length: %d", __FUNCTION__, length+2);
1621 length = 0;
1622 }
1623
1624 if (priv->rx_flags & THROTTLED) {
1625 dbg("%s - throttled", __FUNCTION__);
1626 break;
1627 }
1628 if (tty_buffer_request_room(tty, length) < length) {
1629 /* break out & wait for throttling/unthrottling to happen */
1630 dbg("%s - receive room low", __FUNCTION__);
1631 break;
1632 }
1633
1634 /* Handle errors and break */
1635 error_flag = TTY_NORMAL;
1636 /* Although the device uses a bitmask and hence can have multiple */
1637 /* errors on a packet - the order here sets the priority the */
1638 /* error is returned to the tty layer */
1639
1640 if ( data[packet_offset+1] & FTDI_RS_OE ) {
1641 error_flag = TTY_OVERRUN;
1642 dbg("OVERRRUN error");
1643 }
1644 if ( data[packet_offset+1] & FTDI_RS_BI ) {
1645 error_flag = TTY_BREAK;
1646 dbg("BREAK received");
1647 }
1648 if ( data[packet_offset+1] & FTDI_RS_PE ) {
1649 error_flag = TTY_PARITY;
1650 dbg("PARITY error");
1651 }
1652 if ( data[packet_offset+1] & FTDI_RS_FE ) {
1653 error_flag = TTY_FRAME;
1654 dbg("FRAMING error");
1655 }
1656 if (length > 0) {
1657 for (i = 2; i < length+2; i++) {
1658 /* Note that the error flag is duplicated for
1659 every character received since we don't know
1660 which character it applied to */
1661 tty_insert_flip_char(tty, data[packet_offset+i], error_flag);
1662 }
1663 need_flip = 1;
1664 }
1665
1666 #ifdef NOT_CORRECT_BUT_KEEPING_IT_FOR_NOW
1667 /* if a parity error is detected you get status packets forever
1668 until a character is sent without a parity error.
1669 This doesn't work well since the application receives a never
1670 ending stream of bad data - even though new data hasn't been sent.
1671 Therefore I (bill) have taken this out.
1672 However - this might make sense for framing errors and so on
1673 so I am leaving the code in for now.
1674 */
1675 else {
1676 if (error_flag != TTY_NORMAL){
1677 dbg("error_flag is not normal");
1678 /* In this case it is just status - if that is an error send a bad character */
1679 if(tty->flip.count >= TTY_FLIPBUF_SIZE) {
1680 tty_flip_buffer_push(tty);
1681 }
1682 tty_insert_flip_char(tty, 0xff, error_flag);
1683 need_flip = 1;
1684 }
1685 }
1686 #endif
1687 } /* "for(packet_offset=0..." */
1688
1689 /* Low latency */
1690 if (need_flip) {
1691 tty_flip_buffer_push(tty);
1692 }
1693
1694 if (packet_offset < urb->actual_length) {
1695 /* not completely processed - record progress */
1696 priv->rx_processed = packet_offset;
1697 dbg("%s - incomplete, %d bytes processed, %d remain",
1698 __FUNCTION__, packet_offset,
1699 urb->actual_length - packet_offset);
1700 /* check if we were throttled while processing */
1701 spin_lock_irqsave(&priv->rx_lock, flags);
1702 if (priv->rx_flags & THROTTLED) {
1703 priv->rx_flags |= ACTUALLY_THROTTLED;
1704 spin_unlock_irqrestore(&priv->rx_lock, flags);
1705 dbg("%s - deferring remainder until unthrottled",
1706 __FUNCTION__);
1707 return;
1708 }
1709 spin_unlock_irqrestore(&priv->rx_lock, flags);
1710 /* if the port is closed stop trying to read */
1711 if (port->open_count > 0){
1712 /* delay processing of remainder */
1713 schedule_delayed_work(&priv->rx_work, 1);
1714 } else {
1715 dbg("%s - port is closed", __FUNCTION__);
1716 }
1717 return;
1718 }
1719
1720 /* urb is completely processed */
1721 priv->rx_processed = 0;
1722
1723 /* if the port is closed stop trying to read */
1724 if (port->open_count > 0){
1725 /* Continue trying to always read */
1726 usb_fill_bulk_urb(port->read_urb, port->serial->dev,
1727 usb_rcvbulkpipe(port->serial->dev, port->bulk_in_endpointAddress),
1728 port->read_urb->transfer_buffer, port->read_urb->transfer_buffer_length,
1729 ftdi_read_bulk_callback, port);
1730
1731 result = usb_submit_urb(port->read_urb, GFP_ATOMIC);
1732 if (result)
1733 err("%s - failed resubmitting read urb, error %d", __FUNCTION__, result);
1734 }
1735
1736 return;
1737 } /* ftdi_process_read */
1738
1739
1740 static void ftdi_break_ctl( struct usb_serial_port *port, int break_state )
1741 {
1742 struct ftdi_private *priv = usb_get_serial_port_data(port);
1743 __u16 urb_value = 0;
1744 char buf[1];
1745
1746 /* break_state = -1 to turn on break, and 0 to turn off break */
1747 /* see drivers/char/tty_io.c to see it used */
1748 /* last_set_data_urb_value NEVER has the break bit set in it */
1749
1750 if (break_state) {
1751 urb_value = priv->last_set_data_urb_value | FTDI_SIO_SET_BREAK;
1752 } else {
1753 urb_value = priv->last_set_data_urb_value;
1754 }
1755
1756
1757 if (usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0),
1758 FTDI_SIO_SET_DATA_REQUEST,
1759 FTDI_SIO_SET_DATA_REQUEST_TYPE,
1760 urb_value , priv->interface,
1761 buf, 0, WDR_TIMEOUT) < 0) {
1762 err("%s FAILED to enable/disable break state (state was %d)", __FUNCTION__,break_state);
1763 }
1764
1765 dbg("%s break state is %d - urb is %d", __FUNCTION__,break_state, urb_value);
1766
1767 }
1768
1769
1770 /* old_termios contains the original termios settings and tty->termios contains
1771 * the new setting to be used
1772 * WARNING: set_termios calls this with old_termios in kernel space
1773 */
1774
1775 static void ftdi_set_termios (struct usb_serial_port *port, struct ktermios *old_termios)
1776 { /* ftdi_termios */
1777 struct usb_device *dev = port->serial->dev;
1778 struct ftdi_private *priv = usb_get_serial_port_data(port);
1779 struct ktermios *termios = port->tty->termios;
1780 unsigned int cflag = termios->c_cflag;
1781 __u16 urb_value; /* will hold the new flags */
1782 char buf[1]; /* Perhaps I should dynamically alloc this? */
1783
1784 // Added for xon/xoff support
1785 unsigned int iflag = termios->c_iflag;
1786 unsigned char vstop;
1787 unsigned char vstart;
1788
1789 dbg("%s", __FUNCTION__);
1790
1791 /* Force baud rate if this device requires it, unless it is set to B0. */
1792 if (priv->force_baud && ((termios->c_cflag & CBAUD) != B0)) {
1793 dbg("%s: forcing baud rate for this device", __FUNCTION__);
1794 tty_encode_baud_rate(port->tty, priv->force_baud,
1795 priv->force_baud);
1796 }
1797
1798 /* Force RTS-CTS if this device requires it. */
1799 if (priv->force_rtscts) {
1800 dbg("%s: forcing rtscts for this device", __FUNCTION__);
1801 termios->c_cflag |= CRTSCTS;
1802 }
1803
1804 cflag = termios->c_cflag;
1805
1806 /* FIXME -For this cut I don't care if the line is really changing or
1807 not - so just do the change regardless - should be able to
1808 compare old_termios and tty->termios */
1809 /* NOTE These routines can get interrupted by
1810 ftdi_sio_read_bulk_callback - need to examine what this
1811 means - don't see any problems yet */
1812
1813 /* Set number of data bits, parity, stop bits */
1814
1815 termios->c_cflag &= ~CMSPAR;
1816
1817 urb_value = 0;
1818 urb_value |= (cflag & CSTOPB ? FTDI_SIO_SET_DATA_STOP_BITS_2 :
1819 FTDI_SIO_SET_DATA_STOP_BITS_1);
1820 urb_value |= (cflag & PARENB ?
1821 (cflag & PARODD ? FTDI_SIO_SET_DATA_PARITY_ODD :
1822 FTDI_SIO_SET_DATA_PARITY_EVEN) :
1823 FTDI_SIO_SET_DATA_PARITY_NONE);
1824 if (cflag & CSIZE) {
1825 switch (cflag & CSIZE) {
1826 case CS5: urb_value |= 5; dbg("Setting CS5"); break;
1827 case CS6: urb_value |= 6; dbg("Setting CS6"); break;
1828 case CS7: urb_value |= 7; dbg("Setting CS7"); break;
1829 case CS8: urb_value |= 8; dbg("Setting CS8"); break;
1830 default:
1831 err("CSIZE was set but not CS5-CS8");
1832 }
1833 }
1834
1835 /* This is needed by the break command since it uses the same command - but is
1836 * or'ed with this value */
1837 priv->last_set_data_urb_value = urb_value;
1838
1839 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1840 FTDI_SIO_SET_DATA_REQUEST,
1841 FTDI_SIO_SET_DATA_REQUEST_TYPE,
1842 urb_value , priv->interface,
1843 buf, 0, WDR_SHORT_TIMEOUT) < 0) {
1844 err("%s FAILED to set databits/stopbits/parity", __FUNCTION__);
1845 }
1846
1847 /* Now do the baudrate */
1848 if ((cflag & CBAUD) == B0 ) {
1849 /* Disable flow control */
1850 if (usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
1851 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1852 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1853 0, priv->interface,
1854 buf, 0, WDR_TIMEOUT) < 0) {
1855 err("%s error from disable flowcontrol urb", __FUNCTION__);
1856 }
1857 /* Drop RTS and DTR */
1858 clear_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1859 } else {
1860 /* set the baudrate determined before */
1861 if (change_speed(port)) {
1862 err("%s urb failed to set baudrate", __FUNCTION__);
1863 }
1864 /* Ensure RTS and DTR are raised when baudrate changed from 0 */
1865 if (!old_termios || (old_termios->c_cflag & CBAUD) == B0) {
1866 set_mctrl(port, TIOCM_DTR | TIOCM_RTS);
1867 }
1868 }
1869
1870 /* Set flow control */
1871 /* Note device also supports DTR/CD (ugh) and Xon/Xoff in hardware */
1872 if (cflag & CRTSCTS) {
1873 dbg("%s Setting to CRTSCTS flow control", __FUNCTION__);
1874 if (usb_control_msg(dev,
1875 usb_sndctrlpipe(dev, 0),
1876 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1877 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1878 0 , (FTDI_SIO_RTS_CTS_HS | priv->interface),
1879 buf, 0, WDR_TIMEOUT) < 0) {
1880 err("urb failed to set to rts/cts flow control");
1881 }
1882
1883 } else {
1884 /*
1885 * Xon/Xoff code
1886 *
1887 * Check the IXOFF status in the iflag component of the termios structure
1888 * if IXOFF is not set, the pre-xon/xoff code is executed.
1889 */
1890 if (iflag & IXOFF) {
1891 dbg("%s request to enable xonxoff iflag=%04x",__FUNCTION__,iflag);
1892 // Try to enable the XON/XOFF on the ftdi_sio
1893 // Set the vstart and vstop -- could have been done up above where
1894 // a lot of other dereferencing is done but that would be very
1895 // inefficient as vstart and vstop are not always needed
1896 vstart = termios->c_cc[VSTART];
1897 vstop = termios->c_cc[VSTOP];
1898 urb_value=(vstop << 8) | (vstart);
1899
1900 if (usb_control_msg(dev,
1901 usb_sndctrlpipe(dev, 0),
1902 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1903 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1904 urb_value , (FTDI_SIO_XON_XOFF_HS
1905 | priv->interface),
1906 buf, 0, WDR_TIMEOUT) < 0) {
1907 err("urb failed to set to xon/xoff flow control");
1908 }
1909 } else {
1910 /* else clause to only run if cfag ! CRTSCTS and iflag ! XOFF */
1911 /* CHECKME Assuming XON/XOFF handled by tty stack - not by device */
1912 dbg("%s Turning off hardware flow control", __FUNCTION__);
1913 if (usb_control_msg(dev,
1914 usb_sndctrlpipe(dev, 0),
1915 FTDI_SIO_SET_FLOW_CTRL_REQUEST,
1916 FTDI_SIO_SET_FLOW_CTRL_REQUEST_TYPE,
1917 0, priv->interface,
1918 buf, 0, WDR_TIMEOUT) < 0) {
1919 err("urb failed to clear flow control");
1920 }
1921 }
1922
1923 }
1924 return;
1925 } /* ftdi_termios */
1926
1927
1928 static int ftdi_tiocmget (struct usb_serial_port *port, struct file *file)
1929 {
1930 struct ftdi_private *priv = usb_get_serial_port_data(port);
1931 unsigned char buf[2];
1932 int ret;
1933
1934 dbg("%s TIOCMGET", __FUNCTION__);
1935 switch (priv->chip_type) {
1936 case SIO:
1937 /* Request the status from the device */
1938 if ((ret = usb_control_msg(port->serial->dev,
1939 usb_rcvctrlpipe(port->serial->dev, 0),
1940 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
1941 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
1942 0, 0,
1943 buf, 1, WDR_TIMEOUT)) < 0 ) {
1944 err("%s Could not get modem status of device - err: %d", __FUNCTION__,
1945 ret);
1946 return(ret);
1947 }
1948 break;
1949 case FT8U232AM:
1950 case FT232BM:
1951 case FT2232C:
1952 case FT232RL:
1953 /* the 8U232AM returns a two byte value (the sio is a 1 byte value) - in the same
1954 format as the data returned from the in point */
1955 if ((ret = usb_control_msg(port->serial->dev,
1956 usb_rcvctrlpipe(port->serial->dev, 0),
1957 FTDI_SIO_GET_MODEM_STATUS_REQUEST,
1958 FTDI_SIO_GET_MODEM_STATUS_REQUEST_TYPE,
1959 0, priv->interface,
1960 buf, 2, WDR_TIMEOUT)) < 0 ) {
1961 err("%s Could not get modem status of device - err: %d", __FUNCTION__,
1962 ret);
1963 return(ret);
1964 }
1965 break;
1966 default:
1967 return -EFAULT;
1968 break;
1969 }
1970
1971 return (buf[0] & FTDI_SIO_DSR_MASK ? TIOCM_DSR : 0) |
1972 (buf[0] & FTDI_SIO_CTS_MASK ? TIOCM_CTS : 0) |
1973 (buf[0] & FTDI_SIO_RI_MASK ? TIOCM_RI : 0) |
1974 (buf[0] & FTDI_SIO_RLSD_MASK ? TIOCM_CD : 0) |
1975 priv->last_dtr_rts;
1976 }
1977
1978 static int ftdi_tiocmset(struct usb_serial_port *port, struct file * file, unsigned int set, unsigned int clear)
1979 {
1980 dbg("%s TIOCMSET", __FUNCTION__);
1981 return update_mctrl(port, set, clear);
1982 }
1983
1984
1985 static int ftdi_ioctl (struct usb_serial_port *port, struct file * file, unsigned int cmd, unsigned long arg)
1986 {
1987 struct ftdi_private *priv = usb_get_serial_port_data(port);
1988
1989 dbg("%s cmd 0x%04x", __FUNCTION__, cmd);
1990
1991 /* Based on code from acm.c and others */
1992 switch (cmd) {
1993
1994 case TIOCGSERIAL: /* gets serial port data */
1995 return get_serial_info(port, (struct serial_struct __user *) arg);
1996
1997 case TIOCSSERIAL: /* sets serial port data */
1998 return set_serial_info(port, (struct serial_struct __user *) arg);
1999
2000 /*
2001 * Wait for any of the 4 modem inputs (DCD,RI,DSR,CTS) to change
2002 * - mask passed in arg for lines of interest
2003 * (use |'ed TIOCM_RNG/DSR/CD/CTS for masking)
2004 * Caller should use TIOCGICOUNT to see which one it was.
2005 *
2006 * This code is borrowed from linux/drivers/char/serial.c
2007 */
2008 case TIOCMIWAIT:
2009 while (priv != NULL) {
2010 interruptible_sleep_on(&priv->delta_msr_wait);
2011 /* see if a signal did it */
2012 if (signal_pending(current))
2013 return -ERESTARTSYS;
2014 else {
2015 char diff = priv->diff_status;
2016
2017 if (diff == 0) {
2018 return -EIO; /* no change => error */
2019 }
2020
2021 /* Consume all events */
2022 priv->diff_status = 0;
2023
2024 /* Return 0 if caller wanted to know about these bits */
2025 if ( ((arg & TIOCM_RNG) && (diff & FTDI_RS0_RI)) ||
2026 ((arg & TIOCM_DSR) && (diff & FTDI_RS0_DSR)) ||
2027 ((arg & TIOCM_CD) && (diff & FTDI_RS0_RLSD)) ||
2028 ((arg & TIOCM_CTS) && (diff & FTDI_RS0_CTS)) ) {
2029 return 0;
2030 }
2031 /*
2032 * Otherwise caller can't care less about what happened,
2033 * and so we continue to wait for more events.
2034 */
2035 }
2036 }
2037 return(0);
2038 break;
2039 default:
2040 break;
2041
2042 }
2043
2044
2045 /* This is not necessarily an error - turns out the higher layers will do
2046 * some ioctls itself (see comment above)
2047 */
2048 dbg("%s arg not supported - it was 0x%04x - check /usr/include/asm/ioctls.h", __FUNCTION__, cmd);
2049
2050 return(-ENOIOCTLCMD);
2051 } /* ftdi_ioctl */
2052
2053
2054 static void ftdi_throttle (struct usb_serial_port *port)
2055 {
2056 struct ftdi_private *priv = usb_get_serial_port_data(port);
2057 unsigned long flags;
2058
2059 dbg("%s - port %d", __FUNCTION__, port->number);
2060
2061 spin_lock_irqsave(&priv->rx_lock, flags);
2062 priv->rx_flags |= THROTTLED;
2063 spin_unlock_irqrestore(&priv->rx_lock, flags);
2064 }
2065
2066
2067 static void ftdi_unthrottle (struct usb_serial_port *port)
2068 {
2069 struct ftdi_private *priv = usb_get_serial_port_data(port);
2070 int actually_throttled;
2071 unsigned long flags;
2072
2073 dbg("%s - port %d", __FUNCTION__, port->number);
2074
2075 spin_lock_irqsave(&priv->rx_lock, flags);
2076 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
2077 priv->rx_flags &= ~(THROTTLED | ACTUALLY_THROTTLED);
2078 spin_unlock_irqrestore(&priv->rx_lock, flags);
2079
2080 if (actually_throttled)
2081 schedule_delayed_work(&priv->rx_work, 0);
2082 }
2083
2084 static int __init ftdi_init (void)
2085 {
2086 int retval;
2087
2088 dbg("%s", __FUNCTION__);
2089 if (vendor > 0 && product > 0) {
2090 /* Add user specified VID/PID to reserved element of table. */
2091 int i;
2092 for (i = 0; id_table_combined[i].idVendor; i++)
2093 ;
2094 id_table_combined[i].match_flags = USB_DEVICE_ID_MATCH_DEVICE;
2095 id_table_combined[i].idVendor = vendor;
2096 id_table_combined[i].idProduct = product;
2097 }
2098 retval = usb_serial_register(&ftdi_sio_device);
2099 if (retval)
2100 goto failed_sio_register;
2101 retval = usb_register(&ftdi_driver);
2102 if (retval)
2103 goto failed_usb_register;
2104
2105 info(DRIVER_VERSION ":" DRIVER_DESC);
2106 return 0;
2107 failed_usb_register:
2108 usb_serial_deregister(&ftdi_sio_device);
2109 failed_sio_register:
2110 return retval;
2111 }
2112
2113
2114 static void __exit ftdi_exit (void)
2115 {
2116
2117 dbg("%s", __FUNCTION__);
2118
2119 usb_deregister (&ftdi_driver);
2120 usb_serial_deregister (&ftdi_sio_device);
2121
2122 }
2123
2124
2125 module_init(ftdi_init);
2126 module_exit(ftdi_exit);
2127
2128 MODULE_AUTHOR( DRIVER_AUTHOR );
2129 MODULE_DESCRIPTION( DRIVER_DESC );
2130 MODULE_LICENSE("GPL");
2131
2132 module_param(debug, bool, S_IRUGO | S_IWUSR);
2133 MODULE_PARM_DESC(debug, "Debug enabled or not");
2134 module_param(vendor, ushort, 0);
2135 MODULE_PARM_DESC(vendor, "User specified vendor ID (default="
2136 __MODULE_STRING(FTDI_VID)")");
2137 module_param(product, ushort, 0);
2138 MODULE_PARM_DESC(vendor, "User specified product ID");
2139
WRT350N Kernel Patches