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