15fd54aceSGreg Kroah-Hartman // SPDX-License-Identifier: GPL-2.0 26ce76104SFrank A Kingswood /* 36ce76104SFrank A Kingswood * Copyright 2007, Frank A Kingswood <frank@kingswood-consulting.co.uk> 4664d5df9SWerner Cornelius * Copyright 2007, Werner Cornelius <werner@cornelius-consult.de> 5664d5df9SWerner Cornelius * Copyright 2009, Boris Hajduk <boris@hajduk.org> 66ce76104SFrank A Kingswood * 76ce76104SFrank A Kingswood * ch341.c implements a serial port driver for the Winchiphead CH341. 86ce76104SFrank A Kingswood * 96ce76104SFrank A Kingswood * The CH341 device can be used to implement an RS232 asynchronous 106ce76104SFrank A Kingswood * serial port, an IEEE-1284 parallel printer port or a memory-like 116ce76104SFrank A Kingswood * interface. In all cases the CH341 supports an I2C interface as well. 126ce76104SFrank A Kingswood * This driver only supports the asynchronous serial interface. 136ce76104SFrank A Kingswood */ 146ce76104SFrank A Kingswood 156ce76104SFrank A Kingswood #include <linux/kernel.h> 166ce76104SFrank A Kingswood #include <linux/tty.h> 176ce76104SFrank A Kingswood #include <linux/module.h> 185a0e3ad6STejun Heo #include <linux/slab.h> 196ce76104SFrank A Kingswood #include <linux/usb.h> 206ce76104SFrank A Kingswood #include <linux/usb/serial.h> 216ce76104SFrank A Kingswood #include <linux/serial.h> 225be796f0SJohan Hovold #include <asm/unaligned.h> 236ce76104SFrank A Kingswood 24664d5df9SWerner Cornelius #define DEFAULT_BAUD_RATE 9600 256ce76104SFrank A Kingswood #define DEFAULT_TIMEOUT 1000 266ce76104SFrank A Kingswood 27664d5df9SWerner Cornelius /* flags for IO-Bits */ 28664d5df9SWerner Cornelius #define CH341_BIT_RTS (1 << 6) 29664d5df9SWerner Cornelius #define CH341_BIT_DTR (1 << 5) 30664d5df9SWerner Cornelius 31664d5df9SWerner Cornelius /******************************/ 32664d5df9SWerner Cornelius /* interrupt pipe definitions */ 33664d5df9SWerner Cornelius /******************************/ 34664d5df9SWerner Cornelius /* always 4 interrupt bytes */ 35664d5df9SWerner Cornelius /* first irq byte normally 0x08 */ 36664d5df9SWerner Cornelius /* second irq byte base 0x7d + below */ 37664d5df9SWerner Cornelius /* third irq byte base 0x94 + below */ 38664d5df9SWerner Cornelius /* fourth irq byte normally 0xee */ 39664d5df9SWerner Cornelius 40664d5df9SWerner Cornelius /* second interrupt byte */ 41664d5df9SWerner Cornelius #define CH341_MULT_STAT 0x04 /* multiple status since last interrupt event */ 42664d5df9SWerner Cornelius 43664d5df9SWerner Cornelius /* status returned in third interrupt answer byte, inverted in data 44664d5df9SWerner Cornelius from irq */ 45664d5df9SWerner Cornelius #define CH341_BIT_CTS 0x01 46664d5df9SWerner Cornelius #define CH341_BIT_DSR 0x02 47664d5df9SWerner Cornelius #define CH341_BIT_RI 0x04 48664d5df9SWerner Cornelius #define CH341_BIT_DCD 0x08 49664d5df9SWerner Cornelius #define CH341_BITS_MODEM_STAT 0x0f /* all bits */ 50664d5df9SWerner Cornelius 51492896f0STim Small /* Break support - the information used to implement this was gleaned from 52492896f0STim Small * the Net/FreeBSD uchcom.c driver by Takanori Watanabe. Domo arigato. 53492896f0STim Small */ 54492896f0STim Small 556fde8d29SAidan Thornton #define CH341_REQ_READ_VERSION 0x5F 56492896f0STim Small #define CH341_REQ_WRITE_REG 0x9A 57492896f0STim Small #define CH341_REQ_READ_REG 0x95 586fde8d29SAidan Thornton #define CH341_REQ_SERIAL_INIT 0xA1 596fde8d29SAidan Thornton #define CH341_REQ_MODEM_CTRL 0xA4 60492896f0STim Small 616fde8d29SAidan Thornton #define CH341_REG_BREAK 0x05 622c509d1cSMichael Hanselmann #define CH341_REG_PRESCALER 0x12 632c509d1cSMichael Hanselmann #define CH341_REG_DIVISOR 0x13 646fde8d29SAidan Thornton #define CH341_REG_LCR 0x18 652c509d1cSMichael Hanselmann #define CH341_REG_LCR2 0x25 662c509d1cSMichael Hanselmann 676fde8d29SAidan Thornton #define CH341_NBREAK_BITS 0x01 686fde8d29SAidan Thornton 696fde8d29SAidan Thornton #define CH341_LCR_ENABLE_RX 0x80 706fde8d29SAidan Thornton #define CH341_LCR_ENABLE_TX 0x40 716fde8d29SAidan Thornton #define CH341_LCR_MARK_SPACE 0x20 726fde8d29SAidan Thornton #define CH341_LCR_PAR_EVEN 0x10 736fde8d29SAidan Thornton #define CH341_LCR_ENABLE_PAR 0x08 746fde8d29SAidan Thornton #define CH341_LCR_STOP_BITS_2 0x04 756fde8d29SAidan Thornton #define CH341_LCR_CS8 0x03 766fde8d29SAidan Thornton #define CH341_LCR_CS7 0x02 776fde8d29SAidan Thornton #define CH341_LCR_CS6 0x01 786fde8d29SAidan Thornton #define CH341_LCR_CS5 0x00 79492896f0STim Small 80c432df15SJohan Hovold #define CH341_QUIRK_LIMITED_PRESCALER BIT(0) 810580baa4SMichael Hanselmann #define CH341_QUIRK_SIMULATE_BREAK BIT(1) 82c432df15SJohan Hovold 837d40d7e8SNémeth Márton static const struct usb_device_id id_table[] = { 846ce76104SFrank A Kingswood { USB_DEVICE(0x4348, 0x5523) }, 8582078234SMichael F. Robbins { USB_DEVICE(0x1a86, 0x7523) }, 86d0781383Swangyanqing { USB_DEVICE(0x1a86, 0x5523) }, 876ce76104SFrank A Kingswood { }, 886ce76104SFrank A Kingswood }; 896ce76104SFrank A Kingswood MODULE_DEVICE_TABLE(usb, id_table); 906ce76104SFrank A Kingswood 916ce76104SFrank A Kingswood struct ch341_private { 92664d5df9SWerner Cornelius spinlock_t lock; /* access lock */ 93664d5df9SWerner Cornelius unsigned baud_rate; /* set baud rate */ 94beea33d4SJohan Hovold u8 mcr; 95e8024460SJohan Hovold u8 msr; 963cca8624SJohan Hovold u8 lcr; 97c404bf4aSMichael Hanselmann unsigned long quirks; 980580baa4SMichael Hanselmann unsigned long break_end; 996ce76104SFrank A Kingswood }; 1006ce76104SFrank A Kingswood 101aa91def4SNicolas PLANEL static void ch341_set_termios(struct tty_struct *tty, 102aa91def4SNicolas PLANEL struct usb_serial_port *port, 103aa91def4SNicolas PLANEL struct ktermios *old_termios); 104aa91def4SNicolas PLANEL 1056ce76104SFrank A Kingswood static int ch341_control_out(struct usb_device *dev, u8 request, 1066ce76104SFrank A Kingswood u16 value, u16 index) 1076ce76104SFrank A Kingswood { 1086ce76104SFrank A Kingswood int r; 10979cbeeafSGreg Kroah-Hartman 11091e0efcdSJohan Hovold dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x)\n", __func__, 11191e0efcdSJohan Hovold request, value, index); 1126ce76104SFrank A Kingswood 1136ce76104SFrank A Kingswood r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 1146ce76104SFrank A Kingswood USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 1156ce76104SFrank A Kingswood value, index, NULL, 0, DEFAULT_TIMEOUT); 1162d5a9c72SJohan Hovold if (r < 0) 1172d5a9c72SJohan Hovold dev_err(&dev->dev, "failed to send control message: %d\n", r); 1186ce76104SFrank A Kingswood 1196ce76104SFrank A Kingswood return r; 1206ce76104SFrank A Kingswood } 1216ce76104SFrank A Kingswood 1226ce76104SFrank A Kingswood static int ch341_control_in(struct usb_device *dev, 1236ce76104SFrank A Kingswood u8 request, u16 value, u16 index, 1246ce76104SFrank A Kingswood char *buf, unsigned bufsize) 1256ce76104SFrank A Kingswood { 1266ce76104SFrank A Kingswood int r; 12779cbeeafSGreg Kroah-Hartman 12891e0efcdSJohan Hovold dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x,%u)\n", __func__, 12991e0efcdSJohan Hovold request, value, index, bufsize); 1306ce76104SFrank A Kingswood 1316ce76104SFrank A Kingswood r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 1326ce76104SFrank A Kingswood USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 1336ce76104SFrank A Kingswood value, index, buf, bufsize, DEFAULT_TIMEOUT); 134e33eab9dSDan Carpenter if (r < (int)bufsize) { 1352d5a9c72SJohan Hovold if (r >= 0) { 1362d5a9c72SJohan Hovold dev_err(&dev->dev, 1372d5a9c72SJohan Hovold "short control message received (%d < %u)\n", 1382d5a9c72SJohan Hovold r, bufsize); 1392d5a9c72SJohan Hovold r = -EIO; 1402d5a9c72SJohan Hovold } 1412d5a9c72SJohan Hovold 1422d5a9c72SJohan Hovold dev_err(&dev->dev, "failed to receive control message: %d\n", 1432d5a9c72SJohan Hovold r); 1446ce76104SFrank A Kingswood return r; 1456ce76104SFrank A Kingswood } 1466ce76104SFrank A Kingswood 1472d5a9c72SJohan Hovold return 0; 1482d5a9c72SJohan Hovold } 1492d5a9c72SJohan Hovold 15035714565SJohan Hovold #define CH341_CLKRATE 48000000 15135714565SJohan Hovold #define CH341_CLK_DIV(ps, fact) (1 << (12 - 3 * (ps) - (fact))) 15235714565SJohan Hovold #define CH341_MIN_RATE(ps) (CH341_CLKRATE / (CH341_CLK_DIV((ps), 1) * 512)) 15335714565SJohan Hovold 15435714565SJohan Hovold static const speed_t ch341_min_rates[] = { 15535714565SJohan Hovold CH341_MIN_RATE(0), 15635714565SJohan Hovold CH341_MIN_RATE(1), 15735714565SJohan Hovold CH341_MIN_RATE(2), 15835714565SJohan Hovold CH341_MIN_RATE(3), 15935714565SJohan Hovold }; 16035714565SJohan Hovold 16186f6da29SJohan Hovold /* Supported range is 46 to 3000000 bps. */ 16286f6da29SJohan Hovold #define CH341_MIN_BPS DIV_ROUND_UP(CH341_CLKRATE, CH341_CLK_DIV(0, 0) * 256) 16386f6da29SJohan Hovold #define CH341_MAX_BPS (CH341_CLKRATE / (CH341_CLK_DIV(3, 0) * 2)) 16486f6da29SJohan Hovold 16535714565SJohan Hovold /* 16635714565SJohan Hovold * The device line speed is given by the following equation: 16735714565SJohan Hovold * 16835714565SJohan Hovold * baudrate = 48000000 / (2^(12 - 3 * ps - fact) * div), where 16935714565SJohan Hovold * 17035714565SJohan Hovold * 0 <= ps <= 3, 17135714565SJohan Hovold * 0 <= fact <= 1, 17235714565SJohan Hovold * 2 <= div <= 256 if fact = 0, or 17335714565SJohan Hovold * 9 <= div <= 256 if fact = 1 17435714565SJohan Hovold */ 1750580baa4SMichael Hanselmann static int ch341_get_divisor(struct ch341_private *priv, speed_t speed) 17635714565SJohan Hovold { 17735714565SJohan Hovold unsigned int fact, div, clk_div; 178c432df15SJohan Hovold bool force_fact0 = false; 17935714565SJohan Hovold int ps; 18035714565SJohan Hovold 18135714565SJohan Hovold /* 18235714565SJohan Hovold * Clamp to supported range, this makes the (ps < 0) and (div < 2) 18335714565SJohan Hovold * sanity checks below redundant. 18435714565SJohan Hovold */ 18586f6da29SJohan Hovold speed = clamp_val(speed, CH341_MIN_BPS, CH341_MAX_BPS); 18635714565SJohan Hovold 18735714565SJohan Hovold /* 18835714565SJohan Hovold * Start with highest possible base clock (fact = 1) that will give a 18935714565SJohan Hovold * divisor strictly less than 512. 19035714565SJohan Hovold */ 19135714565SJohan Hovold fact = 1; 19235714565SJohan Hovold for (ps = 3; ps >= 0; ps--) { 19335714565SJohan Hovold if (speed > ch341_min_rates[ps]) 19435714565SJohan Hovold break; 19535714565SJohan Hovold } 19635714565SJohan Hovold 19735714565SJohan Hovold if (ps < 0) 19835714565SJohan Hovold return -EINVAL; 19935714565SJohan Hovold 20035714565SJohan Hovold /* Determine corresponding divisor, rounding down. */ 20135714565SJohan Hovold clk_div = CH341_CLK_DIV(ps, fact); 20235714565SJohan Hovold div = CH341_CLKRATE / (clk_div * speed); 20335714565SJohan Hovold 204c432df15SJohan Hovold /* Some devices require a lower base clock if ps < 3. */ 205c432df15SJohan Hovold if (ps < 3 && (priv->quirks & CH341_QUIRK_LIMITED_PRESCALER)) 206c432df15SJohan Hovold force_fact0 = true; 207c432df15SJohan Hovold 20835714565SJohan Hovold /* Halve base clock (fact = 0) if required. */ 209c432df15SJohan Hovold if (div < 9 || div > 255 || force_fact0) { 21035714565SJohan Hovold div /= 2; 21135714565SJohan Hovold clk_div *= 2; 21235714565SJohan Hovold fact = 0; 21335714565SJohan Hovold } 21435714565SJohan Hovold 21535714565SJohan Hovold if (div < 2) 21635714565SJohan Hovold return -EINVAL; 21735714565SJohan Hovold 21835714565SJohan Hovold /* 21935714565SJohan Hovold * Pick next divisor if resulting rate is closer to the requested one, 22035714565SJohan Hovold * scale up to avoid rounding errors on low rates. 22135714565SJohan Hovold */ 22235714565SJohan Hovold if (16 * CH341_CLKRATE / (clk_div * div) - 16 * speed >= 22335714565SJohan Hovold 16 * speed - 16 * CH341_CLKRATE / (clk_div * (div + 1))) 22435714565SJohan Hovold div++; 22535714565SJohan Hovold 2267c3d0228SJohan Hovold /* 2277c3d0228SJohan Hovold * Prefer lower base clock (fact = 0) if even divisor. 2287c3d0228SJohan Hovold * 2297c3d0228SJohan Hovold * Note that this makes the receiver more tolerant to errors. 2307c3d0228SJohan Hovold */ 2317c3d0228SJohan Hovold if (fact == 1 && div % 2 == 0) { 2327c3d0228SJohan Hovold div /= 2; 2337c3d0228SJohan Hovold fact = 0; 2347c3d0228SJohan Hovold } 2357c3d0228SJohan Hovold 23635714565SJohan Hovold return (0x100 - div) << 8 | fact << 2 | ps; 23735714565SJohan Hovold } 23835714565SJohan Hovold 23955fa15b5SJohan Hovold static int ch341_set_baudrate_lcr(struct usb_device *dev, 2400580baa4SMichael Hanselmann struct ch341_private *priv, 2410580baa4SMichael Hanselmann speed_t baud_rate, u8 lcr) 2426ce76104SFrank A Kingswood { 24335714565SJohan Hovold int val; 2446ce76104SFrank A Kingswood int r; 2456ce76104SFrank A Kingswood 2460580baa4SMichael Hanselmann if (!baud_rate) 2476ce76104SFrank A Kingswood return -EINVAL; 248664d5df9SWerner Cornelius 2490580baa4SMichael Hanselmann val = ch341_get_divisor(priv, baud_rate); 25035714565SJohan Hovold if (val < 0) 251664d5df9SWerner Cornelius return -EINVAL; 252664d5df9SWerner Cornelius 25355fa15b5SJohan Hovold /* 25455fa15b5SJohan Hovold * CH341A buffers data until a full endpoint-size packet (32 bytes) 25555fa15b5SJohan Hovold * has been received unless bit 7 is set. 25655fa15b5SJohan Hovold */ 25735714565SJohan Hovold val |= BIT(7); 25855fa15b5SJohan Hovold 2592c509d1cSMichael Hanselmann r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 2602c509d1cSMichael Hanselmann CH341_REG_DIVISOR << 8 | CH341_REG_PRESCALER, 2612c509d1cSMichael Hanselmann val); 26255fa15b5SJohan Hovold if (r) 26355fa15b5SJohan Hovold return r; 26455fa15b5SJohan Hovold 2652c509d1cSMichael Hanselmann /* 2662c509d1cSMichael Hanselmann * Chip versions before version 0x30 as read using 2672c509d1cSMichael Hanselmann * CH341_REQ_READ_VERSION used separate registers for line control 2682c509d1cSMichael Hanselmann * (stop bits, parity and word length). Version 0x30 and above use 2692c509d1cSMichael Hanselmann * CH341_REG_LCR only and CH341_REG_LCR2 is always set to zero. 2702c509d1cSMichael Hanselmann */ 2712c509d1cSMichael Hanselmann r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 2722c509d1cSMichael Hanselmann CH341_REG_LCR2 << 8 | CH341_REG_LCR, lcr); 27355fa15b5SJohan Hovold if (r) 27455fa15b5SJohan Hovold return r; 2756ce76104SFrank A Kingswood 2766ce76104SFrank A Kingswood return r; 2776ce76104SFrank A Kingswood } 2786ce76104SFrank A Kingswood 279664d5df9SWerner Cornelius static int ch341_set_handshake(struct usb_device *dev, u8 control) 2806ce76104SFrank A Kingswood { 2816fde8d29SAidan Thornton return ch341_control_out(dev, CH341_REQ_MODEM_CTRL, ~control, 0); 2826ce76104SFrank A Kingswood } 2836ce76104SFrank A Kingswood 284664d5df9SWerner Cornelius static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 2856ce76104SFrank A Kingswood { 2862d5a9c72SJohan Hovold const unsigned int size = 2; 2876ce76104SFrank A Kingswood char *buffer; 2886ce76104SFrank A Kingswood int r; 289664d5df9SWerner Cornelius unsigned long flags; 2906ce76104SFrank A Kingswood 2916ce76104SFrank A Kingswood buffer = kmalloc(size, GFP_KERNEL); 2926ce76104SFrank A Kingswood if (!buffer) 2936ce76104SFrank A Kingswood return -ENOMEM; 2946ce76104SFrank A Kingswood 2956fde8d29SAidan Thornton r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x0706, 0, buffer, size); 2966ce76104SFrank A Kingswood if (r < 0) 2976ce76104SFrank A Kingswood goto out; 2986ce76104SFrank A Kingswood 299664d5df9SWerner Cornelius spin_lock_irqsave(&priv->lock, flags); 300e8024460SJohan Hovold priv->msr = (~(*buffer)) & CH341_BITS_MODEM_STAT; 301664d5df9SWerner Cornelius spin_unlock_irqrestore(&priv->lock, flags); 3026ce76104SFrank A Kingswood 3036ce76104SFrank A Kingswood out: kfree(buffer); 3046ce76104SFrank A Kingswood return r; 3056ce76104SFrank A Kingswood } 3066ce76104SFrank A Kingswood 3076ce76104SFrank A Kingswood /* -------------------------------------------------------------------------- */ 3086ce76104SFrank A Kingswood 30993b6497dSAdrian Bunk static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 3106ce76104SFrank A Kingswood { 3112d5a9c72SJohan Hovold const unsigned int size = 2; 3126ce76104SFrank A Kingswood char *buffer; 3136ce76104SFrank A Kingswood int r; 3146ce76104SFrank A Kingswood 3156ce76104SFrank A Kingswood buffer = kmalloc(size, GFP_KERNEL); 3166ce76104SFrank A Kingswood if (!buffer) 3176ce76104SFrank A Kingswood return -ENOMEM; 3186ce76104SFrank A Kingswood 3196ce76104SFrank A Kingswood /* expect two bytes 0x27 0x00 */ 3206fde8d29SAidan Thornton r = ch341_control_in(dev, CH341_REQ_READ_VERSION, 0, 0, buffer, size); 3216ce76104SFrank A Kingswood if (r < 0) 3226ce76104SFrank A Kingswood goto out; 323a98b6900SAidan Thornton dev_dbg(&dev->dev, "Chip version: 0x%02x\n", buffer[0]); 3246ce76104SFrank A Kingswood 3256fde8d29SAidan Thornton r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 0, 0); 3266ce76104SFrank A Kingswood if (r < 0) 3276ce76104SFrank A Kingswood goto out; 3286ce76104SFrank A Kingswood 3290580baa4SMichael Hanselmann r = ch341_set_baudrate_lcr(dev, priv, priv->baud_rate, priv->lcr); 3306ce76104SFrank A Kingswood if (r < 0) 3316ce76104SFrank A Kingswood goto out; 3326ce76104SFrank A Kingswood 333beea33d4SJohan Hovold r = ch341_set_handshake(dev, priv->mcr); 3346ce76104SFrank A Kingswood 3356ce76104SFrank A Kingswood out: kfree(buffer); 3366ce76104SFrank A Kingswood return r; 3376ce76104SFrank A Kingswood } 3386ce76104SFrank A Kingswood 339c404bf4aSMichael Hanselmann static int ch341_detect_quirks(struct usb_serial_port *port) 340c404bf4aSMichael Hanselmann { 341c404bf4aSMichael Hanselmann struct ch341_private *priv = usb_get_serial_port_data(port); 342c404bf4aSMichael Hanselmann struct usb_device *udev = port->serial->dev; 343c404bf4aSMichael Hanselmann const unsigned int size = 2; 344c404bf4aSMichael Hanselmann unsigned long quirks = 0; 345c404bf4aSMichael Hanselmann char *buffer; 346c404bf4aSMichael Hanselmann int r; 347c404bf4aSMichael Hanselmann 348c404bf4aSMichael Hanselmann buffer = kmalloc(size, GFP_KERNEL); 349c404bf4aSMichael Hanselmann if (!buffer) 350c404bf4aSMichael Hanselmann return -ENOMEM; 351c404bf4aSMichael Hanselmann 352c404bf4aSMichael Hanselmann /* 353c404bf4aSMichael Hanselmann * A subset of CH34x devices does not support all features. The 354c404bf4aSMichael Hanselmann * prescaler is limited and there is no support for sending a RS232 355c404bf4aSMichael Hanselmann * break condition. A read failure when trying to set up the latter is 356c404bf4aSMichael Hanselmann * used to detect these devices. 357c404bf4aSMichael Hanselmann */ 358c404bf4aSMichael Hanselmann r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), CH341_REQ_READ_REG, 359c404bf4aSMichael Hanselmann USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 360c404bf4aSMichael Hanselmann CH341_REG_BREAK, 0, buffer, size, DEFAULT_TIMEOUT); 361c404bf4aSMichael Hanselmann if (r == -EPIPE) { 3620580baa4SMichael Hanselmann dev_info(&port->dev, "break control not supported, using simulated break\n"); 3630580baa4SMichael Hanselmann quirks = CH341_QUIRK_LIMITED_PRESCALER | CH341_QUIRK_SIMULATE_BREAK; 364c404bf4aSMichael Hanselmann r = 0; 365c404bf4aSMichael Hanselmann goto out; 366c404bf4aSMichael Hanselmann } 367c404bf4aSMichael Hanselmann 368c404bf4aSMichael Hanselmann if (r != size) { 369c404bf4aSMichael Hanselmann if (r >= 0) 370c404bf4aSMichael Hanselmann r = -EIO; 371c404bf4aSMichael Hanselmann dev_err(&port->dev, "failed to read break control: %d\n", r); 372c404bf4aSMichael Hanselmann goto out; 373c404bf4aSMichael Hanselmann } 374c404bf4aSMichael Hanselmann 375c404bf4aSMichael Hanselmann r = 0; 376c404bf4aSMichael Hanselmann out: 377c404bf4aSMichael Hanselmann kfree(buffer); 378c404bf4aSMichael Hanselmann 379c404bf4aSMichael Hanselmann if (quirks) { 380c404bf4aSMichael Hanselmann dev_dbg(&port->dev, "enabling quirk flags: 0x%02lx\n", quirks); 381c404bf4aSMichael Hanselmann priv->quirks |= quirks; 382c404bf4aSMichael Hanselmann } 383c404bf4aSMichael Hanselmann 384c404bf4aSMichael Hanselmann return r; 385c404bf4aSMichael Hanselmann } 386c404bf4aSMichael Hanselmann 387456c5be5SJohan Hovold static int ch341_port_probe(struct usb_serial_port *port) 3886ce76104SFrank A Kingswood { 3896ce76104SFrank A Kingswood struct ch341_private *priv; 3906ce76104SFrank A Kingswood int r; 3916ce76104SFrank A Kingswood 3926ce76104SFrank A Kingswood priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 3936ce76104SFrank A Kingswood if (!priv) 3946ce76104SFrank A Kingswood return -ENOMEM; 3956ce76104SFrank A Kingswood 396664d5df9SWerner Cornelius spin_lock_init(&priv->lock); 3976ce76104SFrank A Kingswood priv->baud_rate = DEFAULT_BAUD_RATE; 3987c61b0d5SJohan Hovold /* 3997c61b0d5SJohan Hovold * Some CH340 devices appear unable to change the initial LCR 4007c61b0d5SJohan Hovold * settings, so set a sane 8N1 default. 4017c61b0d5SJohan Hovold */ 4027c61b0d5SJohan Hovold priv->lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8; 4036ce76104SFrank A Kingswood 404456c5be5SJohan Hovold r = ch341_configure(port->serial->dev, priv); 4056ce76104SFrank A Kingswood if (r < 0) 4066ce76104SFrank A Kingswood goto error; 4076ce76104SFrank A Kingswood 408456c5be5SJohan Hovold usb_set_serial_port_data(port, priv); 409c404bf4aSMichael Hanselmann 410c404bf4aSMichael Hanselmann r = ch341_detect_quirks(port); 411c404bf4aSMichael Hanselmann if (r < 0) 412c404bf4aSMichael Hanselmann goto error; 413c404bf4aSMichael Hanselmann 4146ce76104SFrank A Kingswood return 0; 4156ce76104SFrank A Kingswood 4166ce76104SFrank A Kingswood error: kfree(priv); 4176ce76104SFrank A Kingswood return r; 4186ce76104SFrank A Kingswood } 4196ce76104SFrank A Kingswood 420456c5be5SJohan Hovold static int ch341_port_remove(struct usb_serial_port *port) 421456c5be5SJohan Hovold { 422456c5be5SJohan Hovold struct ch341_private *priv; 423456c5be5SJohan Hovold 424456c5be5SJohan Hovold priv = usb_get_serial_port_data(port); 425456c5be5SJohan Hovold kfree(priv); 426456c5be5SJohan Hovold 427456c5be5SJohan Hovold return 0; 428456c5be5SJohan Hovold } 429456c5be5SJohan Hovold 430335f8514SAlan Cox static int ch341_carrier_raised(struct usb_serial_port *port) 431335f8514SAlan Cox { 432335f8514SAlan Cox struct ch341_private *priv = usb_get_serial_port_data(port); 433e8024460SJohan Hovold if (priv->msr & CH341_BIT_DCD) 434335f8514SAlan Cox return 1; 435335f8514SAlan Cox return 0; 436335f8514SAlan Cox } 437335f8514SAlan Cox 438335f8514SAlan Cox static void ch341_dtr_rts(struct usb_serial_port *port, int on) 439664d5df9SWerner Cornelius { 440664d5df9SWerner Cornelius struct ch341_private *priv = usb_get_serial_port_data(port); 441664d5df9SWerner Cornelius unsigned long flags; 442664d5df9SWerner Cornelius 443335f8514SAlan Cox /* drop DTR and RTS */ 444335f8514SAlan Cox spin_lock_irqsave(&priv->lock, flags); 445335f8514SAlan Cox if (on) 446beea33d4SJohan Hovold priv->mcr |= CH341_BIT_RTS | CH341_BIT_DTR; 447335f8514SAlan Cox else 448beea33d4SJohan Hovold priv->mcr &= ~(CH341_BIT_RTS | CH341_BIT_DTR); 449335f8514SAlan Cox spin_unlock_irqrestore(&priv->lock, flags); 450beea33d4SJohan Hovold ch341_set_handshake(port->serial->dev, priv->mcr); 451335f8514SAlan Cox } 452335f8514SAlan Cox 453335f8514SAlan Cox static void ch341_close(struct usb_serial_port *port) 454335f8514SAlan Cox { 455f26788daSJohan Hovold usb_serial_generic_close(port); 456664d5df9SWerner Cornelius usb_kill_urb(port->interrupt_in_urb); 457664d5df9SWerner Cornelius } 458664d5df9SWerner Cornelius 459664d5df9SWerner Cornelius 4606ce76104SFrank A Kingswood /* open this device, set default parameters */ 461a509a7e4SAlan Cox static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) 4626ce76104SFrank A Kingswood { 463456c5be5SJohan Hovold struct ch341_private *priv = usb_get_serial_port_data(port); 4646ce76104SFrank A Kingswood int r; 4656ce76104SFrank A Kingswood 466aa91def4SNicolas PLANEL if (tty) 467aa91def4SNicolas PLANEL ch341_set_termios(tty, port, NULL); 4686ce76104SFrank A Kingswood 469d9a38a87SJohan Hovold dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__); 470664d5df9SWerner Cornelius r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 471664d5df9SWerner Cornelius if (r) { 472d9a38a87SJohan Hovold dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n", 473d9a38a87SJohan Hovold __func__, r); 474f2950b78SJohan Hovold return r; 475664d5df9SWerner Cornelius } 476664d5df9SWerner Cornelius 477a0467a96SJohan Hovold r = ch341_get_status(port->serial->dev, priv); 478a0467a96SJohan Hovold if (r < 0) { 479a0467a96SJohan Hovold dev_err(&port->dev, "failed to read modem status: %d\n", r); 480a0467a96SJohan Hovold goto err_kill_interrupt_urb; 481a0467a96SJohan Hovold } 482a0467a96SJohan Hovold 483a509a7e4SAlan Cox r = usb_serial_generic_open(tty, port); 484f2950b78SJohan Hovold if (r) 485f2950b78SJohan Hovold goto err_kill_interrupt_urb; 4866ce76104SFrank A Kingswood 487f2950b78SJohan Hovold return 0; 488f2950b78SJohan Hovold 489f2950b78SJohan Hovold err_kill_interrupt_urb: 490f2950b78SJohan Hovold usb_kill_urb(port->interrupt_in_urb); 491f2950b78SJohan Hovold 492f2950b78SJohan Hovold return r; 4936ce76104SFrank A Kingswood } 4946ce76104SFrank A Kingswood 4956ce76104SFrank A Kingswood /* Old_termios contains the original termios settings and 4966ce76104SFrank A Kingswood * tty->termios contains the new setting to be used. 4976ce76104SFrank A Kingswood */ 49895da310eSAlan Cox static void ch341_set_termios(struct tty_struct *tty, 49995da310eSAlan Cox struct usb_serial_port *port, struct ktermios *old_termios) 5006ce76104SFrank A Kingswood { 5016ce76104SFrank A Kingswood struct ch341_private *priv = usb_get_serial_port_data(port); 5026ce76104SFrank A Kingswood unsigned baud_rate; 503664d5df9SWerner Cornelius unsigned long flags; 504448b6dc5SJohan Hovold u8 lcr; 5054e46c410SAidan Thornton int r; 5064e46c410SAidan Thornton 5074e46c410SAidan Thornton /* redundant changes may cause the chip to lose bytes */ 5084e46c410SAidan Thornton if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios)) 5094e46c410SAidan Thornton return; 5106ce76104SFrank A Kingswood 5116ce76104SFrank A Kingswood baud_rate = tty_get_baud_rate(tty); 5126ce76104SFrank A Kingswood 513448b6dc5SJohan Hovold lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX; 514664d5df9SWerner Cornelius 515ba781bdfSAidan Thornton switch (C_CSIZE(tty)) { 516ba781bdfSAidan Thornton case CS5: 517448b6dc5SJohan Hovold lcr |= CH341_LCR_CS5; 518ba781bdfSAidan Thornton break; 519ba781bdfSAidan Thornton case CS6: 520448b6dc5SJohan Hovold lcr |= CH341_LCR_CS6; 521ba781bdfSAidan Thornton break; 522ba781bdfSAidan Thornton case CS7: 523448b6dc5SJohan Hovold lcr |= CH341_LCR_CS7; 524ba781bdfSAidan Thornton break; 525ba781bdfSAidan Thornton case CS8: 526448b6dc5SJohan Hovold lcr |= CH341_LCR_CS8; 527ba781bdfSAidan Thornton break; 528ba781bdfSAidan Thornton } 529ba781bdfSAidan Thornton 530ba781bdfSAidan Thornton if (C_PARENB(tty)) { 531448b6dc5SJohan Hovold lcr |= CH341_LCR_ENABLE_PAR; 532ba781bdfSAidan Thornton if (C_PARODD(tty) == 0) 533448b6dc5SJohan Hovold lcr |= CH341_LCR_PAR_EVEN; 534ba781bdfSAidan Thornton if (C_CMSPAR(tty)) 535448b6dc5SJohan Hovold lcr |= CH341_LCR_MARK_SPACE; 536ba781bdfSAidan Thornton } 537ba781bdfSAidan Thornton 538ba781bdfSAidan Thornton if (C_CSTOPB(tty)) 539448b6dc5SJohan Hovold lcr |= CH341_LCR_STOP_BITS_2; 5404e46c410SAidan Thornton 541664d5df9SWerner Cornelius if (baud_rate) { 542a20047f3SJohan Hovold priv->baud_rate = baud_rate; 543a20047f3SJohan Hovold 5440580baa4SMichael Hanselmann r = ch341_set_baudrate_lcr(port->serial->dev, priv, 5450580baa4SMichael Hanselmann priv->baud_rate, lcr); 5464e46c410SAidan Thornton if (r < 0 && old_termios) { 5474e46c410SAidan Thornton priv->baud_rate = tty_termios_baud_rate(old_termios); 5484e46c410SAidan Thornton tty_termios_copy_hw(&tty->termios, old_termios); 5493cca8624SJohan Hovold } else if (r == 0) { 550448b6dc5SJohan Hovold priv->lcr = lcr; 5514e46c410SAidan Thornton } 5526ce76104SFrank A Kingswood } 5536ce76104SFrank A Kingswood 554030ee7aeSJohan Hovold spin_lock_irqsave(&priv->lock, flags); 555030ee7aeSJohan Hovold if (C_BAUD(tty) == B0) 556beea33d4SJohan Hovold priv->mcr &= ~(CH341_BIT_DTR | CH341_BIT_RTS); 557030ee7aeSJohan Hovold else if (old_termios && (old_termios->c_cflag & CBAUD) == B0) 558beea33d4SJohan Hovold priv->mcr |= (CH341_BIT_DTR | CH341_BIT_RTS); 559030ee7aeSJohan Hovold spin_unlock_irqrestore(&priv->lock, flags); 5606ce76104SFrank A Kingswood 561beea33d4SJohan Hovold ch341_set_handshake(port->serial->dev, priv->mcr); 562664d5df9SWerner Cornelius } 56373f59308SAlan Cox 5640580baa4SMichael Hanselmann /* 5650580baa4SMichael Hanselmann * A subset of all CH34x devices don't support a real break condition and 5660580baa4SMichael Hanselmann * reading CH341_REG_BREAK fails (see also ch341_detect_quirks). This function 5670580baa4SMichael Hanselmann * simulates a break condition by lowering the baud rate to the minimum 5680580baa4SMichael Hanselmann * supported by the hardware upon enabling the break condition and sending 5690580baa4SMichael Hanselmann * a NUL byte. 5700580baa4SMichael Hanselmann * 5710580baa4SMichael Hanselmann * Incoming data is corrupted while the break condition is being simulated. 5720580baa4SMichael Hanselmann * 5730580baa4SMichael Hanselmann * Normally the duration of the break condition can be controlled individually 5740580baa4SMichael Hanselmann * by userspace using TIOCSBRK and TIOCCBRK or by passing an argument to 5750580baa4SMichael Hanselmann * TCSBRKP. Due to how the simulation is implemented the duration can't be 5760580baa4SMichael Hanselmann * controlled. The duration is always about (1s / 46bd * 9bit) = 196ms. 5770580baa4SMichael Hanselmann */ 5780580baa4SMichael Hanselmann static void ch341_simulate_break(struct tty_struct *tty, int break_state) 5790580baa4SMichael Hanselmann { 5800580baa4SMichael Hanselmann struct usb_serial_port *port = tty->driver_data; 5810580baa4SMichael Hanselmann struct ch341_private *priv = usb_get_serial_port_data(port); 5820580baa4SMichael Hanselmann unsigned long now, delay; 5830580baa4SMichael Hanselmann int r; 5840580baa4SMichael Hanselmann 5850580baa4SMichael Hanselmann if (break_state != 0) { 5860580baa4SMichael Hanselmann dev_dbg(&port->dev, "enter break state requested\n"); 5870580baa4SMichael Hanselmann 5880580baa4SMichael Hanselmann r = ch341_set_baudrate_lcr(port->serial->dev, priv, 5890580baa4SMichael Hanselmann CH341_MIN_BPS, 5900580baa4SMichael Hanselmann CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8); 5910580baa4SMichael Hanselmann if (r < 0) { 5920580baa4SMichael Hanselmann dev_err(&port->dev, 5930580baa4SMichael Hanselmann "failed to change baud rate to %u: %d\n", 5940580baa4SMichael Hanselmann CH341_MIN_BPS, r); 5950580baa4SMichael Hanselmann goto restore; 5960580baa4SMichael Hanselmann } 5970580baa4SMichael Hanselmann 5980580baa4SMichael Hanselmann r = tty_put_char(tty, '\0'); 5990580baa4SMichael Hanselmann if (r < 0) { 6000580baa4SMichael Hanselmann dev_err(&port->dev, 6010580baa4SMichael Hanselmann "failed to write NUL byte for simulated break condition: %d\n", 6020580baa4SMichael Hanselmann r); 6030580baa4SMichael Hanselmann goto restore; 6040580baa4SMichael Hanselmann } 6050580baa4SMichael Hanselmann 6060580baa4SMichael Hanselmann /* 607*6d0bdc42SMichael Hanselmann * Compute expected transmission duration including safety 608*6d0bdc42SMichael Hanselmann * margin. The original baud rate is only restored after the 609*6d0bdc42SMichael Hanselmann * computed point in time. 610*6d0bdc42SMichael Hanselmann * 611*6d0bdc42SMichael Hanselmann * 11 bits = 1 start, 8 data, 1 stop, 1 margin 6120580baa4SMichael Hanselmann */ 613*6d0bdc42SMichael Hanselmann priv->break_end = jiffies + (11 * HZ / CH341_MIN_BPS); 6140580baa4SMichael Hanselmann 6150580baa4SMichael Hanselmann return; 6160580baa4SMichael Hanselmann } 6170580baa4SMichael Hanselmann 6180580baa4SMichael Hanselmann dev_dbg(&port->dev, "leave break state requested\n"); 6190580baa4SMichael Hanselmann 6200580baa4SMichael Hanselmann now = jiffies; 6210580baa4SMichael Hanselmann 6220580baa4SMichael Hanselmann if (time_before(now, priv->break_end)) { 6230580baa4SMichael Hanselmann /* Wait until NUL byte is written */ 6240580baa4SMichael Hanselmann delay = priv->break_end - now; 6250580baa4SMichael Hanselmann dev_dbg(&port->dev, 6260580baa4SMichael Hanselmann "wait %d ms while transmitting NUL byte at %u baud\n", 6270580baa4SMichael Hanselmann jiffies_to_msecs(delay), CH341_MIN_BPS); 6280580baa4SMichael Hanselmann schedule_timeout_interruptible(delay); 6290580baa4SMichael Hanselmann } 6300580baa4SMichael Hanselmann 6310580baa4SMichael Hanselmann restore: 6320580baa4SMichael Hanselmann /* Restore original baud rate */ 6330580baa4SMichael Hanselmann r = ch341_set_baudrate_lcr(port->serial->dev, priv, priv->baud_rate, 6340580baa4SMichael Hanselmann priv->lcr); 6350580baa4SMichael Hanselmann if (r < 0) 6360580baa4SMichael Hanselmann dev_err(&port->dev, 6370580baa4SMichael Hanselmann "restoring original baud rate of %u failed: %d\n", 6380580baa4SMichael Hanselmann priv->baud_rate, r); 6390580baa4SMichael Hanselmann } 6400580baa4SMichael Hanselmann 641492896f0STim Small static void ch341_break_ctl(struct tty_struct *tty, int break_state) 642492896f0STim Small { 643492896f0STim Small const uint16_t ch341_break_reg = 6446fde8d29SAidan Thornton ((uint16_t) CH341_REG_LCR << 8) | CH341_REG_BREAK; 645492896f0STim Small struct usb_serial_port *port = tty->driver_data; 6460580baa4SMichael Hanselmann struct ch341_private *priv = usb_get_serial_port_data(port); 647492896f0STim Small int r; 648492896f0STim Small uint16_t reg_contents; 649f2b5cc83SJohan Hovold uint8_t *break_reg; 650492896f0STim Small 6510580baa4SMichael Hanselmann if (priv->quirks & CH341_QUIRK_SIMULATE_BREAK) { 6520580baa4SMichael Hanselmann ch341_simulate_break(tty, break_state); 6530580baa4SMichael Hanselmann return; 6540580baa4SMichael Hanselmann } 6550580baa4SMichael Hanselmann 656f2b5cc83SJohan Hovold break_reg = kmalloc(2, GFP_KERNEL); 65710c642d0SJohan Hovold if (!break_reg) 658f2b5cc83SJohan Hovold return; 659f2b5cc83SJohan Hovold 660492896f0STim Small r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG, 661f2b5cc83SJohan Hovold ch341_break_reg, 0, break_reg, 2); 662492896f0STim Small if (r < 0) { 6636a9b15feSJohan Hovold dev_err(&port->dev, "%s - USB control read error (%d)\n", 6646a9b15feSJohan Hovold __func__, r); 665f2b5cc83SJohan Hovold goto out; 666492896f0STim Small } 66779cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n", 668492896f0STim Small __func__, break_reg[0], break_reg[1]); 669492896f0STim Small if (break_state != 0) { 67079cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__); 6716fde8d29SAidan Thornton break_reg[0] &= ~CH341_NBREAK_BITS; 6726fde8d29SAidan Thornton break_reg[1] &= ~CH341_LCR_ENABLE_TX; 673492896f0STim Small } else { 67479cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__); 6756fde8d29SAidan Thornton break_reg[0] |= CH341_NBREAK_BITS; 6766fde8d29SAidan Thornton break_reg[1] |= CH341_LCR_ENABLE_TX; 677492896f0STim Small } 67879cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n", 679492896f0STim Small __func__, break_reg[0], break_reg[1]); 6805be796f0SJohan Hovold reg_contents = get_unaligned_le16(break_reg); 681492896f0STim Small r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG, 682492896f0STim Small ch341_break_reg, reg_contents); 683492896f0STim Small if (r < 0) 6846a9b15feSJohan Hovold dev_err(&port->dev, "%s - USB control write error (%d)\n", 6856a9b15feSJohan Hovold __func__, r); 686f2b5cc83SJohan Hovold out: 687f2b5cc83SJohan Hovold kfree(break_reg); 688492896f0STim Small } 689492896f0STim Small 69020b9d177SAlan Cox static int ch341_tiocmset(struct tty_struct *tty, 691664d5df9SWerner Cornelius unsigned int set, unsigned int clear) 692664d5df9SWerner Cornelius { 693664d5df9SWerner Cornelius struct usb_serial_port *port = tty->driver_data; 694664d5df9SWerner Cornelius struct ch341_private *priv = usb_get_serial_port_data(port); 695664d5df9SWerner Cornelius unsigned long flags; 696664d5df9SWerner Cornelius u8 control; 697664d5df9SWerner Cornelius 698664d5df9SWerner Cornelius spin_lock_irqsave(&priv->lock, flags); 699664d5df9SWerner Cornelius if (set & TIOCM_RTS) 700beea33d4SJohan Hovold priv->mcr |= CH341_BIT_RTS; 701664d5df9SWerner Cornelius if (set & TIOCM_DTR) 702beea33d4SJohan Hovold priv->mcr |= CH341_BIT_DTR; 703664d5df9SWerner Cornelius if (clear & TIOCM_RTS) 704beea33d4SJohan Hovold priv->mcr &= ~CH341_BIT_RTS; 705664d5df9SWerner Cornelius if (clear & TIOCM_DTR) 706beea33d4SJohan Hovold priv->mcr &= ~CH341_BIT_DTR; 707beea33d4SJohan Hovold control = priv->mcr; 708664d5df9SWerner Cornelius spin_unlock_irqrestore(&priv->lock, flags); 709664d5df9SWerner Cornelius 710664d5df9SWerner Cornelius return ch341_set_handshake(port->serial->dev, control); 711664d5df9SWerner Cornelius } 712664d5df9SWerner Cornelius 713e8024460SJohan Hovold static void ch341_update_status(struct usb_serial_port *port, 714ac035628SJohan Hovold unsigned char *data, size_t len) 715ac035628SJohan Hovold { 716ac035628SJohan Hovold struct ch341_private *priv = usb_get_serial_port_data(port); 717b770081fSJohan Hovold struct tty_struct *tty; 718ac035628SJohan Hovold unsigned long flags; 719b770081fSJohan Hovold u8 status; 720b770081fSJohan Hovold u8 delta; 721ac035628SJohan Hovold 722ac035628SJohan Hovold if (len < 4) 723ac035628SJohan Hovold return; 724ac035628SJohan Hovold 725b770081fSJohan Hovold status = ~data[2] & CH341_BITS_MODEM_STAT; 726b770081fSJohan Hovold 727ac035628SJohan Hovold spin_lock_irqsave(&priv->lock, flags); 728e8024460SJohan Hovold delta = status ^ priv->msr; 729e8024460SJohan Hovold priv->msr = status; 730ac035628SJohan Hovold spin_unlock_irqrestore(&priv->lock, flags); 731ac035628SJohan Hovold 732fd74b0b1SJohan Hovold if (data[1] & CH341_MULT_STAT) 733fd74b0b1SJohan Hovold dev_dbg(&port->dev, "%s - multiple status change\n", __func__); 734fd74b0b1SJohan Hovold 735d984fe91SJohan Hovold if (!delta) 736d984fe91SJohan Hovold return; 737d984fe91SJohan Hovold 7385e409a26SJohan Hovold if (delta & CH341_BIT_CTS) 7395e409a26SJohan Hovold port->icount.cts++; 7405e409a26SJohan Hovold if (delta & CH341_BIT_DSR) 7415e409a26SJohan Hovold port->icount.dsr++; 7425e409a26SJohan Hovold if (delta & CH341_BIT_RI) 7435e409a26SJohan Hovold port->icount.rng++; 744b770081fSJohan Hovold if (delta & CH341_BIT_DCD) { 7455e409a26SJohan Hovold port->icount.dcd++; 746b770081fSJohan Hovold tty = tty_port_tty_get(&port->port); 747b770081fSJohan Hovold if (tty) { 748ac035628SJohan Hovold usb_serial_handle_dcd_change(port, tty, 749b770081fSJohan Hovold status & CH341_BIT_DCD); 750ac035628SJohan Hovold tty_kref_put(tty); 751ac035628SJohan Hovold } 752b770081fSJohan Hovold } 753ac035628SJohan Hovold 754ac035628SJohan Hovold wake_up_interruptible(&port->port.delta_msr_wait); 755ac035628SJohan Hovold } 756ac035628SJohan Hovold 757664d5df9SWerner Cornelius static void ch341_read_int_callback(struct urb *urb) 758664d5df9SWerner Cornelius { 759271ec2d2SJohan Hovold struct usb_serial_port *port = urb->context; 760664d5df9SWerner Cornelius unsigned char *data = urb->transfer_buffer; 761271ec2d2SJohan Hovold unsigned int len = urb->actual_length; 762664d5df9SWerner Cornelius int status; 763664d5df9SWerner Cornelius 764664d5df9SWerner Cornelius switch (urb->status) { 765664d5df9SWerner Cornelius case 0: 766664d5df9SWerner Cornelius /* success */ 767664d5df9SWerner Cornelius break; 768664d5df9SWerner Cornelius case -ECONNRESET: 769664d5df9SWerner Cornelius case -ENOENT: 770664d5df9SWerner Cornelius case -ESHUTDOWN: 771664d5df9SWerner Cornelius /* this urb is terminated, clean up */ 772271ec2d2SJohan Hovold dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n", 77379cbeeafSGreg Kroah-Hartman __func__, urb->status); 774664d5df9SWerner Cornelius return; 775664d5df9SWerner Cornelius default: 776271ec2d2SJohan Hovold dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", 77779cbeeafSGreg Kroah-Hartman __func__, urb->status); 778664d5df9SWerner Cornelius goto exit; 779664d5df9SWerner Cornelius } 780664d5df9SWerner Cornelius 781271ec2d2SJohan Hovold usb_serial_debug_data(&port->dev, __func__, len, data); 782e8024460SJohan Hovold ch341_update_status(port, data, len); 783664d5df9SWerner Cornelius exit: 784664d5df9SWerner Cornelius status = usb_submit_urb(urb, GFP_ATOMIC); 785271ec2d2SJohan Hovold if (status) { 786271ec2d2SJohan Hovold dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n", 787664d5df9SWerner Cornelius __func__, status); 788664d5df9SWerner Cornelius } 789271ec2d2SJohan Hovold } 790664d5df9SWerner Cornelius 79160b33c13SAlan Cox static int ch341_tiocmget(struct tty_struct *tty) 792664d5df9SWerner Cornelius { 793664d5df9SWerner Cornelius struct usb_serial_port *port = tty->driver_data; 794664d5df9SWerner Cornelius struct ch341_private *priv = usb_get_serial_port_data(port); 795664d5df9SWerner Cornelius unsigned long flags; 796664d5df9SWerner Cornelius u8 mcr; 797664d5df9SWerner Cornelius u8 status; 798664d5df9SWerner Cornelius unsigned int result; 799664d5df9SWerner Cornelius 800664d5df9SWerner Cornelius spin_lock_irqsave(&priv->lock, flags); 801beea33d4SJohan Hovold mcr = priv->mcr; 802e8024460SJohan Hovold status = priv->msr; 803664d5df9SWerner Cornelius spin_unlock_irqrestore(&priv->lock, flags); 804664d5df9SWerner Cornelius 805664d5df9SWerner Cornelius result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0) 806664d5df9SWerner Cornelius | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0) 807664d5df9SWerner Cornelius | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0) 808664d5df9SWerner Cornelius | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0) 809664d5df9SWerner Cornelius | ((status & CH341_BIT_RI) ? TIOCM_RI : 0) 810664d5df9SWerner Cornelius | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0); 811664d5df9SWerner Cornelius 81279cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 813664d5df9SWerner Cornelius 814664d5df9SWerner Cornelius return result; 8156ce76104SFrank A Kingswood } 8166ce76104SFrank A Kingswood 817622b80cfSGreg Kroah-Hartman static int ch341_reset_resume(struct usb_serial *serial) 8181ded7ea4SMing Lei { 819ce5e2928SJohan Hovold struct usb_serial_port *port = serial->port[0]; 8204d5ef53fSJohan Hovold struct ch341_private *priv; 821ce5e2928SJohan Hovold int ret; 8221ded7ea4SMing Lei 8234d5ef53fSJohan Hovold priv = usb_get_serial_port_data(port); 8244d5ef53fSJohan Hovold if (!priv) 8254d5ef53fSJohan Hovold return 0; 8264d5ef53fSJohan Hovold 8271ded7ea4SMing Lei /* reconfigure ch341 serial port after bus-reset */ 8282bfd1c96SGreg Kroah-Hartman ch341_configure(serial->dev, priv); 8291ded7ea4SMing Lei 830ce5e2928SJohan Hovold if (tty_port_initialized(&port->port)) { 831ce5e2928SJohan Hovold ret = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 832ce5e2928SJohan Hovold if (ret) { 833ce5e2928SJohan Hovold dev_err(&port->dev, "failed to submit interrupt urb: %d\n", 834ce5e2928SJohan Hovold ret); 835ce5e2928SJohan Hovold return ret; 836ce5e2928SJohan Hovold } 837a0467a96SJohan Hovold 838a0467a96SJohan Hovold ret = ch341_get_status(port->serial->dev, priv); 839a0467a96SJohan Hovold if (ret < 0) { 840a0467a96SJohan Hovold dev_err(&port->dev, "failed to read modem status: %d\n", 841a0467a96SJohan Hovold ret); 842a0467a96SJohan Hovold } 843ce5e2928SJohan Hovold } 844ce5e2928SJohan Hovold 845ce5e2928SJohan Hovold return usb_serial_generic_resume(serial); 8461ded7ea4SMing Lei } 8471ded7ea4SMing Lei 8486ce76104SFrank A Kingswood static struct usb_serial_driver ch341_device = { 8496ce76104SFrank A Kingswood .driver = { 8506ce76104SFrank A Kingswood .owner = THIS_MODULE, 8516ce76104SFrank A Kingswood .name = "ch341-uart", 8526ce76104SFrank A Kingswood }, 8536ce76104SFrank A Kingswood .id_table = id_table, 8546ce76104SFrank A Kingswood .num_ports = 1, 8556ce76104SFrank A Kingswood .open = ch341_open, 856335f8514SAlan Cox .dtr_rts = ch341_dtr_rts, 857335f8514SAlan Cox .carrier_raised = ch341_carrier_raised, 858664d5df9SWerner Cornelius .close = ch341_close, 8596ce76104SFrank A Kingswood .set_termios = ch341_set_termios, 860492896f0STim Small .break_ctl = ch341_break_ctl, 861664d5df9SWerner Cornelius .tiocmget = ch341_tiocmget, 862664d5df9SWerner Cornelius .tiocmset = ch341_tiocmset, 8635e409a26SJohan Hovold .tiocmiwait = usb_serial_generic_tiocmiwait, 864664d5df9SWerner Cornelius .read_int_callback = ch341_read_int_callback, 865456c5be5SJohan Hovold .port_probe = ch341_port_probe, 866456c5be5SJohan Hovold .port_remove = ch341_port_remove, 8671c1eaba8SGreg Kroah-Hartman .reset_resume = ch341_reset_resume, 8686ce76104SFrank A Kingswood }; 8696ce76104SFrank A Kingswood 87008a4f6bcSAlan Stern static struct usb_serial_driver * const serial_drivers[] = { 87108a4f6bcSAlan Stern &ch341_device, NULL 87208a4f6bcSAlan Stern }; 87308a4f6bcSAlan Stern 87468e24113SGreg Kroah-Hartman module_usb_serial_driver(serial_drivers, id_table); 8756ce76104SFrank A Kingswood 876627cfa89SJohan Hovold MODULE_LICENSE("GPL v2"); 877