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