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