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 62*2c509d1cSMichael Hanselmann #define CH341_REG_PRESCALER 0x12 63*2c509d1cSMichael Hanselmann #define CH341_REG_DIVISOR 0x13 646fde8d29SAidan Thornton #define CH341_REG_LCR 0x18 65*2c509d1cSMichael Hanselmann #define CH341_REG_LCR2 0x25 66*2c509d1cSMichael 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) 81c432df15SJohan Hovold 827d40d7e8SNémeth Márton static const struct usb_device_id id_table[] = { 836ce76104SFrank A Kingswood { USB_DEVICE(0x4348, 0x5523) }, 8482078234SMichael F. Robbins { USB_DEVICE(0x1a86, 0x7523) }, 85d0781383Swangyanqing { USB_DEVICE(0x1a86, 0x5523) }, 866ce76104SFrank A Kingswood { }, 876ce76104SFrank A Kingswood }; 886ce76104SFrank A Kingswood MODULE_DEVICE_TABLE(usb, id_table); 896ce76104SFrank A Kingswood 906ce76104SFrank A Kingswood struct ch341_private { 91664d5df9SWerner Cornelius spinlock_t lock; /* access lock */ 92664d5df9SWerner Cornelius unsigned baud_rate; /* set baud rate */ 93beea33d4SJohan Hovold u8 mcr; 94e8024460SJohan Hovold u8 msr; 953cca8624SJohan Hovold u8 lcr; 96c404bf4aSMichael Hanselmann unsigned long quirks; 976ce76104SFrank A Kingswood }; 986ce76104SFrank A Kingswood 99aa91def4SNicolas PLANEL static void ch341_set_termios(struct tty_struct *tty, 100aa91def4SNicolas PLANEL struct usb_serial_port *port, 101aa91def4SNicolas PLANEL struct ktermios *old_termios); 102aa91def4SNicolas PLANEL 1036ce76104SFrank A Kingswood static int ch341_control_out(struct usb_device *dev, u8 request, 1046ce76104SFrank A Kingswood u16 value, u16 index) 1056ce76104SFrank A Kingswood { 1066ce76104SFrank A Kingswood int r; 10779cbeeafSGreg Kroah-Hartman 10891e0efcdSJohan Hovold dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x)\n", __func__, 10991e0efcdSJohan Hovold request, value, index); 1106ce76104SFrank A Kingswood 1116ce76104SFrank A Kingswood r = usb_control_msg(dev, usb_sndctrlpipe(dev, 0), request, 1126ce76104SFrank A Kingswood USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_OUT, 1136ce76104SFrank A Kingswood value, index, NULL, 0, DEFAULT_TIMEOUT); 1142d5a9c72SJohan Hovold if (r < 0) 1152d5a9c72SJohan Hovold dev_err(&dev->dev, "failed to send control message: %d\n", r); 1166ce76104SFrank A Kingswood 1176ce76104SFrank A Kingswood return r; 1186ce76104SFrank A Kingswood } 1196ce76104SFrank A Kingswood 1206ce76104SFrank A Kingswood static int ch341_control_in(struct usb_device *dev, 1216ce76104SFrank A Kingswood u8 request, u16 value, u16 index, 1226ce76104SFrank A Kingswood char *buf, unsigned bufsize) 1236ce76104SFrank A Kingswood { 1246ce76104SFrank A Kingswood int r; 12579cbeeafSGreg Kroah-Hartman 12691e0efcdSJohan Hovold dev_dbg(&dev->dev, "%s - (%02x,%04x,%04x,%u)\n", __func__, 12791e0efcdSJohan Hovold request, value, index, bufsize); 1286ce76104SFrank A Kingswood 1296ce76104SFrank A Kingswood r = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0), request, 1306ce76104SFrank A Kingswood USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 1316ce76104SFrank A Kingswood value, index, buf, bufsize, DEFAULT_TIMEOUT); 132e33eab9dSDan Carpenter if (r < (int)bufsize) { 1332d5a9c72SJohan Hovold if (r >= 0) { 1342d5a9c72SJohan Hovold dev_err(&dev->dev, 1352d5a9c72SJohan Hovold "short control message received (%d < %u)\n", 1362d5a9c72SJohan Hovold r, bufsize); 1372d5a9c72SJohan Hovold r = -EIO; 1382d5a9c72SJohan Hovold } 1392d5a9c72SJohan Hovold 1402d5a9c72SJohan Hovold dev_err(&dev->dev, "failed to receive control message: %d\n", 1412d5a9c72SJohan Hovold r); 1426ce76104SFrank A Kingswood return r; 1436ce76104SFrank A Kingswood } 1446ce76104SFrank A Kingswood 1452d5a9c72SJohan Hovold return 0; 1462d5a9c72SJohan Hovold } 1472d5a9c72SJohan Hovold 14835714565SJohan Hovold #define CH341_CLKRATE 48000000 14935714565SJohan Hovold #define CH341_CLK_DIV(ps, fact) (1 << (12 - 3 * (ps) - (fact))) 15035714565SJohan Hovold #define CH341_MIN_RATE(ps) (CH341_CLKRATE / (CH341_CLK_DIV((ps), 1) * 512)) 15135714565SJohan Hovold 15235714565SJohan Hovold static const speed_t ch341_min_rates[] = { 15335714565SJohan Hovold CH341_MIN_RATE(0), 15435714565SJohan Hovold CH341_MIN_RATE(1), 15535714565SJohan Hovold CH341_MIN_RATE(2), 15635714565SJohan Hovold CH341_MIN_RATE(3), 15735714565SJohan Hovold }; 15835714565SJohan Hovold 15935714565SJohan Hovold /* 16035714565SJohan Hovold * The device line speed is given by the following equation: 16135714565SJohan Hovold * 16235714565SJohan Hovold * baudrate = 48000000 / (2^(12 - 3 * ps - fact) * div), where 16335714565SJohan Hovold * 16435714565SJohan Hovold * 0 <= ps <= 3, 16535714565SJohan Hovold * 0 <= fact <= 1, 16635714565SJohan Hovold * 2 <= div <= 256 if fact = 0, or 16735714565SJohan Hovold * 9 <= div <= 256 if fact = 1 16835714565SJohan Hovold */ 169c432df15SJohan Hovold static int ch341_get_divisor(struct ch341_private *priv) 17035714565SJohan Hovold { 17135714565SJohan Hovold unsigned int fact, div, clk_div; 172c432df15SJohan Hovold speed_t speed = priv->baud_rate; 173c432df15SJohan Hovold bool force_fact0 = false; 17435714565SJohan Hovold int ps; 17535714565SJohan Hovold 17635714565SJohan Hovold /* 17735714565SJohan Hovold * Clamp to supported range, this makes the (ps < 0) and (div < 2) 17835714565SJohan Hovold * sanity checks below redundant. 17935714565SJohan Hovold */ 18035714565SJohan Hovold speed = clamp(speed, 46U, 3000000U); 18135714565SJohan Hovold 18235714565SJohan Hovold /* 18335714565SJohan Hovold * Start with highest possible base clock (fact = 1) that will give a 18435714565SJohan Hovold * divisor strictly less than 512. 18535714565SJohan Hovold */ 18635714565SJohan Hovold fact = 1; 18735714565SJohan Hovold for (ps = 3; ps >= 0; ps--) { 18835714565SJohan Hovold if (speed > ch341_min_rates[ps]) 18935714565SJohan Hovold break; 19035714565SJohan Hovold } 19135714565SJohan Hovold 19235714565SJohan Hovold if (ps < 0) 19335714565SJohan Hovold return -EINVAL; 19435714565SJohan Hovold 19535714565SJohan Hovold /* Determine corresponding divisor, rounding down. */ 19635714565SJohan Hovold clk_div = CH341_CLK_DIV(ps, fact); 19735714565SJohan Hovold div = CH341_CLKRATE / (clk_div * speed); 19835714565SJohan Hovold 199c432df15SJohan Hovold /* Some devices require a lower base clock if ps < 3. */ 200c432df15SJohan Hovold if (ps < 3 && (priv->quirks & CH341_QUIRK_LIMITED_PRESCALER)) 201c432df15SJohan Hovold force_fact0 = true; 202c432df15SJohan Hovold 20335714565SJohan Hovold /* Halve base clock (fact = 0) if required. */ 204c432df15SJohan Hovold if (div < 9 || div > 255 || force_fact0) { 20535714565SJohan Hovold div /= 2; 20635714565SJohan Hovold clk_div *= 2; 20735714565SJohan Hovold fact = 0; 20835714565SJohan Hovold } 20935714565SJohan Hovold 21035714565SJohan Hovold if (div < 2) 21135714565SJohan Hovold return -EINVAL; 21235714565SJohan Hovold 21335714565SJohan Hovold /* 21435714565SJohan Hovold * Pick next divisor if resulting rate is closer to the requested one, 21535714565SJohan Hovold * scale up to avoid rounding errors on low rates. 21635714565SJohan Hovold */ 21735714565SJohan Hovold if (16 * CH341_CLKRATE / (clk_div * div) - 16 * speed >= 21835714565SJohan Hovold 16 * speed - 16 * CH341_CLKRATE / (clk_div * (div + 1))) 21935714565SJohan Hovold div++; 22035714565SJohan Hovold 2217c3d0228SJohan Hovold /* 2227c3d0228SJohan Hovold * Prefer lower base clock (fact = 0) if even divisor. 2237c3d0228SJohan Hovold * 2247c3d0228SJohan Hovold * Note that this makes the receiver more tolerant to errors. 2257c3d0228SJohan Hovold */ 2267c3d0228SJohan Hovold if (fact == 1 && div % 2 == 0) { 2277c3d0228SJohan Hovold div /= 2; 2287c3d0228SJohan Hovold fact = 0; 2297c3d0228SJohan Hovold } 2307c3d0228SJohan Hovold 23135714565SJohan Hovold return (0x100 - div) << 8 | fact << 2 | ps; 23235714565SJohan Hovold } 23335714565SJohan Hovold 23455fa15b5SJohan Hovold static int ch341_set_baudrate_lcr(struct usb_device *dev, 23555fa15b5SJohan Hovold struct ch341_private *priv, u8 lcr) 2366ce76104SFrank A Kingswood { 23735714565SJohan Hovold int val; 2386ce76104SFrank A Kingswood int r; 2396ce76104SFrank A Kingswood 240664d5df9SWerner Cornelius if (!priv->baud_rate) 2416ce76104SFrank A Kingswood return -EINVAL; 242664d5df9SWerner Cornelius 243c432df15SJohan Hovold val = ch341_get_divisor(priv); 24435714565SJohan Hovold if (val < 0) 245664d5df9SWerner Cornelius return -EINVAL; 246664d5df9SWerner Cornelius 24755fa15b5SJohan Hovold /* 24855fa15b5SJohan Hovold * CH341A buffers data until a full endpoint-size packet (32 bytes) 24955fa15b5SJohan Hovold * has been received unless bit 7 is set. 25055fa15b5SJohan Hovold */ 25135714565SJohan Hovold val |= BIT(7); 25255fa15b5SJohan Hovold 253*2c509d1cSMichael Hanselmann r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 254*2c509d1cSMichael Hanselmann CH341_REG_DIVISOR << 8 | CH341_REG_PRESCALER, 255*2c509d1cSMichael Hanselmann val); 25655fa15b5SJohan Hovold if (r) 25755fa15b5SJohan Hovold return r; 25855fa15b5SJohan Hovold 259*2c509d1cSMichael Hanselmann /* 260*2c509d1cSMichael Hanselmann * Chip versions before version 0x30 as read using 261*2c509d1cSMichael Hanselmann * CH341_REQ_READ_VERSION used separate registers for line control 262*2c509d1cSMichael Hanselmann * (stop bits, parity and word length). Version 0x30 and above use 263*2c509d1cSMichael Hanselmann * CH341_REG_LCR only and CH341_REG_LCR2 is always set to zero. 264*2c509d1cSMichael Hanselmann */ 265*2c509d1cSMichael Hanselmann r = ch341_control_out(dev, CH341_REQ_WRITE_REG, 266*2c509d1cSMichael Hanselmann CH341_REG_LCR2 << 8 | CH341_REG_LCR, lcr); 26755fa15b5SJohan Hovold if (r) 26855fa15b5SJohan Hovold return r; 2696ce76104SFrank A Kingswood 2706ce76104SFrank A Kingswood return r; 2716ce76104SFrank A Kingswood } 2726ce76104SFrank A Kingswood 273664d5df9SWerner Cornelius static int ch341_set_handshake(struct usb_device *dev, u8 control) 2746ce76104SFrank A Kingswood { 2756fde8d29SAidan Thornton return ch341_control_out(dev, CH341_REQ_MODEM_CTRL, ~control, 0); 2766ce76104SFrank A Kingswood } 2776ce76104SFrank A Kingswood 278664d5df9SWerner Cornelius static int ch341_get_status(struct usb_device *dev, struct ch341_private *priv) 2796ce76104SFrank A Kingswood { 2802d5a9c72SJohan Hovold const unsigned int size = 2; 2816ce76104SFrank A Kingswood char *buffer; 2826ce76104SFrank A Kingswood int r; 283664d5df9SWerner Cornelius unsigned long flags; 2846ce76104SFrank A Kingswood 2856ce76104SFrank A Kingswood buffer = kmalloc(size, GFP_KERNEL); 2866ce76104SFrank A Kingswood if (!buffer) 2876ce76104SFrank A Kingswood return -ENOMEM; 2886ce76104SFrank A Kingswood 2896fde8d29SAidan Thornton r = ch341_control_in(dev, CH341_REQ_READ_REG, 0x0706, 0, buffer, size); 2906ce76104SFrank A Kingswood if (r < 0) 2916ce76104SFrank A Kingswood goto out; 2926ce76104SFrank A Kingswood 293664d5df9SWerner Cornelius spin_lock_irqsave(&priv->lock, flags); 294e8024460SJohan Hovold priv->msr = (~(*buffer)) & CH341_BITS_MODEM_STAT; 295664d5df9SWerner Cornelius spin_unlock_irqrestore(&priv->lock, flags); 2966ce76104SFrank A Kingswood 2976ce76104SFrank A Kingswood out: kfree(buffer); 2986ce76104SFrank A Kingswood return r; 2996ce76104SFrank A Kingswood } 3006ce76104SFrank A Kingswood 3016ce76104SFrank A Kingswood /* -------------------------------------------------------------------------- */ 3026ce76104SFrank A Kingswood 30393b6497dSAdrian Bunk static int ch341_configure(struct usb_device *dev, struct ch341_private *priv) 3046ce76104SFrank A Kingswood { 3052d5a9c72SJohan Hovold const unsigned int size = 2; 3066ce76104SFrank A Kingswood char *buffer; 3076ce76104SFrank A Kingswood int r; 3086ce76104SFrank A Kingswood 3096ce76104SFrank A Kingswood buffer = kmalloc(size, GFP_KERNEL); 3106ce76104SFrank A Kingswood if (!buffer) 3116ce76104SFrank A Kingswood return -ENOMEM; 3126ce76104SFrank A Kingswood 3136ce76104SFrank A Kingswood /* expect two bytes 0x27 0x00 */ 3146fde8d29SAidan Thornton r = ch341_control_in(dev, CH341_REQ_READ_VERSION, 0, 0, buffer, size); 3156ce76104SFrank A Kingswood if (r < 0) 3166ce76104SFrank A Kingswood goto out; 317a98b6900SAidan Thornton dev_dbg(&dev->dev, "Chip version: 0x%02x\n", buffer[0]); 3186ce76104SFrank A Kingswood 3196fde8d29SAidan Thornton r = ch341_control_out(dev, CH341_REQ_SERIAL_INIT, 0, 0); 3206ce76104SFrank A Kingswood if (r < 0) 3216ce76104SFrank A Kingswood goto out; 3226ce76104SFrank A Kingswood 32355fa15b5SJohan Hovold r = ch341_set_baudrate_lcr(dev, priv, priv->lcr); 3246ce76104SFrank A Kingswood if (r < 0) 3256ce76104SFrank A Kingswood goto out; 3266ce76104SFrank A Kingswood 327beea33d4SJohan Hovold r = ch341_set_handshake(dev, priv->mcr); 3286ce76104SFrank A Kingswood 3296ce76104SFrank A Kingswood out: kfree(buffer); 3306ce76104SFrank A Kingswood return r; 3316ce76104SFrank A Kingswood } 3326ce76104SFrank A Kingswood 333c404bf4aSMichael Hanselmann static int ch341_detect_quirks(struct usb_serial_port *port) 334c404bf4aSMichael Hanselmann { 335c404bf4aSMichael Hanselmann struct ch341_private *priv = usb_get_serial_port_data(port); 336c404bf4aSMichael Hanselmann struct usb_device *udev = port->serial->dev; 337c404bf4aSMichael Hanselmann const unsigned int size = 2; 338c404bf4aSMichael Hanselmann unsigned long quirks = 0; 339c404bf4aSMichael Hanselmann char *buffer; 340c404bf4aSMichael Hanselmann int r; 341c404bf4aSMichael Hanselmann 342c404bf4aSMichael Hanselmann buffer = kmalloc(size, GFP_KERNEL); 343c404bf4aSMichael Hanselmann if (!buffer) 344c404bf4aSMichael Hanselmann return -ENOMEM; 345c404bf4aSMichael Hanselmann 346c404bf4aSMichael Hanselmann /* 347c404bf4aSMichael Hanselmann * A subset of CH34x devices does not support all features. The 348c404bf4aSMichael Hanselmann * prescaler is limited and there is no support for sending a RS232 349c404bf4aSMichael Hanselmann * break condition. A read failure when trying to set up the latter is 350c404bf4aSMichael Hanselmann * used to detect these devices. 351c404bf4aSMichael Hanselmann */ 352c404bf4aSMichael Hanselmann r = usb_control_msg(udev, usb_rcvctrlpipe(udev, 0), CH341_REQ_READ_REG, 353c404bf4aSMichael Hanselmann USB_TYPE_VENDOR | USB_RECIP_DEVICE | USB_DIR_IN, 354c404bf4aSMichael Hanselmann CH341_REG_BREAK, 0, buffer, size, DEFAULT_TIMEOUT); 355c404bf4aSMichael Hanselmann if (r == -EPIPE) { 356c404bf4aSMichael Hanselmann dev_dbg(&port->dev, "break control not supported\n"); 357c432df15SJohan Hovold quirks = CH341_QUIRK_LIMITED_PRESCALER; 358c404bf4aSMichael Hanselmann r = 0; 359c404bf4aSMichael Hanselmann goto out; 360c404bf4aSMichael Hanselmann } 361c404bf4aSMichael Hanselmann 362c404bf4aSMichael Hanselmann if (r != size) { 363c404bf4aSMichael Hanselmann if (r >= 0) 364c404bf4aSMichael Hanselmann r = -EIO; 365c404bf4aSMichael Hanselmann dev_err(&port->dev, "failed to read break control: %d\n", r); 366c404bf4aSMichael Hanselmann goto out; 367c404bf4aSMichael Hanselmann } 368c404bf4aSMichael Hanselmann 369c404bf4aSMichael Hanselmann r = 0; 370c404bf4aSMichael Hanselmann out: 371c404bf4aSMichael Hanselmann kfree(buffer); 372c404bf4aSMichael Hanselmann 373c404bf4aSMichael Hanselmann if (quirks) { 374c404bf4aSMichael Hanselmann dev_dbg(&port->dev, "enabling quirk flags: 0x%02lx\n", quirks); 375c404bf4aSMichael Hanselmann priv->quirks |= quirks; 376c404bf4aSMichael Hanselmann } 377c404bf4aSMichael Hanselmann 378c404bf4aSMichael Hanselmann return r; 379c404bf4aSMichael Hanselmann } 380c404bf4aSMichael Hanselmann 381456c5be5SJohan Hovold static int ch341_port_probe(struct usb_serial_port *port) 3826ce76104SFrank A Kingswood { 3836ce76104SFrank A Kingswood struct ch341_private *priv; 3846ce76104SFrank A Kingswood int r; 3856ce76104SFrank A Kingswood 3866ce76104SFrank A Kingswood priv = kzalloc(sizeof(struct ch341_private), GFP_KERNEL); 3876ce76104SFrank A Kingswood if (!priv) 3886ce76104SFrank A Kingswood return -ENOMEM; 3896ce76104SFrank A Kingswood 390664d5df9SWerner Cornelius spin_lock_init(&priv->lock); 3916ce76104SFrank A Kingswood priv->baud_rate = DEFAULT_BAUD_RATE; 3927c61b0d5SJohan Hovold /* 3937c61b0d5SJohan Hovold * Some CH340 devices appear unable to change the initial LCR 3947c61b0d5SJohan Hovold * settings, so set a sane 8N1 default. 3957c61b0d5SJohan Hovold */ 3967c61b0d5SJohan Hovold priv->lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX | CH341_LCR_CS8; 3976ce76104SFrank A Kingswood 398456c5be5SJohan Hovold r = ch341_configure(port->serial->dev, priv); 3996ce76104SFrank A Kingswood if (r < 0) 4006ce76104SFrank A Kingswood goto error; 4016ce76104SFrank A Kingswood 402456c5be5SJohan Hovold usb_set_serial_port_data(port, priv); 403c404bf4aSMichael Hanselmann 404c404bf4aSMichael Hanselmann r = ch341_detect_quirks(port); 405c404bf4aSMichael Hanselmann if (r < 0) 406c404bf4aSMichael Hanselmann goto error; 407c404bf4aSMichael Hanselmann 4086ce76104SFrank A Kingswood return 0; 4096ce76104SFrank A Kingswood 4106ce76104SFrank A Kingswood error: kfree(priv); 4116ce76104SFrank A Kingswood return r; 4126ce76104SFrank A Kingswood } 4136ce76104SFrank A Kingswood 414456c5be5SJohan Hovold static int ch341_port_remove(struct usb_serial_port *port) 415456c5be5SJohan Hovold { 416456c5be5SJohan Hovold struct ch341_private *priv; 417456c5be5SJohan Hovold 418456c5be5SJohan Hovold priv = usb_get_serial_port_data(port); 419456c5be5SJohan Hovold kfree(priv); 420456c5be5SJohan Hovold 421456c5be5SJohan Hovold return 0; 422456c5be5SJohan Hovold } 423456c5be5SJohan Hovold 424335f8514SAlan Cox static int ch341_carrier_raised(struct usb_serial_port *port) 425335f8514SAlan Cox { 426335f8514SAlan Cox struct ch341_private *priv = usb_get_serial_port_data(port); 427e8024460SJohan Hovold if (priv->msr & CH341_BIT_DCD) 428335f8514SAlan Cox return 1; 429335f8514SAlan Cox return 0; 430335f8514SAlan Cox } 431335f8514SAlan Cox 432335f8514SAlan Cox static void ch341_dtr_rts(struct usb_serial_port *port, int on) 433664d5df9SWerner Cornelius { 434664d5df9SWerner Cornelius struct ch341_private *priv = usb_get_serial_port_data(port); 435664d5df9SWerner Cornelius unsigned long flags; 436664d5df9SWerner Cornelius 437335f8514SAlan Cox /* drop DTR and RTS */ 438335f8514SAlan Cox spin_lock_irqsave(&priv->lock, flags); 439335f8514SAlan Cox if (on) 440beea33d4SJohan Hovold priv->mcr |= CH341_BIT_RTS | CH341_BIT_DTR; 441335f8514SAlan Cox else 442beea33d4SJohan Hovold priv->mcr &= ~(CH341_BIT_RTS | CH341_BIT_DTR); 443335f8514SAlan Cox spin_unlock_irqrestore(&priv->lock, flags); 444beea33d4SJohan Hovold ch341_set_handshake(port->serial->dev, priv->mcr); 445335f8514SAlan Cox } 446335f8514SAlan Cox 447335f8514SAlan Cox static void ch341_close(struct usb_serial_port *port) 448335f8514SAlan Cox { 449f26788daSJohan Hovold usb_serial_generic_close(port); 450664d5df9SWerner Cornelius usb_kill_urb(port->interrupt_in_urb); 451664d5df9SWerner Cornelius } 452664d5df9SWerner Cornelius 453664d5df9SWerner Cornelius 4546ce76104SFrank A Kingswood /* open this device, set default parameters */ 455a509a7e4SAlan Cox static int ch341_open(struct tty_struct *tty, struct usb_serial_port *port) 4566ce76104SFrank A Kingswood { 457456c5be5SJohan Hovold struct ch341_private *priv = usb_get_serial_port_data(port); 4586ce76104SFrank A Kingswood int r; 4596ce76104SFrank A Kingswood 460aa91def4SNicolas PLANEL if (tty) 461aa91def4SNicolas PLANEL ch341_set_termios(tty, port, NULL); 4626ce76104SFrank A Kingswood 463d9a38a87SJohan Hovold dev_dbg(&port->dev, "%s - submitting interrupt urb\n", __func__); 464664d5df9SWerner Cornelius r = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 465664d5df9SWerner Cornelius if (r) { 466d9a38a87SJohan Hovold dev_err(&port->dev, "%s - failed to submit interrupt urb: %d\n", 467d9a38a87SJohan Hovold __func__, r); 468f2950b78SJohan Hovold return r; 469664d5df9SWerner Cornelius } 470664d5df9SWerner Cornelius 471a0467a96SJohan Hovold r = ch341_get_status(port->serial->dev, priv); 472a0467a96SJohan Hovold if (r < 0) { 473a0467a96SJohan Hovold dev_err(&port->dev, "failed to read modem status: %d\n", r); 474a0467a96SJohan Hovold goto err_kill_interrupt_urb; 475a0467a96SJohan Hovold } 476a0467a96SJohan Hovold 477a509a7e4SAlan Cox r = usb_serial_generic_open(tty, port); 478f2950b78SJohan Hovold if (r) 479f2950b78SJohan Hovold goto err_kill_interrupt_urb; 4806ce76104SFrank A Kingswood 481f2950b78SJohan Hovold return 0; 482f2950b78SJohan Hovold 483f2950b78SJohan Hovold err_kill_interrupt_urb: 484f2950b78SJohan Hovold usb_kill_urb(port->interrupt_in_urb); 485f2950b78SJohan Hovold 486f2950b78SJohan Hovold return r; 4876ce76104SFrank A Kingswood } 4886ce76104SFrank A Kingswood 4896ce76104SFrank A Kingswood /* Old_termios contains the original termios settings and 4906ce76104SFrank A Kingswood * tty->termios contains the new setting to be used. 4916ce76104SFrank A Kingswood */ 49295da310eSAlan Cox static void ch341_set_termios(struct tty_struct *tty, 49395da310eSAlan Cox struct usb_serial_port *port, struct ktermios *old_termios) 4946ce76104SFrank A Kingswood { 4956ce76104SFrank A Kingswood struct ch341_private *priv = usb_get_serial_port_data(port); 4966ce76104SFrank A Kingswood unsigned baud_rate; 497664d5df9SWerner Cornelius unsigned long flags; 498448b6dc5SJohan Hovold u8 lcr; 4994e46c410SAidan Thornton int r; 5004e46c410SAidan Thornton 5014e46c410SAidan Thornton /* redundant changes may cause the chip to lose bytes */ 5024e46c410SAidan Thornton if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios)) 5034e46c410SAidan Thornton return; 5046ce76104SFrank A Kingswood 5056ce76104SFrank A Kingswood baud_rate = tty_get_baud_rate(tty); 5066ce76104SFrank A Kingswood 507448b6dc5SJohan Hovold lcr = CH341_LCR_ENABLE_RX | CH341_LCR_ENABLE_TX; 508664d5df9SWerner Cornelius 509ba781bdfSAidan Thornton switch (C_CSIZE(tty)) { 510ba781bdfSAidan Thornton case CS5: 511448b6dc5SJohan Hovold lcr |= CH341_LCR_CS5; 512ba781bdfSAidan Thornton break; 513ba781bdfSAidan Thornton case CS6: 514448b6dc5SJohan Hovold lcr |= CH341_LCR_CS6; 515ba781bdfSAidan Thornton break; 516ba781bdfSAidan Thornton case CS7: 517448b6dc5SJohan Hovold lcr |= CH341_LCR_CS7; 518ba781bdfSAidan Thornton break; 519ba781bdfSAidan Thornton case CS8: 520448b6dc5SJohan Hovold lcr |= CH341_LCR_CS8; 521ba781bdfSAidan Thornton break; 522ba781bdfSAidan Thornton } 523ba781bdfSAidan Thornton 524ba781bdfSAidan Thornton if (C_PARENB(tty)) { 525448b6dc5SJohan Hovold lcr |= CH341_LCR_ENABLE_PAR; 526ba781bdfSAidan Thornton if (C_PARODD(tty) == 0) 527448b6dc5SJohan Hovold lcr |= CH341_LCR_PAR_EVEN; 528ba781bdfSAidan Thornton if (C_CMSPAR(tty)) 529448b6dc5SJohan Hovold lcr |= CH341_LCR_MARK_SPACE; 530ba781bdfSAidan Thornton } 531ba781bdfSAidan Thornton 532ba781bdfSAidan Thornton if (C_CSTOPB(tty)) 533448b6dc5SJohan Hovold lcr |= CH341_LCR_STOP_BITS_2; 5344e46c410SAidan Thornton 535664d5df9SWerner Cornelius if (baud_rate) { 536a20047f3SJohan Hovold priv->baud_rate = baud_rate; 537a20047f3SJohan Hovold 538448b6dc5SJohan Hovold r = ch341_set_baudrate_lcr(port->serial->dev, priv, lcr); 5394e46c410SAidan Thornton if (r < 0 && old_termios) { 5404e46c410SAidan Thornton priv->baud_rate = tty_termios_baud_rate(old_termios); 5414e46c410SAidan Thornton tty_termios_copy_hw(&tty->termios, old_termios); 5423cca8624SJohan Hovold } else if (r == 0) { 543448b6dc5SJohan Hovold priv->lcr = lcr; 5444e46c410SAidan Thornton } 5456ce76104SFrank A Kingswood } 5466ce76104SFrank A Kingswood 547030ee7aeSJohan Hovold spin_lock_irqsave(&priv->lock, flags); 548030ee7aeSJohan Hovold if (C_BAUD(tty) == B0) 549beea33d4SJohan Hovold priv->mcr &= ~(CH341_BIT_DTR | CH341_BIT_RTS); 550030ee7aeSJohan Hovold else if (old_termios && (old_termios->c_cflag & CBAUD) == B0) 551beea33d4SJohan Hovold priv->mcr |= (CH341_BIT_DTR | CH341_BIT_RTS); 552030ee7aeSJohan Hovold spin_unlock_irqrestore(&priv->lock, flags); 5536ce76104SFrank A Kingswood 554beea33d4SJohan Hovold ch341_set_handshake(port->serial->dev, priv->mcr); 555664d5df9SWerner Cornelius } 55673f59308SAlan Cox 557492896f0STim Small static void ch341_break_ctl(struct tty_struct *tty, int break_state) 558492896f0STim Small { 559492896f0STim Small const uint16_t ch341_break_reg = 5606fde8d29SAidan Thornton ((uint16_t) CH341_REG_LCR << 8) | CH341_REG_BREAK; 561492896f0STim Small struct usb_serial_port *port = tty->driver_data; 562492896f0STim Small int r; 563492896f0STim Small uint16_t reg_contents; 564f2b5cc83SJohan Hovold uint8_t *break_reg; 565492896f0STim Small 566f2b5cc83SJohan Hovold break_reg = kmalloc(2, GFP_KERNEL); 56710c642d0SJohan Hovold if (!break_reg) 568f2b5cc83SJohan Hovold return; 569f2b5cc83SJohan Hovold 570492896f0STim Small r = ch341_control_in(port->serial->dev, CH341_REQ_READ_REG, 571f2b5cc83SJohan Hovold ch341_break_reg, 0, break_reg, 2); 572492896f0STim Small if (r < 0) { 5736a9b15feSJohan Hovold dev_err(&port->dev, "%s - USB control read error (%d)\n", 5746a9b15feSJohan Hovold __func__, r); 575f2b5cc83SJohan Hovold goto out; 576492896f0STim Small } 57779cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - initial ch341 break register contents - reg1: %x, reg2: %x\n", 578492896f0STim Small __func__, break_reg[0], break_reg[1]); 579492896f0STim Small if (break_state != 0) { 58079cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - Enter break state requested\n", __func__); 5816fde8d29SAidan Thornton break_reg[0] &= ~CH341_NBREAK_BITS; 5826fde8d29SAidan Thornton break_reg[1] &= ~CH341_LCR_ENABLE_TX; 583492896f0STim Small } else { 58479cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - Leave break state requested\n", __func__); 5856fde8d29SAidan Thornton break_reg[0] |= CH341_NBREAK_BITS; 5866fde8d29SAidan Thornton break_reg[1] |= CH341_LCR_ENABLE_TX; 587492896f0STim Small } 58879cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - New ch341 break register contents - reg1: %x, reg2: %x\n", 589492896f0STim Small __func__, break_reg[0], break_reg[1]); 5905be796f0SJohan Hovold reg_contents = get_unaligned_le16(break_reg); 591492896f0STim Small r = ch341_control_out(port->serial->dev, CH341_REQ_WRITE_REG, 592492896f0STim Small ch341_break_reg, reg_contents); 593492896f0STim Small if (r < 0) 5946a9b15feSJohan Hovold dev_err(&port->dev, "%s - USB control write error (%d)\n", 5956a9b15feSJohan Hovold __func__, r); 596f2b5cc83SJohan Hovold out: 597f2b5cc83SJohan Hovold kfree(break_reg); 598492896f0STim Small } 599492896f0STim Small 60020b9d177SAlan Cox static int ch341_tiocmset(struct tty_struct *tty, 601664d5df9SWerner Cornelius unsigned int set, unsigned int clear) 602664d5df9SWerner Cornelius { 603664d5df9SWerner Cornelius struct usb_serial_port *port = tty->driver_data; 604664d5df9SWerner Cornelius struct ch341_private *priv = usb_get_serial_port_data(port); 605664d5df9SWerner Cornelius unsigned long flags; 606664d5df9SWerner Cornelius u8 control; 607664d5df9SWerner Cornelius 608664d5df9SWerner Cornelius spin_lock_irqsave(&priv->lock, flags); 609664d5df9SWerner Cornelius if (set & TIOCM_RTS) 610beea33d4SJohan Hovold priv->mcr |= CH341_BIT_RTS; 611664d5df9SWerner Cornelius if (set & TIOCM_DTR) 612beea33d4SJohan Hovold priv->mcr |= CH341_BIT_DTR; 613664d5df9SWerner Cornelius if (clear & TIOCM_RTS) 614beea33d4SJohan Hovold priv->mcr &= ~CH341_BIT_RTS; 615664d5df9SWerner Cornelius if (clear & TIOCM_DTR) 616beea33d4SJohan Hovold priv->mcr &= ~CH341_BIT_DTR; 617beea33d4SJohan Hovold control = priv->mcr; 618664d5df9SWerner Cornelius spin_unlock_irqrestore(&priv->lock, flags); 619664d5df9SWerner Cornelius 620664d5df9SWerner Cornelius return ch341_set_handshake(port->serial->dev, control); 621664d5df9SWerner Cornelius } 622664d5df9SWerner Cornelius 623e8024460SJohan Hovold static void ch341_update_status(struct usb_serial_port *port, 624ac035628SJohan Hovold unsigned char *data, size_t len) 625ac035628SJohan Hovold { 626ac035628SJohan Hovold struct ch341_private *priv = usb_get_serial_port_data(port); 627b770081fSJohan Hovold struct tty_struct *tty; 628ac035628SJohan Hovold unsigned long flags; 629b770081fSJohan Hovold u8 status; 630b770081fSJohan Hovold u8 delta; 631ac035628SJohan Hovold 632ac035628SJohan Hovold if (len < 4) 633ac035628SJohan Hovold return; 634ac035628SJohan Hovold 635b770081fSJohan Hovold status = ~data[2] & CH341_BITS_MODEM_STAT; 636b770081fSJohan Hovold 637ac035628SJohan Hovold spin_lock_irqsave(&priv->lock, flags); 638e8024460SJohan Hovold delta = status ^ priv->msr; 639e8024460SJohan Hovold priv->msr = status; 640ac035628SJohan Hovold spin_unlock_irqrestore(&priv->lock, flags); 641ac035628SJohan Hovold 642fd74b0b1SJohan Hovold if (data[1] & CH341_MULT_STAT) 643fd74b0b1SJohan Hovold dev_dbg(&port->dev, "%s - multiple status change\n", __func__); 644fd74b0b1SJohan Hovold 645d984fe91SJohan Hovold if (!delta) 646d984fe91SJohan Hovold return; 647d984fe91SJohan Hovold 6485e409a26SJohan Hovold if (delta & CH341_BIT_CTS) 6495e409a26SJohan Hovold port->icount.cts++; 6505e409a26SJohan Hovold if (delta & CH341_BIT_DSR) 6515e409a26SJohan Hovold port->icount.dsr++; 6525e409a26SJohan Hovold if (delta & CH341_BIT_RI) 6535e409a26SJohan Hovold port->icount.rng++; 654b770081fSJohan Hovold if (delta & CH341_BIT_DCD) { 6555e409a26SJohan Hovold port->icount.dcd++; 656b770081fSJohan Hovold tty = tty_port_tty_get(&port->port); 657b770081fSJohan Hovold if (tty) { 658ac035628SJohan Hovold usb_serial_handle_dcd_change(port, tty, 659b770081fSJohan Hovold status & CH341_BIT_DCD); 660ac035628SJohan Hovold tty_kref_put(tty); 661ac035628SJohan Hovold } 662b770081fSJohan Hovold } 663ac035628SJohan Hovold 664ac035628SJohan Hovold wake_up_interruptible(&port->port.delta_msr_wait); 665ac035628SJohan Hovold } 666ac035628SJohan Hovold 667664d5df9SWerner Cornelius static void ch341_read_int_callback(struct urb *urb) 668664d5df9SWerner Cornelius { 669271ec2d2SJohan Hovold struct usb_serial_port *port = urb->context; 670664d5df9SWerner Cornelius unsigned char *data = urb->transfer_buffer; 671271ec2d2SJohan Hovold unsigned int len = urb->actual_length; 672664d5df9SWerner Cornelius int status; 673664d5df9SWerner Cornelius 674664d5df9SWerner Cornelius switch (urb->status) { 675664d5df9SWerner Cornelius case 0: 676664d5df9SWerner Cornelius /* success */ 677664d5df9SWerner Cornelius break; 678664d5df9SWerner Cornelius case -ECONNRESET: 679664d5df9SWerner Cornelius case -ENOENT: 680664d5df9SWerner Cornelius case -ESHUTDOWN: 681664d5df9SWerner Cornelius /* this urb is terminated, clean up */ 682271ec2d2SJohan Hovold dev_dbg(&urb->dev->dev, "%s - urb shutting down: %d\n", 68379cbeeafSGreg Kroah-Hartman __func__, urb->status); 684664d5df9SWerner Cornelius return; 685664d5df9SWerner Cornelius default: 686271ec2d2SJohan Hovold dev_dbg(&urb->dev->dev, "%s - nonzero urb status: %d\n", 68779cbeeafSGreg Kroah-Hartman __func__, urb->status); 688664d5df9SWerner Cornelius goto exit; 689664d5df9SWerner Cornelius } 690664d5df9SWerner Cornelius 691271ec2d2SJohan Hovold usb_serial_debug_data(&port->dev, __func__, len, data); 692e8024460SJohan Hovold ch341_update_status(port, data, len); 693664d5df9SWerner Cornelius exit: 694664d5df9SWerner Cornelius status = usb_submit_urb(urb, GFP_ATOMIC); 695271ec2d2SJohan Hovold if (status) { 696271ec2d2SJohan Hovold dev_err(&urb->dev->dev, "%s - usb_submit_urb failed: %d\n", 697664d5df9SWerner Cornelius __func__, status); 698664d5df9SWerner Cornelius } 699271ec2d2SJohan Hovold } 700664d5df9SWerner Cornelius 70160b33c13SAlan Cox static int ch341_tiocmget(struct tty_struct *tty) 702664d5df9SWerner Cornelius { 703664d5df9SWerner Cornelius struct usb_serial_port *port = tty->driver_data; 704664d5df9SWerner Cornelius struct ch341_private *priv = usb_get_serial_port_data(port); 705664d5df9SWerner Cornelius unsigned long flags; 706664d5df9SWerner Cornelius u8 mcr; 707664d5df9SWerner Cornelius u8 status; 708664d5df9SWerner Cornelius unsigned int result; 709664d5df9SWerner Cornelius 710664d5df9SWerner Cornelius spin_lock_irqsave(&priv->lock, flags); 711beea33d4SJohan Hovold mcr = priv->mcr; 712e8024460SJohan Hovold status = priv->msr; 713664d5df9SWerner Cornelius spin_unlock_irqrestore(&priv->lock, flags); 714664d5df9SWerner Cornelius 715664d5df9SWerner Cornelius result = ((mcr & CH341_BIT_DTR) ? TIOCM_DTR : 0) 716664d5df9SWerner Cornelius | ((mcr & CH341_BIT_RTS) ? TIOCM_RTS : 0) 717664d5df9SWerner Cornelius | ((status & CH341_BIT_CTS) ? TIOCM_CTS : 0) 718664d5df9SWerner Cornelius | ((status & CH341_BIT_DSR) ? TIOCM_DSR : 0) 719664d5df9SWerner Cornelius | ((status & CH341_BIT_RI) ? TIOCM_RI : 0) 720664d5df9SWerner Cornelius | ((status & CH341_BIT_DCD) ? TIOCM_CD : 0); 721664d5df9SWerner Cornelius 72279cbeeafSGreg Kroah-Hartman dev_dbg(&port->dev, "%s - result = %x\n", __func__, result); 723664d5df9SWerner Cornelius 724664d5df9SWerner Cornelius return result; 7256ce76104SFrank A Kingswood } 7266ce76104SFrank A Kingswood 727622b80cfSGreg Kroah-Hartman static int ch341_reset_resume(struct usb_serial *serial) 7281ded7ea4SMing Lei { 729ce5e2928SJohan Hovold struct usb_serial_port *port = serial->port[0]; 7304d5ef53fSJohan Hovold struct ch341_private *priv; 731ce5e2928SJohan Hovold int ret; 7321ded7ea4SMing Lei 7334d5ef53fSJohan Hovold priv = usb_get_serial_port_data(port); 7344d5ef53fSJohan Hovold if (!priv) 7354d5ef53fSJohan Hovold return 0; 7364d5ef53fSJohan Hovold 7371ded7ea4SMing Lei /* reconfigure ch341 serial port after bus-reset */ 7382bfd1c96SGreg Kroah-Hartman ch341_configure(serial->dev, priv); 7391ded7ea4SMing Lei 740ce5e2928SJohan Hovold if (tty_port_initialized(&port->port)) { 741ce5e2928SJohan Hovold ret = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 742ce5e2928SJohan Hovold if (ret) { 743ce5e2928SJohan Hovold dev_err(&port->dev, "failed to submit interrupt urb: %d\n", 744ce5e2928SJohan Hovold ret); 745ce5e2928SJohan Hovold return ret; 746ce5e2928SJohan Hovold } 747a0467a96SJohan Hovold 748a0467a96SJohan Hovold ret = ch341_get_status(port->serial->dev, priv); 749a0467a96SJohan Hovold if (ret < 0) { 750a0467a96SJohan Hovold dev_err(&port->dev, "failed to read modem status: %d\n", 751a0467a96SJohan Hovold ret); 752a0467a96SJohan Hovold } 753ce5e2928SJohan Hovold } 754ce5e2928SJohan Hovold 755ce5e2928SJohan Hovold return usb_serial_generic_resume(serial); 7561ded7ea4SMing Lei } 7571ded7ea4SMing Lei 7586ce76104SFrank A Kingswood static struct usb_serial_driver ch341_device = { 7596ce76104SFrank A Kingswood .driver = { 7606ce76104SFrank A Kingswood .owner = THIS_MODULE, 7616ce76104SFrank A Kingswood .name = "ch341-uart", 7626ce76104SFrank A Kingswood }, 7636ce76104SFrank A Kingswood .id_table = id_table, 7646ce76104SFrank A Kingswood .num_ports = 1, 7656ce76104SFrank A Kingswood .open = ch341_open, 766335f8514SAlan Cox .dtr_rts = ch341_dtr_rts, 767335f8514SAlan Cox .carrier_raised = ch341_carrier_raised, 768664d5df9SWerner Cornelius .close = ch341_close, 7696ce76104SFrank A Kingswood .set_termios = ch341_set_termios, 770492896f0STim Small .break_ctl = ch341_break_ctl, 771664d5df9SWerner Cornelius .tiocmget = ch341_tiocmget, 772664d5df9SWerner Cornelius .tiocmset = ch341_tiocmset, 7735e409a26SJohan Hovold .tiocmiwait = usb_serial_generic_tiocmiwait, 774664d5df9SWerner Cornelius .read_int_callback = ch341_read_int_callback, 775456c5be5SJohan Hovold .port_probe = ch341_port_probe, 776456c5be5SJohan Hovold .port_remove = ch341_port_remove, 7771c1eaba8SGreg Kroah-Hartman .reset_resume = ch341_reset_resume, 7786ce76104SFrank A Kingswood }; 7796ce76104SFrank A Kingswood 78008a4f6bcSAlan Stern static struct usb_serial_driver * const serial_drivers[] = { 78108a4f6bcSAlan Stern &ch341_device, NULL 78208a4f6bcSAlan Stern }; 78308a4f6bcSAlan Stern 78468e24113SGreg Kroah-Hartman module_usb_serial_driver(serial_drivers, id_table); 7856ce76104SFrank A Kingswood 786627cfa89SJohan Hovold MODULE_LICENSE("GPL v2"); 787