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