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