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