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_READ_VERSION 0x5F 65 #define CH341_REQ_WRITE_REG 0x9A 66 #define CH341_REQ_READ_REG 0x95 67 #define CH341_REQ_SERIAL_INIT 0xA1 68 #define CH341_REQ_MODEM_CTRL 0xA4 69 70 #define CH341_REG_BREAK 0x05 71 #define CH341_REG_LCR 0x18 72 #define CH341_NBREAK_BITS 0x01 73 74 #define CH341_LCR_ENABLE_RX 0x80 75 #define CH341_LCR_ENABLE_TX 0x40 76 #define CH341_LCR_MARK_SPACE 0x20 77 #define CH341_LCR_PAR_EVEN 0x10 78 #define CH341_LCR_ENABLE_PAR 0x08 79 #define CH341_LCR_STOP_BITS_2 0x04 80 #define CH341_LCR_CS8 0x03 81 #define CH341_LCR_CS7 0x02 82 #define CH341_LCR_CS6 0x01 83 #define CH341_LCR_CS5 0x00 84 85 static const struct usb_device_id id_table[] = { 86 { USB_DEVICE(0x4348, 0x5523) }, 87 { USB_DEVICE(0x1a86, 0x7523) }, 88 { USB_DEVICE(0x1a86, 0x5523) }, 89 { }, 90 }; 91 MODULE_DEVICE_TABLE(usb, id_table); 92 93 struct ch341_private { 94 spinlock_t lock; /* access lock */ 95 unsigned baud_rate; /* set baud rate */ 96 u8 line_control; /* set line control value RTS/DTR */ 97 u8 line_status; /* active status of modem control inputs */ 98 }; 99 100 static void ch341_set_termios(struct tty_struct *tty, 101 struct usb_serial_port *port, 102 struct ktermios *old_termios); 103 104 static int ch341_control_out(struct usb_device *dev, u8 request, 105 u16 value, u16 index) 106 { 107 int r; 108 109 dev_dbg(&dev->dev, "ch341_control_out(%02x,%02x,%04x,%04x)\n", 110 USB_DIR_OUT|0x40, (int)request, (int)value, (int)index); 111 112 r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 113 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 114 value, index, NULL, 0, DEFAULT_TIMEOUT); 115 116 return r; 117 } 118 119 static int ch341_control_in(struct usb_device *dev, 120 u8 request, u16 value, u16 index, 121 char *buf, unsigned bufsize) 122 { 123 int r; 124 125 dev_dbg(&dev->dev, "ch341_control_in(%02x,%02x,%04x,%04x,%p,%u)\n", 126 USB_DIR_IN|0x40, (int)request, (int)value, (int)index, buf, 127 (int)bufsize); 128 129 r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 130 USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 131 value, index, buf, bufsize, DEFAULT_TIMEOUT); 132 return r; 133 } 134 135 static int ch341_init_set_baudrate(struct usb_device *dev, 136 struct ch341_private *priv, unsigned ctrl) 137 { 138 short a; 139 int r; 140 unsigned long factor; 141 short divisor; 142 143 if (!priv->baud_rate) 144 return -EINVAL; 145 factor = (CH341_BAUDBASE_FACTOR / priv->baud_rate); 146 divisor = CH341_BAUDBASE_DIVMAX; 147 148 while ((factor > 0xfff0) && divisor) { 149 factor >>= 3; 150 divisor--; 151 } 152 153 if (factor > 0xfff0) 154 return -EINVAL; 155 156 factor = 0x10000 - factor; 157 a = (factor & 0xff00) | divisor; 158 159 /* 0x9c is "enable SFR_UART Control register and timer" */ 160 r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 161 0x9c | (ctrl << 8), a | 0x80); 162 163 return r; 164 } 165 166 static int ch341_set_handshake(struct usb_device *dev, u8 control) 167 { 168 return ch341_control_out(dev, CH341_REQ_MODEM_CTRL, ~control, 0); 169 } 170 171 static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 172 { 173 char *buffer; 174 int r; 175 const unsigned size = 8; 176 unsigned long flags; 177 178 buffer = kmalloc(size, GFP_KERNEL); 179 if (!buffer) 180 return -ENOMEM; 181 182 r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x0706, 0, buffer, size); 183 if (r < 0) 184 goto out; 185 186 /* setup the private status if available */ 187 if (r == 2) { 188 r = 0; 189 spin_lock_irqsave(&priv->lock, flags); 190 priv->line_status = (~(*buffer)) & CH341_BITS_MODEM_STAT; 191 spin_unlock_irqrestore(&priv->lock, flags); 192 } else 193 r = -EPROTO; 194 195 out: kfree(buffer); 196 return r; 197 } 198 199 /* -------------------------------------------------------------------------- */ 200 201 static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 202 { 203 char *buffer; 204 int r; 205 const unsigned size = 8; 206 207 buffer = kmalloc(size, GFP_KERNEL); 208 if (!buffer) 209 return -ENOMEM; 210 211 /* expect two bytes 0x27 0x00 */ 212 r = ch341_control_in(dev, CH341_REQ_READ_VERSION, 0, 0, buffer, size); 213 if (r < 0) 214 goto out; 215 dev_dbg(&dev->dev, "Chip version: 0x%02x\n", buffer[0]); 216 217 r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 0, 0); 218 if (r < 0) 219 goto out; 220 221 /* expect two bytes 0x56 0x00 */ 222 r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x2518, 0, buffer, size); 223 if (r < 0) 224 goto out; 225 226 r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 0x2518, 0x0050); 227 if (r < 0) 228 goto out; 229 230 /* expect 0xff 0xee */ 231 r = ch341_get_status(dev, priv); 232 if (r < 0) 233 goto out; 234 235 r = ch341_init_set_baudrate(dev, priv, 0); 236 if (r < 0) 237 goto out; 238 239 r = ch341_set_handshake(dev, priv->line_control); 240 if (r < 0) 241 goto out; 242 243 /* expect 0x9f 0xee */ 244 r = ch341_get_status(dev, priv); 245 246 out: kfree(buffer); 247 return r; 248 } 249 250 static int ch341_port_probe(struct usb_serial_port *port) 251 { 252 struct ch341_private *priv; 253 int r; 254 255 priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 256 if (!priv) 257 return -ENOMEM; 258 259 spin_lock_init(&priv->lock); 260 priv->baud_rate = DEFAULT_BAUD_RATE; 261 priv->line_control = CH341_BIT_RTS | CH341_BIT_DTR; 262 263 r = ch341_configure(port->serial->dev, priv); 264 if (r < 0) 265 goto error; 266 267 usb_set_serial_port_data(port, priv); 268 return 0; 269 270 error: kfree(priv); 271 return r; 272 } 273 274 static int ch341_port_remove(struct usb_serial_port *port) 275 { 276 struct ch341_private *priv; 277 278 priv = usb_get_serial_port_data(port); 279 kfree(priv); 280 281 return 0; 282 } 283 284 static int ch341_carrier_raised(struct usb_serial_port *port) 285 { 286 struct ch341_private *priv = usb_get_serial_port_data(port); 287 if (priv->line_status & CH341_BIT_DCD) 288 return 1; 289 return 0; 290 } 291 292 static void ch341_dtr_rts(struct usb_serial_port *port, int on) 293 { 294 struct ch341_private *priv = usb_get_serial_port_data(port); 295 unsigned long flags; 296 297 /* drop DTR and RTS */ 298 spin_lock_irqsave(&priv->lock, flags); 299 if (on) 300 priv->line_control |= CH341_BIT_RTS | CH341_BIT_DTR; 301 else 302 priv->line_control &= ~(CH341_BIT_RTS | CH341_BIT_DTR); 303 spin_unlock_irqrestore(&priv->lock, flags); 304 ch341_set_handshake(port->serial->dev, priv->line_control); 305 } 306 307 static void ch341_close(struct usb_serial_port *port) 308 { 309 usb_serial_generic_close(port); 310 usb_kill_urb(port->interrupt_in_urb); 311 } 312 313 314 /* open this device, set default parameters */ 315 static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) 316 { 317 struct usb_serial *serial = port->serial; 318 struct ch341_private *priv = usb_get_serial_port_data(port); 319 int r; 320 321 r = ch341_configure(serial->dev, priv); 322 if (r) 323 goto out; 324 325 if (tty) 326 ch341_set_termios(tty, port, NULL); 327 328 dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__); 329 r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 330 if (r) { 331 dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n", 332 __func__, r); 333 goto out; 334 } 335 336 r = usb_serial_generic_open(tty, port); 337 338 out: return r; 339 } 340 341 /* Old_termios contains the original termios settings and 342 * tty->termios contains the new setting to be used. 343 */ 344 static void ch341_set_termios(struct tty_struct *tty, 345 struct usb_serial_port *port, struct ktermios *old_termios) 346 { 347 struct ch341_private *priv = usb_get_serial_port_data(port); 348 unsigned baud_rate; 349 unsigned long flags; 350 unsigned char ctrl; 351 int r; 352 353 /* redundant changes may cause the chip to lose bytes */ 354 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios)) 355 return; 356 357 baud_rate = tty_get_baud_rate(tty); 358 359 priv->baud_rate = baud_rate; 360 ctrl = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX; 361 362 switch (C_CSIZE(tty)) { 363 case CS5: 364 ctrl |= CH341_LCR_CS5; 365 break; 366 case CS6: 367 ctrl |= CH341_LCR_CS6; 368 break; 369 case CS7: 370 ctrl |= CH341_LCR_CS7; 371 break; 372 case CS8: 373 ctrl |= CH341_LCR_CS8; 374 break; 375 } 376 377 if (C_PARENB(tty)) { 378 ctrl |= CH341_LCR_ENABLE_PAR; 379 if (C_PARODD(tty) == 0) 380 ctrl |= CH341_LCR_PAR_EVEN; 381 if (C_CMSPAR(tty)) 382 ctrl |= CH341_LCR_MARK_SPACE; 383 } 384 385 if (C_CSTOPB(tty)) 386 ctrl |= CH341_LCR_STOP_BITS_2; 387 388 if (baud_rate) { 389 spin_lock_irqsave(&priv->lock, flags); 390 priv->line_control |= (CH341_BIT_DTR | CH341_BIT_RTS); 391 spin_unlock_irqrestore(&priv->lock, flags); 392 r = ch341_init_set_baudrate(port->serial->dev, priv, ctrl); 393 if (r < 0 && old_termios) { 394 priv->baud_rate = tty_termios_baud_rate(old_termios); 395 tty_termios_copy_hw(&tty->termios, old_termios); 396 } 397 } else { 398 spin_lock_irqsave(&priv->lock, flags); 399 priv->line_control &= ~(CH341_BIT_DTR | CH341_BIT_RTS); 400 spin_unlock_irqrestore(&priv->lock, flags); 401 } 402 403 ch341_set_handshake(port->serial->dev, priv->line_control); 404 405 } 406 407 static void ch341_break_ctl(struct tty_struct *tty, int break_state) 408 { 409 const uint16_t ch341_break_reg = 410 ((uint16_t) CH341_REG_LCR << 8) | CH341_REG_BREAK; 411 struct usb_serial_port *port = tty->driver_data; 412 int r; 413 uint16_t reg_contents; 414 uint8_t *break_reg; 415 416 break_reg = kmalloc(2, GFP_KERNEL); 417 if (!break_reg) 418 return; 419 420 r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG, 421 ch341_break_reg, 0, break_reg, 2); 422 if (r < 0) { 423 dev_err(&port->dev, "%s - USB control read error (%d)\n", 424 __func__, r); 425 goto out; 426 } 427 dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n", 428 __func__, break_reg[0], break_reg[1]); 429 if (break_state != 0) { 430 dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__); 431 break_reg[0] &= ~CH341_NBREAK_BITS; 432 break_reg[1] &= ~CH341_LCR_ENABLE_TX; 433 } else { 434 dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__); 435 break_reg[0] |= CH341_NBREAK_BITS; 436 break_reg[1] |= CH341_LCR_ENABLE_TX; 437 } 438 dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n", 439 __func__, break_reg[0], break_reg[1]); 440 reg_contents = get_unaligned_le16(break_reg); 441 r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG, 442 ch341_break_reg, reg_contents); 443 if (r < 0) 444 dev_err(&port->dev, "%s - USB control write error (%d)\n", 445 __func__, r); 446 out: 447 kfree(break_reg); 448 } 449 450 static int ch341_tiocmset(struct tty_struct *tty, 451 unsigned int set, unsigned int clear) 452 { 453 struct usb_serial_port *port = tty->driver_data; 454 struct ch341_private *priv = usb_get_serial_port_data(port); 455 unsigned long flags; 456 u8 control; 457 458 spin_lock_irqsave(&priv->lock, flags); 459 if (set & TIOCM_RTS) 460 priv->line_control |= CH341_BIT_RTS; 461 if (set & TIOCM_DTR) 462 priv->line_control |= CH341_BIT_DTR; 463 if (clear & TIOCM_RTS) 464 priv->line_control &= ~CH341_BIT_RTS; 465 if (clear & TIOCM_DTR) 466 priv->line_control &= ~CH341_BIT_DTR; 467 control = priv->line_control; 468 spin_unlock_irqrestore(&priv->lock, flags); 469 470 return ch341_set_handshake(port->serial->dev, control); 471 } 472 473 static void ch341_update_line_status(struct usb_serial_port *port, 474 unsigned char *data, size_t len) 475 { 476 struct ch341_private *priv = usb_get_serial_port_data(port); 477 struct tty_struct *tty; 478 unsigned long flags; 479 u8 status; 480 u8 delta; 481 482 if (len < 4) 483 return; 484 485 status = ~data[2] & CH341_BITS_MODEM_STAT; 486 487 spin_lock_irqsave(&priv->lock, flags); 488 delta = status ^ priv->line_status; 489 priv->line_status = status; 490 spin_unlock_irqrestore(&priv->lock, flags); 491 492 if (data[1] & CH341_MULT_STAT) 493 dev_dbg(&port->dev, "%s - multiple status change\n", __func__); 494 495 if (!delta) 496 return; 497 498 if (delta & CH341_BIT_CTS) 499 port->icount.cts++; 500 if (delta & CH341_BIT_DSR) 501 port->icount.dsr++; 502 if (delta & CH341_BIT_RI) 503 port->icount.rng++; 504 if (delta & CH341_BIT_DCD) { 505 port->icount.dcd++; 506 tty = tty_port_tty_get(&port->port); 507 if (tty) { 508 usb_serial_handle_dcd_change(port, tty, 509 status & CH341_BIT_DCD); 510 tty_kref_put(tty); 511 } 512 } 513 514 wake_up_interruptible(&port->port.delta_msr_wait); 515 } 516 517 static void ch341_read_int_callback(struct urb *urb) 518 { 519 struct usb_serial_port *port = urb->context; 520 unsigned char *data = urb->transfer_buffer; 521 unsigned int len = urb->actual_length; 522 int status; 523 524 switch (urb->status) { 525 case 0: 526 /* success */ 527 break; 528 case -ECONNRESET: 529 case -ENOENT: 530 case -ESHUTDOWN: 531 /* this urb is terminated, clean up */ 532 dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n", 533 __func__, urb->status); 534 return; 535 default: 536 dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", 537 __func__, urb->status); 538 goto exit; 539 } 540 541 usb_serial_debug_data(&port->dev, __func__, len, data); 542 ch341_update_line_status(port, data, len); 543 exit: 544 status = usb_submit_urb(urb, GFP_ATOMIC); 545 if (status) { 546 dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n", 547 __func__, status); 548 } 549 } 550 551 static int ch341_tiocmget(struct tty_struct *tty) 552 { 553 struct usb_serial_port *port = tty->driver_data; 554 struct ch341_private *priv = usb_get_serial_port_data(port); 555 unsigned long flags; 556 u8 mcr; 557 u8 status; 558 unsigned int result; 559 560 spin_lock_irqsave(&priv->lock, flags); 561 mcr = priv->line_control; 562 status = priv->line_status; 563 spin_unlock_irqrestore(&priv->lock, flags); 564 565 result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0) 566 | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0) 567 | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0) 568 | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0) 569 | ((status & CH341_BIT_RI) ? TIOCM_RI : 0) 570 | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0); 571 572 dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 573 574 return result; 575 } 576 577 static int ch341_reset_resume(struct usb_serial *serial) 578 { 579 struct ch341_private *priv; 580 581 priv = usb_get_serial_port_data(serial->port[0]); 582 583 /* reconfigure ch341 serial port after bus-reset */ 584 ch341_configure(serial->dev, priv); 585 586 return 0; 587 } 588 589 static struct usb_serial_driver ch341_device = { 590 .driver = { 591 .owner = THIS_MODULE, 592 .name = "ch341-uart", 593 }, 594 .id_table = id_table, 595 .num_ports = 1, 596 .open = ch341_open, 597 .dtr_rts = ch341_dtr_rts, 598 .carrier_raised = ch341_carrier_raised, 599 .close = ch341_close, 600 .set_termios = ch341_set_termios, 601 .break_ctl = ch341_break_ctl, 602 .tiocmget = ch341_tiocmget, 603 .tiocmset = ch341_tiocmset, 604 .tiocmiwait = usb_serial_generic_tiocmiwait, 605 .read_int_callback = ch341_read_int_callback, 606 .port_probe = ch341_port_probe, 607 .port_remove = ch341_port_remove, 608 .reset_resume = ch341_reset_resume, 609 }; 610 611 static struct usb_serial_driver * const serial_drivers[] = { 612 &ch341_device, NULL 613 }; 614 615 module_usb_serial_driver(serial_drivers, id_table); 616 617 MODULE_LICENSE("GPL"); 618