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