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