Back to home page

OSCL-LXR
 
 

     

0001 // SPDX-License-Identifier: GPL-2.0
0002 /*
0003  * Silicon Laboratories CP210x USB to RS232 serial adaptor driver
0004  *
0005  * Copyright (C) 2005 Craig Shelley (craig@microtron.org.uk)
0006  * Copyright (C) 2010-2021 Johan Hovold (johan@kernel.org)
0007  *
0008  * Support to set flow control line levels using TIOCMGET and TIOCMSET
0009  * thanks to Karl Hiramoto karl@hiramoto.org. RTSCTS hardware flow
0010  * control thanks to Munir Nassar nassarmu@real-time.com
0011  *
0012  */
0013 
0014 #include <linux/kernel.h>
0015 #include <linux/errno.h>
0016 #include <linux/slab.h>
0017 #include <linux/tty.h>
0018 #include <linux/tty_flip.h>
0019 #include <linux/module.h>
0020 #include <linux/usb.h>
0021 #include <linux/usb/serial.h>
0022 #include <linux/gpio/driver.h>
0023 #include <linux/bitops.h>
0024 #include <linux/mutex.h>
0025 
0026 #define DRIVER_DESC "Silicon Labs CP210x RS232 serial adaptor driver"
0027 
0028 /*
0029  * Function Prototypes
0030  */
0031 static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
0032 static void cp210x_close(struct usb_serial_port *);
0033 static void cp210x_change_speed(struct tty_struct *, struct usb_serial_port *,
0034                             struct ktermios *);
0035 static void cp210x_set_termios(struct tty_struct *, struct usb_serial_port *,
0036                             struct ktermios*);
0037 static bool cp210x_tx_empty(struct usb_serial_port *port);
0038 static int cp210x_tiocmget(struct tty_struct *);
0039 static int cp210x_tiocmset(struct tty_struct *, unsigned int, unsigned int);
0040 static int cp210x_tiocmset_port(struct usb_serial_port *port,
0041         unsigned int, unsigned int);
0042 static void cp210x_break_ctl(struct tty_struct *, int);
0043 static int cp210x_attach(struct usb_serial *);
0044 static void cp210x_disconnect(struct usb_serial *);
0045 static void cp210x_release(struct usb_serial *);
0046 static int cp210x_port_probe(struct usb_serial_port *);
0047 static void cp210x_port_remove(struct usb_serial_port *);
0048 static void cp210x_dtr_rts(struct usb_serial_port *port, int on);
0049 static void cp210x_process_read_urb(struct urb *urb);
0050 static void cp210x_enable_event_mode(struct usb_serial_port *port);
0051 static void cp210x_disable_event_mode(struct usb_serial_port *port);
0052 
0053 static const struct usb_device_id id_table[] = {
0054     { USB_DEVICE(0x0404, 0x034C) }, /* NCR Retail IO Box */
0055     { USB_DEVICE(0x045B, 0x0053) }, /* Renesas RX610 RX-Stick */
0056     { USB_DEVICE(0x0471, 0x066A) }, /* AKTAKOM ACE-1001 cable */
0057     { USB_DEVICE(0x0489, 0xE000) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
0058     { USB_DEVICE(0x0489, 0xE003) }, /* Pirelli Broadband S.p.A, DP-L10 SIP/GSM Mobile */
0059     { USB_DEVICE(0x0745, 0x1000) }, /* CipherLab USB CCD Barcode Scanner 1000 */
0060     { USB_DEVICE(0x0846, 0x1100) }, /* NetGear Managed Switch M4100 series, M5300 series, M7100 series */
0061     { USB_DEVICE(0x08e6, 0x5501) }, /* Gemalto Prox-PU/CU contactless smartcard reader */
0062     { USB_DEVICE(0x08FD, 0x000A) }, /* Digianswer A/S , ZigBee/802.15.4 MAC Device */
0063     { USB_DEVICE(0x0908, 0x01FF) }, /* Siemens RUGGEDCOM USB Serial Console */
0064     { USB_DEVICE(0x0988, 0x0578) }, /* Teraoka AD2000 */
0065     { USB_DEVICE(0x0B00, 0x3070) }, /* Ingenico 3070 */
0066     { USB_DEVICE(0x0BED, 0x1100) }, /* MEI (TM) Cashflow-SC Bill/Voucher Acceptor */
0067     { USB_DEVICE(0x0BED, 0x1101) }, /* MEI series 2000 Combo Acceptor */
0068     { USB_DEVICE(0x0FCF, 0x1003) }, /* Dynastream ANT development board */
0069     { USB_DEVICE(0x0FCF, 0x1004) }, /* Dynastream ANT2USB */
0070     { USB_DEVICE(0x0FCF, 0x1006) }, /* Dynastream ANT development board */
0071     { USB_DEVICE(0x0FDE, 0xCA05) }, /* OWL Wireless Electricity Monitor CM-160 */
0072     { USB_DEVICE(0x106F, 0x0003) }, /* CPI / Money Controls Bulk Coin Recycler */
0073     { USB_DEVICE(0x10A6, 0xAA26) }, /* Knock-off DCU-11 cable */
0074     { USB_DEVICE(0x10AB, 0x10C5) }, /* Siemens MC60 Cable */
0075     { USB_DEVICE(0x10B5, 0xAC70) }, /* Nokia CA-42 USB */
0076     { USB_DEVICE(0x10C4, 0x0F91) }, /* Vstabi */
0077     { USB_DEVICE(0x10C4, 0x1101) }, /* Arkham Technology DS101 Bus Monitor */
0078     { USB_DEVICE(0x10C4, 0x1601) }, /* Arkham Technology DS101 Adapter */
0079     { USB_DEVICE(0x10C4, 0x800A) }, /* SPORTident BSM7-D-USB main station */
0080     { USB_DEVICE(0x10C4, 0x803B) }, /* Pololu USB-serial converter */
0081     { USB_DEVICE(0x10C4, 0x8044) }, /* Cygnal Debug Adapter */
0082     { USB_DEVICE(0x10C4, 0x804E) }, /* Software Bisque Paramount ME build-in converter */
0083     { USB_DEVICE(0x10C4, 0x8053) }, /* Enfora EDG1228 */
0084     { USB_DEVICE(0x10C4, 0x8054) }, /* Enfora GSM2228 */
0085     { USB_DEVICE(0x10C4, 0x8056) }, /* Lorenz Messtechnik devices */
0086     { USB_DEVICE(0x10C4, 0x8066) }, /* Argussoft In-System Programmer */
0087     { USB_DEVICE(0x10C4, 0x806F) }, /* IMS USB to RS422 Converter Cable */
0088     { USB_DEVICE(0x10C4, 0x807A) }, /* Crumb128 board */
0089     { USB_DEVICE(0x10C4, 0x80C4) }, /* Cygnal Integrated Products, Inc., Optris infrared thermometer */
0090     { USB_DEVICE(0x10C4, 0x80CA) }, /* Degree Controls Inc */
0091     { USB_DEVICE(0x10C4, 0x80DD) }, /* Tracient RFID */
0092     { USB_DEVICE(0x10C4, 0x80F6) }, /* Suunto sports instrument */
0093     { USB_DEVICE(0x10C4, 0x8115) }, /* Arygon NFC/Mifare Reader */
0094     { USB_DEVICE(0x10C4, 0x813D) }, /* Burnside Telecom Deskmobile */
0095     { USB_DEVICE(0x10C4, 0x813F) }, /* Tams Master Easy Control */
0096     { USB_DEVICE(0x10C4, 0x814A) }, /* West Mountain Radio RIGblaster P&P */
0097     { USB_DEVICE(0x10C4, 0x814B) }, /* West Mountain Radio RIGtalk */
0098     { USB_DEVICE(0x2405, 0x0003) }, /* West Mountain Radio RIGblaster Advantage */
0099     { USB_DEVICE(0x10C4, 0x8156) }, /* B&G H3000 link cable */
0100     { USB_DEVICE(0x10C4, 0x815E) }, /* Helicomm IP-Link 1220-DVM */
0101     { USB_DEVICE(0x10C4, 0x815F) }, /* Timewave HamLinkUSB */
0102     { USB_DEVICE(0x10C4, 0x817C) }, /* CESINEL MEDCAL N Power Quality Monitor */
0103     { USB_DEVICE(0x10C4, 0x817D) }, /* CESINEL MEDCAL NT Power Quality Monitor */
0104     { USB_DEVICE(0x10C4, 0x817E) }, /* CESINEL MEDCAL S Power Quality Monitor */
0105     { USB_DEVICE(0x10C4, 0x818B) }, /* AVIT Research USB to TTL */
0106     { USB_DEVICE(0x10C4, 0x819F) }, /* MJS USB Toslink Switcher */
0107     { USB_DEVICE(0x10C4, 0x81A6) }, /* ThinkOptics WavIt */
0108     { USB_DEVICE(0x10C4, 0x81A9) }, /* Multiplex RC Interface */
0109     { USB_DEVICE(0x10C4, 0x81AC) }, /* MSD Dash Hawk */
0110     { USB_DEVICE(0x10C4, 0x81AD) }, /* INSYS USB Modem */
0111     { USB_DEVICE(0x10C4, 0x81C8) }, /* Lipowsky Industrie Elektronik GmbH, Baby-JTAG */
0112     { USB_DEVICE(0x10C4, 0x81D7) }, /* IAI Corp. RCB-CV-USB USB to RS485 Adaptor */
0113     { USB_DEVICE(0x10C4, 0x81E2) }, /* Lipowsky Industrie Elektronik GmbH, Baby-LIN */
0114     { USB_DEVICE(0x10C4, 0x81E7) }, /* Aerocomm Radio */
0115     { USB_DEVICE(0x10C4, 0x81E8) }, /* Zephyr Bioharness */
0116     { USB_DEVICE(0x10C4, 0x81F2) }, /* C1007 HF band RFID controller */
0117     { USB_DEVICE(0x10C4, 0x8218) }, /* Lipowsky Industrie Elektronik GmbH, HARP-1 */
0118     { USB_DEVICE(0x10C4, 0x822B) }, /* Modem EDGE(GSM) Comander 2 */
0119     { USB_DEVICE(0x10C4, 0x826B) }, /* Cygnal Integrated Products, Inc., Fasttrax GPS demonstration module */
0120     { USB_DEVICE(0x10C4, 0x8281) }, /* Nanotec Plug & Drive */
0121     { USB_DEVICE(0x10C4, 0x8293) }, /* Telegesis ETRX2USB */
0122     { USB_DEVICE(0x10C4, 0x82EF) }, /* CESINEL FALCO 6105 AC Power Supply */
0123     { USB_DEVICE(0x10C4, 0x82F1) }, /* CESINEL MEDCAL EFD Earth Fault Detector */
0124     { USB_DEVICE(0x10C4, 0x82F2) }, /* CESINEL MEDCAL ST Network Analyzer */
0125     { USB_DEVICE(0x10C4, 0x82F4) }, /* Starizona MicroTouch */
0126     { USB_DEVICE(0x10C4, 0x82F9) }, /* Procyon AVS */
0127     { USB_DEVICE(0x10C4, 0x8341) }, /* Siemens MC35PU GPRS Modem */
0128     { USB_DEVICE(0x10C4, 0x8382) }, /* Cygnal Integrated Products, Inc. */
0129     { USB_DEVICE(0x10C4, 0x83A8) }, /* Amber Wireless AMB2560 */
0130     { USB_DEVICE(0x10C4, 0x83AA) }, /* Mark-10 Digital Force Gauge */
0131     { USB_DEVICE(0x10C4, 0x83D8) }, /* DekTec DTA Plus VHF/UHF Booster/Attenuator */
0132     { USB_DEVICE(0x10C4, 0x8411) }, /* Kyocera GPS Module */
0133     { USB_DEVICE(0x10C4, 0x8414) }, /* Decagon USB Cable Adapter */
0134     { USB_DEVICE(0x10C4, 0x8418) }, /* IRZ Automation Teleport SG-10 GSM/GPRS Modem */
0135     { USB_DEVICE(0x10C4, 0x846E) }, /* BEI USB Sensor Interface (VCP) */
0136     { USB_DEVICE(0x10C4, 0x8470) }, /* Juniper Networks BX Series System Console */
0137     { USB_DEVICE(0x10C4, 0x8477) }, /* Balluff RFID */
0138     { USB_DEVICE(0x10C4, 0x84B6) }, /* Starizona Hyperion */
0139     { USB_DEVICE(0x10C4, 0x851E) }, /* CESINEL MEDCAL PT Network Analyzer */
0140     { USB_DEVICE(0x10C4, 0x85A7) }, /* LifeScan OneTouch Verio IQ */
0141     { USB_DEVICE(0x10C4, 0x85B8) }, /* CESINEL ReCon T Energy Logger */
0142     { USB_DEVICE(0x10C4, 0x85EA) }, /* AC-Services IBUS-IF */
0143     { USB_DEVICE(0x10C4, 0x85EB) }, /* AC-Services CIS-IBUS */
0144     { USB_DEVICE(0x10C4, 0x85F8) }, /* Virtenio Preon32 */
0145     { USB_DEVICE(0x10C4, 0x8664) }, /* AC-Services CAN-IF */
0146     { USB_DEVICE(0x10C4, 0x8665) }, /* AC-Services OBD-IF */
0147     { USB_DEVICE(0x10C4, 0x8856) }, /* CEL EM357 ZigBee USB Stick - LR */
0148     { USB_DEVICE(0x10C4, 0x8857) }, /* CEL EM357 ZigBee USB Stick */
0149     { USB_DEVICE(0x10C4, 0x88A4) }, /* MMB Networks ZigBee USB Device */
0150     { USB_DEVICE(0x10C4, 0x88A5) }, /* Planet Innovation Ingeni ZigBee USB Device */
0151     { USB_DEVICE(0x10C4, 0x88D8) }, /* Acuity Brands nLight Air Adapter */
0152     { USB_DEVICE(0x10C4, 0x88FB) }, /* CESINEL MEDCAL STII Network Analyzer */
0153     { USB_DEVICE(0x10C4, 0x8938) }, /* CESINEL MEDCAL S II Network Analyzer */
0154     { USB_DEVICE(0x10C4, 0x8946) }, /* Ketra N1 Wireless Interface */
0155     { USB_DEVICE(0x10C4, 0x8962) }, /* Brim Brothers charging dock */
0156     { USB_DEVICE(0x10C4, 0x8977) }, /* CEL MeshWorks DevKit Device */
0157     { USB_DEVICE(0x10C4, 0x8998) }, /* KCF Technologies PRN */
0158     { USB_DEVICE(0x10C4, 0x89A4) }, /* CESINEL FTBC Flexible Thyristor Bridge Controller */
0159     { USB_DEVICE(0x10C4, 0x89FB) }, /* Qivicon ZigBee USB Radio Stick */
0160     { USB_DEVICE(0x10C4, 0x8A2A) }, /* HubZ dual ZigBee and Z-Wave dongle */
0161     { USB_DEVICE(0x10C4, 0x8A5B) }, /* CEL EM3588 ZigBee USB Stick */
0162     { USB_DEVICE(0x10C4, 0x8A5E) }, /* CEL EM3588 ZigBee USB Stick Long Range */
0163     { USB_DEVICE(0x10C4, 0x8B34) }, /* Qivicon ZigBee USB Radio Stick */
0164     { USB_DEVICE(0x10C4, 0xEA60) }, /* Silicon Labs factory default */
0165     { USB_DEVICE(0x10C4, 0xEA61) }, /* Silicon Labs factory default */
0166     { USB_DEVICE(0x10C4, 0xEA63) }, /* Silicon Labs Windows Update (CP2101-4/CP2102N) */
0167     { USB_DEVICE(0x10C4, 0xEA70) }, /* Silicon Labs factory default */
0168     { USB_DEVICE(0x10C4, 0xEA71) }, /* Infinity GPS-MIC-1 Radio Monophone */
0169     { USB_DEVICE(0x10C4, 0xEA7A) }, /* Silicon Labs Windows Update (CP2105) */
0170     { USB_DEVICE(0x10C4, 0xEA7B) }, /* Silicon Labs Windows Update (CP2108) */
0171     { USB_DEVICE(0x10C4, 0xF001) }, /* Elan Digital Systems USBscope50 */
0172     { USB_DEVICE(0x10C4, 0xF002) }, /* Elan Digital Systems USBwave12 */
0173     { USB_DEVICE(0x10C4, 0xF003) }, /* Elan Digital Systems USBpulse100 */
0174     { USB_DEVICE(0x10C4, 0xF004) }, /* Elan Digital Systems USBcount50 */
0175     { USB_DEVICE(0x10C5, 0xEA61) }, /* Silicon Labs MobiData GPRS USB Modem */
0176     { USB_DEVICE(0x10CE, 0xEA6A) }, /* Silicon Labs MobiData GPRS USB Modem 100EU */
0177     { USB_DEVICE(0x12B8, 0xEC60) }, /* Link G4 ECU */
0178     { USB_DEVICE(0x12B8, 0xEC62) }, /* Link G4+ ECU */
0179     { USB_DEVICE(0x13AD, 0x9999) }, /* Baltech card reader */
0180     { USB_DEVICE(0x1555, 0x0004) }, /* Owen AC4 USB-RS485 Converter */
0181     { USB_DEVICE(0x155A, 0x1006) }, /* ELDAT Easywave RX09 */
0182     { USB_DEVICE(0x166A, 0x0201) }, /* Clipsal 5500PACA C-Bus Pascal Automation Controller */
0183     { USB_DEVICE(0x166A, 0x0301) }, /* Clipsal 5800PC C-Bus Wireless PC Interface */
0184     { USB_DEVICE(0x166A, 0x0303) }, /* Clipsal 5500PCU C-Bus USB interface */
0185     { USB_DEVICE(0x166A, 0x0304) }, /* Clipsal 5000CT2 C-Bus Black and White Touchscreen */
0186     { USB_DEVICE(0x166A, 0x0305) }, /* Clipsal C-5000CT2 C-Bus Spectrum Colour Touchscreen */
0187     { USB_DEVICE(0x166A, 0x0401) }, /* Clipsal L51xx C-Bus Architectural Dimmer */
0188     { USB_DEVICE(0x166A, 0x0101) }, /* Clipsal 5560884 C-Bus Multi-room Audio Matrix Switcher */
0189     { USB_DEVICE(0x16C0, 0x09B0) }, /* Lunatico Seletek */
0190     { USB_DEVICE(0x16C0, 0x09B1) }, /* Lunatico Seletek */
0191     { USB_DEVICE(0x16D6, 0x0001) }, /* Jablotron serial interface */
0192     { USB_DEVICE(0x16DC, 0x0010) }, /* W-IE-NE-R Plein & Baus GmbH PL512 Power Supply */
0193     { USB_DEVICE(0x16DC, 0x0011) }, /* W-IE-NE-R Plein & Baus GmbH RCM Remote Control for MARATON Power Supply */
0194     { USB_DEVICE(0x16DC, 0x0012) }, /* W-IE-NE-R Plein & Baus GmbH MPOD Multi Channel Power Supply */
0195     { USB_DEVICE(0x16DC, 0x0015) }, /* W-IE-NE-R Plein & Baus GmbH CML Control, Monitoring and Data Logger */
0196     { USB_DEVICE(0x17A8, 0x0001) }, /* Kamstrup Optical Eye/3-wire */
0197     { USB_DEVICE(0x17A8, 0x0005) }, /* Kamstrup M-Bus Master MultiPort 250D */
0198     { USB_DEVICE(0x17A8, 0x0101) }, /* Kamstrup 868 MHz wM-Bus C-Mode Meter Reader (Int Ant) */
0199     { USB_DEVICE(0x17A8, 0x0102) }, /* Kamstrup 868 MHz wM-Bus C-Mode Meter Reader (Ext Ant) */
0200     { USB_DEVICE(0x17F4, 0xAAAA) }, /* Wavesense Jazz blood glucose meter */
0201     { USB_DEVICE(0x1843, 0x0200) }, /* Vaisala USB Instrument Cable */
0202     { USB_DEVICE(0x18EF, 0xE00F) }, /* ELV USB-I2C-Interface */
0203     { USB_DEVICE(0x18EF, 0xE025) }, /* ELV Marble Sound Board 1 */
0204     { USB_DEVICE(0x18EF, 0xE030) }, /* ELV ALC 8xxx Battery Charger */
0205     { USB_DEVICE(0x18EF, 0xE032) }, /* ELV TFD500 Data Logger */
0206     { USB_DEVICE(0x1901, 0x0190) }, /* GE B850 CP2105 Recorder interface */
0207     { USB_DEVICE(0x1901, 0x0193) }, /* GE B650 CP2104 PMC interface */
0208     { USB_DEVICE(0x1901, 0x0194) }, /* GE Healthcare Remote Alarm Box */
0209     { USB_DEVICE(0x1901, 0x0195) }, /* GE B850/B650/B450 CP2104 DP UART interface */
0210     { USB_DEVICE(0x1901, 0x0196) }, /* GE B850 CP2105 DP UART interface */
0211     { USB_DEVICE(0x1901, 0x0197) }, /* GE CS1000 M.2 Key E serial interface */
0212     { USB_DEVICE(0x1901, 0x0198) }, /* GE CS1000 Display serial interface */
0213     { USB_DEVICE(0x199B, 0xBA30) }, /* LORD WSDA-200-USB */
0214     { USB_DEVICE(0x19CF, 0x3000) }, /* Parrot NMEA GPS Flight Recorder */
0215     { USB_DEVICE(0x1ADB, 0x0001) }, /* Schweitzer Engineering C662 Cable */
0216     { USB_DEVICE(0x1B1C, 0x1C00) }, /* Corsair USB Dongle */
0217     { USB_DEVICE(0x1BA4, 0x0002) }, /* Silicon Labs 358x factory default */
0218     { USB_DEVICE(0x1BE3, 0x07A6) }, /* WAGO 750-923 USB Service Cable */
0219     { USB_DEVICE(0x1D6F, 0x0010) }, /* Seluxit ApS RF Dongle */
0220     { USB_DEVICE(0x1E29, 0x0102) }, /* Festo CPX-USB */
0221     { USB_DEVICE(0x1E29, 0x0501) }, /* Festo CMSP */
0222     { USB_DEVICE(0x1FB9, 0x0100) }, /* Lake Shore Model 121 Current Source */
0223     { USB_DEVICE(0x1FB9, 0x0200) }, /* Lake Shore Model 218A Temperature Monitor */
0224     { USB_DEVICE(0x1FB9, 0x0201) }, /* Lake Shore Model 219 Temperature Monitor */
0225     { USB_DEVICE(0x1FB9, 0x0202) }, /* Lake Shore Model 233 Temperature Transmitter */
0226     { USB_DEVICE(0x1FB9, 0x0203) }, /* Lake Shore Model 235 Temperature Transmitter */
0227     { USB_DEVICE(0x1FB9, 0x0300) }, /* Lake Shore Model 335 Temperature Controller */
0228     { USB_DEVICE(0x1FB9, 0x0301) }, /* Lake Shore Model 336 Temperature Controller */
0229     { USB_DEVICE(0x1FB9, 0x0302) }, /* Lake Shore Model 350 Temperature Controller */
0230     { USB_DEVICE(0x1FB9, 0x0303) }, /* Lake Shore Model 371 AC Bridge */
0231     { USB_DEVICE(0x1FB9, 0x0400) }, /* Lake Shore Model 411 Handheld Gaussmeter */
0232     { USB_DEVICE(0x1FB9, 0x0401) }, /* Lake Shore Model 425 Gaussmeter */
0233     { USB_DEVICE(0x1FB9, 0x0402) }, /* Lake Shore Model 455A Gaussmeter */
0234     { USB_DEVICE(0x1FB9, 0x0403) }, /* Lake Shore Model 475A Gaussmeter */
0235     { USB_DEVICE(0x1FB9, 0x0404) }, /* Lake Shore Model 465 Three Axis Gaussmeter */
0236     { USB_DEVICE(0x1FB9, 0x0600) }, /* Lake Shore Model 625A Superconducting MPS */
0237     { USB_DEVICE(0x1FB9, 0x0601) }, /* Lake Shore Model 642A Magnet Power Supply */
0238     { USB_DEVICE(0x1FB9, 0x0602) }, /* Lake Shore Model 648 Magnet Power Supply */
0239     { USB_DEVICE(0x1FB9, 0x0700) }, /* Lake Shore Model 737 VSM Controller */
0240     { USB_DEVICE(0x1FB9, 0x0701) }, /* Lake Shore Model 776 Hall Matrix */
0241     { USB_DEVICE(0x2184, 0x0030) }, /* GW Instek GDM-834x Digital Multimeter */
0242     { USB_DEVICE(0x2626, 0xEA60) }, /* Aruba Networks 7xxx USB Serial Console */
0243     { USB_DEVICE(0x3195, 0xF190) }, /* Link Instruments MSO-19 */
0244     { USB_DEVICE(0x3195, 0xF280) }, /* Link Instruments MSO-28 */
0245     { USB_DEVICE(0x3195, 0xF281) }, /* Link Instruments MSO-28 */
0246     { USB_DEVICE(0x3923, 0x7A0B) }, /* National Instruments USB Serial Console */
0247     { USB_DEVICE(0x413C, 0x9500) }, /* DW700 GPS USB interface */
0248     { } /* Terminating Entry */
0249 };
0250 
0251 MODULE_DEVICE_TABLE(usb, id_table);
0252 
0253 struct cp210x_serial_private {
0254 #ifdef CONFIG_GPIOLIB
0255     struct gpio_chip    gc;
0256     bool            gpio_registered;
0257     u16         gpio_pushpull;
0258     u16         gpio_altfunc;
0259     u16         gpio_input;
0260 #endif
0261     u8          partnum;
0262     u32         fw_version;
0263     speed_t         min_speed;
0264     speed_t         max_speed;
0265     bool            use_actual_rate;
0266     bool            no_flow_control;
0267     bool            no_event_mode;
0268 };
0269 
0270 enum cp210x_event_state {
0271     ES_DATA,
0272     ES_ESCAPE,
0273     ES_LSR,
0274     ES_LSR_DATA_0,
0275     ES_LSR_DATA_1,
0276     ES_MSR
0277 };
0278 
0279 struct cp210x_port_private {
0280     u8          bInterfaceNumber;
0281     bool            event_mode;
0282     enum cp210x_event_state event_state;
0283     u8          lsr;
0284 
0285     struct mutex        mutex;
0286     bool            crtscts;
0287     bool            dtr;
0288     bool            rts;
0289 };
0290 
0291 static struct usb_serial_driver cp210x_device = {
0292     .driver = {
0293         .owner =    THIS_MODULE,
0294         .name =     "cp210x",
0295     },
0296     .id_table       = id_table,
0297     .num_ports      = 1,
0298     .bulk_in_size       = 256,
0299     .bulk_out_size      = 256,
0300     .open           = cp210x_open,
0301     .close          = cp210x_close,
0302     .break_ctl      = cp210x_break_ctl,
0303     .set_termios        = cp210x_set_termios,
0304     .tx_empty       = cp210x_tx_empty,
0305     .throttle       = usb_serial_generic_throttle,
0306     .unthrottle     = usb_serial_generic_unthrottle,
0307     .tiocmget       = cp210x_tiocmget,
0308     .tiocmset       = cp210x_tiocmset,
0309     .get_icount     = usb_serial_generic_get_icount,
0310     .attach         = cp210x_attach,
0311     .disconnect     = cp210x_disconnect,
0312     .release        = cp210x_release,
0313     .port_probe     = cp210x_port_probe,
0314     .port_remove        = cp210x_port_remove,
0315     .dtr_rts        = cp210x_dtr_rts,
0316     .process_read_urb   = cp210x_process_read_urb,
0317 };
0318 
0319 static struct usb_serial_driver * const serial_drivers[] = {
0320     &cp210x_device, NULL
0321 };
0322 
0323 /* Config request types */
0324 #define REQTYPE_HOST_TO_INTERFACE   0x41
0325 #define REQTYPE_INTERFACE_TO_HOST   0xc1
0326 #define REQTYPE_HOST_TO_DEVICE  0x40
0327 #define REQTYPE_DEVICE_TO_HOST  0xc0
0328 
0329 /* Config request codes */
0330 #define CP210X_IFC_ENABLE   0x00
0331 #define CP210X_SET_BAUDDIV  0x01
0332 #define CP210X_GET_BAUDDIV  0x02
0333 #define CP210X_SET_LINE_CTL 0x03
0334 #define CP210X_GET_LINE_CTL 0x04
0335 #define CP210X_SET_BREAK    0x05
0336 #define CP210X_IMM_CHAR     0x06
0337 #define CP210X_SET_MHS      0x07
0338 #define CP210X_GET_MDMSTS   0x08
0339 #define CP210X_SET_XON      0x09
0340 #define CP210X_SET_XOFF     0x0A
0341 #define CP210X_SET_EVENTMASK    0x0B
0342 #define CP210X_GET_EVENTMASK    0x0C
0343 #define CP210X_SET_CHAR     0x0D
0344 #define CP210X_GET_CHARS    0x0E
0345 #define CP210X_GET_PROPS    0x0F
0346 #define CP210X_GET_COMM_STATUS  0x10
0347 #define CP210X_RESET        0x11
0348 #define CP210X_PURGE        0x12
0349 #define CP210X_SET_FLOW     0x13
0350 #define CP210X_GET_FLOW     0x14
0351 #define CP210X_EMBED_EVENTS 0x15
0352 #define CP210X_GET_EVENTSTATE   0x16
0353 #define CP210X_SET_CHARS    0x19
0354 #define CP210X_GET_BAUDRATE 0x1D
0355 #define CP210X_SET_BAUDRATE 0x1E
0356 #define CP210X_VENDOR_SPECIFIC  0xFF
0357 
0358 /* CP210X_IFC_ENABLE */
0359 #define UART_ENABLE     0x0001
0360 #define UART_DISABLE        0x0000
0361 
0362 /* CP210X_(SET|GET)_BAUDDIV */
0363 #define BAUD_RATE_GEN_FREQ  0x384000
0364 
0365 /* CP210X_(SET|GET)_LINE_CTL */
0366 #define BITS_DATA_MASK      0X0f00
0367 #define BITS_DATA_5     0X0500
0368 #define BITS_DATA_6     0X0600
0369 #define BITS_DATA_7     0X0700
0370 #define BITS_DATA_8     0X0800
0371 #define BITS_DATA_9     0X0900
0372 
0373 #define BITS_PARITY_MASK    0x00f0
0374 #define BITS_PARITY_NONE    0x0000
0375 #define BITS_PARITY_ODD     0x0010
0376 #define BITS_PARITY_EVEN    0x0020
0377 #define BITS_PARITY_MARK    0x0030
0378 #define BITS_PARITY_SPACE   0x0040
0379 
0380 #define BITS_STOP_MASK      0x000f
0381 #define BITS_STOP_1     0x0000
0382 #define BITS_STOP_1_5       0x0001
0383 #define BITS_STOP_2     0x0002
0384 
0385 /* CP210X_SET_BREAK */
0386 #define BREAK_ON        0x0001
0387 #define BREAK_OFF       0x0000
0388 
0389 /* CP210X_(SET_MHS|GET_MDMSTS) */
0390 #define CONTROL_DTR     0x0001
0391 #define CONTROL_RTS     0x0002
0392 #define CONTROL_CTS     0x0010
0393 #define CONTROL_DSR     0x0020
0394 #define CONTROL_RING        0x0040
0395 #define CONTROL_DCD     0x0080
0396 #define CONTROL_WRITE_DTR   0x0100
0397 #define CONTROL_WRITE_RTS   0x0200
0398 
0399 /* CP210X_(GET|SET)_CHARS */
0400 struct cp210x_special_chars {
0401     u8  bEofChar;
0402     u8  bErrorChar;
0403     u8  bBreakChar;
0404     u8  bEventChar;
0405     u8  bXonChar;
0406     u8  bXoffChar;
0407 };
0408 
0409 /* CP210X_VENDOR_SPECIFIC values */
0410 #define CP210X_GET_FW_VER   0x000E
0411 #define CP210X_READ_2NCONFIG    0x000E
0412 #define CP210X_GET_FW_VER_2N    0x0010
0413 #define CP210X_READ_LATCH   0x00C2
0414 #define CP210X_GET_PARTNUM  0x370B
0415 #define CP210X_GET_PORTCONFIG   0x370C
0416 #define CP210X_GET_DEVICEMODE   0x3711
0417 #define CP210X_WRITE_LATCH  0x37E1
0418 
0419 /* Part number definitions */
0420 #define CP210X_PARTNUM_CP2101   0x01
0421 #define CP210X_PARTNUM_CP2102   0x02
0422 #define CP210X_PARTNUM_CP2103   0x03
0423 #define CP210X_PARTNUM_CP2104   0x04
0424 #define CP210X_PARTNUM_CP2105   0x05
0425 #define CP210X_PARTNUM_CP2108   0x08
0426 #define CP210X_PARTNUM_CP2102N_QFN28    0x20
0427 #define CP210X_PARTNUM_CP2102N_QFN24    0x21
0428 #define CP210X_PARTNUM_CP2102N_QFN20    0x22
0429 #define CP210X_PARTNUM_UNKNOWN  0xFF
0430 
0431 /* CP210X_GET_COMM_STATUS returns these 0x13 bytes */
0432 struct cp210x_comm_status {
0433     __le32   ulErrors;
0434     __le32   ulHoldReasons;
0435     __le32   ulAmountInInQueue;
0436     __le32   ulAmountInOutQueue;
0437     u8       bEofReceived;
0438     u8       bWaitForImmediate;
0439     u8       bReserved;
0440 } __packed;
0441 
0442 /*
0443  * CP210X_PURGE - 16 bits passed in wValue of USB request.
0444  * SiLabs app note AN571 gives a strange description of the 4 bits:
0445  * bit 0 or bit 2 clears the transmit queue and 1 or 3 receive.
0446  * writing 1 to all, however, purges cp2108 well enough to avoid the hang.
0447  */
0448 #define PURGE_ALL       0x000f
0449 
0450 /* CP210X_EMBED_EVENTS */
0451 #define CP210X_ESCCHAR      0xec
0452 
0453 #define CP210X_LSR_OVERRUN  BIT(1)
0454 #define CP210X_LSR_PARITY   BIT(2)
0455 #define CP210X_LSR_FRAME    BIT(3)
0456 #define CP210X_LSR_BREAK    BIT(4)
0457 
0458 
0459 /* CP210X_GET_FLOW/CP210X_SET_FLOW read/write these 0x10 bytes */
0460 struct cp210x_flow_ctl {
0461     __le32  ulControlHandshake;
0462     __le32  ulFlowReplace;
0463     __le32  ulXonLimit;
0464     __le32  ulXoffLimit;
0465 };
0466 
0467 /* cp210x_flow_ctl::ulControlHandshake */
0468 #define CP210X_SERIAL_DTR_MASK      GENMASK(1, 0)
0469 #define CP210X_SERIAL_DTR_INACTIVE  (0 << 0)
0470 #define CP210X_SERIAL_DTR_ACTIVE    (1 << 0)
0471 #define CP210X_SERIAL_DTR_FLOW_CTL  (2 << 0)
0472 #define CP210X_SERIAL_CTS_HANDSHAKE BIT(3)
0473 #define CP210X_SERIAL_DSR_HANDSHAKE BIT(4)
0474 #define CP210X_SERIAL_DCD_HANDSHAKE BIT(5)
0475 #define CP210X_SERIAL_DSR_SENSITIVITY   BIT(6)
0476 
0477 /* cp210x_flow_ctl::ulFlowReplace */
0478 #define CP210X_SERIAL_AUTO_TRANSMIT BIT(0)
0479 #define CP210X_SERIAL_AUTO_RECEIVE  BIT(1)
0480 #define CP210X_SERIAL_ERROR_CHAR    BIT(2)
0481 #define CP210X_SERIAL_NULL_STRIPPING    BIT(3)
0482 #define CP210X_SERIAL_BREAK_CHAR    BIT(4)
0483 #define CP210X_SERIAL_RTS_MASK      GENMASK(7, 6)
0484 #define CP210X_SERIAL_RTS_INACTIVE  (0 << 6)
0485 #define CP210X_SERIAL_RTS_ACTIVE    (1 << 6)
0486 #define CP210X_SERIAL_RTS_FLOW_CTL  (2 << 6)
0487 #define CP210X_SERIAL_XOFF_CONTINUE BIT(31)
0488 
0489 /* CP210X_VENDOR_SPECIFIC, CP210X_GET_DEVICEMODE call reads these 0x2 bytes. */
0490 struct cp210x_pin_mode {
0491     u8  eci;
0492     u8  sci;
0493 };
0494 
0495 #define CP210X_PIN_MODE_MODEM       0
0496 #define CP210X_PIN_MODE_GPIO        BIT(0)
0497 
0498 /*
0499  * CP210X_VENDOR_SPECIFIC, CP210X_GET_PORTCONFIG call reads these 0xf bytes
0500  * on a CP2105 chip. Structure needs padding due to unused/unspecified bytes.
0501  */
0502 struct cp210x_dual_port_config {
0503     __le16  gpio_mode;
0504     u8  __pad0[2];
0505     __le16  reset_state;
0506     u8  __pad1[4];
0507     __le16  suspend_state;
0508     u8  sci_cfg;
0509     u8  eci_cfg;
0510     u8  device_cfg;
0511 } __packed;
0512 
0513 /*
0514  * CP210X_VENDOR_SPECIFIC, CP210X_GET_PORTCONFIG call reads these 0xd bytes
0515  * on a CP2104 chip. Structure needs padding due to unused/unspecified bytes.
0516  */
0517 struct cp210x_single_port_config {
0518     __le16  gpio_mode;
0519     u8  __pad0[2];
0520     __le16  reset_state;
0521     u8  __pad1[4];
0522     __le16  suspend_state;
0523     u8  device_cfg;
0524 } __packed;
0525 
0526 /* GPIO modes */
0527 #define CP210X_SCI_GPIO_MODE_OFFSET 9
0528 #define CP210X_SCI_GPIO_MODE_MASK   GENMASK(11, 9)
0529 
0530 #define CP210X_ECI_GPIO_MODE_OFFSET 2
0531 #define CP210X_ECI_GPIO_MODE_MASK   GENMASK(3, 2)
0532 
0533 #define CP210X_GPIO_MODE_OFFSET     8
0534 #define CP210X_GPIO_MODE_MASK       GENMASK(11, 8)
0535 
0536 /* CP2105 port configuration values */
0537 #define CP2105_GPIO0_TXLED_MODE     BIT(0)
0538 #define CP2105_GPIO1_RXLED_MODE     BIT(1)
0539 #define CP2105_GPIO1_RS485_MODE     BIT(2)
0540 
0541 /* CP2104 port configuration values */
0542 #define CP2104_GPIO0_TXLED_MODE     BIT(0)
0543 #define CP2104_GPIO1_RXLED_MODE     BIT(1)
0544 #define CP2104_GPIO2_RS485_MODE     BIT(2)
0545 
0546 struct cp210x_quad_port_state {
0547     __le16 gpio_mode_pb0;
0548     __le16 gpio_mode_pb1;
0549     __le16 gpio_mode_pb2;
0550     __le16 gpio_mode_pb3;
0551     __le16 gpio_mode_pb4;
0552 
0553     __le16 gpio_lowpower_pb0;
0554     __le16 gpio_lowpower_pb1;
0555     __le16 gpio_lowpower_pb2;
0556     __le16 gpio_lowpower_pb3;
0557     __le16 gpio_lowpower_pb4;
0558 
0559     __le16 gpio_latch_pb0;
0560     __le16 gpio_latch_pb1;
0561     __le16 gpio_latch_pb2;
0562     __le16 gpio_latch_pb3;
0563     __le16 gpio_latch_pb4;
0564 };
0565 
0566 /*
0567  * CP210X_VENDOR_SPECIFIC, CP210X_GET_PORTCONFIG call reads these 0x49 bytes
0568  * on a CP2108 chip.
0569  *
0570  * See https://www.silabs.com/documents/public/application-notes/an978-cp210x-usb-to-uart-api-specification.pdf
0571  */
0572 struct cp210x_quad_port_config {
0573     struct cp210x_quad_port_state reset_state;
0574     struct cp210x_quad_port_state suspend_state;
0575     u8 ipdelay_ifc[4];
0576     u8 enhancedfxn_ifc[4];
0577     u8 enhancedfxn_device;
0578     u8 extclkfreq[4];
0579 } __packed;
0580 
0581 #define CP2108_EF_IFC_GPIO_TXLED        0x01
0582 #define CP2108_EF_IFC_GPIO_RXLED        0x02
0583 #define CP2108_EF_IFC_GPIO_RS485        0x04
0584 #define CP2108_EF_IFC_GPIO_RS485_LOGIC      0x08
0585 #define CP2108_EF_IFC_GPIO_CLOCK        0x10
0586 #define CP2108_EF_IFC_DYNAMIC_SUSPEND       0x40
0587 
0588 /* CP2102N configuration array indices */
0589 #define CP210X_2NCONFIG_CONFIG_VERSION_IDX  2
0590 #define CP210X_2NCONFIG_GPIO_MODE_IDX       581
0591 #define CP210X_2NCONFIG_GPIO_RSTLATCH_IDX   587
0592 #define CP210X_2NCONFIG_GPIO_CONTROL_IDX    600
0593 
0594 /* CP2102N QFN20 port configuration values */
0595 #define CP2102N_QFN20_GPIO2_TXLED_MODE      BIT(2)
0596 #define CP2102N_QFN20_GPIO3_RXLED_MODE      BIT(3)
0597 #define CP2102N_QFN20_GPIO1_RS485_MODE      BIT(4)
0598 #define CP2102N_QFN20_GPIO0_CLK_MODE        BIT(6)
0599 
0600 /*
0601  * CP210X_VENDOR_SPECIFIC, CP210X_WRITE_LATCH call writes these 0x02 bytes
0602  * for CP2102N, CP2103, CP2104 and CP2105.
0603  */
0604 struct cp210x_gpio_write {
0605     u8  mask;
0606     u8  state;
0607 };
0608 
0609 /*
0610  * CP210X_VENDOR_SPECIFIC, CP210X_WRITE_LATCH call writes these 0x04 bytes
0611  * for CP2108.
0612  */
0613 struct cp210x_gpio_write16 {
0614     __le16  mask;
0615     __le16  state;
0616 };
0617 
0618 /*
0619  * Helper to get interface number when we only have struct usb_serial.
0620  */
0621 static u8 cp210x_interface_num(struct usb_serial *serial)
0622 {
0623     struct usb_host_interface *cur_altsetting;
0624 
0625     cur_altsetting = serial->interface->cur_altsetting;
0626 
0627     return cur_altsetting->desc.bInterfaceNumber;
0628 }
0629 
0630 /*
0631  * Reads a variable-sized block of CP210X_ registers, identified by req.
0632  * Returns data into buf in native USB byte order.
0633  */
0634 static int cp210x_read_reg_block(struct usb_serial_port *port, u8 req,
0635         void *buf, int bufsize)
0636 {
0637     struct usb_serial *serial = port->serial;
0638     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0639     int result;
0640 
0641 
0642     result = usb_control_msg_recv(serial->dev, 0, req,
0643             REQTYPE_INTERFACE_TO_HOST, 0,
0644             port_priv->bInterfaceNumber, buf, bufsize,
0645             USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
0646     if (result) {
0647         dev_err(&port->dev, "failed get req 0x%x size %d status: %d\n",
0648                 req, bufsize, result);
0649         return result;
0650     }
0651 
0652     return 0;
0653 }
0654 
0655 /*
0656  * Reads any 8-bit CP210X_ register identified by req.
0657  */
0658 static int cp210x_read_u8_reg(struct usb_serial_port *port, u8 req, u8 *val)
0659 {
0660     return cp210x_read_reg_block(port, req, val, sizeof(*val));
0661 }
0662 
0663 /*
0664  * Reads a variable-sized vendor block of CP210X_ registers, identified by val.
0665  * Returns data into buf in native USB byte order.
0666  */
0667 static int cp210x_read_vendor_block(struct usb_serial *serial, u8 type, u16 val,
0668                     void *buf, int bufsize)
0669 {
0670     int result;
0671 
0672     result = usb_control_msg_recv(serial->dev, 0, CP210X_VENDOR_SPECIFIC,
0673             type, val, cp210x_interface_num(serial), buf, bufsize,
0674             USB_CTRL_GET_TIMEOUT, GFP_KERNEL);
0675     if (result) {
0676         dev_err(&serial->interface->dev,
0677             "failed to get vendor val 0x%04x size %d: %d\n", val,
0678             bufsize, result);
0679         return result;
0680     }
0681 
0682     return 0;
0683 }
0684 
0685 /*
0686  * Writes any 16-bit CP210X_ register (req) whose value is passed
0687  * entirely in the wValue field of the USB request.
0688  */
0689 static int cp210x_write_u16_reg(struct usb_serial_port *port, u8 req, u16 val)
0690 {
0691     struct usb_serial *serial = port->serial;
0692     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0693     int result;
0694 
0695     result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
0696             req, REQTYPE_HOST_TO_INTERFACE, val,
0697             port_priv->bInterfaceNumber, NULL, 0,
0698             USB_CTRL_SET_TIMEOUT);
0699     if (result < 0) {
0700         dev_err(&port->dev, "failed set request 0x%x status: %d\n",
0701                 req, result);
0702     }
0703 
0704     return result;
0705 }
0706 
0707 /*
0708  * Writes a variable-sized block of CP210X_ registers, identified by req.
0709  * Data in buf must be in native USB byte order.
0710  */
0711 static int cp210x_write_reg_block(struct usb_serial_port *port, u8 req,
0712         void *buf, int bufsize)
0713 {
0714     struct usb_serial *serial = port->serial;
0715     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0716     int result;
0717 
0718     result = usb_control_msg_send(serial->dev, 0, req,
0719             REQTYPE_HOST_TO_INTERFACE, 0,
0720             port_priv->bInterfaceNumber, buf, bufsize,
0721             USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
0722     if (result) {
0723         dev_err(&port->dev, "failed set req 0x%x size %d status: %d\n",
0724                 req, bufsize, result);
0725         return result;
0726     }
0727 
0728     return 0;
0729 }
0730 
0731 /*
0732  * Writes any 32-bit CP210X_ register identified by req.
0733  */
0734 static int cp210x_write_u32_reg(struct usb_serial_port *port, u8 req, u32 val)
0735 {
0736     __le32 le32_val;
0737 
0738     le32_val = cpu_to_le32(val);
0739 
0740     return cp210x_write_reg_block(port, req, &le32_val, sizeof(le32_val));
0741 }
0742 
0743 #ifdef CONFIG_GPIOLIB
0744 /*
0745  * Writes a variable-sized vendor block of CP210X_ registers, identified by val.
0746  * Data in buf must be in native USB byte order.
0747  */
0748 static int cp210x_write_vendor_block(struct usb_serial *serial, u8 type,
0749                      u16 val, void *buf, int bufsize)
0750 {
0751     int result;
0752 
0753     result = usb_control_msg_send(serial->dev, 0, CP210X_VENDOR_SPECIFIC,
0754             type, val, cp210x_interface_num(serial), buf, bufsize,
0755             USB_CTRL_SET_TIMEOUT, GFP_KERNEL);
0756     if (result) {
0757         dev_err(&serial->interface->dev,
0758             "failed to set vendor val 0x%04x size %d: %d\n", val,
0759             bufsize, result);
0760         return result;
0761     }
0762 
0763     return 0;
0764 }
0765 #endif
0766 
0767 static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
0768 {
0769     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0770     int result;
0771 
0772     result = cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_ENABLE);
0773     if (result) {
0774         dev_err(&port->dev, "%s - Unable to enable UART\n", __func__);
0775         return result;
0776     }
0777 
0778     if (tty)
0779         cp210x_set_termios(tty, port, NULL);
0780 
0781     result = usb_serial_generic_open(tty, port);
0782     if (result)
0783         goto err_disable;
0784 
0785     return 0;
0786 
0787 err_disable:
0788     cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_DISABLE);
0789     port_priv->event_mode = false;
0790 
0791     return result;
0792 }
0793 
0794 static void cp210x_close(struct usb_serial_port *port)
0795 {
0796     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0797 
0798     usb_serial_generic_close(port);
0799 
0800     /* Clear both queues; cp2108 needs this to avoid an occasional hang */
0801     cp210x_write_u16_reg(port, CP210X_PURGE, PURGE_ALL);
0802 
0803     cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_DISABLE);
0804 
0805     /* Disabling the interface disables event-insertion mode. */
0806     port_priv->event_mode = false;
0807 }
0808 
0809 static void cp210x_process_lsr(struct usb_serial_port *port, unsigned char lsr, char *flag)
0810 {
0811     if (lsr & CP210X_LSR_BREAK) {
0812         port->icount.brk++;
0813         *flag = TTY_BREAK;
0814     } else if (lsr & CP210X_LSR_PARITY) {
0815         port->icount.parity++;
0816         *flag = TTY_PARITY;
0817     } else if (lsr & CP210X_LSR_FRAME) {
0818         port->icount.frame++;
0819         *flag = TTY_FRAME;
0820     }
0821 
0822     if (lsr & CP210X_LSR_OVERRUN) {
0823         port->icount.overrun++;
0824         tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
0825     }
0826 }
0827 
0828 static bool cp210x_process_char(struct usb_serial_port *port, unsigned char *ch, char *flag)
0829 {
0830     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0831 
0832     switch (port_priv->event_state) {
0833     case ES_DATA:
0834         if (*ch == CP210X_ESCCHAR) {
0835             port_priv->event_state = ES_ESCAPE;
0836             break;
0837         }
0838         return false;
0839     case ES_ESCAPE:
0840         switch (*ch) {
0841         case 0:
0842             dev_dbg(&port->dev, "%s - escape char\n", __func__);
0843             *ch = CP210X_ESCCHAR;
0844             port_priv->event_state = ES_DATA;
0845             return false;
0846         case 1:
0847             port_priv->event_state = ES_LSR_DATA_0;
0848             break;
0849         case 2:
0850             port_priv->event_state = ES_LSR;
0851             break;
0852         case 3:
0853             port_priv->event_state = ES_MSR;
0854             break;
0855         default:
0856             dev_err(&port->dev, "malformed event 0x%02x\n", *ch);
0857             port_priv->event_state = ES_DATA;
0858             break;
0859         }
0860         break;
0861     case ES_LSR_DATA_0:
0862         port_priv->lsr = *ch;
0863         port_priv->event_state = ES_LSR_DATA_1;
0864         break;
0865     case ES_LSR_DATA_1:
0866         dev_dbg(&port->dev, "%s - lsr = 0x%02x, data = 0x%02x\n",
0867                 __func__, port_priv->lsr, *ch);
0868         cp210x_process_lsr(port, port_priv->lsr, flag);
0869         port_priv->event_state = ES_DATA;
0870         return false;
0871     case ES_LSR:
0872         dev_dbg(&port->dev, "%s - lsr = 0x%02x\n", __func__, *ch);
0873         port_priv->lsr = *ch;
0874         cp210x_process_lsr(port, port_priv->lsr, flag);
0875         port_priv->event_state = ES_DATA;
0876         break;
0877     case ES_MSR:
0878         dev_dbg(&port->dev, "%s - msr = 0x%02x\n", __func__, *ch);
0879         /* unimplemented */
0880         port_priv->event_state = ES_DATA;
0881         break;
0882     }
0883 
0884     return true;
0885 }
0886 
0887 static void cp210x_process_read_urb(struct urb *urb)
0888 {
0889     struct usb_serial_port *port = urb->context;
0890     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0891     unsigned char *ch = urb->transfer_buffer;
0892     char flag;
0893     int i;
0894 
0895     if (!urb->actual_length)
0896         return;
0897 
0898     if (port_priv->event_mode) {
0899         for (i = 0; i < urb->actual_length; i++, ch++) {
0900             flag = TTY_NORMAL;
0901 
0902             if (cp210x_process_char(port, ch, &flag))
0903                 continue;
0904 
0905             tty_insert_flip_char(&port->port, *ch, flag);
0906         }
0907     } else {
0908         tty_insert_flip_string(&port->port, ch, urb->actual_length);
0909     }
0910     tty_flip_buffer_push(&port->port);
0911 }
0912 
0913 /*
0914  * Read how many bytes are waiting in the TX queue.
0915  */
0916 static int cp210x_get_tx_queue_byte_count(struct usb_serial_port *port,
0917         u32 *count)
0918 {
0919     struct usb_serial *serial = port->serial;
0920     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
0921     struct cp210x_comm_status sts;
0922     int result;
0923 
0924     result = usb_control_msg_recv(serial->dev, 0, CP210X_GET_COMM_STATUS,
0925             REQTYPE_INTERFACE_TO_HOST, 0,
0926             port_priv->bInterfaceNumber, &sts, sizeof(sts),
0927             USB_CTRL_GET_TIMEOUT, GFP_KERNEL);
0928     if (result) {
0929         dev_err(&port->dev, "failed to get comm status: %d\n", result);
0930         return result;
0931     }
0932 
0933     *count = le32_to_cpu(sts.ulAmountInOutQueue);
0934 
0935     return 0;
0936 }
0937 
0938 static bool cp210x_tx_empty(struct usb_serial_port *port)
0939 {
0940     int err;
0941     u32 count;
0942 
0943     err = cp210x_get_tx_queue_byte_count(port, &count);
0944     if (err)
0945         return true;
0946 
0947     return !count;
0948 }
0949 
0950 struct cp210x_rate {
0951     speed_t rate;
0952     speed_t high;
0953 };
0954 
0955 static const struct cp210x_rate cp210x_an205_table1[] = {
0956     { 300, 300 },
0957     { 600, 600 },
0958     { 1200, 1200 },
0959     { 1800, 1800 },
0960     { 2400, 2400 },
0961     { 4000, 4000 },
0962     { 4800, 4803 },
0963     { 7200, 7207 },
0964     { 9600, 9612 },
0965     { 14400, 14428 },
0966     { 16000, 16062 },
0967     { 19200, 19250 },
0968     { 28800, 28912 },
0969     { 38400, 38601 },
0970     { 51200, 51558 },
0971     { 56000, 56280 },
0972     { 57600, 58053 },
0973     { 64000, 64111 },
0974     { 76800, 77608 },
0975     { 115200, 117028 },
0976     { 128000, 129347 },
0977     { 153600, 156868 },
0978     { 230400, 237832 },
0979     { 250000, 254234 },
0980     { 256000, 273066 },
0981     { 460800, 491520 },
0982     { 500000, 567138 },
0983     { 576000, 670254 },
0984     { 921600, UINT_MAX }
0985 };
0986 
0987 /*
0988  * Quantises the baud rate as per AN205 Table 1
0989  */
0990 static speed_t cp210x_get_an205_rate(speed_t baud)
0991 {
0992     int i;
0993 
0994     for (i = 0; i < ARRAY_SIZE(cp210x_an205_table1); ++i) {
0995         if (baud <= cp210x_an205_table1[i].high)
0996             break;
0997     }
0998 
0999     return cp210x_an205_table1[i].rate;
1000 }
1001 
1002 static speed_t cp210x_get_actual_rate(speed_t baud)
1003 {
1004     unsigned int prescale = 1;
1005     unsigned int div;
1006 
1007     if (baud <= 365)
1008         prescale = 4;
1009 
1010     div = DIV_ROUND_CLOSEST(48000000, 2 * prescale * baud);
1011     baud = 48000000 / (2 * prescale * div);
1012 
1013     return baud;
1014 }
1015 
1016 /*
1017  * CP2101 supports the following baud rates:
1018  *
1019  *  300, 600, 1200, 1800, 2400, 4800, 7200, 9600, 14400, 19200, 28800,
1020  *  38400, 56000, 57600, 115200, 128000, 230400, 460800, 921600
1021  *
1022  * CP2102 and CP2103 support the following additional rates:
1023  *
1024  *  4000, 16000, 51200, 64000, 76800, 153600, 250000, 256000, 500000,
1025  *  576000
1026  *
1027  * The device will map a requested rate to a supported one, but the result
1028  * of requests for rates greater than 1053257 is undefined (see AN205).
1029  *
1030  * CP2104, CP2105 and CP2110 support most rates up to 2M, 921k and 1M baud,
1031  * respectively, with an error less than 1%. The actual rates are determined
1032  * by
1033  *
1034  *  div = round(freq / (2 x prescale x request))
1035  *  actual = freq / (2 x prescale x div)
1036  *
1037  * For CP2104 and CP2105 freq is 48Mhz and prescale is 4 for request <= 365bps
1038  * or 1 otherwise.
1039  * For CP2110 freq is 24Mhz and prescale is 4 for request <= 300bps or 1
1040  * otherwise.
1041  */
1042 static void cp210x_change_speed(struct tty_struct *tty,
1043         struct usb_serial_port *port, struct ktermios *old_termios)
1044 {
1045     struct usb_serial *serial = port->serial;
1046     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1047     u32 baud;
1048 
1049     /*
1050      * This maps the requested rate to the actual rate, a valid rate on
1051      * cp2102 or cp2103, or to an arbitrary rate in [1M, max_speed].
1052      *
1053      * NOTE: B0 is not implemented.
1054      */
1055     baud = clamp(tty->termios.c_ospeed, priv->min_speed, priv->max_speed);
1056 
1057     if (priv->use_actual_rate)
1058         baud = cp210x_get_actual_rate(baud);
1059     else if (baud < 1000000)
1060         baud = cp210x_get_an205_rate(baud);
1061 
1062     dev_dbg(&port->dev, "%s - setting baud rate to %u\n", __func__, baud);
1063     if (cp210x_write_u32_reg(port, CP210X_SET_BAUDRATE, baud)) {
1064         dev_warn(&port->dev, "failed to set baud rate to %u\n", baud);
1065         if (old_termios)
1066             baud = old_termios->c_ospeed;
1067         else
1068             baud = 9600;
1069     }
1070 
1071     tty_encode_baud_rate(tty, baud, baud);
1072 }
1073 
1074 static void cp210x_enable_event_mode(struct usb_serial_port *port)
1075 {
1076     struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1077     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1078     int ret;
1079 
1080     if (port_priv->event_mode)
1081         return;
1082 
1083     if (priv->no_event_mode)
1084         return;
1085 
1086     port_priv->event_state = ES_DATA;
1087     port_priv->event_mode = true;
1088 
1089     ret = cp210x_write_u16_reg(port, CP210X_EMBED_EVENTS, CP210X_ESCCHAR);
1090     if (ret) {
1091         dev_err(&port->dev, "failed to enable events: %d\n", ret);
1092         port_priv->event_mode = false;
1093     }
1094 }
1095 
1096 static void cp210x_disable_event_mode(struct usb_serial_port *port)
1097 {
1098     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1099     int ret;
1100 
1101     if (!port_priv->event_mode)
1102         return;
1103 
1104     ret = cp210x_write_u16_reg(port, CP210X_EMBED_EVENTS, 0);
1105     if (ret) {
1106         dev_err(&port->dev, "failed to disable events: %d\n", ret);
1107         return;
1108     }
1109 
1110     port_priv->event_mode = false;
1111 }
1112 
1113 static bool cp210x_termios_change(const struct ktermios *a, const struct ktermios *b)
1114 {
1115     bool iflag_change, cc_change;
1116 
1117     iflag_change = ((a->c_iflag ^ b->c_iflag) & (INPCK | IXON | IXOFF));
1118     cc_change = a->c_cc[VSTART] != b->c_cc[VSTART] ||
1119             a->c_cc[VSTOP] != b->c_cc[VSTOP];
1120 
1121     return tty_termios_hw_change(a, b) || iflag_change || cc_change;
1122 }
1123 
1124 static void cp210x_set_flow_control(struct tty_struct *tty,
1125         struct usb_serial_port *port, struct ktermios *old_termios)
1126 {
1127     struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1128     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1129     struct cp210x_special_chars chars;
1130     struct cp210x_flow_ctl flow_ctl;
1131     u32 flow_repl;
1132     u32 ctl_hs;
1133     bool crtscts;
1134     int ret;
1135 
1136     /*
1137      * Some CP2102N interpret ulXonLimit as ulFlowReplace (erratum
1138      * CP2102N_E104). Report back that flow control is not supported.
1139      */
1140     if (priv->no_flow_control) {
1141         tty->termios.c_cflag &= ~CRTSCTS;
1142         tty->termios.c_iflag &= ~(IXON | IXOFF);
1143     }
1144 
1145     if (old_termios &&
1146             C_CRTSCTS(tty) == (old_termios->c_cflag & CRTSCTS) &&
1147             I_IXON(tty) == (old_termios->c_iflag & IXON) &&
1148             I_IXOFF(tty) == (old_termios->c_iflag & IXOFF) &&
1149             START_CHAR(tty) == old_termios->c_cc[VSTART] &&
1150             STOP_CHAR(tty) == old_termios->c_cc[VSTOP]) {
1151         return;
1152     }
1153 
1154     if (I_IXON(tty) || I_IXOFF(tty)) {
1155         memset(&chars, 0, sizeof(chars));
1156 
1157         chars.bXonChar = START_CHAR(tty);
1158         chars.bXoffChar = STOP_CHAR(tty);
1159 
1160         ret = cp210x_write_reg_block(port, CP210X_SET_CHARS, &chars,
1161                 sizeof(chars));
1162         if (ret) {
1163             dev_err(&port->dev, "failed to set special chars: %d\n",
1164                     ret);
1165         }
1166     }
1167 
1168     mutex_lock(&port_priv->mutex);
1169 
1170     ret = cp210x_read_reg_block(port, CP210X_GET_FLOW, &flow_ctl,
1171             sizeof(flow_ctl));
1172     if (ret)
1173         goto out_unlock;
1174 
1175     ctl_hs = le32_to_cpu(flow_ctl.ulControlHandshake);
1176     flow_repl = le32_to_cpu(flow_ctl.ulFlowReplace);
1177 
1178     ctl_hs &= ~CP210X_SERIAL_DSR_HANDSHAKE;
1179     ctl_hs &= ~CP210X_SERIAL_DCD_HANDSHAKE;
1180     ctl_hs &= ~CP210X_SERIAL_DSR_SENSITIVITY;
1181     ctl_hs &= ~CP210X_SERIAL_DTR_MASK;
1182     if (port_priv->dtr)
1183         ctl_hs |= CP210X_SERIAL_DTR_ACTIVE;
1184     else
1185         ctl_hs |= CP210X_SERIAL_DTR_INACTIVE;
1186 
1187     flow_repl &= ~CP210X_SERIAL_RTS_MASK;
1188     if (C_CRTSCTS(tty)) {
1189         ctl_hs |= CP210X_SERIAL_CTS_HANDSHAKE;
1190         if (port_priv->rts)
1191             flow_repl |= CP210X_SERIAL_RTS_FLOW_CTL;
1192         else
1193             flow_repl |= CP210X_SERIAL_RTS_INACTIVE;
1194         crtscts = true;
1195     } else {
1196         ctl_hs &= ~CP210X_SERIAL_CTS_HANDSHAKE;
1197         if (port_priv->rts)
1198             flow_repl |= CP210X_SERIAL_RTS_ACTIVE;
1199         else
1200             flow_repl |= CP210X_SERIAL_RTS_INACTIVE;
1201         crtscts = false;
1202     }
1203 
1204     if (I_IXOFF(tty)) {
1205         flow_repl |= CP210X_SERIAL_AUTO_RECEIVE;
1206 
1207         flow_ctl.ulXonLimit = cpu_to_le32(128);
1208         flow_ctl.ulXoffLimit = cpu_to_le32(128);
1209     } else {
1210         flow_repl &= ~CP210X_SERIAL_AUTO_RECEIVE;
1211     }
1212 
1213     if (I_IXON(tty))
1214         flow_repl |= CP210X_SERIAL_AUTO_TRANSMIT;
1215     else
1216         flow_repl &= ~CP210X_SERIAL_AUTO_TRANSMIT;
1217 
1218     dev_dbg(&port->dev, "%s - ctrl = 0x%02x, flow = 0x%02x\n", __func__,
1219             ctl_hs, flow_repl);
1220 
1221     flow_ctl.ulControlHandshake = cpu_to_le32(ctl_hs);
1222     flow_ctl.ulFlowReplace = cpu_to_le32(flow_repl);
1223 
1224     ret = cp210x_write_reg_block(port, CP210X_SET_FLOW, &flow_ctl,
1225             sizeof(flow_ctl));
1226     if (ret)
1227         goto out_unlock;
1228 
1229     port_priv->crtscts = crtscts;
1230 out_unlock:
1231     mutex_unlock(&port_priv->mutex);
1232 }
1233 
1234 static void cp210x_set_termios(struct tty_struct *tty,
1235         struct usb_serial_port *port, struct ktermios *old_termios)
1236 {
1237     struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1238     u16 bits;
1239     int ret;
1240 
1241     if (old_termios && !cp210x_termios_change(&tty->termios, old_termios))
1242         return;
1243 
1244     if (!old_termios || tty->termios.c_ospeed != old_termios->c_ospeed)
1245         cp210x_change_speed(tty, port, old_termios);
1246 
1247     /* CP2101 only supports CS8, 1 stop bit and non-stick parity. */
1248     if (priv->partnum == CP210X_PARTNUM_CP2101) {
1249         tty->termios.c_cflag &= ~(CSIZE | CSTOPB | CMSPAR);
1250         tty->termios.c_cflag |= CS8;
1251     }
1252 
1253     bits = 0;
1254 
1255     switch (C_CSIZE(tty)) {
1256     case CS5:
1257         bits |= BITS_DATA_5;
1258         break;
1259     case CS6:
1260         bits |= BITS_DATA_6;
1261         break;
1262     case CS7:
1263         bits |= BITS_DATA_7;
1264         break;
1265     case CS8:
1266     default:
1267         bits |= BITS_DATA_8;
1268         break;
1269     }
1270 
1271     if (C_PARENB(tty)) {
1272         if (C_CMSPAR(tty)) {
1273             if (C_PARODD(tty))
1274                 bits |= BITS_PARITY_MARK;
1275             else
1276                 bits |= BITS_PARITY_SPACE;
1277         } else {
1278             if (C_PARODD(tty))
1279                 bits |= BITS_PARITY_ODD;
1280             else
1281                 bits |= BITS_PARITY_EVEN;
1282         }
1283     }
1284 
1285     if (C_CSTOPB(tty))
1286         bits |= BITS_STOP_2;
1287     else
1288         bits |= BITS_STOP_1;
1289 
1290     ret = cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
1291     if (ret)
1292         dev_err(&port->dev, "failed to set line control: %d\n", ret);
1293 
1294     cp210x_set_flow_control(tty, port, old_termios);
1295 
1296     /*
1297      * Enable event-insertion mode only if input parity checking is
1298      * enabled for now.
1299      */
1300     if (I_INPCK(tty))
1301         cp210x_enable_event_mode(port);
1302     else
1303         cp210x_disable_event_mode(port);
1304 }
1305 
1306 static int cp210x_tiocmset(struct tty_struct *tty,
1307         unsigned int set, unsigned int clear)
1308 {
1309     struct usb_serial_port *port = tty->driver_data;
1310     return cp210x_tiocmset_port(port, set, clear);
1311 }
1312 
1313 static int cp210x_tiocmset_port(struct usb_serial_port *port,
1314         unsigned int set, unsigned int clear)
1315 {
1316     struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1317     struct cp210x_flow_ctl flow_ctl;
1318     u32 ctl_hs, flow_repl;
1319     u16 control = 0;
1320     int ret;
1321 
1322     mutex_lock(&port_priv->mutex);
1323 
1324     if (set & TIOCM_RTS) {
1325         port_priv->rts = true;
1326         control |= CONTROL_RTS;
1327         control |= CONTROL_WRITE_RTS;
1328     }
1329     if (set & TIOCM_DTR) {
1330         port_priv->dtr = true;
1331         control |= CONTROL_DTR;
1332         control |= CONTROL_WRITE_DTR;
1333     }
1334     if (clear & TIOCM_RTS) {
1335         port_priv->rts = false;
1336         control &= ~CONTROL_RTS;
1337         control |= CONTROL_WRITE_RTS;
1338     }
1339     if (clear & TIOCM_DTR) {
1340         port_priv->dtr = false;
1341         control &= ~CONTROL_DTR;
1342         control |= CONTROL_WRITE_DTR;
1343     }
1344 
1345     /*
1346      * Use SET_FLOW to set DTR and enable/disable auto-RTS when hardware
1347      * flow control is enabled.
1348      */
1349     if (port_priv->crtscts && control & CONTROL_WRITE_RTS) {
1350         ret = cp210x_read_reg_block(port, CP210X_GET_FLOW, &flow_ctl,
1351                 sizeof(flow_ctl));
1352         if (ret)
1353             goto out_unlock;
1354 
1355         ctl_hs = le32_to_cpu(flow_ctl.ulControlHandshake);
1356         flow_repl = le32_to_cpu(flow_ctl.ulFlowReplace);
1357 
1358         ctl_hs &= ~CP210X_SERIAL_DTR_MASK;
1359         if (port_priv->dtr)
1360             ctl_hs |= CP210X_SERIAL_DTR_ACTIVE;
1361         else
1362             ctl_hs |= CP210X_SERIAL_DTR_INACTIVE;
1363 
1364         flow_repl &= ~CP210X_SERIAL_RTS_MASK;
1365         if (port_priv->rts)
1366             flow_repl |= CP210X_SERIAL_RTS_FLOW_CTL;
1367         else
1368             flow_repl |= CP210X_SERIAL_RTS_INACTIVE;
1369 
1370         flow_ctl.ulControlHandshake = cpu_to_le32(ctl_hs);
1371         flow_ctl.ulFlowReplace = cpu_to_le32(flow_repl);
1372 
1373         dev_dbg(&port->dev, "%s - ctrl = 0x%02x, flow = 0x%02x\n",
1374                 __func__, ctl_hs, flow_repl);
1375 
1376         ret = cp210x_write_reg_block(port, CP210X_SET_FLOW, &flow_ctl,
1377                 sizeof(flow_ctl));
1378     } else {
1379         dev_dbg(&port->dev, "%s - control = 0x%04x\n", __func__, control);
1380 
1381         ret = cp210x_write_u16_reg(port, CP210X_SET_MHS, control);
1382     }
1383 out_unlock:
1384     mutex_unlock(&port_priv->mutex);
1385 
1386     return ret;
1387 }
1388 
1389 static void cp210x_dtr_rts(struct usb_serial_port *port, int on)
1390 {
1391     if (on)
1392         cp210x_tiocmset_port(port, TIOCM_DTR | TIOCM_RTS, 0);
1393     else
1394         cp210x_tiocmset_port(port, 0, TIOCM_DTR | TIOCM_RTS);
1395 }
1396 
1397 static int cp210x_tiocmget(struct tty_struct *tty)
1398 {
1399     struct usb_serial_port *port = tty->driver_data;
1400     u8 control;
1401     int result;
1402 
1403     result = cp210x_read_u8_reg(port, CP210X_GET_MDMSTS, &control);
1404     if (result)
1405         return result;
1406 
1407     result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
1408         |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
1409         |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
1410         |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
1411         |((control & CONTROL_RING)? TIOCM_RI  : 0)
1412         |((control & CONTROL_DCD) ? TIOCM_CD  : 0);
1413 
1414     dev_dbg(&port->dev, "%s - control = 0x%02x\n", __func__, control);
1415 
1416     return result;
1417 }
1418 
1419 static void cp210x_break_ctl(struct tty_struct *tty, int break_state)
1420 {
1421     struct usb_serial_port *port = tty->driver_data;
1422     u16 state;
1423 
1424     if (break_state == 0)
1425         state = BREAK_OFF;
1426     else
1427         state = BREAK_ON;
1428     dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
1429         state == BREAK_OFF ? "off" : "on");
1430     cp210x_write_u16_reg(port, CP210X_SET_BREAK, state);
1431 }
1432 
1433 #ifdef CONFIG_GPIOLIB
1434 static int cp210x_gpio_get(struct gpio_chip *gc, unsigned int gpio)
1435 {
1436     struct usb_serial *serial = gpiochip_get_data(gc);
1437     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1438     u8 req_type;
1439     u16 mask;
1440     int result;
1441     int len;
1442 
1443     result = usb_autopm_get_interface(serial->interface);
1444     if (result)
1445         return result;
1446 
1447     switch (priv->partnum) {
1448     case CP210X_PARTNUM_CP2105:
1449         req_type = REQTYPE_INTERFACE_TO_HOST;
1450         len = 1;
1451         break;
1452     case CP210X_PARTNUM_CP2108:
1453         req_type = REQTYPE_INTERFACE_TO_HOST;
1454         len = 2;
1455         break;
1456     default:
1457         req_type = REQTYPE_DEVICE_TO_HOST;
1458         len = 1;
1459         break;
1460     }
1461 
1462     mask = 0;
1463     result = cp210x_read_vendor_block(serial, req_type, CP210X_READ_LATCH,
1464                       &mask, len);
1465 
1466     usb_autopm_put_interface(serial->interface);
1467 
1468     if (result < 0)
1469         return result;
1470 
1471     le16_to_cpus(&mask);
1472 
1473     return !!(mask & BIT(gpio));
1474 }
1475 
1476 static void cp210x_gpio_set(struct gpio_chip *gc, unsigned int gpio, int value)
1477 {
1478     struct usb_serial *serial = gpiochip_get_data(gc);
1479     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1480     struct cp210x_gpio_write16 buf16;
1481     struct cp210x_gpio_write buf;
1482     u16 mask, state;
1483     u16 wIndex;
1484     int result;
1485 
1486     if (value == 1)
1487         state = BIT(gpio);
1488     else
1489         state = 0;
1490 
1491     mask = BIT(gpio);
1492 
1493     result = usb_autopm_get_interface(serial->interface);
1494     if (result)
1495         goto out;
1496 
1497     switch (priv->partnum) {
1498     case CP210X_PARTNUM_CP2105:
1499         buf.mask = (u8)mask;
1500         buf.state = (u8)state;
1501         result = cp210x_write_vendor_block(serial,
1502                            REQTYPE_HOST_TO_INTERFACE,
1503                            CP210X_WRITE_LATCH, &buf,
1504                            sizeof(buf));
1505         break;
1506     case CP210X_PARTNUM_CP2108:
1507         buf16.mask = cpu_to_le16(mask);
1508         buf16.state = cpu_to_le16(state);
1509         result = cp210x_write_vendor_block(serial,
1510                            REQTYPE_HOST_TO_INTERFACE,
1511                            CP210X_WRITE_LATCH, &buf16,
1512                            sizeof(buf16));
1513         break;
1514     default:
1515         wIndex = state << 8 | mask;
1516         result = usb_control_msg(serial->dev,
1517                      usb_sndctrlpipe(serial->dev, 0),
1518                      CP210X_VENDOR_SPECIFIC,
1519                      REQTYPE_HOST_TO_DEVICE,
1520                      CP210X_WRITE_LATCH,
1521                      wIndex,
1522                      NULL, 0, USB_CTRL_SET_TIMEOUT);
1523         break;
1524     }
1525 
1526     usb_autopm_put_interface(serial->interface);
1527 out:
1528     if (result < 0) {
1529         dev_err(&serial->interface->dev, "failed to set GPIO value: %d\n",
1530                 result);
1531     }
1532 }
1533 
1534 static int cp210x_gpio_direction_get(struct gpio_chip *gc, unsigned int gpio)
1535 {
1536     struct usb_serial *serial = gpiochip_get_data(gc);
1537     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1538 
1539     return priv->gpio_input & BIT(gpio);
1540 }
1541 
1542 static int cp210x_gpio_direction_input(struct gpio_chip *gc, unsigned int gpio)
1543 {
1544     struct usb_serial *serial = gpiochip_get_data(gc);
1545     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1546 
1547     if (priv->partnum == CP210X_PARTNUM_CP2105) {
1548         /* hardware does not support an input mode */
1549         return -ENOTSUPP;
1550     }
1551 
1552     /* push-pull pins cannot be changed to be inputs */
1553     if (priv->gpio_pushpull & BIT(gpio))
1554         return -EINVAL;
1555 
1556     /* make sure to release pin if it is being driven low */
1557     cp210x_gpio_set(gc, gpio, 1);
1558 
1559     priv->gpio_input |= BIT(gpio);
1560 
1561     return 0;
1562 }
1563 
1564 static int cp210x_gpio_direction_output(struct gpio_chip *gc, unsigned int gpio,
1565                     int value)
1566 {
1567     struct usb_serial *serial = gpiochip_get_data(gc);
1568     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1569 
1570     priv->gpio_input &= ~BIT(gpio);
1571     cp210x_gpio_set(gc, gpio, value);
1572 
1573     return 0;
1574 }
1575 
1576 static int cp210x_gpio_set_config(struct gpio_chip *gc, unsigned int gpio,
1577                   unsigned long config)
1578 {
1579     struct usb_serial *serial = gpiochip_get_data(gc);
1580     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1581     enum pin_config_param param = pinconf_to_config_param(config);
1582 
1583     /* Succeed only if in correct mode (this can't be set at runtime) */
1584     if ((param == PIN_CONFIG_DRIVE_PUSH_PULL) &&
1585         (priv->gpio_pushpull & BIT(gpio)))
1586         return 0;
1587 
1588     if ((param == PIN_CONFIG_DRIVE_OPEN_DRAIN) &&
1589         !(priv->gpio_pushpull & BIT(gpio)))
1590         return 0;
1591 
1592     return -ENOTSUPP;
1593 }
1594 
1595 static int cp210x_gpio_init_valid_mask(struct gpio_chip *gc,
1596         unsigned long *valid_mask, unsigned int ngpios)
1597 {
1598     struct usb_serial *serial = gpiochip_get_data(gc);
1599     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1600     struct device *dev = &serial->interface->dev;
1601     unsigned long altfunc_mask = priv->gpio_altfunc;
1602 
1603     bitmap_complement(valid_mask, &altfunc_mask, ngpios);
1604 
1605     if (bitmap_empty(valid_mask, ngpios))
1606         dev_dbg(dev, "no pin configured for GPIO\n");
1607     else
1608         dev_dbg(dev, "GPIO.%*pbl configured for GPIO\n", ngpios,
1609                 valid_mask);
1610     return 0;
1611 }
1612 
1613 /*
1614  * This function is for configuring GPIO using shared pins, where other signals
1615  * are made unavailable by configuring the use of GPIO. This is believed to be
1616  * only applicable to the cp2105 at this point, the other devices supported by
1617  * this driver that provide GPIO do so in a way that does not impact other
1618  * signals and are thus expected to have very different initialisation.
1619  */
1620 static int cp2105_gpioconf_init(struct usb_serial *serial)
1621 {
1622     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1623     struct cp210x_pin_mode mode;
1624     struct cp210x_dual_port_config config;
1625     u8 intf_num = cp210x_interface_num(serial);
1626     u8 iface_config;
1627     int result;
1628 
1629     result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1630                       CP210X_GET_DEVICEMODE, &mode,
1631                       sizeof(mode));
1632     if (result < 0)
1633         return result;
1634 
1635     result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1636                       CP210X_GET_PORTCONFIG, &config,
1637                       sizeof(config));
1638     if (result < 0)
1639         return result;
1640 
1641     /*  2 banks of GPIO - One for the pins taken from each serial port */
1642     if (intf_num == 0) {
1643         priv->gc.ngpio = 2;
1644 
1645         if (mode.eci == CP210X_PIN_MODE_MODEM) {
1646             /* mark all GPIOs of this interface as reserved */
1647             priv->gpio_altfunc = 0xff;
1648             return 0;
1649         }
1650 
1651         iface_config = config.eci_cfg;
1652         priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1653                         CP210X_ECI_GPIO_MODE_MASK) >>
1654                         CP210X_ECI_GPIO_MODE_OFFSET);
1655     } else if (intf_num == 1) {
1656         priv->gc.ngpio = 3;
1657 
1658         if (mode.sci == CP210X_PIN_MODE_MODEM) {
1659             /* mark all GPIOs of this interface as reserved */
1660             priv->gpio_altfunc = 0xff;
1661             return 0;
1662         }
1663 
1664         iface_config = config.sci_cfg;
1665         priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1666                         CP210X_SCI_GPIO_MODE_MASK) >>
1667                         CP210X_SCI_GPIO_MODE_OFFSET);
1668     } else {
1669         return -ENODEV;
1670     }
1671 
1672     /* mark all pins which are not in GPIO mode */
1673     if (iface_config & CP2105_GPIO0_TXLED_MODE) /* GPIO 0 */
1674         priv->gpio_altfunc |= BIT(0);
1675     if (iface_config & (CP2105_GPIO1_RXLED_MODE |   /* GPIO 1 */
1676             CP2105_GPIO1_RS485_MODE))
1677         priv->gpio_altfunc |= BIT(1);
1678 
1679     /* driver implementation for CP2105 only supports outputs */
1680     priv->gpio_input = 0;
1681 
1682     return 0;
1683 }
1684 
1685 static int cp2104_gpioconf_init(struct usb_serial *serial)
1686 {
1687     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1688     struct cp210x_single_port_config config;
1689     u8 iface_config;
1690     u8 gpio_latch;
1691     int result;
1692     u8 i;
1693 
1694     result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1695                       CP210X_GET_PORTCONFIG, &config,
1696                       sizeof(config));
1697     if (result < 0)
1698         return result;
1699 
1700     priv->gc.ngpio = 4;
1701 
1702     iface_config = config.device_cfg;
1703     priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1704                     CP210X_GPIO_MODE_MASK) >>
1705                     CP210X_GPIO_MODE_OFFSET);
1706     gpio_latch = (u8)((le16_to_cpu(config.reset_state) &
1707                     CP210X_GPIO_MODE_MASK) >>
1708                     CP210X_GPIO_MODE_OFFSET);
1709 
1710     /* mark all pins which are not in GPIO mode */
1711     if (iface_config & CP2104_GPIO0_TXLED_MODE) /* GPIO 0 */
1712         priv->gpio_altfunc |= BIT(0);
1713     if (iface_config & CP2104_GPIO1_RXLED_MODE) /* GPIO 1 */
1714         priv->gpio_altfunc |= BIT(1);
1715     if (iface_config & CP2104_GPIO2_RS485_MODE) /* GPIO 2 */
1716         priv->gpio_altfunc |= BIT(2);
1717 
1718     /*
1719      * Like CP2102N, CP2104 has also no strict input and output pin
1720      * modes.
1721      * Do the same input mode emulation as CP2102N.
1722      */
1723     for (i = 0; i < priv->gc.ngpio; ++i) {
1724         /*
1725          * Set direction to "input" iff pin is open-drain and reset
1726          * value is 1.
1727          */
1728         if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1729             priv->gpio_input |= BIT(i);
1730     }
1731 
1732     return 0;
1733 }
1734 
1735 static int cp2108_gpio_init(struct usb_serial *serial)
1736 {
1737     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1738     struct cp210x_quad_port_config config;
1739     u16 gpio_latch;
1740     int result;
1741     u8 i;
1742 
1743     result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1744                       CP210X_GET_PORTCONFIG, &config,
1745                       sizeof(config));
1746     if (result < 0)
1747         return result;
1748 
1749     priv->gc.ngpio = 16;
1750     priv->gpio_pushpull = le16_to_cpu(config.reset_state.gpio_mode_pb1);
1751     gpio_latch = le16_to_cpu(config.reset_state.gpio_latch_pb1);
1752 
1753     /*
1754      * Mark all pins which are not in GPIO mode.
1755      *
1756      * Refer to table 9.1 "GPIO Mode alternate Functions" in the datasheet:
1757      * https://www.silabs.com/documents/public/data-sheets/cp2108-datasheet.pdf
1758      *
1759      * Alternate functions of GPIO0 to GPIO3 are determine by enhancedfxn_ifc[0]
1760      * and the similarly for the other pins; enhancedfxn_ifc[1]: GPIO4 to GPIO7,
1761      * enhancedfxn_ifc[2]: GPIO8 to GPIO11, enhancedfxn_ifc[3]: GPIO12 to GPIO15.
1762      */
1763     for (i = 0; i < 4; i++) {
1764         if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_TXLED)
1765             priv->gpio_altfunc |= BIT(i * 4);
1766         if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_RXLED)
1767             priv->gpio_altfunc |= BIT((i * 4) + 1);
1768         if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_RS485)
1769             priv->gpio_altfunc |= BIT((i * 4) + 2);
1770         if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_CLOCK)
1771             priv->gpio_altfunc |= BIT((i * 4) + 3);
1772     }
1773 
1774     /*
1775      * Like CP2102N, CP2108 has also no strict input and output pin
1776      * modes. Do the same input mode emulation as CP2102N.
1777      */
1778     for (i = 0; i < priv->gc.ngpio; ++i) {
1779         /*
1780          * Set direction to "input" iff pin is open-drain and reset
1781          * value is 1.
1782          */
1783         if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1784             priv->gpio_input |= BIT(i);
1785     }
1786 
1787     return 0;
1788 }
1789 
1790 static int cp2102n_gpioconf_init(struct usb_serial *serial)
1791 {
1792     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1793     const u16 config_size = 0x02a6;
1794     u8 gpio_rst_latch;
1795     u8 config_version;
1796     u8 gpio_pushpull;
1797     u8 *config_buf;
1798     u8 gpio_latch;
1799     u8 gpio_ctrl;
1800     int result;
1801     u8 i;
1802 
1803     /*
1804      * Retrieve device configuration from the device.
1805      * The array received contains all customization settings done at the
1806      * factory/manufacturer. Format of the array is documented at the
1807      * time of writing at:
1808      * https://www.silabs.com/community/interface/knowledge-base.entry.html/2017/03/31/cp2102n_setconfig-xsfa
1809      */
1810     config_buf = kmalloc(config_size, GFP_KERNEL);
1811     if (!config_buf)
1812         return -ENOMEM;
1813 
1814     result = cp210x_read_vendor_block(serial,
1815                       REQTYPE_DEVICE_TO_HOST,
1816                       CP210X_READ_2NCONFIG,
1817                       config_buf,
1818                       config_size);
1819     if (result < 0) {
1820         kfree(config_buf);
1821         return result;
1822     }
1823 
1824     config_version = config_buf[CP210X_2NCONFIG_CONFIG_VERSION_IDX];
1825     gpio_pushpull = config_buf[CP210X_2NCONFIG_GPIO_MODE_IDX];
1826     gpio_ctrl = config_buf[CP210X_2NCONFIG_GPIO_CONTROL_IDX];
1827     gpio_rst_latch = config_buf[CP210X_2NCONFIG_GPIO_RSTLATCH_IDX];
1828 
1829     kfree(config_buf);
1830 
1831     /* Make sure this is a config format we understand. */
1832     if (config_version != 0x01)
1833         return -ENOTSUPP;
1834 
1835     priv->gc.ngpio = 4;
1836 
1837     /*
1838      * Get default pin states after reset. Needed so we can determine
1839      * the direction of an open-drain pin.
1840      */
1841     gpio_latch = (gpio_rst_latch >> 3) & 0x0f;
1842 
1843     /* 0 indicates open-drain mode, 1 is push-pull */
1844     priv->gpio_pushpull = (gpio_pushpull >> 3) & 0x0f;
1845 
1846     /* 0 indicates GPIO mode, 1 is alternate function */
1847     if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN20) {
1848         /* QFN20 is special... */
1849         if (gpio_ctrl & CP2102N_QFN20_GPIO0_CLK_MODE)   /* GPIO 0 */
1850             priv->gpio_altfunc |= BIT(0);
1851         if (gpio_ctrl & CP2102N_QFN20_GPIO1_RS485_MODE) /* GPIO 1 */
1852             priv->gpio_altfunc |= BIT(1);
1853         if (gpio_ctrl & CP2102N_QFN20_GPIO2_TXLED_MODE) /* GPIO 2 */
1854             priv->gpio_altfunc |= BIT(2);
1855         if (gpio_ctrl & CP2102N_QFN20_GPIO3_RXLED_MODE) /* GPIO 3 */
1856             priv->gpio_altfunc |= BIT(3);
1857     } else {
1858         priv->gpio_altfunc = (gpio_ctrl >> 2) & 0x0f;
1859     }
1860 
1861     if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN28) {
1862         /*
1863          * For the QFN28 package, GPIO4-6 are controlled by
1864          * the low three bits of the mode/latch fields.
1865          * Contrary to the document linked above, the bits for
1866          * the SUSPEND pins are elsewhere.  No alternate
1867          * function is available for these pins.
1868          */
1869         priv->gc.ngpio = 7;
1870         gpio_latch |= (gpio_rst_latch & 7) << 4;
1871         priv->gpio_pushpull |= (gpio_pushpull & 7) << 4;
1872     }
1873 
1874     /*
1875      * The CP2102N does not strictly has input and output pin modes,
1876      * it only knows open-drain and push-pull modes which is set at
1877      * factory. An open-drain pin can function both as an
1878      * input or an output. We emulate input mode for open-drain pins
1879      * by making sure they are not driven low, and we do not allow
1880      * push-pull pins to be set as an input.
1881      */
1882     for (i = 0; i < priv->gc.ngpio; ++i) {
1883         /*
1884          * Set direction to "input" iff pin is open-drain and reset
1885          * value is 1.
1886          */
1887         if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1888             priv->gpio_input |= BIT(i);
1889     }
1890 
1891     return 0;
1892 }
1893 
1894 static int cp210x_gpio_init(struct usb_serial *serial)
1895 {
1896     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1897     int result;
1898 
1899     switch (priv->partnum) {
1900     case CP210X_PARTNUM_CP2104:
1901         result = cp2104_gpioconf_init(serial);
1902         break;
1903     case CP210X_PARTNUM_CP2105:
1904         result = cp2105_gpioconf_init(serial);
1905         break;
1906     case CP210X_PARTNUM_CP2108:
1907         /*
1908          * The GPIOs are not tied to any specific port so only register
1909          * once for interface 0.
1910          */
1911         if (cp210x_interface_num(serial) != 0)
1912             return 0;
1913         result = cp2108_gpio_init(serial);
1914         break;
1915     case CP210X_PARTNUM_CP2102N_QFN28:
1916     case CP210X_PARTNUM_CP2102N_QFN24:
1917     case CP210X_PARTNUM_CP2102N_QFN20:
1918         result = cp2102n_gpioconf_init(serial);
1919         break;
1920     default:
1921         return 0;
1922     }
1923 
1924     if (result < 0)
1925         return result;
1926 
1927     priv->gc.label = "cp210x";
1928     priv->gc.get_direction = cp210x_gpio_direction_get;
1929     priv->gc.direction_input = cp210x_gpio_direction_input;
1930     priv->gc.direction_output = cp210x_gpio_direction_output;
1931     priv->gc.get = cp210x_gpio_get;
1932     priv->gc.set = cp210x_gpio_set;
1933     priv->gc.set_config = cp210x_gpio_set_config;
1934     priv->gc.init_valid_mask = cp210x_gpio_init_valid_mask;
1935     priv->gc.owner = THIS_MODULE;
1936     priv->gc.parent = &serial->interface->dev;
1937     priv->gc.base = -1;
1938     priv->gc.can_sleep = true;
1939 
1940     result = gpiochip_add_data(&priv->gc, serial);
1941     if (!result)
1942         priv->gpio_registered = true;
1943 
1944     return result;
1945 }
1946 
1947 static void cp210x_gpio_remove(struct usb_serial *serial)
1948 {
1949     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1950 
1951     if (priv->gpio_registered) {
1952         gpiochip_remove(&priv->gc);
1953         priv->gpio_registered = false;
1954     }
1955 }
1956 
1957 #else
1958 
1959 static int cp210x_gpio_init(struct usb_serial *serial)
1960 {
1961     return 0;
1962 }
1963 
1964 static void cp210x_gpio_remove(struct usb_serial *serial)
1965 {
1966     /* Nothing to do */
1967 }
1968 
1969 #endif
1970 
1971 static int cp210x_port_probe(struct usb_serial_port *port)
1972 {
1973     struct usb_serial *serial = port->serial;
1974     struct cp210x_port_private *port_priv;
1975 
1976     port_priv = kzalloc(sizeof(*port_priv), GFP_KERNEL);
1977     if (!port_priv)
1978         return -ENOMEM;
1979 
1980     port_priv->bInterfaceNumber = cp210x_interface_num(serial);
1981     mutex_init(&port_priv->mutex);
1982 
1983     usb_set_serial_port_data(port, port_priv);
1984 
1985     return 0;
1986 }
1987 
1988 static void cp210x_port_remove(struct usb_serial_port *port)
1989 {
1990     struct cp210x_port_private *port_priv;
1991 
1992     port_priv = usb_get_serial_port_data(port);
1993     kfree(port_priv);
1994 }
1995 
1996 static void cp210x_init_max_speed(struct usb_serial *serial)
1997 {
1998     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1999     bool use_actual_rate = false;
2000     speed_t min = 300;
2001     speed_t max;
2002 
2003     switch (priv->partnum) {
2004     case CP210X_PARTNUM_CP2101:
2005         max = 921600;
2006         break;
2007     case CP210X_PARTNUM_CP2102:
2008     case CP210X_PARTNUM_CP2103:
2009         max = 1000000;
2010         break;
2011     case CP210X_PARTNUM_CP2104:
2012         use_actual_rate = true;
2013         max = 2000000;
2014         break;
2015     case CP210X_PARTNUM_CP2108:
2016         max = 2000000;
2017         break;
2018     case CP210X_PARTNUM_CP2105:
2019         if (cp210x_interface_num(serial) == 0) {
2020             use_actual_rate = true;
2021             max = 2000000;  /* ECI */
2022         } else {
2023             min = 2400;
2024             max = 921600;   /* SCI */
2025         }
2026         break;
2027     case CP210X_PARTNUM_CP2102N_QFN28:
2028     case CP210X_PARTNUM_CP2102N_QFN24:
2029     case CP210X_PARTNUM_CP2102N_QFN20:
2030         use_actual_rate = true;
2031         max = 3000000;
2032         break;
2033     default:
2034         max = 2000000;
2035         break;
2036     }
2037 
2038     priv->min_speed = min;
2039     priv->max_speed = max;
2040     priv->use_actual_rate = use_actual_rate;
2041 }
2042 
2043 static void cp2102_determine_quirks(struct usb_serial *serial)
2044 {
2045     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2046     u8 *buf;
2047     int ret;
2048 
2049     buf = kmalloc(2, GFP_KERNEL);
2050     if (!buf)
2051         return;
2052     /*
2053      * Some (possibly counterfeit) CP2102 do not support event-insertion
2054      * mode and respond differently to malformed vendor requests.
2055      * Specifically, they return one instead of two bytes when sent a
2056      * two-byte part-number request.
2057      */
2058     ret = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2059             CP210X_VENDOR_SPECIFIC, REQTYPE_DEVICE_TO_HOST,
2060             CP210X_GET_PARTNUM, 0, buf, 2, USB_CTRL_GET_TIMEOUT);
2061     if (ret == 1) {
2062         dev_dbg(&serial->interface->dev,
2063                 "device does not support event-insertion mode\n");
2064         priv->no_event_mode = true;
2065     }
2066 
2067     kfree(buf);
2068 }
2069 
2070 static int cp210x_get_fw_version(struct usb_serial *serial, u16 value)
2071 {
2072     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2073     u8 ver[3];
2074     int ret;
2075 
2076     ret = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST, value,
2077             ver, sizeof(ver));
2078     if (ret)
2079         return ret;
2080 
2081     dev_dbg(&serial->interface->dev, "%s - %d.%d.%d\n", __func__,
2082             ver[0], ver[1], ver[2]);
2083 
2084     priv->fw_version = ver[0] << 16 | ver[1] << 8 | ver[2];
2085 
2086     return 0;
2087 }
2088 
2089 static void cp210x_determine_type(struct usb_serial *serial)
2090 {
2091     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2092     int ret;
2093 
2094     ret = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
2095             CP210X_GET_PARTNUM, &priv->partnum,
2096             sizeof(priv->partnum));
2097     if (ret < 0) {
2098         dev_warn(&serial->interface->dev,
2099                 "querying part number failed\n");
2100         priv->partnum = CP210X_PARTNUM_UNKNOWN;
2101         return;
2102     }
2103 
2104     dev_dbg(&serial->interface->dev, "partnum = 0x%02x\n", priv->partnum);
2105 
2106     switch (priv->partnum) {
2107     case CP210X_PARTNUM_CP2102:
2108         cp2102_determine_quirks(serial);
2109         break;
2110     case CP210X_PARTNUM_CP2105:
2111     case CP210X_PARTNUM_CP2108:
2112         cp210x_get_fw_version(serial, CP210X_GET_FW_VER);
2113         break;
2114     case CP210X_PARTNUM_CP2102N_QFN28:
2115     case CP210X_PARTNUM_CP2102N_QFN24:
2116     case CP210X_PARTNUM_CP2102N_QFN20:
2117         ret = cp210x_get_fw_version(serial, CP210X_GET_FW_VER_2N);
2118         if (ret)
2119             break;
2120         if (priv->fw_version <= 0x10004)
2121             priv->no_flow_control = true;
2122         break;
2123     default:
2124         break;
2125     }
2126 }
2127 
2128 static int cp210x_attach(struct usb_serial *serial)
2129 {
2130     int result;
2131     struct cp210x_serial_private *priv;
2132 
2133     priv = kzalloc(sizeof(*priv), GFP_KERNEL);
2134     if (!priv)
2135         return -ENOMEM;
2136 
2137     usb_set_serial_data(serial, priv);
2138 
2139     cp210x_determine_type(serial);
2140     cp210x_init_max_speed(serial);
2141 
2142     result = cp210x_gpio_init(serial);
2143     if (result < 0) {
2144         dev_err(&serial->interface->dev, "GPIO initialisation failed: %d\n",
2145                 result);
2146     }
2147 
2148     return 0;
2149 }
2150 
2151 static void cp210x_disconnect(struct usb_serial *serial)
2152 {
2153     cp210x_gpio_remove(serial);
2154 }
2155 
2156 static void cp210x_release(struct usb_serial *serial)
2157 {
2158     struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2159 
2160     cp210x_gpio_remove(serial);
2161 
2162     kfree(priv);
2163 }
2164 
2165 module_usb_serial_driver(serial_drivers, id_table);
2166 
2167 MODULE_DESCRIPTION(DRIVER_DESC);
2168 MODULE_LICENSE("GPL v2");
[ Source navigation ] [ Diff markup ] [ Identifier search ] [ general search ]

This page was automatically generated by the 2.1.0 LXR engine.

The LXR team
Valid CSS 2.1! Valid HTML 4.01!