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(0x1a86, 0x5512) }, 85 { USB_DEVICE(0x1a86, 0x5523) }, 86 { USB_DEVICE(0x1a86, 0x7522) }, 87 { USB_DEVICE(0x1a86, 0x7523) }, 88 { USB_DEVICE(0x4348, 0x5523) }, 89 { USB_DEVICE(0x9986, 0x7523) }, 90 { }, 91 }; 92 MODULE_DEVICE_TABLE(usb, id_table); 93 94 struct 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 unsigned long quirks; 101 unsigned long break_end; 102 }; 103 104 static void ch341_set_termios(struct tty_struct *tty, 105 struct usb_serial_port *port, 106 struct ktermios *old_termios); 107 108 static int ch341_control_out(struct usb_device *dev, u8 request, 109 u16 value, u16 index) 110 { 111 int r; 112 113 dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x)\n", __func__, 114 request, value, index); 115 116 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 117 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 118 value, index, NULL, 0, DEFAULT_TIMEOUT); 119 if (r < 0) 120 dev_err(&dev->dev, "failed to send control message: %d\n", r); 121 122 return r; 123 } 124 125 static int ch341_control_in(struct usb_device *dev, 126 u8 request, u16 value, u16 index, 127 char *buf, unsigned bufsize) 128 { 129 int r; 130 131 dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x,%u)\n", __func__, 132 request, value, index, bufsize); 133 134 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 135 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 136 value, index, buf, bufsize, DEFAULT_TIMEOUT); 137 if (r < (int)bufsize) { 138 if (r >= 0) { 139 dev_err(&dev->dev, 140 "short control message received (%d < %u)\n", 141 r, bufsize); 142 r = -EIO; 143 } 144 145 dev_err(&dev->dev, "failed to receive control message: %d\n", 146 r); 147 return r; 148 } 149 150 return 0; 151 } 152 153 #define CH341_CLKRATE 48000000 154 #define CH341_CLK_DIV(ps, fact) (1 << (12 - 3 * (ps) - (fact))) 155 #define CH341_MIN_RATE(ps) (CH341_CLKRATE / (CH341_CLK_DIV((ps), 1) * 512)) 156 157 static const speed_t ch341_min_rates[] = { 158 CH341_MIN_RATE(0), 159 CH341_MIN_RATE(1), 160 CH341_MIN_RATE(2), 161 CH341_MIN_RATE(3), 162 }; 163 164 /* Supported range is 46 to 3000000 bps. */ 165 #define CH341_MIN_BPS DIV_ROUND_UP(CH341_CLKRATE, CH341_CLK_DIV(0, 0) * 256) 166 #define CH341_MAX_BPS (CH341_CLKRATE / (CH341_CLK_DIV(3, 0) * 2)) 167 168 /* 169 * The device line speed is given by the following equation: 170 * 171 * baudrate = 48000000 / (2^(12 - 3 * ps - fact) * div), where 172 * 173 * 0 <= ps <= 3, 174 * 0 <= fact <= 1, 175 * 2 <= div <= 256 if fact = 0, or 176 * 9 <= div <= 256 if fact = 1 177 */ 178 static int ch341_get_divisor(struct ch341_private *priv, speed_t speed) 179 { 180 unsigned int fact, div, clk_div; 181 bool force_fact0 = false; 182 int ps; 183 184 /* 185 * Clamp to supported range, this makes the (ps < 0) and (div < 2) 186 * sanity checks below redundant. 187 */ 188 speed = clamp_val(speed, CH341_MIN_BPS, CH341_MAX_BPS); 189 190 /* 191 * Start with highest possible base clock (fact = 1) that will give a 192 * divisor strictly less than 512. 193 */ 194 fact = 1; 195 for (ps = 3; ps >= 0; ps--) { 196 if (speed > ch341_min_rates[ps]) 197 break; 198 } 199 200 if (ps < 0) 201 return -EINVAL; 202 203 /* Determine corresponding divisor, rounding down. */ 204 clk_div = CH341_CLK_DIV(ps, fact); 205 div = CH341_CLKRATE / (clk_div * speed); 206 207 /* Some devices require a lower base clock if ps < 3. */ 208 if (ps < 3 && (priv->quirks & CH341_QUIRK_LIMITED_PRESCALER)) 209 force_fact0 = true; 210 211 /* Halve base clock (fact = 0) if required. */ 212 if (div < 9 || div > 255 || force_fact0) { 213 div /= 2; 214 clk_div *= 2; 215 fact = 0; 216 } 217 218 if (div < 2) 219 return -EINVAL; 220 221 /* 222 * Pick next divisor if resulting rate is closer to the requested one, 223 * scale up to avoid rounding errors on low rates. 224 */ 225 if (16 * CH341_CLKRATE / (clk_div * div) - 16 * speed >= 226 16 * speed - 16 * CH341_CLKRATE / (clk_div * (div + 1))) 227 div++; 228 229 /* 230 * Prefer lower base clock (fact = 0) if even divisor. 231 * 232 * Note that this makes the receiver more tolerant to errors. 233 */ 234 if (fact == 1 && div % 2 == 0) { 235 div /= 2; 236 fact = 0; 237 } 238 239 return (0x100 - div) << 8 | fact << 2 | ps; 240 } 241 242 static int ch341_set_baudrate_lcr(struct usb_device *dev, 243 struct ch341_private *priv, 244 speed_t baud_rate, u8 lcr) 245 { 246 int val; 247 int r; 248 249 if (!baud_rate) 250 return -EINVAL; 251 252 val = ch341_get_divisor(priv, baud_rate); 253 if (val < 0) 254 return -EINVAL; 255 256 /* 257 * CH341A buffers data until a full endpoint-size packet (32 bytes) 258 * has been received unless bit 7 is set. 259 */ 260 val |= BIT(7); 261 262 r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 263 CH341_REG_DIVISOR << 8 | CH341_REG_PRESCALER, 264 val); 265 if (r) 266 return r; 267 268 /* 269 * Chip versions before version 0x30 as read using 270 * CH341_REQ_READ_VERSION used separate registers for line control 271 * (stop bits, parity and word length). Version 0x30 and above use 272 * CH341_REG_LCR only and CH341_REG_LCR2 is always set to zero. 273 */ 274 r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 275 CH341_REG_LCR2 << 8 | CH341_REG_LCR, lcr); 276 if (r) 277 return r; 278 279 return r; 280 } 281 282 static int ch341_set_handshake(struct usb_device *dev, u8 control) 283 { 284 return ch341_control_out(dev, CH341_REQ_MODEM_CTRL, ~control, 0); 285 } 286 287 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 288 { 289 const unsigned int size = 2; 290 char *buffer; 291 int r; 292 unsigned long flags; 293 294 buffer = kmalloc(size, GFP_KERNEL); 295 if (!buffer) 296 return -ENOMEM; 297 298 r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x0706, 0, buffer, size); 299 if (r < 0) 300 goto out; 301 302 spin_lock_irqsave(&priv->lock, flags); 303 priv->msr = (~(*buffer)) & CH341_BITS_MODEM_STAT; 304 spin_unlock_irqrestore(&priv->lock, flags); 305 306 out: kfree(buffer); 307 return r; 308 } 309 310 /* -------------------------------------------------------------------------- */ 311 312 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 313 { 314 const unsigned int size = 2; 315 char *buffer; 316 int r; 317 318 buffer = kmalloc(size, GFP_KERNEL); 319 if (!buffer) 320 return -ENOMEM; 321 322 /* expect two bytes 0x27 0x00 */ 323 r = ch341_control_in(dev, CH341_REQ_READ_VERSION, 0, 0, buffer, size); 324 if (r < 0) 325 goto out; 326 dev_dbg(&dev->dev, "Chip version: 0x%02x\n", buffer[0]); 327 328 r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 0, 0); 329 if (r < 0) 330 goto out; 331 332 r = ch341_set_baudrate_lcr(dev, priv, priv->baud_rate, priv->lcr); 333 if (r < 0) 334 goto out; 335 336 r = ch341_set_handshake(dev, priv->mcr); 337 338 out: kfree(buffer); 339 return r; 340 } 341 342 static int ch341_detect_quirks(struct usb_serial_port *port) 343 { 344 struct ch341_private *priv = usb_get_serial_port_data(port); 345 struct usb_device *udev = port->serial->dev; 346 const unsigned int size = 2; 347 unsigned long quirks = 0; 348 char *buffer; 349 int r; 350 351 buffer = kmalloc(size, GFP_KERNEL); 352 if (!buffer) 353 return -ENOMEM; 354 355 /* 356 * A subset of CH34x devices does not support all features. The 357 * prescaler is limited and there is no support for sending a RS232 358 * break condition. A read failure when trying to set up the latter is 359 * used to detect these devices. 360 */ 361 r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), CH341_REQ_READ_REG, 362 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 363 CH341_REG_BREAK, 0, buffer, size, DEFAULT_TIMEOUT); 364 if (r == -EPIPE) { 365 dev_info(&port->dev, "break control not supported, using simulated break\n"); 366 quirks = CH341_QUIRK_LIMITED_PRESCALER | CH341_QUIRK_SIMULATE_BREAK; 367 r = 0; 368 goto out; 369 } 370 371 if (r != size) { 372 if (r >= 0) 373 r = -EIO; 374 dev_err(&port->dev, "failed to read break control: %d\n", r); 375 goto out; 376 } 377 378 r = 0; 379 out: 380 kfree(buffer); 381 382 if (quirks) { 383 dev_dbg(&port->dev, "enabling quirk flags: 0x%02lx\n", quirks); 384 priv->quirks |= quirks; 385 } 386 387 return r; 388 } 389 390 static int ch341_port_probe(struct usb_serial_port *port) 391 { 392 struct ch341_private *priv; 393 int r; 394 395 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 396 if (!priv) 397 return -ENOMEM; 398 399 spin_lock_init(&priv->lock); 400 priv->baud_rate = DEFAULT_BAUD_RATE; 401 /* 402 * Some CH340 devices appear unable to change the initial LCR 403 * settings, so set a sane 8N1 default. 404 */ 405 priv->lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8; 406 407 r = ch341_configure(port->serial->dev, priv); 408 if (r < 0) 409 goto error; 410 411 usb_set_serial_port_data(port, priv); 412 413 r = ch341_detect_quirks(port); 414 if (r < 0) 415 goto error; 416 417 return 0; 418 419 error: kfree(priv); 420 return r; 421 } 422 423 static void ch341_port_remove(struct usb_serial_port *port) 424 { 425 struct ch341_private *priv; 426 427 priv = usb_get_serial_port_data(port); 428 kfree(priv); 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 .bulk_in_size = 512, 855 .id_table = id_table, 856 .num_ports = 1, 857 .open = ch341_open, 858 .dtr_rts = ch341_dtr_rts, 859 .carrier_raised = ch341_carrier_raised, 860 .close = ch341_close, 861 .set_termios = ch341_set_termios, 862 .break_ctl = ch341_break_ctl, 863 .tiocmget = ch341_tiocmget, 864 .tiocmset = ch341_tiocmset, 865 .tiocmiwait = usb_serial_generic_tiocmiwait, 866 .read_int_callback = ch341_read_int_callback, 867 .port_probe = ch341_port_probe, 868 .port_remove = ch341_port_remove, 869 .reset_resume = ch341_reset_resume, 870 }; 871 872 static struct usb_serial_driver * const serial_drivers[] = { 873 &ch341_device, NULL 874 }; 875 876 module_usb_serial_driver(serial_drivers, id_table); 877 878 MODULE_LICENSE("GPL v2"); 879