1// SPDX-License-Identifier: GPL-2.0 2/* 3 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk> 4 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de> 5 * Copyright 2009, Boris Hajduk <boris@hajduk.org> 6 * 7 * ch341.c implements a serial port driver for the Winchiphead CH341. 8 * 9 * The CH341 device can be used to implement an RS232 asynchronous 10 * serial port, an IEEE-1284 parallel printer port or a memory-like 11 * interface. In all cases the CH341 supports an I2C interface as well. 12 * This driver only supports the asynchronous serial interface. 13 */ 14 15#include <linux/kernel.h> 16#include <linux/tty.h> 17#include <linux/module.h> 18#include <linux/slab.h> 19#include <linux/usb.h> 20#include <linux/usb/serial.h> 21#include <linux/serial.h> 22#include <asm/unaligned.h> 23 24#define DEFAULT_BAUD_RATE 9600 25#define DEFAULT_TIMEOUT 1000 26 27/* flags for IO-Bits */ 28#define CH341_BIT_RTS (1 << 6) 29#define CH341_BIT_DTR (1 << 5) 30 31/******************************/ 32/* interrupt pipe definitions */ 33/******************************/ 34/* always 4 interrupt bytes */ 35/* first irq byte normally 0x08 */ 36/* second irq byte base 0x7d + below */ 37/* third irq byte base 0x94 + below */ 38/* fourth irq byte normally 0xee */ 39 40/* second interrupt byte */ 41#define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */ 42 43/* status returned in third interrupt answer byte, inverted in data 44 from irq */ 45#define CH341_BIT_CTS 0x01 46#define CH341_BIT_DSR 0x02 47#define CH341_BIT_RI 0x04 48#define CH341_BIT_DCD 0x08 49#define CH341_BITS_MODEM_STAT 0x0f /* all bits */ 50 51/* Break support - the information used to implement this was gleaned from 52 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato. 53 */ 54 55#define CH341_REQ_READ_VERSION 0x5F 56#define CH341_REQ_WRITE_REG 0x9A 57#define CH341_REQ_READ_REG 0x95 58#define CH341_REQ_SERIAL_INIT 0xA1 59#define CH341_REQ_MODEM_CTRL 0xA4 60 61#define CH341_REG_BREAK 0x05 62#define CH341_REG_PRESCALER 0x12 63#define CH341_REG_DIVISOR 0x13 64#define CH341_REG_LCR 0x18 65#define CH341_REG_LCR2 0x25 66 67#define CH341_NBREAK_BITS 0x01 68 69#define CH341_LCR_ENABLE_RX 0x80 70#define CH341_LCR_ENABLE_TX 0x40 71#define CH341_LCR_MARK_SPACE 0x20 72#define CH341_LCR_PAR_EVEN 0x10 73#define CH341_LCR_ENABLE_PAR 0x08 74#define CH341_LCR_STOP_BITS_2 0x04 75#define CH341_LCR_CS8 0x03 76#define CH341_LCR_CS7 0x02 77#define CH341_LCR_CS6 0x01 78#define CH341_LCR_CS5 0x00 79 80#define CH341_QUIRK_LIMITED_PRESCALER BIT(0) 81#define CH341_QUIRK_SIMULATE_BREAK BIT(1) 82 83static const struct usb_device_id id_table[] = { 84 { USB_DEVICE(0x1a86, 0x5523) }, 85 { USB_DEVICE(0x1a86, 0x7522) }, 86 { USB_DEVICE(0x1a86, 0x7523) }, 87 { USB_DEVICE(0x2184, 0x0057) }, 88 { USB_DEVICE(0x4348, 0x5523) }, 89 { USB_DEVICE(0x9986, 0x7523) }, 90 { }, 91}; 92MODULE_DEVICE_TABLE(usb, id_table); 93 94struct ch341_private { 95 spinlock_t lock; /* access lock */ 96 unsigned baud_rate; /* set baud rate */ 97 u8 mcr; 98 u8 msr; 99 u8 lcr; 100 101 unsigned long quirks; 102 u8 version; 103 104 unsigned long break_end; 105}; 106 107static void ch341_set_termios(struct tty_struct *tty, 108 struct usb_serial_port *port, 109 struct ktermios *old_termios); 110 111static int ch341_control_out(struct usb_device *dev, u8 request, 112 u16 value, u16 index) 113{ 114 int r; 115 116 dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x)\n", __func__, 117 request, value, index); 118 119 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 120 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 121 value, index, NULL, 0, DEFAULT_TIMEOUT); 122 if (r < 0) 123 dev_err(&dev->dev, "failed to send control message: %d\n", r); 124 125 return r; 126} 127 128static int ch341_control_in(struct usb_device *dev, 129 u8 request, u16 value, u16 index, 130 char *buf, unsigned bufsize) 131{ 132 int r; 133 134 dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x,%u)\n", __func__, 135 request, value, index, bufsize); 136 137 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 138 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 139 value, index, buf, bufsize, DEFAULT_TIMEOUT); 140 if (r < (int)bufsize) { 141 if (r >= 0) { 142 dev_err(&dev->dev, 143 "short control message received (%d < %u)\n", 144 r, bufsize); 145 r = -EIO; 146 } 147 148 dev_err(&dev->dev, "failed to receive control message: %d\n", 149 r); 150 return r; 151 } 152 153 return 0; 154} 155 156#define CH341_CLKRATE 48000000 157#define CH341_CLK_DIV(ps, fact) (1 << (12 - 3 * (ps) - (fact))) 158#define CH341_MIN_RATE(ps) (CH341_CLKRATE / (CH341_CLK_DIV((ps), 1) * 512)) 159 160static const speed_t ch341_min_rates[] = { 161 CH341_MIN_RATE(0), 162 CH341_MIN_RATE(1), 163 CH341_MIN_RATE(2), 164 CH341_MIN_RATE(3), 165}; 166 167/* Supported range is 46 to 3000000 bps. */ 168#define CH341_MIN_BPS DIV_ROUND_UP(CH341_CLKRATE, CH341_CLK_DIV(0, 0) * 256) 169#define CH341_MAX_BPS (CH341_CLKRATE / (CH341_CLK_DIV(3, 0) * 2)) 170 171/* 172 * The device line speed is given by the following equation: 173 * 174 * baudrate = 48000000 / (2^(12 - 3 * ps - fact) * div), where 175 * 176 * 0 <= ps <= 3, 177 * 0 <= fact <= 1, 178 * 2 <= div <= 256 if fact = 0, or 179 * 9 <= div <= 256 if fact = 1 180 */ 181static int ch341_get_divisor(struct ch341_private *priv, speed_t speed) 182{ 183 unsigned int fact, div, clk_div; 184 bool force_fact0 = false; 185 int ps; 186 187 /* 188 * Clamp to supported range, this makes the (ps < 0) and (div < 2) 189 * sanity checks below redundant. 190 */ 191 speed = clamp_val(speed, CH341_MIN_BPS, CH341_MAX_BPS); 192 193 /* 194 * Start with highest possible base clock (fact = 1) that will give a 195 * divisor strictly less than 512. 196 */ 197 fact = 1; 198 for (ps = 3; ps >= 0; ps--) { 199 if (speed > ch341_min_rates[ps]) 200 break; 201 } 202 203 if (ps < 0) 204 return -EINVAL; 205 206 /* Determine corresponding divisor, rounding down. */ 207 clk_div = CH341_CLK_DIV(ps, fact); 208 div = CH341_CLKRATE / (clk_div * speed); 209 210 /* Some devices require a lower base clock if ps < 3. */ 211 if (ps < 3 && (priv->quirks & CH341_QUIRK_LIMITED_PRESCALER)) 212 force_fact0 = true; 213 214 /* Halve base clock (fact = 0) if required. */ 215 if (div < 9 || div > 255 || force_fact0) { 216 div /= 2; 217 clk_div *= 2; 218 fact = 0; 219 } 220 221 if (div < 2) 222 return -EINVAL; 223 224 /* 225 * Pick next divisor if resulting rate is closer to the requested one, 226 * scale up to avoid rounding errors on low rates. 227 */ 228 if (16 * CH341_CLKRATE / (clk_div * div) - 16 * speed >= 229 16 * speed - 16 * CH341_CLKRATE / (clk_div * (div + 1))) 230 div++; 231 232 /* 233 * Prefer lower base clock (fact = 0) if even divisor. 234 * 235 * Note that this makes the receiver more tolerant to errors. 236 */ 237 if (fact == 1 && div % 2 == 0) { 238 div /= 2; 239 fact = 0; 240 } 241 242 return (0x100 - div) << 8 | fact << 2 | ps; 243} 244 245static int ch341_set_baudrate_lcr(struct usb_device *dev, 246 struct ch341_private *priv, 247 speed_t baud_rate, u8 lcr) 248{ 249 int val; 250 int r; 251 252 if (!baud_rate) 253 return -EINVAL; 254 255 val = ch341_get_divisor(priv, baud_rate); 256 if (val < 0) 257 return -EINVAL; 258 259 /* 260 * CH341A buffers data until a full endpoint-size packet (32 bytes) 261 * has been received unless bit 7 is set. 262 * 263 * At least one device with version 0x27 appears to have this bit 264 * inverted. 265 */ 266 if (priv->version > 0x27) 267 val |= BIT(7); 268 269 r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 270 CH341_REG_DIVISOR << 8 | CH341_REG_PRESCALER, 271 val); 272 if (r) 273 return r; 274 275 /* 276 * Chip versions before version 0x30 as read using 277 * CH341_REQ_READ_VERSION used separate registers for line control 278 * (stop bits, parity and word length). Version 0x30 and above use 279 * CH341_REG_LCR only and CH341_REG_LCR2 is always set to zero. 280 */ 281 if (priv->version < 0x30) 282 return 0; 283 284 r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 285 CH341_REG_LCR2 << 8 | CH341_REG_LCR, lcr); 286 if (r) 287 return r; 288 289 return r; 290} 291 292static int ch341_set_handshake(struct usb_device *dev, u8 control) 293{ 294 return ch341_control_out(dev, CH341_REQ_MODEM_CTRL, ~control, 0); 295} 296 297static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 298{ 299 const unsigned int size = 2; 300 char *buffer; 301 int r; 302 unsigned long flags; 303 304 buffer = kmalloc(size, GFP_KERNEL); 305 if (!buffer) 306 return -ENOMEM; 307 308 r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x0706, 0, buffer, size); 309 if (r < 0) 310 goto out; 311 312 spin_lock_irqsave(&priv->lock, flags); 313 priv->msr = (~(*buffer)) & CH341_BITS_MODEM_STAT; 314 spin_unlock_irqrestore(&priv->lock, flags); 315 316out: kfree(buffer); 317 return r; 318} 319 320/* -------------------------------------------------------------------------- */ 321 322static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 323{ 324 const unsigned int size = 2; 325 char *buffer; 326 int r; 327 328 buffer = kmalloc(size, GFP_KERNEL); 329 if (!buffer) 330 return -ENOMEM; 331 332 /* expect two bytes 0x27 0x00 */ 333 r = ch341_control_in(dev, CH341_REQ_READ_VERSION, 0, 0, buffer, size); 334 if (r < 0) 335 goto out; 336 337 priv->version = buffer[0]; 338 dev_dbg(&dev->dev, "Chip version: 0x%02x\n", priv->version); 339 340 r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 0, 0); 341 if (r < 0) 342 goto out; 343 344 r = ch341_set_baudrate_lcr(dev, priv, priv->baud_rate, priv->lcr); 345 if (r < 0) 346 goto out; 347 348 r = ch341_set_handshake(dev, priv->mcr); 349 350out: kfree(buffer); 351 return r; 352} 353 354static int ch341_detect_quirks(struct usb_serial_port *port) 355{ 356 struct ch341_private *priv = usb_get_serial_port_data(port); 357 struct usb_device *udev = port->serial->dev; 358 const unsigned int size = 2; 359 unsigned long quirks = 0; 360 char *buffer; 361 int r; 362 363 buffer = kmalloc(size, GFP_KERNEL); 364 if (!buffer) 365 return -ENOMEM; 366 367 /* 368 * A subset of CH34x devices does not support all features. The 369 * prescaler is limited and there is no support for sending a RS232 370 * break condition. A read failure when trying to set up the latter is 371 * used to detect these devices. 372 */ 373 r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), CH341_REQ_READ_REG, 374 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 375 CH341_REG_BREAK, 0, buffer, size, DEFAULT_TIMEOUT); 376 if (r == -EPIPE) { 377 dev_info(&port->dev, "break control not supported, using simulated break\n"); 378 quirks = CH341_QUIRK_LIMITED_PRESCALER | CH341_QUIRK_SIMULATE_BREAK; 379 r = 0; 380 goto out; 381 } 382 383 if (r != size) { 384 if (r >= 0) 385 r = -EIO; 386 dev_err(&port->dev, "failed to read break control: %d\n", r); 387 goto out; 388 } 389 390 r = 0; 391out: 392 kfree(buffer); 393 394 if (quirks) { 395 dev_dbg(&port->dev, "enabling quirk flags: 0x%02lx\n", quirks); 396 priv->quirks |= quirks; 397 } 398 399 return r; 400} 401 402static int ch341_port_probe(struct usb_serial_port *port) 403{ 404 struct ch341_private *priv; 405 int r; 406 407 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 408 if (!priv) 409 return -ENOMEM; 410 411 spin_lock_init(&priv->lock); 412 priv->baud_rate = DEFAULT_BAUD_RATE; 413 /* 414 * Some CH340 devices appear unable to change the initial LCR 415 * settings, so set a sane 8N1 default. 416 */ 417 priv->lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8; 418 419 r = ch341_configure(port->serial->dev, priv); 420 if (r < 0) 421 goto error; 422 423 usb_set_serial_port_data(port, priv); 424 425 r = ch341_detect_quirks(port); 426 if (r < 0) 427 goto error; 428 429 return 0; 430 431error: kfree(priv); 432 return r; 433} 434 435static int ch341_port_remove(struct usb_serial_port *port) 436{ 437 struct ch341_private *priv; 438 439 priv = usb_get_serial_port_data(port); 440 kfree(priv); 441 442 return 0; 443} 444 445static int ch341_carrier_raised(struct usb_serial_port *port) 446{ 447 struct ch341_private *priv = usb_get_serial_port_data(port); 448 if (priv->msr & CH341_BIT_DCD) 449 return 1; 450 return 0; 451} 452 453static void ch341_dtr_rts(struct usb_serial_port *port, int on) 454{ 455 struct ch341_private *priv = usb_get_serial_port_data(port); 456 unsigned long flags; 457 458 /* drop DTR and RTS */ 459 spin_lock_irqsave(&priv->lock, flags); 460 if (on) 461 priv->mcr |= CH341_BIT_RTS | CH341_BIT_DTR; 462 else 463 priv->mcr &= ~(CH341_BIT_RTS | CH341_BIT_DTR); 464 spin_unlock_irqrestore(&priv->lock, flags); 465 ch341_set_handshake(port->serial->dev, priv->mcr); 466} 467 468static void ch341_close(struct usb_serial_port *port) 469{ 470 usb_serial_generic_close(port); 471 usb_kill_urb(port->interrupt_in_urb); 472} 473 474 475/* open this device, set default parameters */ 476static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) 477{ 478 struct ch341_private *priv = usb_get_serial_port_data(port); 479 int r; 480 481 if (tty) 482 ch341_set_termios(tty, port, NULL); 483 484 dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__); 485 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 486 if (r) { 487 dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n", 488 __func__, r); 489 return r; 490 } 491 492 r = ch341_get_status(port->serial->dev, priv); 493 if (r < 0) { 494 dev_err(&port->dev, "failed to read modem status: %d\n", r); 495 goto err_kill_interrupt_urb; 496 } 497 498 r = usb_serial_generic_open(tty, port); 499 if (r) 500 goto err_kill_interrupt_urb; 501 502 return 0; 503 504err_kill_interrupt_urb: 505 usb_kill_urb(port->interrupt_in_urb); 506 507 return r; 508} 509 510/* Old_termios contains the original termios settings and 511 * tty->termios contains the new setting to be used. 512 */ 513static void ch341_set_termios(struct tty_struct *tty, 514 struct usb_serial_port *port, struct ktermios *old_termios) 515{ 516 struct ch341_private *priv = usb_get_serial_port_data(port); 517 unsigned baud_rate; 518 unsigned long flags; 519 u8 lcr; 520 int r; 521 522 /* redundant changes may cause the chip to lose bytes */ 523 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios)) 524 return; 525 526 baud_rate = tty_get_baud_rate(tty); 527 528 lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX; 529 530 switch (C_CSIZE(tty)) { 531 case CS5: 532 lcr |= CH341_LCR_CS5; 533 break; 534 case CS6: 535 lcr |= CH341_LCR_CS6; 536 break; 537 case CS7: 538 lcr |= CH341_LCR_CS7; 539 break; 540 case CS8: 541 lcr |= CH341_LCR_CS8; 542 break; 543 } 544 545 if (C_PARENB(tty)) { 546 lcr |= CH341_LCR_ENABLE_PAR; 547 if (C_PARODD(tty) == 0) 548 lcr |= CH341_LCR_PAR_EVEN; 549 if (C_CMSPAR(tty)) 550 lcr |= CH341_LCR_MARK_SPACE; 551 } 552 553 if (C_CSTOPB(tty)) 554 lcr |= CH341_LCR_STOP_BITS_2; 555 556 if (baud_rate) { 557 priv->baud_rate = baud_rate; 558 559 r = ch341_set_baudrate_lcr(port->serial->dev, priv, 560 priv->baud_rate, lcr); 561 if (r < 0 && old_termios) { 562 priv->baud_rate = tty_termios_baud_rate(old_termios); 563 tty_termios_copy_hw(&tty->termios, old_termios); 564 } else if (r == 0) { 565 priv->lcr = lcr; 566 } 567 } 568 569 spin_lock_irqsave(&priv->lock, flags); 570 if (C_BAUD(tty) == B0) 571 priv->mcr &= ~(CH341_BIT_DTR | CH341_BIT_RTS); 572 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0) 573 priv->mcr |= (CH341_BIT_DTR | CH341_BIT_RTS); 574 spin_unlock_irqrestore(&priv->lock, flags); 575 576 ch341_set_handshake(port->serial->dev, priv->mcr); 577} 578 579/* 580 * A subset of all CH34x devices don't support a real break condition and 581 * reading CH341_REG_BREAK fails (see also ch341_detect_quirks). This function 582 * simulates a break condition by lowering the baud rate to the minimum 583 * supported by the hardware upon enabling the break condition and sending 584 * a NUL byte. 585 * 586 * Incoming data is corrupted while the break condition is being simulated. 587 * 588 * Normally the duration of the break condition can be controlled individually 589 * by userspace using TIOCSBRK and TIOCCBRK or by passing an argument to 590 * TCSBRKP. Due to how the simulation is implemented the duration can't be 591 * controlled. The duration is always about (1s / 46bd * 9bit) = 196ms. 592 */ 593static void ch341_simulate_break(struct tty_struct *tty, int break_state) 594{ 595 struct usb_serial_port *port = tty->driver_data; 596 struct ch341_private *priv = usb_get_serial_port_data(port); 597 unsigned long now, delay; 598 int r; 599 600 if (break_state != 0) { 601 dev_dbg(&port->dev, "enter break state requested\n"); 602 603 r = ch341_set_baudrate_lcr(port->serial->dev, priv, 604 CH341_MIN_BPS, 605 CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8); 606 if (r < 0) { 607 dev_err(&port->dev, 608 "failed to change baud rate to %u: %d\n", 609 CH341_MIN_BPS, r); 610 goto restore; 611 } 612 613 r = tty_put_char(tty, '\0'); 614 if (r < 0) { 615 dev_err(&port->dev, 616 "failed to write NUL byte for simulated break condition: %d\n", 617 r); 618 goto restore; 619 } 620 621 /* 622 * Compute expected transmission duration including safety 623 * margin. The original baud rate is only restored after the 624 * computed point in time. 625 * 626 * 11 bits = 1 start, 8 data, 1 stop, 1 margin 627 */ 628 priv->break_end = jiffies + (11 * HZ / CH341_MIN_BPS); 629 630 return; 631 } 632 633 dev_dbg(&port->dev, "leave break state requested\n"); 634 635 now = jiffies; 636 637 if (time_before(now, priv->break_end)) { 638 /* Wait until NUL byte is written */ 639 delay = priv->break_end - now; 640 dev_dbg(&port->dev, 641 "wait %d ms while transmitting NUL byte at %u baud\n", 642 jiffies_to_msecs(delay), CH341_MIN_BPS); 643 schedule_timeout_interruptible(delay); 644 } 645 646restore: 647 /* Restore original baud rate */ 648 r = ch341_set_baudrate_lcr(port->serial->dev, priv, priv->baud_rate, 649 priv->lcr); 650 if (r < 0) 651 dev_err(&port->dev, 652 "restoring original baud rate of %u failed: %d\n", 653 priv->baud_rate, r); 654} 655 656static void ch341_break_ctl(struct tty_struct *tty, int break_state) 657{ 658 const uint16_t ch341_break_reg = 659 ((uint16_t) CH341_REG_LCR << 8) | CH341_REG_BREAK; 660 struct usb_serial_port *port = tty->driver_data; 661 struct ch341_private *priv = usb_get_serial_port_data(port); 662 int r; 663 uint16_t reg_contents; 664 uint8_t *break_reg; 665 666 if (priv->quirks & CH341_QUIRK_SIMULATE_BREAK) { 667 ch341_simulate_break(tty, break_state); 668 return; 669 } 670 671 break_reg = kmalloc(2, GFP_KERNEL); 672 if (!break_reg) 673 return; 674 675 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG, 676 ch341_break_reg, 0, break_reg, 2); 677 if (r < 0) { 678 dev_err(&port->dev, "%s - USB control read error (%d)\n", 679 __func__, r); 680 goto out; 681 } 682 dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n", 683 __func__, break_reg[0], break_reg[1]); 684 if (break_state != 0) { 685 dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__); 686 break_reg[0] &= ~CH341_NBREAK_BITS; 687 break_reg[1] &= ~CH341_LCR_ENABLE_TX; 688 } else { 689 dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__); 690 break_reg[0] |= CH341_NBREAK_BITS; 691 break_reg[1] |= CH341_LCR_ENABLE_TX; 692 } 693 dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n", 694 __func__, break_reg[0], break_reg[1]); 695 reg_contents = get_unaligned_le16(break_reg); 696 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG, 697 ch341_break_reg, reg_contents); 698 if (r < 0) 699 dev_err(&port->dev, "%s - USB control write error (%d)\n", 700 __func__, r); 701out: 702 kfree(break_reg); 703} 704 705static int ch341_tiocmset(struct tty_struct *tty, 706 unsigned int set, unsigned int clear) 707{ 708 struct usb_serial_port *port = tty->driver_data; 709 struct ch341_private *priv = usb_get_serial_port_data(port); 710 unsigned long flags; 711 u8 control; 712 713 spin_lock_irqsave(&priv->lock, flags); 714 if (set & TIOCM_RTS) 715 priv->mcr |= CH341_BIT_RTS; 716 if (set & TIOCM_DTR) 717 priv->mcr |= CH341_BIT_DTR; 718 if (clear & TIOCM_RTS) 719 priv->mcr &= ~CH341_BIT_RTS; 720 if (clear & TIOCM_DTR) 721 priv->mcr &= ~CH341_BIT_DTR; 722 control = priv->mcr; 723 spin_unlock_irqrestore(&priv->lock, flags); 724 725 return ch341_set_handshake(port->serial->dev, control); 726} 727 728static void ch341_update_status(struct usb_serial_port *port, 729 unsigned char *data, size_t len) 730{ 731 struct ch341_private *priv = usb_get_serial_port_data(port); 732 struct tty_struct *tty; 733 unsigned long flags; 734 u8 status; 735 u8 delta; 736 737 if (len < 4) 738 return; 739 740 status = ~data[2] & CH341_BITS_MODEM_STAT; 741 742 spin_lock_irqsave(&priv->lock, flags); 743 delta = status ^ priv->msr; 744 priv->msr = status; 745 spin_unlock_irqrestore(&priv->lock, flags); 746 747 if (data[1] & CH341_MULT_STAT) 748 dev_dbg(&port->dev, "%s - multiple status change\n", __func__); 749 750 if (!delta) 751 return; 752 753 if (delta & CH341_BIT_CTS) 754 port->icount.cts++; 755 if (delta & CH341_BIT_DSR) 756 port->icount.dsr++; 757 if (delta & CH341_BIT_RI) 758 port->icount.rng++; 759 if (delta & CH341_BIT_DCD) { 760 port->icount.dcd++; 761 tty = tty_port_tty_get(&port->port); 762 if (tty) { 763 usb_serial_handle_dcd_change(port, tty, 764 status & CH341_BIT_DCD); 765 tty_kref_put(tty); 766 } 767 } 768 769 wake_up_interruptible(&port->port.delta_msr_wait); 770} 771 772static void ch341_read_int_callback(struct urb *urb) 773{ 774 struct usb_serial_port *port = urb->context; 775 unsigned char *data = urb->transfer_buffer; 776 unsigned int len = urb->actual_length; 777 int status; 778 779 switch (urb->status) { 780 case 0: 781 /* success */ 782 break; 783 case -ECONNRESET: 784 case -ENOENT: 785 case -ESHUTDOWN: 786 /* this urb is terminated, clean up */ 787 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n", 788 __func__, urb->status); 789 return; 790 default: 791 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", 792 __func__, urb->status); 793 goto exit; 794 } 795 796 usb_serial_debug_data(&port->dev, __func__, len, data); 797 ch341_update_status(port, data, len); 798exit: 799 status = usb_submit_urb(urb, GFP_ATOMIC); 800 if (status) { 801 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n", 802 __func__, status); 803 } 804} 805 806static int ch341_tiocmget(struct tty_struct *tty) 807{ 808 struct usb_serial_port *port = tty->driver_data; 809 struct ch341_private *priv = usb_get_serial_port_data(port); 810 unsigned long flags; 811 u8 mcr; 812 u8 status; 813 unsigned int result; 814 815 spin_lock_irqsave(&priv->lock, flags); 816 mcr = priv->mcr; 817 status = priv->msr; 818 spin_unlock_irqrestore(&priv->lock, flags); 819 820 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0) 821 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0) 822 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0) 823 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0) 824 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0) 825 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0); 826 827 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 828 829 return result; 830} 831 832static int ch341_reset_resume(struct usb_serial *serial) 833{ 834 struct usb_serial_port *port = serial->port[0]; 835 struct ch341_private *priv; 836 int ret; 837 838 priv = usb_get_serial_port_data(port); 839 if (!priv) 840 return 0; 841 842 /* reconfigure ch341 serial port after bus-reset */ 843 ch341_configure(serial->dev, priv); 844 845 if (tty_port_initialized(&port->port)) { 846 ret = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 847 if (ret) { 848 dev_err(&port->dev, "failed to submit interrupt urb: %d\n", 849 ret); 850 return ret; 851 } 852 853 ret = ch341_get_status(port->serial->dev, priv); 854 if (ret < 0) { 855 dev_err(&port->dev, "failed to read modem status: %d\n", 856 ret); 857 } 858 } 859 860 return usb_serial_generic_resume(serial); 861} 862 863static struct usb_serial_driver ch341_device = { 864 .driver = { 865 .owner = THIS_MODULE, 866 .name = "ch341-uart", 867 }, 868 .id_table = id_table, 869 .num_ports = 1, 870 .open = ch341_open, 871 .dtr_rts = ch341_dtr_rts, 872 .carrier_raised = ch341_carrier_raised, 873 .close = ch341_close, 874 .set_termios = ch341_set_termios, 875 .break_ctl = ch341_break_ctl, 876 .tiocmget = ch341_tiocmget, 877 .tiocmset = ch341_tiocmset, 878 .tiocmiwait = usb_serial_generic_tiocmiwait, 879 .read_int_callback = ch341_read_int_callback, 880 .port_probe = ch341_port_probe, 881 .port_remove = ch341_port_remove, 882 .reset_resume = ch341_reset_resume, 883}; 884 885static struct usb_serial_driver * const serial_drivers[] = { 886 &ch341_device, NULL 887}; 888 889module_usb_serial_driver(serial_drivers, id_table); 890 891MODULE_LICENSE("GPL v2"); 892