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 { USB_DEVICE(VENDOR_ID_FRWD, PRODUCT_ID_CYPHIDCOM_FRWD) }, 69 { } /* Terminating entry */ 70 }; 71 72 static const struct usb_device_id id_table_nokiaca42v2[] = { 73 { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) }, 74 { } /* Terminating entry */ 75 }; 76 77 static const struct usb_device_id id_table_combined[] = { 78 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) }, 79 { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) }, 80 { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) }, 81 { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) }, 82 { USB_DEVICE(VENDOR_ID_FRWD, PRODUCT_ID_CYPHIDCOM_FRWD) }, 83 { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) }, 84 { } /* Terminating entry */ 85 }; 86 87 MODULE_DEVICE_TABLE(usb, id_table_combined); 88 89 enum packet_format { 90 packet_format_1, /* b0:status, b1:payload count */ 91 packet_format_2 /* b0[7:3]:status, b0[2:0]:payload count */ 92 }; 93 94 struct cypress_private { 95 spinlock_t lock; /* private lock */ 96 int chiptype; /* identifier of device, for quirks/etc */ 97 int bytes_in; /* used for statistics */ 98 int bytes_out; /* used for statistics */ 99 int cmd_count; /* used for statistics */ 100 int cmd_ctrl; /* always set this to 1 before issuing a command */ 101 struct kfifo write_fifo; /* write fifo */ 102 int write_urb_in_use; /* write urb in use indicator */ 103 int write_urb_interval; /* interval to use for write urb */ 104 int read_urb_interval; /* interval to use for read urb */ 105 int comm_is_ok; /* true if communication is (still) ok */ 106 int termios_initialized; 107 __u8 line_control; /* holds dtr / rts value */ 108 __u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */ 109 __u8 current_config; /* stores the current configuration byte */ 110 __u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */ 111 enum packet_format pkt_fmt; /* format to use for packet send / receive */ 112 int get_cfg_unsafe; /* If true, the CYPRESS_GET_CONFIG is unsafe */ 113 int baud_rate; /* stores current baud rate in 114 integer form */ 115 int isthrottled; /* if throttled, discard reads */ 116 char prev_status, diff_status; /* used for TIOCMIWAIT */ 117 /* we pass a pointer to this as the argument sent to 118 cypress_set_termios old_termios */ 119 struct ktermios tmp_termios; /* stores the old termios settings */ 120 }; 121 122 /* function prototypes for the Cypress USB to serial device */ 123 static int cypress_earthmate_port_probe(struct usb_serial_port *port); 124 static int cypress_hidcom_port_probe(struct usb_serial_port *port); 125 static int cypress_ca42v2_port_probe(struct usb_serial_port *port); 126 static int cypress_port_remove(struct usb_serial_port *port); 127 static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port); 128 static void cypress_close(struct usb_serial_port *port); 129 static void cypress_dtr_rts(struct usb_serial_port *port, int on); 130 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 131 const unsigned char *buf, int count); 132 static void cypress_send(struct usb_serial_port *port); 133 static int cypress_write_room(struct tty_struct *tty); 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_tiocmiwait(struct tty_struct *tty, unsigned long arg); 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 .set_termios = cypress_set_termios, 163 .tiocmget = cypress_tiocmget, 164 .tiocmset = cypress_tiocmset, 165 .tiocmiwait = cypress_tiocmiwait, 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 .set_termios = cypress_set_termios, 189 .tiocmget = cypress_tiocmget, 190 .tiocmset = cypress_tiocmset, 191 .tiocmiwait = cypress_tiocmiwait, 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 .set_termios = cypress_set_termios, 215 .tiocmget = cypress_tiocmget, 216 .tiocmset = cypress_tiocmset, 217 .tiocmiwait = cypress_tiocmiwait, 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 /* FRWD Dongle hidcom needs to skip reset and speed checks */ 235 static inline bool is_frwd(struct usb_device *dev) 236 { 237 return ((le16_to_cpu(dev->descriptor.idVendor) == VENDOR_ID_FRWD) && 238 (le16_to_cpu(dev->descriptor.idProduct) == PRODUCT_ID_CYPHIDCOM_FRWD)); 239 } 240 241 static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate) 242 { 243 struct cypress_private *priv; 244 priv = usb_get_serial_port_data(port); 245 246 if (unstable_bauds) 247 return new_rate; 248 249 /* FRWD Dongle uses 115200 bps */ 250 if (is_frwd(port->serial->dev)) 251 return new_rate; 252 253 /* 254 * The general purpose firmware for the Cypress M8 allows for 255 * a maximum speed of 57600bps (I have no idea whether DeLorme 256 * chose to use the general purpose firmware or not), if you 257 * need to modify this speed setting for your own project 258 * please add your own chiptype and modify the code likewise. 259 * The Cypress HID->COM device will work successfully up to 260 * 115200bps (but the actual throughput is around 3kBps). 261 */ 262 if (port->serial->dev->speed == USB_SPEED_LOW) { 263 /* 264 * Mike Isely <isely@pobox.com> 2-Feb-2008: The 265 * Cypress app note that describes this mechanism 266 * states the the low-speed part can't handle more 267 * than 800 bytes/sec, in which case 4800 baud is the 268 * safest speed for a part like that. 269 */ 270 if (new_rate > 4800) { 271 dev_dbg(&port->dev, 272 "%s - failed setting baud rate, device incapable speed %d\n", 273 __func__, new_rate); 274 return -1; 275 } 276 } 277 switch (priv->chiptype) { 278 case CT_EARTHMATE: 279 if (new_rate <= 600) { 280 /* 300 and 600 baud rates are supported under 281 * the generic firmware, but are not used with 282 * NMEA and SiRF protocols */ 283 dev_dbg(&port->dev, 284 "%s - failed setting baud rate, unsupported speed of %d on Earthmate GPS", 285 __func__, new_rate); 286 return -1; 287 } 288 break; 289 default: 290 break; 291 } 292 return new_rate; 293 } 294 295 296 /* This function can either set or retrieve the current serial line settings */ 297 static int cypress_serial_control(struct tty_struct *tty, 298 struct usb_serial_port *port, speed_t baud_rate, int data_bits, 299 int stop_bits, int parity_enable, int parity_type, int reset, 300 int cypress_request_type) 301 { 302 int new_baudrate = 0, retval = 0, tries = 0; 303 struct cypress_private *priv; 304 struct device *dev = &port->dev; 305 u8 *feature_buffer; 306 const unsigned int feature_len = 5; 307 unsigned long flags; 308 309 priv = usb_get_serial_port_data(port); 310 311 if (!priv->comm_is_ok) 312 return -ENODEV; 313 314 feature_buffer = kcalloc(feature_len, sizeof(u8), GFP_KERNEL); 315 if (!feature_buffer) 316 return -ENOMEM; 317 318 switch (cypress_request_type) { 319 case CYPRESS_SET_CONFIG: 320 /* 0 means 'Hang up' so doesn't change the true bit rate */ 321 new_baudrate = priv->baud_rate; 322 if (baud_rate && baud_rate != priv->baud_rate) { 323 dev_dbg(dev, "%s - baud rate is changing\n", __func__); 324 retval = analyze_baud_rate(port, baud_rate); 325 if (retval >= 0) { 326 new_baudrate = retval; 327 dev_dbg(dev, "%s - New baud rate set to %d\n", 328 __func__, new_baudrate); 329 } 330 } 331 dev_dbg(dev, "%s - baud rate is being sent as %d\n", __func__, 332 new_baudrate); 333 334 /* fill the feature_buffer with new configuration */ 335 put_unaligned_le32(new_baudrate, feature_buffer); 336 feature_buffer[4] |= data_bits; /* assign data bits in 2 bit space ( max 3 ) */ 337 /* 1 bit gap */ 338 feature_buffer[4] |= (stop_bits << 3); /* assign stop bits in 1 bit space */ 339 feature_buffer[4] |= (parity_enable << 4); /* assign parity flag in 1 bit space */ 340 feature_buffer[4] |= (parity_type << 5); /* assign parity type in 1 bit space */ 341 /* 1 bit gap */ 342 feature_buffer[4] |= (reset << 7); /* assign reset at end of byte, 1 bit space */ 343 344 dev_dbg(dev, "%s - device is being sent this feature report:\n", __func__); 345 dev_dbg(dev, "%s - %02X - %02X - %02X - %02X - %02X\n", __func__, 346 feature_buffer[0], feature_buffer[1], 347 feature_buffer[2], feature_buffer[3], 348 feature_buffer[4]); 349 350 do { 351 retval = usb_control_msg(port->serial->dev, 352 usb_sndctrlpipe(port->serial->dev, 0), 353 HID_REQ_SET_REPORT, 354 USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 355 0x0300, 0, feature_buffer, 356 feature_len, 500); 357 358 if (tries++ >= 3) 359 break; 360 361 } while (retval != feature_len && 362 retval != -ENODEV); 363 364 if (retval != feature_len) { 365 dev_err(dev, "%s - failed sending serial line settings - %d\n", 366 __func__, retval); 367 cypress_set_dead(port); 368 } else { 369 spin_lock_irqsave(&priv->lock, flags); 370 priv->baud_rate = new_baudrate; 371 priv->current_config = feature_buffer[4]; 372 spin_unlock_irqrestore(&priv->lock, flags); 373 /* If we asked for a speed change encode it */ 374 if (baud_rate) 375 tty_encode_baud_rate(tty, 376 new_baudrate, new_baudrate); 377 } 378 break; 379 case CYPRESS_GET_CONFIG: 380 if (priv->get_cfg_unsafe) { 381 /* Not implemented for this device, 382 and if we try to do it we're likely 383 to crash the hardware. */ 384 retval = -ENOTTY; 385 goto out; 386 } 387 dev_dbg(dev, "%s - retreiving serial line settings\n", __func__); 388 do { 389 retval = usb_control_msg(port->serial->dev, 390 usb_rcvctrlpipe(port->serial->dev, 0), 391 HID_REQ_GET_REPORT, 392 USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS, 393 0x0300, 0, feature_buffer, 394 feature_len, 500); 395 396 if (tries++ >= 3) 397 break; 398 } while (retval != feature_len 399 && retval != -ENODEV); 400 401 if (retval != feature_len) { 402 dev_err(dev, "%s - failed to retrieve serial line settings - %d\n", 403 __func__, retval); 404 cypress_set_dead(port); 405 goto out; 406 } else { 407 spin_lock_irqsave(&priv->lock, flags); 408 /* store the config in one byte, and later 409 use bit masks to check values */ 410 priv->current_config = feature_buffer[4]; 411 priv->baud_rate = get_unaligned_le32(feature_buffer); 412 spin_unlock_irqrestore(&priv->lock, flags); 413 } 414 } 415 spin_lock_irqsave(&priv->lock, flags); 416 ++priv->cmd_count; 417 spin_unlock_irqrestore(&priv->lock, flags); 418 out: 419 kfree(feature_buffer); 420 return retval; 421 } /* cypress_serial_control */ 422 423 424 static void cypress_set_dead(struct usb_serial_port *port) 425 { 426 struct cypress_private *priv = usb_get_serial_port_data(port); 427 unsigned long flags; 428 429 spin_lock_irqsave(&priv->lock, flags); 430 if (!priv->comm_is_ok) { 431 spin_unlock_irqrestore(&priv->lock, flags); 432 return; 433 } 434 priv->comm_is_ok = 0; 435 spin_unlock_irqrestore(&priv->lock, flags); 436 437 dev_err(&port->dev, "cypress_m8 suspending failing port %d - " 438 "interval might be too short\n", port->port_number); 439 } 440 441 442 /***************************************************************************** 443 * Cypress serial driver functions 444 *****************************************************************************/ 445 446 447 static int cypress_generic_port_probe(struct usb_serial_port *port) 448 { 449 struct usb_serial *serial = port->serial; 450 struct cypress_private *priv; 451 452 priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL); 453 if (!priv) 454 return -ENOMEM; 455 456 priv->comm_is_ok = !0; 457 spin_lock_init(&priv->lock); 458 if (kfifo_alloc(&priv->write_fifo, CYPRESS_BUF_SIZE, GFP_KERNEL)) { 459 kfree(priv); 460 return -ENOMEM; 461 } 462 463 /* Skip reset for FRWD device. It is a workaound: 464 device hangs if it receives SET_CONFIGURE in Configured 465 state. */ 466 if (!is_frwd(serial->dev)) 467 usb_reset_configuration(serial->dev); 468 469 priv->cmd_ctrl = 0; 470 priv->line_control = 0; 471 priv->termios_initialized = 0; 472 priv->rx_flags = 0; 473 /* Default packet format setting is determined by packet size. 474 Anything with a size larger then 9 must have a separate 475 count field since the 3 bit count field is otherwise too 476 small. Otherwise we can use the slightly more compact 477 format. This is in accordance with the cypress_m8 serial 478 converter app note. */ 479 if (port->interrupt_out_size > 9) 480 priv->pkt_fmt = packet_format_1; 481 else 482 priv->pkt_fmt = packet_format_2; 483 484 if (interval > 0) { 485 priv->write_urb_interval = interval; 486 priv->read_urb_interval = interval; 487 dev_dbg(&port->dev, "%s - read & write intervals forced to %d\n", 488 __func__, interval); 489 } else { 490 priv->write_urb_interval = port->interrupt_out_urb->interval; 491 priv->read_urb_interval = port->interrupt_in_urb->interval; 492 dev_dbg(&port->dev, "%s - intervals: read=%d write=%d\n", 493 __func__, priv->read_urb_interval, 494 priv->write_urb_interval); 495 } 496 usb_set_serial_port_data(port, priv); 497 498 port->port.drain_delay = 256; 499 500 return 0; 501 } 502 503 504 static int cypress_earthmate_port_probe(struct usb_serial_port *port) 505 { 506 struct usb_serial *serial = port->serial; 507 struct cypress_private *priv; 508 int ret; 509 510 ret = cypress_generic_port_probe(port); 511 if (ret) { 512 dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__); 513 return ret; 514 } 515 516 priv = usb_get_serial_port_data(port); 517 priv->chiptype = CT_EARTHMATE; 518 /* All Earthmate devices use the separated-count packet 519 format! Idiotic. */ 520 priv->pkt_fmt = packet_format_1; 521 if (serial->dev->descriptor.idProduct != 522 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB)) { 523 /* The old original USB Earthmate seemed able to 524 handle GET_CONFIG requests; everything they've 525 produced since that time crashes if this command is 526 attempted :-( */ 527 dev_dbg(&port->dev, 528 "%s - Marking this device as unsafe for GET_CONFIG commands\n", 529 __func__); 530 priv->get_cfg_unsafe = !0; 531 } 532 533 return 0; 534 } 535 536 static int cypress_hidcom_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_CYPHIDCOM; 549 550 return 0; 551 } 552 553 static int cypress_ca42v2_port_probe(struct usb_serial_port *port) 554 { 555 struct cypress_private *priv; 556 int ret; 557 558 ret = cypress_generic_port_probe(port); 559 if (ret) { 560 dev_dbg(&port->dev, "%s - Failed setting up port\n", __func__); 561 return ret; 562 } 563 564 priv = usb_get_serial_port_data(port); 565 priv->chiptype = CT_CA42V2; 566 567 return 0; 568 } 569 570 static int cypress_port_remove(struct usb_serial_port *port) 571 { 572 struct cypress_private *priv; 573 574 priv = usb_get_serial_port_data(port); 575 576 kfifo_free(&priv->write_fifo); 577 kfree(priv); 578 579 return 0; 580 } 581 582 static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port) 583 { 584 struct cypress_private *priv = usb_get_serial_port_data(port); 585 struct usb_serial *serial = port->serial; 586 unsigned long flags; 587 int result = 0; 588 589 if (!priv->comm_is_ok) 590 return -EIO; 591 592 /* clear halts before open */ 593 usb_clear_halt(serial->dev, 0x81); 594 usb_clear_halt(serial->dev, 0x02); 595 596 spin_lock_irqsave(&priv->lock, flags); 597 /* reset read/write statistics */ 598 priv->bytes_in = 0; 599 priv->bytes_out = 0; 600 priv->cmd_count = 0; 601 priv->rx_flags = 0; 602 spin_unlock_irqrestore(&priv->lock, flags); 603 604 /* Set termios */ 605 cypress_send(port); 606 607 if (tty) 608 cypress_set_termios(tty, port, &priv->tmp_termios); 609 610 /* setup the port and start reading from the device */ 611 if (!port->interrupt_in_urb) { 612 dev_err(&port->dev, "%s - interrupt_in_urb is empty!\n", 613 __func__); 614 return -1; 615 } 616 617 usb_fill_int_urb(port->interrupt_in_urb, serial->dev, 618 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress), 619 port->interrupt_in_urb->transfer_buffer, 620 port->interrupt_in_urb->transfer_buffer_length, 621 cypress_read_int_callback, port, priv->read_urb_interval); 622 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 623 624 if (result) { 625 dev_err(&port->dev, 626 "%s - failed submitting read urb, error %d\n", 627 __func__, result); 628 cypress_set_dead(port); 629 } 630 631 return result; 632 } /* cypress_open */ 633 634 static void cypress_dtr_rts(struct usb_serial_port *port, int on) 635 { 636 struct cypress_private *priv = usb_get_serial_port_data(port); 637 /* drop dtr and rts */ 638 spin_lock_irq(&priv->lock); 639 if (on == 0) 640 priv->line_control = 0; 641 else 642 priv->line_control = CONTROL_DTR | CONTROL_RTS; 643 priv->cmd_ctrl = 1; 644 spin_unlock_irq(&priv->lock); 645 cypress_write(NULL, port, NULL, 0); 646 } 647 648 static void cypress_close(struct usb_serial_port *port) 649 { 650 struct cypress_private *priv = usb_get_serial_port_data(port); 651 unsigned long flags; 652 653 spin_lock_irqsave(&priv->lock, flags); 654 kfifo_reset_out(&priv->write_fifo); 655 spin_unlock_irqrestore(&priv->lock, flags); 656 657 dev_dbg(&port->dev, "%s - stopping urbs\n", __func__); 658 usb_kill_urb(port->interrupt_in_urb); 659 usb_kill_urb(port->interrupt_out_urb); 660 661 if (stats) 662 dev_info(&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n", 663 priv->bytes_in, priv->bytes_out, priv->cmd_count); 664 } /* cypress_close */ 665 666 667 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port, 668 const unsigned char *buf, int count) 669 { 670 struct cypress_private *priv = usb_get_serial_port_data(port); 671 672 dev_dbg(&port->dev, "%s - %d bytes\n", __func__, count); 673 674 /* line control commands, which need to be executed immediately, 675 are not put into the buffer for obvious reasons. 676 */ 677 if (priv->cmd_ctrl) { 678 count = 0; 679 goto finish; 680 } 681 682 if (!count) 683 return count; 684 685 count = kfifo_in_locked(&priv->write_fifo, buf, count, &priv->lock); 686 687 finish: 688 cypress_send(port); 689 690 return count; 691 } /* cypress_write */ 692 693 694 static void cypress_send(struct usb_serial_port *port) 695 { 696 int count = 0, result, offset, actual_size; 697 struct cypress_private *priv = usb_get_serial_port_data(port); 698 struct device *dev = &port->dev; 699 unsigned long flags; 700 701 if (!priv->comm_is_ok) 702 return; 703 704 dev_dbg(dev, "%s - interrupt out size is %d\n", __func__, 705 port->interrupt_out_size); 706 707 spin_lock_irqsave(&priv->lock, flags); 708 if (priv->write_urb_in_use) { 709 dev_dbg(dev, "%s - can't write, urb in use\n", __func__); 710 spin_unlock_irqrestore(&priv->lock, flags); 711 return; 712 } 713 spin_unlock_irqrestore(&priv->lock, flags); 714 715 /* clear buffer */ 716 memset(port->interrupt_out_urb->transfer_buffer, 0, 717 port->interrupt_out_size); 718 719 spin_lock_irqsave(&priv->lock, flags); 720 switch (priv->pkt_fmt) { 721 default: 722 case packet_format_1: 723 /* this is for the CY7C64013... */ 724 offset = 2; 725 port->interrupt_out_buffer[0] = priv->line_control; 726 break; 727 case packet_format_2: 728 /* this is for the CY7C63743... */ 729 offset = 1; 730 port->interrupt_out_buffer[0] = priv->line_control; 731 break; 732 } 733 734 if (priv->line_control & CONTROL_RESET) 735 priv->line_control &= ~CONTROL_RESET; 736 737 if (priv->cmd_ctrl) { 738 priv->cmd_count++; 739 dev_dbg(dev, "%s - line control command being issued\n", __func__); 740 spin_unlock_irqrestore(&priv->lock, flags); 741 goto send; 742 } else 743 spin_unlock_irqrestore(&priv->lock, flags); 744 745 count = kfifo_out_locked(&priv->write_fifo, 746 &port->interrupt_out_buffer[offset], 747 port->interrupt_out_size - offset, 748 &priv->lock); 749 if (count == 0) 750 return; 751 752 switch (priv->pkt_fmt) { 753 default: 754 case packet_format_1: 755 port->interrupt_out_buffer[1] = count; 756 break; 757 case packet_format_2: 758 port->interrupt_out_buffer[0] |= count; 759 } 760 761 dev_dbg(dev, "%s - count is %d\n", __func__, count); 762 763 send: 764 spin_lock_irqsave(&priv->lock, flags); 765 priv->write_urb_in_use = 1; 766 spin_unlock_irqrestore(&priv->lock, flags); 767 768 if (priv->cmd_ctrl) 769 actual_size = 1; 770 else 771 actual_size = count + 772 (priv->pkt_fmt == packet_format_1 ? 2 : 1); 773 774 usb_serial_debug_data(dev, __func__, port->interrupt_out_size, 775 port->interrupt_out_urb->transfer_buffer); 776 777 usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev, 778 usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress), 779 port->interrupt_out_buffer, port->interrupt_out_size, 780 cypress_write_int_callback, port, priv->write_urb_interval); 781 result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC); 782 if (result) { 783 dev_err_console(port, 784 "%s - failed submitting write urb, error %d\n", 785 __func__, result); 786 priv->write_urb_in_use = 0; 787 cypress_set_dead(port); 788 } 789 790 spin_lock_irqsave(&priv->lock, flags); 791 if (priv->cmd_ctrl) 792 priv->cmd_ctrl = 0; 793 794 /* do not count the line control and size bytes */ 795 priv->bytes_out += count; 796 spin_unlock_irqrestore(&priv->lock, flags); 797 798 usb_serial_port_softint(port); 799 } /* cypress_send */ 800 801 802 /* returns how much space is available in the soft buffer */ 803 static int cypress_write_room(struct tty_struct *tty) 804 { 805 struct usb_serial_port *port = tty->driver_data; 806 struct cypress_private *priv = usb_get_serial_port_data(port); 807 int room = 0; 808 unsigned long flags; 809 810 spin_lock_irqsave(&priv->lock, flags); 811 room = kfifo_avail(&priv->write_fifo); 812 spin_unlock_irqrestore(&priv->lock, flags); 813 814 dev_dbg(&port->dev, "%s - returns %d\n", __func__, room); 815 return room; 816 } 817 818 819 static int cypress_tiocmget(struct tty_struct *tty) 820 { 821 struct usb_serial_port *port = tty->driver_data; 822 struct cypress_private *priv = usb_get_serial_port_data(port); 823 __u8 status, control; 824 unsigned int result = 0; 825 unsigned long flags; 826 827 spin_lock_irqsave(&priv->lock, flags); 828 control = priv->line_control; 829 status = priv->current_status; 830 spin_unlock_irqrestore(&priv->lock, flags); 831 832 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0) 833 | ((control & CONTROL_RTS) ? TIOCM_RTS : 0) 834 | ((status & UART_CTS) ? TIOCM_CTS : 0) 835 | ((status & UART_DSR) ? TIOCM_DSR : 0) 836 | ((status & UART_RI) ? TIOCM_RI : 0) 837 | ((status & UART_CD) ? TIOCM_CD : 0); 838 839 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 840 841 return result; 842 } 843 844 845 static int cypress_tiocmset(struct tty_struct *tty, 846 unsigned int set, unsigned int clear) 847 { 848 struct usb_serial_port *port = tty->driver_data; 849 struct cypress_private *priv = usb_get_serial_port_data(port); 850 unsigned long flags; 851 852 spin_lock_irqsave(&priv->lock, flags); 853 if (set & TIOCM_RTS) 854 priv->line_control |= CONTROL_RTS; 855 if (set & TIOCM_DTR) 856 priv->line_control |= CONTROL_DTR; 857 if (clear & TIOCM_RTS) 858 priv->line_control &= ~CONTROL_RTS; 859 if (clear & TIOCM_DTR) 860 priv->line_control &= ~CONTROL_DTR; 861 priv->cmd_ctrl = 1; 862 spin_unlock_irqrestore(&priv->lock, flags); 863 864 return cypress_write(tty, port, NULL, 0); 865 } 866 867 868 static int cypress_tiocmiwait(struct tty_struct *tty, unsigned long arg) 869 { 870 struct usb_serial_port *port = tty->driver_data; 871 struct cypress_private *priv = usb_get_serial_port_data(port); 872 char diff; 873 874 for (;;) { 875 interruptible_sleep_on(&port->port.delta_msr_wait); 876 /* see if a signal did it */ 877 if (signal_pending(current)) 878 return -ERESTARTSYS; 879 880 if (port->serial->disconnected) 881 return -EIO; 882 883 diff = priv->diff_status; 884 if (diff == 0) 885 return -EIO; /* no change => error */ 886 887 /* consume all events */ 888 priv->diff_status = 0; 889 890 /* return 0 if caller wanted to know about 891 these bits */ 892 if (((arg & TIOCM_RNG) && (diff & UART_RI)) || 893 ((arg & TIOCM_DSR) && (diff & UART_DSR)) || 894 ((arg & TIOCM_CD) && (diff & UART_CD)) || 895 ((arg & TIOCM_CTS) && (diff & UART_CTS))) 896 return 0; 897 /* otherwise caller can't care less about what 898 * happened, and so we continue to wait for 899 * more events. 900 */ 901 } 902 903 return 0; 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(&port->port.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 (bytes > i) { 1218 tty_insert_flip_string_fixed_flag(&port->port, data + i, 1219 tty_flag, bytes - i); 1220 tty_flip_buffer_push(&port->port); 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