xref: /linux/drivers/usb/serial/ti_usb_3410_5052.c (revision 3a39d672e7f48b8d6b91a09afa4b55352773b4b5)
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 		.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 		.name		= "ti_usb_3410_5052_2",
453 	},
454 	.description		= "TI USB 5052 2 port adapter",
455 	.id_table		= ti_id_table_5052,
456 	.num_ports		= 2,
457 	.num_bulk_out		= 1,
458 	.attach			= ti_startup,
459 	.release		= ti_release,
460 	.port_probe		= ti_port_probe,
461 	.port_remove		= ti_port_remove,
462 	.open			= ti_open,
463 	.close			= ti_close,
464 	.write			= ti_write,
465 	.write_room		= ti_write_room,
466 	.chars_in_buffer	= ti_chars_in_buffer,
467 	.tx_empty		= ti_tx_empty,
468 	.throttle		= ti_throttle,
469 	.unthrottle		= ti_unthrottle,
470 	.get_serial		= ti_get_serial_info,
471 	.set_termios		= ti_set_termios,
472 	.tiocmget		= ti_tiocmget,
473 	.tiocmset		= ti_tiocmset,
474 	.tiocmiwait		= usb_serial_generic_tiocmiwait,
475 	.get_icount		= usb_serial_generic_get_icount,
476 	.break_ctl		= ti_break,
477 	.read_int_callback	= ti_interrupt_callback,
478 	.read_bulk_callback	= ti_bulk_in_callback,
479 	.write_bulk_callback	= ti_bulk_out_callback,
480 };
481 
482 static struct usb_serial_driver * const serial_drivers[] = {
483 	&ti_1port_device, &ti_2port_device, NULL
484 };
485 
486 MODULE_AUTHOR(TI_DRIVER_AUTHOR);
487 MODULE_DESCRIPTION(TI_DRIVER_DESC);
488 MODULE_LICENSE("GPL");
489 
490 MODULE_FIRMWARE("ti_3410.fw");
491 MODULE_FIRMWARE("ti_5052.fw");
492 MODULE_FIRMWARE("mts_cdma.fw");
493 MODULE_FIRMWARE("mts_gsm.fw");
494 MODULE_FIRMWARE("mts_edge.fw");
495 MODULE_FIRMWARE("mts_mt9234mu.fw");
496 MODULE_FIRMWARE("mts_mt9234zba.fw");
497 MODULE_FIRMWARE("moxa/moxa-1110.fw");
498 MODULE_FIRMWARE("moxa/moxa-1130.fw");
499 MODULE_FIRMWARE("moxa/moxa-1131.fw");
500 MODULE_FIRMWARE("moxa/moxa-1150.fw");
501 MODULE_FIRMWARE("moxa/moxa-1151.fw");
502 
503 MODULE_DEVICE_TABLE(usb, ti_id_table_combined);
504 
505 module_usb_serial_driver(serial_drivers, ti_id_table_combined);
506 
ti_startup(struct usb_serial * serial)507 static int ti_startup(struct usb_serial *serial)
508 {
509 	struct ti_device *tdev;
510 	struct usb_device *dev = serial->dev;
511 	struct usb_host_interface *cur_altsetting;
512 	int num_endpoints;
513 	u16 vid, pid;
514 	int status;
515 
516 	dev_dbg(&dev->dev,
517 		"%s - product 0x%4X, num configurations %d, configuration value %d\n",
518 		__func__, le16_to_cpu(dev->descriptor.idProduct),
519 		dev->descriptor.bNumConfigurations,
520 		dev->actconfig->desc.bConfigurationValue);
521 
522 	tdev = kzalloc(sizeof(struct ti_device), GFP_KERNEL);
523 	if (!tdev)
524 		return -ENOMEM;
525 
526 	mutex_init(&tdev->td_open_close_lock);
527 	tdev->td_serial = serial;
528 	usb_set_serial_data(serial, tdev);
529 
530 	/* determine device type */
531 	if (serial->type == &ti_1port_device)
532 		tdev->td_is_3410 = 1;
533 	dev_dbg(&dev->dev, "%s - device type is %s\n", __func__,
534 		tdev->td_is_3410 ? "3410" : "5052");
535 
536 	vid = le16_to_cpu(dev->descriptor.idVendor);
537 	pid = le16_to_cpu(dev->descriptor.idProduct);
538 	if (vid == MXU1_VENDOR_ID) {
539 		switch (pid) {
540 		case MXU1_1130_PRODUCT_ID:
541 		case MXU1_1131_PRODUCT_ID:
542 			tdev->td_rs485_only = true;
543 			break;
544 		}
545 	}
546 
547 	cur_altsetting = serial->interface->cur_altsetting;
548 	num_endpoints = cur_altsetting->desc.bNumEndpoints;
549 
550 	/* if we have only 1 configuration and 1 endpoint, download firmware */
551 	if (dev->descriptor.bNumConfigurations == 1 && num_endpoints == 1) {
552 		status = ti_download_firmware(tdev);
553 
554 		if (status != 0)
555 			goto free_tdev;
556 
557 		/* 3410 must be reset, 5052 resets itself */
558 		if (tdev->td_is_3410) {
559 			msleep_interruptible(100);
560 			usb_reset_device(dev);
561 		}
562 
563 		status = -ENODEV;
564 		goto free_tdev;
565 	}
566 
567 	/* the second configuration must be set */
568 	if (dev->actconfig->desc.bConfigurationValue == TI_BOOT_CONFIG) {
569 		status = usb_driver_set_configuration(dev, TI_ACTIVE_CONFIG);
570 		status = status ? status : -ENODEV;
571 		goto free_tdev;
572 	}
573 
574 	if (serial->num_bulk_in < serial->num_ports ||
575 			serial->num_bulk_out < serial->num_ports) {
576 		dev_err(&serial->interface->dev, "missing endpoints\n");
577 		status = -ENODEV;
578 		goto free_tdev;
579 	}
580 
581 	return 0;
582 
583 free_tdev:
584 	kfree(tdev);
585 	usb_set_serial_data(serial, NULL);
586 	return status;
587 }
588 
589 
ti_release(struct usb_serial * serial)590 static void ti_release(struct usb_serial *serial)
591 {
592 	struct ti_device *tdev = usb_get_serial_data(serial);
593 
594 	kfree(tdev);
595 }
596 
ti_port_probe(struct usb_serial_port * port)597 static int ti_port_probe(struct usb_serial_port *port)
598 {
599 	struct ti_port *tport;
600 
601 	tport = kzalloc(sizeof(*tport), GFP_KERNEL);
602 	if (!tport)
603 		return -ENOMEM;
604 
605 	spin_lock_init(&tport->tp_lock);
606 	if (port == port->serial->port[0])
607 		tport->tp_uart_base_addr = TI_UART1_BASE_ADDR;
608 	else
609 		tport->tp_uart_base_addr = TI_UART2_BASE_ADDR;
610 	tport->tp_port = port;
611 	tport->tp_tdev = usb_get_serial_data(port->serial);
612 
613 	if (tport->tp_tdev->td_rs485_only)
614 		tport->tp_uart_mode = TI_UART_485_RECEIVER_DISABLED;
615 	else
616 		tport->tp_uart_mode = TI_UART_232;
617 
618 	usb_set_serial_port_data(port, tport);
619 
620 	/*
621 	 * The TUSB5052 LSR does not tell when the transmitter shift register
622 	 * has emptied so add a one-character drain delay.
623 	 */
624 	if (!tport->tp_tdev->td_is_3410)
625 		port->port.drain_delay = 1;
626 
627 	return 0;
628 }
629 
ti_port_remove(struct usb_serial_port * port)630 static void ti_port_remove(struct usb_serial_port *port)
631 {
632 	struct ti_port *tport;
633 
634 	tport = usb_get_serial_port_data(port);
635 	kfree(tport);
636 }
637 
ti_open(struct tty_struct * tty,struct usb_serial_port * port)638 static int ti_open(struct tty_struct *tty, struct usb_serial_port *port)
639 {
640 	struct ti_port *tport = usb_get_serial_port_data(port);
641 	struct ti_device *tdev;
642 	struct usb_device *dev;
643 	struct urb *urb;
644 	int status;
645 	u16 open_settings;
646 
647 	open_settings = (TI_PIPE_MODE_CONTINUOUS |
648 			 TI_PIPE_TIMEOUT_ENABLE |
649 			 (TI_TRANSFER_TIMEOUT << 2));
650 
651 	dev = port->serial->dev;
652 	tdev = tport->tp_tdev;
653 
654 	/* only one open on any port on a device at a time */
655 	if (mutex_lock_interruptible(&tdev->td_open_close_lock))
656 		return -ERESTARTSYS;
657 
658 	tport->tp_msr = 0;
659 	tport->tp_shadow_mcr |= (TI_MCR_RTS | TI_MCR_DTR);
660 
661 	/* start interrupt urb the first time a port is opened on this device */
662 	if (tdev->td_open_port_count == 0) {
663 		dev_dbg(&port->dev, "%s - start interrupt in urb\n", __func__);
664 		urb = tdev->td_serial->port[0]->interrupt_in_urb;
665 		if (!urb) {
666 			dev_err(&port->dev, "%s - no interrupt urb\n", __func__);
667 			status = -EINVAL;
668 			goto release_lock;
669 		}
670 		urb->context = tdev;
671 		status = usb_submit_urb(urb, GFP_KERNEL);
672 		if (status) {
673 			dev_err(&port->dev, "%s - submit interrupt urb failed, %d\n", __func__, status);
674 			goto release_lock;
675 		}
676 	}
677 
678 	if (tty)
679 		ti_set_termios(tty, port, &tty->termios);
680 
681 	status = ti_port_cmd_out(port, TI_OPEN_PORT, open_settings, NULL, 0);
682 	if (status) {
683 		dev_err(&port->dev, "%s - cannot send open command, %d\n",
684 			__func__, status);
685 		goto unlink_int_urb;
686 	}
687 
688 	status = ti_port_cmd_out(port, TI_START_PORT, 0, NULL, 0);
689 	if (status) {
690 		dev_err(&port->dev, "%s - cannot send start command, %d\n",
691 							__func__, status);
692 		goto unlink_int_urb;
693 	}
694 
695 	status = ti_port_cmd_out(port, TI_PURGE_PORT, TI_PURGE_INPUT, NULL, 0);
696 	if (status) {
697 		dev_err(&port->dev, "%s - cannot clear input buffers, %d\n",
698 							__func__, status);
699 		goto unlink_int_urb;
700 	}
701 	status = ti_port_cmd_out(port, TI_PURGE_PORT, TI_PURGE_OUTPUT, NULL, 0);
702 	if (status) {
703 		dev_err(&port->dev, "%s - cannot clear output buffers, %d\n",
704 							__func__, status);
705 		goto unlink_int_urb;
706 	}
707 
708 	/* reset the data toggle on the bulk endpoints to work around bug in
709 	 * host controllers where things get out of sync some times */
710 	usb_clear_halt(dev, port->write_urb->pipe);
711 	usb_clear_halt(dev, port->read_urb->pipe);
712 
713 	if (tty)
714 		ti_set_termios(tty, port, &tty->termios);
715 
716 	status = ti_port_cmd_out(port, TI_OPEN_PORT, open_settings, NULL, 0);
717 	if (status) {
718 		dev_err(&port->dev, "%s - cannot send open command (2), %d\n",
719 							__func__, status);
720 		goto unlink_int_urb;
721 	}
722 
723 	status = ti_port_cmd_out(port, TI_START_PORT, 0, NULL, 0);
724 	if (status) {
725 		dev_err(&port->dev, "%s - cannot send start command (2), %d\n",
726 							__func__, status);
727 		goto unlink_int_urb;
728 	}
729 
730 	/* start read urb */
731 	urb = port->read_urb;
732 	if (!urb) {
733 		dev_err(&port->dev, "%s - no read urb\n", __func__);
734 		status = -EINVAL;
735 		goto unlink_int_urb;
736 	}
737 	tport->tp_read_urb_state = TI_READ_URB_RUNNING;
738 	urb->context = tport;
739 	status = usb_submit_urb(urb, GFP_KERNEL);
740 	if (status) {
741 		dev_err(&port->dev, "%s - submit read urb failed, %d\n",
742 							__func__, status);
743 		goto unlink_int_urb;
744 	}
745 
746 	tport->tp_is_open = 1;
747 	++tdev->td_open_port_count;
748 
749 	goto release_lock;
750 
751 unlink_int_urb:
752 	if (tdev->td_open_port_count == 0)
753 		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
754 release_lock:
755 	mutex_unlock(&tdev->td_open_close_lock);
756 	return status;
757 }
758 
759 
ti_close(struct usb_serial_port * port)760 static void ti_close(struct usb_serial_port *port)
761 {
762 	struct ti_device *tdev;
763 	struct ti_port *tport;
764 	int status;
765 	unsigned long flags;
766 
767 	tdev = usb_get_serial_data(port->serial);
768 	tport = usb_get_serial_port_data(port);
769 
770 	tport->tp_is_open = 0;
771 
772 	usb_kill_urb(port->read_urb);
773 	usb_kill_urb(port->write_urb);
774 	tport->tp_write_urb_in_use = 0;
775 	spin_lock_irqsave(&tport->tp_lock, flags);
776 	kfifo_reset_out(&port->write_fifo);
777 	spin_unlock_irqrestore(&tport->tp_lock, flags);
778 
779 	status = ti_port_cmd_out(port, TI_CLOSE_PORT, 0, NULL, 0);
780 	if (status)
781 		dev_err(&port->dev,
782 			"%s - cannot send close port command, %d\n"
783 							, __func__, status);
784 
785 	mutex_lock(&tdev->td_open_close_lock);
786 	--tdev->td_open_port_count;
787 	if (tdev->td_open_port_count == 0) {
788 		/* last port is closed, shut down interrupt urb */
789 		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
790 	}
791 	mutex_unlock(&tdev->td_open_close_lock);
792 }
793 
794 
ti_write(struct tty_struct * tty,struct usb_serial_port * port,const unsigned char * data,int count)795 static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
796 			const unsigned char *data, int count)
797 {
798 	struct ti_port *tport = usb_get_serial_port_data(port);
799 
800 	if (count == 0) {
801 		return 0;
802 	}
803 
804 	if (!tport->tp_is_open)
805 		return -ENODEV;
806 
807 	count = kfifo_in_locked(&port->write_fifo, data, count,
808 							&tport->tp_lock);
809 	ti_send(tport);
810 
811 	return count;
812 }
813 
814 
ti_write_room(struct tty_struct * tty)815 static unsigned int ti_write_room(struct tty_struct *tty)
816 {
817 	struct usb_serial_port *port = tty->driver_data;
818 	struct ti_port *tport = usb_get_serial_port_data(port);
819 	unsigned int room;
820 	unsigned long flags;
821 
822 	spin_lock_irqsave(&tport->tp_lock, flags);
823 	room = kfifo_avail(&port->write_fifo);
824 	spin_unlock_irqrestore(&tport->tp_lock, flags);
825 
826 	dev_dbg(&port->dev, "%s - returns %u\n", __func__, room);
827 	return room;
828 }
829 
830 
ti_chars_in_buffer(struct tty_struct * tty)831 static unsigned int ti_chars_in_buffer(struct tty_struct *tty)
832 {
833 	struct usb_serial_port *port = tty->driver_data;
834 	struct ti_port *tport = usb_get_serial_port_data(port);
835 	unsigned int chars;
836 	unsigned long flags;
837 
838 	spin_lock_irqsave(&tport->tp_lock, flags);
839 	chars = kfifo_len(&port->write_fifo);
840 	spin_unlock_irqrestore(&tport->tp_lock, flags);
841 
842 	dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
843 	return chars;
844 }
845 
ti_tx_empty(struct usb_serial_port * port)846 static bool ti_tx_empty(struct usb_serial_port *port)
847 {
848 	struct ti_port *tport = usb_get_serial_port_data(port);
849 	u8 lsr, mask;
850 	int ret;
851 
852 	/*
853 	 * TUSB5052 does not have the TEMT bit to tell if the shift register
854 	 * is empty.
855 	 */
856 	if (tport->tp_tdev->td_is_3410)
857 		mask = TI_LSR_TX_EMPTY_BOTH;
858 	else
859 		mask = TI_LSR_TX_EMPTY;
860 
861 	ret = ti_get_lsr(tport, &lsr);
862 	if (!ret && !(lsr & mask))
863 		return false;
864 
865 	return true;
866 }
867 
ti_throttle(struct tty_struct * tty)868 static void ti_throttle(struct tty_struct *tty)
869 {
870 	struct usb_serial_port *port = tty->driver_data;
871 	struct ti_port *tport = usb_get_serial_port_data(port);
872 
873 	if (I_IXOFF(tty) || C_CRTSCTS(tty))
874 		ti_stop_read(tport, tty);
875 
876 }
877 
878 
ti_unthrottle(struct tty_struct * tty)879 static void ti_unthrottle(struct tty_struct *tty)
880 {
881 	struct usb_serial_port *port = tty->driver_data;
882 	struct ti_port *tport = usb_get_serial_port_data(port);
883 	int status;
884 
885 	if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
886 		status = ti_restart_read(tport, tty);
887 		if (status)
888 			dev_err(&port->dev, "%s - cannot restart read, %d\n",
889 							__func__, status);
890 	}
891 }
892 
ti_set_termios(struct tty_struct * tty,struct usb_serial_port * port,const struct ktermios * old_termios)893 static void ti_set_termios(struct tty_struct *tty,
894 			   struct usb_serial_port *port,
895 			   const 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 int 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 		return status;
1087 	}
1088 
1089 	return 0;
1090 }
1091 
ti_get_port_from_code(unsigned char code)1092 static int ti_get_port_from_code(unsigned char code)
1093 {
1094 	return (code >> 6) & 0x01;
1095 }
1096 
ti_get_func_from_code(unsigned char code)1097 static int ti_get_func_from_code(unsigned char code)
1098 {
1099 	return code & 0x0f;
1100 }
1101 
ti_interrupt_callback(struct urb * urb)1102 static void ti_interrupt_callback(struct urb *urb)
1103 {
1104 	struct ti_device *tdev = urb->context;
1105 	struct usb_serial_port *port;
1106 	struct usb_serial *serial = tdev->td_serial;
1107 	struct ti_port *tport;
1108 	struct device *dev = &urb->dev->dev;
1109 	unsigned char *data = urb->transfer_buffer;
1110 	int length = urb->actual_length;
1111 	int port_number;
1112 	int function;
1113 	int status = urb->status;
1114 	int retval;
1115 	u8 msr;
1116 
1117 	switch (status) {
1118 	case 0:
1119 		break;
1120 	case -ECONNRESET:
1121 	case -ENOENT:
1122 	case -ESHUTDOWN:
1123 		dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
1124 		return;
1125 	default:
1126 		dev_err(dev, "%s - nonzero urb status, %d\n", __func__, status);
1127 		goto exit;
1128 	}
1129 
1130 	if (length != 2) {
1131 		dev_dbg(dev, "%s - bad packet size, %d\n", __func__, length);
1132 		goto exit;
1133 	}
1134 
1135 	if (data[0] == TI_CODE_HARDWARE_ERROR) {
1136 		dev_err(dev, "%s - hardware error, %d\n", __func__, data[1]);
1137 		goto exit;
1138 	}
1139 
1140 	port_number = ti_get_port_from_code(data[0]);
1141 	function = ti_get_func_from_code(data[0]);
1142 
1143 	dev_dbg(dev, "%s - port_number %d, function %d, data 0x%02X\n",
1144 		__func__, port_number, function, data[1]);
1145 
1146 	if (port_number >= serial->num_ports) {
1147 		dev_err(dev, "%s - bad port number, %d\n",
1148 						__func__, port_number);
1149 		goto exit;
1150 	}
1151 
1152 	port = serial->port[port_number];
1153 
1154 	tport = usb_get_serial_port_data(port);
1155 	if (!tport)
1156 		goto exit;
1157 
1158 	switch (function) {
1159 	case TI_CODE_DATA_ERROR:
1160 		dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n",
1161 			__func__, port_number, data[1]);
1162 		break;
1163 
1164 	case TI_CODE_MODEM_STATUS:
1165 		msr = data[1];
1166 		dev_dbg(dev, "%s - port %d, msr 0x%02X\n", __func__, port_number, msr);
1167 		ti_handle_new_msr(tport, msr);
1168 		break;
1169 
1170 	default:
1171 		dev_err(dev, "%s - unknown interrupt code, 0x%02X\n",
1172 							__func__, data[1]);
1173 		break;
1174 	}
1175 
1176 exit:
1177 	retval = usb_submit_urb(urb, GFP_ATOMIC);
1178 	if (retval)
1179 		dev_err(dev, "%s - resubmit interrupt urb failed, %d\n",
1180 			__func__, retval);
1181 }
1182 
1183 
ti_bulk_in_callback(struct urb * urb)1184 static void ti_bulk_in_callback(struct urb *urb)
1185 {
1186 	struct ti_port *tport = urb->context;
1187 	struct usb_serial_port *port = tport->tp_port;
1188 	struct device *dev = &urb->dev->dev;
1189 	int status = urb->status;
1190 	unsigned long flags;
1191 	int retval = 0;
1192 
1193 	switch (status) {
1194 	case 0:
1195 		break;
1196 	case -ECONNRESET:
1197 	case -ENOENT:
1198 	case -ESHUTDOWN:
1199 		dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
1200 		return;
1201 	default:
1202 		dev_err(dev, "%s - nonzero urb status, %d\n",
1203 			__func__, status);
1204 	}
1205 
1206 	if (status == -EPIPE)
1207 		goto exit;
1208 
1209 	if (status) {
1210 		dev_err(dev, "%s - stopping read!\n", __func__);
1211 		return;
1212 	}
1213 
1214 	if (urb->actual_length) {
1215 		usb_serial_debug_data(dev, __func__, urb->actual_length,
1216 				      urb->transfer_buffer);
1217 
1218 		if (!tport->tp_is_open)
1219 			dev_dbg(dev, "%s - port closed, dropping data\n",
1220 				__func__);
1221 		else
1222 			ti_recv(port, urb->transfer_buffer, urb->actual_length);
1223 		spin_lock_irqsave(&tport->tp_lock, flags);
1224 		port->icount.rx += urb->actual_length;
1225 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1226 	}
1227 
1228 exit:
1229 	/* continue to read unless stopping */
1230 	spin_lock_irqsave(&tport->tp_lock, flags);
1231 	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1232 		retval = usb_submit_urb(urb, GFP_ATOMIC);
1233 	else if (tport->tp_read_urb_state == TI_READ_URB_STOPPING)
1234 		tport->tp_read_urb_state = TI_READ_URB_STOPPED;
1235 
1236 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1237 	if (retval)
1238 		dev_err(dev, "%s - resubmit read urb failed, %d\n",
1239 			__func__, retval);
1240 }
1241 
1242 
ti_bulk_out_callback(struct urb * urb)1243 static void ti_bulk_out_callback(struct urb *urb)
1244 {
1245 	struct ti_port *tport = urb->context;
1246 	struct usb_serial_port *port = tport->tp_port;
1247 	int status = urb->status;
1248 
1249 	tport->tp_write_urb_in_use = 0;
1250 
1251 	switch (status) {
1252 	case 0:
1253 		break;
1254 	case -ECONNRESET:
1255 	case -ENOENT:
1256 	case -ESHUTDOWN:
1257 		dev_dbg(&port->dev, "%s - urb shutting down, %d\n", __func__, status);
1258 		return;
1259 	default:
1260 		dev_err_console(port, "%s - nonzero urb status, %d\n",
1261 			__func__, status);
1262 	}
1263 
1264 	/* send any buffered data */
1265 	ti_send(tport);
1266 }
1267 
1268 
ti_recv(struct usb_serial_port * port,unsigned char * data,int length)1269 static void ti_recv(struct usb_serial_port *port, unsigned char *data,
1270 		int length)
1271 {
1272 	int cnt;
1273 
1274 	do {
1275 		cnt = tty_insert_flip_string(&port->port, data, length);
1276 		if (cnt < length) {
1277 			dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
1278 						__func__, length - cnt);
1279 			if (cnt == 0)
1280 				break;
1281 		}
1282 		tty_flip_buffer_push(&port->port);
1283 		data += cnt;
1284 		length -= cnt;
1285 	} while (length > 0);
1286 }
1287 
1288 
ti_send(struct ti_port * tport)1289 static void ti_send(struct ti_port *tport)
1290 {
1291 	int count, result;
1292 	struct usb_serial_port *port = tport->tp_port;
1293 	unsigned long flags;
1294 
1295 	spin_lock_irqsave(&tport->tp_lock, flags);
1296 
1297 	if (tport->tp_write_urb_in_use)
1298 		goto unlock;
1299 
1300 	count = kfifo_out(&port->write_fifo,
1301 				port->write_urb->transfer_buffer,
1302 				port->bulk_out_size);
1303 
1304 	if (count == 0)
1305 		goto unlock;
1306 
1307 	tport->tp_write_urb_in_use = 1;
1308 
1309 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1310 
1311 	usb_serial_debug_data(&port->dev, __func__, count,
1312 			      port->write_urb->transfer_buffer);
1313 
1314 	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
1315 			   usb_sndbulkpipe(port->serial->dev,
1316 					    port->bulk_out_endpointAddress),
1317 			   port->write_urb->transfer_buffer, count,
1318 			   ti_bulk_out_callback, tport);
1319 
1320 	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1321 	if (result) {
1322 		dev_err_console(port, "%s - submit write urb failed, %d\n",
1323 							__func__, result);
1324 		tport->tp_write_urb_in_use = 0;
1325 		/* TODO: reschedule ti_send */
1326 	} else {
1327 		spin_lock_irqsave(&tport->tp_lock, flags);
1328 		port->icount.tx += count;
1329 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1330 	}
1331 
1332 	/* more room in the buffer for new writes, wakeup */
1333 	tty_port_tty_wakeup(&port->port);
1334 
1335 	return;
1336 unlock:
1337 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1338 	return;
1339 }
1340 
1341 
ti_set_mcr(struct ti_port * tport,unsigned int mcr)1342 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr)
1343 {
1344 	unsigned long flags;
1345 	int status;
1346 
1347 	status = ti_write_byte(tport->tp_port, tport->tp_tdev,
1348 		tport->tp_uart_base_addr + TI_UART_OFFSET_MCR,
1349 		TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr);
1350 
1351 	spin_lock_irqsave(&tport->tp_lock, flags);
1352 	if (!status)
1353 		tport->tp_shadow_mcr = mcr;
1354 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1355 
1356 	return status;
1357 }
1358 
1359 
ti_get_lsr(struct ti_port * tport,u8 * lsr)1360 static int ti_get_lsr(struct ti_port *tport, u8 *lsr)
1361 {
1362 	int size, status;
1363 	struct usb_serial_port *port = tport->tp_port;
1364 	struct ti_port_status *data;
1365 
1366 	size = sizeof(struct ti_port_status);
1367 	data = kmalloc(size, GFP_KERNEL);
1368 	if (!data)
1369 		return -ENOMEM;
1370 
1371 	status = ti_port_cmd_in(port, TI_GET_PORT_STATUS, 0, data, size);
1372 	if (status) {
1373 		dev_err(&port->dev,
1374 			"%s - get port status command failed, %d\n",
1375 							__func__, status);
1376 		goto free_data;
1377 	}
1378 
1379 	dev_dbg(&port->dev, "%s - lsr 0x%02X\n", __func__, data->bLSR);
1380 
1381 	*lsr = data->bLSR;
1382 
1383 free_data:
1384 	kfree(data);
1385 	return status;
1386 }
1387 
1388 
ti_get_serial_info(struct tty_struct * tty,struct serial_struct * ss)1389 static void ti_get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
1390 {
1391 	struct usb_serial_port *port = tty->driver_data;
1392 	struct ti_port *tport = usb_get_serial_port_data(port);
1393 
1394 	ss->baud_base = tport->tp_tdev->td_is_3410 ? 921600 : 460800;
1395 }
1396 
1397 
ti_handle_new_msr(struct ti_port * tport,u8 msr)1398 static void ti_handle_new_msr(struct ti_port *tport, u8 msr)
1399 {
1400 	struct async_icount *icount;
1401 	struct tty_struct *tty;
1402 	unsigned long flags;
1403 
1404 	dev_dbg(&tport->tp_port->dev, "%s - msr 0x%02X\n", __func__, msr);
1405 
1406 	if (msr & TI_MSR_DELTA_MASK) {
1407 		spin_lock_irqsave(&tport->tp_lock, flags);
1408 		icount = &tport->tp_port->icount;
1409 		if (msr & TI_MSR_DELTA_CTS)
1410 			icount->cts++;
1411 		if (msr & TI_MSR_DELTA_DSR)
1412 			icount->dsr++;
1413 		if (msr & TI_MSR_DELTA_CD)
1414 			icount->dcd++;
1415 		if (msr & TI_MSR_DELTA_RI)
1416 			icount->rng++;
1417 		wake_up_interruptible(&tport->tp_port->port.delta_msr_wait);
1418 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1419 	}
1420 
1421 	tport->tp_msr = msr & TI_MSR_MASK;
1422 
1423 	/* handle CTS flow control */
1424 	tty = tty_port_tty_get(&tport->tp_port->port);
1425 	if (tty && C_CRTSCTS(tty)) {
1426 		if (msr & TI_MSR_CTS)
1427 			tty_wakeup(tty);
1428 	}
1429 	tty_kref_put(tty);
1430 }
1431 
1432 
ti_stop_read(struct ti_port * tport,struct tty_struct * tty)1433 static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty)
1434 {
1435 	unsigned long flags;
1436 
1437 	spin_lock_irqsave(&tport->tp_lock, flags);
1438 
1439 	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1440 		tport->tp_read_urb_state = TI_READ_URB_STOPPING;
1441 
1442 	spin_unlock_irqrestore(&tport->tp_lock, flags);
1443 }
1444 
1445 
ti_restart_read(struct ti_port * tport,struct tty_struct * tty)1446 static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty)
1447 {
1448 	struct urb *urb;
1449 	int status = 0;
1450 	unsigned long flags;
1451 
1452 	spin_lock_irqsave(&tport->tp_lock, flags);
1453 
1454 	if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) {
1455 		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1456 		urb = tport->tp_port->read_urb;
1457 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1458 		urb->context = tport;
1459 		status = usb_submit_urb(urb, GFP_KERNEL);
1460 	} else  {
1461 		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1462 		spin_unlock_irqrestore(&tport->tp_lock, flags);
1463 	}
1464 
1465 	return status;
1466 }
1467 
ti_command_out_sync(struct usb_device * udev,u8 command,u16 moduleid,u16 value,void * data,int size)1468 static int ti_command_out_sync(struct usb_device *udev, u8 command,
1469 		u16 moduleid, u16 value, void *data, int size)
1470 {
1471 	int status;
1472 
1473 	status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), command,
1474 			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
1475 			value, moduleid, data, size, 1000);
1476 	if (status < 0)
1477 		return status;
1478 
1479 	return 0;
1480 }
1481 
ti_command_in_sync(struct usb_device * udev,u8 command,u16 moduleid,u16 value,void * data,int size)1482 static int ti_command_in_sync(struct usb_device *udev, u8 command,
1483 		u16 moduleid, u16 value, void *data, int size)
1484 {
1485 	int status;
1486 
1487 	status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), command,
1488 			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
1489 			value, moduleid, data, size, 1000);
1490 	if (status == size)
1491 		status = 0;
1492 	else if (status >= 0)
1493 		status = -ECOMM;
1494 
1495 	return status;
1496 }
1497 
ti_port_cmd_out(struct usb_serial_port * port,u8 command,u16 value,void * data,int size)1498 static int ti_port_cmd_out(struct usb_serial_port *port, u8 command,
1499 		u16 value, void *data, int size)
1500 {
1501 	return ti_command_out_sync(port->serial->dev, command,
1502 			TI_UART1_PORT + port->port_number,
1503 			value, data, size);
1504 }
1505 
ti_port_cmd_in(struct usb_serial_port * port,u8 command,u16 value,void * data,int size)1506 static int ti_port_cmd_in(struct usb_serial_port *port, u8 command,
1507 		u16 value, void *data, int size)
1508 {
1509 	return ti_command_in_sync(port->serial->dev, command,
1510 			TI_UART1_PORT + port->port_number,
1511 			value, data, size);
1512 }
1513 
ti_write_byte(struct usb_serial_port * port,struct ti_device * tdev,unsigned long addr,u8 mask,u8 byte)1514 static int ti_write_byte(struct usb_serial_port *port,
1515 			 struct ti_device *tdev, unsigned long addr,
1516 			 u8 mask, u8 byte)
1517 {
1518 	int status;
1519 	unsigned int size;
1520 	struct ti_write_data_bytes *data;
1521 
1522 	dev_dbg(&port->dev, "%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X\n", __func__,
1523 		addr, mask, byte);
1524 
1525 	size = sizeof(struct ti_write_data_bytes) + 2;
1526 	data = kmalloc(size, GFP_KERNEL);
1527 	if (!data)
1528 		return -ENOMEM;
1529 
1530 	data->bAddrType = TI_RW_DATA_ADDR_XDATA;
1531 	data->bDataType = TI_RW_DATA_BYTE;
1532 	data->bDataCounter = 1;
1533 	data->wBaseAddrHi = cpu_to_be16(addr>>16);
1534 	data->wBaseAddrLo = cpu_to_be16(addr);
1535 	data->bData[0] = mask;
1536 	data->bData[1] = byte;
1537 
1538 	status = ti_command_out_sync(port->serial->dev, TI_WRITE_DATA,
1539 			TI_RAM_PORT, 0, data, size);
1540 	if (status < 0)
1541 		dev_err(&port->dev, "%s - failed, %d\n", __func__, status);
1542 
1543 	kfree(data);
1544 
1545 	return status;
1546 }
1547 
ti_do_download(struct usb_device * dev,int pipe,u8 * buffer,int size)1548 static int ti_do_download(struct usb_device *dev, int pipe,
1549 						u8 *buffer, int size)
1550 {
1551 	int pos;
1552 	u8 cs = 0;
1553 	int done;
1554 	struct ti_firmware_header *header;
1555 	int status = 0;
1556 	int len;
1557 
1558 	for (pos = sizeof(struct ti_firmware_header); pos < size; pos++)
1559 		cs = (u8)(cs + buffer[pos]);
1560 
1561 	header = (struct ti_firmware_header *)buffer;
1562 	header->wLength = cpu_to_le16(size - sizeof(*header));
1563 	header->bCheckSum = cs;
1564 
1565 	dev_dbg(&dev->dev, "%s - downloading firmware\n", __func__);
1566 	for (pos = 0; pos < size; pos += done) {
1567 		len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
1568 		status = usb_bulk_msg(dev, pipe, buffer + pos, len,
1569 								&done, 1000);
1570 		if (status)
1571 			break;
1572 	}
1573 	return status;
1574 }
1575 
ti_download_firmware(struct ti_device * tdev)1576 static int ti_download_firmware(struct ti_device *tdev)
1577 {
1578 	int status;
1579 	int buffer_size;
1580 	u8 *buffer;
1581 	struct usb_device *dev = tdev->td_serial->dev;
1582 	unsigned int pipe = usb_sndbulkpipe(dev,
1583 		tdev->td_serial->port[0]->bulk_out_endpointAddress);
1584 	const struct firmware *fw_p;
1585 	char buf[32];
1586 
1587 	if (le16_to_cpu(dev->descriptor.idVendor) == MXU1_VENDOR_ID) {
1588 		snprintf(buf,
1589 			sizeof(buf),
1590 			"moxa/moxa-%04x.fw",
1591 			le16_to_cpu(dev->descriptor.idProduct));
1592 
1593 		status = request_firmware(&fw_p, buf, &dev->dev);
1594 		goto check_firmware;
1595 	}
1596 
1597 	/* try ID specific firmware first, then try generic firmware */
1598 	sprintf(buf, "ti_usb-v%04x-p%04x.fw",
1599 			le16_to_cpu(dev->descriptor.idVendor),
1600 			le16_to_cpu(dev->descriptor.idProduct));
1601 	status = request_firmware(&fw_p, buf, &dev->dev);
1602 
1603 	if (status != 0) {
1604 		buf[0] = '\0';
1605 		if (le16_to_cpu(dev->descriptor.idVendor) == MTS_VENDOR_ID) {
1606 			switch (le16_to_cpu(dev->descriptor.idProduct)) {
1607 			case MTS_CDMA_PRODUCT_ID:
1608 				strcpy(buf, "mts_cdma.fw");
1609 				break;
1610 			case MTS_GSM_PRODUCT_ID:
1611 				strcpy(buf, "mts_gsm.fw");
1612 				break;
1613 			case MTS_EDGE_PRODUCT_ID:
1614 				strcpy(buf, "mts_edge.fw");
1615 				break;
1616 			case MTS_MT9234MU_PRODUCT_ID:
1617 				strcpy(buf, "mts_mt9234mu.fw");
1618 				break;
1619 			case MTS_MT9234ZBA_PRODUCT_ID:
1620 				strcpy(buf, "mts_mt9234zba.fw");
1621 				break;
1622 			case MTS_MT9234ZBAOLD_PRODUCT_ID:
1623 				strcpy(buf, "mts_mt9234zba.fw");
1624 				break;			}
1625 		}
1626 		if (buf[0] == '\0') {
1627 			if (tdev->td_is_3410)
1628 				strcpy(buf, "ti_3410.fw");
1629 			else
1630 				strcpy(buf, "ti_5052.fw");
1631 		}
1632 		status = request_firmware(&fw_p, buf, &dev->dev);
1633 	}
1634 
1635 check_firmware:
1636 	if (status) {
1637 		dev_err(&dev->dev, "%s - firmware not found\n", __func__);
1638 		return -ENOENT;
1639 	}
1640 	if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
1641 		dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size);
1642 		release_firmware(fw_p);
1643 		return -ENOENT;
1644 	}
1645 
1646 	buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
1647 	buffer = kmalloc(buffer_size, GFP_KERNEL);
1648 	if (buffer) {
1649 		memcpy(buffer, fw_p->data, fw_p->size);
1650 		memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
1651 		status = ti_do_download(dev, pipe, buffer, fw_p->size);
1652 		kfree(buffer);
1653 	} else {
1654 		status = -ENOMEM;
1655 	}
1656 	release_firmware(fw_p);
1657 	if (status) {
1658 		dev_err(&dev->dev, "%s - error downloading firmware, %d\n",
1659 							__func__, status);
1660 		return status;
1661 	}
1662 
1663 	dev_dbg(&dev->dev, "%s - download successful\n", __func__);
1664 
1665 	return 0;
1666 }
1667