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