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