cachepc-linux

Fork of AMDESE/linux with modifications for CachePC side-channel attack
git clone https://git.sinitax.com/sinitax/cachepc-linux
Log | Files | Refs | README | LICENSE | sfeed.txt

ti_usb_3410_5052.c (44665B)


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