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 ti_restart_read(tport, tty); 777 } 778 779 if (I_IXOFF(tty) || I_IXON(tty)) { 780 config->cXon = START_CHAR(tty); 781 config->cXoff = STOP_CHAR(tty); 782 783 if (I_IXOFF(tty)) 784 config->wFlags |= TI_UART_ENABLE_X_IN; 785 else 786 ti_restart_read(tport, tty); 787 788 if (I_IXON(tty)) 789 config->wFlags |= TI_UART_ENABLE_X_OUT; 790 } 791 792 baud = tty_get_baud_rate(tty); 793 if (!baud) 794 baud = 9600; 795 if (tport->tp_tdev->td_is_3410) 796 config->wBaudRate = (__u16)((923077 + baud/2) / baud); 797 else 798 config->wBaudRate = (__u16)((461538 + baud/2) / baud); 799 800 /* FIXME: Should calculate resulting baud here and report it back */ 801 if ((cflag & CBAUD) != B0) 802 tty_encode_baud_rate(tty, baud, baud); 803 804 dev_dbg(&port->dev, 805 "%s - BaudRate=%d, wBaudRate=%d, wFlags=0x%04X, bDataBits=%d, bParity=%d, bStopBits=%d, cXon=%d, cXoff=%d, bUartMode=%d\n", 806 __func__, baud, config->wBaudRate, config->wFlags, 807 config->bDataBits, config->bParity, config->bStopBits, 808 config->cXon, config->cXoff, config->bUartMode); 809 810 cpu_to_be16s(&config->wBaudRate); 811 cpu_to_be16s(&config->wFlags); 812 813 status = ti_command_out_sync(tport->tp_tdev, TI_SET_CONFIG, 814 (__u8)(TI_UART1_PORT + port_number), 0, (__u8 *)config, 815 sizeof(*config)); 816 if (status) 817 dev_err(&port->dev, "%s - cannot set config on port %d, %d\n", 818 __func__, port_number, status); 819 820 /* SET_CONFIG asserts RTS and DTR, reset them correctly */ 821 mcr = tport->tp_shadow_mcr; 822 /* if baud rate is B0, clear RTS and DTR */ 823 if ((cflag & CBAUD) == B0) 824 mcr &= ~(TI_MCR_DTR | TI_MCR_RTS); 825 status = ti_set_mcr(tport, mcr); 826 if (status) 827 dev_err(&port->dev, 828 "%s - cannot set modem control on port %d, %d\n", 829 __func__, port_number, status); 830 831 kfree(config); 832 } 833 834 835 static int ti_tiocmget(struct tty_struct *tty) 836 { 837 struct usb_serial_port *port = tty->driver_data; 838 struct ti_port *tport = usb_get_serial_port_data(port); 839 unsigned int result; 840 unsigned int msr; 841 unsigned int mcr; 842 unsigned long flags; 843 844 if (tport == NULL) 845 return -ENODEV; 846 847 spin_lock_irqsave(&tport->tp_lock, flags); 848 msr = tport->tp_msr; 849 mcr = tport->tp_shadow_mcr; 850 spin_unlock_irqrestore(&tport->tp_lock, flags); 851 852 result = ((mcr & TI_MCR_DTR) ? TIOCM_DTR : 0) 853 | ((mcr & TI_MCR_RTS) ? TIOCM_RTS : 0) 854 | ((mcr & TI_MCR_LOOP) ? TIOCM_LOOP : 0) 855 | ((msr & TI_MSR_CTS) ? TIOCM_CTS : 0) 856 | ((msr & TI_MSR_CD) ? TIOCM_CAR : 0) 857 | ((msr & TI_MSR_RI) ? TIOCM_RI : 0) 858 | ((msr & TI_MSR_DSR) ? TIOCM_DSR : 0); 859 860 dev_dbg(&port->dev, "%s - 0x%04X\n", __func__, result); 861 862 return result; 863 } 864 865 866 static int ti_tiocmset(struct tty_struct *tty, 867 unsigned int set, unsigned int clear) 868 { 869 struct usb_serial_port *port = tty->driver_data; 870 struct ti_port *tport = usb_get_serial_port_data(port); 871 unsigned int mcr; 872 unsigned long flags; 873 874 if (tport == NULL) 875 return -ENODEV; 876 877 spin_lock_irqsave(&tport->tp_lock, flags); 878 mcr = tport->tp_shadow_mcr; 879 880 if (set & TIOCM_RTS) 881 mcr |= TI_MCR_RTS; 882 if (set & TIOCM_DTR) 883 mcr |= TI_MCR_DTR; 884 if (set & TIOCM_LOOP) 885 mcr |= TI_MCR_LOOP; 886 887 if (clear & TIOCM_RTS) 888 mcr &= ~TI_MCR_RTS; 889 if (clear & TIOCM_DTR) 890 mcr &= ~TI_MCR_DTR; 891 if (clear & TIOCM_LOOP) 892 mcr &= ~TI_MCR_LOOP; 893 spin_unlock_irqrestore(&tport->tp_lock, flags); 894 895 return ti_set_mcr(tport, mcr); 896 } 897 898 899 static void ti_break(struct tty_struct *tty, int break_state) 900 { 901 struct usb_serial_port *port = tty->driver_data; 902 struct ti_port *tport = usb_get_serial_port_data(port); 903 int status; 904 905 dev_dbg(&port->dev, "%s - state = %d\n", __func__, break_state); 906 907 if (tport == NULL) 908 return; 909 910 status = ti_write_byte(port, tport->tp_tdev, 911 tport->tp_uart_base_addr + TI_UART_OFFSET_LCR, 912 TI_LCR_BREAK, break_state == -1 ? TI_LCR_BREAK : 0); 913 914 if (status) 915 dev_dbg(&port->dev, "%s - error setting break, %d\n", __func__, status); 916 } 917 918 919 static void ti_interrupt_callback(struct urb *urb) 920 { 921 struct ti_device *tdev = urb->context; 922 struct usb_serial_port *port; 923 struct usb_serial *serial = tdev->td_serial; 924 struct ti_port *tport; 925 struct device *dev = &urb->dev->dev; 926 unsigned char *data = urb->transfer_buffer; 927 int length = urb->actual_length; 928 int port_number; 929 int function; 930 int status = urb->status; 931 int retval; 932 __u8 msr; 933 934 switch (status) { 935 case 0: 936 break; 937 case -ECONNRESET: 938 case -ENOENT: 939 case -ESHUTDOWN: 940 dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status); 941 tdev->td_urb_error = 1; 942 return; 943 default: 944 dev_err(dev, "%s - nonzero urb status, %d\n", __func__, status); 945 tdev->td_urb_error = 1; 946 goto exit; 947 } 948 949 if (length != 2) { 950 dev_dbg(dev, "%s - bad packet size, %d\n", __func__, length); 951 goto exit; 952 } 953 954 if (data[0] == TI_CODE_HARDWARE_ERROR) { 955 dev_err(dev, "%s - hardware error, %d\n", __func__, data[1]); 956 goto exit; 957 } 958 959 port_number = TI_GET_PORT_FROM_CODE(data[0]); 960 function = TI_GET_FUNC_FROM_CODE(data[0]); 961 962 dev_dbg(dev, "%s - port_number %d, function %d, data 0x%02X\n", 963 __func__, port_number, function, data[1]); 964 965 if (port_number >= serial->num_ports) { 966 dev_err(dev, "%s - bad port number, %d\n", 967 __func__, port_number); 968 goto exit; 969 } 970 971 port = serial->port[port_number]; 972 973 tport = usb_get_serial_port_data(port); 974 if (!tport) 975 goto exit; 976 977 switch (function) { 978 case TI_CODE_DATA_ERROR: 979 dev_err(dev, "%s - DATA ERROR, port %d, data 0x%02X\n", 980 __func__, port_number, data[1]); 981 break; 982 983 case TI_CODE_MODEM_STATUS: 984 msr = data[1]; 985 dev_dbg(dev, "%s - port %d, msr 0x%02X\n", __func__, port_number, msr); 986 ti_handle_new_msr(tport, msr); 987 break; 988 989 default: 990 dev_err(dev, "%s - unknown interrupt code, 0x%02X\n", 991 __func__, data[1]); 992 break; 993 } 994 995 exit: 996 retval = usb_submit_urb(urb, GFP_ATOMIC); 997 if (retval) 998 dev_err(dev, "%s - resubmit interrupt urb failed, %d\n", 999 __func__, retval); 1000 } 1001 1002 1003 static void ti_bulk_in_callback(struct urb *urb) 1004 { 1005 struct ti_port *tport = urb->context; 1006 struct usb_serial_port *port = tport->tp_port; 1007 struct device *dev = &urb->dev->dev; 1008 int status = urb->status; 1009 int retval = 0; 1010 1011 switch (status) { 1012 case 0: 1013 break; 1014 case -ECONNRESET: 1015 case -ENOENT: 1016 case -ESHUTDOWN: 1017 dev_dbg(dev, "%s - urb shutting down, %d\n", __func__, status); 1018 tport->tp_tdev->td_urb_error = 1; 1019 return; 1020 default: 1021 dev_err(dev, "%s - nonzero urb status, %d\n", 1022 __func__, status); 1023 tport->tp_tdev->td_urb_error = 1; 1024 } 1025 1026 if (status == -EPIPE) 1027 goto exit; 1028 1029 if (status) { 1030 dev_err(dev, "%s - stopping read!\n", __func__); 1031 return; 1032 } 1033 1034 if (urb->actual_length) { 1035 usb_serial_debug_data(dev, __func__, urb->actual_length, 1036 urb->transfer_buffer); 1037 1038 if (!tport->tp_is_open) 1039 dev_dbg(dev, "%s - port closed, dropping data\n", 1040 __func__); 1041 else 1042 ti_recv(port, urb->transfer_buffer, urb->actual_length); 1043 spin_lock(&tport->tp_lock); 1044 port->icount.rx += urb->actual_length; 1045 spin_unlock(&tport->tp_lock); 1046 } 1047 1048 exit: 1049 /* continue to read unless stopping */ 1050 spin_lock(&tport->tp_lock); 1051 if (tport->tp_read_urb_state == TI_READ_URB_RUNNING) 1052 retval = usb_submit_urb(urb, GFP_ATOMIC); 1053 else if (tport->tp_read_urb_state == TI_READ_URB_STOPPING) 1054 tport->tp_read_urb_state = TI_READ_URB_STOPPED; 1055 1056 spin_unlock(&tport->tp_lock); 1057 if (retval) 1058 dev_err(dev, "%s - resubmit read urb failed, %d\n", 1059 __func__, retval); 1060 } 1061 1062 1063 static void ti_bulk_out_callback(struct urb *urb) 1064 { 1065 struct ti_port *tport = urb->context; 1066 struct usb_serial_port *port = tport->tp_port; 1067 int status = urb->status; 1068 1069 tport->tp_write_urb_in_use = 0; 1070 1071 switch (status) { 1072 case 0: 1073 break; 1074 case -ECONNRESET: 1075 case -ENOENT: 1076 case -ESHUTDOWN: 1077 dev_dbg(&port->dev, "%s - urb shutting down, %d\n", __func__, status); 1078 tport->tp_tdev->td_urb_error = 1; 1079 return; 1080 default: 1081 dev_err_console(port, "%s - nonzero urb status, %d\n", 1082 __func__, status); 1083 tport->tp_tdev->td_urb_error = 1; 1084 } 1085 1086 /* send any buffered data */ 1087 ti_send(tport); 1088 } 1089 1090 1091 static void ti_recv(struct usb_serial_port *port, unsigned char *data, 1092 int length) 1093 { 1094 int cnt; 1095 1096 do { 1097 cnt = tty_insert_flip_string(&port->port, data, length); 1098 if (cnt < length) { 1099 dev_err(&port->dev, "%s - dropping data, %d bytes lost\n", 1100 __func__, length - cnt); 1101 if (cnt == 0) 1102 break; 1103 } 1104 tty_flip_buffer_push(&port->port); 1105 data += cnt; 1106 length -= cnt; 1107 } while (length > 0); 1108 } 1109 1110 1111 static void ti_send(struct ti_port *tport) 1112 { 1113 int count, result; 1114 struct usb_serial_port *port = tport->tp_port; 1115 unsigned long flags; 1116 1117 spin_lock_irqsave(&tport->tp_lock, flags); 1118 1119 if (tport->tp_write_urb_in_use) 1120 goto unlock; 1121 1122 count = kfifo_out(&port->write_fifo, 1123 port->write_urb->transfer_buffer, 1124 port->bulk_out_size); 1125 1126 if (count == 0) 1127 goto unlock; 1128 1129 tport->tp_write_urb_in_use = 1; 1130 1131 spin_unlock_irqrestore(&tport->tp_lock, flags); 1132 1133 usb_serial_debug_data(&port->dev, __func__, count, 1134 port->write_urb->transfer_buffer); 1135 1136 usb_fill_bulk_urb(port->write_urb, port->serial->dev, 1137 usb_sndbulkpipe(port->serial->dev, 1138 port->bulk_out_endpointAddress), 1139 port->write_urb->transfer_buffer, count, 1140 ti_bulk_out_callback, tport); 1141 1142 result = usb_submit_urb(port->write_urb, GFP_ATOMIC); 1143 if (result) { 1144 dev_err_console(port, "%s - submit write urb failed, %d\n", 1145 __func__, result); 1146 tport->tp_write_urb_in_use = 0; 1147 /* TODO: reschedule ti_send */ 1148 } else { 1149 spin_lock_irqsave(&tport->tp_lock, flags); 1150 port->icount.tx += count; 1151 spin_unlock_irqrestore(&tport->tp_lock, flags); 1152 } 1153 1154 /* more room in the buffer for new writes, wakeup */ 1155 tty_port_tty_wakeup(&port->port); 1156 1157 return; 1158 unlock: 1159 spin_unlock_irqrestore(&tport->tp_lock, flags); 1160 return; 1161 } 1162 1163 1164 static int ti_set_mcr(struct ti_port *tport, unsigned int mcr) 1165 { 1166 unsigned long flags; 1167 int status; 1168 1169 status = ti_write_byte(tport->tp_port, tport->tp_tdev, 1170 tport->tp_uart_base_addr + TI_UART_OFFSET_MCR, 1171 TI_MCR_RTS | TI_MCR_DTR | TI_MCR_LOOP, mcr); 1172 1173 spin_lock_irqsave(&tport->tp_lock, flags); 1174 if (!status) 1175 tport->tp_shadow_mcr = mcr; 1176 spin_unlock_irqrestore(&tport->tp_lock, flags); 1177 1178 return status; 1179 } 1180 1181 1182 static int ti_get_lsr(struct ti_port *tport, u8 *lsr) 1183 { 1184 int size, status; 1185 struct ti_device *tdev = tport->tp_tdev; 1186 struct usb_serial_port *port = tport->tp_port; 1187 int port_number = port->port_number; 1188 struct ti_port_status *data; 1189 1190 size = sizeof(struct ti_port_status); 1191 data = kmalloc(size, GFP_KERNEL); 1192 if (!data) 1193 return -ENOMEM; 1194 1195 status = ti_command_in_sync(tdev, TI_GET_PORT_STATUS, 1196 (__u8)(TI_UART1_PORT+port_number), 0, (__u8 *)data, size); 1197 if (status) { 1198 dev_err(&port->dev, 1199 "%s - get port status command failed, %d\n", 1200 __func__, status); 1201 goto free_data; 1202 } 1203 1204 dev_dbg(&port->dev, "%s - lsr 0x%02X\n", __func__, data->bLSR); 1205 1206 *lsr = data->bLSR; 1207 1208 free_data: 1209 kfree(data); 1210 return status; 1211 } 1212 1213 1214 static int ti_get_serial_info(struct ti_port *tport, 1215 struct serial_struct __user *ret_arg) 1216 { 1217 struct usb_serial_port *port = tport->tp_port; 1218 struct serial_struct ret_serial; 1219 unsigned cwait; 1220 1221 if (!ret_arg) 1222 return -EFAULT; 1223 1224 cwait = port->port.closing_wait; 1225 if (cwait != ASYNC_CLOSING_WAIT_NONE) 1226 cwait = jiffies_to_msecs(cwait) / 10; 1227 1228 memset(&ret_serial, 0, sizeof(ret_serial)); 1229 1230 ret_serial.type = PORT_16550A; 1231 ret_serial.line = port->minor; 1232 ret_serial.port = port->port_number; 1233 ret_serial.flags = tport->tp_flags; 1234 ret_serial.xmit_fifo_size = kfifo_size(&port->write_fifo); 1235 ret_serial.baud_base = tport->tp_tdev->td_is_3410 ? 921600 : 460800; 1236 ret_serial.closing_wait = cwait; 1237 1238 if (copy_to_user(ret_arg, &ret_serial, sizeof(*ret_arg))) 1239 return -EFAULT; 1240 1241 return 0; 1242 } 1243 1244 1245 static int ti_set_serial_info(struct tty_struct *tty, struct ti_port *tport, 1246 struct serial_struct __user *new_arg) 1247 { 1248 struct serial_struct new_serial; 1249 unsigned cwait; 1250 1251 if (copy_from_user(&new_serial, new_arg, sizeof(new_serial))) 1252 return -EFAULT; 1253 1254 cwait = new_serial.closing_wait; 1255 if (cwait != ASYNC_CLOSING_WAIT_NONE) 1256 cwait = msecs_to_jiffies(10 * new_serial.closing_wait); 1257 1258 tport->tp_flags = new_serial.flags & TI_SET_SERIAL_FLAGS; 1259 tport->tp_port->port.closing_wait = cwait; 1260 1261 return 0; 1262 } 1263 1264 1265 static void ti_handle_new_msr(struct ti_port *tport, __u8 msr) 1266 { 1267 struct async_icount *icount; 1268 struct tty_struct *tty; 1269 unsigned long flags; 1270 1271 dev_dbg(&tport->tp_port->dev, "%s - msr 0x%02X\n", __func__, msr); 1272 1273 if (msr & TI_MSR_DELTA_MASK) { 1274 spin_lock_irqsave(&tport->tp_lock, flags); 1275 icount = &tport->tp_port->icount; 1276 if (msr & TI_MSR_DELTA_CTS) 1277 icount->cts++; 1278 if (msr & TI_MSR_DELTA_DSR) 1279 icount->dsr++; 1280 if (msr & TI_MSR_DELTA_CD) 1281 icount->dcd++; 1282 if (msr & TI_MSR_DELTA_RI) 1283 icount->rng++; 1284 wake_up_interruptible(&tport->tp_port->port.delta_msr_wait); 1285 spin_unlock_irqrestore(&tport->tp_lock, flags); 1286 } 1287 1288 tport->tp_msr = msr & TI_MSR_MASK; 1289 1290 /* handle CTS flow control */ 1291 tty = tty_port_tty_get(&tport->tp_port->port); 1292 if (tty && C_CRTSCTS(tty)) { 1293 if (msr & TI_MSR_CTS) 1294 tty_wakeup(tty); 1295 } 1296 tty_kref_put(tty); 1297 } 1298 1299 1300 static void ti_stop_read(struct ti_port *tport, struct tty_struct *tty) 1301 { 1302 unsigned long flags; 1303 1304 spin_lock_irqsave(&tport->tp_lock, flags); 1305 1306 if (tport->tp_read_urb_state == TI_READ_URB_RUNNING) 1307 tport->tp_read_urb_state = TI_READ_URB_STOPPING; 1308 1309 spin_unlock_irqrestore(&tport->tp_lock, flags); 1310 } 1311 1312 1313 static int ti_restart_read(struct ti_port *tport, struct tty_struct *tty) 1314 { 1315 struct urb *urb; 1316 int status = 0; 1317 unsigned long flags; 1318 1319 spin_lock_irqsave(&tport->tp_lock, flags); 1320 1321 if (tport->tp_read_urb_state == TI_READ_URB_STOPPED) { 1322 tport->tp_read_urb_state = TI_READ_URB_RUNNING; 1323 urb = tport->tp_port->read_urb; 1324 spin_unlock_irqrestore(&tport->tp_lock, flags); 1325 urb->context = tport; 1326 status = usb_submit_urb(urb, GFP_KERNEL); 1327 } else { 1328 tport->tp_read_urb_state = TI_READ_URB_RUNNING; 1329 spin_unlock_irqrestore(&tport->tp_lock, flags); 1330 } 1331 1332 return status; 1333 } 1334 1335 1336 static int ti_command_out_sync(struct ti_device *tdev, __u8 command, 1337 __u16 moduleid, __u16 value, __u8 *data, int size) 1338 { 1339 int status; 1340 1341 status = usb_control_msg(tdev->td_serial->dev, 1342 usb_sndctrlpipe(tdev->td_serial->dev, 0), command, 1343 (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT), 1344 value, moduleid, data, size, 1000); 1345 1346 if (status == size) 1347 status = 0; 1348 1349 if (status > 0) 1350 status = -ECOMM; 1351 1352 return status; 1353 } 1354 1355 1356 static int ti_command_in_sync(struct ti_device *tdev, __u8 command, 1357 __u16 moduleid, __u16 value, __u8 *data, int size) 1358 { 1359 int status; 1360 1361 status = usb_control_msg(tdev->td_serial->dev, 1362 usb_rcvctrlpipe(tdev->td_serial->dev, 0), command, 1363 (USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN), 1364 value, moduleid, data, size, 1000); 1365 1366 if (status == size) 1367 status = 0; 1368 1369 if (status > 0) 1370 status = -ECOMM; 1371 1372 return status; 1373 } 1374 1375 1376 static int ti_write_byte(struct usb_serial_port *port, 1377 struct ti_device *tdev, unsigned long addr, 1378 __u8 mask, __u8 byte) 1379 { 1380 int status; 1381 unsigned int size; 1382 struct ti_write_data_bytes *data; 1383 1384 dev_dbg(&port->dev, "%s - addr 0x%08lX, mask 0x%02X, byte 0x%02X\n", __func__, 1385 addr, mask, byte); 1386 1387 size = sizeof(struct ti_write_data_bytes) + 2; 1388 data = kmalloc(size, GFP_KERNEL); 1389 if (!data) 1390 return -ENOMEM; 1391 1392 data->bAddrType = TI_RW_DATA_ADDR_XDATA; 1393 data->bDataType = TI_RW_DATA_BYTE; 1394 data->bDataCounter = 1; 1395 data->wBaseAddrHi = cpu_to_be16(addr>>16); 1396 data->wBaseAddrLo = cpu_to_be16(addr); 1397 data->bData[0] = mask; 1398 data->bData[1] = byte; 1399 1400 status = ti_command_out_sync(tdev, TI_WRITE_DATA, TI_RAM_PORT, 0, 1401 (__u8 *)data, size); 1402 1403 if (status < 0) 1404 dev_err(&port->dev, "%s - failed, %d\n", __func__, status); 1405 1406 kfree(data); 1407 1408 return status; 1409 } 1410 1411 static int ti_do_download(struct usb_device *dev, int pipe, 1412 u8 *buffer, int size) 1413 { 1414 int pos; 1415 u8 cs = 0; 1416 int done; 1417 struct ti_firmware_header *header; 1418 int status = 0; 1419 int len; 1420 1421 for (pos = sizeof(struct ti_firmware_header); pos < size; pos++) 1422 cs = (__u8)(cs + buffer[pos]); 1423 1424 header = (struct ti_firmware_header *)buffer; 1425 header->wLength = cpu_to_le16((__u16)(size 1426 - sizeof(struct ti_firmware_header))); 1427 header->bCheckSum = cs; 1428 1429 dev_dbg(&dev->dev, "%s - downloading firmware\n", __func__); 1430 for (pos = 0; pos < size; pos += done) { 1431 len = min(size - pos, TI_DOWNLOAD_MAX_PACKET_SIZE); 1432 status = usb_bulk_msg(dev, pipe, buffer + pos, len, 1433 &done, 1000); 1434 if (status) 1435 break; 1436 } 1437 return status; 1438 } 1439 1440 static int ti_download_firmware(struct ti_device *tdev) 1441 { 1442 int status; 1443 int buffer_size; 1444 __u8 *buffer; 1445 struct usb_device *dev = tdev->td_serial->dev; 1446 unsigned int pipe = usb_sndbulkpipe(dev, 1447 tdev->td_serial->port[0]->bulk_out_endpointAddress); 1448 const struct firmware *fw_p; 1449 char buf[32]; 1450 1451 /* try ID specific firmware first, then try generic firmware */ 1452 sprintf(buf, "ti_usb-v%04x-p%04x.fw", 1453 le16_to_cpu(dev->descriptor.idVendor), 1454 le16_to_cpu(dev->descriptor.idProduct)); 1455 status = request_firmware(&fw_p, buf, &dev->dev); 1456 1457 if (status != 0) { 1458 buf[0] = '\0'; 1459 if (le16_to_cpu(dev->descriptor.idVendor) == MTS_VENDOR_ID) { 1460 switch (le16_to_cpu(dev->descriptor.idProduct)) { 1461 case MTS_CDMA_PRODUCT_ID: 1462 strcpy(buf, "mts_cdma.fw"); 1463 break; 1464 case MTS_GSM_PRODUCT_ID: 1465 strcpy(buf, "mts_gsm.fw"); 1466 break; 1467 case MTS_EDGE_PRODUCT_ID: 1468 strcpy(buf, "mts_edge.fw"); 1469 break; 1470 case MTS_MT9234MU_PRODUCT_ID: 1471 strcpy(buf, "mts_mt9234mu.fw"); 1472 break; 1473 case MTS_MT9234ZBA_PRODUCT_ID: 1474 strcpy(buf, "mts_mt9234zba.fw"); 1475 break; 1476 case MTS_MT9234ZBAOLD_PRODUCT_ID: 1477 strcpy(buf, "mts_mt9234zba.fw"); 1478 break; } 1479 } 1480 if (buf[0] == '\0') { 1481 if (tdev->td_is_3410) 1482 strcpy(buf, "ti_3410.fw"); 1483 else 1484 strcpy(buf, "ti_5052.fw"); 1485 } 1486 status = request_firmware(&fw_p, buf, &dev->dev); 1487 } 1488 if (status) { 1489 dev_err(&dev->dev, "%s - firmware not found\n", __func__); 1490 return -ENOENT; 1491 } 1492 if (fw_p->size > TI_FIRMWARE_BUF_SIZE) { 1493 dev_err(&dev->dev, "%s - firmware too large %zu\n", __func__, fw_p->size); 1494 release_firmware(fw_p); 1495 return -ENOENT; 1496 } 1497 1498 buffer_size = TI_FIRMWARE_BUF_SIZE + sizeof(struct ti_firmware_header); 1499 buffer = kmalloc(buffer_size, GFP_KERNEL); 1500 if (buffer) { 1501 memcpy(buffer, fw_p->data, fw_p->size); 1502 memset(buffer + fw_p->size, 0xff, buffer_size - fw_p->size); 1503 status = ti_do_download(dev, pipe, buffer, fw_p->size); 1504 kfree(buffer); 1505 } else { 1506 status = -ENOMEM; 1507 } 1508 release_firmware(fw_p); 1509 if (status) { 1510 dev_err(&dev->dev, "%s - error downloading firmware, %d\n", 1511 __func__, status); 1512 return status; 1513 } 1514 1515 dev_dbg(&dev->dev, "%s - download successful\n", __func__); 1516 1517 return 0; 1518 } 1519