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