1 /* 2 * USB Cypress M8 driver 3 * 4 * Copyright (C) 2004 5 * Lonnie Mendez (dignome@gmail.com) 6 * Copyright (C) 2003,2004 7 * Neil Whelchel (koyama@firstlight.net) 8 * 9 * This program is free software; you can redistribute it and/or modify 10 * it under the terms of the GNU General Public License as published by 11 * the Free Software Foundation; either version 2 of the License, or 12 * (at your option) any later version. 13 * 14 * See Documentation/usb/usb-serial.txt for more information on using this 15 * driver 16 * 17 * See http://geocities.com/i0xox0i for information on this driver and the 18 * earthmate usb device. 19 */ 20 21 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation 22 for linux. */ 23 /* Thanks to cypress for providing references for the hid reports. */ 24 /* Thanks to Jiang Zhang for providing links and for general help. */ 25 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others.*/ 26 27 28 #include <linux/kernel.h> 29 #include <linux/errno.h> 30 #include <linux/init.h> 31 #include <linux/slab.h> 32 #include <linux/tty.h> 33 #include <linux/tty_driver.h> 34 #include <linux/tty_flip.h> 35 #include <linux/module.h> 36 #include <linux/moduleparam.h> 37 #include <linux/spinlock.h> 38 #include <linux/usb.h> 39 #include <linux/usb/serial.h> 40 #include <linux/serial.h> 41 #include <linux/kfifo.h> 42 #include <linux/delay.h> 43 #include <linux/uaccess.h> 44 #include <asm/unaligned.h> 45 46 #include "cypress_m8.h" 47 48 49 static bool stats; 50 static int interval; 51 static bool unstable_bauds; 52 53 /* 54 * Version Information 55 */ 56 #define DRIVER_VERSION "v1.10" 57 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>" 58 #define DRIVER_DESC "Cypress USB to Serial Driver" 59 60 /* write buffer size defines */ 61 #define CYPRESS_BUF_SIZE 1024 62 63 static const struct usb_device_id id_table_earthmate[] = { 64 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 65 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 66 { } /* Terminating entry */ 67 }; 68 69 static const struct usb_device_id id_table_cyphidcomrs232[] = { 70 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 71 { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) }, 72 { } /* Terminating entry */ 73 }; 74 75 static const struct usb_device_id id_table_nokiaca42v2[] = { 76 { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) }, 77 { } /* Terminating entry */ 78 }; 79 80 static const struct usb_device_id id_table_combined[] = { 81 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 82 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 83 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 84 { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) }, 85 { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) }, 86 { } /* Terminating entry */ 87 }; 88 89 MODULE_DEVICE_TABLE(usb, id_table_combined); 90 91 enum packet_format { 92 packet_format_1, /* b0:status, b1:payload count */ 93 packet_format_2 /* b0[7:3]:status, b0[2:0]:payload count */ 94 }; 95 96 struct cypress_private { 97 spinlock_t lock; /* private lock */ 98 int chiptype; /* identifier of device, for quirks/etc */ 99 int bytes_in; /* used for statistics */ 100 int bytes_out; /* used for statistics */ 101 int cmd_count; /* used for statistics */ 102 int cmd_ctrl; /* always set this to 1 before issuing a command */ 103 struct kfifo write_fifo; /* write fifo */ 104 int write_urb_in_use; /* write urb in use indicator */ 105 int write_urb_interval; /* interval to use for write urb */ 106 int read_urb_interval; /* interval to use for read urb */ 107 int comm_is_ok; /* true if communication is (still) ok */ 108 int termios_initialized; 109 __u8 line_control; /* holds dtr / rts value */ 110 __u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */ 111 __u8 current_config; /* stores the current configuration byte */ 112 __u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */ 113 enum packet_format pkt_fmt; /* format to use for packet send / receive */ 114 int get_cfg_unsafe; /* If true, the CYPRESS_GET_CONFIG is unsafe */ 115 int baud_rate; /* stores current baud rate in 116 integer form */ 117 int isthrottled; /* if throttled, discard reads */ 118 wait_queue_head_t delta_msr_wait; /* used for TIOCMIWAIT */ 119 char prev_status, diff_status; /* used for TIOCMIWAIT */ 120 /* we pass a pointer to this as the argument sent to 121 cypress_set_termios old_termios */ 122 struct ktermios tmp_termios; /* stores the old termios settings */ 123 }; 124 125 /* function prototypes for the Cypress USB to serial device */ 126 static int cypress_earthmate_startup(struct usb_serial *serial); 127 static int cypress_hidcom_startup(struct usb_serial *serial); 128 static int cypress_ca42v2_startup(struct usb_serial *serial); 129 static void cypress_release(struct usb_serial *serial); 130 static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port); 131 static void cypress_close(struct usb_serial_port *port); 132 static void cypress_dtr_rts(struct usb_serial_port *port, int on); 133 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 134 const unsigned char *buf, int count); 135 static void cypress_send(struct usb_serial_port *port); 136 static int cypress_write_room(struct tty_struct *tty); 137 static int cypress_ioctl(struct tty_struct *tty, 138 unsigned int cmd, unsigned long arg); 139 static void cypress_set_termios(struct tty_struct *tty, 140 struct usb_serial_port *port, struct ktermios *old); 141 static int cypress_tiocmget(struct tty_struct *tty); 142 static int cypress_tiocmset(struct tty_struct *tty, 143 unsigned int set, unsigned int clear); 144 static int cypress_chars_in_buffer(struct tty_struct *tty); 145 static void cypress_throttle(struct tty_struct *tty); 146 static void cypress_unthrottle(struct tty_struct *tty); 147 static void cypress_set_dead(struct usb_serial_port *port); 148 static void cypress_read_int_callback(struct urb *urb); 149 static void cypress_write_int_callback(struct urb *urb); 150 151 static struct usb_serial_driver cypress_earthmate_device = { 152 .driver = { 153 .owner = THIS_MODULE, 154 .name = "earthmate", 155 }, 156 .description = "DeLorme Earthmate USB", 157 .id_table = id_table_earthmate, 158 .num_ports = 1, 159 .attach = cypress_earthmate_startup, 160 .release = cypress_release, 161 .open = cypress_open, 162 .close = cypress_close, 163 .dtr_rts = cypress_dtr_rts, 164 .write = cypress_write, 165 .write_room = cypress_write_room, 166 .ioctl = cypress_ioctl, 167 .set_termios = cypress_set_termios, 168 .tiocmget = cypress_tiocmget, 169 .tiocmset = cypress_tiocmset, 170 .chars_in_buffer = cypress_chars_in_buffer, 171 .throttle = cypress_throttle, 172 .unthrottle = cypress_unthrottle, 173 .read_int_callback = cypress_read_int_callback, 174 .write_int_callback = cypress_write_int_callback, 175 }; 176 177 static struct usb_serial_driver cypress_hidcom_device = { 178 .driver = { 179 .owner = THIS_MODULE, 180 .name = "cyphidcom", 181 }, 182 .description = "HID->COM RS232 Adapter", 183 .id_table = id_table_cyphidcomrs232, 184 .num_ports = 1, 185 .attach = cypress_hidcom_startup, 186 .release = cypress_release, 187 .open = cypress_open, 188 .close = cypress_close, 189 .dtr_rts = cypress_dtr_rts, 190 .write = cypress_write, 191 .write_room = cypress_write_room, 192 .ioctl = cypress_ioctl, 193 .set_termios = cypress_set_termios, 194 .tiocmget = cypress_tiocmget, 195 .tiocmset = cypress_tiocmset, 196 .chars_in_buffer = cypress_chars_in_buffer, 197 .throttle = cypress_throttle, 198 .unthrottle = cypress_unthrottle, 199 .read_int_callback = cypress_read_int_callback, 200 .write_int_callback = cypress_write_int_callback, 201 }; 202 203 static struct usb_serial_driver cypress_ca42v2_device = { 204 .driver = { 205 .owner = THIS_MODULE, 206 .name = "nokiaca42v2", 207 }, 208 .description = "Nokia CA-42 V2 Adapter", 209 .id_table = id_table_nokiaca42v2, 210 .num_ports = 1, 211 .attach = cypress_ca42v2_startup, 212 .release = cypress_release, 213 .open = cypress_open, 214 .close = cypress_close, 215 .dtr_rts = cypress_dtr_rts, 216 .write = cypress_write, 217 .write_room = cypress_write_room, 218 .ioctl = cypress_ioctl, 219 .set_termios = cypress_set_termios, 220 .tiocmget = cypress_tiocmget, 221 .tiocmset = cypress_tiocmset, 222 .chars_in_buffer = cypress_chars_in_buffer, 223 .throttle = cypress_throttle, 224 .unthrottle = cypress_unthrottle, 225 .read_int_callback = cypress_read_int_callback, 226 .write_int_callback = cypress_write_int_callback, 227 }; 228 229 static struct usb_serial_driver * const serial_drivers[] = { 230 &cypress_earthmate_device, &cypress_hidcom_device, 231 &cypress_ca42v2_device, NULL 232 }; 233 234 /***************************************************************************** 235 * Cypress serial helper functions 236 *****************************************************************************/ 237 238 239 static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate) 240 { 241 struct cypress_private *priv; 242 priv = usb_get_serial_port_data(port); 243 244 if (unstable_bauds) 245 return new_rate; 246 247 /* 248 * The general purpose firmware for the Cypress M8 allows for 249 * a maximum speed of 57600bps (I have no idea whether DeLorme 250 * chose to use the general purpose firmware or not), if you 251 * need to modify this speed setting for your own project 252 * please add your own chiptype and modify the code likewise. 253 * The Cypress HID->COM device will work successfully up to 254 * 115200bps (but the actual throughput is around 3kBps). 255 */ 256 if (port->serial->dev->speed == USB_SPEED_LOW) { 257 /* 258 * Mike Isely <isely@pobox.com> 2-Feb-2008: The 259 * Cypress app note that describes this mechanism 260 * states the the low-speed part can't handle more 261 * than 800 bytes/sec, in which case 4800 baud is the 262 * safest speed for a part like that. 263 */ 264 if (new_rate > 4800) { 265 dev_dbg(&port->dev, 266 "%s - failed setting baud rate, device incapable speed %d\n", 267 __func__, new_rate); 268 return -1; 269 } 270 } 271 switch (priv->chiptype) { 272 case CT_EARTHMATE: 273 if (new_rate <= 600) { 274 /* 300 and 600 baud rates are supported under 275 * the generic firmware, but are not used with 276 * NMEA and SiRF protocols */ 277 dev_dbg(&port->dev, 278 "%s - failed setting baud rate, unsupported speed of %d on Earthmate GPS", 279 __func__, new_rate); 280 return -1; 281 } 282 break; 283 default: 284 break; 285 } 286 return new_rate; 287 } 288 289 290 /* This function can either set or retrieve the current serial line settings */ 291 static int cypress_serial_control(struct tty_struct *tty, 292 struct usb_serial_port *port, speed_t baud_rate, int data_bits, 293 int stop_bits, int parity_enable, int parity_type, int reset, 294 int cypress_request_type) 295 { 296 int new_baudrate = 0, retval = 0, tries = 0; 297 struct cypress_private *priv; 298 struct device *dev = &port->dev; 299 u8 *feature_buffer; 300 const unsigned int feature_len = 5; 301 unsigned long flags; 302 303 priv = usb_get_serial_port_data(port); 304 305 if (!priv->comm_is_ok) 306 return -ENODEV; 307 308 feature_buffer = kcalloc(feature_len, sizeof(u8), GFP_KERNEL); 309 if (!feature_buffer) 310 return -ENOMEM; 311 312 switch (cypress_request_type) { 313 case CYPRESS_SET_CONFIG: 314 /* 0 means 'Hang up' so doesn't change the true bit rate */ 315 new_baudrate = priv->baud_rate; 316 if (baud_rate && baud_rate != priv->baud_rate) { 317 dev_dbg(dev, "%s - baud rate is changing\n", __func__); 318 retval = analyze_baud_rate(port, baud_rate); 319 if (retval >= 0) { 320 new_baudrate = retval; 321 dev_dbg(dev, "%s - New baud rate set to %d\n", 322 __func__, new_baudrate); 323 } 324 } 325 dev_dbg(dev, "%s - baud rate is being sent as %d\n", __func__, 326 new_baudrate); 327 328 /* fill the feature_buffer with new configuration */ 329 put_unaligned_le32(new_baudrate, feature_buffer); 330 feature_buffer[4] |= data_bits; /* assign data bits in 2 bit space ( max 3 ) */ 331 /* 1 bit gap */ 332 feature_buffer[4] |= (stop_bits << 3); /* assign stop bits in 1 bit space */ 333 feature_buffer[4] |= (parity_enable << 4); /* assign parity flag in 1 bit space */ 334 feature_buffer[4] |= (parity_type << 5); /* assign parity type in 1 bit space */ 335 /* 1 bit gap */ 336 feature_buffer[4] |= (reset << 7); /* assign reset at end of byte, 1 bit space */ 337 338 dev_dbg(dev, "%s - device is being sent this feature report:\n", __func__); 339 dev_dbg(dev, "%s - %02X - %02X - %02X - %02X - %02X\n", __func__, 340 feature_buffer[0], feature_buffer[1], 341 feature_buffer[2], feature_buffer[3], 342 feature_buffer[4]); 343 344 do { 345 retval = usb_control_msg(port->serial->dev, 346 usb_sndctrlpipe(port->serial->dev, 0), 347 HID_REQ_SET_REPORT, 348 USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 349 0x0300, 0, feature_buffer, 350 feature_len, 500); 351 352 if (tries++ >= 3) 353 break; 354 355 } while (retval != feature_len && 356 retval != -ENODEV); 357 358 if (retval != feature_len) { 359 dev_err(dev, "%s - failed sending serial line settings - %d\n", 360 __func__, retval); 361 cypress_set_dead(port); 362 } else { 363 spin_lock_irqsave(&priv->lock, flags); 364 priv->baud_rate = new_baudrate; 365 priv->current_config = feature_buffer[4]; 366 spin_unlock_irqrestore(&priv->lock, flags); 367 /* If we asked for a speed change encode it */ 368 if (baud_rate) 369 tty_encode_baud_rate(tty, 370 new_baudrate, new_baudrate); 371 } 372 break; 373 case CYPRESS_GET_CONFIG: 374 if (priv->get_cfg_unsafe) { 375 /* Not implemented for this device, 376 and if we try to do it we're likely 377 to crash the hardware. */ 378 retval = -ENOTTY; 379 goto out; 380 } 381 dev_dbg(dev, "%s - retreiving serial line settings\n", __func__); 382 do { 383 retval = usb_control_msg(port->serial->dev, 384 usb_rcvctrlpipe(port->serial->dev, 0), 385 HID_REQ_GET_REPORT, 386 USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 387 0x0300, 0, feature_buffer, 388 feature_len, 500); 389 390 if (tries++ >= 3) 391 break; 392 } while (retval != feature_len 393 && retval != -ENODEV); 394 395 if (retval != feature_len) { 396 dev_err(dev, "%s - failed to retrieve serial line settings - %d\n", 397 __func__, retval); 398 cypress_set_dead(port); 399 goto out; 400 } else { 401 spin_lock_irqsave(&priv->lock, flags); 402 /* store the config in one byte, and later 403 use bit masks to check values */ 404 priv->current_config = feature_buffer[4]; 405 priv->baud_rate = get_unaligned_le32(feature_buffer); 406 spin_unlock_irqrestore(&priv->lock, flags); 407 } 408 } 409 spin_lock_irqsave(&priv->lock, flags); 410 ++priv->cmd_count; 411 spin_unlock_irqrestore(&priv->lock, flags); 412 out: 413 kfree(feature_buffer); 414 return retval; 415 } /* cypress_serial_control */ 416 417 418 static void cypress_set_dead(struct usb_serial_port *port) 419 { 420 struct cypress_private *priv = usb_get_serial_port_data(port); 421 unsigned long flags; 422 423 spin_lock_irqsave(&priv->lock, flags); 424 if (!priv->comm_is_ok) { 425 spin_unlock_irqrestore(&priv->lock, flags); 426 return; 427 } 428 priv->comm_is_ok = 0; 429 spin_unlock_irqrestore(&priv->lock, flags); 430 431 dev_err(&port->dev, "cypress_m8 suspending failing port %d - " 432 "interval might be too short\n", port->number); 433 } 434 435 436 /***************************************************************************** 437 * Cypress serial driver functions 438 *****************************************************************************/ 439 440 441 static int generic_startup(struct usb_serial *serial) 442 { 443 struct cypress_private *priv; 444 struct usb_serial_port *port = serial->port[0]; 445 446 priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL); 447 if (!priv) 448 return -ENOMEM; 449 450 priv->comm_is_ok = !0; 451 spin_lock_init(&priv->lock); 452 if (kfifo_alloc(&priv->write_fifo, CYPRESS_BUF_SIZE, GFP_KERNEL)) { 453 kfree(priv); 454 return -ENOMEM; 455 } 456 init_waitqueue_head(&priv->delta_msr_wait); 457 458 usb_reset_configuration(serial->dev); 459 460 priv->cmd_ctrl = 0; 461 priv->line_control = 0; 462 priv->termios_initialized = 0; 463 priv->rx_flags = 0; 464 /* Default packet format setting is determined by packet size. 465 Anything with a size larger then 9 must have a separate 466 count field since the 3 bit count field is otherwise too 467 small. Otherwise we can use the slightly more compact 468 format. This is in accordance with the cypress_m8 serial 469 converter app note. */ 470 if (port->interrupt_out_size > 9) 471 priv->pkt_fmt = packet_format_1; 472 else 473 priv->pkt_fmt = packet_format_2; 474 475 if (interval > 0) { 476 priv->write_urb_interval = interval; 477 priv->read_urb_interval = interval; 478 dev_dbg(&port->dev, "%s - read & write intervals forced to %d\n", 479 __func__, interval); 480 } else { 481 priv->write_urb_interval = port->interrupt_out_urb->interval; 482 priv->read_urb_interval = port->interrupt_in_urb->interval; 483 dev_dbg(&port->dev, "%s - intervals: read=%d write=%d\n", 484 __func__, priv->read_urb_interval, 485 priv->write_urb_interval); 486 } 487 usb_set_serial_port_data(port, priv); 488 489 return 0; 490 } 491 492 493 static int cypress_earthmate_startup(struct usb_serial *serial) 494 { 495 struct cypress_private *priv; 496 struct usb_serial_port *port = serial->port[0]; 497 498 if (generic_startup(serial)) { 499 dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__); 500 return 1; 501 } 502 503 priv = usb_get_serial_port_data(port); 504 priv->chiptype = CT_EARTHMATE; 505 /* All Earthmate devices use the separated-count packet 506 format! Idiotic. */ 507 priv->pkt_fmt = packet_format_1; 508 if (serial->dev->descriptor.idProduct != 509 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB)) { 510 /* The old original USB Earthmate seemed able to 511 handle GET_CONFIG requests; everything they've 512 produced since that time crashes if this command is 513 attempted :-( */ 514 dev_dbg(&port->dev, 515 "%s - Marking this device as unsafe for GET_CONFIG commands\n", 516 __func__); 517 priv->get_cfg_unsafe = !0; 518 } 519 520 return 0; 521 } /* cypress_earthmate_startup */ 522 523 524 static int cypress_hidcom_startup(struct usb_serial *serial) 525 { 526 struct cypress_private *priv; 527 struct usb_serial_port *port = serial->port[0]; 528 529 if (generic_startup(serial)) { 530 dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__); 531 return 1; 532 } 533 534 priv = usb_get_serial_port_data(port); 535 priv->chiptype = CT_CYPHIDCOM; 536 537 return 0; 538 } /* cypress_hidcom_startup */ 539 540 541 static int cypress_ca42v2_startup(struct usb_serial *serial) 542 { 543 struct cypress_private *priv; 544 struct usb_serial_port *port = serial->port[0]; 545 546 if (generic_startup(serial)) { 547 dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__); 548 return 1; 549 } 550 551 priv = usb_get_serial_port_data(port); 552 priv->chiptype = CT_CA42V2; 553 554 return 0; 555 } /* cypress_ca42v2_startup */ 556 557 558 static void cypress_release(struct usb_serial *serial) 559 { 560 struct cypress_private *priv; 561 562 /* all open ports are closed at this point */ 563 priv = usb_get_serial_port_data(serial->port[0]); 564 565 if (priv) { 566 kfifo_free(&priv->write_fifo); 567 kfree(priv); 568 } 569 } 570 571 572 static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port) 573 { 574 struct cypress_private *priv = usb_get_serial_port_data(port); 575 struct usb_serial *serial = port->serial; 576 unsigned long flags; 577 int result = 0; 578 579 if (!priv->comm_is_ok) 580 return -EIO; 581 582 /* clear halts before open */ 583 usb_clear_halt(serial->dev, 0x81); 584 usb_clear_halt(serial->dev, 0x02); 585 586 spin_lock_irqsave(&priv->lock, flags); 587 /* reset read/write statistics */ 588 priv->bytes_in = 0; 589 priv->bytes_out = 0; 590 priv->cmd_count = 0; 591 priv->rx_flags = 0; 592 spin_unlock_irqrestore(&priv->lock, flags); 593 594 /* Set termios */ 595 cypress_send(port); 596 597 if (tty) 598 cypress_set_termios(tty, port, &priv->tmp_termios); 599 600 /* setup the port and start reading from the device */ 601 if (!port->interrupt_in_urb) { 602 dev_err(&port->dev, "%s - interrupt_in_urb is empty!\n", 603 __func__); 604 return -1; 605 } 606 607 usb_fill_int_urb(port->interrupt_in_urb, serial->dev, 608 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress), 609 port->interrupt_in_urb->transfer_buffer, 610 port->interrupt_in_urb->transfer_buffer_length, 611 cypress_read_int_callback, port, priv->read_urb_interval); 612 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 613 614 if (result) { 615 dev_err(&port->dev, 616 "%s - failed submitting read urb, error %d\n", 617 __func__, result); 618 cypress_set_dead(port); 619 } 620 port->port.drain_delay = 256; 621 return result; 622 } /* cypress_open */ 623 624 static void cypress_dtr_rts(struct usb_serial_port *port, int on) 625 { 626 struct cypress_private *priv = usb_get_serial_port_data(port); 627 /* drop dtr and rts */ 628 spin_lock_irq(&priv->lock); 629 if (on == 0) 630 priv->line_control = 0; 631 else 632 priv->line_control = CONTROL_DTR | CONTROL_RTS; 633 priv->cmd_ctrl = 1; 634 spin_unlock_irq(&priv->lock); 635 cypress_write(NULL, port, NULL, 0); 636 } 637 638 static void cypress_close(struct usb_serial_port *port) 639 { 640 struct cypress_private *priv = usb_get_serial_port_data(port); 641 unsigned long flags; 642 643 /* writing is potentially harmful, lock must be taken */ 644 mutex_lock(&port->serial->disc_mutex); 645 if (port->serial->disconnected) { 646 mutex_unlock(&port->serial->disc_mutex); 647 return; 648 } 649 spin_lock_irqsave(&priv->lock, flags); 650 kfifo_reset_out(&priv->write_fifo); 651 spin_unlock_irqrestore(&priv->lock, flags); 652 653 dev_dbg(&port->dev, "%s - stopping urbs\n", __func__); 654 usb_kill_urb(port->interrupt_in_urb); 655 usb_kill_urb(port->interrupt_out_urb); 656 657 if (stats) 658 dev_info(&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n", 659 priv->bytes_in, priv->bytes_out, priv->cmd_count); 660 mutex_unlock(&port->serial->disc_mutex); 661 } /* cypress_close */ 662 663 664 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 665 const unsigned char *buf, int count) 666 { 667 struct cypress_private *priv = usb_get_serial_port_data(port); 668 669 dev_dbg(&port->dev, "%s - port %d, %d bytes\n", __func__, port->number, count); 670 671 /* line control commands, which need to be executed immediately, 672 are not put into the buffer for obvious reasons. 673 */ 674 if (priv->cmd_ctrl) { 675 count = 0; 676 goto finish; 677 } 678 679 if (!count) 680 return count; 681 682 count = kfifo_in_locked(&priv->write_fifo, buf, count, &priv->lock); 683 684 finish: 685 cypress_send(port); 686 687 return count; 688 } /* cypress_write */ 689 690 691 static void cypress_send(struct usb_serial_port *port) 692 { 693 int count = 0, result, offset, actual_size; 694 struct cypress_private *priv = usb_get_serial_port_data(port); 695 struct device *dev = &port->dev; 696 unsigned long flags; 697 698 if (!priv->comm_is_ok) 699 return; 700 701 dev_dbg(dev, "%s - interrupt out size is %d\n", __func__, 702 port->interrupt_out_size); 703 704 spin_lock_irqsave(&priv->lock, flags); 705 if (priv->write_urb_in_use) { 706 dev_dbg(dev, "%s - can't write, urb in use\n", __func__); 707 spin_unlock_irqrestore(&priv->lock, flags); 708 return; 709 } 710 spin_unlock_irqrestore(&priv->lock, flags); 711 712 /* clear buffer */ 713 memset(port->interrupt_out_urb->transfer_buffer, 0, 714 port->interrupt_out_size); 715 716 spin_lock_irqsave(&priv->lock, flags); 717 switch (priv->pkt_fmt) { 718 default: 719 case packet_format_1: 720 /* this is for the CY7C64013... */ 721 offset = 2; 722 port->interrupt_out_buffer[0] = priv->line_control; 723 break; 724 case packet_format_2: 725 /* this is for the CY7C63743... */ 726 offset = 1; 727 port->interrupt_out_buffer[0] = priv->line_control; 728 break; 729 } 730 731 if (priv->line_control & CONTROL_RESET) 732 priv->line_control &= ~CONTROL_RESET; 733 734 if (priv->cmd_ctrl) { 735 priv->cmd_count++; 736 dev_dbg(dev, "%s - line control command being issued\n", __func__); 737 spin_unlock_irqrestore(&priv->lock, flags); 738 goto send; 739 } else 740 spin_unlock_irqrestore(&priv->lock, flags); 741 742 count = kfifo_out_locked(&priv->write_fifo, 743 &port->interrupt_out_buffer[offset], 744 port->interrupt_out_size - offset, 745 &priv->lock); 746 if (count == 0) 747 return; 748 749 switch (priv->pkt_fmt) { 750 default: 751 case packet_format_1: 752 port->interrupt_out_buffer[1] = count; 753 break; 754 case packet_format_2: 755 port->interrupt_out_buffer[0] |= count; 756 } 757 758 dev_dbg(dev, "%s - count is %d\n", __func__, count); 759 760 send: 761 spin_lock_irqsave(&priv->lock, flags); 762 priv->write_urb_in_use = 1; 763 spin_unlock_irqrestore(&priv->lock, flags); 764 765 if (priv->cmd_ctrl) 766 actual_size = 1; 767 else 768 actual_size = count + 769 (priv->pkt_fmt == packet_format_1 ? 2 : 1); 770 771 usb_serial_debug_data(dev, __func__, port->interrupt_out_size, 772 port->interrupt_out_urb->transfer_buffer); 773 774 usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev, 775 usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress), 776 port->interrupt_out_buffer, port->interrupt_out_size, 777 cypress_write_int_callback, port, priv->write_urb_interval); 778 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC); 779 if (result) { 780 dev_err_console(port, 781 "%s - failed submitting write urb, error %d\n", 782 __func__, result); 783 priv->write_urb_in_use = 0; 784 cypress_set_dead(port); 785 } 786 787 spin_lock_irqsave(&priv->lock, flags); 788 if (priv->cmd_ctrl) 789 priv->cmd_ctrl = 0; 790 791 /* do not count the line control and size bytes */ 792 priv->bytes_out += count; 793 spin_unlock_irqrestore(&priv->lock, flags); 794 795 usb_serial_port_softint(port); 796 } /* cypress_send */ 797 798 799 /* returns how much space is available in the soft buffer */ 800 static int cypress_write_room(struct tty_struct *tty) 801 { 802 struct usb_serial_port *port = tty->driver_data; 803 struct cypress_private *priv = usb_get_serial_port_data(port); 804 int room = 0; 805 unsigned long flags; 806 807 spin_lock_irqsave(&priv->lock, flags); 808 room = kfifo_avail(&priv->write_fifo); 809 spin_unlock_irqrestore(&priv->lock, flags); 810 811 dev_dbg(&port->dev, "%s - returns %d\n", __func__, room); 812 return room; 813 } 814 815 816 static int cypress_tiocmget(struct tty_struct *tty) 817 { 818 struct usb_serial_port *port = tty->driver_data; 819 struct cypress_private *priv = usb_get_serial_port_data(port); 820 __u8 status, control; 821 unsigned int result = 0; 822 unsigned long flags; 823 824 spin_lock_irqsave(&priv->lock, flags); 825 control = priv->line_control; 826 status = priv->current_status; 827 spin_unlock_irqrestore(&priv->lock, flags); 828 829 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0) 830 | ((control & CONTROL_RTS) ? TIOCM_RTS : 0) 831 | ((status & UART_CTS) ? TIOCM_CTS : 0) 832 | ((status & UART_DSR) ? TIOCM_DSR : 0) 833 | ((status & UART_RI) ? TIOCM_RI : 0) 834 | ((status & UART_CD) ? TIOCM_CD : 0); 835 836 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 837 838 return result; 839 } 840 841 842 static int cypress_tiocmset(struct tty_struct *tty, 843 unsigned int set, unsigned int clear) 844 { 845 struct usb_serial_port *port = tty->driver_data; 846 struct cypress_private *priv = usb_get_serial_port_data(port); 847 unsigned long flags; 848 849 spin_lock_irqsave(&priv->lock, flags); 850 if (set & TIOCM_RTS) 851 priv->line_control |= CONTROL_RTS; 852 if (set & TIOCM_DTR) 853 priv->line_control |= CONTROL_DTR; 854 if (clear & TIOCM_RTS) 855 priv->line_control &= ~CONTROL_RTS; 856 if (clear & TIOCM_DTR) 857 priv->line_control &= ~CONTROL_DTR; 858 priv->cmd_ctrl = 1; 859 spin_unlock_irqrestore(&priv->lock, flags); 860 861 return cypress_write(tty, port, NULL, 0); 862 } 863 864 865 static int cypress_ioctl(struct tty_struct *tty, 866 unsigned int cmd, unsigned long arg) 867 { 868 struct usb_serial_port *port = tty->driver_data; 869 struct cypress_private *priv = usb_get_serial_port_data(port); 870 871 dev_dbg(&port->dev, "%s - port %d, cmd 0x%.4x\n", __func__, port->number, cmd); 872 873 switch (cmd) { 874 /* This code comes from drivers/char/serial.c and ftdi_sio.c */ 875 case TIOCMIWAIT: 876 while (priv != NULL) { 877 interruptible_sleep_on(&priv->delta_msr_wait); 878 /* see if a signal did it */ 879 if (signal_pending(current)) 880 return -ERESTARTSYS; 881 else { 882 char diff = priv->diff_status; 883 if (diff == 0) 884 return -EIO; /* no change => error */ 885 886 /* consume all events */ 887 priv->diff_status = 0; 888 889 /* return 0 if caller wanted to know about 890 these bits */ 891 if (((arg & TIOCM_RNG) && (diff & UART_RI)) || 892 ((arg & TIOCM_DSR) && (diff & UART_DSR)) || 893 ((arg & TIOCM_CD) && (diff & UART_CD)) || 894 ((arg & TIOCM_CTS) && (diff & UART_CTS))) 895 return 0; 896 /* otherwise caller can't care less about what 897 * happened, and so we continue to wait for 898 * more events. 899 */ 900 } 901 } 902 return 0; 903 default: 904 break; 905 } 906 dev_dbg(&port->dev, "%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h\n", __func__, cmd); 907 return -ENOIOCTLCMD; 908 } /* cypress_ioctl */ 909 910 911 static void cypress_set_termios(struct tty_struct *tty, 912 struct usb_serial_port *port, struct ktermios *old_termios) 913 { 914 struct cypress_private *priv = usb_get_serial_port_data(port); 915 struct device *dev = &port->dev; 916 int data_bits, stop_bits, parity_type, parity_enable; 917 unsigned cflag, iflag; 918 unsigned long flags; 919 __u8 oldlines; 920 int linechange = 0; 921 922 spin_lock_irqsave(&priv->lock, flags); 923 /* We can't clean this one up as we don't know the device type 924 early enough */ 925 if (!priv->termios_initialized) { 926 if (priv->chiptype == CT_EARTHMATE) { 927 tty->termios = tty_std_termios; 928 tty->termios.c_cflag = B4800 | CS8 | CREAD | HUPCL | 929 CLOCAL; 930 tty->termios.c_ispeed = 4800; 931 tty->termios.c_ospeed = 4800; 932 } else if (priv->chiptype == CT_CYPHIDCOM) { 933 tty->termios = tty_std_termios; 934 tty->termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | 935 CLOCAL; 936 tty->termios.c_ispeed = 9600; 937 tty->termios.c_ospeed = 9600; 938 } else if (priv->chiptype == CT_CA42V2) { 939 tty->termios = tty_std_termios; 940 tty->termios.c_cflag = B9600 | CS8 | CREAD | HUPCL | 941 CLOCAL; 942 tty->termios.c_ispeed = 9600; 943 tty->termios.c_ospeed = 9600; 944 } 945 priv->termios_initialized = 1; 946 } 947 spin_unlock_irqrestore(&priv->lock, flags); 948 949 /* Unsupported features need clearing */ 950 tty->termios.c_cflag &= ~(CMSPAR|CRTSCTS); 951 952 cflag = tty->termios.c_cflag; 953 iflag = tty->termios.c_iflag; 954 955 /* check if there are new settings */ 956 if (old_termios) { 957 spin_lock_irqsave(&priv->lock, flags); 958 priv->tmp_termios = tty->termios; 959 spin_unlock_irqrestore(&priv->lock, flags); 960 } 961 962 /* set number of data bits, parity, stop bits */ 963 /* when parity is disabled the parity type bit is ignored */ 964 965 /* 1 means 2 stop bits, 0 means 1 stop bit */ 966 stop_bits = cflag & CSTOPB ? 1 : 0; 967 968 if (cflag & PARENB) { 969 parity_enable = 1; 970 /* 1 means odd parity, 0 means even parity */ 971 parity_type = cflag & PARODD ? 1 : 0; 972 } else 973 parity_enable = parity_type = 0; 974 975 switch (cflag & CSIZE) { 976 case CS5: 977 data_bits = 0; 978 break; 979 case CS6: 980 data_bits = 1; 981 break; 982 case CS7: 983 data_bits = 2; 984 break; 985 case CS8: 986 data_bits = 3; 987 break; 988 default: 989 dev_err(dev, "%s - CSIZE was set, but not CS5-CS8\n", __func__); 990 data_bits = 3; 991 } 992 spin_lock_irqsave(&priv->lock, flags); 993 oldlines = priv->line_control; 994 if ((cflag & CBAUD) == B0) { 995 /* drop dtr and rts */ 996 dev_dbg(dev, "%s - dropping the lines, baud rate 0bps\n", __func__); 997 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS); 998 } else 999 priv->line_control = (CONTROL_DTR | CONTROL_RTS); 1000 spin_unlock_irqrestore(&priv->lock, flags); 1001 1002 dev_dbg(dev, "%s - sending %d stop_bits, %d parity_enable, %d parity_type, %d data_bits (+5)\n", 1003 __func__, stop_bits, parity_enable, parity_type, data_bits); 1004 1005 cypress_serial_control(tty, port, tty_get_baud_rate(tty), 1006 data_bits, stop_bits, 1007 parity_enable, parity_type, 1008 0, CYPRESS_SET_CONFIG); 1009 1010 /* we perform a CYPRESS_GET_CONFIG so that the current settings are 1011 * filled into the private structure this should confirm that all is 1012 * working if it returns what we just set */ 1013 cypress_serial_control(tty, port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG); 1014 1015 /* Here we can define custom tty settings for devices; the main tty 1016 * termios flag base comes from empeg.c */ 1017 1018 spin_lock_irqsave(&priv->lock, flags); 1019 if (priv->chiptype == CT_EARTHMATE && priv->baud_rate == 4800) { 1020 dev_dbg(dev, "Using custom termios settings for a baud rate of 4800bps.\n"); 1021 /* define custom termios settings for NMEA protocol */ 1022 1023 tty->termios.c_iflag /* input modes - */ 1024 &= ~(IGNBRK /* disable ignore break */ 1025 | BRKINT /* disable break causes interrupt */ 1026 | PARMRK /* disable mark parity errors */ 1027 | ISTRIP /* disable clear high bit of input char */ 1028 | INLCR /* disable translate NL to CR */ 1029 | IGNCR /* disable ignore CR */ 1030 | ICRNL /* disable translate CR to NL */ 1031 | IXON); /* disable enable XON/XOFF flow control */ 1032 1033 tty->termios.c_oflag /* output modes */ 1034 &= ~OPOST; /* disable postprocess output char */ 1035 1036 tty->termios.c_lflag /* line discipline modes */ 1037 &= ~(ECHO /* disable echo input characters */ 1038 | ECHONL /* disable echo new line */ 1039 | ICANON /* disable erase, kill, werase, and rprnt 1040 special characters */ 1041 | ISIG /* disable interrupt, quit, and suspend 1042 special characters */ 1043 | IEXTEN); /* disable non-POSIX special characters */ 1044 } /* CT_CYPHIDCOM: Application should handle this for device */ 1045 1046 linechange = (priv->line_control != oldlines); 1047 spin_unlock_irqrestore(&priv->lock, flags); 1048 1049 /* if necessary, set lines */ 1050 if (linechange) { 1051 priv->cmd_ctrl = 1; 1052 cypress_write(tty, port, NULL, 0); 1053 } 1054 } /* cypress_set_termios */ 1055 1056 1057 /* returns amount of data still left in soft buffer */ 1058 static int cypress_chars_in_buffer(struct tty_struct *tty) 1059 { 1060 struct usb_serial_port *port = tty->driver_data; 1061 struct cypress_private *priv = usb_get_serial_port_data(port); 1062 int chars = 0; 1063 unsigned long flags; 1064 1065 spin_lock_irqsave(&priv->lock, flags); 1066 chars = kfifo_len(&priv->write_fifo); 1067 spin_unlock_irqrestore(&priv->lock, flags); 1068 1069 dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars); 1070 return chars; 1071 } 1072 1073 1074 static void cypress_throttle(struct tty_struct *tty) 1075 { 1076 struct usb_serial_port *port = tty->driver_data; 1077 struct cypress_private *priv = usb_get_serial_port_data(port); 1078 1079 spin_lock_irq(&priv->lock); 1080 priv->rx_flags = THROTTLED; 1081 spin_unlock_irq(&priv->lock); 1082 } 1083 1084 1085 static void cypress_unthrottle(struct tty_struct *tty) 1086 { 1087 struct usb_serial_port *port = tty->driver_data; 1088 struct cypress_private *priv = usb_get_serial_port_data(port); 1089 int actually_throttled, result; 1090 1091 spin_lock_irq(&priv->lock); 1092 actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED; 1093 priv->rx_flags = 0; 1094 spin_unlock_irq(&priv->lock); 1095 1096 if (!priv->comm_is_ok) 1097 return; 1098 1099 if (actually_throttled) { 1100 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 1101 if (result) { 1102 dev_err(&port->dev, "%s - failed submitting read urb, " 1103 "error %d\n", __func__, result); 1104 cypress_set_dead(port); 1105 } 1106 } 1107 } 1108 1109 1110 static void cypress_read_int_callback(struct urb *urb) 1111 { 1112 struct usb_serial_port *port = urb->context; 1113 struct cypress_private *priv = usb_get_serial_port_data(port); 1114 struct device *dev = &urb->dev->dev; 1115 struct tty_struct *tty; 1116 unsigned char *data = urb->transfer_buffer; 1117 unsigned long flags; 1118 char tty_flag = TTY_NORMAL; 1119 int havedata = 0; 1120 int bytes = 0; 1121 int result; 1122 int i = 0; 1123 int status = urb->status; 1124 1125 switch (status) { 1126 case 0: /* success */ 1127 break; 1128 case -ECONNRESET: 1129 case -ENOENT: 1130 case -ESHUTDOWN: 1131 /* precursor to disconnect so just go away */ 1132 return; 1133 case -EPIPE: 1134 /* Can't call usb_clear_halt while in_interrupt */ 1135 /* FALLS THROUGH */ 1136 default: 1137 /* something ugly is going on... */ 1138 dev_err(dev, "%s - unexpected nonzero read status received: %d\n", 1139 __func__, status); 1140 cypress_set_dead(port); 1141 return; 1142 } 1143 1144 spin_lock_irqsave(&priv->lock, flags); 1145 if (priv->rx_flags & THROTTLED) { 1146 dev_dbg(dev, "%s - now throttling\n", __func__); 1147 priv->rx_flags |= ACTUALLY_THROTTLED; 1148 spin_unlock_irqrestore(&priv->lock, flags); 1149 return; 1150 } 1151 spin_unlock_irqrestore(&priv->lock, flags); 1152 1153 tty = tty_port_tty_get(&port->port); 1154 if (!tty) { 1155 dev_dbg(dev, "%s - bad tty pointer - exiting\n", __func__); 1156 return; 1157 } 1158 1159 spin_lock_irqsave(&priv->lock, flags); 1160 result = urb->actual_length; 1161 switch (priv->pkt_fmt) { 1162 default: 1163 case packet_format_1: 1164 /* This is for the CY7C64013... */ 1165 priv->current_status = data[0] & 0xF8; 1166 bytes = data[1] + 2; 1167 i = 2; 1168 if (bytes > 2) 1169 havedata = 1; 1170 break; 1171 case packet_format_2: 1172 /* This is for the CY7C63743... */ 1173 priv->current_status = data[0] & 0xF8; 1174 bytes = (data[0] & 0x07) + 1; 1175 i = 1; 1176 if (bytes > 1) 1177 havedata = 1; 1178 break; 1179 } 1180 spin_unlock_irqrestore(&priv->lock, flags); 1181 if (result < bytes) { 1182 dev_dbg(dev, 1183 "%s - wrong packet size - received %d bytes but packet said %d bytes\n", 1184 __func__, result, bytes); 1185 goto continue_read; 1186 } 1187 1188 usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data); 1189 1190 spin_lock_irqsave(&priv->lock, flags); 1191 /* check to see if status has changed */ 1192 if (priv->current_status != priv->prev_status) { 1193 priv->diff_status |= priv->current_status ^ 1194 priv->prev_status; 1195 wake_up_interruptible(&priv->delta_msr_wait); 1196 priv->prev_status = priv->current_status; 1197 } 1198 spin_unlock_irqrestore(&priv->lock, flags); 1199 1200 /* hangup, as defined in acm.c... this might be a bad place for it 1201 * though */ 1202 if (tty && !(tty->termios.c_cflag & CLOCAL) && 1203 !(priv->current_status & UART_CD)) { 1204 dev_dbg(dev, "%s - calling hangup\n", __func__); 1205 tty_hangup(tty); 1206 goto continue_read; 1207 } 1208 1209 /* There is one error bit... I'm assuming it is a parity error 1210 * indicator as the generic firmware will set this bit to 1 if a 1211 * parity error occurs. 1212 * I can not find reference to any other error events. */ 1213 spin_lock_irqsave(&priv->lock, flags); 1214 if (priv->current_status & CYP_ERROR) { 1215 spin_unlock_irqrestore(&priv->lock, flags); 1216 tty_flag = TTY_PARITY; 1217 dev_dbg(dev, "%s - Parity Error detected\n", __func__); 1218 } else 1219 spin_unlock_irqrestore(&priv->lock, flags); 1220 1221 /* process read if there is data other than line status */ 1222 if (tty && bytes > i) { 1223 tty_insert_flip_string_fixed_flag(tty, data + i, 1224 tty_flag, bytes - i); 1225 tty_flip_buffer_push(tty); 1226 } 1227 1228 spin_lock_irqsave(&priv->lock, flags); 1229 /* control and status byte(s) are also counted */ 1230 priv->bytes_in += bytes; 1231 spin_unlock_irqrestore(&priv->lock, flags); 1232 1233 continue_read: 1234 tty_kref_put(tty); 1235 1236 /* Continue trying to always read */ 1237 1238 if (priv->comm_is_ok) { 1239 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev, 1240 usb_rcvintpipe(port->serial->dev, 1241 port->interrupt_in_endpointAddress), 1242 port->interrupt_in_urb->transfer_buffer, 1243 port->interrupt_in_urb->transfer_buffer_length, 1244 cypress_read_int_callback, port, 1245 priv->read_urb_interval); 1246 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC); 1247 if (result && result != -EPERM) { 1248 dev_err(dev, "%s - failed resubmitting read urb, error %d\n", 1249 __func__, result); 1250 cypress_set_dead(port); 1251 } 1252 } 1253 } /* cypress_read_int_callback */ 1254 1255 1256 static void cypress_write_int_callback(struct urb *urb) 1257 { 1258 struct usb_serial_port *port = urb->context; 1259 struct cypress_private *priv = usb_get_serial_port_data(port); 1260 struct device *dev = &urb->dev->dev; 1261 int result; 1262 int status = urb->status; 1263 1264 switch (status) { 1265 case 0: 1266 /* success */ 1267 break; 1268 case -ECONNRESET: 1269 case -ENOENT: 1270 case -ESHUTDOWN: 1271 /* this urb is terminated, clean up */ 1272 dev_dbg(dev, "%s - urb shutting down with status: %d\n", 1273 __func__, status); 1274 priv->write_urb_in_use = 0; 1275 return; 1276 case -EPIPE: /* no break needed; clear halt and resubmit */ 1277 if (!priv->comm_is_ok) 1278 break; 1279 usb_clear_halt(port->serial->dev, 0x02); 1280 /* error in the urb, so we have to resubmit it */ 1281 dev_dbg(dev, "%s - nonzero write bulk status received: %d\n", 1282 __func__, status); 1283 port->interrupt_out_urb->transfer_buffer_length = 1; 1284 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC); 1285 if (!result) 1286 return; 1287 dev_err(dev, "%s - failed resubmitting write urb, error %d\n", 1288 __func__, result); 1289 cypress_set_dead(port); 1290 break; 1291 default: 1292 dev_err(dev, "%s - unexpected nonzero write status received: %d\n", 1293 __func__, status); 1294 cypress_set_dead(port); 1295 break; 1296 } 1297 priv->write_urb_in_use = 0; 1298 1299 /* send any buffered data */ 1300 cypress_send(port); 1301 } 1302 1303 module_usb_serial_driver(serial_drivers, id_table_combined); 1304 1305 MODULE_AUTHOR(DRIVER_AUTHOR); 1306 MODULE_DESCRIPTION(DRIVER_DESC); 1307 MODULE_VERSION(DRIVER_VERSION); 1308 MODULE_LICENSE("GPL"); 1309 1310 module_param(stats, bool, S_IRUGO | S_IWUSR); 1311 MODULE_PARM_DESC(stats, "Enable statistics or not"); 1312 module_param(interval, int, S_IRUGO | S_IWUSR); 1313 MODULE_PARM_DESC(interval, "Overrides interrupt interval"); 1314 module_param(unstable_bauds, bool, S_IRUGO | S_IWUSR); 1315 MODULE_PARM_DESC(unstable_bauds, "Allow unstable baud rates"); 1316