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