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