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