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