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