1 /* 2 * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk> 3 * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de> 4 * Copyright 2009, Boris Hajduk <boris@hajduk.org> 5 * 6 * ch341.c implements a serial port driver for the Winchiphead CH341. 7 * 8 * The CH341 device can be used to implement an RS232 asynchronous 9 * serial port, an IEEE-1284 parallel printer port or a memory-like 10 * interface. In all cases the CH341 supports an I2C interface as well. 11 * This driver only supports the asynchronous serial interface. 12 * 13 * This program is free software; you can redistribute it and/or 14 * modify it under the terms of the GNU General Public License version 15 * 2 as published by the Free Software Foundation. 16 */ 17 18 #include <linux/kernel.h> 19 #include <linux/tty.h> 20 #include <linux/module.h> 21 #include <linux/slab.h> 22 #include <linux/usb.h> 23 #include <linux/usb/serial.h> 24 #include <linux/serial.h> 25 #include <asm/unaligned.h> 26 27 #define DEFAULT_BAUD_RATE 9600 28 #define DEFAULT_TIMEOUT 1000 29 30 /* flags for IO-Bits */ 31 #define CH341_BIT_RTS (1 << 6) 32 #define CH341_BIT_DTR (1 << 5) 33 34 /******************************/ 35 /* interrupt pipe definitions */ 36 /******************************/ 37 /* always 4 interrupt bytes */ 38 /* first irq byte normally 0x08 */ 39 /* second irq byte base 0x7d + below */ 40 /* third irq byte base 0x94 + below */ 41 /* fourth irq byte normally 0xee */ 42 43 /* second interrupt byte */ 44 #define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */ 45 46 /* status returned in third interrupt answer byte, inverted in data 47 from irq */ 48 #define CH341_BIT_CTS 0x01 49 #define CH341_BIT_DSR 0x02 50 #define CH341_BIT_RI 0x04 51 #define CH341_BIT_DCD 0x08 52 #define CH341_BITS_MODEM_STAT 0x0f /* all bits */ 53 54 /*******************************/ 55 /* baudrate calculation factor */ 56 /*******************************/ 57 #define CH341_BAUDBASE_FACTOR 1532620800 58 #define CH341_BAUDBASE_DIVMAX 3 59 60 /* Break support - the information used to implement this was gleaned from 61 * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato. 62 */ 63 64 #define CH341_REQ_WRITE_REG 0x9A 65 #define CH341_REQ_READ_REG 0x95 66 #define CH341_REG_BREAK1 0x05 67 #define CH341_REG_BREAK2 0x18 68 #define CH341_NBREAK_BITS_REG1 0x01 69 #define CH341_NBREAK_BITS_REG2 0x40 70 71 72 static const struct usb_device_id id_table[] = { 73 { USB_DEVICE(0x1a86, 0x5512) }, 74 { USB_DEVICE(0x1a86, 0x5523) }, 75 { USB_DEVICE(0x1a86, 0x7522) }, 76 { USB_DEVICE(0x1a86, 0x7523) }, 77 { USB_DEVICE(0x4348, 0x5523) }, 78 { USB_DEVICE(0x9986, 0x7523) }, 79 { }, 80 }; 81 MODULE_DEVICE_TABLE(usb, id_table); 82 83 struct ch341_private { 84 spinlock_t lock; /* access lock */ 85 unsigned baud_rate; /* set baud rate */ 86 u8 line_control; /* set line control value RTS/DTR */ 87 u8 line_status; /* active status of modem control inputs */ 88 }; 89 90 static void ch341_set_termios(struct tty_struct *tty, 91 struct usb_serial_port *port, 92 struct ktermios *old_termios); 93 ch341_control_out(struct usb_device * dev,u8 request,u16 value,u16 index)94 static int ch341_control_out(struct usb_device *dev, u8 request, 95 u16 value, u16 index) 96 { 97 int r; 98 99 dev_dbg(&dev->dev, "ch341_control_out(%02x,%02x,%04x,%04x)\n", 100 USB_DIR_OUT|0x40, (int)request, (int)value, (int)index); 101 102 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 103 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 104 value, index, NULL, 0, DEFAULT_TIMEOUT); 105 if (r < 0) 106 dev_err(&dev->dev, "failed to send control message: %d\n", r); 107 108 return r; 109 } 110 ch341_control_in(struct usb_device * dev,u8 request,u16 value,u16 index,char * buf,unsigned bufsize)111 static int ch341_control_in(struct usb_device *dev, 112 u8 request, u16 value, u16 index, 113 char *buf, unsigned bufsize) 114 { 115 int r; 116 117 dev_dbg(&dev->dev, "ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)\n", 118 USB_DIR_IN|0x40, (int)request, (int)value, (int)index, buf, 119 (int)bufsize); 120 121 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 122 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 123 value, index, buf, bufsize, DEFAULT_TIMEOUT); 124 if (r < (int)bufsize) { 125 if (r >= 0) { 126 dev_err(&dev->dev, 127 "short control message received (%d < %u)\n", 128 r, bufsize); 129 r = -EIO; 130 } 131 132 dev_err(&dev->dev, "failed to receive control message: %d\n", 133 r); 134 return r; 135 } 136 137 return 0; 138 } 139 ch341_set_baudrate(struct usb_device * dev,struct ch341_private * priv)140 static int ch341_set_baudrate(struct usb_device *dev, 141 struct ch341_private *priv) 142 { 143 short a, b; 144 int r; 145 unsigned long factor; 146 short divisor; 147 148 if (!priv->baud_rate) 149 return -EINVAL; 150 factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate); 151 divisor = CH341_BAUDBASE_DIVMAX; 152 153 while ((factor > 0xfff0) && divisor) { 154 factor >>= 3; 155 divisor--; 156 } 157 158 if (factor > 0xfff0) 159 return -EINVAL; 160 161 factor = 0x10000 - factor; 162 a = (factor & 0xff00) | divisor; 163 b = factor & 0xff; 164 165 r = ch341_control_out(dev, 0x9a, 0x1312, a); 166 if (!r) 167 r = ch341_control_out(dev, 0x9a, 0x0f2c, b); 168 169 return r; 170 } 171 ch341_set_handshake(struct usb_device * dev,u8 control)172 static int ch341_set_handshake(struct usb_device *dev, u8 control) 173 { 174 return ch341_control_out(dev, 0xa4, ~control, 0); 175 } 176 ch341_get_status(struct usb_device * dev,struct ch341_private * priv)177 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 178 { 179 const unsigned int size = 2; 180 char *buffer; 181 int r; 182 unsigned long flags; 183 184 buffer = kmalloc(size, GFP_KERNEL); 185 if (!buffer) 186 return -ENOMEM; 187 188 r = ch341_control_in(dev, 0x95, 0x0706, 0, buffer, size); 189 if (r < 0) 190 goto out; 191 192 spin_lock_irqsave(&priv->lock, flags); 193 priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT; 194 spin_unlock_irqrestore(&priv->lock, flags); 195 196 out: kfree(buffer); 197 return r; 198 } 199 200 /* -------------------------------------------------------------------------- */ 201 ch341_configure(struct usb_device * dev,struct ch341_private * priv)202 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 203 { 204 const unsigned int size = 2; 205 char *buffer; 206 int r; 207 208 buffer = kmalloc(size, GFP_KERNEL); 209 if (!buffer) 210 return -ENOMEM; 211 212 /* expect two bytes 0x27 0x00 */ 213 r = ch341_control_in(dev, 0x5f, 0, 0, buffer, size); 214 if (r < 0) 215 goto out; 216 217 r = ch341_control_out(dev, 0xa1, 0, 0); 218 if (r < 0) 219 goto out; 220 221 r = ch341_set_baudrate(dev, priv); 222 if (r < 0) 223 goto out; 224 225 /* expect two bytes 0x56 0x00 */ 226 r = ch341_control_in(dev, 0x95, 0x2518, 0, buffer, size); 227 if (r < 0) 228 goto out; 229 230 r = ch341_control_out(dev, 0x9a, 0x2518, 0x0050); 231 if (r < 0) 232 goto out; 233 234 /* expect 0xff 0xee */ 235 r = ch341_get_status(dev, priv); 236 if (r < 0) 237 goto out; 238 239 r = ch341_control_out(dev, 0xa1, 0x501f, 0xd90a); 240 if (r < 0) 241 goto out; 242 243 r = ch341_set_baudrate(dev, priv); 244 if (r < 0) 245 goto out; 246 247 r = ch341_set_handshake(dev, priv->line_control); 248 if (r < 0) 249 goto out; 250 251 /* expect 0x9f 0xee */ 252 r = ch341_get_status(dev, priv); 253 254 out: kfree(buffer); 255 return r; 256 } 257 ch341_port_probe(struct usb_serial_port * port)258 static int ch341_port_probe(struct usb_serial_port *port) 259 { 260 struct ch341_private *priv; 261 int r; 262 263 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 264 if (!priv) 265 return -ENOMEM; 266 267 spin_lock_init(&priv->lock); 268 priv->baud_rate = DEFAULT_BAUD_RATE; 269 270 r = ch341_configure(port->serial->dev, priv); 271 if (r < 0) 272 goto error; 273 274 usb_set_serial_port_data(port, priv); 275 return 0; 276 277 error: kfree(priv); 278 return r; 279 } 280 ch341_port_remove(struct usb_serial_port * port)281 static int ch341_port_remove(struct usb_serial_port *port) 282 { 283 struct ch341_private *priv; 284 285 priv = usb_get_serial_port_data(port); 286 kfree(priv); 287 288 return 0; 289 } 290 ch341_carrier_raised(struct usb_serial_port * port)291 static int ch341_carrier_raised(struct usb_serial_port *port) 292 { 293 struct ch341_private *priv = usb_get_serial_port_data(port); 294 if (priv->line_status & CH341_BIT_DCD) 295 return 1; 296 return 0; 297 } 298 ch341_dtr_rts(struct usb_serial_port * port,int on)299 static void ch341_dtr_rts(struct usb_serial_port *port, int on) 300 { 301 struct ch341_private *priv = usb_get_serial_port_data(port); 302 unsigned long flags; 303 304 /* drop DTR and RTS */ 305 spin_lock_irqsave(&priv->lock, flags); 306 if (on) 307 priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR; 308 else 309 priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR); 310 spin_unlock_irqrestore(&priv->lock, flags); 311 ch341_set_handshake(port->serial->dev, priv->line_control); 312 } 313 ch341_close(struct usb_serial_port * port)314 static void ch341_close(struct usb_serial_port *port) 315 { 316 usb_serial_generic_close(port); 317 usb_kill_urb(port->interrupt_in_urb); 318 } 319 320 321 /* open this device, set default parameters */ ch341_open(struct tty_struct * tty,struct usb_serial_port * port)322 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) 323 { 324 struct usb_serial *serial = port->serial; 325 struct ch341_private *priv = usb_get_serial_port_data(port); 326 int r; 327 328 r = ch341_configure(serial->dev, priv); 329 if (r) 330 return r; 331 332 if (tty) 333 ch341_set_termios(tty, port, NULL); 334 335 dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__); 336 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 337 if (r) { 338 dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n", 339 __func__, r); 340 return r; 341 } 342 343 r = usb_serial_generic_open(tty, port); 344 if (r) 345 goto err_kill_interrupt_urb; 346 347 return 0; 348 349 err_kill_interrupt_urb: 350 usb_kill_urb(port->interrupt_in_urb); 351 352 return r; 353 } 354 355 /* Old_termios contains the original termios settings and 356 * tty->termios contains the new setting to be used. 357 */ ch341_set_termios(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)358 static void ch341_set_termios(struct tty_struct *tty, 359 struct usb_serial_port *port, struct ktermios *old_termios) 360 { 361 struct ch341_private *priv = usb_get_serial_port_data(port); 362 unsigned baud_rate; 363 unsigned long flags; 364 365 baud_rate = tty_get_baud_rate(tty); 366 367 if (baud_rate) { 368 priv->baud_rate = baud_rate; 369 ch341_set_baudrate(port->serial->dev, priv); 370 } 371 372 /* Unimplemented: 373 * (cflag & CSIZE) : data bits [5, 8] 374 * (cflag & PARENB) : parity {NONE, EVEN, ODD} 375 * (cflag & CSTOPB) : stop bits [1, 2] 376 */ 377 378 spin_lock_irqsave(&priv->lock, flags); 379 if (C_BAUD(tty) == B0) 380 priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS); 381 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0) 382 priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS); 383 spin_unlock_irqrestore(&priv->lock, flags); 384 385 ch341_set_handshake(port->serial->dev, priv->line_control); 386 } 387 ch341_break_ctl(struct tty_struct * tty,int break_state)388 static void ch341_break_ctl(struct tty_struct *tty, int break_state) 389 { 390 const uint16_t ch341_break_reg = 391 CH341_REG_BREAK1 | ((uint16_t) CH341_REG_BREAK2 << 8); 392 struct usb_serial_port *port = tty->driver_data; 393 int r; 394 uint16_t reg_contents; 395 uint8_t *break_reg; 396 397 break_reg = kmalloc(2, GFP_KERNEL); 398 if (!break_reg) 399 return; 400 401 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG, 402 ch341_break_reg, 0, break_reg, 2); 403 if (r < 0) { 404 dev_err(&port->dev, "%s - USB control read error (%d)\n", 405 __func__, r); 406 goto out; 407 } 408 dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n", 409 __func__, break_reg[0], break_reg[1]); 410 if (break_state != 0) { 411 dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__); 412 break_reg[0] &= ~CH341_NBREAK_BITS_REG1; 413 break_reg[1] &= ~CH341_NBREAK_BITS_REG2; 414 } else { 415 dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__); 416 break_reg[0] |= CH341_NBREAK_BITS_REG1; 417 break_reg[1] |= CH341_NBREAK_BITS_REG2; 418 } 419 dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n", 420 __func__, break_reg[0], break_reg[1]); 421 reg_contents = get_unaligned_le16(break_reg); 422 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG, 423 ch341_break_reg, reg_contents); 424 if (r < 0) 425 dev_err(&port->dev, "%s - USB control write error (%d)\n", 426 __func__, r); 427 out: 428 kfree(break_reg); 429 } 430 ch341_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)431 static int ch341_tiocmset(struct tty_struct *tty, 432 unsigned int set, unsigned int clear) 433 { 434 struct usb_serial_port *port = tty->driver_data; 435 struct ch341_private *priv = usb_get_serial_port_data(port); 436 unsigned long flags; 437 u8 control; 438 439 spin_lock_irqsave(&priv->lock, flags); 440 if (set & TIOCM_RTS) 441 priv->line_control |= CH341_BIT_RTS; 442 if (set & TIOCM_DTR) 443 priv->line_control |= CH341_BIT_DTR; 444 if (clear & TIOCM_RTS) 445 priv->line_control &= ~CH341_BIT_RTS; 446 if (clear & TIOCM_DTR) 447 priv->line_control &= ~CH341_BIT_DTR; 448 control = priv->line_control; 449 spin_unlock_irqrestore(&priv->lock, flags); 450 451 return ch341_set_handshake(port->serial->dev, control); 452 } 453 ch341_update_line_status(struct usb_serial_port * port,unsigned char * data,size_t len)454 static void ch341_update_line_status(struct usb_serial_port *port, 455 unsigned char *data, size_t len) 456 { 457 struct ch341_private *priv = usb_get_serial_port_data(port); 458 struct tty_struct *tty; 459 unsigned long flags; 460 u8 status; 461 u8 delta; 462 463 if (len < 4) 464 return; 465 466 status = ~data[2] & CH341_BITS_MODEM_STAT; 467 468 spin_lock_irqsave(&priv->lock, flags); 469 delta = status ^ priv->line_status; 470 priv->line_status = status; 471 spin_unlock_irqrestore(&priv->lock, flags); 472 473 if (data[1] & CH341_MULT_STAT) 474 dev_dbg(&port->dev, "%s - multiple status change\n", __func__); 475 476 if (!delta) 477 return; 478 479 if (delta & CH341_BIT_CTS) 480 port->icount.cts++; 481 if (delta & CH341_BIT_DSR) 482 port->icount.dsr++; 483 if (delta & CH341_BIT_RI) 484 port->icount.rng++; 485 if (delta & CH341_BIT_DCD) { 486 port->icount.dcd++; 487 tty = tty_port_tty_get(&port->port); 488 if (tty) { 489 usb_serial_handle_dcd_change(port, tty, 490 status & CH341_BIT_DCD); 491 tty_kref_put(tty); 492 } 493 } 494 495 wake_up_interruptible(&port->port.delta_msr_wait); 496 } 497 ch341_read_int_callback(struct urb * urb)498 static void ch341_read_int_callback(struct urb *urb) 499 { 500 struct usb_serial_port *port = urb->context; 501 unsigned char *data = urb->transfer_buffer; 502 unsigned int len = urb->actual_length; 503 int status; 504 505 switch (urb->status) { 506 case 0: 507 /* success */ 508 break; 509 case -ECONNRESET: 510 case -ENOENT: 511 case -ESHUTDOWN: 512 /* this urb is terminated, clean up */ 513 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n", 514 __func__, urb->status); 515 return; 516 default: 517 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", 518 __func__, urb->status); 519 goto exit; 520 } 521 522 usb_serial_debug_data(&port->dev, __func__, len, data); 523 ch341_update_line_status(port, data, len); 524 exit: 525 status = usb_submit_urb(urb, GFP_ATOMIC); 526 if (status) { 527 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n", 528 __func__, status); 529 } 530 } 531 ch341_tiocmget(struct tty_struct * tty)532 static int ch341_tiocmget(struct tty_struct *tty) 533 { 534 struct usb_serial_port *port = tty->driver_data; 535 struct ch341_private *priv = usb_get_serial_port_data(port); 536 unsigned long flags; 537 u8 mcr; 538 u8 status; 539 unsigned int result; 540 541 spin_lock_irqsave(&priv->lock, flags); 542 mcr = priv->line_control; 543 status = priv->line_status; 544 spin_unlock_irqrestore(&priv->lock, flags); 545 546 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0) 547 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0) 548 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0) 549 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0) 550 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0) 551 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0); 552 553 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 554 555 return result; 556 } 557 ch341_reset_resume(struct usb_serial * serial)558 static int ch341_reset_resume(struct usb_serial *serial) 559 { 560 struct usb_serial_port *port = serial->port[0]; 561 struct ch341_private *priv; 562 int ret; 563 564 priv = usb_get_serial_port_data(port); 565 if (!priv) 566 return 0; 567 568 /* reconfigure ch341 serial port after bus-reset */ 569 ch341_configure(serial->dev, priv); 570 571 if (test_bit(ASYNCB_INITIALIZED, &port->port.flags)) { 572 ret = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 573 if (ret) { 574 dev_err(&port->dev, "failed to submit interrupt urb: %d\n", 575 ret); 576 return ret; 577 } 578 } 579 580 return usb_serial_generic_resume(serial); 581 } 582 583 static struct usb_serial_driver ch341_device = { 584 .driver = { 585 .owner = THIS_MODULE, 586 .name = "ch341-uart", 587 }, 588 .id_table = id_table, 589 .num_ports = 1, 590 .open = ch341_open, 591 .dtr_rts = ch341_dtr_rts, 592 .carrier_raised = ch341_carrier_raised, 593 .close = ch341_close, 594 .set_termios = ch341_set_termios, 595 .break_ctl = ch341_break_ctl, 596 .tiocmget = ch341_tiocmget, 597 .tiocmset = ch341_tiocmset, 598 .tiocmiwait = usb_serial_generic_tiocmiwait, 599 .read_int_callback = ch341_read_int_callback, 600 .port_probe = ch341_port_probe, 601 .port_remove = ch341_port_remove, 602 .reset_resume = ch341_reset_resume, 603 }; 604 605 static struct usb_serial_driver * const serial_drivers[] = { 606 &ch341_device, NULL 607 }; 608 609 module_usb_serial_driver(serial_drivers, id_table); 610 611 MODULE_LICENSE("GPL"); 612