This source file includes following definitions.
- cp210x_interface_num
- cp210x_read_reg_block
- cp210x_read_u32_reg
- cp210x_read_u16_reg
- cp210x_read_u8_reg
- cp210x_read_vendor_block
- cp210x_write_u16_reg
- cp210x_write_reg_block
- cp210x_write_u32_reg
- cp210x_write_vendor_block
- cp210x_detect_swapped_line_ctl
- cp210x_get_line_ctl
- cp210x_open
- cp210x_close
- cp210x_get_tx_queue_byte_count
- cp210x_tx_empty
- cp210x_get_termios
- cp210x_get_termios_port
- cp210x_get_an205_rate
- cp210x_get_actual_rate
- cp210x_change_speed
- cp210x_set_termios
- cp210x_tiocmset
- cp210x_tiocmset_port
- cp210x_dtr_rts
- cp210x_tiocmget
- cp210x_break_ctl
- cp210x_gpio_request
- cp210x_gpio_get
- cp210x_gpio_set
- cp210x_gpio_direction_get
- cp210x_gpio_direction_input
- cp210x_gpio_direction_output
- cp210x_gpio_set_config
- cp2105_gpioconf_init
- cp2104_gpioconf_init
- cp2102n_gpioconf_init
- cp210x_gpio_init
- cp210x_gpio_remove
- cp210x_gpio_init
- cp210x_gpio_remove
- cp210x_port_probe
- cp210x_port_remove
- cp210x_init_max_speed
- cp210x_attach
- cp210x_disconnect
- cp210x_release
1
2
3
4
5
6
7
8
9
10
11
12
13 #include <linux/kernel.h>
14 #include <linux/errno.h>
15 #include <linux/slab.h>
16 #include <linux/tty.h>
17 #include <linux/tty_flip.h>
18 #include <linux/module.h>
19 #include <linux/moduleparam.h>
20 #include <linux/usb.h>
21 #include <linux/uaccess.h>
22 #include <linux/usb/serial.h>
23 #include <linux/gpio/driver.h>
24 #include <linux/bitops.h>
25 #include <linux/mutex.h>
26
27 #define DRIVER_DESC "Silicon Labs CP210x RS232 serial adaptor driver"
28
29
30
31
32 static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *);
33 static void cp210x_close(struct usb_serial_port *);
34 static void cp210x_get_termios(struct tty_struct *, struct usb_serial_port *);
35 static void cp210x_get_termios_port(struct usb_serial_port *port,
36 tcflag_t *cflagp, unsigned int *baudp);
37 static void cp210x_change_speed(struct tty_struct *, struct usb_serial_port *,
38 struct ktermios *);
39 static void cp210x_set_termios(struct tty_struct *, struct usb_serial_port *,
40 struct ktermios*);
41 static bool cp210x_tx_empty(struct usb_serial_port *port);
42 static int cp210x_tiocmget(struct tty_struct *);
43 static int cp210x_tiocmset(struct tty_struct *, unsigned int, unsigned int);
44 static int cp210x_tiocmset_port(struct usb_serial_port *port,
45 unsigned int, unsigned int);
46 static void cp210x_break_ctl(struct tty_struct *, int);
47 static int cp210x_attach(struct usb_serial *);
48 static void cp210x_disconnect(struct usb_serial *);
49 static void cp210x_release(struct usb_serial *);
50 static int cp210x_port_probe(struct usb_serial_port *);
51 static int cp210x_port_remove(struct usb_serial_port *);
52 static void cp210x_dtr_rts(struct usb_serial_port *p, int on);
53
54 static const struct usb_device_id id_table[] = {
55 { USB_DEVICE(0x045B, 0x0053) },
56 { USB_DEVICE(0x0471, 0x066A) },
57 { USB_DEVICE(0x0489, 0xE000) },
58 { USB_DEVICE(0x0489, 0xE003) },
59 { USB_DEVICE(0x0745, 0x1000) },
60 { USB_DEVICE(0x0846, 0x1100) },
61 { USB_DEVICE(0x08e6, 0x5501) },
62 { USB_DEVICE(0x08FD, 0x000A) },
63 { USB_DEVICE(0x0908, 0x01FF) },
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, 0x88FB) },
149 { USB_DEVICE(0x10C4, 0x8938) },
150 { USB_DEVICE(0x10C4, 0x8946) },
151 { USB_DEVICE(0x10C4, 0x8962) },
152 { USB_DEVICE(0x10C4, 0x8977) },
153 { USB_DEVICE(0x10C4, 0x8998) },
154 { USB_DEVICE(0x10C4, 0x89A4) },
155 { USB_DEVICE(0x10C4, 0x89FB) },
156 { USB_DEVICE(0x10C4, 0x8A2A) },
157 { USB_DEVICE(0x10C4, 0x8A5E) },
158 { USB_DEVICE(0x10C4, 0x8B34) },
159 { USB_DEVICE(0x10C4, 0xEA60) },
160 { USB_DEVICE(0x10C4, 0xEA61) },
161 { USB_DEVICE(0x10C4, 0xEA63) },
162 { USB_DEVICE(0x10C4, 0xEA70) },
163 { USB_DEVICE(0x10C4, 0xEA71) },
164 { USB_DEVICE(0x10C4, 0xEA7A) },
165 { USB_DEVICE(0x10C4, 0xEA7B) },
166 { USB_DEVICE(0x10C4, 0xF001) },
167 { USB_DEVICE(0x10C4, 0xF002) },
168 { USB_DEVICE(0x10C4, 0xF003) },
169 { USB_DEVICE(0x10C4, 0xF004) },
170 { USB_DEVICE(0x10C5, 0xEA61) },
171 { USB_DEVICE(0x10CE, 0xEA6A) },
172 { USB_DEVICE(0x12B8, 0xEC60) },
173 { USB_DEVICE(0x12B8, 0xEC62) },
174 { USB_DEVICE(0x13AD, 0x9999) },
175 { USB_DEVICE(0x1555, 0x0004) },
176 { USB_DEVICE(0x155A, 0x1006) },
177 { USB_DEVICE(0x166A, 0x0201) },
178 { USB_DEVICE(0x166A, 0x0301) },
179 { USB_DEVICE(0x166A, 0x0303) },
180 { USB_DEVICE(0x166A, 0x0304) },
181 { USB_DEVICE(0x166A, 0x0305) },
182 { USB_DEVICE(0x166A, 0x0401) },
183 { USB_DEVICE(0x166A, 0x0101) },
184 { USB_DEVICE(0x16C0, 0x09B0) },
185 { USB_DEVICE(0x16C0, 0x09B1) },
186 { USB_DEVICE(0x16D6, 0x0001) },
187 { USB_DEVICE(0x16DC, 0x0010) },
188 { USB_DEVICE(0x16DC, 0x0011) },
189 { USB_DEVICE(0x16DC, 0x0012) },
190 { USB_DEVICE(0x16DC, 0x0015) },
191 { USB_DEVICE(0x17A8, 0x0001) },
192 { USB_DEVICE(0x17A8, 0x0005) },
193 { USB_DEVICE(0x17F4, 0xAAAA) },
194 { USB_DEVICE(0x1843, 0x0200) },
195 { USB_DEVICE(0x18EF, 0xE00F) },
196 { USB_DEVICE(0x18EF, 0xE025) },
197 { USB_DEVICE(0x18EF, 0xE030) },
198 { USB_DEVICE(0x18EF, 0xE032) },
199 { USB_DEVICE(0x1901, 0x0190) },
200 { USB_DEVICE(0x1901, 0x0193) },
201 { USB_DEVICE(0x1901, 0x0194) },
202 { USB_DEVICE(0x1901, 0x0195) },
203 { USB_DEVICE(0x1901, 0x0196) },
204 { USB_DEVICE(0x19CF, 0x3000) },
205 { USB_DEVICE(0x1ADB, 0x0001) },
206 { USB_DEVICE(0x1B1C, 0x1C00) },
207 { USB_DEVICE(0x1BA4, 0x0002) },
208 { USB_DEVICE(0x1BE3, 0x07A6) },
209 { USB_DEVICE(0x1D6F, 0x0010) },
210 { USB_DEVICE(0x1E29, 0x0102) },
211 { USB_DEVICE(0x1E29, 0x0501) },
212 { USB_DEVICE(0x1FB9, 0x0100) },
213 { USB_DEVICE(0x1FB9, 0x0200) },
214 { USB_DEVICE(0x1FB9, 0x0201) },
215 { USB_DEVICE(0x1FB9, 0x0202) },
216 { USB_DEVICE(0x1FB9, 0x0203) },
217 { USB_DEVICE(0x1FB9, 0x0300) },
218 { USB_DEVICE(0x1FB9, 0x0301) },
219 { USB_DEVICE(0x1FB9, 0x0302) },
220 { USB_DEVICE(0x1FB9, 0x0303) },
221 { USB_DEVICE(0x1FB9, 0x0400) },
222 { USB_DEVICE(0x1FB9, 0x0401) },
223 { USB_DEVICE(0x1FB9, 0x0402) },
224 { USB_DEVICE(0x1FB9, 0x0403) },
225 { USB_DEVICE(0x1FB9, 0x0404) },
226 { USB_DEVICE(0x1FB9, 0x0600) },
227 { USB_DEVICE(0x1FB9, 0x0601) },
228 { USB_DEVICE(0x1FB9, 0x0602) },
229 { USB_DEVICE(0x1FB9, 0x0700) },
230 { USB_DEVICE(0x1FB9, 0x0701) },
231 { USB_DEVICE(0x2626, 0xEA60) },
232 { USB_DEVICE(0x3195, 0xF190) },
233 { USB_DEVICE(0x3195, 0xF280) },
234 { USB_DEVICE(0x3195, 0xF281) },
235 { USB_DEVICE(0x3923, 0x7A0B) },
236 { USB_DEVICE(0x413C, 0x9500) },
237 { }
238 };
239
240 MODULE_DEVICE_TABLE(usb, id_table);
241
242 struct cp210x_serial_private {
243 #ifdef CONFIG_GPIOLIB
244 struct gpio_chip gc;
245 bool gpio_registered;
246 u8 gpio_pushpull;
247 u8 gpio_altfunc;
248 u8 gpio_input;
249 #endif
250 u8 partnum;
251 speed_t min_speed;
252 speed_t max_speed;
253 bool use_actual_rate;
254 };
255
256 struct cp210x_port_private {
257 __u8 bInterfaceNumber;
258 bool has_swapped_line_ctl;
259 };
260
261 static struct usb_serial_driver cp210x_device = {
262 .driver = {
263 .owner = THIS_MODULE,
264 .name = "cp210x",
265 },
266 .id_table = id_table,
267 .num_ports = 1,
268 .bulk_in_size = 256,
269 .bulk_out_size = 256,
270 .open = cp210x_open,
271 .close = cp210x_close,
272 .break_ctl = cp210x_break_ctl,
273 .set_termios = cp210x_set_termios,
274 .tx_empty = cp210x_tx_empty,
275 .tiocmget = cp210x_tiocmget,
276 .tiocmset = cp210x_tiocmset,
277 .attach = cp210x_attach,
278 .disconnect = cp210x_disconnect,
279 .release = cp210x_release,
280 .port_probe = cp210x_port_probe,
281 .port_remove = cp210x_port_remove,
282 .dtr_rts = cp210x_dtr_rts
283 };
284
285 static struct usb_serial_driver * const serial_drivers[] = {
286 &cp210x_device, NULL
287 };
288
289
290 #define REQTYPE_HOST_TO_INTERFACE 0x41
291 #define REQTYPE_INTERFACE_TO_HOST 0xc1
292 #define REQTYPE_HOST_TO_DEVICE 0x40
293 #define REQTYPE_DEVICE_TO_HOST 0xc0
294
295
296 #define CP210X_IFC_ENABLE 0x00
297 #define CP210X_SET_BAUDDIV 0x01
298 #define CP210X_GET_BAUDDIV 0x02
299 #define CP210X_SET_LINE_CTL 0x03
300 #define CP210X_GET_LINE_CTL 0x04
301 #define CP210X_SET_BREAK 0x05
302 #define CP210X_IMM_CHAR 0x06
303 #define CP210X_SET_MHS 0x07
304 #define CP210X_GET_MDMSTS 0x08
305 #define CP210X_SET_XON 0x09
306 #define CP210X_SET_XOFF 0x0A
307 #define CP210X_SET_EVENTMASK 0x0B
308 #define CP210X_GET_EVENTMASK 0x0C
309 #define CP210X_SET_CHAR 0x0D
310 #define CP210X_GET_CHARS 0x0E
311 #define CP210X_GET_PROPS 0x0F
312 #define CP210X_GET_COMM_STATUS 0x10
313 #define CP210X_RESET 0x11
314 #define CP210X_PURGE 0x12
315 #define CP210X_SET_FLOW 0x13
316 #define CP210X_GET_FLOW 0x14
317 #define CP210X_EMBED_EVENTS 0x15
318 #define CP210X_GET_EVENTSTATE 0x16
319 #define CP210X_SET_CHARS 0x19
320 #define CP210X_GET_BAUDRATE 0x1D
321 #define CP210X_SET_BAUDRATE 0x1E
322 #define CP210X_VENDOR_SPECIFIC 0xFF
323
324
325 #define UART_ENABLE 0x0001
326 #define UART_DISABLE 0x0000
327
328
329 #define BAUD_RATE_GEN_FREQ 0x384000
330
331
332 #define BITS_DATA_MASK 0X0f00
333 #define BITS_DATA_5 0X0500
334 #define BITS_DATA_6 0X0600
335 #define BITS_DATA_7 0X0700
336 #define BITS_DATA_8 0X0800
337 #define BITS_DATA_9 0X0900
338
339 #define BITS_PARITY_MASK 0x00f0
340 #define BITS_PARITY_NONE 0x0000
341 #define BITS_PARITY_ODD 0x0010
342 #define BITS_PARITY_EVEN 0x0020
343 #define BITS_PARITY_MARK 0x0030
344 #define BITS_PARITY_SPACE 0x0040
345
346 #define BITS_STOP_MASK 0x000f
347 #define BITS_STOP_1 0x0000
348 #define BITS_STOP_1_5 0x0001
349 #define BITS_STOP_2 0x0002
350
351
352 #define BREAK_ON 0x0001
353 #define BREAK_OFF 0x0000
354
355
356 #define CONTROL_DTR 0x0001
357 #define CONTROL_RTS 0x0002
358 #define CONTROL_CTS 0x0010
359 #define CONTROL_DSR 0x0020
360 #define CONTROL_RING 0x0040
361 #define CONTROL_DCD 0x0080
362 #define CONTROL_WRITE_DTR 0x0100
363 #define CONTROL_WRITE_RTS 0x0200
364
365
366 #define CP210X_READ_2NCONFIG 0x000E
367 #define CP210X_READ_LATCH 0x00C2
368 #define CP210X_GET_PARTNUM 0x370B
369 #define CP210X_GET_PORTCONFIG 0x370C
370 #define CP210X_GET_DEVICEMODE 0x3711
371 #define CP210X_WRITE_LATCH 0x37E1
372
373
374 #define CP210X_PARTNUM_CP2101 0x01
375 #define CP210X_PARTNUM_CP2102 0x02
376 #define CP210X_PARTNUM_CP2103 0x03
377 #define CP210X_PARTNUM_CP2104 0x04
378 #define CP210X_PARTNUM_CP2105 0x05
379 #define CP210X_PARTNUM_CP2108 0x08
380 #define CP210X_PARTNUM_CP2102N_QFN28 0x20
381 #define CP210X_PARTNUM_CP2102N_QFN24 0x21
382 #define CP210X_PARTNUM_CP2102N_QFN20 0x22
383 #define CP210X_PARTNUM_UNKNOWN 0xFF
384
385
386 struct cp210x_comm_status {
387 __le32 ulErrors;
388 __le32 ulHoldReasons;
389 __le32 ulAmountInInQueue;
390 __le32 ulAmountInOutQueue;
391 u8 bEofReceived;
392 u8 bWaitForImmediate;
393 u8 bReserved;
394 } __packed;
395
396
397
398
399
400
401
402 #define PURGE_ALL 0x000f
403
404
405 struct cp210x_flow_ctl {
406 __le32 ulControlHandshake;
407 __le32 ulFlowReplace;
408 __le32 ulXonLimit;
409 __le32 ulXoffLimit;
410 } __packed;
411
412
413 #define CP210X_SERIAL_DTR_MASK GENMASK(1, 0)
414 #define CP210X_SERIAL_DTR_SHIFT(_mode) (_mode)
415 #define CP210X_SERIAL_CTS_HANDSHAKE BIT(3)
416 #define CP210X_SERIAL_DSR_HANDSHAKE BIT(4)
417 #define CP210X_SERIAL_DCD_HANDSHAKE BIT(5)
418 #define CP210X_SERIAL_DSR_SENSITIVITY BIT(6)
419
420
421 #define CP210X_SERIAL_DTR_INACTIVE 0
422 #define CP210X_SERIAL_DTR_ACTIVE 1
423 #define CP210X_SERIAL_DTR_FLOW_CTL 2
424
425
426 #define CP210X_SERIAL_AUTO_TRANSMIT BIT(0)
427 #define CP210X_SERIAL_AUTO_RECEIVE BIT(1)
428 #define CP210X_SERIAL_ERROR_CHAR BIT(2)
429 #define CP210X_SERIAL_NULL_STRIPPING BIT(3)
430 #define CP210X_SERIAL_BREAK_CHAR BIT(4)
431 #define CP210X_SERIAL_RTS_MASK GENMASK(7, 6)
432 #define CP210X_SERIAL_RTS_SHIFT(_mode) (_mode << 6)
433 #define CP210X_SERIAL_XOFF_CONTINUE BIT(31)
434
435
436 #define CP210X_SERIAL_RTS_INACTIVE 0
437 #define CP210X_SERIAL_RTS_ACTIVE 1
438 #define CP210X_SERIAL_RTS_FLOW_CTL 2
439
440
441 struct cp210x_pin_mode {
442 u8 eci;
443 u8 sci;
444 } __packed;
445
446 #define CP210X_PIN_MODE_MODEM 0
447 #define CP210X_PIN_MODE_GPIO BIT(0)
448
449
450
451
452
453 struct cp210x_dual_port_config {
454 __le16 gpio_mode;
455 u8 __pad0[2];
456 __le16 reset_state;
457 u8 __pad1[4];
458 __le16 suspend_state;
459 u8 sci_cfg;
460 u8 eci_cfg;
461 u8 device_cfg;
462 } __packed;
463
464
465
466
467
468 struct cp210x_single_port_config {
469 __le16 gpio_mode;
470 u8 __pad0[2];
471 __le16 reset_state;
472 u8 __pad1[4];
473 __le16 suspend_state;
474 u8 device_cfg;
475 } __packed;
476
477
478 #define CP210X_SCI_GPIO_MODE_OFFSET 9
479 #define CP210X_SCI_GPIO_MODE_MASK GENMASK(11, 9)
480
481 #define CP210X_ECI_GPIO_MODE_OFFSET 2
482 #define CP210X_ECI_GPIO_MODE_MASK GENMASK(3, 2)
483
484 #define CP210X_GPIO_MODE_OFFSET 8
485 #define CP210X_GPIO_MODE_MASK GENMASK(11, 8)
486
487
488 #define CP2105_GPIO0_TXLED_MODE BIT(0)
489 #define CP2105_GPIO1_RXLED_MODE BIT(1)
490 #define CP2105_GPIO1_RS485_MODE BIT(2)
491
492
493 #define CP2104_GPIO0_TXLED_MODE BIT(0)
494 #define CP2104_GPIO1_RXLED_MODE BIT(1)
495 #define CP2104_GPIO2_RS485_MODE BIT(2)
496
497
498 #define CP210X_2NCONFIG_CONFIG_VERSION_IDX 2
499 #define CP210X_2NCONFIG_GPIO_MODE_IDX 581
500 #define CP210X_2NCONFIG_GPIO_RSTLATCH_IDX 587
501 #define CP210X_2NCONFIG_GPIO_CONTROL_IDX 600
502
503
504 struct cp210x_gpio_write {
505 u8 mask;
506 u8 state;
507 } __packed;
508
509
510
511
512 static u8 cp210x_interface_num(struct usb_serial *serial)
513 {
514 struct usb_host_interface *cur_altsetting;
515
516 cur_altsetting = serial->interface->cur_altsetting;
517
518 return cur_altsetting->desc.bInterfaceNumber;
519 }
520
521
522
523
524
525 static int cp210x_read_reg_block(struct usb_serial_port *port, u8 req,
526 void *buf, int bufsize)
527 {
528 struct usb_serial *serial = port->serial;
529 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
530 void *dmabuf;
531 int result;
532
533 dmabuf = kmalloc(bufsize, GFP_KERNEL);
534 if (!dmabuf) {
535
536
537
538
539 memset(buf, 0, bufsize);
540 return -ENOMEM;
541 }
542
543 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
544 req, REQTYPE_INTERFACE_TO_HOST, 0,
545 port_priv->bInterfaceNumber, dmabuf, bufsize,
546 USB_CTRL_SET_TIMEOUT);
547 if (result == bufsize) {
548 memcpy(buf, dmabuf, bufsize);
549 result = 0;
550 } else {
551 dev_err(&port->dev, "failed get req 0x%x size %d status: %d\n",
552 req, bufsize, result);
553 if (result >= 0)
554 result = -EIO;
555
556
557
558
559
560 memset(buf, 0, bufsize);
561 }
562
563 kfree(dmabuf);
564
565 return result;
566 }
567
568
569
570
571 static int cp210x_read_u32_reg(struct usb_serial_port *port, u8 req, u32 *val)
572 {
573 __le32 le32_val;
574 int err;
575
576 err = cp210x_read_reg_block(port, req, &le32_val, sizeof(le32_val));
577 if (err) {
578
579
580
581
582 *val = 0;
583 return err;
584 }
585
586 *val = le32_to_cpu(le32_val);
587
588 return 0;
589 }
590
591
592
593
594 static int cp210x_read_u16_reg(struct usb_serial_port *port, u8 req, u16 *val)
595 {
596 __le16 le16_val;
597 int err;
598
599 err = cp210x_read_reg_block(port, req, &le16_val, sizeof(le16_val));
600 if (err)
601 return err;
602
603 *val = le16_to_cpu(le16_val);
604
605 return 0;
606 }
607
608
609
610
611 static int cp210x_read_u8_reg(struct usb_serial_port *port, u8 req, u8 *val)
612 {
613 return cp210x_read_reg_block(port, req, val, sizeof(*val));
614 }
615
616
617
618
619
620 static int cp210x_read_vendor_block(struct usb_serial *serial, u8 type, u16 val,
621 void *buf, int bufsize)
622 {
623 void *dmabuf;
624 int result;
625
626 dmabuf = kmalloc(bufsize, GFP_KERNEL);
627 if (!dmabuf)
628 return -ENOMEM;
629
630 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
631 CP210X_VENDOR_SPECIFIC, type, val,
632 cp210x_interface_num(serial), dmabuf, bufsize,
633 USB_CTRL_GET_TIMEOUT);
634 if (result == bufsize) {
635 memcpy(buf, dmabuf, bufsize);
636 result = 0;
637 } else {
638 dev_err(&serial->interface->dev,
639 "failed to get vendor val 0x%04x size %d: %d\n", val,
640 bufsize, result);
641 if (result >= 0)
642 result = -EIO;
643 }
644
645 kfree(dmabuf);
646
647 return result;
648 }
649
650
651
652
653
654 static int cp210x_write_u16_reg(struct usb_serial_port *port, u8 req, u16 val)
655 {
656 struct usb_serial *serial = port->serial;
657 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
658 int result;
659
660 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
661 req, REQTYPE_HOST_TO_INTERFACE, val,
662 port_priv->bInterfaceNumber, NULL, 0,
663 USB_CTRL_SET_TIMEOUT);
664 if (result < 0) {
665 dev_err(&port->dev, "failed set request 0x%x status: %d\n",
666 req, result);
667 }
668
669 return result;
670 }
671
672
673
674
675
676 static int cp210x_write_reg_block(struct usb_serial_port *port, u8 req,
677 void *buf, int bufsize)
678 {
679 struct usb_serial *serial = port->serial;
680 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
681 void *dmabuf;
682 int result;
683
684 dmabuf = kmemdup(buf, bufsize, GFP_KERNEL);
685 if (!dmabuf)
686 return -ENOMEM;
687
688 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
689 req, REQTYPE_HOST_TO_INTERFACE, 0,
690 port_priv->bInterfaceNumber, dmabuf, bufsize,
691 USB_CTRL_SET_TIMEOUT);
692
693 kfree(dmabuf);
694
695 if (result == bufsize) {
696 result = 0;
697 } else {
698 dev_err(&port->dev, "failed set req 0x%x size %d status: %d\n",
699 req, bufsize, result);
700 if (result >= 0)
701 result = -EIO;
702 }
703
704 return result;
705 }
706
707
708
709
710 static int cp210x_write_u32_reg(struct usb_serial_port *port, u8 req, u32 val)
711 {
712 __le32 le32_val;
713
714 le32_val = cpu_to_le32(val);
715
716 return cp210x_write_reg_block(port, req, &le32_val, sizeof(le32_val));
717 }
718
719 #ifdef CONFIG_GPIOLIB
720
721
722
723
724 static int cp210x_write_vendor_block(struct usb_serial *serial, u8 type,
725 u16 val, void *buf, int bufsize)
726 {
727 void *dmabuf;
728 int result;
729
730 dmabuf = kmemdup(buf, bufsize, GFP_KERNEL);
731 if (!dmabuf)
732 return -ENOMEM;
733
734 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
735 CP210X_VENDOR_SPECIFIC, type, val,
736 cp210x_interface_num(serial), dmabuf, bufsize,
737 USB_CTRL_SET_TIMEOUT);
738
739 kfree(dmabuf);
740
741 if (result == bufsize) {
742 result = 0;
743 } else {
744 dev_err(&serial->interface->dev,
745 "failed to set vendor val 0x%04x size %d: %d\n", val,
746 bufsize, result);
747 if (result >= 0)
748 result = -EIO;
749 }
750
751 return result;
752 }
753 #endif
754
755
756
757
758
759
760
761 static int cp210x_detect_swapped_line_ctl(struct usb_serial_port *port)
762 {
763 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
764 u16 line_ctl_save;
765 u16 line_ctl_test;
766 int err;
767
768 err = cp210x_read_u16_reg(port, CP210X_GET_LINE_CTL, &line_ctl_save);
769 if (err)
770 return err;
771
772 err = cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, 0x800);
773 if (err)
774 return err;
775
776 err = cp210x_read_u16_reg(port, CP210X_GET_LINE_CTL, &line_ctl_test);
777 if (err)
778 return err;
779
780 if (line_ctl_test == 8) {
781 port_priv->has_swapped_line_ctl = true;
782 line_ctl_save = swab16(line_ctl_save);
783 }
784
785 return cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, line_ctl_save);
786 }
787
788
789
790
791
792 static int cp210x_get_line_ctl(struct usb_serial_port *port, u16 *ctl)
793 {
794 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
795 int err;
796
797 err = cp210x_read_u16_reg(port, CP210X_GET_LINE_CTL, ctl);
798 if (err)
799 return err;
800
801
802 if (port_priv->has_swapped_line_ctl)
803 *ctl = swab16(*ctl);
804
805 return 0;
806 }
807
808 static int cp210x_open(struct tty_struct *tty, struct usb_serial_port *port)
809 {
810 int result;
811
812 result = cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_ENABLE);
813 if (result) {
814 dev_err(&port->dev, "%s - Unable to enable UART\n", __func__);
815 return result;
816 }
817
818
819 cp210x_get_termios(tty, port);
820
821
822 if (tty)
823 cp210x_change_speed(tty, port, NULL);
824
825 return usb_serial_generic_open(tty, port);
826 }
827
828 static void cp210x_close(struct usb_serial_port *port)
829 {
830 usb_serial_generic_close(port);
831
832
833 cp210x_write_u16_reg(port, CP210X_PURGE, PURGE_ALL);
834
835 cp210x_write_u16_reg(port, CP210X_IFC_ENABLE, UART_DISABLE);
836 }
837
838
839
840
841 static int cp210x_get_tx_queue_byte_count(struct usb_serial_port *port,
842 u32 *count)
843 {
844 struct usb_serial *serial = port->serial;
845 struct cp210x_port_private *port_priv = usb_get_serial_port_data(port);
846 struct cp210x_comm_status *sts;
847 int result;
848
849 sts = kmalloc(sizeof(*sts), GFP_KERNEL);
850 if (!sts)
851 return -ENOMEM;
852
853 result = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
854 CP210X_GET_COMM_STATUS, REQTYPE_INTERFACE_TO_HOST,
855 0, port_priv->bInterfaceNumber, sts, sizeof(*sts),
856 USB_CTRL_GET_TIMEOUT);
857 if (result == sizeof(*sts)) {
858 *count = le32_to_cpu(sts->ulAmountInOutQueue);
859 result = 0;
860 } else {
861 dev_err(&port->dev, "failed to get comm status: %d\n", result);
862 if (result >= 0)
863 result = -EIO;
864 }
865
866 kfree(sts);
867
868 return result;
869 }
870
871 static bool cp210x_tx_empty(struct usb_serial_port *port)
872 {
873 int err;
874 u32 count;
875
876 err = cp210x_get_tx_queue_byte_count(port, &count);
877 if (err)
878 return true;
879
880 return !count;
881 }
882
883
884
885
886
887
888
889 static void cp210x_get_termios(struct tty_struct *tty,
890 struct usb_serial_port *port)
891 {
892 unsigned int baud;
893
894 if (tty) {
895 cp210x_get_termios_port(tty->driver_data,
896 &tty->termios.c_cflag, &baud);
897 tty_encode_baud_rate(tty, baud, baud);
898 } else {
899 tcflag_t cflag;
900 cflag = 0;
901 cp210x_get_termios_port(port, &cflag, &baud);
902 }
903 }
904
905
906
907
908
909 static void cp210x_get_termios_port(struct usb_serial_port *port,
910 tcflag_t *cflagp, unsigned int *baudp)
911 {
912 struct device *dev = &port->dev;
913 tcflag_t cflag;
914 struct cp210x_flow_ctl flow_ctl;
915 u32 baud;
916 u16 bits;
917 u32 ctl_hs;
918
919 cp210x_read_u32_reg(port, CP210X_GET_BAUDRATE, &baud);
920
921 dev_dbg(dev, "%s - baud rate = %d\n", __func__, baud);
922 *baudp = baud;
923
924 cflag = *cflagp;
925
926 cp210x_get_line_ctl(port, &bits);
927 cflag &= ~CSIZE;
928 switch (bits & BITS_DATA_MASK) {
929 case BITS_DATA_5:
930 dev_dbg(dev, "%s - data bits = 5\n", __func__);
931 cflag |= CS5;
932 break;
933 case BITS_DATA_6:
934 dev_dbg(dev, "%s - data bits = 6\n", __func__);
935 cflag |= CS6;
936 break;
937 case BITS_DATA_7:
938 dev_dbg(dev, "%s - data bits = 7\n", __func__);
939 cflag |= CS7;
940 break;
941 case BITS_DATA_8:
942 dev_dbg(dev, "%s - data bits = 8\n", __func__);
943 cflag |= CS8;
944 break;
945 case BITS_DATA_9:
946 dev_dbg(dev, "%s - data bits = 9 (not supported, using 8 data bits)\n", __func__);
947 cflag |= CS8;
948 bits &= ~BITS_DATA_MASK;
949 bits |= BITS_DATA_8;
950 cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
951 break;
952 default:
953 dev_dbg(dev, "%s - Unknown number of data bits, using 8\n", __func__);
954 cflag |= CS8;
955 bits &= ~BITS_DATA_MASK;
956 bits |= BITS_DATA_8;
957 cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
958 break;
959 }
960
961 switch (bits & BITS_PARITY_MASK) {
962 case BITS_PARITY_NONE:
963 dev_dbg(dev, "%s - parity = NONE\n", __func__);
964 cflag &= ~PARENB;
965 break;
966 case BITS_PARITY_ODD:
967 dev_dbg(dev, "%s - parity = ODD\n", __func__);
968 cflag |= (PARENB|PARODD);
969 break;
970 case BITS_PARITY_EVEN:
971 dev_dbg(dev, "%s - parity = EVEN\n", __func__);
972 cflag &= ~PARODD;
973 cflag |= PARENB;
974 break;
975 case BITS_PARITY_MARK:
976 dev_dbg(dev, "%s - parity = MARK\n", __func__);
977 cflag |= (PARENB|PARODD|CMSPAR);
978 break;
979 case BITS_PARITY_SPACE:
980 dev_dbg(dev, "%s - parity = SPACE\n", __func__);
981 cflag &= ~PARODD;
982 cflag |= (PARENB|CMSPAR);
983 break;
984 default:
985 dev_dbg(dev, "%s - Unknown parity mode, disabling parity\n", __func__);
986 cflag &= ~PARENB;
987 bits &= ~BITS_PARITY_MASK;
988 cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
989 break;
990 }
991
992 cflag &= ~CSTOPB;
993 switch (bits & BITS_STOP_MASK) {
994 case BITS_STOP_1:
995 dev_dbg(dev, "%s - stop bits = 1\n", __func__);
996 break;
997 case BITS_STOP_1_5:
998 dev_dbg(dev, "%s - stop bits = 1.5 (not supported, using 1 stop bit)\n", __func__);
999 bits &= ~BITS_STOP_MASK;
1000 cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
1001 break;
1002 case BITS_STOP_2:
1003 dev_dbg(dev, "%s - stop bits = 2\n", __func__);
1004 cflag |= CSTOPB;
1005 break;
1006 default:
1007 dev_dbg(dev, "%s - Unknown number of stop bits, using 1 stop bit\n", __func__);
1008 bits &= ~BITS_STOP_MASK;
1009 cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits);
1010 break;
1011 }
1012
1013 cp210x_read_reg_block(port, CP210X_GET_FLOW, &flow_ctl,
1014 sizeof(flow_ctl));
1015 ctl_hs = le32_to_cpu(flow_ctl.ulControlHandshake);
1016 if (ctl_hs & CP210X_SERIAL_CTS_HANDSHAKE) {
1017 dev_dbg(dev, "%s - flow control = CRTSCTS\n", __func__);
1018 cflag |= CRTSCTS;
1019 } else {
1020 dev_dbg(dev, "%s - flow control = NONE\n", __func__);
1021 cflag &= ~CRTSCTS;
1022 }
1023
1024 *cflagp = cflag;
1025 }
1026
1027 struct cp210x_rate {
1028 speed_t rate;
1029 speed_t high;
1030 };
1031
1032 static const struct cp210x_rate cp210x_an205_table1[] = {
1033 { 300, 300 },
1034 { 600, 600 },
1035 { 1200, 1200 },
1036 { 1800, 1800 },
1037 { 2400, 2400 },
1038 { 4000, 4000 },
1039 { 4800, 4803 },
1040 { 7200, 7207 },
1041 { 9600, 9612 },
1042 { 14400, 14428 },
1043 { 16000, 16062 },
1044 { 19200, 19250 },
1045 { 28800, 28912 },
1046 { 38400, 38601 },
1047 { 51200, 51558 },
1048 { 56000, 56280 },
1049 { 57600, 58053 },
1050 { 64000, 64111 },
1051 { 76800, 77608 },
1052 { 115200, 117028 },
1053 { 128000, 129347 },
1054 { 153600, 156868 },
1055 { 230400, 237832 },
1056 { 250000, 254234 },
1057 { 256000, 273066 },
1058 { 460800, 491520 },
1059 { 500000, 567138 },
1060 { 576000, 670254 },
1061 { 921600, UINT_MAX }
1062 };
1063
1064
1065
1066
1067 static speed_t cp210x_get_an205_rate(speed_t baud)
1068 {
1069 int i;
1070
1071 for (i = 0; i < ARRAY_SIZE(cp210x_an205_table1); ++i) {
1072 if (baud <= cp210x_an205_table1[i].high)
1073 break;
1074 }
1075
1076 return cp210x_an205_table1[i].rate;
1077 }
1078
1079 static speed_t cp210x_get_actual_rate(speed_t baud)
1080 {
1081 unsigned int prescale = 1;
1082 unsigned int div;
1083
1084 if (baud <= 365)
1085 prescale = 4;
1086
1087 div = DIV_ROUND_CLOSEST(48000000, 2 * prescale * baud);
1088 baud = 48000000 / (2 * prescale * div);
1089
1090 return baud;
1091 }
1092
1093
1094
1095
1096
1097
1098
1099
1100
1101
1102
1103
1104
1105
1106
1107
1108
1109
1110
1111
1112
1113
1114
1115
1116
1117
1118
1119 static void cp210x_change_speed(struct tty_struct *tty,
1120 struct usb_serial_port *port, struct ktermios *old_termios)
1121 {
1122 struct usb_serial *serial = port->serial;
1123 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1124 u32 baud;
1125
1126
1127
1128
1129
1130
1131
1132 baud = clamp(tty->termios.c_ospeed, priv->min_speed, priv->max_speed);
1133
1134 if (priv->use_actual_rate)
1135 baud = cp210x_get_actual_rate(baud);
1136 else if (baud < 1000000)
1137 baud = cp210x_get_an205_rate(baud);
1138
1139 dev_dbg(&port->dev, "%s - setting baud rate to %u\n", __func__, baud);
1140 if (cp210x_write_u32_reg(port, CP210X_SET_BAUDRATE, baud)) {
1141 dev_warn(&port->dev, "failed to set baud rate to %u\n", baud);
1142 if (old_termios)
1143 baud = old_termios->c_ospeed;
1144 else
1145 baud = 9600;
1146 }
1147
1148 tty_encode_baud_rate(tty, baud, baud);
1149 }
1150
1151 static void cp210x_set_termios(struct tty_struct *tty,
1152 struct usb_serial_port *port, struct ktermios *old_termios)
1153 {
1154 struct device *dev = &port->dev;
1155 unsigned int cflag, old_cflag;
1156 u16 bits;
1157
1158 cflag = tty->termios.c_cflag;
1159 old_cflag = old_termios->c_cflag;
1160
1161 if (tty->termios.c_ospeed != old_termios->c_ospeed)
1162 cp210x_change_speed(tty, port, old_termios);
1163
1164
1165 if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
1166 cp210x_get_line_ctl(port, &bits);
1167 bits &= ~BITS_DATA_MASK;
1168 switch (cflag & CSIZE) {
1169 case CS5:
1170 bits |= BITS_DATA_5;
1171 dev_dbg(dev, "%s - data bits = 5\n", __func__);
1172 break;
1173 case CS6:
1174 bits |= BITS_DATA_6;
1175 dev_dbg(dev, "%s - data bits = 6\n", __func__);
1176 break;
1177 case CS7:
1178 bits |= BITS_DATA_7;
1179 dev_dbg(dev, "%s - data bits = 7\n", __func__);
1180 break;
1181 case CS8:
1182 default:
1183 bits |= BITS_DATA_8;
1184 dev_dbg(dev, "%s - data bits = 8\n", __func__);
1185 break;
1186 }
1187 if (cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits))
1188 dev_dbg(dev, "Number of data bits requested not supported by device\n");
1189 }
1190
1191 if ((cflag & (PARENB|PARODD|CMSPAR)) !=
1192 (old_cflag & (PARENB|PARODD|CMSPAR))) {
1193 cp210x_get_line_ctl(port, &bits);
1194 bits &= ~BITS_PARITY_MASK;
1195 if (cflag & PARENB) {
1196 if (cflag & CMSPAR) {
1197 if (cflag & PARODD) {
1198 bits |= BITS_PARITY_MARK;
1199 dev_dbg(dev, "%s - parity = MARK\n", __func__);
1200 } else {
1201 bits |= BITS_PARITY_SPACE;
1202 dev_dbg(dev, "%s - parity = SPACE\n", __func__);
1203 }
1204 } else {
1205 if (cflag & PARODD) {
1206 bits |= BITS_PARITY_ODD;
1207 dev_dbg(dev, "%s - parity = ODD\n", __func__);
1208 } else {
1209 bits |= BITS_PARITY_EVEN;
1210 dev_dbg(dev, "%s - parity = EVEN\n", __func__);
1211 }
1212 }
1213 }
1214 if (cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits))
1215 dev_dbg(dev, "Parity mode not supported by device\n");
1216 }
1217
1218 if ((cflag & CSTOPB) != (old_cflag & CSTOPB)) {
1219 cp210x_get_line_ctl(port, &bits);
1220 bits &= ~BITS_STOP_MASK;
1221 if (cflag & CSTOPB) {
1222 bits |= BITS_STOP_2;
1223 dev_dbg(dev, "%s - stop bits = 2\n", __func__);
1224 } else {
1225 bits |= BITS_STOP_1;
1226 dev_dbg(dev, "%s - stop bits = 1\n", __func__);
1227 }
1228 if (cp210x_write_u16_reg(port, CP210X_SET_LINE_CTL, bits))
1229 dev_dbg(dev, "Number of stop bits requested not supported by device\n");
1230 }
1231
1232 if ((cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
1233 struct cp210x_flow_ctl flow_ctl;
1234 u32 ctl_hs;
1235 u32 flow_repl;
1236
1237 cp210x_read_reg_block(port, CP210X_GET_FLOW, &flow_ctl,
1238 sizeof(flow_ctl));
1239 ctl_hs = le32_to_cpu(flow_ctl.ulControlHandshake);
1240 flow_repl = le32_to_cpu(flow_ctl.ulFlowReplace);
1241 dev_dbg(dev, "%s - read ulControlHandshake=0x%08x, ulFlowReplace=0x%08x\n",
1242 __func__, ctl_hs, flow_repl);
1243
1244 ctl_hs &= ~CP210X_SERIAL_DSR_HANDSHAKE;
1245 ctl_hs &= ~CP210X_SERIAL_DCD_HANDSHAKE;
1246 ctl_hs &= ~CP210X_SERIAL_DSR_SENSITIVITY;
1247 ctl_hs &= ~CP210X_SERIAL_DTR_MASK;
1248 ctl_hs |= CP210X_SERIAL_DTR_SHIFT(CP210X_SERIAL_DTR_ACTIVE);
1249 if (cflag & CRTSCTS) {
1250 ctl_hs |= CP210X_SERIAL_CTS_HANDSHAKE;
1251
1252 flow_repl &= ~CP210X_SERIAL_RTS_MASK;
1253 flow_repl |= CP210X_SERIAL_RTS_SHIFT(
1254 CP210X_SERIAL_RTS_FLOW_CTL);
1255 dev_dbg(dev, "%s - flow control = CRTSCTS\n", __func__);
1256 } else {
1257 ctl_hs &= ~CP210X_SERIAL_CTS_HANDSHAKE;
1258
1259 flow_repl &= ~CP210X_SERIAL_RTS_MASK;
1260 flow_repl |= CP210X_SERIAL_RTS_SHIFT(
1261 CP210X_SERIAL_RTS_ACTIVE);
1262 dev_dbg(dev, "%s - flow control = NONE\n", __func__);
1263 }
1264
1265 dev_dbg(dev, "%s - write ulControlHandshake=0x%08x, ulFlowReplace=0x%08x\n",
1266 __func__, ctl_hs, flow_repl);
1267 flow_ctl.ulControlHandshake = cpu_to_le32(ctl_hs);
1268 flow_ctl.ulFlowReplace = cpu_to_le32(flow_repl);
1269 cp210x_write_reg_block(port, CP210X_SET_FLOW, &flow_ctl,
1270 sizeof(flow_ctl));
1271 }
1272
1273 }
1274
1275 static int cp210x_tiocmset(struct tty_struct *tty,
1276 unsigned int set, unsigned int clear)
1277 {
1278 struct usb_serial_port *port = tty->driver_data;
1279 return cp210x_tiocmset_port(port, set, clear);
1280 }
1281
1282 static int cp210x_tiocmset_port(struct usb_serial_port *port,
1283 unsigned int set, unsigned int clear)
1284 {
1285 u16 control = 0;
1286
1287 if (set & TIOCM_RTS) {
1288 control |= CONTROL_RTS;
1289 control |= CONTROL_WRITE_RTS;
1290 }
1291 if (set & TIOCM_DTR) {
1292 control |= CONTROL_DTR;
1293 control |= CONTROL_WRITE_DTR;
1294 }
1295 if (clear & TIOCM_RTS) {
1296 control &= ~CONTROL_RTS;
1297 control |= CONTROL_WRITE_RTS;
1298 }
1299 if (clear & TIOCM_DTR) {
1300 control &= ~CONTROL_DTR;
1301 control |= CONTROL_WRITE_DTR;
1302 }
1303
1304 dev_dbg(&port->dev, "%s - control = 0x%.4x\n", __func__, control);
1305
1306 return cp210x_write_u16_reg(port, CP210X_SET_MHS, control);
1307 }
1308
1309 static void cp210x_dtr_rts(struct usb_serial_port *p, int on)
1310 {
1311 if (on)
1312 cp210x_tiocmset_port(p, TIOCM_DTR|TIOCM_RTS, 0);
1313 else
1314 cp210x_tiocmset_port(p, 0, TIOCM_DTR|TIOCM_RTS);
1315 }
1316
1317 static int cp210x_tiocmget(struct tty_struct *tty)
1318 {
1319 struct usb_serial_port *port = tty->driver_data;
1320 u8 control;
1321 int result;
1322
1323 result = cp210x_read_u8_reg(port, CP210X_GET_MDMSTS, &control);
1324 if (result)
1325 return result;
1326
1327 result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
1328 |((control & CONTROL_RTS) ? TIOCM_RTS : 0)
1329 |((control & CONTROL_CTS) ? TIOCM_CTS : 0)
1330 |((control & CONTROL_DSR) ? TIOCM_DSR : 0)
1331 |((control & CONTROL_RING)? TIOCM_RI : 0)
1332 |((control & CONTROL_DCD) ? TIOCM_CD : 0);
1333
1334 dev_dbg(&port->dev, "%s - control = 0x%.2x\n", __func__, control);
1335
1336 return result;
1337 }
1338
1339 static void cp210x_break_ctl(struct tty_struct *tty, int break_state)
1340 {
1341 struct usb_serial_port *port = tty->driver_data;
1342 u16 state;
1343
1344 if (break_state == 0)
1345 state = BREAK_OFF;
1346 else
1347 state = BREAK_ON;
1348 dev_dbg(&port->dev, "%s - turning break %s\n", __func__,
1349 state == BREAK_OFF ? "off" : "on");
1350 cp210x_write_u16_reg(port, CP210X_SET_BREAK, state);
1351 }
1352
1353 #ifdef CONFIG_GPIOLIB
1354 static int cp210x_gpio_request(struct gpio_chip *gc, unsigned int offset)
1355 {
1356 struct usb_serial *serial = gpiochip_get_data(gc);
1357 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1358
1359 if (priv->gpio_altfunc & BIT(offset))
1360 return -ENODEV;
1361
1362 return 0;
1363 }
1364
1365 static int cp210x_gpio_get(struct gpio_chip *gc, unsigned int gpio)
1366 {
1367 struct usb_serial *serial = gpiochip_get_data(gc);
1368 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1369 u8 req_type = REQTYPE_DEVICE_TO_HOST;
1370 int result;
1371 u8 buf;
1372
1373 if (priv->partnum == CP210X_PARTNUM_CP2105)
1374 req_type = REQTYPE_INTERFACE_TO_HOST;
1375
1376 result = usb_autopm_get_interface(serial->interface);
1377 if (result)
1378 return result;
1379
1380 result = cp210x_read_vendor_block(serial, req_type,
1381 CP210X_READ_LATCH, &buf, sizeof(buf));
1382 usb_autopm_put_interface(serial->interface);
1383 if (result < 0)
1384 return result;
1385
1386 return !!(buf & BIT(gpio));
1387 }
1388
1389 static void cp210x_gpio_set(struct gpio_chip *gc, unsigned int gpio, int value)
1390 {
1391 struct usb_serial *serial = gpiochip_get_data(gc);
1392 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1393 struct cp210x_gpio_write buf;
1394 int result;
1395
1396 if (value == 1)
1397 buf.state = BIT(gpio);
1398 else
1399 buf.state = 0;
1400
1401 buf.mask = BIT(gpio);
1402
1403 result = usb_autopm_get_interface(serial->interface);
1404 if (result)
1405 goto out;
1406
1407 if (priv->partnum == CP210X_PARTNUM_CP2105) {
1408 result = cp210x_write_vendor_block(serial,
1409 REQTYPE_HOST_TO_INTERFACE,
1410 CP210X_WRITE_LATCH, &buf,
1411 sizeof(buf));
1412 } else {
1413 u16 wIndex = buf.state << 8 | buf.mask;
1414
1415 result = usb_control_msg(serial->dev,
1416 usb_sndctrlpipe(serial->dev, 0),
1417 CP210X_VENDOR_SPECIFIC,
1418 REQTYPE_HOST_TO_DEVICE,
1419 CP210X_WRITE_LATCH,
1420 wIndex,
1421 NULL, 0, USB_CTRL_SET_TIMEOUT);
1422 }
1423
1424 usb_autopm_put_interface(serial->interface);
1425 out:
1426 if (result < 0) {
1427 dev_err(&serial->interface->dev, "failed to set GPIO value: %d\n",
1428 result);
1429 }
1430 }
1431
1432 static int cp210x_gpio_direction_get(struct gpio_chip *gc, unsigned int gpio)
1433 {
1434 struct usb_serial *serial = gpiochip_get_data(gc);
1435 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1436
1437 return priv->gpio_input & BIT(gpio);
1438 }
1439
1440 static int cp210x_gpio_direction_input(struct gpio_chip *gc, unsigned int gpio)
1441 {
1442 struct usb_serial *serial = gpiochip_get_data(gc);
1443 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1444
1445 if (priv->partnum == CP210X_PARTNUM_CP2105) {
1446
1447 return -ENOTSUPP;
1448 }
1449
1450
1451 if (priv->gpio_pushpull & BIT(gpio))
1452 return -EINVAL;
1453
1454
1455 cp210x_gpio_set(gc, gpio, 1);
1456
1457 priv->gpio_input |= BIT(gpio);
1458
1459 return 0;
1460 }
1461
1462 static int cp210x_gpio_direction_output(struct gpio_chip *gc, unsigned int gpio,
1463 int value)
1464 {
1465 struct usb_serial *serial = gpiochip_get_data(gc);
1466 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1467
1468 priv->gpio_input &= ~BIT(gpio);
1469 cp210x_gpio_set(gc, gpio, value);
1470
1471 return 0;
1472 }
1473
1474 static int cp210x_gpio_set_config(struct gpio_chip *gc, unsigned int gpio,
1475 unsigned long config)
1476 {
1477 struct usb_serial *serial = gpiochip_get_data(gc);
1478 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1479 enum pin_config_param param = pinconf_to_config_param(config);
1480
1481
1482 if ((param == PIN_CONFIG_DRIVE_PUSH_PULL) &&
1483 (priv->gpio_pushpull & BIT(gpio)))
1484 return 0;
1485
1486 if ((param == PIN_CONFIG_DRIVE_OPEN_DRAIN) &&
1487 !(priv->gpio_pushpull & BIT(gpio)))
1488 return 0;
1489
1490 return -ENOTSUPP;
1491 }
1492
1493
1494
1495
1496
1497
1498
1499
1500 static int cp2105_gpioconf_init(struct usb_serial *serial)
1501 {
1502 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1503 struct cp210x_pin_mode mode;
1504 struct cp210x_dual_port_config config;
1505 u8 intf_num = cp210x_interface_num(serial);
1506 u8 iface_config;
1507 int result;
1508
1509 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1510 CP210X_GET_DEVICEMODE, &mode,
1511 sizeof(mode));
1512 if (result < 0)
1513 return result;
1514
1515 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1516 CP210X_GET_PORTCONFIG, &config,
1517 sizeof(config));
1518 if (result < 0)
1519 return result;
1520
1521
1522 if (intf_num == 0) {
1523 if (mode.eci == CP210X_PIN_MODE_MODEM) {
1524
1525 priv->gpio_altfunc = 0xff;
1526 return 0;
1527 }
1528
1529 iface_config = config.eci_cfg;
1530 priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1531 CP210X_ECI_GPIO_MODE_MASK) >>
1532 CP210X_ECI_GPIO_MODE_OFFSET);
1533 priv->gc.ngpio = 2;
1534 } else if (intf_num == 1) {
1535 if (mode.sci == CP210X_PIN_MODE_MODEM) {
1536
1537 priv->gpio_altfunc = 0xff;
1538 return 0;
1539 }
1540
1541 iface_config = config.sci_cfg;
1542 priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1543 CP210X_SCI_GPIO_MODE_MASK) >>
1544 CP210X_SCI_GPIO_MODE_OFFSET);
1545 priv->gc.ngpio = 3;
1546 } else {
1547 return -ENODEV;
1548 }
1549
1550
1551 if (iface_config & CP2105_GPIO0_TXLED_MODE)
1552 priv->gpio_altfunc |= BIT(0);
1553 if (iface_config & (CP2105_GPIO1_RXLED_MODE |
1554 CP2105_GPIO1_RS485_MODE))
1555 priv->gpio_altfunc |= BIT(1);
1556
1557
1558 priv->gpio_input = 0;
1559
1560 return 0;
1561 }
1562
1563 static int cp2104_gpioconf_init(struct usb_serial *serial)
1564 {
1565 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1566 struct cp210x_single_port_config config;
1567 u8 iface_config;
1568 u8 gpio_latch;
1569 int result;
1570 u8 i;
1571
1572 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1573 CP210X_GET_PORTCONFIG, &config,
1574 sizeof(config));
1575 if (result < 0)
1576 return result;
1577
1578 priv->gc.ngpio = 4;
1579
1580 iface_config = config.device_cfg;
1581 priv->gpio_pushpull = (u8)((le16_to_cpu(config.gpio_mode) &
1582 CP210X_GPIO_MODE_MASK) >>
1583 CP210X_GPIO_MODE_OFFSET);
1584 gpio_latch = (u8)((le16_to_cpu(config.reset_state) &
1585 CP210X_GPIO_MODE_MASK) >>
1586 CP210X_GPIO_MODE_OFFSET);
1587
1588
1589 if (iface_config & CP2104_GPIO0_TXLED_MODE)
1590 priv->gpio_altfunc |= BIT(0);
1591 if (iface_config & CP2104_GPIO1_RXLED_MODE)
1592 priv->gpio_altfunc |= BIT(1);
1593 if (iface_config & CP2104_GPIO2_RS485_MODE)
1594 priv->gpio_altfunc |= BIT(2);
1595
1596
1597
1598
1599
1600
1601 for (i = 0; i < priv->gc.ngpio; ++i) {
1602
1603
1604
1605
1606 if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1607 priv->gpio_input |= BIT(i);
1608 }
1609
1610 return 0;
1611 }
1612
1613 static int cp2102n_gpioconf_init(struct usb_serial *serial)
1614 {
1615 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1616 const u16 config_size = 0x02a6;
1617 u8 gpio_rst_latch;
1618 u8 config_version;
1619 u8 gpio_pushpull;
1620 u8 *config_buf;
1621 u8 gpio_latch;
1622 u8 gpio_ctrl;
1623 int result;
1624 u8 i;
1625
1626
1627
1628
1629
1630
1631
1632
1633 config_buf = kmalloc(config_size, GFP_KERNEL);
1634 if (!config_buf)
1635 return -ENOMEM;
1636
1637 result = cp210x_read_vendor_block(serial,
1638 REQTYPE_DEVICE_TO_HOST,
1639 CP210X_READ_2NCONFIG,
1640 config_buf,
1641 config_size);
1642 if (result < 0) {
1643 kfree(config_buf);
1644 return result;
1645 }
1646
1647 config_version = config_buf[CP210X_2NCONFIG_CONFIG_VERSION_IDX];
1648 gpio_pushpull = config_buf[CP210X_2NCONFIG_GPIO_MODE_IDX];
1649 gpio_ctrl = config_buf[CP210X_2NCONFIG_GPIO_CONTROL_IDX];
1650 gpio_rst_latch = config_buf[CP210X_2NCONFIG_GPIO_RSTLATCH_IDX];
1651
1652 kfree(config_buf);
1653
1654
1655 if (config_version != 0x01)
1656 return -ENOTSUPP;
1657
1658 priv->gc.ngpio = 4;
1659
1660
1661
1662
1663
1664 gpio_latch = (gpio_rst_latch >> 3) & 0x0f;
1665
1666
1667 priv->gpio_pushpull = (gpio_pushpull >> 3) & 0x0f;
1668
1669
1670 priv->gpio_altfunc = (gpio_ctrl >> 2) & 0x0f;
1671
1672 if (priv->partnum == CP210X_PARTNUM_CP2102N_QFN28) {
1673
1674
1675
1676
1677
1678
1679
1680 priv->gc.ngpio = 7;
1681 gpio_latch |= (gpio_rst_latch & 7) << 4;
1682 priv->gpio_pushpull |= (gpio_pushpull & 7) << 4;
1683 }
1684
1685
1686
1687
1688
1689
1690
1691
1692
1693 for (i = 0; i < priv->gc.ngpio; ++i) {
1694
1695
1696
1697
1698 if (!(priv->gpio_pushpull & BIT(i)) && (gpio_latch & BIT(i)))
1699 priv->gpio_input |= BIT(i);
1700 }
1701
1702 return 0;
1703 }
1704
1705 static int cp210x_gpio_init(struct usb_serial *serial)
1706 {
1707 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1708 int result;
1709
1710 switch (priv->partnum) {
1711 case CP210X_PARTNUM_CP2104:
1712 result = cp2104_gpioconf_init(serial);
1713 break;
1714 case CP210X_PARTNUM_CP2105:
1715 result = cp2105_gpioconf_init(serial);
1716 break;
1717 case CP210X_PARTNUM_CP2102N_QFN28:
1718 case CP210X_PARTNUM_CP2102N_QFN24:
1719 case CP210X_PARTNUM_CP2102N_QFN20:
1720 result = cp2102n_gpioconf_init(serial);
1721 break;
1722 default:
1723 return 0;
1724 }
1725
1726 if (result < 0)
1727 return result;
1728
1729 priv->gc.label = "cp210x";
1730 priv->gc.request = cp210x_gpio_request;
1731 priv->gc.get_direction = cp210x_gpio_direction_get;
1732 priv->gc.direction_input = cp210x_gpio_direction_input;
1733 priv->gc.direction_output = cp210x_gpio_direction_output;
1734 priv->gc.get = cp210x_gpio_get;
1735 priv->gc.set = cp210x_gpio_set;
1736 priv->gc.set_config = cp210x_gpio_set_config;
1737 priv->gc.owner = THIS_MODULE;
1738 priv->gc.parent = &serial->interface->dev;
1739 priv->gc.base = -1;
1740 priv->gc.can_sleep = true;
1741
1742 result = gpiochip_add_data(&priv->gc, serial);
1743 if (!result)
1744 priv->gpio_registered = true;
1745
1746 return result;
1747 }
1748
1749 static void cp210x_gpio_remove(struct usb_serial *serial)
1750 {
1751 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1752
1753 if (priv->gpio_registered) {
1754 gpiochip_remove(&priv->gc);
1755 priv->gpio_registered = false;
1756 }
1757 }
1758
1759 #else
1760
1761 static int cp210x_gpio_init(struct usb_serial *serial)
1762 {
1763 return 0;
1764 }
1765
1766 static void cp210x_gpio_remove(struct usb_serial *serial)
1767 {
1768
1769 }
1770
1771 #endif
1772
1773 static int cp210x_port_probe(struct usb_serial_port *port)
1774 {
1775 struct usb_serial *serial = port->serial;
1776 struct cp210x_port_private *port_priv;
1777 int ret;
1778
1779 port_priv = kzalloc(sizeof(*port_priv), GFP_KERNEL);
1780 if (!port_priv)
1781 return -ENOMEM;
1782
1783 port_priv->bInterfaceNumber = cp210x_interface_num(serial);
1784
1785 usb_set_serial_port_data(port, port_priv);
1786
1787 ret = cp210x_detect_swapped_line_ctl(port);
1788 if (ret) {
1789 kfree(port_priv);
1790 return ret;
1791 }
1792
1793 return 0;
1794 }
1795
1796 static int cp210x_port_remove(struct usb_serial_port *port)
1797 {
1798 struct cp210x_port_private *port_priv;
1799
1800 port_priv = usb_get_serial_port_data(port);
1801 kfree(port_priv);
1802
1803 return 0;
1804 }
1805
1806 static void cp210x_init_max_speed(struct usb_serial *serial)
1807 {
1808 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1809 bool use_actual_rate = false;
1810 speed_t min = 300;
1811 speed_t max;
1812
1813 switch (priv->partnum) {
1814 case CP210X_PARTNUM_CP2101:
1815 max = 921600;
1816 break;
1817 case CP210X_PARTNUM_CP2102:
1818 case CP210X_PARTNUM_CP2103:
1819 max = 1000000;
1820 break;
1821 case CP210X_PARTNUM_CP2104:
1822 use_actual_rate = true;
1823 max = 2000000;
1824 break;
1825 case CP210X_PARTNUM_CP2108:
1826 max = 2000000;
1827 break;
1828 case CP210X_PARTNUM_CP2105:
1829 if (cp210x_interface_num(serial) == 0) {
1830 use_actual_rate = true;
1831 max = 2000000;
1832 } else {
1833 min = 2400;
1834 max = 921600;
1835 }
1836 break;
1837 case CP210X_PARTNUM_CP2102N_QFN28:
1838 case CP210X_PARTNUM_CP2102N_QFN24:
1839 case CP210X_PARTNUM_CP2102N_QFN20:
1840 use_actual_rate = true;
1841 max = 3000000;
1842 break;
1843 default:
1844 max = 2000000;
1845 break;
1846 }
1847
1848 priv->min_speed = min;
1849 priv->max_speed = max;
1850 priv->use_actual_rate = use_actual_rate;
1851 }
1852
1853 static int cp210x_attach(struct usb_serial *serial)
1854 {
1855 int result;
1856 struct cp210x_serial_private *priv;
1857
1858 priv = kzalloc(sizeof(*priv), GFP_KERNEL);
1859 if (!priv)
1860 return -ENOMEM;
1861
1862 result = cp210x_read_vendor_block(serial, REQTYPE_DEVICE_TO_HOST,
1863 CP210X_GET_PARTNUM, &priv->partnum,
1864 sizeof(priv->partnum));
1865 if (result < 0) {
1866 dev_warn(&serial->interface->dev,
1867 "querying part number failed\n");
1868 priv->partnum = CP210X_PARTNUM_UNKNOWN;
1869 }
1870
1871 usb_set_serial_data(serial, priv);
1872
1873 cp210x_init_max_speed(serial);
1874
1875 result = cp210x_gpio_init(serial);
1876 if (result < 0) {
1877 dev_err(&serial->interface->dev, "GPIO initialisation failed: %d\n",
1878 result);
1879 }
1880
1881 return 0;
1882 }
1883
1884 static void cp210x_disconnect(struct usb_serial *serial)
1885 {
1886 cp210x_gpio_remove(serial);
1887 }
1888
1889 static void cp210x_release(struct usb_serial *serial)
1890 {
1891 struct cp210x_serial_private *priv = usb_get_serial_data(serial);
1892
1893 cp210x_gpio_remove(serial);
1894
1895 kfree(priv);
1896 }
1897
1898 module_usb_serial_driver(serial_drivers, id_table);
1899
1900 MODULE_DESCRIPTION(DRIVER_DESC);
1901 MODULE_LICENSE("GPL v2");