1
2
3
4
5
6
7
8
9
10
11
12
13
14#include <linux/kernel.h>
15#include <linux/errno.h>
16#include <linux/slab.h>
17#include <linux/tty.h>
18#include <linux/tty_flip.h>
19#include <linux/module.h>
20#include <linux/usb.h>
21#include <linux/usb/serial.h>
22#include <linux/gpio/driver.h>
23#include <linux/bitops.h>
24#include <linux/mutex.h>
25
26#define DRIVER_DESC "Silicon Labs CP210x RS232 serial adaptor driver"
27
28
29
30
31static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
32static void cp210x_close(struct usb_serial_port *);
33static void cp210x_change_speed(struct tty_struct *, struct usb_serial_port *,
34 struct ktermios *);
35static void cp210x_set_termios(struct tty_struct *, struct usb_serial_port *,
36 struct ktermios*);
37static bool cp210x_tx_empty(struct usb_serial_port *port);
38static int cp210x_tiocmget(struct tty_struct *);
39static int cp210x_tiocmset(struct tty_struct *, unsigned int, unsigned int);
40static int cp210x_tiocmset_port(struct usb_serial_port *port,
41 unsigned int, unsigned int);
42static void cp210x_break_ctl(struct tty_struct *, int);
43static int cp210x_attach(struct usb_serial *);
44static void cp210x_disconnect(struct usb_serial *);
45static void cp210x_release(struct usb_serial *);
46static int cp210x_port_probe(struct usb_serial_port *);
47static void cp210x_port_remove(struct usb_serial_port *);
48static void cp210x_dtr_rts(struct usb_serial_port *port, int on);
49static void cp210x_process_read_urb(struct urb *urb);
50static void cp210x_enable_event_mode(struct usb_serial_port *port);
51static void cp210x_disable_event_mode(struct usb_serial_port *port);
52
53static const struct usb_device_id id_table[] = {
54 { USB_DEVICE(0x045B, 0x0053) },
55 { USB_DEVICE(0x0471, 0x066A) },
56 { USB_DEVICE(0x0489, 0xE000) },
57 { USB_DEVICE(0x0489, 0xE003) },
58 { USB_DEVICE(0x0745, 0x1000) },
59 { USB_DEVICE(0x0846, 0x1100) },
60 { USB_DEVICE(0x08e6, 0x5501) },
61 { USB_DEVICE(0x08FD, 0x000A) },
62 { USB_DEVICE(0x0908, 0x01FF) },
63 { USB_DEVICE(0x0988, 0x0578) },
64 { USB_DEVICE(0x0B00, 0x3070) },
65 { USB_DEVICE(0x0BED, 0x1100) },
66 { USB_DEVICE(0x0BED, 0x1101) },
67 { USB_DEVICE(0x0FCF, 0x1003) },
68 { USB_DEVICE(0x0FCF, 0x1004) },
69 { USB_DEVICE(0x0FCF, 0x1006) },
70 { USB_DEVICE(0x0FDE, 0xCA05) },
71 { USB_DEVICE(0x10A6, 0xAA26) },
72 { USB_DEVICE(0x10AB, 0x10C5) },
73 { USB_DEVICE(0x10B5, 0xAC70) },
74 { USB_DEVICE(0x10C4, 0x0F91) },
75 { USB_DEVICE(0x10C4, 0x1101) },
76 { USB_DEVICE(0x10C4, 0x1601) },
77 { USB_DEVICE(0x10C4, 0x800A) },
78 { USB_DEVICE(0x10C4, 0x803B) },
79 { USB_DEVICE(0x10C4, 0x8044) },
80 { USB_DEVICE(0x10C4, 0x804E) },
81 { USB_DEVICE(0x10C4, 0x8053) },
82 { USB_DEVICE(0x10C4, 0x8054) },
83 { USB_DEVICE(0x10C4, 0x8056) },
84 { USB_DEVICE(0x10C4, 0x8066) },
85 { USB_DEVICE(0x10C4, 0x806F) },
86 { USB_DEVICE(0x10C4, 0x807A) },
87 { USB_DEVICE(0x10C4, 0x80C4) },
88 { USB_DEVICE(0x10C4, 0x80CA) },
89 { USB_DEVICE(0x10C4, 0x80DD) },
90 { USB_DEVICE(0x10C4, 0x80F6) },
91 { USB_DEVICE(0x10C4, 0x8115) },
92 { USB_DEVICE(0x10C4, 0x813D) },
93 { USB_DEVICE(0x10C4, 0x813F) },
94 { USB_DEVICE(0x10C4, 0x814A) },
95 { USB_DEVICE(0x10C4, 0x814B) },
96 { USB_DEVICE(0x2405, 0x0003) },
97 { USB_DEVICE(0x10C4, 0x8156) },
98 { USB_DEVICE(0x10C4, 0x815E) },
99 { USB_DEVICE(0x10C4, 0x815F) },
100 { USB_DEVICE(0x10C4, 0x817C) },
101 { USB_DEVICE(0x10C4, 0x817D) },
102 { USB_DEVICE(0x10C4, 0x817E) },
103 { USB_DEVICE(0x10C4, 0x818B) },
104 { USB_DEVICE(0x10C4, 0x819F) },
105 { USB_DEVICE(0x10C4, 0x81A6) },
106 { USB_DEVICE(0x10C4, 0x81A9) },
107 { USB_DEVICE(0x10C4, 0x81AC) },
108 { USB_DEVICE(0x10C4, 0x81AD) },
109 { USB_DEVICE(0x10C4, 0x81C8) },
110 { USB_DEVICE(0x10C4, 0x81D7) },
111 { USB_DEVICE(0x10C4, 0x81E2) },
112 { USB_DEVICE(0x10C4, 0x81E7) },
113 { USB_DEVICE(0x10C4, 0x81E8) },
114 { USB_DEVICE(0x10C4, 0x81F2) },
115 { USB_DEVICE(0x10C4, 0x8218) },
116 { USB_DEVICE(0x10C4, 0x822B) },
117 { USB_DEVICE(0x10C4, 0x826B) },
118 { USB_DEVICE(0x10C4, 0x8281) },
119 { USB_DEVICE(0x10C4, 0x8293) },
120 { USB_DEVICE(0x10C4, 0x82EF) },
121 { USB_DEVICE(0x10C4, 0x82F1) },
122 { USB_DEVICE(0x10C4, 0x82F2) },
123 { USB_DEVICE(0x10C4, 0x82F4) },
124 { USB_DEVICE(0x10C4, 0x82F9) },
125 { USB_DEVICE(0x10C4, 0x8341) },
126 { USB_DEVICE(0x10C4, 0x8382) },
127 { USB_DEVICE(0x10C4, 0x83A8) },
128 { USB_DEVICE(0x10C4, 0x83AA) },
129 { USB_DEVICE(0x10C4, 0x83D8) },
130 { USB_DEVICE(0x10C4, 0x8411) },
131 { USB_DEVICE(0x10C4, 0x8418) },
132 { USB_DEVICE(0x10C4, 0x846E) },
133 { USB_DEVICE(0x10C4, 0x8470) },
134 { USB_DEVICE(0x10C4, 0x8477) },
135 { USB_DEVICE(0x10C4, 0x84B6) },
136 { USB_DEVICE(0x10C4, 0x851E) },
137 { USB_DEVICE(0x10C4, 0x85A7) },
138 { USB_DEVICE(0x10C4, 0x85B8) },
139 { USB_DEVICE(0x10C4, 0x85EA) },
140 { USB_DEVICE(0x10C4, 0x85EB) },
141 { USB_DEVICE(0x10C4, 0x85F8) },
142 { USB_DEVICE(0x10C4, 0x8664) },
143 { USB_DEVICE(0x10C4, 0x8665) },
144 { USB_DEVICE(0x10C4, 0x8856) },
145 { USB_DEVICE(0x10C4, 0x8857) },
146 { USB_DEVICE(0x10C4, 0x88A4) },
147 { USB_DEVICE(0x10C4, 0x88A5) },
148 { USB_DEVICE(0x10C4, 0x88D8) },
149 { USB_DEVICE(0x10C4, 0x88FB) },
150 { USB_DEVICE(0x10C4, 0x8938) },
151 { USB_DEVICE(0x10C4, 0x8946) },
152 { USB_DEVICE(0x10C4, 0x8962) },
153 { USB_DEVICE(0x10C4, 0x8977) },
154 { USB_DEVICE(0x10C4, 0x8998) },
155 { USB_DEVICE(0x10C4, 0x89A4) },
156 { USB_DEVICE(0x10C4, 0x89FB) },
157 { USB_DEVICE(0x10C4, 0x8A2A) },
158 { USB_DEVICE(0x10C4, 0x8A5B) },
159 { USB_DEVICE(0x10C4, 0x8A5E) },
160 { USB_DEVICE(0x10C4, 0x8B34) },
161 { USB_DEVICE(0x10C4, 0xEA60) },
162 { USB_DEVICE(0x10C4, 0xEA61) },
163 { USB_DEVICE(0x10C4, 0xEA63) },
164 { USB_DEVICE(0x10C4, 0xEA70) },
165 { USB_DEVICE(0x10C4, 0xEA71) },
166 { USB_DEVICE(0x10C4, 0xEA7A) },
167 { USB_DEVICE(0x10C4, 0xEA7B) },
168 { USB_DEVICE(0x10C4, 0xF001) },
169 { USB_DEVICE(0x10C4, 0xF002) },
170 { USB_DEVICE(0x10C4, 0xF003) },
171 { USB_DEVICE(0x10C4, 0xF004) },
172 { USB_DEVICE(0x10C5, 0xEA61) },
173 { USB_DEVICE(0x10CE, 0xEA6A) },
174 { USB_DEVICE(0x12B8, 0xEC60) },
175 { USB_DEVICE(0x12B8, 0xEC62) },
176 { USB_DEVICE(0x13AD, 0x9999) },
177 { USB_DEVICE(0x1555, 0x0004) },
178 { USB_DEVICE(0x155A, 0x1006) },
179 { USB_DEVICE(0x166A, 0x0201) },
180 { USB_DEVICE(0x166A, 0x0301) },
181 { USB_DEVICE(0x166A, 0x0303) },
182 { USB_DEVICE(0x166A, 0x0304) },
183 { USB_DEVICE(0x166A, 0x0305) },
184 { USB_DEVICE(0x166A, 0x0401) },
185 { USB_DEVICE(0x166A, 0x0101) },
186 { USB_DEVICE(0x16C0, 0x09B0) },
187 { USB_DEVICE(0x16C0, 0x09B1) },
188 { USB_DEVICE(0x16D6, 0x0001) },
189 { USB_DEVICE(0x16DC, 0x0010) },
190 { USB_DEVICE(0x16DC, 0x0011) },
191 { USB_DEVICE(0x16DC, 0x0012) },
192 { USB_DEVICE(0x16DC, 0x0015) },
193 { USB_DEVICE(0x17A8, 0x0001) },
194 { USB_DEVICE(0x17A8, 0x0005) },
195 { USB_DEVICE(0x17F4, 0xAAAA) },
196 { USB_DEVICE(0x1843, 0x0200) },
197 { USB_DEVICE(0x18EF, 0xE00F) },
198 { USB_DEVICE(0x18EF, 0xE025) },
199 { USB_DEVICE(0x18EF, 0xE030) },
200 { USB_DEVICE(0x18EF, 0xE032) },
201 { USB_DEVICE(0x1901, 0x0190) },
202 { USB_DEVICE(0x1901, 0x0193) },
203 { USB_DEVICE(0x1901, 0x0194) },
204 { USB_DEVICE(0x1901, 0x0195) },
205 { USB_DEVICE(0x1901, 0x0196) },
206 { USB_DEVICE(0x1901, 0x0197) },
207 { USB_DEVICE(0x1901, 0x0198) },
208 { USB_DEVICE(0x199B, 0xBA30) },
209 { USB_DEVICE(0x19CF, 0x3000) },
210 { USB_DEVICE(0x1ADB, 0x0001) },
211 { USB_DEVICE(0x1B1C, 0x1C00) },
212 { USB_DEVICE(0x1BA4, 0x0002) },
213 { USB_DEVICE(0x1BE3, 0x07A6) },
214 { USB_DEVICE(0x1D6F, 0x0010) },
215 { USB_DEVICE(0x1E29, 0x0102) },
216 { USB_DEVICE(0x1E29, 0x0501) },
217 { USB_DEVICE(0x1FB9, 0x0100) },
218 { USB_DEVICE(0x1FB9, 0x0200) },
219 { USB_DEVICE(0x1FB9, 0x0201) },
220 { USB_DEVICE(0x1FB9, 0x0202) },
221 { USB_DEVICE(0x1FB9, 0x0203) },
222 { USB_DEVICE(0x1FB9, 0x0300) },
223 { USB_DEVICE(0x1FB9, 0x0301) },
224 { USB_DEVICE(0x1FB9, 0x0302) },
225 { USB_DEVICE(0x1FB9, 0x0303) },
226 { USB_DEVICE(0x1FB9, 0x0400) },
227 { USB_DEVICE(0x1FB9, 0x0401) },
228 { USB_DEVICE(0x1FB9, 0x0402) },
229 { USB_DEVICE(0x1FB9, 0x0403) },
230 { USB_DEVICE(0x1FB9, 0x0404) },
231 { USB_DEVICE(0x1FB9, 0x0600) },
232 { USB_DEVICE(0x1FB9, 0x0601) },
233 { USB_DEVICE(0x1FB9, 0x0602) },
234 { USB_DEVICE(0x1FB9, 0x0700) },
235 { USB_DEVICE(0x1FB9, 0x0701) },
236 { USB_DEVICE(0x2184, 0x0030) },
237 { USB_DEVICE(0x2626, 0xEA60) },
238 { USB_DEVICE(0x3195, 0xF190) },
239 { USB_DEVICE(0x3195, 0xF280) },
240 { USB_DEVICE(0x3195, 0xF281) },
241 { USB_DEVICE(0x3923, 0x7A0B) },
242 { USB_DEVICE(0x413C, 0x9500) },
243 { }
244};
245
246MODULE_DEVICE_TABLE(usb, id_table);
247
248struct cp210x_serial_private {
249#ifdef CONFIG_GPIOLIB
250 struct gpio_chip gc;
251 bool gpio_registered;
252 u16 gpio_pushpull;
253 u16 gpio_altfunc;
254 u16 gpio_input;
255#endif
256 u8 partnum;
257 u32 fw_version;
258 speed_t min_speed;
259 speed_t max_speed;
260 bool use_actual_rate;
261 bool no_flow_control;
262 bool no_event_mode;
263};
264
265enum cp210x_event_state {
266 ES_DATA,
267 ES_ESCAPE,
268 ES_LSR,
269 ES_LSR_DATA_0,
270 ES_LSR_DATA_1,
271 ES_MSR
272};
273
274struct cp210x_port_private {
275 u8 bInterfaceNumber;
276 bool event_mode;
277 enum cp210x_event_state event_state;
278 u8 lsr;
279
280 struct mutex mutex;
281 bool crtscts;
282 bool dtr;
283 bool rts;
284};
285
286static struct usb_serial_driver cp210x_device = {
287 .driver = {
288 .owner = THIS_MODULE,
289 .name = "cp210x",
290 },
291 .id_table = id_table,
292 .num_ports = 1,
293 .bulk_in_size = 256,
294 .bulk_out_size = 256,
295 .open = cp210x_open,
296 .close = cp210x_close,
297 .break_ctl = cp210x_break_ctl,
298 .set_termios = cp210x_set_termios,
299 .tx_empty = cp210x_tx_empty,
300 .throttle = usb_serial_generic_throttle,
301 .unthrottle = usb_serial_generic_unthrottle,
302 .tiocmget = cp210x_tiocmget,
303 .tiocmset = cp210x_tiocmset,
304 .get_icount = usb_serial_generic_get_icount,
305 .attach = cp210x_attach,
306 .disconnect = cp210x_disconnect,
307 .release = cp210x_release,
308 .port_probe = cp210x_port_probe,
309 .port_remove = cp210x_port_remove,
310 .dtr_rts = cp210x_dtr_rts,
311 .process_read_urb = cp210x_process_read_urb,
312};
313
314static struct usb_serial_driver * const serial_drivers[] = {
315 &cp210x_device, NULL
316};
317
318
319#define REQTYPE_HOST_TO_INTERFACE 0x41
320#define REQTYPE_INTERFACE_TO_HOST 0xc1
321#define REQTYPE_HOST_TO_DEVICE 0x40
322#define REQTYPE_DEVICE_TO_HOST 0xc0
323
324
325#define CP210X_IFC_ENABLE 0x00
326#define CP210X_SET_BAUDDIV 0x01
327#define CP210X_GET_BAUDDIV 0x02
328#define CP210X_SET_LINE_CTL 0x03
329#define CP210X_GET_LINE_CTL 0x04
330#define CP210X_SET_BREAK 0x05
331#define CP210X_IMM_CHAR 0x06
332#define CP210X_SET_MHS 0x07
333#define CP210X_GET_MDMSTS 0x08
334#define CP210X_SET_XON 0x09
335#define CP210X_SET_XOFF 0x0A
336#define CP210X_SET_EVENTMASK 0x0B
337#define CP210X_GET_EVENTMASK 0x0C
338#define CP210X_SET_CHAR 0x0D
339#define CP210X_GET_CHARS 0x0E
340#define CP210X_GET_PROPS 0x0F
341#define CP210X_GET_COMM_STATUS 0x10
342#define CP210X_RESET 0x11
343#define CP210X_PURGE 0x12
344#define CP210X_SET_FLOW 0x13
345#define CP210X_GET_FLOW 0x14
346#define CP210X_EMBED_EVENTS 0x15
347#define CP210X_GET_EVENTSTATE 0x16
348#define CP210X_SET_CHARS 0x19
349#define CP210X_GET_BAUDRATE 0x1D
350#define CP210X_SET_BAUDRATE 0x1E
351#define CP210X_VENDOR_SPECIFIC 0xFF
352
353
354#define UART_ENABLE 0x0001
355#define UART_DISABLE 0x0000
356
357
358#define BAUD_RATE_GEN_FREQ 0x384000
359
360
361#define BITS_DATA_MASK 0X0f00
362#define BITS_DATA_5 0X0500
363#define BITS_DATA_6 0X0600
364#define BITS_DATA_7 0X0700
365#define BITS_DATA_8 0X0800
366#define BITS_DATA_9 0X0900
367
368#define BITS_PARITY_MASK 0x00f0
369#define BITS_PARITY_NONE 0x0000
370#define BITS_PARITY_ODD 0x0010
371#define BITS_PARITY_EVEN 0x0020
372#define BITS_PARITY_MARK 0x0030
373#define BITS_PARITY_SPACE 0x0040
374
375#define BITS_STOP_MASK 0x000f
376#define BITS_STOP_1 0x0000
377#define BITS_STOP_1_5 0x0001
378#define BITS_STOP_2 0x0002
379
380
381#define BREAK_ON 0x0001
382#define BREAK_OFF 0x0000
383
384
385#define CONTROL_DTR 0x0001
386#define CONTROL_RTS 0x0002
387#define CONTROL_CTS 0x0010
388#define CONTROL_DSR 0x0020
389#define CONTROL_RING 0x0040
390#define CONTROL_DCD 0x0080
391#define CONTROL_WRITE_DTR 0x0100
392#define CONTROL_WRITE_RTS 0x0200
393
394
395struct cp210x_special_chars {
396 u8 bEofChar;
397 u8 bErrorChar;
398 u8 bBreakChar;
399 u8 bEventChar;
400 u8 bXonChar;
401 u8 bXoffChar;
402};
403
404
405#define CP210X_GET_FW_VER 0x000E
406#define CP210X_READ_2NCONFIG 0x000E
407#define CP210X_GET_FW_VER_2N 0x0010
408#define CP210X_READ_LATCH 0x00C2
409#define CP210X_GET_PARTNUM 0x370B
410#define CP210X_GET_PORTCONFIG 0x370C
411#define CP210X_GET_DEVICEMODE 0x3711
412#define CP210X_WRITE_LATCH 0x37E1
413
414
415#define CP210X_PARTNUM_CP2101 0x01
416#define CP210X_PARTNUM_CP2102 0x02
417#define CP210X_PARTNUM_CP2103 0x03
418#define CP210X_PARTNUM_CP2104 0x04
419#define CP210X_PARTNUM_CP2105 0x05
420#define CP210X_PARTNUM_CP2108 0x08
421#define CP210X_PARTNUM_CP2102N_QFN28 0x20
422#define CP210X_PARTNUM_CP2102N_QFN24 0x21
423#define CP210X_PARTNUM_CP2102N_QFN20 0x22
424#define CP210X_PARTNUM_UNKNOWN 0xFF
425
426
427struct cp210x_comm_status {
428 __le32 ulErrors;
429 __le32 ulHoldReasons;
430 __le32 ulAmountInInQueue;
431 __le32 ulAmountInOutQueue;
432 u8 bEofReceived;
433 u8 bWaitForImmediate;
434 u8 bReserved;
435} __packed;
436
437
438
439
440
441
442
443#define PURGE_ALL 0x000f
444
445
446#define CP210X_ESCCHAR 0xec
447
448#define CP210X_LSR_OVERRUN BIT(1)
449#define CP210X_LSR_PARITY BIT(2)
450#define CP210X_LSR_FRAME BIT(3)
451#define CP210X_LSR_BREAK BIT(4)
452
453
454
455struct cp210x_flow_ctl {
456 __le32 ulControlHandshake;
457 __le32 ulFlowReplace;
458 __le32 ulXonLimit;
459 __le32 ulXoffLimit;
460};
461
462
463#define CP210X_SERIAL_DTR_MASK GENMASK(1, 0)
464#define CP210X_SERIAL_DTR_INACTIVE (0 << 0)
465#define CP210X_SERIAL_DTR_ACTIVE (1 << 0)
466#define CP210X_SERIAL_DTR_FLOW_CTL (2 << 0)
467#define CP210X_SERIAL_CTS_HANDSHAKE BIT(3)
468#define CP210X_SERIAL_DSR_HANDSHAKE BIT(4)
469#define CP210X_SERIAL_DCD_HANDSHAKE BIT(5)
470#define CP210X_SERIAL_DSR_SENSITIVITY BIT(6)
471
472
473#define CP210X_SERIAL_AUTO_TRANSMIT BIT(0)
474#define CP210X_SERIAL_AUTO_RECEIVE BIT(1)
475#define CP210X_SERIAL_ERROR_CHAR BIT(2)
476#define CP210X_SERIAL_NULL_STRIPPING BIT(3)
477#define CP210X_SERIAL_BREAK_CHAR BIT(4)
478#define CP210X_SERIAL_RTS_MASK GENMASK(7, 6)
479#define CP210X_SERIAL_RTS_INACTIVE (0 << 6)
480#define CP210X_SERIAL_RTS_ACTIVE (1 << 6)
481#define CP210X_SERIAL_RTS_FLOW_CTL (2 << 6)
482#define CP210X_SERIAL_XOFF_CONTINUE BIT(31)
483
484
485struct cp210x_pin_mode {
486 u8 eci;
487 u8 sci;
488};
489
490#define CP210X_PIN_MODE_MODEM 0
491#define CP210X_PIN_MODE_GPIO BIT(0)
492
493
494
495
496
497struct cp210x_dual_port_config {
498 __le16 gpio_mode;
499 u8 __pad0[2];
500 __le16 reset_state;
501 u8 __pad1[4];
502 __le16 suspend_state;
503 u8 sci_cfg;
504 u8 eci_cfg;
505 u8 device_cfg;
506} __packed;
507
508
509
510
511
512struct cp210x_single_port_config {
513 __le16 gpio_mode;
514 u8 __pad0[2];
515 __le16 reset_state;
516 u8 __pad1[4];
517 __le16 suspend_state;
518 u8 device_cfg;
519} __packed;
520
521
522#define CP210X_SCI_GPIO_MODE_OFFSET 9
523#define CP210X_SCI_GPIO_MODE_MASK GENMASK(11, 9)
524
525#define CP210X_ECI_GPIO_MODE_OFFSET 2
526#define CP210X_ECI_GPIO_MODE_MASK GENMASK(3, 2)
527
528#define CP210X_GPIO_MODE_OFFSET 8
529#define CP210X_GPIO_MODE_MASK GENMASK(11, 8)
530
531
532#define CP2105_GPIO0_TXLED_MODE BIT(0)
533#define CP2105_GPIO1_RXLED_MODE BIT(1)
534#define CP2105_GPIO1_RS485_MODE BIT(2)
535
536
537#define CP2104_GPIO0_TXLED_MODE BIT(0)
538#define CP2104_GPIO1_RXLED_MODE BIT(1)
539#define CP2104_GPIO2_RS485_MODE BIT(2)
540
541struct cp210x_quad_port_state {
542 __le16 gpio_mode_pb0;
543 __le16 gpio_mode_pb1;
544 __le16 gpio_mode_pb2;
545 __le16 gpio_mode_pb3;
546 __le16 gpio_mode_pb4;
547
548 __le16 gpio_lowpower_pb0;
549 __le16 gpio_lowpower_pb1;
550 __le16 gpio_lowpower_pb2;
551 __le16 gpio_lowpower_pb3;
552 __le16 gpio_lowpower_pb4;
553
554 __le16 gpio_latch_pb0;
555 __le16 gpio_latch_pb1;
556 __le16 gpio_latch_pb2;
557 __le16 gpio_latch_pb3;
558 __le16 gpio_latch_pb4;
559};
560
561
562
563
564
565
566
567struct cp210x_quad_port_config {
568 struct cp210x_quad_port_state reset_state;
569 struct cp210x_quad_port_state suspend_state;
570 u8 ipdelay_ifc[4];
571 u8 enhancedfxn_ifc[4];
572 u8 enhancedfxn_device;
573 u8 extclkfreq[4];
574} __packed;
575
576#define CP2108_EF_IFC_GPIO_TXLED 0x01
577#define CP2108_EF_IFC_GPIO_RXLED 0x02
578#define CP2108_EF_IFC_GPIO_RS485 0x04
579#define CP2108_EF_IFC_GPIO_RS485_LOGIC 0x08
580#define CP2108_EF_IFC_GPIO_CLOCK 0x10
581#define CP2108_EF_IFC_DYNAMIC_SUSPEND 0x40
582
583
584#define CP210X_2NCONFIG_CONFIG_VERSION_IDX 2
585#define CP210X_2NCONFIG_GPIO_MODE_IDX 581
586#define CP210X_2NCONFIG_GPIO_RSTLATCH_IDX 587
587#define CP210X_2NCONFIG_GPIO_CONTROL_IDX 600
588
589
590#define CP2102N_QFN20_GPIO2_TXLED_MODE BIT(2)
591#define CP2102N_QFN20_GPIO3_RXLED_MODE BIT(3)
592#define CP2102N_QFN20_GPIO1_RS485_MODE BIT(4)
593#define CP2102N_QFN20_GPIO0_CLK_MODE BIT(6)
594
595
596
597
598
599struct cp210x_gpio_write {
600 u8 mask;
601 u8 state;
602};
603
604
605
606
607
608struct cp210x_gpio_write16 {
609 __le16 mask;
610 __le16 state;
611};
612
613
614
615
616static u8 cp210x_interface_num(struct usb_serial *serial)
617{
618 struct usb_host_interface *cur_altsetting;
619
620 cur_altsetting = serial->interface->cur_altsetting;
621
622 return cur_altsetting->desc.bInterfaceNumber;
623}
624
625
626
627
628
629static int cp210x_read_reg_block(struct usb_serial_port *port, u8 req,
630 void *buf, int bufsize)
631{
632 struct usb_serial *serial = port->serial;
633 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
634 void *dmabuf;
635 int result;
636
637 dmabuf = kmalloc(bufsize, GFP_KERNEL);
638 if (!dmabuf)
639 return -ENOMEM;
640
641 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
642 req, REQTYPE_INTERFACE_TO_HOST, 0,
643 port_priv->bInterfaceNumber, dmabuf, bufsize,
644 USB_CTRL_GET_TIMEOUT);
645 if (result == bufsize) {
646 memcpy(buf, dmabuf, bufsize);
647 result = 0;
648 } else {
649 dev_err(&port->dev, "failed get req 0x%x size %d status: %d\n",
650 req, bufsize, result);
651 if (result >= 0)
652 result = -EIO;
653 }
654
655 kfree(dmabuf);
656
657 return result;
658}
659
660
661
662
663static int cp210x_read_u8_reg(struct usb_serial_port *port, u8 req, u8 *val)
664{
665 return cp210x_read_reg_block(port, req, val, sizeof(*val));
666}
667
668
669
670
671
672static int cp210x_read_vendor_block(struct usb_serial *serial, u8 type, u16 val,
673 void *buf, int bufsize)
674{
675 void *dmabuf;
676 int result;
677
678 dmabuf = kmalloc(bufsize, GFP_KERNEL);
679 if (!dmabuf)
680 return -ENOMEM;
681
682 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
683 CP210X_VENDOR_SPECIFIC, type, val,
684 cp210x_interface_num(serial), dmabuf, bufsize,
685 USB_CTRL_GET_TIMEOUT);
686 if (result == bufsize) {
687 memcpy(buf, dmabuf, bufsize);
688 result = 0;
689 } else {
690 dev_err(&serial->interface->dev,
691 "failed to get vendor val 0x%04x size %d: %d\n", val,
692 bufsize, result);
693 if (result >= 0)
694 result = -EIO;
695 }
696
697 kfree(dmabuf);
698
699 return result;
700}
701
702
703
704
705
706static int cp210x_write_u16_reg(struct usb_serial_port *port, u8 req, u16 val)
707{
708 struct usb_serial *serial = port->serial;
709 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
710 int result;
711
712 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
713 req, REQTYPE_HOST_TO_INTERFACE, val,
714 port_priv->bInterfaceNumber, NULL, 0,
715 USB_CTRL_SET_TIMEOUT);
716 if (result < 0) {
717 dev_err(&port->dev, "failed set request 0x%x status: %d\n",
718 req, result);
719 }
720
721 return result;
722}
723
724
725
726
727
728static int cp210x_write_reg_block(struct usb_serial_port *port, u8 req,
729 void *buf, int bufsize)
730{
731 struct usb_serial *serial = port->serial;
732 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
733 void *dmabuf;
734 int result;
735
736 dmabuf = kmemdup(buf, bufsize, GFP_KERNEL);
737 if (!dmabuf)
738 return -ENOMEM;
739
740 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
741 req, REQTYPE_HOST_TO_INTERFACE, 0,
742 port_priv->bInterfaceNumber, dmabuf, bufsize,
743 USB_CTRL_SET_TIMEOUT);
744
745 kfree(dmabuf);
746
747 if (result < 0) {
748 dev_err(&port->dev, "failed set req 0x%x size %d status: %d\n",
749 req, bufsize, result);
750 return result;
751 }
752
753 return 0;
754}
755
756
757
758
759static int cp210x_write_u32_reg(struct usb_serial_port *port, u8 req, u32 val)
760{
761 __le32 le32_val;
762
763 le32_val = cpu_to_le32(val);
764
765 return cp210x_write_reg_block(port, req, &le32_val, sizeof(le32_val));
766}
767
768#ifdef CONFIG_GPIOLIB
769
770
771
772
773static int cp210x_write_vendor_block(struct usb_serial *serial, u8 type,
774 u16 val, void *buf, int bufsize)
775{
776 void *dmabuf;
777 int result;
778
779 dmabuf = kmemdup(buf, bufsize, GFP_KERNEL);
780 if (!dmabuf)
781 return -ENOMEM;
782
783 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
784 CP210X_VENDOR_SPECIFIC, type, val,
785 cp210x_interface_num(serial), dmabuf, bufsize,
786 USB_CTRL_SET_TIMEOUT);
787
788 kfree(dmabuf);
789
790 if (result < 0) {
791 dev_err(&serial->interface->dev,
792 "failed to set vendor val 0x%04x size %d: %d\n", val,
793 bufsize, result);
794 return result;
795 }
796
797 return 0;
798}
799#endif
800
801static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
802{
803 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
804 int result;
805
806 result = cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_ENABLE);
807 if (result) {
808 dev_err(&port->dev, "%s - Unable to enable UART\n", __func__);
809 return result;
810 }
811
812 if (tty)
813 cp210x_set_termios(tty, port, NULL);
814
815 result = usb_serial_generic_open(tty, port);
816 if (result)
817 goto err_disable;
818
819 return 0;
820
821err_disable:
822 cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_DISABLE);
823 port_priv->event_mode = false;
824
825 return result;
826}
827
828static void cp210x_close(struct usb_serial_port *port)
829{
830 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
831
832 usb_serial_generic_close(port);
833
834
835 cp210x_write_u16_reg(port, CP210X_PURGE, PURGE_ALL);
836
837 cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_DISABLE);
838
839
840 port_priv->event_mode = false;
841}
842
843static void cp210x_process_lsr(struct usb_serial_port *port, unsigned char lsr, char *flag)
844{
845 if (lsr & CP210X_LSR_BREAK) {
846 port->icount.brk++;
847 *flag = TTY_BREAK;
848 } else if (lsr & CP210X_LSR_PARITY) {
849 port->icount.parity++;
850 *flag = TTY_PARITY;
851 } else if (lsr & CP210X_LSR_FRAME) {
852 port->icount.frame++;
853 *flag = TTY_FRAME;
854 }
855
856 if (lsr & CP210X_LSR_OVERRUN) {
857 port->icount.overrun++;
858 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN);
859 }
860}
861
862static bool cp210x_process_char(struct usb_serial_port *port, unsigned char *ch, char *flag)
863{
864 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
865
866 switch (port_priv->event_state) {
867 case ES_DATA:
868 if (*ch == CP210X_ESCCHAR) {
869 port_priv->event_state = ES_ESCAPE;
870 break;
871 }
872 return false;
873 case ES_ESCAPE:
874 switch (*ch) {
875 case 0:
876 dev_dbg(&port->dev, "%s - escape char\n", __func__);
877 *ch = CP210X_ESCCHAR;
878 port_priv->event_state = ES_DATA;
879 return false;
880 case 1:
881 port_priv->event_state = ES_LSR_DATA_0;
882 break;
883 case 2:
884 port_priv->event_state = ES_LSR;
885 break;
886 case 3:
887 port_priv->event_state = ES_MSR;
888 break;
889 default:
890 dev_err(&port->dev, "malformed event 0x%02x\n", *ch);
891 port_priv->event_state = ES_DATA;
892 break;
893 }
894 break;
895 case ES_LSR_DATA_0:
896 port_priv->lsr = *ch;
897 port_priv->event_state = ES_LSR_DATA_1;
898 break;
899 case ES_LSR_DATA_1:
900 dev_dbg(&port->dev, "%s - lsr = 0x%02x, data = 0x%02x\n",
901 __func__, port_priv->lsr, *ch);
902 cp210x_process_lsr(port, port_priv->lsr, flag);
903 port_priv->event_state = ES_DATA;
904 return false;
905 case ES_LSR:
906 dev_dbg(&port->dev, "%s - lsr = 0x%02x\n", __func__, *ch);
907 port_priv->lsr = *ch;
908 cp210x_process_lsr(port, port_priv->lsr, flag);
909 port_priv->event_state = ES_DATA;
910 break;
911 case ES_MSR:
912 dev_dbg(&port->dev, "%s - msr = 0x%02x\n", __func__, *ch);
913
914 port_priv->event_state = ES_DATA;
915 break;
916 }
917
918 return true;
919}
920
921static void cp210x_process_read_urb(struct urb *urb)
922{
923 struct usb_serial_port *port = urb->context;
924 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
925 unsigned char *ch = urb->transfer_buffer;
926 char flag;
927 int i;
928
929 if (!urb->actual_length)
930 return;
931
932 if (port_priv->event_mode) {
933 for (i = 0; i < urb->actual_length; i++, ch++) {
934 flag = TTY_NORMAL;
935
936 if (cp210x_process_char(port, ch, &flag))
937 continue;
938
939 tty_insert_flip_char(&port->port, *ch, flag);
940 }
941 } else {
942 tty_insert_flip_string(&port->port, ch, urb->actual_length);
943 }
944 tty_flip_buffer_push(&port->port);
945}
946
947
948
949
950static int cp210x_get_tx_queue_byte_count(struct usb_serial_port *port,
951 u32 *count)
952{
953 struct usb_serial *serial = port->serial;
954 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
955 struct cp210x_comm_status *sts;
956 int result;
957
958 sts = kmalloc(sizeof(*sts), GFP_KERNEL);
959 if (!sts)
960 return -ENOMEM;
961
962 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
963 CP210X_GET_COMM_STATUS, REQTYPE_INTERFACE_TO_HOST,
964 0, port_priv->bInterfaceNumber, sts, sizeof(*sts),
965 USB_CTRL_GET_TIMEOUT);
966 if (result == sizeof(*sts)) {
967 *count = le32_to_cpu(sts->ulAmountInOutQueue);
968 result = 0;
969 } else {
970 dev_err(&port->dev, "failed to get comm status: %d\n", result);
971 if (result >= 0)
972 result = -EIO;
973 }
974
975 kfree(sts);
976
977 return result;
978}
979
980static bool cp210x_tx_empty(struct usb_serial_port *port)
981{
982 int err;
983 u32 count;
984
985 err = cp210x_get_tx_queue_byte_count(port, &count);
986 if (err)
987 return true;
988
989 return !count;
990}
991
992struct cp210x_rate {
993 speed_t rate;
994 speed_t high;
995};
996
997static const struct cp210x_rate cp210x_an205_table1[] = {
998 { 300, 300 },
999 { 600, 600 },
1000 { 1200, 1200 },
1001 { 1800, 1800 },
1002 { 2400, 2400 },
1003 { 4000, 4000 },
1004 { 4800, 4803 },
1005 { 7200, 7207 },
1006 { 9600, 9612 },
1007 { 14400, 14428 },
1008 { 16000, 16062 },
1009 { 19200, 19250 },
1010 { 28800, 28912 },
1011 { 38400, 38601 },
1012 { 51200, 51558 },
1013 { 56000, 56280 },
1014 { 57600, 58053 },
1015 { 64000, 64111 },
1016 { 76800, 77608 },
1017 { 115200, 117028 },
1018 { 128000, 129347 },
1019 { 153600, 156868 },
1020 { 230400, 237832 },
1021 { 250000, 254234 },
1022 { 256000, 273066 },
1023 { 460800, 491520 },
1024 { 500000, 567138 },
1025 { 576000, 670254 },
1026 { 921600, UINT_MAX }
1027};
1028
1029
1030
1031
1032static speed_t cp210x_get_an205_rate(speed_t baud)
1033{
1034 int i;
1035
1036 for (i = 0; i < ARRAY_SIZE(cp210x_an205_table1); ++i) {
1037 if (baud <= cp210x_an205_table1[i].high)
1038 break;
1039 }
1040
1041 return cp210x_an205_table1[i].rate;
1042}
1043
1044static speed_t cp210x_get_actual_rate(speed_t baud)
1045{
1046 unsigned int prescale = 1;
1047 unsigned int div;
1048
1049 if (baud <= 365)
1050 prescale = 4;
1051
1052 div = DIV_ROUND_CLOSEST(48000000, 2 * prescale * baud);
1053 baud = 48000000 / (2 * prescale * div);
1054
1055 return baud;
1056}
1057
1058
1059
1060
1061
1062
1063
1064
1065
1066
1067
1068
1069
1070
1071
1072
1073
1074
1075
1076
1077
1078
1079
1080
1081
1082
1083
1084static void cp210x_change_speed(struct tty_struct *tty,
1085 struct usb_serial_port *port, struct ktermios *old_termios)
1086{
1087 struct usb_serial *serial = port->serial;
1088 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1089 u32 baud;
1090
1091
1092
1093
1094
1095
1096
1097 baud = clamp(tty->termios.c_ospeed, priv->min_speed, priv->max_speed);
1098
1099 if (priv->use_actual_rate)
1100 baud = cp210x_get_actual_rate(baud);
1101 else if (baud < 1000000)
1102 baud = cp210x_get_an205_rate(baud);
1103
1104 dev_dbg(&port->dev, "%s - setting baud rate to %u\n", __func__, baud);
1105 if (cp210x_write_u32_reg(port, CP210X_SET_BAUDRATE, baud)) {
1106 dev_warn(&port->dev, "failed to set baud rate to %u\n", baud);
1107 if (old_termios)
1108 baud = old_termios->c_ospeed;
1109 else
1110 baud = 9600;
1111 }
1112
1113 tty_encode_baud_rate(tty, baud, baud);
1114}
1115
1116static void cp210x_enable_event_mode(struct usb_serial_port *port)
1117{
1118 struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1119 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1120 int ret;
1121
1122 if (port_priv->event_mode)
1123 return;
1124
1125 if (priv->no_event_mode)
1126 return;
1127
1128 port_priv->event_state = ES_DATA;
1129 port_priv->event_mode = true;
1130
1131 ret = cp210x_write_u16_reg(port, CP210X_EMBED_EVENTS, CP210X_ESCCHAR);
1132 if (ret) {
1133 dev_err(&port->dev, "failed to enable events: %d\n", ret);
1134 port_priv->event_mode = false;
1135 }
1136}
1137
1138static void cp210x_disable_event_mode(struct usb_serial_port *port)
1139{
1140 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1141 int ret;
1142
1143 if (!port_priv->event_mode)
1144 return;
1145
1146 ret = cp210x_write_u16_reg(port, CP210X_EMBED_EVENTS, 0);
1147 if (ret) {
1148 dev_err(&port->dev, "failed to disable events: %d\n", ret);
1149 return;
1150 }
1151
1152 port_priv->event_mode = false;
1153}
1154
1155static bool cp210x_termios_change(const struct ktermios *a, const struct ktermios *b)
1156{
1157 bool iflag_change, cc_change;
1158
1159 iflag_change = ((a->c_iflag ^ b->c_iflag) & (INPCK | IXON | IXOFF));
1160 cc_change = a->c_cc[VSTART] != b->c_cc[VSTART] ||
1161 a->c_cc[VSTOP] != b->c_cc[VSTOP];
1162
1163 return tty_termios_hw_change(a, b) || iflag_change || cc_change;
1164}
1165
1166static void cp210x_set_flow_control(struct tty_struct *tty,
1167 struct usb_serial_port *port, struct ktermios *old_termios)
1168{
1169 struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1170 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1171 struct cp210x_special_chars chars;
1172 struct cp210x_flow_ctl flow_ctl;
1173 u32 flow_repl;
1174 u32 ctl_hs;
1175 bool crtscts;
1176 int ret;
1177
1178
1179
1180
1181
1182 if (priv->no_flow_control) {
1183 tty->termios.c_cflag &= ~CRTSCTS;
1184 tty->termios.c_iflag &= ~(IXON | IXOFF);
1185 }
1186
1187 if (old_termios &&
1188 C_CRTSCTS(tty) == (old_termios->c_cflag & CRTSCTS) &&
1189 I_IXON(tty) == (old_termios->c_iflag & IXON) &&
1190 I_IXOFF(tty) == (old_termios->c_iflag & IXOFF) &&
1191 START_CHAR(tty) == old_termios->c_cc[VSTART] &&
1192 STOP_CHAR(tty) == old_termios->c_cc[VSTOP]) {
1193 return;
1194 }
1195
1196 if (I_IXON(tty) || I_IXOFF(tty)) {
1197 memset(&chars, 0, sizeof(chars));
1198
1199 chars.bXonChar = START_CHAR(tty);
1200 chars.bXoffChar = STOP_CHAR(tty);
1201
1202 ret = cp210x_write_reg_block(port, CP210X_SET_CHARS, &chars,
1203 sizeof(chars));
1204 if (ret) {
1205 dev_err(&port->dev, "failed to set special chars: %d\n",
1206 ret);
1207 }
1208 }
1209
1210 mutex_lock(&port_priv->mutex);
1211
1212 ret = cp210x_read_reg_block(port, CP210X_GET_FLOW, &flow_ctl,
1213 sizeof(flow_ctl));
1214 if (ret)
1215 goto out_unlock;
1216
1217 ctl_hs = le32_to_cpu(flow_ctl.ulControlHandshake);
1218 flow_repl = le32_to_cpu(flow_ctl.ulFlowReplace);
1219
1220 ctl_hs &= ~CP210X_SERIAL_DSR_HANDSHAKE;
1221 ctl_hs &= ~CP210X_SERIAL_DCD_HANDSHAKE;
1222 ctl_hs &= ~CP210X_SERIAL_DSR_SENSITIVITY;
1223 ctl_hs &= ~CP210X_SERIAL_DTR_MASK;
1224 if (port_priv->dtr)
1225 ctl_hs |= CP210X_SERIAL_DTR_ACTIVE;
1226 else
1227 ctl_hs |= CP210X_SERIAL_DTR_INACTIVE;
1228
1229 flow_repl &= ~CP210X_SERIAL_RTS_MASK;
1230 if (C_CRTSCTS(tty)) {
1231 ctl_hs |= CP210X_SERIAL_CTS_HANDSHAKE;
1232 if (port_priv->rts)
1233 flow_repl |= CP210X_SERIAL_RTS_FLOW_CTL;
1234 else
1235 flow_repl |= CP210X_SERIAL_RTS_INACTIVE;
1236 crtscts = true;
1237 } else {
1238 ctl_hs &= ~CP210X_SERIAL_CTS_HANDSHAKE;
1239 if (port_priv->rts)
1240 flow_repl |= CP210X_SERIAL_RTS_ACTIVE;
1241 else
1242 flow_repl |= CP210X_SERIAL_RTS_INACTIVE;
1243 crtscts = false;
1244 }
1245
1246 if (I_IXOFF(tty)) {
1247 flow_repl |= CP210X_SERIAL_AUTO_RECEIVE;
1248
1249 flow_ctl.ulXonLimit = cpu_to_le32(128);
1250 flow_ctl.ulXoffLimit = cpu_to_le32(128);
1251 } else {
1252 flow_repl &= ~CP210X_SERIAL_AUTO_RECEIVE;
1253 }
1254
1255 if (I_IXON(tty))
1256 flow_repl |= CP210X_SERIAL_AUTO_TRANSMIT;
1257 else
1258 flow_repl &= ~CP210X_SERIAL_AUTO_TRANSMIT;
1259
1260 dev_dbg(&port->dev, "%s - ctrl = 0x%02x, flow = 0x%02x\n", __func__,
1261 ctl_hs, flow_repl);
1262
1263 flow_ctl.ulControlHandshake = cpu_to_le32(ctl_hs);
1264 flow_ctl.ulFlowReplace = cpu_to_le32(flow_repl);
1265
1266 ret = cp210x_write_reg_block(port, CP210X_SET_FLOW, &flow_ctl,
1267 sizeof(flow_ctl));
1268 if (ret)
1269 goto out_unlock;
1270
1271 port_priv->crtscts = crtscts;
1272out_unlock:
1273 mutex_unlock(&port_priv->mutex);
1274}
1275
1276static void cp210x_set_termios(struct tty_struct *tty,
1277 struct usb_serial_port *port, struct ktermios *old_termios)
1278{
1279 struct cp210x_serial_private *priv = usb_get_serial_data(port->serial);
1280 u16 bits;
1281 int ret;
1282
1283 if (old_termios && !cp210x_termios_change(&tty->termios, old_termios))
1284 return;
1285
1286 if (!old_termios || tty->termios.c_ospeed != old_termios->c_ospeed)
1287 cp210x_change_speed(tty, port, old_termios);
1288
1289
1290 if (priv->partnum == CP210X_PARTNUM_CP2101) {
1291 tty->termios.c_cflag &= ~(CSIZE | CSTOPB | CMSPAR);
1292 tty->termios.c_cflag |= CS8;
1293 }
1294
1295 bits = 0;
1296
1297 switch (C_CSIZE(tty)) {
1298 case CS5:
1299 bits |= BITS_DATA_5;
1300 break;
1301 case CS6:
1302 bits |= BITS_DATA_6;
1303 break;
1304 case CS7:
1305 bits |= BITS_DATA_7;
1306 break;
1307 case CS8:
1308 default:
1309 bits |= BITS_DATA_8;
1310 break;
1311 }
1312
1313 if (C_PARENB(tty)) {
1314 if (C_CMSPAR(tty)) {
1315 if (C_PARODD(tty))
1316 bits |= BITS_PARITY_MARK;
1317 else
1318 bits |= BITS_PARITY_SPACE;
1319 } else {
1320 if (C_PARODD(tty))
1321 bits |= BITS_PARITY_ODD;
1322 else
1323 bits |= BITS_PARITY_EVEN;
1324 }
1325 }
1326
1327 if (C_CSTOPB(tty))
1328 bits |= BITS_STOP_2;
1329 else
1330 bits |= BITS_STOP_1;
1331
1332 ret = cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
1333 if (ret)
1334 dev_err(&port->dev, "failed to set line control: %d\n", ret);
1335
1336 cp210x_set_flow_control(tty, port, old_termios);
1337
1338
1339
1340
1341
1342 if (I_INPCK(tty))
1343 cp210x_enable_event_mode(port);
1344 else
1345 cp210x_disable_event_mode(port);
1346}
1347
1348static int cp210x_tiocmset(struct tty_struct *tty,
1349 unsigned int set, unsigned int clear)
1350{
1351 struct usb_serial_port *port = tty->driver_data;
1352 return cp210x_tiocmset_port(port, set, clear);
1353}
1354
1355static int cp210x_tiocmset_port(struct usb_serial_port *port,
1356 unsigned int set, unsigned int clear)
1357{
1358 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
1359 struct cp210x_flow_ctl flow_ctl;
1360 u32 ctl_hs, flow_repl;
1361 u16 control = 0;
1362 int ret;
1363
1364 mutex_lock(&port_priv->mutex);
1365
1366 if (set & TIOCM_RTS) {
1367 port_priv->rts = true;
1368 control |= CONTROL_RTS;
1369 control |= CONTROL_WRITE_RTS;
1370 }
1371 if (set & TIOCM_DTR) {
1372 port_priv->dtr = true;
1373 control |= CONTROL_DTR;
1374 control |= CONTROL_WRITE_DTR;
1375 }
1376 if (clear & TIOCM_RTS) {
1377 port_priv->rts = false;
1378 control &= ~CONTROL_RTS;
1379 control |= CONTROL_WRITE_RTS;
1380 }
1381 if (clear & TIOCM_DTR) {
1382 port_priv->dtr = false;
1383 control &= ~CONTROL_DTR;
1384 control |= CONTROL_WRITE_DTR;
1385 }
1386
1387
1388
1389
1390
1391 if (port_priv->crtscts && control & CONTROL_WRITE_RTS) {
1392 ret = cp210x_read_reg_block(port, CP210X_GET_FLOW, &flow_ctl,
1393 sizeof(flow_ctl));
1394 if (ret)
1395 goto out_unlock;
1396
1397 ctl_hs = le32_to_cpu(flow_ctl.ulControlHandshake);
1398 flow_repl = le32_to_cpu(flow_ctl.ulFlowReplace);
1399
1400 ctl_hs &= ~CP210X_SERIAL_DTR_MASK;
1401 if (port_priv->dtr)
1402 ctl_hs |= CP210X_SERIAL_DTR_ACTIVE;
1403 else
1404 ctl_hs |= CP210X_SERIAL_DTR_INACTIVE;
1405
1406 flow_repl &= ~CP210X_SERIAL_RTS_MASK;
1407 if (port_priv->rts)
1408 flow_repl |= CP210X_SERIAL_RTS_FLOW_CTL;
1409 else
1410 flow_repl |= CP210X_SERIAL_RTS_INACTIVE;
1411
1412 flow_ctl.ulControlHandshake = cpu_to_le32(ctl_hs);
1413 flow_ctl.ulFlowReplace = cpu_to_le32(flow_repl);
1414
1415 dev_dbg(&port->dev, "%s - ctrl = 0x%02x, flow = 0x%02x\n",
1416 __func__, ctl_hs, flow_repl);
1417
1418 ret = cp210x_write_reg_block(port, CP210X_SET_FLOW, &flow_ctl,
1419 sizeof(flow_ctl));
1420 } else {
1421 dev_dbg(&port->dev, "%s - control = 0x%04x\n", __func__, control);
1422
1423 ret = cp210x_write_u16_reg(port, CP210X_SET_MHS, control);
1424 }
1425out_unlock:
1426 mutex_unlock(&port_priv->mutex);
1427
1428 return ret;
1429}
1430
1431static void cp210x_dtr_rts(struct usb_serial_port *port, int on)
1432{
1433 if (on)
1434 cp210x_tiocmset_port(port, TIOCM_DTR | TIOCM_RTS, 0);
1435 else
1436 cp210x_tiocmset_port(port, 0, TIOCM_DTR | TIOCM_RTS);
1437}
1438
1439static int cp210x_tiocmget(struct tty_struct *tty)
1440{
1441 struct usb_serial_port *port = tty->driver_data;
1442 u8 control;
1443 int result;
1444
1445 result = cp210x_read_u8_reg(port, CP210X_GET_MDMSTS, &control);
1446 if (result)
1447 return result;
1448
1449 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
1450 |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
1451 |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
1452 |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
1453 |((control & CONTROL_RING)? TIOCM_RI : 0)
1454 |((control & CONTROL_DCD) ? TIOCM_CD : 0);
1455
1456 dev_dbg(&port->dev, "%s - control = 0x%02x\n", __func__, control);
1457
1458 return result;
1459}
1460
1461static void cp210x_break_ctl(struct tty_struct *tty, int break_state)
1462{
1463 struct usb_serial_port *port = tty->driver_data;
1464 u16 state;
1465
1466 if (break_state == 0)
1467 state = BREAK_OFF;
1468 else
1469 state = BREAK_ON;
1470 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
1471 state == BREAK_OFF ? "off" : "on");
1472 cp210x_write_u16_reg(port, CP210X_SET_BREAK, state);
1473}
1474
1475#ifdef CONFIG_GPIOLIB
1476static int cp210x_gpio_get(struct gpio_chip *gc, unsigned int gpio)
1477{
1478 struct usb_serial *serial = gpiochip_get_data(gc);
1479 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1480 u8 req_type;
1481 u16 mask;
1482 int result;
1483 int len;
1484
1485 result = usb_autopm_get_interface(serial->interface);
1486 if (result)
1487 return result;
1488
1489 switch (priv->partnum) {
1490 case CP210X_PARTNUM_CP2105:
1491 req_type = REQTYPE_INTERFACE_TO_HOST;
1492 len = 1;
1493 break;
1494 case CP210X_PARTNUM_CP2108:
1495 req_type = REQTYPE_INTERFACE_TO_HOST;
1496 len = 2;
1497 break;
1498 default:
1499 req_type = REQTYPE_DEVICE_TO_HOST;
1500 len = 1;
1501 break;
1502 }
1503
1504 mask = 0;
1505 result = cp210x_read_vendor_block(serial, req_type, CP210X_READ_LATCH,
1506 &mask, len);
1507
1508 usb_autopm_put_interface(serial->interface);
1509
1510 if (result < 0)
1511 return result;
1512
1513 le16_to_cpus(&mask);
1514
1515 return !!(mask & BIT(gpio));
1516}
1517
1518static void cp210x_gpio_set(struct gpio_chip *gc, unsigned int gpio, int value)
1519{
1520 struct usb_serial *serial = gpiochip_get_data(gc);
1521 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1522 struct cp210x_gpio_write16 buf16;
1523 struct cp210x_gpio_write buf;
1524 u16 mask, state;
1525 u16 wIndex;
1526 int result;
1527
1528 if (value == 1)
1529 state = BIT(gpio);
1530 else
1531 state = 0;
1532
1533 mask = BIT(gpio);
1534
1535 result = usb_autopm_get_interface(serial->interface);
1536 if (result)
1537 goto out;
1538
1539 switch (priv->partnum) {
1540 case CP210X_PARTNUM_CP2105:
1541 buf.mask = (u8)mask;
1542 buf.state = (u8)state;
1543 result = cp210x_write_vendor_block(serial,
1544 REQTYPE_HOST_TO_INTERFACE,
1545 CP210X_WRITE_LATCH, &buf,
1546 sizeof(buf));
1547 break;
1548 case CP210X_PARTNUM_CP2108:
1549 buf16.mask = cpu_to_le16(mask);
1550 buf16.state = cpu_to_le16(state);
1551 result = cp210x_write_vendor_block(serial,
1552 REQTYPE_HOST_TO_INTERFACE,
1553 CP210X_WRITE_LATCH, &buf16,
1554 sizeof(buf16));
1555 break;
1556 default:
1557 wIndex = state << 8 | mask;
1558 result = usb_control_msg(serial->dev,
1559 usb_sndctrlpipe(serial->dev, 0),
1560 CP210X_VENDOR_SPECIFIC,
1561 REQTYPE_HOST_TO_DEVICE,
1562 CP210X_WRITE_LATCH,
1563 wIndex,
1564 NULL, 0, USB_CTRL_SET_TIMEOUT);
1565 break;
1566 }
1567
1568 usb_autopm_put_interface(serial->interface);
1569out:
1570 if (result < 0) {
1571 dev_err(&serial->interface->dev, "failed to set GPIO value: %d\n",
1572 result);
1573 }
1574}
1575
1576static int cp210x_gpio_direction_get(struct gpio_chip *gc, unsigned int gpio)
1577{
1578 struct usb_serial *serial = gpiochip_get_data(gc);
1579 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1580
1581 return priv->gpio_input & BIT(gpio);
1582}
1583
1584static int cp210x_gpio_direction_input(struct gpio_chip *gc, unsigned int gpio)
1585{
1586 struct usb_serial *serial = gpiochip_get_data(gc);
1587 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1588
1589 if (priv->partnum == CP210X_PARTNUM_CP2105) {
1590
1591 return -ENOTSUPP;
1592 }
1593
1594
1595 if (priv->gpio_pushpull & BIT(gpio))
1596 return -EINVAL;
1597
1598
1599 cp210x_gpio_set(gc, gpio, 1);
1600
1601 priv->gpio_input |= BIT(gpio);
1602
1603 return 0;
1604}
1605
1606static int cp210x_gpio_direction_output(struct gpio_chip *gc, unsigned int gpio,
1607 int value)
1608{
1609 struct usb_serial *serial = gpiochip_get_data(gc);
1610 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1611
1612 priv->gpio_input &= ~BIT(gpio);
1613 cp210x_gpio_set(gc, gpio, value);
1614
1615 return 0;
1616}
1617
1618static int cp210x_gpio_set_config(struct gpio_chip *gc, unsigned int gpio,
1619 unsigned long config)
1620{
1621 struct usb_serial *serial = gpiochip_get_data(gc);
1622 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1623 enum pin_config_param param = pinconf_to_config_param(config);
1624
1625
1626 if ((param == PIN_CONFIG_DRIVE_PUSH_PULL) &&
1627 (priv->gpio_pushpull & BIT(gpio)))
1628 return 0;
1629
1630 if ((param == PIN_CONFIG_DRIVE_OPEN_DRAIN) &&
1631 !(priv->gpio_pushpull & BIT(gpio)))
1632 return 0;
1633
1634 return -ENOTSUPP;
1635}
1636
1637static int cp210x_gpio_init_valid_mask(struct gpio_chip *gc,
1638 unsigned long *valid_mask, unsigned int ngpios)
1639{
1640 struct usb_serial *serial = gpiochip_get_data(gc);
1641 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1642 struct device *dev = &serial->interface->dev;
1643 unsigned long altfunc_mask = priv->gpio_altfunc;
1644
1645 bitmap_complement(valid_mask, &altfunc_mask, ngpios);
1646
1647 if (bitmap_empty(valid_mask, ngpios))
1648 dev_dbg(dev, "no pin configured for GPIO\n");
1649 else
1650 dev_dbg(dev, "GPIO.%*pbl configured for GPIO\n", ngpios,
1651 valid_mask);
1652 return 0;
1653}
1654
1655
1656
1657
1658
1659
1660
1661
1662static int cp2105_gpioconf_init(struct usb_serial *serial)
1663{
1664 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1665 struct cp210x_pin_mode mode;
1666 struct cp210x_dual_port_config config;
1667 u8 intf_num = cp210x_interface_num(serial);
1668 u8 iface_config;
1669 int result;
1670
1671 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1672 CP210X_GET_DEVICEMODE, &mode,
1673 sizeof(mode));
1674 if (result < 0)
1675 return result;
1676
1677 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1678 CP210X_GET_PORTCONFIG, &config,
1679 sizeof(config));
1680 if (result < 0)
1681 return result;
1682
1683
1684 if (intf_num == 0) {
1685 if (mode.eci == CP210X_PIN_MODE_MODEM) {
1686
1687 priv->gpio_altfunc = 0xff;
1688 return 0;
1689 }
1690
1691 iface_config = config.eci_cfg;
1692 priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1693 CP210X_ECI_GPIO_MODE_MASK) >>
1694 CP210X_ECI_GPIO_MODE_OFFSET);
1695 priv->gc.ngpio = 2;
1696 } else if (intf_num == 1) {
1697 if (mode.sci == CP210X_PIN_MODE_MODEM) {
1698
1699 priv->gpio_altfunc = 0xff;
1700 return 0;
1701 }
1702
1703 iface_config = config.sci_cfg;
1704 priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1705 CP210X_SCI_GPIO_MODE_MASK) >>
1706 CP210X_SCI_GPIO_MODE_OFFSET);
1707 priv->gc.ngpio = 3;
1708 } else {
1709 return -ENODEV;
1710 }
1711
1712
1713 if (iface_config & CP2105_GPIO0_TXLED_MODE)
1714 priv->gpio_altfunc |= BIT(0);
1715 if (iface_config & (CP2105_GPIO1_RXLED_MODE |
1716 CP2105_GPIO1_RS485_MODE))
1717 priv->gpio_altfunc |= BIT(1);
1718
1719
1720 priv->gpio_input = 0;
1721
1722 return 0;
1723}
1724
1725static int cp2104_gpioconf_init(struct usb_serial *serial)
1726{
1727 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1728 struct cp210x_single_port_config config;
1729 u8 iface_config;
1730 u8 gpio_latch;
1731 int result;
1732 u8 i;
1733
1734 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1735 CP210X_GET_PORTCONFIG, &config,
1736 sizeof(config));
1737 if (result < 0)
1738 return result;
1739
1740 priv->gc.ngpio = 4;
1741
1742 iface_config = config.device_cfg;
1743 priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1744 CP210X_GPIO_MODE_MASK) >>
1745 CP210X_GPIO_MODE_OFFSET);
1746 gpio_latch = (u8)((le16_to_cpu(config.reset_state) &
1747 CP210X_GPIO_MODE_MASK) >>
1748 CP210X_GPIO_MODE_OFFSET);
1749
1750
1751 if (iface_config & CP2104_GPIO0_TXLED_MODE)
1752 priv->gpio_altfunc |= BIT(0);
1753 if (iface_config & CP2104_GPIO1_RXLED_MODE)
1754 priv->gpio_altfunc |= BIT(1);
1755 if (iface_config & CP2104_GPIO2_RS485_MODE)
1756 priv->gpio_altfunc |= BIT(2);
1757
1758
1759
1760
1761
1762
1763 for (i = 0; i < priv->gc.ngpio; ++i) {
1764
1765
1766
1767
1768 if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1769 priv->gpio_input |= BIT(i);
1770 }
1771
1772 return 0;
1773}
1774
1775static int cp2108_gpio_init(struct usb_serial *serial)
1776{
1777 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1778 struct cp210x_quad_port_config config;
1779 u16 gpio_latch;
1780 int result;
1781 u8 i;
1782
1783 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1784 CP210X_GET_PORTCONFIG, &config,
1785 sizeof(config));
1786 if (result < 0)
1787 return result;
1788
1789 priv->gc.ngpio = 16;
1790 priv->gpio_pushpull = le16_to_cpu(config.reset_state.gpio_mode_pb1);
1791 gpio_latch = le16_to_cpu(config.reset_state.gpio_latch_pb1);
1792
1793
1794
1795
1796
1797
1798
1799
1800
1801
1802
1803 for (i = 0; i < 4; i++) {
1804 if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_TXLED)
1805 priv->gpio_altfunc |= BIT(i * 4);
1806 if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_RXLED)
1807 priv->gpio_altfunc |= BIT((i * 4) + 1);
1808 if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_RS485)
1809 priv->gpio_altfunc |= BIT((i * 4) + 2);
1810 if (config.enhancedfxn_ifc[i] & CP2108_EF_IFC_GPIO_CLOCK)
1811 priv->gpio_altfunc |= BIT((i * 4) + 3);
1812 }
1813
1814
1815
1816
1817
1818 for (i = 0; i < priv->gc.ngpio; ++i) {
1819
1820
1821
1822
1823 if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1824 priv->gpio_input |= BIT(i);
1825 }
1826
1827 return 0;
1828}
1829
1830static int cp2102n_gpioconf_init(struct usb_serial *serial)
1831{
1832 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1833 const u16 config_size = 0x02a6;
1834 u8 gpio_rst_latch;
1835 u8 config_version;
1836 u8 gpio_pushpull;
1837 u8 *config_buf;
1838 u8 gpio_latch;
1839 u8 gpio_ctrl;
1840 int result;
1841 u8 i;
1842
1843
1844
1845
1846
1847
1848
1849
1850 config_buf = kmalloc(config_size, GFP_KERNEL);
1851 if (!config_buf)
1852 return -ENOMEM;
1853
1854 result = cp210x_read_vendor_block(serial,
1855 REQTYPE_DEVICE_TO_HOST,
1856 CP210X_READ_2NCONFIG,
1857 config_buf,
1858 config_size);
1859 if (result < 0) {
1860 kfree(config_buf);
1861 return result;
1862 }
1863
1864 config_version = config_buf[CP210X_2NCONFIG_CONFIG_VERSION_IDX];
1865 gpio_pushpull = config_buf[CP210X_2NCONFIG_GPIO_MODE_IDX];
1866 gpio_ctrl = config_buf[CP210X_2NCONFIG_GPIO_CONTROL_IDX];
1867 gpio_rst_latch = config_buf[CP210X_2NCONFIG_GPIO_RSTLATCH_IDX];
1868
1869 kfree(config_buf);
1870
1871
1872 if (config_version != 0x01)
1873 return -ENOTSUPP;
1874
1875 priv->gc.ngpio = 4;
1876
1877
1878
1879
1880
1881 gpio_latch = (gpio_rst_latch >> 3) & 0x0f;
1882
1883
1884 priv->gpio_pushpull = (gpio_pushpull >> 3) & 0x0f;
1885
1886
1887 if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN20) {
1888
1889 if (gpio_ctrl & CP2102N_QFN20_GPIO0_CLK_MODE)
1890 priv->gpio_altfunc |= BIT(0);
1891 if (gpio_ctrl & CP2102N_QFN20_GPIO1_RS485_MODE)
1892 priv->gpio_altfunc |= BIT(1);
1893 if (gpio_ctrl & CP2102N_QFN20_GPIO2_TXLED_MODE)
1894 priv->gpio_altfunc |= BIT(2);
1895 if (gpio_ctrl & CP2102N_QFN20_GPIO3_RXLED_MODE)
1896 priv->gpio_altfunc |= BIT(3);
1897 } else {
1898 priv->gpio_altfunc = (gpio_ctrl >> 2) & 0x0f;
1899 }
1900
1901 if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN28) {
1902
1903
1904
1905
1906
1907
1908
1909 priv->gc.ngpio = 7;
1910 gpio_latch |= (gpio_rst_latch & 7) << 4;
1911 priv->gpio_pushpull |= (gpio_pushpull & 7) << 4;
1912 }
1913
1914
1915
1916
1917
1918
1919
1920
1921
1922 for (i = 0; i < priv->gc.ngpio; ++i) {
1923
1924
1925
1926
1927 if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1928 priv->gpio_input |= BIT(i);
1929 }
1930
1931 return 0;
1932}
1933
1934static int cp210x_gpio_init(struct usb_serial *serial)
1935{
1936 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1937 int result;
1938
1939 switch (priv->partnum) {
1940 case CP210X_PARTNUM_CP2104:
1941 result = cp2104_gpioconf_init(serial);
1942 break;
1943 case CP210X_PARTNUM_CP2105:
1944 result = cp2105_gpioconf_init(serial);
1945 break;
1946 case CP210X_PARTNUM_CP2108:
1947
1948
1949
1950
1951 if (cp210x_interface_num(serial) != 0)
1952 return 0;
1953 result = cp2108_gpio_init(serial);
1954 break;
1955 case CP210X_PARTNUM_CP2102N_QFN28:
1956 case CP210X_PARTNUM_CP2102N_QFN24:
1957 case CP210X_PARTNUM_CP2102N_QFN20:
1958 result = cp2102n_gpioconf_init(serial);
1959 break;
1960 default:
1961 return 0;
1962 }
1963
1964 if (result < 0)
1965 return result;
1966
1967 priv->gc.label = "cp210x";
1968 priv->gc.get_direction = cp210x_gpio_direction_get;
1969 priv->gc.direction_input = cp210x_gpio_direction_input;
1970 priv->gc.direction_output = cp210x_gpio_direction_output;
1971 priv->gc.get = cp210x_gpio_get;
1972 priv->gc.set = cp210x_gpio_set;
1973 priv->gc.set_config = cp210x_gpio_set_config;
1974 priv->gc.init_valid_mask = cp210x_gpio_init_valid_mask;
1975 priv->gc.owner = THIS_MODULE;
1976 priv->gc.parent = &serial->interface->dev;
1977 priv->gc.base = -1;
1978 priv->gc.can_sleep = true;
1979
1980 result = gpiochip_add_data(&priv->gc, serial);
1981 if (!result)
1982 priv->gpio_registered = true;
1983
1984 return result;
1985}
1986
1987static void cp210x_gpio_remove(struct usb_serial *serial)
1988{
1989 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1990
1991 if (priv->gpio_registered) {
1992 gpiochip_remove(&priv->gc);
1993 priv->gpio_registered = false;
1994 }
1995}
1996
1997#else
1998
1999static int cp210x_gpio_init(struct usb_serial *serial)
2000{
2001 return 0;
2002}
2003
2004static void cp210x_gpio_remove(struct usb_serial *serial)
2005{
2006
2007}
2008
2009#endif
2010
2011static int cp210x_port_probe(struct usb_serial_port *port)
2012{
2013 struct usb_serial *serial = port->serial;
2014 struct cp210x_port_private *port_priv;
2015
2016 port_priv = kzalloc(sizeof(*port_priv), GFP_KERNEL);
2017 if (!port_priv)
2018 return -ENOMEM;
2019
2020 port_priv->bInterfaceNumber = cp210x_interface_num(serial);
2021 mutex_init(&port_priv->mutex);
2022
2023 usb_set_serial_port_data(port, port_priv);
2024
2025 return 0;
2026}
2027
2028static void cp210x_port_remove(struct usb_serial_port *port)
2029{
2030 struct cp210x_port_private *port_priv;
2031
2032 port_priv = usb_get_serial_port_data(port);
2033 kfree(port_priv);
2034}
2035
2036static void cp210x_init_max_speed(struct usb_serial *serial)
2037{
2038 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2039 bool use_actual_rate = false;
2040 speed_t min = 300;
2041 speed_t max;
2042
2043 switch (priv->partnum) {
2044 case CP210X_PARTNUM_CP2101:
2045 max = 921600;
2046 break;
2047 case CP210X_PARTNUM_CP2102:
2048 case CP210X_PARTNUM_CP2103:
2049 max = 1000000;
2050 break;
2051 case CP210X_PARTNUM_CP2104:
2052 use_actual_rate = true;
2053 max = 2000000;
2054 break;
2055 case CP210X_PARTNUM_CP2108:
2056 max = 2000000;
2057 break;
2058 case CP210X_PARTNUM_CP2105:
2059 if (cp210x_interface_num(serial) == 0) {
2060 use_actual_rate = true;
2061 max = 2000000;
2062 } else {
2063 min = 2400;
2064 max = 921600;
2065 }
2066 break;
2067 case CP210X_PARTNUM_CP2102N_QFN28:
2068 case CP210X_PARTNUM_CP2102N_QFN24:
2069 case CP210X_PARTNUM_CP2102N_QFN20:
2070 use_actual_rate = true;
2071 max = 3000000;
2072 break;
2073 default:
2074 max = 2000000;
2075 break;
2076 }
2077
2078 priv->min_speed = min;
2079 priv->max_speed = max;
2080 priv->use_actual_rate = use_actual_rate;
2081}
2082
2083static void cp2102_determine_quirks(struct usb_serial *serial)
2084{
2085 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2086 u8 *buf;
2087 int ret;
2088
2089 buf = kmalloc(2, GFP_KERNEL);
2090 if (!buf)
2091 return;
2092
2093
2094
2095
2096
2097
2098 ret = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
2099 CP210X_VENDOR_SPECIFIC, REQTYPE_DEVICE_TO_HOST,
2100 CP210X_GET_PARTNUM, 0, buf, 2, USB_CTRL_GET_TIMEOUT);
2101 if (ret == 1) {
2102 dev_dbg(&serial->interface->dev,
2103 "device does not support event-insertion mode\n");
2104 priv->no_event_mode = true;
2105 }
2106
2107 kfree(buf);
2108}
2109
2110static int cp210x_get_fw_version(struct usb_serial *serial, u16 value)
2111{
2112 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2113 u8 ver[3];
2114 int ret;
2115
2116 ret = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST, value,
2117 ver, sizeof(ver));
2118 if (ret)
2119 return ret;
2120
2121 dev_dbg(&serial->interface->dev, "%s - %d.%d.%d\n", __func__,
2122 ver[0], ver[1], ver[2]);
2123
2124 priv->fw_version = ver[0] << 16 | ver[1] << 8 | ver[2];
2125
2126 return 0;
2127}
2128
2129static void cp210x_determine_type(struct usb_serial *serial)
2130{
2131 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2132 int ret;
2133
2134 ret = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
2135 CP210X_GET_PARTNUM, &priv->partnum,
2136 sizeof(priv->partnum));
2137 if (ret < 0) {
2138 dev_warn(&serial->interface->dev,
2139 "querying part number failed\n");
2140 priv->partnum = CP210X_PARTNUM_UNKNOWN;
2141 return;
2142 }
2143
2144 dev_dbg(&serial->interface->dev, "partnum = 0x%02x\n", priv->partnum);
2145
2146 switch (priv->partnum) {
2147 case CP210X_PARTNUM_CP2102:
2148 cp2102_determine_quirks(serial);
2149 break;
2150 case CP210X_PARTNUM_CP2105:
2151 case CP210X_PARTNUM_CP2108:
2152 cp210x_get_fw_version(serial, CP210X_GET_FW_VER);
2153 break;
2154 case CP210X_PARTNUM_CP2102N_QFN28:
2155 case CP210X_PARTNUM_CP2102N_QFN24:
2156 case CP210X_PARTNUM_CP2102N_QFN20:
2157 ret = cp210x_get_fw_version(serial, CP210X_GET_FW_VER_2N);
2158 if (ret)
2159 break;
2160 if (priv->fw_version <= 0x10004)
2161 priv->no_flow_control = true;
2162 break;
2163 default:
2164 break;
2165 }
2166}
2167
2168static int cp210x_attach(struct usb_serial *serial)
2169{
2170 int result;
2171 struct cp210x_serial_private *priv;
2172
2173 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
2174 if (!priv)
2175 return -ENOMEM;
2176
2177 usb_set_serial_data(serial, priv);
2178
2179 cp210x_determine_type(serial);
2180 cp210x_init_max_speed(serial);
2181
2182 result = cp210x_gpio_init(serial);
2183 if (result < 0) {
2184 dev_err(&serial->interface->dev, "GPIO initialisation failed: %d\n",
2185 result);
2186 }
2187
2188 return 0;
2189}
2190
2191static void cp210x_disconnect(struct usb_serial *serial)
2192{
2193 cp210x_gpio_remove(serial);
2194}
2195
2196static void cp210x_release(struct usb_serial *serial)
2197{
2198 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
2199
2200 cp210x_gpio_remove(serial);
2201
2202 kfree(priv);
2203}
2204
2205module_usb_serial_driver(serial_drivers, id_table);
2206
2207MODULE_DESCRIPTION(DRIVER_DESC);
2208MODULE_LICENSE("GPL v2");
2209