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