1 // SPDX-License-Identifier: GPL-2.0+
2 /*
3 * MaxLinear/Exar USB to Serial driver
4 *
5 * Copyright (c) 2020 Manivannan Sadhasivam <mani@kernel.org>
6 * Copyright (c) 2021 Johan Hovold <johan@kernel.org>
7 *
8 * Based on the initial driver written by Patong Yang:
9 *
10 * https://lore.kernel.org/r/20180404070634.nhspvmxcjwfgjkcv@advantechmxl-desktop
11 *
12 * Copyright (c) 2018 Patong Yang <patong.mxl@gmail.com>
13 */
14
15 #include <linux/kernel.h>
16 #include <linux/module.h>
17 #include <linux/slab.h>
18 #include <linux/tty.h>
19 #include <linux/usb.h>
20 #include <linux/usb/cdc.h>
21 #include <linux/usb/serial.h>
22
23 struct xr_txrx_clk_mask {
24 u16 tx;
25 u16 rx0;
26 u16 rx1;
27 };
28
29 #define XR_INT_OSC_HZ 48000000U
30 #define XR21V141X_MIN_SPEED 46U
31 #define XR21V141X_MAX_SPEED XR_INT_OSC_HZ
32
33 /* XR21V141X register blocks */
34 #define XR21V141X_UART_REG_BLOCK 0
35 #define XR21V141X_UM_REG_BLOCK 4
36 #define XR21V141X_UART_CUSTOM_BLOCK 0x66
37
38 /* XR21V141X UART registers */
39 #define XR21V141X_CLOCK_DIVISOR_0 0x04
40 #define XR21V141X_CLOCK_DIVISOR_1 0x05
41 #define XR21V141X_CLOCK_DIVISOR_2 0x06
42 #define XR21V141X_TX_CLOCK_MASK_0 0x07
43 #define XR21V141X_TX_CLOCK_MASK_1 0x08
44 #define XR21V141X_RX_CLOCK_MASK_0 0x09
45 #define XR21V141X_RX_CLOCK_MASK_1 0x0a
46 #define XR21V141X_REG_FORMAT 0x0b
47
48 /* XR21V141X UART Manager registers */
49 #define XR21V141X_UM_FIFO_ENABLE_REG 0x10
50 #define XR21V141X_UM_ENABLE_TX_FIFO 0x01
51 #define XR21V141X_UM_ENABLE_RX_FIFO 0x02
52
53 #define XR21V141X_UM_RX_FIFO_RESET 0x18
54 #define XR21V141X_UM_TX_FIFO_RESET 0x1c
55
56 #define XR_UART_ENABLE_TX 0x1
57 #define XR_UART_ENABLE_RX 0x2
58
59 #define XR_GPIO_RI BIT(0)
60 #define XR_GPIO_CD BIT(1)
61 #define XR_GPIO_DSR BIT(2)
62 #define XR_GPIO_DTR BIT(3)
63 #define XR_GPIO_CTS BIT(4)
64 #define XR_GPIO_RTS BIT(5)
65 #define XR_GPIO_CLK BIT(6)
66 #define XR_GPIO_XEN BIT(7)
67 #define XR_GPIO_TXT BIT(8)
68 #define XR_GPIO_RXT BIT(9)
69
70 #define XR_UART_DATA_MASK GENMASK(3, 0)
71 #define XR_UART_DATA_7 0x7
72 #define XR_UART_DATA_8 0x8
73
74 #define XR_UART_PARITY_MASK GENMASK(6, 4)
75 #define XR_UART_PARITY_SHIFT 4
76 #define XR_UART_PARITY_NONE (0x0 << XR_UART_PARITY_SHIFT)
77 #define XR_UART_PARITY_ODD (0x1 << XR_UART_PARITY_SHIFT)
78 #define XR_UART_PARITY_EVEN (0x2 << XR_UART_PARITY_SHIFT)
79 #define XR_UART_PARITY_MARK (0x3 << XR_UART_PARITY_SHIFT)
80 #define XR_UART_PARITY_SPACE (0x4 << XR_UART_PARITY_SHIFT)
81
82 #define XR_UART_STOP_MASK BIT(7)
83 #define XR_UART_STOP_SHIFT 7
84 #define XR_UART_STOP_1 (0x0 << XR_UART_STOP_SHIFT)
85 #define XR_UART_STOP_2 (0x1 << XR_UART_STOP_SHIFT)
86
87 #define XR_UART_FLOW_MODE_NONE 0x0
88 #define XR_UART_FLOW_MODE_HW 0x1
89 #define XR_UART_FLOW_MODE_SW 0x2
90
91 #define XR_GPIO_MODE_SEL_MASK GENMASK(2, 0)
92 #define XR_GPIO_MODE_SEL_RTS_CTS 0x1
93 #define XR_GPIO_MODE_SEL_DTR_DSR 0x2
94 #define XR_GPIO_MODE_SEL_RS485 0x3
95 #define XR_GPIO_MODE_SEL_RS485_ADDR 0x4
96 #define XR_GPIO_MODE_TX_TOGGLE 0x100
97 #define XR_GPIO_MODE_RX_TOGGLE 0x200
98
99 #define XR_FIFO_RESET 0x1
100
101 #define XR_CUSTOM_DRIVER_ACTIVE 0x1
102
103 static int xr21v141x_uart_enable(struct usb_serial_port *port);
104 static int xr21v141x_uart_disable(struct usb_serial_port *port);
105 static int xr21v141x_fifo_reset(struct usb_serial_port *port);
106 static void xr21v141x_set_line_settings(struct tty_struct *tty,
107 struct usb_serial_port *port, struct ktermios *old_termios);
108
109 struct xr_type {
110 int reg_width;
111 u8 reg_recipient;
112 u8 set_reg;
113 u8 get_reg;
114
115 u16 uart_enable;
116 u16 flow_control;
117 u16 xon_char;
118 u16 xoff_char;
119 u16 tx_break;
120 u16 gpio_mode;
121 u16 gpio_direction;
122 u16 gpio_set;
123 u16 gpio_clear;
124 u16 gpio_status;
125 u16 tx_fifo_reset;
126 u16 rx_fifo_reset;
127 u16 custom_driver;
128
129 bool have_5_6_bit_mode;
130 bool have_xmit_toggle;
131
132 int (*enable)(struct usb_serial_port *port);
133 int (*disable)(struct usb_serial_port *port);
134 int (*fifo_reset)(struct usb_serial_port *port);
135 void (*set_line_settings)(struct tty_struct *tty,
136 struct usb_serial_port *port,
137 struct ktermios *old_termios);
138 };
139
140 enum xr_type_id {
141 XR21V141X,
142 XR21B142X,
143 XR21B1411,
144 XR2280X,
145 XR_TYPE_COUNT,
146 };
147
148 static const struct xr_type xr_types[] = {
149 [XR21V141X] = {
150 .reg_width = 8,
151 .reg_recipient = USB_RECIP_DEVICE,
152 .set_reg = 0x00,
153 .get_reg = 0x01,
154
155 .uart_enable = 0x03,
156 .flow_control = 0x0c,
157 .xon_char = 0x10,
158 .xoff_char = 0x11,
159 .tx_break = 0x14,
160 .gpio_mode = 0x1a,
161 .gpio_direction = 0x1b,
162 .gpio_set = 0x1d,
163 .gpio_clear = 0x1e,
164 .gpio_status = 0x1f,
165
166 .enable = xr21v141x_uart_enable,
167 .disable = xr21v141x_uart_disable,
168 .fifo_reset = xr21v141x_fifo_reset,
169 .set_line_settings = xr21v141x_set_line_settings,
170 },
171 [XR21B142X] = {
172 .reg_width = 16,
173 .reg_recipient = USB_RECIP_INTERFACE,
174 .set_reg = 0x00,
175 .get_reg = 0x00,
176
177 .uart_enable = 0x00,
178 .flow_control = 0x06,
179 .xon_char = 0x07,
180 .xoff_char = 0x08,
181 .tx_break = 0x0a,
182 .gpio_mode = 0x0c,
183 .gpio_direction = 0x0d,
184 .gpio_set = 0x0e,
185 .gpio_clear = 0x0f,
186 .gpio_status = 0x10,
187 .tx_fifo_reset = 0x40,
188 .rx_fifo_reset = 0x43,
189 .custom_driver = 0x60,
190
191 .have_5_6_bit_mode = true,
192 .have_xmit_toggle = true,
193 },
194 [XR21B1411] = {
195 .reg_width = 12,
196 .reg_recipient = USB_RECIP_DEVICE,
197 .set_reg = 0x00,
198 .get_reg = 0x01,
199
200 .uart_enable = 0xc00,
201 .flow_control = 0xc06,
202 .xon_char = 0xc07,
203 .xoff_char = 0xc08,
204 .tx_break = 0xc0a,
205 .gpio_mode = 0xc0c,
206 .gpio_direction = 0xc0d,
207 .gpio_set = 0xc0e,
208 .gpio_clear = 0xc0f,
209 .gpio_status = 0xc10,
210 .tx_fifo_reset = 0xc80,
211 .rx_fifo_reset = 0xcc0,
212 .custom_driver = 0x20d,
213 },
214 [XR2280X] = {
215 .reg_width = 16,
216 .reg_recipient = USB_RECIP_DEVICE,
217 .set_reg = 0x05,
218 .get_reg = 0x05,
219
220 .uart_enable = 0x40,
221 .flow_control = 0x46,
222 .xon_char = 0x47,
223 .xoff_char = 0x48,
224 .tx_break = 0x4a,
225 .gpio_mode = 0x4c,
226 .gpio_direction = 0x4d,
227 .gpio_set = 0x4e,
228 .gpio_clear = 0x4f,
229 .gpio_status = 0x50,
230 .tx_fifo_reset = 0x60,
231 .rx_fifo_reset = 0x63,
232 .custom_driver = 0x81,
233 },
234 };
235
236 struct xr_data {
237 const struct xr_type *type;
238 u8 channel; /* zero-based index or interface number */
239 };
240
xr_set_reg(struct usb_serial_port * port,u8 channel,u16 reg,u16 val)241 static int xr_set_reg(struct usb_serial_port *port, u8 channel, u16 reg, u16 val)
242 {
243 struct xr_data *data = usb_get_serial_port_data(port);
244 const struct xr_type *type = data->type;
245 struct usb_serial *serial = port->serial;
246 int ret;
247
248 ret = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
249 type->set_reg,
250 USB_DIR_OUT | USB_TYPE_VENDOR | type->reg_recipient,
251 val, (channel << 8) | reg, NULL, 0,
252 USB_CTRL_SET_TIMEOUT);
253 if (ret < 0) {
254 dev_err(&port->dev, "Failed to set reg 0x%02x: %d\n", reg, ret);
255 return ret;
256 }
257
258 return 0;
259 }
260
xr_get_reg(struct usb_serial_port * port,u8 channel,u16 reg,u16 * val)261 static int xr_get_reg(struct usb_serial_port *port, u8 channel, u16 reg, u16 *val)
262 {
263 struct xr_data *data = usb_get_serial_port_data(port);
264 const struct xr_type *type = data->type;
265 struct usb_serial *serial = port->serial;
266 u8 *dmabuf;
267 int ret, len;
268
269 if (type->reg_width == 8)
270 len = 1;
271 else
272 len = 2;
273
274 dmabuf = kmalloc(len, GFP_KERNEL);
275 if (!dmabuf)
276 return -ENOMEM;
277
278 ret = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
279 type->get_reg,
280 USB_DIR_IN | USB_TYPE_VENDOR | type->reg_recipient,
281 0, (channel << 8) | reg, dmabuf, len,
282 USB_CTRL_GET_TIMEOUT);
283 if (ret == len) {
284 if (len == 2)
285 *val = le16_to_cpup((__le16 *)dmabuf);
286 else
287 *val = *dmabuf;
288 ret = 0;
289 } else {
290 dev_err(&port->dev, "Failed to get reg 0x%02x: %d\n", reg, ret);
291 if (ret >= 0)
292 ret = -EIO;
293 }
294
295 kfree(dmabuf);
296
297 return ret;
298 }
299
xr_set_reg_uart(struct usb_serial_port * port,u16 reg,u16 val)300 static int xr_set_reg_uart(struct usb_serial_port *port, u16 reg, u16 val)
301 {
302 struct xr_data *data = usb_get_serial_port_data(port);
303
304 return xr_set_reg(port, data->channel, reg, val);
305 }
306
xr_get_reg_uart(struct usb_serial_port * port,u16 reg,u16 * val)307 static int xr_get_reg_uart(struct usb_serial_port *port, u16 reg, u16 *val)
308 {
309 struct xr_data *data = usb_get_serial_port_data(port);
310
311 return xr_get_reg(port, data->channel, reg, val);
312 }
313
xr_set_reg_um(struct usb_serial_port * port,u8 reg_base,u8 val)314 static int xr_set_reg_um(struct usb_serial_port *port, u8 reg_base, u8 val)
315 {
316 struct xr_data *data = usb_get_serial_port_data(port);
317 u8 reg;
318
319 reg = reg_base + data->channel;
320
321 return xr_set_reg(port, XR21V141X_UM_REG_BLOCK, reg, val);
322 }
323
__xr_uart_enable(struct usb_serial_port * port)324 static int __xr_uart_enable(struct usb_serial_port *port)
325 {
326 struct xr_data *data = usb_get_serial_port_data(port);
327
328 return xr_set_reg_uart(port, data->type->uart_enable,
329 XR_UART_ENABLE_TX | XR_UART_ENABLE_RX);
330 }
331
__xr_uart_disable(struct usb_serial_port * port)332 static int __xr_uart_disable(struct usb_serial_port *port)
333 {
334 struct xr_data *data = usb_get_serial_port_data(port);
335
336 return xr_set_reg_uart(port, data->type->uart_enable, 0);
337 }
338
339 /*
340 * According to datasheet, below is the recommended sequence for enabling UART
341 * module in XR21V141X:
342 *
343 * Enable Tx FIFO
344 * Enable Tx and Rx
345 * Enable Rx FIFO
346 */
xr21v141x_uart_enable(struct usb_serial_port * port)347 static int xr21v141x_uart_enable(struct usb_serial_port *port)
348 {
349 int ret;
350
351 ret = xr_set_reg_um(port, XR21V141X_UM_FIFO_ENABLE_REG,
352 XR21V141X_UM_ENABLE_TX_FIFO);
353 if (ret)
354 return ret;
355
356 ret = __xr_uart_enable(port);
357 if (ret)
358 return ret;
359
360 ret = xr_set_reg_um(port, XR21V141X_UM_FIFO_ENABLE_REG,
361 XR21V141X_UM_ENABLE_TX_FIFO | XR21V141X_UM_ENABLE_RX_FIFO);
362 if (ret)
363 __xr_uart_disable(port);
364
365 return ret;
366 }
367
xr21v141x_uart_disable(struct usb_serial_port * port)368 static int xr21v141x_uart_disable(struct usb_serial_port *port)
369 {
370 int ret;
371
372 ret = __xr_uart_disable(port);
373 if (ret)
374 return ret;
375
376 ret = xr_set_reg_um(port, XR21V141X_UM_FIFO_ENABLE_REG, 0);
377
378 return ret;
379 }
380
xr_uart_enable(struct usb_serial_port * port)381 static int xr_uart_enable(struct usb_serial_port *port)
382 {
383 struct xr_data *data = usb_get_serial_port_data(port);
384
385 if (data->type->enable)
386 return data->type->enable(port);
387
388 return __xr_uart_enable(port);
389 }
390
xr_uart_disable(struct usb_serial_port * port)391 static int xr_uart_disable(struct usb_serial_port *port)
392 {
393 struct xr_data *data = usb_get_serial_port_data(port);
394
395 if (data->type->disable)
396 return data->type->disable(port);
397
398 return __xr_uart_disable(port);
399 }
400
xr21v141x_fifo_reset(struct usb_serial_port * port)401 static int xr21v141x_fifo_reset(struct usb_serial_port *port)
402 {
403 int ret;
404
405 ret = xr_set_reg_um(port, XR21V141X_UM_TX_FIFO_RESET, XR_FIFO_RESET);
406 if (ret)
407 return ret;
408
409 ret = xr_set_reg_um(port, XR21V141X_UM_RX_FIFO_RESET, XR_FIFO_RESET);
410 if (ret)
411 return ret;
412
413 return 0;
414 }
415
xr_fifo_reset(struct usb_serial_port * port)416 static int xr_fifo_reset(struct usb_serial_port *port)
417 {
418 struct xr_data *data = usb_get_serial_port_data(port);
419 int ret;
420
421 if (data->type->fifo_reset)
422 return data->type->fifo_reset(port);
423
424 ret = xr_set_reg_uart(port, data->type->tx_fifo_reset, XR_FIFO_RESET);
425 if (ret)
426 return ret;
427
428 ret = xr_set_reg_uart(port, data->type->rx_fifo_reset, XR_FIFO_RESET);
429 if (ret)
430 return ret;
431
432 return 0;
433 }
434
xr_tiocmget(struct tty_struct * tty)435 static int xr_tiocmget(struct tty_struct *tty)
436 {
437 struct usb_serial_port *port = tty->driver_data;
438 struct xr_data *data = usb_get_serial_port_data(port);
439 u16 status;
440 int ret;
441
442 ret = xr_get_reg_uart(port, data->type->gpio_status, &status);
443 if (ret)
444 return ret;
445
446 /*
447 * Modem control pins are active low, so reading '0' means it is active
448 * and '1' means not active.
449 */
450 ret = ((status & XR_GPIO_DTR) ? 0 : TIOCM_DTR) |
451 ((status & XR_GPIO_RTS) ? 0 : TIOCM_RTS) |
452 ((status & XR_GPIO_CTS) ? 0 : TIOCM_CTS) |
453 ((status & XR_GPIO_DSR) ? 0 : TIOCM_DSR) |
454 ((status & XR_GPIO_RI) ? 0 : TIOCM_RI) |
455 ((status & XR_GPIO_CD) ? 0 : TIOCM_CD);
456
457 return ret;
458 }
459
xr_tiocmset_port(struct usb_serial_port * port,unsigned int set,unsigned int clear)460 static int xr_tiocmset_port(struct usb_serial_port *port,
461 unsigned int set, unsigned int clear)
462 {
463 struct xr_data *data = usb_get_serial_port_data(port);
464 const struct xr_type *type = data->type;
465 u16 gpio_set = 0;
466 u16 gpio_clr = 0;
467 int ret = 0;
468
469 /* Modem control pins are active low, so set & clr are swapped */
470 if (set & TIOCM_RTS)
471 gpio_clr |= XR_GPIO_RTS;
472 if (set & TIOCM_DTR)
473 gpio_clr |= XR_GPIO_DTR;
474 if (clear & TIOCM_RTS)
475 gpio_set |= XR_GPIO_RTS;
476 if (clear & TIOCM_DTR)
477 gpio_set |= XR_GPIO_DTR;
478
479 /* Writing '0' to gpio_{set/clr} bits has no effect, so no need to do */
480 if (gpio_clr)
481 ret = xr_set_reg_uart(port, type->gpio_clear, gpio_clr);
482
483 if (gpio_set)
484 ret = xr_set_reg_uart(port, type->gpio_set, gpio_set);
485
486 return ret;
487 }
488
xr_tiocmset(struct tty_struct * tty,unsigned int set,unsigned int clear)489 static int xr_tiocmset(struct tty_struct *tty,
490 unsigned int set, unsigned int clear)
491 {
492 struct usb_serial_port *port = tty->driver_data;
493
494 return xr_tiocmset_port(port, set, clear);
495 }
496
xr_dtr_rts(struct usb_serial_port * port,int on)497 static void xr_dtr_rts(struct usb_serial_port *port, int on)
498 {
499 if (on)
500 xr_tiocmset_port(port, TIOCM_DTR | TIOCM_RTS, 0);
501 else
502 xr_tiocmset_port(port, 0, TIOCM_DTR | TIOCM_RTS);
503 }
504
xr_break_ctl(struct tty_struct * tty,int break_state)505 static void xr_break_ctl(struct tty_struct *tty, int break_state)
506 {
507 struct usb_serial_port *port = tty->driver_data;
508 struct xr_data *data = usb_get_serial_port_data(port);
509 const struct xr_type *type = data->type;
510 u16 state;
511
512 if (break_state == 0)
513 state = 0;
514 else
515 state = GENMASK(type->reg_width - 1, 0);
516
517 dev_dbg(&port->dev, "Turning break %s\n", state == 0 ? "off" : "on");
518
519 xr_set_reg_uart(port, type->tx_break, state);
520 }
521
522 /* Tx and Rx clock mask values obtained from section 3.3.4 of datasheet */
523 static const struct xr_txrx_clk_mask xr21v141x_txrx_clk_masks[] = {
524 { 0x000, 0x000, 0x000 },
525 { 0x000, 0x000, 0x000 },
526 { 0x100, 0x000, 0x100 },
527 { 0x020, 0x400, 0x020 },
528 { 0x010, 0x100, 0x010 },
529 { 0x208, 0x040, 0x208 },
530 { 0x104, 0x820, 0x108 },
531 { 0x844, 0x210, 0x884 },
532 { 0x444, 0x110, 0x444 },
533 { 0x122, 0x888, 0x224 },
534 { 0x912, 0x448, 0x924 },
535 { 0x492, 0x248, 0x492 },
536 { 0x252, 0x928, 0x292 },
537 { 0x94a, 0x4a4, 0xa52 },
538 { 0x52a, 0xaa4, 0x54a },
539 { 0xaaa, 0x954, 0x4aa },
540 { 0xaaa, 0x554, 0xaaa },
541 { 0x555, 0xad4, 0x5aa },
542 { 0xb55, 0xab4, 0x55a },
543 { 0x6b5, 0x5ac, 0xb56 },
544 { 0x5b5, 0xd6c, 0x6d6 },
545 { 0xb6d, 0xb6a, 0xdb6 },
546 { 0x76d, 0x6da, 0xbb6 },
547 { 0xedd, 0xdda, 0x76e },
548 { 0xddd, 0xbba, 0xeee },
549 { 0x7bb, 0xf7a, 0xdde },
550 { 0xf7b, 0xef6, 0x7de },
551 { 0xdf7, 0xbf6, 0xf7e },
552 { 0x7f7, 0xfee, 0xefe },
553 { 0xfdf, 0xfbe, 0x7fe },
554 { 0xf7f, 0xefe, 0xffe },
555 { 0xfff, 0xffe, 0xffd },
556 };
557
xr21v141x_set_baudrate(struct tty_struct * tty,struct usb_serial_port * port)558 static int xr21v141x_set_baudrate(struct tty_struct *tty, struct usb_serial_port *port)
559 {
560 u32 divisor, baud, idx;
561 u16 tx_mask, rx_mask;
562 int ret;
563
564 baud = tty->termios.c_ospeed;
565 if (!baud)
566 return 0;
567
568 baud = clamp(baud, XR21V141X_MIN_SPEED, XR21V141X_MAX_SPEED);
569 divisor = XR_INT_OSC_HZ / baud;
570 idx = ((32 * XR_INT_OSC_HZ) / baud) & 0x1f;
571 tx_mask = xr21v141x_txrx_clk_masks[idx].tx;
572
573 if (divisor & 0x01)
574 rx_mask = xr21v141x_txrx_clk_masks[idx].rx1;
575 else
576 rx_mask = xr21v141x_txrx_clk_masks[idx].rx0;
577
578 dev_dbg(&port->dev, "Setting baud rate: %u\n", baud);
579 /*
580 * XR21V141X uses fractional baud rate generator with 48MHz internal
581 * oscillator and 19-bit programmable divisor. So theoretically it can
582 * generate most commonly used baud rates with high accuracy.
583 */
584 ret = xr_set_reg_uart(port, XR21V141X_CLOCK_DIVISOR_0,
585 divisor & 0xff);
586 if (ret)
587 return ret;
588
589 ret = xr_set_reg_uart(port, XR21V141X_CLOCK_DIVISOR_1,
590 (divisor >> 8) & 0xff);
591 if (ret)
592 return ret;
593
594 ret = xr_set_reg_uart(port, XR21V141X_CLOCK_DIVISOR_2,
595 (divisor >> 16) & 0xff);
596 if (ret)
597 return ret;
598
599 ret = xr_set_reg_uart(port, XR21V141X_TX_CLOCK_MASK_0,
600 tx_mask & 0xff);
601 if (ret)
602 return ret;
603
604 ret = xr_set_reg_uart(port, XR21V141X_TX_CLOCK_MASK_1,
605 (tx_mask >> 8) & 0xff);
606 if (ret)
607 return ret;
608
609 ret = xr_set_reg_uart(port, XR21V141X_RX_CLOCK_MASK_0,
610 rx_mask & 0xff);
611 if (ret)
612 return ret;
613
614 ret = xr_set_reg_uart(port, XR21V141X_RX_CLOCK_MASK_1,
615 (rx_mask >> 8) & 0xff);
616 if (ret)
617 return ret;
618
619 tty_encode_baud_rate(tty, baud, baud);
620
621 return 0;
622 }
623
xr_set_flow_mode(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)624 static void xr_set_flow_mode(struct tty_struct *tty,
625 struct usb_serial_port *port,
626 struct ktermios *old_termios)
627 {
628 struct xr_data *data = usb_get_serial_port_data(port);
629 const struct xr_type *type = data->type;
630 u16 flow, gpio_mode;
631 int ret;
632
633 ret = xr_get_reg_uart(port, type->gpio_mode, &gpio_mode);
634 if (ret)
635 return;
636
637 /*
638 * According to the datasheets, the UART needs to be disabled while
639 * writing to the FLOW_CONTROL register (XR21V141X), or any register
640 * but GPIO_SET, GPIO_CLEAR, TX_BREAK and ERROR_STATUS (XR21B142X).
641 */
642 xr_uart_disable(port);
643
644 /* Set GPIO mode for controlling the pins manually by default. */
645 gpio_mode &= ~XR_GPIO_MODE_SEL_MASK;
646
647 if (C_CRTSCTS(tty) && C_BAUD(tty) != B0) {
648 dev_dbg(&port->dev, "Enabling hardware flow ctrl\n");
649 gpio_mode |= XR_GPIO_MODE_SEL_RTS_CTS;
650 flow = XR_UART_FLOW_MODE_HW;
651 } else if (I_IXON(tty)) {
652 u8 start_char = START_CHAR(tty);
653 u8 stop_char = STOP_CHAR(tty);
654
655 dev_dbg(&port->dev, "Enabling sw flow ctrl\n");
656 flow = XR_UART_FLOW_MODE_SW;
657
658 xr_set_reg_uart(port, type->xon_char, start_char);
659 xr_set_reg_uart(port, type->xoff_char, stop_char);
660 } else {
661 dev_dbg(&port->dev, "Disabling flow ctrl\n");
662 flow = XR_UART_FLOW_MODE_NONE;
663 }
664
665 xr_set_reg_uart(port, type->flow_control, flow);
666 xr_set_reg_uart(port, type->gpio_mode, gpio_mode);
667
668 xr_uart_enable(port);
669
670 if (C_BAUD(tty) == B0)
671 xr_dtr_rts(port, 0);
672 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
673 xr_dtr_rts(port, 1);
674 }
675
xr21v141x_set_line_settings(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)676 static void xr21v141x_set_line_settings(struct tty_struct *tty,
677 struct usb_serial_port *port, struct ktermios *old_termios)
678 {
679 struct ktermios *termios = &tty->termios;
680 u8 bits = 0;
681 int ret;
682
683 if (!old_termios || (tty->termios.c_ospeed != old_termios->c_ospeed))
684 xr21v141x_set_baudrate(tty, port);
685
686 switch (C_CSIZE(tty)) {
687 case CS5:
688 case CS6:
689 /* CS5 and CS6 are not supported, so just restore old setting */
690 termios->c_cflag &= ~CSIZE;
691 if (old_termios)
692 termios->c_cflag |= old_termios->c_cflag & CSIZE;
693 else
694 termios->c_cflag |= CS8;
695
696 if (C_CSIZE(tty) == CS7)
697 bits |= XR_UART_DATA_7;
698 else
699 bits |= XR_UART_DATA_8;
700 break;
701 case CS7:
702 bits |= XR_UART_DATA_7;
703 break;
704 case CS8:
705 default:
706 bits |= XR_UART_DATA_8;
707 break;
708 }
709
710 if (C_PARENB(tty)) {
711 if (C_CMSPAR(tty)) {
712 if (C_PARODD(tty))
713 bits |= XR_UART_PARITY_MARK;
714 else
715 bits |= XR_UART_PARITY_SPACE;
716 } else {
717 if (C_PARODD(tty))
718 bits |= XR_UART_PARITY_ODD;
719 else
720 bits |= XR_UART_PARITY_EVEN;
721 }
722 }
723
724 if (C_CSTOPB(tty))
725 bits |= XR_UART_STOP_2;
726 else
727 bits |= XR_UART_STOP_1;
728
729 ret = xr_set_reg_uart(port, XR21V141X_REG_FORMAT, bits);
730 if (ret)
731 return;
732 }
733
xr_cdc_set_line_coding(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)734 static void xr_cdc_set_line_coding(struct tty_struct *tty,
735 struct usb_serial_port *port, struct ktermios *old_termios)
736 {
737 struct xr_data *data = usb_get_serial_port_data(port);
738 struct usb_host_interface *alt = port->serial->interface->cur_altsetting;
739 struct usb_device *udev = port->serial->dev;
740 struct usb_cdc_line_coding *lc;
741 int ret;
742
743 lc = kzalloc(sizeof(*lc), GFP_KERNEL);
744 if (!lc)
745 return;
746
747 if (tty->termios.c_ospeed)
748 lc->dwDTERate = cpu_to_le32(tty->termios.c_ospeed);
749 else if (old_termios)
750 lc->dwDTERate = cpu_to_le32(old_termios->c_ospeed);
751 else
752 lc->dwDTERate = cpu_to_le32(9600);
753
754 if (C_CSTOPB(tty))
755 lc->bCharFormat = USB_CDC_2_STOP_BITS;
756 else
757 lc->bCharFormat = USB_CDC_1_STOP_BITS;
758
759 if (C_PARENB(tty)) {
760 if (C_CMSPAR(tty)) {
761 if (C_PARODD(tty))
762 lc->bParityType = USB_CDC_MARK_PARITY;
763 else
764 lc->bParityType = USB_CDC_SPACE_PARITY;
765 } else {
766 if (C_PARODD(tty))
767 lc->bParityType = USB_CDC_ODD_PARITY;
768 else
769 lc->bParityType = USB_CDC_EVEN_PARITY;
770 }
771 } else {
772 lc->bParityType = USB_CDC_NO_PARITY;
773 }
774
775 if (!data->type->have_5_6_bit_mode &&
776 (C_CSIZE(tty) == CS5 || C_CSIZE(tty) == CS6)) {
777 tty->termios.c_cflag &= ~CSIZE;
778 if (old_termios)
779 tty->termios.c_cflag |= old_termios->c_cflag & CSIZE;
780 else
781 tty->termios.c_cflag |= CS8;
782 }
783
784 switch (C_CSIZE(tty)) {
785 case CS5:
786 lc->bDataBits = 5;
787 break;
788 case CS6:
789 lc->bDataBits = 6;
790 break;
791 case CS7:
792 lc->bDataBits = 7;
793 break;
794 case CS8:
795 default:
796 lc->bDataBits = 8;
797 break;
798 }
799
800 ret = usb_control_msg(udev, usb_sndctrlpipe(udev, 0),
801 USB_CDC_REQ_SET_LINE_CODING,
802 USB_TYPE_CLASS | USB_RECIP_INTERFACE,
803 0, alt->desc.bInterfaceNumber,
804 lc, sizeof(*lc), USB_CTRL_SET_TIMEOUT);
805 if (ret < 0)
806 dev_err(&port->dev, "Failed to set line coding: %d\n", ret);
807
808 kfree(lc);
809 }
810
xr_set_termios(struct tty_struct * tty,struct usb_serial_port * port,struct ktermios * old_termios)811 static void xr_set_termios(struct tty_struct *tty,
812 struct usb_serial_port *port, struct ktermios *old_termios)
813 {
814 struct xr_data *data = usb_get_serial_port_data(port);
815
816 /*
817 * XR21V141X does not have a CUSTOM_DRIVER flag and always enters CDC
818 * mode upon receiving CDC requests.
819 */
820 if (data->type->set_line_settings)
821 data->type->set_line_settings(tty, port, old_termios);
822 else
823 xr_cdc_set_line_coding(tty, port, old_termios);
824
825 xr_set_flow_mode(tty, port, old_termios);
826 }
827
xr_open(struct tty_struct * tty,struct usb_serial_port * port)828 static int xr_open(struct tty_struct *tty, struct usb_serial_port *port)
829 {
830 int ret;
831
832 ret = xr_fifo_reset(port);
833 if (ret)
834 return ret;
835
836 ret = xr_uart_enable(port);
837 if (ret) {
838 dev_err(&port->dev, "Failed to enable UART\n");
839 return ret;
840 }
841
842 /* Setup termios */
843 if (tty)
844 xr_set_termios(tty, port, NULL);
845
846 ret = usb_serial_generic_open(tty, port);
847 if (ret) {
848 xr_uart_disable(port);
849 return ret;
850 }
851
852 return 0;
853 }
854
xr_close(struct usb_serial_port * port)855 static void xr_close(struct usb_serial_port *port)
856 {
857 usb_serial_generic_close(port);
858
859 xr_uart_disable(port);
860 }
861
xr_probe(struct usb_serial * serial,const struct usb_device_id * id)862 static int xr_probe(struct usb_serial *serial, const struct usb_device_id *id)
863 {
864 struct usb_interface *control = serial->interface;
865 struct usb_host_interface *alt = control->cur_altsetting;
866 struct usb_cdc_parsed_header hdrs;
867 struct usb_cdc_union_desc *desc;
868 struct usb_interface *data;
869 int ret;
870
871 ret = cdc_parse_cdc_header(&hdrs, control, alt->extra, alt->extralen);
872 if (ret < 0)
873 return -ENODEV;
874
875 desc = hdrs.usb_cdc_union_desc;
876 if (!desc)
877 return -ENODEV;
878
879 data = usb_ifnum_to_if(serial->dev, desc->bSlaveInterface0);
880 if (!data)
881 return -ENODEV;
882
883 ret = usb_serial_claim_interface(serial, data);
884 if (ret)
885 return ret;
886
887 usb_set_serial_data(serial, (void *)id->driver_info);
888
889 return 0;
890 }
891
xr_gpio_init(struct usb_serial_port * port,const struct xr_type * type)892 static int xr_gpio_init(struct usb_serial_port *port, const struct xr_type *type)
893 {
894 u16 mask, mode;
895 int ret;
896
897 /*
898 * Configure all pins as GPIO except for Receive and Transmit Toggle.
899 */
900 mode = 0;
901 if (type->have_xmit_toggle)
902 mode |= XR_GPIO_MODE_RX_TOGGLE | XR_GPIO_MODE_TX_TOGGLE;
903
904 ret = xr_set_reg_uart(port, type->gpio_mode, mode);
905 if (ret)
906 return ret;
907
908 /*
909 * Configure DTR and RTS as outputs and make sure they are deasserted
910 * (active low), and configure RI, CD, DSR and CTS as inputs.
911 */
912 mask = XR_GPIO_DTR | XR_GPIO_RTS;
913 ret = xr_set_reg_uart(port, type->gpio_direction, mask);
914 if (ret)
915 return ret;
916
917 ret = xr_set_reg_uart(port, type->gpio_set, mask);
918 if (ret)
919 return ret;
920
921 return 0;
922 }
923
xr_port_probe(struct usb_serial_port * port)924 static int xr_port_probe(struct usb_serial_port *port)
925 {
926 struct usb_interface_descriptor *desc;
927 const struct xr_type *type;
928 struct xr_data *data;
929 enum xr_type_id type_id;
930 int ret;
931
932 type_id = (int)(unsigned long)usb_get_serial_data(port->serial);
933 type = &xr_types[type_id];
934
935 data = kzalloc(sizeof(*data), GFP_KERNEL);
936 if (!data)
937 return -ENOMEM;
938
939 data->type = type;
940
941 desc = &port->serial->interface->cur_altsetting->desc;
942 if (type_id == XR21V141X)
943 data->channel = desc->bInterfaceNumber / 2;
944 else
945 data->channel = desc->bInterfaceNumber;
946
947 usb_set_serial_port_data(port, data);
948
949 if (type->custom_driver) {
950 ret = xr_set_reg_uart(port, type->custom_driver,
951 XR_CUSTOM_DRIVER_ACTIVE);
952 if (ret)
953 goto err_free;
954 }
955
956 ret = xr_gpio_init(port, type);
957 if (ret)
958 goto err_free;
959
960 return 0;
961
962 err_free:
963 kfree(data);
964
965 return ret;
966 }
967
xr_port_remove(struct usb_serial_port * port)968 static void xr_port_remove(struct usb_serial_port *port)
969 {
970 struct xr_data *data = usb_get_serial_port_data(port);
971
972 kfree(data);
973 }
974
975 #define XR_DEVICE(vid, pid, type) \
976 USB_DEVICE_INTERFACE_CLASS((vid), (pid), USB_CLASS_COMM), \
977 .driver_info = (type)
978
979 static const struct usb_device_id id_table[] = {
980 { XR_DEVICE(0x04e2, 0x1400, XR2280X) },
981 { XR_DEVICE(0x04e2, 0x1401, XR2280X) },
982 { XR_DEVICE(0x04e2, 0x1402, XR2280X) },
983 { XR_DEVICE(0x04e2, 0x1403, XR2280X) },
984 { XR_DEVICE(0x04e2, 0x1410, XR21V141X) },
985 { XR_DEVICE(0x04e2, 0x1411, XR21B1411) },
986 { XR_DEVICE(0x04e2, 0x1412, XR21V141X) },
987 { XR_DEVICE(0x04e2, 0x1414, XR21V141X) },
988 { XR_DEVICE(0x04e2, 0x1420, XR21B142X) },
989 { XR_DEVICE(0x04e2, 0x1422, XR21B142X) },
990 { XR_DEVICE(0x04e2, 0x1424, XR21B142X) },
991 { }
992 };
993 MODULE_DEVICE_TABLE(usb, id_table);
994
995 static struct usb_serial_driver xr_device = {
996 .driver = {
997 .owner = THIS_MODULE,
998 .name = "xr_serial",
999 },
1000 .id_table = id_table,
1001 .num_ports = 1,
1002 .probe = xr_probe,
1003 .port_probe = xr_port_probe,
1004 .port_remove = xr_port_remove,
1005 .open = xr_open,
1006 .close = xr_close,
1007 .break_ctl = xr_break_ctl,
1008 .set_termios = xr_set_termios,
1009 .tiocmget = xr_tiocmget,
1010 .tiocmset = xr_tiocmset,
1011 .dtr_rts = xr_dtr_rts
1012 };
1013
1014 static struct usb_serial_driver * const serial_drivers[] = {
1015 &xr_device, NULL
1016 };
1017
1018 module_usb_serial_driver(serial_drivers, id_table);
1019
1020 MODULE_AUTHOR("Manivannan Sadhasivam <mani@kernel.org>");
1021 MODULE_DESCRIPTION("MaxLinear/Exar USB to Serial driver");
1022 MODULE_LICENSE("GPL");
1023