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