ti_usb_3410_5052.c

   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 */
 179struct 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 */
 191struct 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
 218struct 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
 227struct ti_read_data_request {
 228	u8	bAddrType;
 229	u8	bDataType;
 230	u8	bDataCounter;
 231	__be16	wBaseAddrHi;
 232	__be16	wBaseAddrLo;
 233} __packed;
 234
 235struct ti_read_data_bytes {
 236	u8	bCmdCode;
 237	u8	bModuleId;
 238	u8	bErrorCode;
 239	u8	bData[];
 240};
 241
 242/* Interrupt struct */
 243struct 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 */
 257struct 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
 282struct 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
 295struct 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
 303static int ti_startup(struct usb_serial *serial);
 304static void ti_release(struct usb_serial *serial);
 305static int ti_port_probe(struct usb_serial_port *port);
 306static void ti_port_remove(struct usb_serial_port *port);
 307static int ti_open(struct tty_struct *tty, struct usb_serial_port *port);
 308static void ti_close(struct usb_serial_port *port);
 309static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
 310		const unsigned char *data, int count);
 311static unsigned int ti_write_room(struct tty_struct *tty);
 312static unsigned int ti_chars_in_buffer(struct tty_struct *tty);
 313static bool ti_tx_empty(struct usb_serial_port *port);
 314static void ti_throttle(struct tty_struct *tty);
 315static void ti_unthrottle(struct tty_struct *tty);
 316static void ti_set_termios(struct tty_struct *tty,
 317			   struct usb_serial_port *port,
 318			   const struct ktermios *old_termios);
 319static int ti_tiocmget(struct tty_struct *tty);
 320static int ti_tiocmset(struct tty_struct *tty,
 321		unsigned int set, unsigned int clear);
 322static int ti_break(struct tty_struct *tty, int break_state);
 323static void ti_interrupt_callback(struct urb *urb);
 324static void ti_bulk_in_callback(struct urb *urb);
 325static void ti_bulk_out_callback(struct urb *urb);
 326
 327static void ti_recv(struct usb_serial_port *port, unsigned char *data,
 328		int length);
 329static void ti_send(struct ti_port *tport);
 330static int ti_set_mcr(struct ti_port *tport, unsigned int mcr);
 331static int ti_get_lsr(struct ti_port *tport, u8 *lsr);
 332static void ti_get_serial_info(struct tty_struct *tty, struct serial_struct *ss);
 333static void ti_handle_new_msr(struct ti_port *tport, u8 msr);
 334
 335static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty);
 336static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty);
 337
 338static int ti_command_out_sync(struct usb_device *udev, u8 command,
 339		u16 moduleid, u16 value, void *data, int size);
 340static int ti_command_in_sync(struct usb_device *udev, u8 command,
 341		u16 moduleid, u16 value, void *data, int size);
 342static int ti_port_cmd_out(struct usb_serial_port *port, u8 command,
 343		u16 value, void *data, int size);
 344static int ti_port_cmd_in(struct usb_serial_port *port, u8 command,
 345		u16 value, void *data, int size);
 346
 347static int ti_write_byte(struct usb_serial_port *port, struct ti_device *tdev,
 348			 unsigned long addr, u8 mask, u8 byte);
 349
 350static int ti_download_firmware(struct ti_device *tdev);
 351
 352static 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
 379static 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
 387static 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
 418static 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
 450static 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
 482static struct usb_serial_driver * const serial_drivers[] = {
 483	&ti_1port_device, &ti_2port_device, NULL
 484};
 485
 486MODULE_AUTHOR(TI_DRIVER_AUTHOR);
 487MODULE_DESCRIPTION(TI_DRIVER_DESC);
 488MODULE_LICENSE("GPL");
 489
 490MODULE_FIRMWARE("ti_3410.fw");
 491MODULE_FIRMWARE("ti_5052.fw");
 492MODULE_FIRMWARE("mts_cdma.fw");
 493MODULE_FIRMWARE("mts_gsm.fw");
 494MODULE_FIRMWARE("mts_edge.fw");
 495MODULE_FIRMWARE("mts_mt9234mu.fw");
 496MODULE_FIRMWARE("mts_mt9234zba.fw");
 497MODULE_FIRMWARE("moxa/moxa-1110.fw");
 498MODULE_FIRMWARE("moxa/moxa-1130.fw");
 499MODULE_FIRMWARE("moxa/moxa-1131.fw");
 500MODULE_FIRMWARE("moxa/moxa-1150.fw");
 501MODULE_FIRMWARE("moxa/moxa-1151.fw");
 502
 503MODULE_DEVICE_TABLE(usb, ti_id_table_combined);
 504
 505module_usb_serial_driver(serial_drivers, ti_id_table_combined);
 506
 507static 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
 583free_tdev:
 584	kfree(tdev);
 585	usb_set_serial_data(serial, NULL);
 586	return status;
 587}
 588
 589
 590static void ti_release(struct usb_serial *serial)
 591{
 592	struct ti_device *tdev = usb_get_serial_data(serial);
 593
 594	kfree(tdev);
 595}
 596
 597static 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
 630static 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
 638static 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	tport->tp_read_urb_state = TI_READ_URB_RUNNING;
 733	urb->context = tport;
 734	status = usb_submit_urb(urb, GFP_KERNEL);
 735	if (status) {
 736		dev_err(&port->dev, "%s - submit read urb failed, %d\n",
 737							__func__, status);
 738		goto unlink_int_urb;
 739	}
 740
 741	tport->tp_is_open = 1;
 742	++tdev->td_open_port_count;
 743
 744	goto release_lock;
 745
 746unlink_int_urb:
 747	if (tdev->td_open_port_count == 0)
 748		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
 749release_lock:
 750	mutex_unlock(&tdev->td_open_close_lock);
 751	return status;
 752}
 753
 754
 755static void ti_close(struct usb_serial_port *port)
 756{
 757	struct ti_device *tdev;
 758	struct ti_port *tport;
 759	int status;
 760	unsigned long flags;
 761
 762	tdev = usb_get_serial_data(port->serial);
 763	tport = usb_get_serial_port_data(port);
 764
 765	tport->tp_is_open = 0;
 766
 767	usb_kill_urb(port->read_urb);
 768	usb_kill_urb(port->write_urb);
 769	tport->tp_write_urb_in_use = 0;
 770	spin_lock_irqsave(&tport->tp_lock, flags);
 771	kfifo_reset_out(&port->write_fifo);
 772	spin_unlock_irqrestore(&tport->tp_lock, flags);
 773
 774	status = ti_port_cmd_out(port, TI_CLOSE_PORT, 0, NULL, 0);
 775	if (status)
 776		dev_err(&port->dev,
 777			"%s - cannot send close port command, %d\n"
 778							, __func__, status);
 779
 780	mutex_lock(&tdev->td_open_close_lock);
 781	--tdev->td_open_port_count;
 782	if (tdev->td_open_port_count == 0) {
 783		/* last port is closed, shut down interrupt urb */
 784		usb_kill_urb(port->serial->port[0]->interrupt_in_urb);
 785	}
 786	mutex_unlock(&tdev->td_open_close_lock);
 787}
 788
 789
 790static int ti_write(struct tty_struct *tty, struct usb_serial_port *port,
 791			const unsigned char *data, int count)
 792{
 793	struct ti_port *tport = usb_get_serial_port_data(port);
 794
 795	if (count == 0) {
 796		return 0;
 797	}
 798
 799	if (!tport->tp_is_open)
 800		return -ENODEV;
 801
 802	count = kfifo_in_locked(&port->write_fifo, data, count,
 803							&tport->tp_lock);
 804	ti_send(tport);
 805
 806	return count;
 807}
 808
 809
 810static unsigned int ti_write_room(struct tty_struct *tty)
 811{
 812	struct usb_serial_port *port = tty->driver_data;
 813	struct ti_port *tport = usb_get_serial_port_data(port);
 814	unsigned int room;
 815	unsigned long flags;
 816
 817	spin_lock_irqsave(&tport->tp_lock, flags);
 818	room = kfifo_avail(&port->write_fifo);
 819	spin_unlock_irqrestore(&tport->tp_lock, flags);
 820
 821	dev_dbg(&port->dev, "%s - returns %u\n", __func__, room);
 822	return room;
 823}
 824
 825
 826static unsigned int ti_chars_in_buffer(struct tty_struct *tty)
 827{
 828	struct usb_serial_port *port = tty->driver_data;
 829	struct ti_port *tport = usb_get_serial_port_data(port);
 830	unsigned int chars;
 831	unsigned long flags;
 832
 833	spin_lock_irqsave(&tport->tp_lock, flags);
 834	chars = kfifo_len(&port->write_fifo);
 835	spin_unlock_irqrestore(&tport->tp_lock, flags);
 836
 837	dev_dbg(&port->dev, "%s - returns %u\n", __func__, chars);
 838	return chars;
 839}
 840
 841static bool ti_tx_empty(struct usb_serial_port *port)
 842{
 843	struct ti_port *tport = usb_get_serial_port_data(port);
 844	u8 lsr, mask;
 845	int ret;
 846
 847	/*
 848	 * TUSB5052 does not have the TEMT bit to tell if the shift register
 849	 * is empty.
 850	 */
 851	if (tport->tp_tdev->td_is_3410)
 852		mask = TI_LSR_TX_EMPTY_BOTH;
 853	else
 854		mask = TI_LSR_TX_EMPTY;
 855
 856	ret = ti_get_lsr(tport, &lsr);
 857	if (!ret && !(lsr & mask))
 858		return false;
 859
 860	return true;
 861}
 862
 863static void ti_throttle(struct tty_struct *tty)
 864{
 865	struct usb_serial_port *port = tty->driver_data;
 866	struct ti_port *tport = usb_get_serial_port_data(port);
 867
 868	if (I_IXOFF(tty) || C_CRTSCTS(tty))
 869		ti_stop_read(tport, tty);
 870
 871}
 872
 873
 874static void ti_unthrottle(struct tty_struct *tty)
 875{
 876	struct usb_serial_port *port = tty->driver_data;
 877	struct ti_port *tport = usb_get_serial_port_data(port);
 878	int status;
 879
 880	if (I_IXOFF(tty) || C_CRTSCTS(tty)) {
 881		status = ti_restart_read(tport, tty);
 882		if (status)
 883			dev_err(&port->dev, "%s - cannot restart read, %d\n",
 884							__func__, status);
 885	}
 886}
 887
 888static void ti_set_termios(struct tty_struct *tty,
 889			   struct usb_serial_port *port,
 890			   const struct ktermios *old_termios)
 891{
 892	struct ti_port *tport = usb_get_serial_port_data(port);
 893	struct ti_uart_config *config;
 894	int baud;
 895	int status;
 896	unsigned int mcr;
 897	u16 wbaudrate;
 898	u16 wflags = 0;
 899
 900	config = kmalloc(sizeof(*config), GFP_KERNEL);
 901	if (!config)
 902		return;
 903
 904	/* these flags must be set */
 905	wflags |= TI_UART_ENABLE_MS_INTS;
 906	wflags |= TI_UART_ENABLE_AUTO_START_DMA;
 907	config->bUartMode = tport->tp_uart_mode;
 908
 909	switch (C_CSIZE(tty)) {
 910	case CS5:
 911		config->bDataBits = TI_UART_5_DATA_BITS;
 912		break;
 913	case CS6:
 914		config->bDataBits = TI_UART_6_DATA_BITS;
 915		break;
 916	case CS7:
 917		config->bDataBits = TI_UART_7_DATA_BITS;
 918		break;
 919	default:
 920	case CS8:
 921		config->bDataBits = TI_UART_8_DATA_BITS;
 922		break;
 923	}
 924
 925	/* CMSPAR isn't supported by this driver */
 926	tty->termios.c_cflag &= ~CMSPAR;
 927
 928	if (C_PARENB(tty)) {
 929		if (C_PARODD(tty)) {
 930			wflags |= TI_UART_ENABLE_PARITY_CHECKING;
 931			config->bParity = TI_UART_ODD_PARITY;
 932		} else {
 933			wflags |= TI_UART_ENABLE_PARITY_CHECKING;
 934			config->bParity = TI_UART_EVEN_PARITY;
 935		}
 936	} else {
 937		wflags &= ~TI_UART_ENABLE_PARITY_CHECKING;
 938		config->bParity = TI_UART_NO_PARITY;
 939	}
 940
 941	if (C_CSTOPB(tty))
 942		config->bStopBits = TI_UART_2_STOP_BITS;
 943	else
 944		config->bStopBits = TI_UART_1_STOP_BITS;
 945
 946	if (C_CRTSCTS(tty)) {
 947		/* RTS flow control must be off to drop RTS for baud rate B0 */
 948		if ((C_BAUD(tty)) != B0)
 949			wflags |= TI_UART_ENABLE_RTS_IN;
 950		wflags |= TI_UART_ENABLE_CTS_OUT;
 951	} else {
 952		ti_restart_read(tport, tty);
 953	}
 954
 955	if (I_IXOFF(tty) || I_IXON(tty)) {
 956		config->cXon  = START_CHAR(tty);
 957		config->cXoff = STOP_CHAR(tty);
 958
 959		if (I_IXOFF(tty))
 960			wflags |= TI_UART_ENABLE_X_IN;
 961		else
 962			ti_restart_read(tport, tty);
 963
 964		if (I_IXON(tty))
 965			wflags |= TI_UART_ENABLE_X_OUT;
 966	}
 967
 968	baud = tty_get_baud_rate(tty);
 969	if (!baud)
 970		baud = 9600;
 971	if (tport->tp_tdev->td_is_3410)
 972		wbaudrate = (923077 + baud/2) / baud;
 973	else
 974		wbaudrate = (461538 + baud/2) / baud;
 975
 976	/* FIXME: Should calculate resulting baud here and report it back */
 977	if ((C_BAUD(tty)) != B0)
 978		tty_encode_baud_rate(tty, baud, baud);
 979
 980	dev_dbg(&port->dev,
 981		"%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d\n",
 982		__func__, baud, wbaudrate, wflags,
 983		config->bDataBits, config->bParity, config->bStopBits,
 984		config->cXon, config->cXoff, config->bUartMode);
 985
 986	config->wBaudRate = cpu_to_be16(wbaudrate);
 987	config->wFlags = cpu_to_be16(wflags);
 988
 989	status = ti_port_cmd_out(port, TI_SET_CONFIG, 0, config,
 990			sizeof(*config));
 991	if (status)
 992		dev_err(&port->dev, "%s - cannot set config on port %d, %d\n",
 993				__func__, port->port_number, status);
 994
 995	/* SET_CONFIG asserts RTS and DTR, reset them correctly */
 996	mcr = tport->tp_shadow_mcr;
 997	/* if baud rate is B0, clear RTS and DTR */
 998	if (C_BAUD(tty) == B0)
 999		mcr &= ~(TI_MCR_DTR | TI_MCR_RTS);
1000	status = ti_set_mcr(tport, mcr);
1001	if (status)
1002		dev_err(&port->dev, "%s - cannot set modem control on port %d, %d\n",
1003				__func__, port->port_number, status);
1004
1005	kfree(config);
1006}
1007
1008
1009static int ti_tiocmget(struct tty_struct *tty)
1010{
1011	struct usb_serial_port *port = tty->driver_data;
1012	struct ti_port *tport = usb_get_serial_port_data(port);
1013	unsigned int result;
1014	unsigned int msr;
1015	unsigned int mcr;
1016	unsigned long flags;
1017
1018	spin_lock_irqsave(&tport->tp_lock, flags);
1019	msr = tport->tp_msr;
1020	mcr = tport->tp_shadow_mcr;
1021	spin_unlock_irqrestore(&tport->tp_lock, flags);
1022
1023	result = ((mcr & TI_MCR_DTR) ? TIOCM_DTR : 0)
1024		| ((mcr & TI_MCR_RTS) ? TIOCM_RTS : 0)
1025		| ((mcr & TI_MCR_LOOP) ? TIOCM_LOOP : 0)
1026		| ((msr & TI_MSR_CTS) ? TIOCM_CTS : 0)
1027		| ((msr & TI_MSR_CD) ? TIOCM_CAR : 0)
1028		| ((msr & TI_MSR_RI) ? TIOCM_RI : 0)
1029		| ((msr & TI_MSR_DSR) ? TIOCM_DSR : 0);
1030
1031	dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result);
1032
1033	return result;
1034}
1035
1036
1037static int ti_tiocmset(struct tty_struct *tty,
1038				unsigned int set, unsigned int clear)
1039{
1040	struct usb_serial_port *port = tty->driver_data;
1041	struct ti_port *tport = usb_get_serial_port_data(port);
1042	unsigned int mcr;
1043	unsigned long flags;
1044
1045	spin_lock_irqsave(&tport->tp_lock, flags);
1046	mcr = tport->tp_shadow_mcr;
1047
1048	if (set & TIOCM_RTS)
1049		mcr |= TI_MCR_RTS;
1050	if (set & TIOCM_DTR)
1051		mcr |= TI_MCR_DTR;
1052	if (set & TIOCM_LOOP)
1053		mcr |= TI_MCR_LOOP;
1054
1055	if (clear & TIOCM_RTS)
1056		mcr &= ~TI_MCR_RTS;
1057	if (clear & TIOCM_DTR)
1058		mcr &= ~TI_MCR_DTR;
1059	if (clear & TIOCM_LOOP)
1060		mcr &= ~TI_MCR_LOOP;
1061	spin_unlock_irqrestore(&tport->tp_lock, flags);
1062
1063	return ti_set_mcr(tport, mcr);
1064}
1065
1066
1067static int ti_break(struct tty_struct *tty, int break_state)
1068{
1069	struct usb_serial_port *port = tty->driver_data;
1070	struct ti_port *tport = usb_get_serial_port_data(port);
1071	int status;
1072
1073	dev_dbg(&port->dev, "%s - state = %d\n", __func__, break_state);
1074
1075	status = ti_write_byte(port, tport->tp_tdev,
1076		tport->tp_uart_base_addr + TI_UART_OFFSET_LCR,
1077		TI_LCR_BREAK, break_state == -1 ? TI_LCR_BREAK : 0);
1078
1079	if (status) {
1080		dev_dbg(&port->dev, "%s - error setting break, %d\n", __func__, status);
1081		return status;
1082	}
1083
1084	return 0;
1085}
1086
1087static int ti_get_port_from_code(unsigned char code)
1088{
1089	return (code >> 6) & 0x01;
1090}
1091
1092static int ti_get_func_from_code(unsigned char code)
1093{
1094	return code & 0x0f;
1095}
1096
1097static void ti_interrupt_callback(struct urb *urb)
1098{
1099	struct ti_device *tdev = urb->context;
1100	struct usb_serial_port *port;
1101	struct usb_serial *serial = tdev->td_serial;
1102	struct ti_port *tport;
1103	struct device *dev = &urb->dev->dev;
1104	unsigned char *data = urb->transfer_buffer;
1105	int length = urb->actual_length;
1106	int port_number;
1107	int function;
1108	int status = urb->status;
1109	int retval;
1110	u8 msr;
1111
1112	switch (status) {
1113	case 0:
1114		break;
1115	case -ECONNRESET:
1116	case -ENOENT:
1117	case -ESHUTDOWN:
1118		dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
1119		return;
1120	default:
1121		dev_err(dev, "%s - nonzero urb status, %d\n", __func__, status);
1122		goto exit;
1123	}
1124
1125	if (length != 2) {
1126		dev_dbg(dev, "%s - bad packet size, %d\n", __func__, length);
1127		goto exit;
1128	}
1129
1130	if (data[0] == TI_CODE_HARDWARE_ERROR) {
1131		dev_err(dev, "%s - hardware error, %d\n", __func__, data[1]);
1132		goto exit;
1133	}
1134
1135	port_number = ti_get_port_from_code(data[0]);
1136	function = ti_get_func_from_code(data[0]);
1137
1138	dev_dbg(dev, "%s - port_number %d, function %d, data 0x%02X\n",
1139		__func__, port_number, function, data[1]);
1140
1141	if (port_number >= serial->num_ports) {
1142		dev_err(dev, "%s - bad port number, %d\n",
1143						__func__, port_number);
1144		goto exit;
1145	}
1146
1147	port = serial->port[port_number];
1148
1149	tport = usb_get_serial_port_data(port);
1150	if (!tport)
1151		goto exit;
1152
1153	switch (function) {
1154	case TI_CODE_DATA_ERROR:
1155		dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n",
1156			__func__, port_number, data[1]);
1157		break;
1158
1159	case TI_CODE_MODEM_STATUS:
1160		msr = data[1];
1161		dev_dbg(dev, "%s - port %d, msr 0x%02X\n", __func__, port_number, msr);
1162		ti_handle_new_msr(tport, msr);
1163		break;
1164
1165	default:
1166		dev_err(dev, "%s - unknown interrupt code, 0x%02X\n",
1167							__func__, data[1]);
1168		break;
1169	}
1170
1171exit:
1172	retval = usb_submit_urb(urb, GFP_ATOMIC);
1173	if (retval)
1174		dev_err(dev, "%s - resubmit interrupt urb failed, %d\n",
1175			__func__, retval);
1176}
1177
1178
1179static void ti_bulk_in_callback(struct urb *urb)
1180{
1181	struct ti_port *tport = urb->context;
1182	struct usb_serial_port *port = tport->tp_port;
1183	struct device *dev = &urb->dev->dev;
1184	int status = urb->status;
1185	unsigned long flags;
1186	int retval = 0;
1187
1188	switch (status) {
1189	case 0:
1190		break;
1191	case -ECONNRESET:
1192	case -ENOENT:
1193	case -ESHUTDOWN:
1194		dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status);
1195		return;
1196	default:
1197		dev_err(dev, "%s - nonzero urb status, %d\n",
1198			__func__, status);
1199	}
1200
1201	if (status == -EPIPE)
1202		goto exit;
1203
1204	if (status) {
1205		dev_err(dev, "%s - stopping read!\n", __func__);
1206		return;
1207	}
1208
1209	if (urb->actual_length) {
1210		usb_serial_debug_data(dev, __func__, urb->actual_length,
1211				      urb->transfer_buffer);
1212
1213		if (!tport->tp_is_open)
1214			dev_dbg(dev, "%s - port closed, dropping data\n",
1215				__func__);
1216		else
1217			ti_recv(port, urb->transfer_buffer, urb->actual_length);
1218		spin_lock_irqsave(&tport->tp_lock, flags);
1219		port->icount.rx += urb->actual_length;
1220		spin_unlock_irqrestore(&tport->tp_lock, flags);
1221	}
1222
1223exit:
1224	/* continue to read unless stopping */
1225	spin_lock_irqsave(&tport->tp_lock, flags);
1226	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1227		retval = usb_submit_urb(urb, GFP_ATOMIC);
1228	else if (tport->tp_read_urb_state == TI_READ_URB_STOPPING)
1229		tport->tp_read_urb_state = TI_READ_URB_STOPPED;
1230
1231	spin_unlock_irqrestore(&tport->tp_lock, flags);
1232	if (retval)
1233		dev_err(dev, "%s - resubmit read urb failed, %d\n",
1234			__func__, retval);
1235}
1236
1237
1238static void ti_bulk_out_callback(struct urb *urb)
1239{
1240	struct ti_port *tport = urb->context;
1241	struct usb_serial_port *port = tport->tp_port;
1242	int status = urb->status;
1243
1244	tport->tp_write_urb_in_use = 0;
1245
1246	switch (status) {
1247	case 0:
1248		break;
1249	case -ECONNRESET:
1250	case -ENOENT:
1251	case -ESHUTDOWN:
1252		dev_dbg(&port->dev, "%s - urb shutting down, %d\n", __func__, status);
1253		return;
1254	default:
1255		dev_err_console(port, "%s - nonzero urb status, %d\n",
1256			__func__, status);
1257	}
1258
1259	/* send any buffered data */
1260	ti_send(tport);
1261}
1262
1263
1264static void ti_recv(struct usb_serial_port *port, unsigned char *data,
1265		int length)
1266{
1267	int cnt;
1268
1269	do {
1270		cnt = tty_insert_flip_string(&port->port, data, length);
1271		if (cnt < length) {
1272			dev_err(&port->dev, "%s - dropping data, %d bytes lost\n",
1273						__func__, length - cnt);
1274			if (cnt == 0)
1275				break;
1276		}
1277		tty_flip_buffer_push(&port->port);
1278		data += cnt;
1279		length -= cnt;
1280	} while (length > 0);
1281}
1282
1283
1284static void ti_send(struct ti_port *tport)
1285{
1286	int count, result;
1287	struct usb_serial_port *port = tport->tp_port;
1288	unsigned long flags;
1289
1290	spin_lock_irqsave(&tport->tp_lock, flags);
1291
1292	if (tport->tp_write_urb_in_use)
1293		goto unlock;
1294
1295	count = kfifo_out(&port->write_fifo,
1296				port->write_urb->transfer_buffer,
1297				port->bulk_out_size);
1298
1299	if (count == 0)
1300		goto unlock;
1301
1302	tport->tp_write_urb_in_use = 1;
1303
1304	spin_unlock_irqrestore(&tport->tp_lock, flags);
1305
1306	usb_serial_debug_data(&port->dev, __func__, count,
1307			      port->write_urb->transfer_buffer);
1308
1309	usb_fill_bulk_urb(port->write_urb, port->serial->dev,
1310			   usb_sndbulkpipe(port->serial->dev,
1311					    port->bulk_out_endpointAddress),
1312			   port->write_urb->transfer_buffer, count,
1313			   ti_bulk_out_callback, tport);
1314
1315	result = usb_submit_urb(port->write_urb, GFP_ATOMIC);
1316	if (result) {
1317		dev_err_console(port, "%s - submit write urb failed, %d\n",
1318							__func__, result);
1319		tport->tp_write_urb_in_use = 0;
1320		/* TODO: reschedule ti_send */
1321	} else {
1322		spin_lock_irqsave(&tport->tp_lock, flags);
1323		port->icount.tx += count;
1324		spin_unlock_irqrestore(&tport->tp_lock, flags);
1325	}
1326
1327	/* more room in the buffer for new writes, wakeup */
1328	tty_port_tty_wakeup(&port->port);
1329
1330	return;
1331unlock:
1332	spin_unlock_irqrestore(&tport->tp_lock, flags);
1333	return;
1334}
1335
1336
1337static int ti_set_mcr(struct ti_port *tport, unsigned int mcr)
1338{
1339	unsigned long flags;
1340	int status;
1341
1342	status = ti_write_byte(tport->tp_port, tport->tp_tdev,
1343		tport->tp_uart_base_addr + TI_UART_OFFSET_MCR,
1344		TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr);
1345
1346	spin_lock_irqsave(&tport->tp_lock, flags);
1347	if (!status)
1348		tport->tp_shadow_mcr = mcr;
1349	spin_unlock_irqrestore(&tport->tp_lock, flags);
1350
1351	return status;
1352}
1353
1354
1355static int ti_get_lsr(struct ti_port *tport, u8 *lsr)
1356{
1357	int size, status;
1358	struct usb_serial_port *port = tport->tp_port;
1359	struct ti_port_status *data;
1360
1361	size = sizeof(struct ti_port_status);
1362	data = kmalloc(size, GFP_KERNEL);
1363	if (!data)
1364		return -ENOMEM;
1365
1366	status = ti_port_cmd_in(port, TI_GET_PORT_STATUS, 0, data, size);
1367	if (status) {
1368		dev_err(&port->dev,
1369			"%s - get port status command failed, %d\n",
1370							__func__, status);
1371		goto free_data;
1372	}
1373
1374	dev_dbg(&port->dev, "%s - lsr 0x%02X\n", __func__, data->bLSR);
1375
1376	*lsr = data->bLSR;
1377
1378free_data:
1379	kfree(data);
1380	return status;
1381}
1382
1383
1384static void ti_get_serial_info(struct tty_struct *tty, struct serial_struct *ss)
1385{
1386	struct usb_serial_port *port = tty->driver_data;
1387	struct ti_port *tport = usb_get_serial_port_data(port);
1388
1389	ss->baud_base = tport->tp_tdev->td_is_3410 ? 921600 : 460800;
1390}
1391
1392
1393static void ti_handle_new_msr(struct ti_port *tport, u8 msr)
1394{
1395	struct async_icount *icount;
1396	struct tty_struct *tty;
1397	unsigned long flags;
1398
1399	dev_dbg(&tport->tp_port->dev, "%s - msr 0x%02X\n", __func__, msr);
1400
1401	if (msr & TI_MSR_DELTA_MASK) {
1402		spin_lock_irqsave(&tport->tp_lock, flags);
1403		icount = &tport->tp_port->icount;
1404		if (msr & TI_MSR_DELTA_CTS)
1405			icount->cts++;
1406		if (msr & TI_MSR_DELTA_DSR)
1407			icount->dsr++;
1408		if (msr & TI_MSR_DELTA_CD)
1409			icount->dcd++;
1410		if (msr & TI_MSR_DELTA_RI)
1411			icount->rng++;
1412		wake_up_interruptible(&tport->tp_port->port.delta_msr_wait);
1413		spin_unlock_irqrestore(&tport->tp_lock, flags);
1414	}
1415
1416	tport->tp_msr = msr & TI_MSR_MASK;
1417
1418	/* handle CTS flow control */
1419	tty = tty_port_tty_get(&tport->tp_port->port);
1420	if (tty && C_CRTSCTS(tty)) {
1421		if (msr & TI_MSR_CTS)
1422			tty_wakeup(tty);
1423	}
1424	tty_kref_put(tty);
1425}
1426
1427
1428static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty)
1429{
1430	unsigned long flags;
1431
1432	spin_lock_irqsave(&tport->tp_lock, flags);
1433
1434	if (tport->tp_read_urb_state == TI_READ_URB_RUNNING)
1435		tport->tp_read_urb_state = TI_READ_URB_STOPPING;
1436
1437	spin_unlock_irqrestore(&tport->tp_lock, flags);
1438}
1439
1440
1441static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty)
1442{
1443	struct urb *urb;
1444	int status = 0;
1445	unsigned long flags;
1446
1447	spin_lock_irqsave(&tport->tp_lock, flags);
1448
1449	if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) {
1450		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1451		urb = tport->tp_port->read_urb;
1452		spin_unlock_irqrestore(&tport->tp_lock, flags);
1453		urb->context = tport;
1454		status = usb_submit_urb(urb, GFP_KERNEL);
1455	} else  {
1456		tport->tp_read_urb_state = TI_READ_URB_RUNNING;
1457		spin_unlock_irqrestore(&tport->tp_lock, flags);
1458	}
1459
1460	return status;
1461}
1462
1463static int ti_command_out_sync(struct usb_device *udev, u8 command,
1464		u16 moduleid, u16 value, void *data, int size)
1465{
1466	int status;
1467
1468	status = usb_control_msg(udev, usb_sndctrlpipe(udev, 0), command,
1469			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT,
1470			value, moduleid, data, size, 1000);
1471	if (status < 0)
1472		return status;
1473
1474	return 0;
1475}
1476
1477static int ti_command_in_sync(struct usb_device *udev, u8 command,
1478		u16 moduleid, u16 value, void *data, int size)
1479{
1480	int status;
1481
1482	status = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), command,
1483			USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN,
1484			value, moduleid, data, size, 1000);
1485	if (status == size)
1486		status = 0;
1487	else if (status >= 0)
1488		status = -ECOMM;
1489
1490	return status;
1491}
1492
1493static int ti_port_cmd_out(struct usb_serial_port *port, u8 command,
1494		u16 value, void *data, int size)
1495{
1496	return ti_command_out_sync(port->serial->dev, command,
1497			TI_UART1_PORT + port->port_number,
1498			value, data, size);
1499}
1500
1501static int ti_port_cmd_in(struct usb_serial_port *port, u8 command,
1502		u16 value, void *data, int size)
1503{
1504	return ti_command_in_sync(port->serial->dev, command,
1505			TI_UART1_PORT + port->port_number,
1506			value, data, size);
1507}
1508
1509static int ti_write_byte(struct usb_serial_port *port,
1510			 struct ti_device *tdev, unsigned long addr,
1511			 u8 mask, u8 byte)
1512{
1513	int status;
1514	unsigned int size;
1515	struct ti_write_data_bytes *data;
1516
1517	dev_dbg(&port->dev, "%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X\n", __func__,
1518		addr, mask, byte);
1519
1520	size = sizeof(struct ti_write_data_bytes) + 2;
1521	data = kmalloc(size, GFP_KERNEL);
1522	if (!data)
1523		return -ENOMEM;
1524
1525	data->bAddrType = TI_RW_DATA_ADDR_XDATA;
1526	data->bDataType = TI_RW_DATA_BYTE;
1527	data->bDataCounter = 1;
1528	data->wBaseAddrHi = cpu_to_be16(addr>>16);
1529	data->wBaseAddrLo = cpu_to_be16(addr);
1530	data->bData[0] = mask;
1531	data->bData[1] = byte;
1532
1533	status = ti_command_out_sync(port->serial->dev, TI_WRITE_DATA,
1534			TI_RAM_PORT, 0, data, size);
1535	if (status < 0)
1536		dev_err(&port->dev, "%s - failed, %d\n", __func__, status);
1537
1538	kfree(data);
1539
1540	return status;
1541}
1542
1543static int ti_do_download(struct usb_device *dev, int pipe,
1544						u8 *buffer, int size)
1545{
1546	int pos;
1547	u8 cs = 0;
1548	int done;
1549	struct ti_firmware_header *header;
1550	int status = 0;
1551	int len;
1552
1553	for (pos = sizeof(struct ti_firmware_header); pos < size; pos++)
1554		cs = (u8)(cs + buffer[pos]);
1555
1556	header = (struct ti_firmware_header *)buffer;
1557	header->wLength = cpu_to_le16(size - sizeof(*header));
1558	header->bCheckSum = cs;
1559
1560	dev_dbg(&dev->dev, "%s - downloading firmware\n", __func__);
1561	for (pos = 0; pos < size; pos += done) {
1562		len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE);
1563		status = usb_bulk_msg(dev, pipe, buffer + pos, len,
1564								&done, 1000);
1565		if (status)
1566			break;
1567	}
1568	return status;
1569}
1570
1571static int ti_download_firmware(struct ti_device *tdev)
1572{
1573	int status;
1574	int buffer_size;
1575	u8 *buffer;
1576	struct usb_device *dev = tdev->td_serial->dev;
1577	unsigned int pipe = usb_sndbulkpipe(dev,
1578		tdev->td_serial->port[0]->bulk_out_endpointAddress);
1579	const struct firmware *fw_p;
1580	char buf[32];
1581
1582	if (le16_to_cpu(dev->descriptor.idVendor) == MXU1_VENDOR_ID) {
1583		snprintf(buf,
1584			sizeof(buf),
1585			"moxa/moxa-%04x.fw",
1586			le16_to_cpu(dev->descriptor.idProduct));
1587
1588		status = request_firmware(&fw_p, buf, &dev->dev);
1589		goto check_firmware;
1590	}
1591
1592	/* try ID specific firmware first, then try generic firmware */
1593	sprintf(buf, "ti_usb-v%04x-p%04x.fw",
1594			le16_to_cpu(dev->descriptor.idVendor),
1595			le16_to_cpu(dev->descriptor.idProduct));
1596	status = request_firmware(&fw_p, buf, &dev->dev);
1597
1598	if (status != 0) {
1599		buf[0] = '\0';
1600		if (le16_to_cpu(dev->descriptor.idVendor) == MTS_VENDOR_ID) {
1601			switch (le16_to_cpu(dev->descriptor.idProduct)) {
1602			case MTS_CDMA_PRODUCT_ID:
1603				strcpy(buf, "mts_cdma.fw");
1604				break;
1605			case MTS_GSM_PRODUCT_ID:
1606				strcpy(buf, "mts_gsm.fw");
1607				break;
1608			case MTS_EDGE_PRODUCT_ID:
1609				strcpy(buf, "mts_edge.fw");
1610				break;
1611			case MTS_MT9234MU_PRODUCT_ID:
1612				strcpy(buf, "mts_mt9234mu.fw");
1613				break;
1614			case MTS_MT9234ZBA_PRODUCT_ID:
1615				strcpy(buf, "mts_mt9234zba.fw");
1616				break;
1617			case MTS_MT9234ZBAOLD_PRODUCT_ID:
1618				strcpy(buf, "mts_mt9234zba.fw");
1619				break;			}
1620		}
1621		if (buf[0] == '\0') {
1622			if (tdev->td_is_3410)
1623				strcpy(buf, "ti_3410.fw");
1624			else
1625				strcpy(buf, "ti_5052.fw");
1626		}
1627		status = request_firmware(&fw_p, buf, &dev->dev);
1628	}
1629
1630check_firmware:
1631	if (status) {
1632		dev_err(&dev->dev, "%s - firmware not found\n", __func__);
1633		return -ENOENT;
1634	}
1635	if (fw_p->size > TI_FIRMWARE_BUF_SIZE) {
1636		dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size);
1637		release_firmware(fw_p);
1638		return -ENOENT;
1639	}
1640
1641	buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header);
1642	buffer = kmalloc(buffer_size, GFP_KERNEL);
1643	if (buffer) {
1644		memcpy(buffer, fw_p->data, fw_p->size);
1645		memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size);
1646		status = ti_do_download(dev, pipe, buffer, fw_p->size);
1647		kfree(buffer);
1648	} else {
1649		status = -ENOMEM;
1650	}
1651	release_firmware(fw_p);
1652	if (status) {
1653		dev_err(&dev->dev, "%s - error downloading firmware, %d\n",
1654							__func__, status);
1655		return status;
1656	}
1657
1658	dev_dbg(&dev->dev, "%s - download successful\n", __func__);
1659
1660	return 0;
1661}