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