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