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