1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3  * TI 3410/5052 USB Serial Driver
4  *
5  * Copyright (C) 2004 Texas Instruments
6  *
7  * This driver is based on the Linux io_ti driver, which is
8  *   Copyright (C) 2000-2002 Inside Out Networks
9  *   Copyright (C) 2001-2002 Greg Kroah-Hartman
10  *
11  * For questions or problems with this driver, contact Texas Instruments
12  * technical support, or Al Borchers <alborchers@steinerpoint.com>, or
13  * Peter Berger <pberger@brimson.com>.
14  */
15 
16 #include <linux/kernel.h>
17 #include <linux/errno.h>
18 #include <linux/firmware.h>
19 #include <linux/slab.h>
20 #include <linux/tty.h>
21 #include <linux/tty_driver.h>
22 #include <linux/tty_flip.h>
23 #include <linux/module.h>
24 #include <linux/spinlock.h>
25 #include <linux/ioctl.h>
26 #include <linux/serial.h>
27 #include <linux/kfifo.h>
28 #include <linux/mutex.h>
29 #include <linux/uaccess.h>
30 #include <linux/usb.h>
31 #include <linux/usb/serial.h>
32 
33 /* Configuration ids */
34 #define TI_BOOT_CONFIG			1
35 #define TI_ACTIVE_CONFIG		2
36 
37 /* Vendor and product ids */
38 #define TI_VENDOR_ID			0x0451
39 #define IBM_VENDOR_ID			0x04b3
40 #define TI_3410_PRODUCT_ID		0x3410
41 #define IBM_4543_PRODUCT_ID		0x4543
42 #define IBM_454B_PRODUCT_ID		0x454b
43 #define IBM_454C_PRODUCT_ID		0x454c
44 #define TI_3410_EZ430_ID		0xF430  /* TI ez430 development tool */
45 #define TI_5052_BOOT_PRODUCT_ID		0x5052	/* no EEPROM, no firmware */
46 #define TI_5152_BOOT_PRODUCT_ID		0x5152	/* no EEPROM, no firmware */
47 #define TI_5052_EEPROM_PRODUCT_ID	0x505A	/* EEPROM, no firmware */
48 #define TI_5052_FIRMWARE_PRODUCT_ID	0x505F	/* firmware is running */
49 #define FRI2_PRODUCT_ID			0x5053  /* Fish River Island II */
50 
51 /* Multi-Tech vendor and product ids */
52 #define MTS_VENDOR_ID			0x06E0
53 #define MTS_GSM_NO_FW_PRODUCT_ID	0xF108
54 #define MTS_CDMA_NO_FW_PRODUCT_ID	0xF109
55 #define MTS_CDMA_PRODUCT_ID		0xF110
56 #define MTS_GSM_PRODUCT_ID		0xF111
57 #define MTS_EDGE_PRODUCT_ID		0xF112
58 #define MTS_MT9234MU_PRODUCT_ID		0xF114
59 #define MTS_MT9234ZBA_PRODUCT_ID	0xF115
60 #define MTS_MT9234ZBAOLD_PRODUCT_ID	0x0319
61 
62 /* Abbott Diabetics vendor and product ids */
63 #define ABBOTT_VENDOR_ID		0x1a61
64 #define ABBOTT_STEREO_PLUG_ID		0x3410
65 #define ABBOTT_PRODUCT_ID		ABBOTT_STEREO_PLUG_ID
66 #define ABBOTT_STRIP_PORT_ID		0x3420
67 
68 /* Honeywell vendor and product IDs */
69 #define HONEYWELL_VENDOR_ID		0x10ac
70 #define HONEYWELL_HGI80_PRODUCT_ID	0x0102  /* Honeywell HGI80 */
71 
72 /* Moxa UPORT 11x0 vendor and product IDs */
73 #define MXU1_VENDOR_ID				0x110a
74 #define MXU1_1110_PRODUCT_ID			0x1110
75 #define MXU1_1130_PRODUCT_ID			0x1130
76 #define MXU1_1150_PRODUCT_ID			0x1150
77 #define MXU1_1151_PRODUCT_ID			0x1151
78 #define MXU1_1131_PRODUCT_ID			0x1131
79 
80 /* Commands */
81 #define TI_GET_VERSION			0x01
82 #define TI_GET_PORT_STATUS		0x02
83 #define TI_GET_PORT_DEV_INFO		0x03
84 #define TI_GET_CONFIG			0x04
85 #define TI_SET_CONFIG			0x05
86 #define TI_OPEN_PORT			0x06
87 #define TI_CLOSE_PORT			0x07
88 #define TI_START_PORT			0x08
89 #define TI_STOP_PORT			0x09
90 #define TI_TEST_PORT			0x0A
91 #define TI_PURGE_PORT			0x0B
92 #define TI_RESET_EXT_DEVICE		0x0C
93 #define TI_WRITE_DATA			0x80
94 #define TI_READ_DATA			0x81
95 #define TI_REQ_TYPE_CLASS		0x82
96 
97 /* Module identifiers */
98 #define TI_I2C_PORT			0x01
99 #define TI_IEEE1284_PORT		0x02
100 #define TI_UART1_PORT			0x03
101 #define TI_UART2_PORT			0x04
102 #define TI_RAM_PORT			0x05
103 
104 /* Modem status */
105 #define TI_MSR_DELTA_CTS		0x01
106 #define TI_MSR_DELTA_DSR		0x02
107 #define TI_MSR_DELTA_RI			0x04
108 #define TI_MSR_DELTA_CD			0x08
109 #define TI_MSR_CTS			0x10
110 #define TI_MSR_DSR			0x20
111 #define TI_MSR_RI			0x40
112 #define TI_MSR_CD			0x80
113 #define TI_MSR_DELTA_MASK		0x0F
114 #define TI_MSR_MASK			0xF0
115 
116 /* Line status */
117 #define TI_LSR_OVERRUN_ERROR		0x01
118 #define TI_LSR_PARITY_ERROR		0x02
119 #define TI_LSR_FRAMING_ERROR		0x04
120 #define TI_LSR_BREAK			0x08
121 #define TI_LSR_ERROR			0x0F
122 #define TI_LSR_RX_FULL			0x10
123 #define TI_LSR_TX_EMPTY			0x20
124 #define TI_LSR_TX_EMPTY_BOTH		0x40
125 
126 /* Line control */
127 #define TI_LCR_BREAK			0x40
128 
129 /* Modem control */
130 #define TI_MCR_LOOP			0x04
131 #define TI_MCR_DTR			0x10
132 #define TI_MCR_RTS			0x20
133 
134 /* Mask settings */
135 #define TI_UART_ENABLE_RTS_IN		0x0001
136 #define TI_UART_DISABLE_RTS		0x0002
137 #define TI_UART_ENABLE_PARITY_CHECKING	0x0008
138 #define TI_UART_ENABLE_DSR_OUT		0x0010
139 #define TI_UART_ENABLE_CTS_OUT		0x0020
140 #define TI_UART_ENABLE_X_OUT		0x0040
141 #define TI_UART_ENABLE_XA_OUT		0x0080
142 #define TI_UART_ENABLE_X_IN		0x0100
143 #define TI_UART_ENABLE_DTR_IN		0x0800
144 #define TI_UART_DISABLE_DTR		0x1000
145 #define TI_UART_ENABLE_MS_INTS		0x2000
146 #define TI_UART_ENABLE_AUTO_START_DMA	0x4000
147 
148 /* Parity */
149 #define TI_UART_NO_PARITY		0x00
150 #define TI_UART_ODD_PARITY		0x01
151 #define TI_UART_EVEN_PARITY		0x02
152 #define TI_UART_MARK_PARITY		0x03
153 #define TI_UART_SPACE_PARITY		0x04
154 
155 /* Stop bits */
156 #define TI_UART_1_STOP_BITS		0x00
157 #define TI_UART_1_5_STOP_BITS		0x01
158 #define TI_UART_2_STOP_BITS		0x02
159 
160 /* Bits per character */
161 #define TI_UART_5_DATA_BITS		0x00
162 #define TI_UART_6_DATA_BITS		0x01
163 #define TI_UART_7_DATA_BITS		0x02
164 #define TI_UART_8_DATA_BITS		0x03
165 
166 /* 232/485 modes */
167 #define TI_UART_232			0x00
168 #define TI_UART_485_RECEIVER_DISABLED	0x01
169 #define TI_UART_485_RECEIVER_ENABLED	0x02
170 
171 /* Pipe transfer mode and timeout */
172 #define TI_PIPE_MODE_CONTINUOUS		0x01
173 #define TI_PIPE_MODE_MASK		0x03
174 #define TI_PIPE_TIMEOUT_MASK		0x7C
175 #define TI_PIPE_TIMEOUT_ENABLE		0x80
176 
177 /* Config struct */
178 struct ti_uart_config {
179 	__be16	wBaudRate;
180 	__be16	wFlags;
181 	u8	bDataBits;
182 	u8	bParity;
183 	u8	bStopBits;
184 	char	cXon;
185 	char	cXoff;
186 	u8	bUartMode;
187 };
188 
189 /* Get port status */
190 struct ti_port_status {
191 	u8 bCmdCode;
192 	u8 bModuleId;
193 	u8 bErrorCode;
194 	u8 bMSR;
195 	u8 bLSR;
196 };
197 
198 /* Purge modes */
199 #define TI_PURGE_OUTPUT			0x00
200 #define TI_PURGE_INPUT			0x80
201 
202 /* Read/Write data */
203 #define TI_RW_DATA_ADDR_SFR		0x10
204 #define TI_RW_DATA_ADDR_IDATA		0x20
205 #define TI_RW_DATA_ADDR_XDATA		0x30
206 #define TI_RW_DATA_ADDR_CODE		0x40
207 #define TI_RW_DATA_ADDR_GPIO		0x50
208 #define TI_RW_DATA_ADDR_I2C		0x60
209 #define TI_RW_DATA_ADDR_FLASH		0x70
210 #define TI_RW_DATA_ADDR_DSP		0x80
211 
212 #define TI_RW_DATA_UNSPECIFIED		0x00
213 #define TI_RW_DATA_BYTE			0x01
214 #define TI_RW_DATA_WORD			0x02
215 #define TI_RW_DATA_DOUBLE_WORD		0x04
216 
217 struct ti_write_data_bytes {
218 	u8	bAddrType;
219 	u8	bDataType;
220 	u8	bDataCounter;
221 	__be16	wBaseAddrHi;
222 	__be16	wBaseAddrLo;
223 	u8	bData[];
224 } __packed;
225 
226 struct ti_read_data_request {
227 	u8	bAddrType;
228 	u8	bDataType;
229 	u8	bDataCounter;
230 	__be16	wBaseAddrHi;
231 	__be16	wBaseAddrLo;
232 } __packed;
233 
234 struct ti_read_data_bytes {
235 	u8	bCmdCode;
236 	u8	bModuleId;
237 	u8	bErrorCode;
238 	u8	bData[];
239 };
240 
241 /* Interrupt struct */
242 struct ti_interrupt {
243 	u8	bICode;
244 	u8	bIInfo;
245 };
246 
247 /* Interrupt codes */
248 #define TI_CODE_HARDWARE_ERROR		0xFF
249 #define TI_CODE_DATA_ERROR		0x03
250 #define TI_CODE_MODEM_STATUS		0x04
251 
252 /* Download firmware max packet size */
253 #define TI_DOWNLOAD_MAX_PACKET_SIZE	64
254 
255 /* Firmware image header */
256 struct ti_firmware_header {
257 	__le16	wLength;
258 	u8	bCheckSum;
259 } __packed;
260 
261 /* UART addresses */
262 #define TI_UART1_BASE_ADDR		0xFFA0	/* UART 1 base address */
263 #define TI_UART2_BASE_ADDR		0xFFB0	/* UART 2 base address */
264 #define TI_UART_OFFSET_LCR		0x0002	/* UART MCR register offset */
265 #define TI_UART_OFFSET_MCR		0x0004	/* UART MCR register offset */
266 
267 #define TI_DRIVER_AUTHOR	"Al Borchers <alborchers@steinerpoint.com>"
268 #define TI_DRIVER_DESC		"TI USB 3410/5052 Serial Driver"
269 
270 #define TI_FIRMWARE_BUF_SIZE	16284
271 
272 #define TI_TRANSFER_TIMEOUT	2
273 
274 /* read urb states */
275 #define TI_READ_URB_RUNNING	0
276 #define TI_READ_URB_STOPPING	1
277 #define TI_READ_URB_STOPPED	2
278 
279 #define TI_EXTRA_VID_PID_COUNT	5
280 
281 struct ti_port {
282 	int			tp_is_open;
283 	u8			tp_msr;
284 	u8			tp_shadow_mcr;
285 	u8			tp_uart_mode;	/* 232 or 485 modes */
286 	unsigned int		tp_uart_base_addr;
287 	struct ti_device	*tp_tdev;
288 	struct usb_serial_port	*tp_port;
289 	spinlock_t		tp_lock;
290 	int			tp_read_urb_state;
291 	int			tp_write_urb_in_use;
292 };
293 
294 struct ti_device {
295 	struct mutex		td_open_close_lock;
296 	int			td_open_port_count;
297 	struct usb_serial	*td_serial;
298 	int			td_is_3410;
299 	bool			td_rs485_only;
300 };
301 
302 static int ti_startup(struct usb_serial *serial);
303 static void ti_release(struct usb_serial *serial);
304 static int ti_port_probe(struct usb_serial_port *port);
305 static void ti_port_remove(struct usb_serial_port *port);
306 static int ti_open(struct tty_struct *tty, struct usb_serial_port *port);
307 static void ti_close(struct usb_serial_port *port);
308 static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
309 		const unsigned char *data, int count);
310 static int ti_write_room(struct tty_struct *tty);
311 static int ti_chars_in_buffer(struct tty_struct *tty);
312 static bool ti_tx_empty(struct usb_serial_port *port);
313 static void ti_throttle(struct tty_struct *tty);
314 static void ti_unthrottle(struct tty_struct *tty);
315 static void ti_set_termios(struct tty_struct *tty,
316 		struct usb_serial_port *port, struct ktermios *old_termios);
317 static int ti_tiocmget(struct tty_struct *tty);
318 static int ti_tiocmset(struct tty_struct *tty,
319 		unsigned int set, unsigned int clear);
320 static void ti_break(struct tty_struct *tty, int break_state);
321 static void ti_interrupt_callback(struct urb *urb);
322 static void ti_bulk_in_callback(struct urb *urb);
323 static void ti_bulk_out_callback(struct urb *urb);
324 
325 static void ti_recv(struct usb_serial_port *port, unsigned char *data,
326 		int length);
327 static void ti_send(struct ti_port *tport);
328 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr);
329 static int ti_get_lsr(struct ti_port *tport, u8 *lsr);
330 static void ti_get_serial_info(struct tty_struct *tty, struct serial_struct *ss);
331 static void ti_handle_new_msr(struct ti_port *tport, u8 msr);
332 
333 static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty);
334 static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty);
335 
336 static int ti_command_out_sync(struct usb_device *udev, u8 command,
337 		u16 moduleid, u16 value, void *data, int size);
338 static int ti_command_in_sync(struct usb_device *udev, u8 command,
339 		u16 moduleid, u16 value, void *data, int size);
340 static int ti_port_cmd_out(struct usb_serial_port *port, u8 command,
341 		u16 value, void *data, int size);
342 static int ti_port_cmd_in(struct usb_serial_port *port, u8 command,
343 		u16 value, void *data, int size);
344 
345 static int ti_write_byte(struct usb_serial_port *port, struct ti_device *tdev,
346 			 unsigned long addr, u8 mask, u8 byte);
347 
348 static int ti_download_firmware(struct ti_device *tdev);
349 
350 static const struct usb_device_id ti_id_table_3410[] = {
351 	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
352 	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
353 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
354 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_NO_FW_PRODUCT_ID) },
355 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_PRODUCT_ID) },
356 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_PRODUCT_ID) },
357 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_EDGE_PRODUCT_ID) },
358 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234MU_PRODUCT_ID) },
359 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBA_PRODUCT_ID) },
360 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBAOLD_PRODUCT_ID) },
361 	{ USB_DEVICE(IBM_VENDOR_ID, IBM_4543_PRODUCT_ID) },
362 	{ USB_DEVICE(IBM_VENDOR_ID, IBM_454B_PRODUCT_ID) },
363 	{ USB_DEVICE(IBM_VENDOR_ID, IBM_454C_PRODUCT_ID) },
364 	{ USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_STEREO_PLUG_ID) },
365 	{ USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_STRIP_PORT_ID) },
366 	{ USB_DEVICE(TI_VENDOR_ID, FRI2_PRODUCT_ID) },
367 	{ USB_DEVICE(HONEYWELL_VENDOR_ID, HONEYWELL_HGI80_PRODUCT_ID) },
368 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1110_PRODUCT_ID) },
369 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1130_PRODUCT_ID) },
370 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1131_PRODUCT_ID) },
371 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1150_PRODUCT_ID) },
372 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1151_PRODUCT_ID) },
373 	{ }	/* terminator */
374 };
375 
376 static const struct usb_device_id ti_id_table_5052[] = {
377 	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
378 	{ USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
379 	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
380 	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
381 	{ }
382 };
383 
384 static const struct usb_device_id ti_id_table_combined[] = {
385 	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_PRODUCT_ID) },
386 	{ USB_DEVICE(TI_VENDOR_ID, TI_3410_EZ430_ID) },
387 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_NO_FW_PRODUCT_ID) },
388 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_NO_FW_PRODUCT_ID) },
389 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_CDMA_PRODUCT_ID) },
390 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_GSM_PRODUCT_ID) },
391 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_EDGE_PRODUCT_ID) },
392 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234MU_PRODUCT_ID) },
393 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBA_PRODUCT_ID) },
394 	{ USB_DEVICE(MTS_VENDOR_ID, MTS_MT9234ZBAOLD_PRODUCT_ID) },
395 	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_BOOT_PRODUCT_ID) },
396 	{ USB_DEVICE(TI_VENDOR_ID, TI_5152_BOOT_PRODUCT_ID) },
397 	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_EEPROM_PRODUCT_ID) },
398 	{ USB_DEVICE(TI_VENDOR_ID, TI_5052_FIRMWARE_PRODUCT_ID) },
399 	{ USB_DEVICE(IBM_VENDOR_ID, IBM_4543_PRODUCT_ID) },
400 	{ USB_DEVICE(IBM_VENDOR_ID, IBM_454B_PRODUCT_ID) },
401 	{ USB_DEVICE(IBM_VENDOR_ID, IBM_454C_PRODUCT_ID) },
402 	{ USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_PRODUCT_ID) },
403 	{ USB_DEVICE(ABBOTT_VENDOR_ID, ABBOTT_STRIP_PORT_ID) },
404 	{ USB_DEVICE(TI_VENDOR_ID, FRI2_PRODUCT_ID) },
405 	{ USB_DEVICE(HONEYWELL_VENDOR_ID, HONEYWELL_HGI80_PRODUCT_ID) },
406 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1110_PRODUCT_ID) },
407 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1130_PRODUCT_ID) },
408 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1131_PRODUCT_ID) },
409 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1150_PRODUCT_ID) },
410 	{ USB_DEVICE(MXU1_VENDOR_ID, MXU1_1151_PRODUCT_ID) },
411 	{ }	/* terminator */
412 };
413 
414 static struct usb_serial_driver ti_1port_device = {
415 	.driver = {
416 		.owner		= THIS_MODULE,
417 		.name		= "ti_usb_3410_5052_1",
418 	},
419 	.description		= "TI USB 3410 1 port adapter",
420 	.id_table		= ti_id_table_3410,
421 	.num_ports		= 1,
422 	.num_bulk_out		= 1,
423 	.attach			= ti_startup,
424 	.release		= ti_release,
425 	.port_probe		= ti_port_probe,
426 	.port_remove		= ti_port_remove,
427 	.open			= ti_open,
428 	.close			= ti_close,
429 	.write			= ti_write,
430 	.write_room		= ti_write_room,
431 	.chars_in_buffer	= ti_chars_in_buffer,
432 	.tx_empty		= ti_tx_empty,
433 	.throttle		= ti_throttle,
434 	.unthrottle		= ti_unthrottle,
435 	.get_serial		= ti_get_serial_info,
436 	.set_termios		= ti_set_termios,
437 	.tiocmget		= ti_tiocmget,
438 	.tiocmset		= ti_tiocmset,
439 	.tiocmiwait		= usb_serial_generic_tiocmiwait,
440 	.get_icount		= usb_serial_generic_get_icount,
441 	.break_ctl		= ti_break,
442 	.read_int_callback	= ti_interrupt_callback,
443 	.read_bulk_callback	= ti_bulk_in_callback,
444 	.write_bulk_callback	= ti_bulk_out_callback,
445 };
446 
447 static struct usb_serial_driver ti_2port_device = {
448 	.driver = {
449 		.owner		= THIS_MODULE,
450 		.name		= "ti_usb_3410_5052_2",
451 	},
452 	.description		= "TI USB 5052 2 port adapter",
453 	.id_table		= ti_id_table_5052,
454 	.num_ports		= 2,
455 	.num_bulk_out		= 1,
456 	.attach			= ti_startup,
457 	.release		= ti_release,
458 	.port_probe		= ti_port_probe,
459 	.port_remove		= ti_port_remove,
460 	.open			= ti_open,
461 	.close			= ti_close,
462 	.write			= ti_write,
463 	.write_room		= ti_write_room,
464 	.chars_in_buffer	= ti_chars_in_buffer,
465 	.tx_empty		= ti_tx_empty,
466 	.throttle		= ti_throttle,
467 	.unthrottle		= ti_unthrottle,
468 	.get_serial		= ti_get_serial_info,
469 	.set_termios		= ti_set_termios,
470 	.tiocmget		= ti_tiocmget,
471 	.tiocmset		= ti_tiocmset,
472 	.tiocmiwait		= usb_serial_generic_tiocmiwait,
473 	.get_icount		= usb_serial_generic_get_icount,
474 	.break_ctl		= ti_break,
475 	.read_int_callback	= ti_interrupt_callback,
476 	.read_bulk_callback	= ti_bulk_in_callback,
477 	.write_bulk_callback	= ti_bulk_out_callback,
478 };
479 
480 static struct usb_serial_driver * const serial_drivers[] = {
481 	&ti_1port_device, &ti_2port_device, NULL
482 };
483 
484 MODULE_AUTHOR(TI_DRIVER_AUTHOR);
485 MODULE_DESCRIPTION(TI_DRIVER_DESC);
486 MODULE_LICENSE("GPL");
487 
488 MODULE_FIRMWARE("ti_3410.fw");
489 MODULE_FIRMWARE("ti_5052.fw");
490 MODULE_FIRMWARE("mts_cdma.fw");
491 MODULE_FIRMWARE("mts_gsm.fw");
492 MODULE_FIRMWARE("mts_edge.fw");
493 MODULE_FIRMWARE("mts_mt9234mu.fw");
494 MODULE_FIRMWARE("mts_mt9234zba.fw");
495 MODULE_FIRMWARE("moxa/moxa-1110.fw");
496 MODULE_FIRMWARE("moxa/moxa-1130.fw");
497 MODULE_FIRMWARE("moxa/moxa-1131.fw");
498 MODULE_FIRMWARE("moxa/moxa-1150.fw");
499 MODULE_FIRMWARE("moxa/moxa-1151.fw");
500 
501 MODULE_DEVICE_TABLE(usb, ti_id_table_combined);
502 
503 module_usb_serial_driver(serial_drivers, ti_id_table_combined);
504 
505 static int ti_startup(struct usb_serial *serial)
506 {
507 	struct ti_device *tdev;
508 	struct usb_device *dev = serial->dev;
509 	struct usb_host_interface *cur_altsetting;
510 	int num_endpoints;
511 	u16 vid, pid;
512 	int status;
513 
514 	dev_dbg(&dev->dev,
515 		"%s - product 0x%4X, num configurations %d, configuration value %d\n",
516 		__func__, le16_to_cpu(dev->descriptor.idProduct),
517 		dev->descriptor.bNumConfigurations,
518 		dev->actconfig->desc.bConfigurationValue);
519 
520 	tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
521 	if (!tdev)
522 		return -ENOMEM;
523 
524 	mutex_init(&tdev->td_open_close_lock);
525 	tdev->td_serial = serial;
526 	usb_set_serial_data(serial, tdev);
527 
528 	/* determine device type */
529 	if (serial->type == &ti_1port_device)
530 		tdev->td_is_3410 = 1;
531 	dev_dbg(&dev->dev, "%s - device type is %s\n", __func__,
532 		tdev->td_is_3410 ? "3410" : "5052");
533 
534 	vid = le16_to_cpu(dev->descriptor.idVendor);
535 	pid = le16_to_cpu(dev->descriptor.idProduct);
536 	if (vid == MXU1_VENDOR_ID) {
537 		switch (pid) {
538 		case MXU1_1130_PRODUCT_ID:
539 		case MXU1_1131_PRODUCT_ID:
540 			tdev->td_rs485_only = true;
541 			break;
542 		}
543 	}
544 
545 	cur_altsetting = serial->interface->cur_altsetting;
546 	num_endpoints = cur_altsetting->desc.bNumEndpoints;
547 
548 	/* if we have only 1 configuration and 1 endpoint, download firmware */
549 	if (dev->descriptor.bNumConfigurations == 1 && num_endpoints == 1) {
550 		status = ti_download_firmware(tdev);
551 
552 		if (status != 0)
553 			goto free_tdev;
554 
555 		/* 3410 must be reset, 5052 resets itself */
556 		if (tdev->td_is_3410) {
557 			msleep_interruptible(100);
558 			usb_reset_device(dev);
559 		}
560 
561 		status = -ENODEV;
562 		goto free_tdev;
563 	}
564 
565 	/* the second configuration must be set */
566 	if (dev->actconfig->desc.bConfigurationValue == TI_BOOT_CONFIG) {
567 		status = usb_driver_set_configuration(dev, TI_ACTIVE_CONFIG);
568 		status = status ? status : -ENODEV;
569 		goto free_tdev;
570 	}
571 
572 	if (serial->num_bulk_in < serial->num_ports ||
573 			serial->num_bulk_out < serial->num_ports) {
574 		dev_err(&serial->interface->dev, "missing endpoints\n");
575 		status = -ENODEV;
576 		goto free_tdev;
577 	}
578 
579 	return 0;
580 
581 free_tdev:
582 	kfree(tdev);
583 	usb_set_serial_data(serial, NULL);
584 	return status;
585 }
586 
587 
588 static void ti_release(struct usb_serial *serial)
589 {
590 	struct ti_device *tdev = usb_get_serial_data(serial);
591 
592 	kfree(tdev);
593 }
594 
595 static int ti_port_probe(struct usb_serial_port *port)
596 {
597 	struct ti_port *tport;
598 
599 	tport = kzalloc(sizeof(*tport), GFP_KERNEL);
600 	if (!tport)
601 		return -ENOMEM;
602 
603 	spin_lock_init(&tport->tp_lock);
604 	if (port == port->serial->port[0])
605 		tport->tp_uart_base_addr = TI_UART1_BASE_ADDR;
606 	else
607 		tport->tp_uart_base_addr = TI_UART2_BASE_ADDR;
608 	tport->tp_port = port;
609 	tport->tp_tdev = usb_get_serial_data(port->serial);
610 
611 	if (tport->tp_tdev->td_rs485_only)
612 		tport->tp_uart_mode = TI_UART_485_RECEIVER_DISABLED;
613 	else
614 		tport->tp_uart_mode = TI_UART_232;
615 
616 	usb_set_serial_port_data(port, tport);
617 
618 	/*
619 	 * The TUSB5052 LSR does not tell when the transmitter shift register
620 	 * has emptied so add a one-character drain delay.
621 	 */
622 	if (!tport->tp_tdev->td_is_3410)
623 		port->port.drain_delay = 1;
624 
625 	return 0;
626 }
627 
628 static void ti_port_remove(struct usb_serial_port *port)
629 {
630 	struct ti_port *tport;
631 
632 	tport = usb_get_serial_port_data(port);
633 	kfree(tport);
634 }
635 
636 static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
637 {
638 	struct ti_port *tport = usb_get_serial_port_data(port);
639 	struct ti_device *tdev;
640 	struct usb_device *dev;
641 	struct urb *urb;
642 	int status;
643 	u16 open_settings;
644 
645 	open_settings = (TI_PIPE_MODE_CONTINUOUS |
646 			 TI_PIPE_TIMEOUT_ENABLE |
647 			 (TI_TRANSFER_TIMEOUT << 2));
648 
649 	dev = port->serial->dev;
650 	tdev = tport->tp_tdev;
651 
652 	/* only one open on any port on a device at a time */
653 	if (mutex_lock_interruptible(&tdev->td_open_close_lock))
654 		return -ERESTARTSYS;
655 
656 	tport->tp_msr = 0;
657 	tport->tp_shadow_mcr |= (TI_MCR_RTS | TI_MCR_DTR);
658 
659 	/* start interrupt urb the first time a port is opened on this device */
660 	if (tdev->td_open_port_count == 0) {
661 		dev_dbg(&port->dev, "%s - start interrupt in urb\n", __func__);
662 		urb = tdev->td_serial->port[0]->interrupt_in_urb;
663 		if (!urb) {
664 			dev_err(&port->dev, "%s - no interrupt urb\n", __func__);
665 			status = -EINVAL;
666 			goto release_lock;
667 		}
668 		urb->context = tdev;
669 		status = usb_submit_urb(urb, GFP_KERNEL);
670 		if (status) {
671 			dev_err(&port->dev, "%s - submit interrupt urb failed, %d\n", __func__, status);
672 			goto release_lock;
673 		}
674 	}
675 
676 	if (tty)
677 		ti_set_termios(tty, port, &tty->termios);
678 
679 	status = ti_port_cmd_out(port, TI_OPEN_PORT, open_settings, NULL, 0);
680 	if (status) {
681 		dev_err(&port->dev, "%s - cannot send open command, %d\n",
682 			__func__, status);
683 		goto unlink_int_urb;
684 	}
685 
686 	status = ti_port_cmd_out(port, TI_START_PORT, 0, NULL, 0);
687 	if (status) {
688 		dev_err(&port->dev, "%s - cannot send start command, %d\n",
689 							__func__, status);
690 		goto unlink_int_urb;
691 	}
692 
693 	status = ti_port_cmd_out(port, TI_PURGE_PORT, TI_PURGE_INPUT, NULL, 0);
694 	if (status) {
695 		dev_err(&port->dev, "%s - cannot clear input buffers, %d\n",
696 							__func__, status);
697 		goto unlink_int_urb;
698 	}
699 	status = ti_port_cmd_out(port, TI_PURGE_PORT, TI_PURGE_OUTPUT, NULL, 0);
700 	if (status) {
701 		dev_err(&port->dev, "%s - cannot clear output buffers, %d\n",
702 							__func__, status);
703 		goto unlink_int_urb;
704 	}
705 
706 	/* reset the data toggle on the bulk endpoints to work around bug in
707 	 * host controllers where things get out of sync some times */
708 	usb_clear_halt(dev, port->write_urb->pipe);
709 	usb_clear_halt(dev, port->read_urb->pipe);
710 
711 	if (tty)
712 		ti_set_termios(tty, port, &tty->termios);
713 
714 	status = ti_port_cmd_out(port, TI_OPEN_PORT, open_settings, NULL, 0);
715 	if (status) {
716 		dev_err(&port->dev, "%s - cannot send open command (2), %d\n",
717 							__func__, status);
718 		goto unlink_int_urb;
719 	}
720 
721 	status = ti_port_cmd_out(port, TI_START_PORT, 0, NULL, 0);
722 	if (status) {
723 		dev_err(&port->dev, "%s - cannot send start command (2), %d\n",
724 							__func__, status);
725 		goto unlink_int_urb;
726 	}
727 
728 	/* start read urb */
729 	urb = port->read_urb;
730 	if (!urb) {
731 		dev_err(&port->dev, "%s - no read urb\n", __func__);
732 		status = -EINVAL;
733 		goto unlink_int_urb;
734 	}
735 	tport->tp_read_urb_state = TI_READ_URB_RUNNING;
736 	urb->context = tport;
737 	status = usb_submit_urb(urb, GFP_KERNEL);
738 	if (status) {
739 		dev_err(&port->dev, "%s - submit read urb failed, %d\n",
740 							__func__, status);
741 		goto unlink_int_urb;
742 	}
743 
744 	tport->tp_is_open = 1;
745 	++tdev->td_open_port_count;
746 
747 	goto release_lock;
748 
749 unlink_int_urb:
750 	if (tdev->td_open_port_count == 0)
751 		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
752 release_lock:
753 	mutex_unlock(&tdev->td_open_close_lock);
754 	return status;
755 }
756 
757 
758 static void ti_close(struct usb_serial_port *port)
759 {
760 	struct ti_device *tdev;
761 	struct ti_port *tport;
762 	int status;
763 	unsigned long flags;
764 
765 	tdev = usb_get_serial_data(port->serial);
766 	tport = usb_get_serial_port_data(port);
767 
768 	tport->tp_is_open = 0;
769 
770 	usb_kill_urb(port->read_urb);
771 	usb_kill_urb(port->write_urb);
772 	tport->tp_write_urb_in_use = 0;
773 	spin_lock_irqsave(&tport->tp_lock, flags);
774 	kfifo_reset_out(&port->write_fifo);
775 	spin_unlock_irqrestore(&tport->tp_lock, flags);
776 
777 	status = ti_port_cmd_out(port, TI_CLOSE_PORT, 0, NULL, 0);
778 	if (status)
779 		dev_err(&port->dev,
780 			"%s - cannot send close port command, %d\n"
781 							, __func__, status);
782 
783 	mutex_lock(&tdev->td_open_close_lock);
784 	--tdev->td_open_port_count;
785 	if (tdev->td_open_port_count == 0) {
786 		/* last port is closed, shut down interrupt urb */
787 		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
788 	}
789 	mutex_unlock(&tdev->td_open_close_lock);
790 }
791 
792 
793 static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
794 			const unsigned char *data, int count)
795 {
796 	struct ti_port *tport = usb_get_serial_port_data(port);
797 
798 	if (count == 0) {
799 		return 0;
800 	}
801 
802 	if (!tport->tp_is_open)
803 		return -ENODEV;
804 
805 	count = kfifo_in_locked(&port->write_fifo, data, count,
806 							&tport->tp_lock);
807 	ti_send(tport);
808 
809 	return count;
810 }
811 
812 
813 static int ti_write_room(struct tty_struct *tty)
814 {
815 	struct usb_serial_port *port = tty->driver_data;
816 	struct ti_port *tport = usb_get_serial_port_data(port);
817 	int room = 0;
818 	unsigned long flags;
819 
820 	spin_lock_irqsave(&tport->tp_lock, flags);
821 	room = kfifo_avail(&port->write_fifo);
822 	spin_unlock_irqrestore(&tport->tp_lock, flags);
823 
824 	dev_dbg(&port->dev, "%s - returns %d\n", __func__, room);
825 	return room;
826 }
827 
828 
829 static int ti_chars_in_buffer(struct tty_struct *tty)
830 {
831 	struct usb_serial_port *port = tty->driver_data;
832 	struct ti_port *tport = usb_get_serial_port_data(port);
833 	int chars = 0;
834 	unsigned long flags;
835 
836 	spin_lock_irqsave(&tport->tp_lock, flags);
837 	chars = kfifo_len(&port->write_fifo);
838 	spin_unlock_irqrestore(&tport->tp_lock, flags);
839 
840 	dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
841 	return chars;
842 }
843 
844 static bool ti_tx_empty(struct usb_serial_port *port)
845 {
846 	struct ti_port *tport = usb_get_serial_port_data(port);
847 	u8 lsr, mask;
848 	int ret;
849 
850 	/*
851 	 * TUSB5052 does not have the TEMT bit to tell if the shift register
852 	 * is empty.
853 	 */
854 	if (tport->tp_tdev->td_is_3410)
855 		mask = TI_LSR_TX_EMPTY_BOTH;
856 	else
857 		mask = TI_LSR_TX_EMPTY;
858 
859 	ret = ti_get_lsr(tport, &lsr);
860 	if (!ret && !(lsr & mask))
861 		return false;
862 
863 	return true;
864 }
865 
866 static void ti_throttle(struct tty_struct *tty)
867 {
868 	struct usb_serial_port *port = tty->driver_data;
869 	struct ti_port *tport = usb_get_serial_port_data(port);
870 
871 	if (I_IXOFF(tty) || C_CRTSCTS(tty))
872 		ti_stop_read(tport, tty);
873 
874 }
875 
876 
877 static void ti_unthrottle(struct tty_struct *tty)
878 {
879 	struct usb_serial_port *port = tty->driver_data;
880 	struct ti_port *tport = usb_get_serial_port_data(port);
881 	int status;
882 
883 	if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
884 		status = ti_restart_read(tport, tty);
885 		if (status)
886 			dev_err(&port->dev, "%s - cannot restart read, %d\n",
887 							__func__, status);
888 	}
889 }
890 
891 static void ti_set_termios(struct tty_struct *tty,
892 		struct usb_serial_port *port, struct ktermios *old_termios)
893 {
894 	struct ti_port *tport = usb_get_serial_port_data(port);
895 	struct ti_uart_config *config;
896 	int baud;
897 	int status;
898 	unsigned int mcr;
899 	u16 wbaudrate;
900 	u16 wflags = 0;
901 
902 	config = kmalloc(sizeof(*config), GFP_KERNEL);
903 	if (!config)
904 		return;
905 
906 	/* these flags must be set */
907 	wflags |= TI_UART_ENABLE_MS_INTS;
908 	wflags |= TI_UART_ENABLE_AUTO_START_DMA;
909 	config->bUartMode = tport->tp_uart_mode;
910 
911 	switch (C_CSIZE(tty)) {
912 	case CS5:
913 		config->bDataBits = TI_UART_5_DATA_BITS;
914 		break;
915 	case CS6:
916 		config->bDataBits = TI_UART_6_DATA_BITS;
917 		break;
918 	case CS7:
919 		config->bDataBits = TI_UART_7_DATA_BITS;
920 		break;
921 	default:
922 	case CS8:
923 		config->bDataBits = TI_UART_8_DATA_BITS;
924 		break;
925 	}
926 
927 	/* CMSPAR isn't supported by this driver */
928 	tty->termios.c_cflag &= ~CMSPAR;
929 
930 	if (C_PARENB(tty)) {
931 		if (C_PARODD(tty)) {
932 			wflags |= TI_UART_ENABLE_PARITY_CHECKING;
933 			config->bParity = TI_UART_ODD_PARITY;
934 		} else {
935 			wflags |= TI_UART_ENABLE_PARITY_CHECKING;
936 			config->bParity = TI_UART_EVEN_PARITY;
937 		}
938 	} else {
939 		wflags &= ~TI_UART_ENABLE_PARITY_CHECKING;
940 		config->bParity = TI_UART_NO_PARITY;
941 	}
942 
943 	if (C_CSTOPB(tty))
944 		config->bStopBits = TI_UART_2_STOP_BITS;
945 	else
946 		config->bStopBits = TI_UART_1_STOP_BITS;
947 
948 	if (C_CRTSCTS(tty)) {
949 		/* RTS flow control must be off to drop RTS for baud rate B0 */
950 		if ((C_BAUD(tty)) != B0)
951 			wflags |= TI_UART_ENABLE_RTS_IN;
952 		wflags |= TI_UART_ENABLE_CTS_OUT;
953 	} else {
954 		ti_restart_read(tport, tty);
955 	}
956 
957 	if (I_IXOFF(tty) || I_IXON(tty)) {
958 		config->cXon  = START_CHAR(tty);
959 		config->cXoff = STOP_CHAR(tty);
960 
961 		if (I_IXOFF(tty))
962 			wflags |= TI_UART_ENABLE_X_IN;
963 		else
964 			ti_restart_read(tport, tty);
965 
966 		if (I_IXON(tty))
967 			wflags |= TI_UART_ENABLE_X_OUT;
968 	}
969 
970 	baud = tty_get_baud_rate(tty);
971 	if (!baud)
972 		baud = 9600;
973 	if (tport->tp_tdev->td_is_3410)
974 		wbaudrate = (923077 + baud/2) / baud;
975 	else
976 		wbaudrate = (461538 + baud/2) / baud;
977 
978 	/* FIXME: Should calculate resulting baud here and report it back */
979 	if ((C_BAUD(tty)) != B0)
980 		tty_encode_baud_rate(tty, baud, baud);
981 
982 	dev_dbg(&port->dev,
983 		"%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d\n",
984 		__func__, baud, wbaudrate, wflags,
985 		config->bDataBits, config->bParity, config->bStopBits,
986 		config->cXon, config->cXoff, config->bUartMode);
987 
988 	config->wBaudRate = cpu_to_be16(wbaudrate);
989 	config->wFlags = cpu_to_be16(wflags);
990 
991 	status = ti_port_cmd_out(port, TI_SET_CONFIG, 0, config,
992 			sizeof(*config));
993 	if (status)
994 		dev_err(&port->dev, "%s - cannot set config on port %d, %d\n",
995 				__func__, port->port_number, status);
996 
997 	/* SET_CONFIG asserts RTS and DTR, reset them correctly */
998 	mcr = tport->tp_shadow_mcr;
999 	/* if baud rate is B0, clear RTS and DTR */
1000 	if (C_BAUD(tty) == B0)
1001 		mcr &= ~(TI_MCR_DTR | TI_MCR_RTS);
1002 	status = ti_set_mcr(tport, mcr);
1003 	if (status)
1004 		dev_err(&port->dev, "%s - cannot set modem control on port %d, %d\n",
1005 				__func__, port->port_number, status);
1006 
1007 	kfree(config);
1008 }
1009 
1010 
1011 static int ti_tiocmget(struct tty_struct *tty)
1012 {
1013 	struct usb_serial_port *port = tty->driver_data;
1014 	struct ti_port *tport = usb_get_serial_port_data(port);
1015 	unsigned int result;
1016 	unsigned int msr;
1017 	unsigned int mcr;
1018 	unsigned long flags;
1019 
1020 	spin_lock_irqsave(&tport->tp_lock, flags);
1021 	msr = tport->tp_msr;
1022 	mcr = tport->tp_shadow_mcr;
1023 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1024 
1025 	result = ((mcr & TI_MCR_DTR) ? TIOCM_DTR : 0)
1026 		| ((mcr & TI_MCR_RTS) ? TIOCM_RTS : 0)
1027 		| ((mcr & TI_MCR_LOOP) ? TIOCM_LOOP : 0)
1028 		| ((msr & TI_MSR_CTS) ? TIOCM_CTS : 0)
1029 		| ((msr & TI_MSR_CD) ? TIOCM_CAR : 0)
1030 		| ((msr & TI_MSR_RI) ? TIOCM_RI : 0)
1031 		| ((msr & TI_MSR_DSR) ? TIOCM_DSR : 0);
1032 
1033 	dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
1034 
1035 	return result;
1036 }
1037 
1038 
1039 static int ti_tiocmset(struct tty_struct *tty,
1040 				unsigned int set, unsigned int clear)
1041 {
1042 	struct usb_serial_port *port = tty->driver_data;
1043 	struct ti_port *tport = usb_get_serial_port_data(port);
1044 	unsigned int mcr;
1045 	unsigned long flags;
1046 
1047 	spin_lock_irqsave(&tport->tp_lock, flags);
1048 	mcr = tport->tp_shadow_mcr;
1049 
1050 	if (set & TIOCM_RTS)
1051 		mcr |= TI_MCR_RTS;
1052 	if (set & TIOCM_DTR)
1053 		mcr |= TI_MCR_DTR;
1054 	if (set & TIOCM_LOOP)
1055 		mcr |= TI_MCR_LOOP;
1056 
1057 	if (clear & TIOCM_RTS)
1058 		mcr &= ~TI_MCR_RTS;
1059 	if (clear & TIOCM_DTR)
1060 		mcr &= ~TI_MCR_DTR;
1061 	if (clear & TIOCM_LOOP)
1062 		mcr &= ~TI_MCR_LOOP;
1063 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1064 
1065 	return ti_set_mcr(tport, mcr);
1066 }
1067 
1068 
1069 static void ti_break(struct tty_struct *tty, int break_state)
1070 {
1071 	struct usb_serial_port *port = tty->driver_data;
1072 	struct ti_port *tport = usb_get_serial_port_data(port);
1073 	int status;
1074 
1075 	dev_dbg(&port->dev, "%s - state = %d\n", __func__, break_state);
1076 
1077 	status = ti_write_byte(port, tport->tp_tdev,
1078 		tport->tp_uart_base_addr + TI_UART_OFFSET_LCR,
1079 		TI_LCR_BREAK, break_state == -1 ? TI_LCR_BREAK : 0);
1080 
1081 	if (status)
1082 		dev_dbg(&port->dev, "%s - error setting break, %d\n", __func__, status);
1083 }
1084 
1085 static int ti_get_port_from_code(unsigned char code)
1086 {
1087 	return (code >> 6) & 0x01;
1088 }
1089 
1090 static int ti_get_func_from_code(unsigned char code)
1091 {
1092 	return code & 0x0f;
1093 }
1094 
1095 static void ti_interrupt_callback(struct urb *urb)
1096 {
1097 	struct ti_device *tdev = urb->context;
1098 	struct usb_serial_port *port;
1099 	struct usb_serial *serial = tdev->td_serial;
1100 	struct ti_port *tport;
1101 	struct device *dev = &urb->dev->dev;
1102 	unsigned char *data = urb->transfer_buffer;
1103 	int length = urb->actual_length;
1104 	int port_number;
1105 	int function;
1106 	int status = urb->status;
1107 	int retval;
1108 	u8 msr;
1109 
1110 	switch (status) {
1111 	case 0:
1112 		break;
1113 	case -ECONNRESET:
1114 	case -ENOENT:
1115 	case -ESHUTDOWN:
1116 		dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
1117 		return;
1118 	default:
1119 		dev_err(dev, "%s - nonzero urb status, %d\n", __func__, status);
1120 		goto exit;
1121 	}
1122 
1123 	if (length != 2) {
1124 		dev_dbg(dev, "%s - bad packet size, %d\n", __func__, length);
1125 		goto exit;
1126 	}
1127 
1128 	if (data[0] == TI_CODE_HARDWARE_ERROR) {
1129 		dev_err(dev, "%s - hardware error, %d\n", __func__, data[1]);
1130 		goto exit;
1131 	}
1132 
1133 	port_number = ti_get_port_from_code(data[0]);
1134 	function = ti_get_func_from_code(data[0]);
1135 
1136 	dev_dbg(dev, "%s - port_number %d, function %d, data 0x%02X\n",
1137 		__func__, port_number, function, data[1]);
1138 
1139 	if (port_number >= serial->num_ports) {
1140 		dev_err(dev, "%s - bad port number, %d\n",
1141 						__func__, port_number);
1142 		goto exit;
1143 	}
1144 
1145 	port = serial->port[port_number];
1146 
1147 	tport = usb_get_serial_port_data(port);
1148 	if (!tport)
1149 		goto exit;
1150 
1151 	switch (function) {
1152 	case TI_CODE_DATA_ERROR:
1153 		dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n",
1154 			__func__, port_number, data[1]);
1155 		break;
1156 
1157 	case TI_CODE_MODEM_STATUS:
1158 		msr = data[1];
1159 		dev_dbg(dev, "%s - port %d, msr 0x%02X\n", __func__, port_number, msr);
1160 		ti_handle_new_msr(tport, msr);
1161 		break;
1162 
1163 	default:
1164 		dev_err(dev, "%s - unknown interrupt code, 0x%02X\n",
1165 							__func__, data[1]);
1166 		break;
1167 	}
1168 
1169 exit:
1170 	retval = usb_submit_urb(urb, GFP_ATOMIC);
1171 	if (retval)
1172 		dev_err(dev, "%s - resubmit interrupt urb failed, %d\n",
1173 			__func__, retval);
1174 }
1175 
1176 
1177 static void ti_bulk_in_callback(struct urb *urb)
1178 {
1179 	struct ti_port *tport = urb->context;
1180 	struct usb_serial_port *port = tport->tp_port;
1181 	struct device *dev = &urb->dev->dev;
1182 	int status = urb->status;
1183 	unsigned long flags;
1184 	int retval = 0;
1185 
1186 	switch (status) {
1187 	case 0:
1188 		break;
1189 	case -ECONNRESET:
1190 	case -ENOENT:
1191 	case -ESHUTDOWN:
1192 		dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
1193 		return;
1194 	default:
1195 		dev_err(dev, "%s - nonzero urb status, %d\n",
1196 			__func__, status);
1197 	}
1198 
1199 	if (status == -EPIPE)
1200 		goto exit;
1201 
1202 	if (status) {
1203 		dev_err(dev, "%s - stopping read!\n", __func__);
1204 		return;
1205 	}
1206 
1207 	if (urb->actual_length) {
1208 		usb_serial_debug_data(dev, __func__, urb->actual_length,
1209 				      urb->transfer_buffer);
1210 
1211 		if (!tport->tp_is_open)
1212 			dev_dbg(dev, "%s - port closed, dropping data\n",
1213 				__func__);
1214 		else
1215 			ti_recv(port, urb->transfer_buffer, urb->actual_length);
1216 		spin_lock_irqsave(&tport->tp_lock, flags);
1217 		port->icount.rx += urb->actual_length;
1218 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1219 	}
1220 
1221 exit:
1222 	/* continue to read unless stopping */
1223 	spin_lock_irqsave(&tport->tp_lock, flags);
1224 	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1225 		retval = usb_submit_urb(urb, GFP_ATOMIC);
1226 	else if (tport->tp_read_urb_state == TI_READ_URB_STOPPING)
1227 		tport->tp_read_urb_state = TI_READ_URB_STOPPED;
1228 
1229 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1230 	if (retval)
1231 		dev_err(dev, "%s - resubmit read urb failed, %d\n",
1232 			__func__, retval);
1233 }
1234 
1235 
1236 static void ti_bulk_out_callback(struct urb *urb)
1237 {
1238 	struct ti_port *tport = urb->context;
1239 	struct usb_serial_port *port = tport->tp_port;
1240 	int status = urb->status;
1241 
1242 	tport->tp_write_urb_in_use = 0;
1243 
1244 	switch (status) {
1245 	case 0:
1246 		break;
1247 	case -ECONNRESET:
1248 	case -ENOENT:
1249 	case -ESHUTDOWN:
1250 		dev_dbg(&port->dev, "%s - urb shutting down, %d\n", __func__, status);
1251 		return;
1252 	default:
1253 		dev_err_console(port, "%s - nonzero urb status, %d\n",
1254 			__func__, status);
1255 	}
1256 
1257 	/* send any buffered data */
1258 	ti_send(tport);
1259 }
1260 
1261 
1262 static void ti_recv(struct usb_serial_port *port, unsigned char *data,
1263 		int length)
1264 {
1265 	int cnt;
1266 
1267 	do {
1268 		cnt = tty_insert_flip_string(&port->port, data, length);
1269 		if (cnt < length) {
1270 			dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
1271 						__func__, length - cnt);
1272 			if (cnt == 0)
1273 				break;
1274 		}
1275 		tty_flip_buffer_push(&port->port);
1276 		data += cnt;
1277 		length -= cnt;
1278 	} while (length > 0);
1279 }
1280 
1281 
1282 static void ti_send(struct ti_port *tport)
1283 {
1284 	int count, result;
1285 	struct usb_serial_port *port = tport->tp_port;
1286 	unsigned long flags;
1287 
1288 	spin_lock_irqsave(&tport->tp_lock, flags);
1289 
1290 	if (tport->tp_write_urb_in_use)
1291 		goto unlock;
1292 
1293 	count = kfifo_out(&port->write_fifo,
1294 				port->write_urb->transfer_buffer,
1295 				port->bulk_out_size);
1296 
1297 	if (count == 0)
1298 		goto unlock;
1299 
1300 	tport->tp_write_urb_in_use = 1;
1301 
1302 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1303 
1304 	usb_serial_debug_data(&port->dev, __func__, count,
1305 			      port->write_urb->transfer_buffer);
1306 
1307 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
1308 			   usb_sndbulkpipe(port->serial->dev,
1309 					    port->bulk_out_endpointAddress),
1310 			   port->write_urb->transfer_buffer, count,
1311 			   ti_bulk_out_callback, tport);
1312 
1313 	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1314 	if (result) {
1315 		dev_err_console(port, "%s - submit write urb failed, %d\n",
1316 							__func__, result);
1317 		tport->tp_write_urb_in_use = 0;
1318 		/* TODO: reschedule ti_send */
1319 	} else {
1320 		spin_lock_irqsave(&tport->tp_lock, flags);
1321 		port->icount.tx += count;
1322 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1323 	}
1324 
1325 	/* more room in the buffer for new writes, wakeup */
1326 	tty_port_tty_wakeup(&port->port);
1327 
1328 	return;
1329 unlock:
1330 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1331 	return;
1332 }
1333 
1334 
1335 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr)
1336 {
1337 	unsigned long flags;
1338 	int status;
1339 
1340 	status = ti_write_byte(tport->tp_port, tport->tp_tdev,
1341 		tport->tp_uart_base_addr + TI_UART_OFFSET_MCR,
1342 		TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr);
1343 
1344 	spin_lock_irqsave(&tport->tp_lock, flags);
1345 	if (!status)
1346 		tport->tp_shadow_mcr = mcr;
1347 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1348 
1349 	return status;
1350 }
1351 
1352 
1353 static int ti_get_lsr(struct ti_port *tport, u8 *lsr)
1354 {
1355 	int size, status;
1356 	struct usb_serial_port *port = tport->tp_port;
1357 	struct ti_port_status *data;
1358 
1359 	size = sizeof(struct ti_port_status);
1360 	data = kmalloc(size, GFP_KERNEL);
1361 	if (!data)
1362 		return -ENOMEM;
1363 
1364 	status = ti_port_cmd_in(port, TI_GET_PORT_STATUS, 0, data, size);
1365 	if (status) {
1366 		dev_err(&port->dev,
1367 			"%s - get port status command failed, %d\n",
1368 							__func__, status);
1369 		goto free_data;
1370 	}
1371 
1372 	dev_dbg(&port->dev, "%s - lsr 0x%02X\n", __func__, data->bLSR);
1373 
1374 	*lsr = data->bLSR;
1375 
1376 free_data:
1377 	kfree(data);
1378 	return status;
1379 }
1380 
1381 
1382 static void ti_get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
1383 {
1384 	struct usb_serial_port *port = tty->driver_data;
1385 	struct ti_port *tport = usb_get_serial_port_data(port);
1386 
1387 	ss->baud_base = tport->tp_tdev->td_is_3410 ? 921600 : 460800;
1388 }
1389 
1390 
1391 static void ti_handle_new_msr(struct ti_port *tport, u8 msr)
1392 {
1393 	struct async_icount *icount;
1394 	struct tty_struct *tty;
1395 	unsigned long flags;
1396 
1397 	dev_dbg(&tport->tp_port->dev, "%s - msr 0x%02X\n", __func__, msr);
1398 
1399 	if (msr & TI_MSR_DELTA_MASK) {
1400 		spin_lock_irqsave(&tport->tp_lock, flags);
1401 		icount = &tport->tp_port->icount;
1402 		if (msr & TI_MSR_DELTA_CTS)
1403 			icount->cts++;
1404 		if (msr & TI_MSR_DELTA_DSR)
1405 			icount->dsr++;
1406 		if (msr & TI_MSR_DELTA_CD)
1407 			icount->dcd++;
1408 		if (msr & TI_MSR_DELTA_RI)
1409 			icount->rng++;
1410 		wake_up_interruptible(&tport->tp_port->port.delta_msr_wait);
1411 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1412 	}
1413 
1414 	tport->tp_msr = msr & TI_MSR_MASK;
1415 
1416 	/* handle CTS flow control */
1417 	tty = tty_port_tty_get(&tport->tp_port->port);
1418 	if (tty && C_CRTSCTS(tty)) {
1419 		if (msr & TI_MSR_CTS)
1420 			tty_wakeup(tty);
1421 	}
1422 	tty_kref_put(tty);
1423 }
1424 
1425 
1426 static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty)
1427 {
1428 	unsigned long flags;
1429 
1430 	spin_lock_irqsave(&tport->tp_lock, flags);
1431 
1432 	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1433 		tport->tp_read_urb_state = TI_READ_URB_STOPPING;
1434 
1435 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1436 }
1437 
1438 
1439 static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty)
1440 {
1441 	struct urb *urb;
1442 	int status = 0;
1443 	unsigned long flags;
1444 
1445 	spin_lock_irqsave(&tport->tp_lock, flags);
1446 
1447 	if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) {
1448 		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1449 		urb = tport->tp_port->read_urb;
1450 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1451 		urb->context = tport;
1452 		status = usb_submit_urb(urb, GFP_KERNEL);
1453 	} else  {
1454 		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1455 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1456 	}
1457 
1458 	return status;
1459 }
1460 
1461 static int ti_command_out_sync(struct usb_device *udev, u8 command,
1462 		u16 moduleid, u16 value, void *data, int size)
1463 {
1464 	int status;
1465 
1466 	status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), command,
1467 			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
1468 			value, moduleid, data, size, 1000);
1469 	if (status < 0)
1470 		return status;
1471 
1472 	return 0;
1473 }
1474 
1475 static int ti_command_in_sync(struct usb_device *udev, u8 command,
1476 		u16 moduleid, u16 value, void *data, int size)
1477 {
1478 	int status;
1479 
1480 	status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), command,
1481 			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
1482 			value, moduleid, data, size, 1000);
1483 	if (status == size)
1484 		status = 0;
1485 	else if (status >= 0)
1486 		status = -ECOMM;
1487 
1488 	return status;
1489 }
1490 
1491 static int ti_port_cmd_out(struct usb_serial_port *port, u8 command,
1492 		u16 value, void *data, int size)
1493 {
1494 	return ti_command_out_sync(port->serial->dev, command,
1495 			TI_UART1_PORT + port->port_number,
1496 			value, data, size);
1497 }
1498 
1499 static int ti_port_cmd_in(struct usb_serial_port *port, u8 command,
1500 		u16 value, void *data, int size)
1501 {
1502 	return ti_command_in_sync(port->serial->dev, command,
1503 			TI_UART1_PORT + port->port_number,
1504 			value, data, size);
1505 }
1506 
1507 static int ti_write_byte(struct usb_serial_port *port,
1508 			 struct ti_device *tdev, unsigned long addr,
1509 			 u8 mask, u8 byte)
1510 {
1511 	int status;
1512 	unsigned int size;
1513 	struct ti_write_data_bytes *data;
1514 
1515 	dev_dbg(&port->dev, "%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X\n", __func__,
1516 		addr, mask, byte);
1517 
1518 	size = sizeof(struct ti_write_data_bytes) + 2;
1519 	data = kmalloc(size, GFP_KERNEL);
1520 	if (!data)
1521 		return -ENOMEM;
1522 
1523 	data->bAddrType = TI_RW_DATA_ADDR_XDATA;
1524 	data->bDataType = TI_RW_DATA_BYTE;
1525 	data->bDataCounter = 1;
1526 	data->wBaseAddrHi = cpu_to_be16(addr>>16);
1527 	data->wBaseAddrLo = cpu_to_be16(addr);
1528 	data->bData[0] = mask;
1529 	data->bData[1] = byte;
1530 
1531 	status = ti_command_out_sync(port->serial->dev, TI_WRITE_DATA,
1532 			TI_RAM_PORT, 0, data, size);
1533 	if (status < 0)
1534 		dev_err(&port->dev, "%s - failed, %d\n", __func__, status);
1535 
1536 	kfree(data);
1537 
1538 	return status;
1539 }
1540 
1541 static int ti_do_download(struct usb_device *dev, int pipe,
1542 						u8 *buffer, int size)
1543 {
1544 	int pos;
1545 	u8 cs = 0;
1546 	int done;
1547 	struct ti_firmware_header *header;
1548 	int status = 0;
1549 	int len;
1550 
1551 	for (pos = sizeof(struct ti_firmware_header); pos < size; pos++)
1552 		cs = (u8)(cs + buffer[pos]);
1553 
1554 	header = (struct ti_firmware_header *)buffer;
1555 	header->wLength = cpu_to_le16(size - sizeof(*header));
1556 	header->bCheckSum = cs;
1557 
1558 	dev_dbg(&dev->dev, "%s - downloading firmware\n", __func__);
1559 	for (pos = 0; pos < size; pos += done) {
1560 		len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
1561 		status = usb_bulk_msg(dev, pipe, buffer + pos, len,
1562 								&done, 1000);
1563 		if (status)
1564 			break;
1565 	}
1566 	return status;
1567 }
1568 
1569 static int ti_download_firmware(struct ti_device *tdev)
1570 {
1571 	int status;
1572 	int buffer_size;
1573 	u8 *buffer;
1574 	struct usb_device *dev = tdev->td_serial->dev;
1575 	unsigned int pipe = usb_sndbulkpipe(dev,
1576 		tdev->td_serial->port[0]->bulk_out_endpointAddress);
1577 	const struct firmware *fw_p;
1578 	char buf[32];
1579 
1580 	if (le16_to_cpu(dev->descriptor.idVendor) == MXU1_VENDOR_ID) {
1581 		snprintf(buf,
1582 			sizeof(buf),
1583 			"moxa/moxa-%04x.fw",
1584 			le16_to_cpu(dev->descriptor.idProduct));
1585 
1586 		status = request_firmware(&fw_p, buf, &dev->dev);
1587 		goto check_firmware;
1588 	}
1589 
1590 	/* try ID specific firmware first, then try generic firmware */
1591 	sprintf(buf, "ti_usb-v%04x-p%04x.fw",
1592 			le16_to_cpu(dev->descriptor.idVendor),
1593 			le16_to_cpu(dev->descriptor.idProduct));
1594 	status = request_firmware(&fw_p, buf, &dev->dev);
1595 
1596 	if (status != 0) {
1597 		buf[0] = '\0';
1598 		if (le16_to_cpu(dev->descriptor.idVendor) == MTS_VENDOR_ID) {
1599 			switch (le16_to_cpu(dev->descriptor.idProduct)) {
1600 			case MTS_CDMA_PRODUCT_ID:
1601 				strcpy(buf, "mts_cdma.fw");
1602 				break;
1603 			case MTS_GSM_PRODUCT_ID:
1604 				strcpy(buf, "mts_gsm.fw");
1605 				break;
1606 			case MTS_EDGE_PRODUCT_ID:
1607 				strcpy(buf, "mts_edge.fw");
1608 				break;
1609 			case MTS_MT9234MU_PRODUCT_ID:
1610 				strcpy(buf, "mts_mt9234mu.fw");
1611 				break;
1612 			case MTS_MT9234ZBA_PRODUCT_ID:
1613 				strcpy(buf, "mts_mt9234zba.fw");
1614 				break;
1615 			case MTS_MT9234ZBAOLD_PRODUCT_ID:
1616 				strcpy(buf, "mts_mt9234zba.fw");
1617 				break;			}
1618 		}
1619 		if (buf[0] == '\0') {
1620 			if (tdev->td_is_3410)
1621 				strcpy(buf, "ti_3410.fw");
1622 			else
1623 				strcpy(buf, "ti_5052.fw");
1624 		}
1625 		status = request_firmware(&fw_p, buf, &dev->dev);
1626 	}
1627 
1628 check_firmware:
1629 	if (status) {
1630 		dev_err(&dev->dev, "%s - firmware not found\n", __func__);
1631 		return -ENOENT;
1632 	}
1633 	if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
1634 		dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size);
1635 		release_firmware(fw_p);
1636 		return -ENOENT;
1637 	}
1638 
1639 	buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
1640 	buffer = kmalloc(buffer_size, GFP_KERNEL);
1641 	if (buffer) {
1642 		memcpy(buffer, fw_p->data, fw_p->size);
1643 		memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
1644 		status = ti_do_download(dev, pipe, buffer, fw_p->size);
1645 		kfree(buffer);
1646 	} else {
1647 		status = -ENOMEM;
1648 	}
1649 	release_firmware(fw_p);
1650 	if (status) {
1651 		dev_err(&dev->dev, "%s - error downloading firmware, %d\n",
1652 							__func__, status);
1653 		return status;
1654 	}
1655 
1656 	dev_dbg(&dev->dev, "%s - download successful\n", __func__);
1657 
1658 	return 0;
1659 }
1660