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