1 | // SPDX-License-Identifier: GPL-2.0+ |
2 | /* |
3 | * mxuport.c - MOXA UPort series driver |
4 | * |
5 | * Copyright (c) 2006 Moxa Technologies Co., Ltd. |
6 | * Copyright (c) 2013 Andrew Lunn <andrew@lunn.ch> |
7 | * |
8 | * Supports the following Moxa USB to serial converters: |
9 | * 2 ports : UPort 1250, UPort 1250I |
10 | * 4 ports : UPort 1410, UPort 1450, UPort 1450I |
11 | * 8 ports : UPort 1610-8, UPort 1650-8 |
12 | * 16 ports : UPort 1610-16, UPort 1650-16 |
13 | */ |
14 | |
15 | #include <linux/kernel.h> |
16 | #include <linux/module.h> |
17 | #include <linux/firmware.h> |
18 | #include <linux/jiffies.h> |
19 | #include <linux/serial.h> |
20 | #include <linux/serial_reg.h> |
21 | #include <linux/slab.h> |
22 | #include <linux/tty.h> |
23 | #include <linux/tty_driver.h> |
24 | #include <linux/tty_flip.h> |
25 | #include <linux/uaccess.h> |
26 | #include <linux/usb.h> |
27 | #include <linux/usb/serial.h> |
28 | #include <asm/unaligned.h> |
29 | |
30 | /* Definitions for the vendor ID and device ID */ |
31 | #define MX_USBSERIAL_VID 0x110A |
32 | #define MX_UPORT1250_PID 0x1250 |
33 | #define MX_UPORT1251_PID 0x1251 |
34 | #define MX_UPORT1410_PID 0x1410 |
35 | #define MX_UPORT1450_PID 0x1450 |
36 | #define MX_UPORT1451_PID 0x1451 |
37 | #define MX_UPORT1618_PID 0x1618 |
38 | #define MX_UPORT1658_PID 0x1658 |
39 | #define MX_UPORT1613_PID 0x1613 |
40 | #define MX_UPORT1653_PID 0x1653 |
41 | |
42 | /* Definitions for USB info */ |
43 | #define 4 |
44 | #define EVENT_LENGTH 8 |
45 | #define DOWN_BLOCK_SIZE 64 |
46 | |
47 | /* Definitions for firmware info */ |
48 | #define VER_ADDR_1 0x20 |
49 | #define VER_ADDR_2 0x24 |
50 | #define VER_ADDR_3 0x28 |
51 | |
52 | /* Definitions for USB vendor request */ |
53 | #define RQ_VENDOR_NONE 0x00 |
54 | #define RQ_VENDOR_SET_BAUD 0x01 /* Set baud rate */ |
55 | #define RQ_VENDOR_SET_LINE 0x02 /* Set line status */ |
56 | #define RQ_VENDOR_SET_CHARS 0x03 /* Set Xon/Xoff chars */ |
57 | #define RQ_VENDOR_SET_RTS 0x04 /* Set RTS */ |
58 | #define RQ_VENDOR_SET_DTR 0x05 /* Set DTR */ |
59 | #define RQ_VENDOR_SET_XONXOFF 0x06 /* Set auto Xon/Xoff */ |
60 | #define RQ_VENDOR_SET_RX_HOST_EN 0x07 /* Set RX host enable */ |
61 | #define RQ_VENDOR_SET_OPEN 0x08 /* Set open/close port */ |
62 | #define RQ_VENDOR_PURGE 0x09 /* Purge Rx/Tx buffer */ |
63 | #define RQ_VENDOR_SET_MCR 0x0A /* Set MCR register */ |
64 | #define RQ_VENDOR_SET_BREAK 0x0B /* Set Break signal */ |
65 | |
66 | #define RQ_VENDOR_START_FW_DOWN 0x0C /* Start firmware download */ |
67 | #define RQ_VENDOR_STOP_FW_DOWN 0x0D /* Stop firmware download */ |
68 | #define RQ_VENDOR_QUERY_FW_READY 0x0E /* Query if new firmware ready */ |
69 | |
70 | #define RQ_VENDOR_SET_FIFO_DISABLE 0x0F /* Set fifo disable */ |
71 | #define RQ_VENDOR_SET_INTERFACE 0x10 /* Set interface */ |
72 | #define RQ_VENDOR_SET_HIGH_PERFOR 0x11 /* Set hi-performance */ |
73 | |
74 | #define RQ_VENDOR_ERASE_BLOCK 0x12 /* Erase flash block */ |
75 | #define RQ_VENDOR_WRITE_PAGE 0x13 /* Write flash page */ |
76 | #define RQ_VENDOR_PREPARE_WRITE 0x14 /* Prepare write flash */ |
77 | #define RQ_VENDOR_CONFIRM_WRITE 0x15 /* Confirm write flash */ |
78 | #define RQ_VENDOR_LOCATE 0x16 /* Locate the device */ |
79 | |
80 | #define RQ_VENDOR_START_ROM_DOWN 0x17 /* Start firmware download */ |
81 | #define RQ_VENDOR_ROM_DATA 0x18 /* Rom file data */ |
82 | #define RQ_VENDOR_STOP_ROM_DOWN 0x19 /* Stop firmware download */ |
83 | #define RQ_VENDOR_FW_DATA 0x20 /* Firmware data */ |
84 | |
85 | #define RQ_VENDOR_RESET_DEVICE 0x23 /* Try to reset the device */ |
86 | #define RQ_VENDOR_QUERY_FW_CONFIG 0x24 |
87 | |
88 | #define RQ_VENDOR_GET_VERSION 0x81 /* Get firmware version */ |
89 | #define RQ_VENDOR_GET_PAGE 0x82 /* Read flash page */ |
90 | #define RQ_VENDOR_GET_ROM_PROC 0x83 /* Get ROM process state */ |
91 | |
92 | #define RQ_VENDOR_GET_INQUEUE 0x84 /* Data in input buffer */ |
93 | #define RQ_VENDOR_GET_OUTQUEUE 0x85 /* Data in output buffer */ |
94 | |
95 | #define RQ_VENDOR_GET_MSR 0x86 /* Get modem status register */ |
96 | |
97 | /* Definitions for UPort event type */ |
98 | #define UPORT_EVENT_NONE 0 /* None */ |
99 | #define UPORT_EVENT_TXBUF_THRESHOLD 1 /* Tx buffer threshold */ |
100 | #define UPORT_EVENT_SEND_NEXT 2 /* Send next */ |
101 | #define UPORT_EVENT_MSR 3 /* Modem status */ |
102 | #define UPORT_EVENT_LSR 4 /* Line status */ |
103 | #define UPORT_EVENT_MCR 5 /* Modem control */ |
104 | |
105 | /* Definitions for serial event type */ |
106 | #define SERIAL_EV_CTS 0x0008 /* CTS changed state */ |
107 | #define SERIAL_EV_DSR 0x0010 /* DSR changed state */ |
108 | #define SERIAL_EV_RLSD 0x0020 /* RLSD changed state */ |
109 | |
110 | /* Definitions for modem control event type */ |
111 | #define SERIAL_EV_XOFF 0x40 /* XOFF received */ |
112 | |
113 | /* Definitions for line control of communication */ |
114 | #define MX_WORDLENGTH_5 5 |
115 | #define MX_WORDLENGTH_6 6 |
116 | #define MX_WORDLENGTH_7 7 |
117 | #define MX_WORDLENGTH_8 8 |
118 | |
119 | #define MX_PARITY_NONE 0 |
120 | #define MX_PARITY_ODD 1 |
121 | #define MX_PARITY_EVEN 2 |
122 | #define MX_PARITY_MARK 3 |
123 | #define MX_PARITY_SPACE 4 |
124 | |
125 | #define MX_STOP_BITS_1 0 |
126 | #define MX_STOP_BITS_1_5 1 |
127 | #define MX_STOP_BITS_2 2 |
128 | |
129 | #define MX_RTS_DISABLE 0x0 |
130 | #define MX_RTS_ENABLE 0x1 |
131 | #define MX_RTS_HW 0x2 |
132 | #define MX_RTS_NO_CHANGE 0x3 /* Flag, not valid register value*/ |
133 | |
134 | #define MX_INT_RS232 0 |
135 | #define MX_INT_2W_RS485 1 |
136 | #define MX_INT_RS422 2 |
137 | #define MX_INT_4W_RS485 3 |
138 | |
139 | /* Definitions for holding reason */ |
140 | #define MX_WAIT_FOR_CTS 0x0001 |
141 | #define MX_WAIT_FOR_DSR 0x0002 |
142 | #define MX_WAIT_FOR_DCD 0x0004 |
143 | #define MX_WAIT_FOR_XON 0x0008 |
144 | #define MX_WAIT_FOR_START_TX 0x0010 |
145 | #define MX_WAIT_FOR_UNTHROTTLE 0x0020 |
146 | #define MX_WAIT_FOR_LOW_WATER 0x0040 |
147 | #define MX_WAIT_FOR_SEND_NEXT 0x0080 |
148 | |
149 | #define MX_UPORT_2_PORT BIT(0) |
150 | #define MX_UPORT_4_PORT BIT(1) |
151 | #define MX_UPORT_8_PORT BIT(2) |
152 | #define MX_UPORT_16_PORT BIT(3) |
153 | |
154 | /* This structure holds all of the local port information */ |
155 | struct mxuport_port { |
156 | u8 mcr_state; /* Last MCR state */ |
157 | u8 msr_state; /* Last MSR state */ |
158 | struct mutex mutex; /* Protects mcr_state */ |
159 | spinlock_t spinlock; /* Protects msr_state */ |
160 | }; |
161 | |
162 | /* Table of devices that work with this driver */ |
163 | static const struct usb_device_id mxuport_idtable[] = { |
164 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1250_PID), |
165 | .driver_info = MX_UPORT_2_PORT }, |
166 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1251_PID), |
167 | .driver_info = MX_UPORT_2_PORT }, |
168 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1410_PID), |
169 | .driver_info = MX_UPORT_4_PORT }, |
170 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1450_PID), |
171 | .driver_info = MX_UPORT_4_PORT }, |
172 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1451_PID), |
173 | .driver_info = MX_UPORT_4_PORT }, |
174 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1618_PID), |
175 | .driver_info = MX_UPORT_8_PORT }, |
176 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1658_PID), |
177 | .driver_info = MX_UPORT_8_PORT }, |
178 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1613_PID), |
179 | .driver_info = MX_UPORT_16_PORT }, |
180 | { USB_DEVICE(MX_USBSERIAL_VID, MX_UPORT1653_PID), |
181 | .driver_info = MX_UPORT_16_PORT }, |
182 | {} /* Terminating entry */ |
183 | }; |
184 | |
185 | MODULE_DEVICE_TABLE(usb, mxuport_idtable); |
186 | |
187 | /* |
188 | * Add a four byte header containing the port number and the number of |
189 | * bytes of data in the message. Return the number of bytes in the |
190 | * buffer. |
191 | */ |
192 | static int mxuport_prepare_write_buffer(struct usb_serial_port *port, |
193 | void *dest, size_t size) |
194 | { |
195 | u8 *buf = dest; |
196 | int count; |
197 | |
198 | count = kfifo_out_locked(&port->write_fifo, buf + HEADER_SIZE, |
199 | size - HEADER_SIZE, |
200 | &port->lock); |
201 | |
202 | put_unaligned_be16(val: port->port_number, p: buf); |
203 | put_unaligned_be16(val: count, p: buf + 2); |
204 | |
205 | dev_dbg(&port->dev, "%s - size %zd count %d\n" , __func__, |
206 | size, count); |
207 | |
208 | return count + HEADER_SIZE; |
209 | } |
210 | |
211 | /* Read the given buffer in from the control pipe. */ |
212 | static int mxuport_recv_ctrl_urb(struct usb_serial *serial, |
213 | u8 request, u16 value, u16 index, |
214 | u8 *data, size_t size) |
215 | { |
216 | int status; |
217 | |
218 | status = usb_control_msg(dev: serial->dev, |
219 | usb_rcvctrlpipe(serial->dev, 0), |
220 | request, |
221 | requesttype: (USB_DIR_IN | USB_TYPE_VENDOR | |
222 | USB_RECIP_DEVICE), value, index, |
223 | data, size, |
224 | USB_CTRL_GET_TIMEOUT); |
225 | if (status < 0) { |
226 | dev_err(&serial->interface->dev, |
227 | "%s - usb_control_msg failed (%d)\n" , |
228 | __func__, status); |
229 | return status; |
230 | } |
231 | |
232 | if (status != size) { |
233 | dev_err(&serial->interface->dev, |
234 | "%s - short read (%d / %zd)\n" , |
235 | __func__, status, size); |
236 | return -EIO; |
237 | } |
238 | |
239 | return status; |
240 | } |
241 | |
242 | /* Write the given buffer out to the control pipe. */ |
243 | static int mxuport_send_ctrl_data_urb(struct usb_serial *serial, |
244 | u8 request, |
245 | u16 value, u16 index, |
246 | u8 *data, size_t size) |
247 | { |
248 | int status; |
249 | |
250 | status = usb_control_msg(dev: serial->dev, |
251 | usb_sndctrlpipe(serial->dev, 0), |
252 | request, |
253 | requesttype: (USB_DIR_OUT | USB_TYPE_VENDOR | |
254 | USB_RECIP_DEVICE), value, index, |
255 | data, size, |
256 | USB_CTRL_SET_TIMEOUT); |
257 | if (status < 0) { |
258 | dev_err(&serial->interface->dev, |
259 | "%s - usb_control_msg failed (%d)\n" , |
260 | __func__, status); |
261 | return status; |
262 | } |
263 | |
264 | return 0; |
265 | } |
266 | |
267 | /* Send a vendor request without any data */ |
268 | static int mxuport_send_ctrl_urb(struct usb_serial *serial, |
269 | u8 request, u16 value, u16 index) |
270 | { |
271 | return mxuport_send_ctrl_data_urb(serial, request, value, index, |
272 | NULL, size: 0); |
273 | } |
274 | |
275 | /* |
276 | * mxuport_throttle - throttle function of driver |
277 | * |
278 | * This function is called by the tty driver when it wants to stop the |
279 | * data being read from the port. Since all the data comes over one |
280 | * bulk in endpoint, we cannot stop submitting urbs by setting |
281 | * port->throttle. Instead tell the device to stop sending us data for |
282 | * the port. |
283 | */ |
284 | static void mxuport_throttle(struct tty_struct *tty) |
285 | { |
286 | struct usb_serial_port *port = tty->driver_data; |
287 | struct usb_serial *serial = port->serial; |
288 | |
289 | dev_dbg(&port->dev, "%s\n" , __func__); |
290 | |
291 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN, |
292 | value: 0, index: port->port_number); |
293 | } |
294 | |
295 | /* |
296 | * mxuport_unthrottle - unthrottle function of driver |
297 | * |
298 | * This function is called by the tty driver when it wants to resume |
299 | * the data being read from the port. Tell the device it can resume |
300 | * sending us received data from the port. |
301 | */ |
302 | static void mxuport_unthrottle(struct tty_struct *tty) |
303 | { |
304 | |
305 | struct usb_serial_port *port = tty->driver_data; |
306 | struct usb_serial *serial = port->serial; |
307 | |
308 | dev_dbg(&port->dev, "%s\n" , __func__); |
309 | |
310 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN, |
311 | value: 1, index: port->port_number); |
312 | } |
313 | |
314 | /* |
315 | * Processes one chunk of data received for a port. Mostly a copy of |
316 | * usb_serial_generic_process_read_urb(). |
317 | */ |
318 | static void mxuport_process_read_urb_data(struct usb_serial_port *port, |
319 | char *data, int size) |
320 | { |
321 | int i; |
322 | |
323 | if (port->sysrq) { |
324 | for (i = 0; i < size; i++, data++) { |
325 | if (!usb_serial_handle_sysrq_char(port, ch: *data)) |
326 | tty_insert_flip_char(port: &port->port, ch: *data, |
327 | TTY_NORMAL); |
328 | } |
329 | } else { |
330 | tty_insert_flip_string(port: &port->port, chars: data, size); |
331 | } |
332 | tty_flip_buffer_push(port: &port->port); |
333 | } |
334 | |
335 | static void mxuport_msr_event(struct usb_serial_port *port, u8 buf[4]) |
336 | { |
337 | struct mxuport_port *mxport = usb_get_serial_port_data(port); |
338 | u8 rcv_msr_hold = buf[2] & 0xF0; |
339 | u16 rcv_msr_event = get_unaligned_be16(p: buf); |
340 | unsigned long flags; |
341 | |
342 | if (rcv_msr_event == 0) |
343 | return; |
344 | |
345 | /* Update MSR status */ |
346 | spin_lock_irqsave(&mxport->spinlock, flags); |
347 | |
348 | dev_dbg(&port->dev, "%s - current MSR status = 0x%x\n" , |
349 | __func__, mxport->msr_state); |
350 | |
351 | if (rcv_msr_hold & UART_MSR_CTS) { |
352 | mxport->msr_state |= UART_MSR_CTS; |
353 | dev_dbg(&port->dev, "%s - CTS high\n" , __func__); |
354 | } else { |
355 | mxport->msr_state &= ~UART_MSR_CTS; |
356 | dev_dbg(&port->dev, "%s - CTS low\n" , __func__); |
357 | } |
358 | |
359 | if (rcv_msr_hold & UART_MSR_DSR) { |
360 | mxport->msr_state |= UART_MSR_DSR; |
361 | dev_dbg(&port->dev, "%s - DSR high\n" , __func__); |
362 | } else { |
363 | mxport->msr_state &= ~UART_MSR_DSR; |
364 | dev_dbg(&port->dev, "%s - DSR low\n" , __func__); |
365 | } |
366 | |
367 | if (rcv_msr_hold & UART_MSR_DCD) { |
368 | mxport->msr_state |= UART_MSR_DCD; |
369 | dev_dbg(&port->dev, "%s - DCD high\n" , __func__); |
370 | } else { |
371 | mxport->msr_state &= ~UART_MSR_DCD; |
372 | dev_dbg(&port->dev, "%s - DCD low\n" , __func__); |
373 | } |
374 | spin_unlock_irqrestore(lock: &mxport->spinlock, flags); |
375 | |
376 | if (rcv_msr_event & |
377 | (SERIAL_EV_CTS | SERIAL_EV_DSR | SERIAL_EV_RLSD)) { |
378 | |
379 | if (rcv_msr_event & SERIAL_EV_CTS) { |
380 | port->icount.cts++; |
381 | dev_dbg(&port->dev, "%s - CTS change\n" , __func__); |
382 | } |
383 | |
384 | if (rcv_msr_event & SERIAL_EV_DSR) { |
385 | port->icount.dsr++; |
386 | dev_dbg(&port->dev, "%s - DSR change\n" , __func__); |
387 | } |
388 | |
389 | if (rcv_msr_event & SERIAL_EV_RLSD) { |
390 | port->icount.dcd++; |
391 | dev_dbg(&port->dev, "%s - DCD change\n" , __func__); |
392 | } |
393 | wake_up_interruptible(&port->port.delta_msr_wait); |
394 | } |
395 | } |
396 | |
397 | static void mxuport_lsr_event(struct usb_serial_port *port, u8 buf[4]) |
398 | { |
399 | u8 lsr_event = buf[2]; |
400 | |
401 | if (lsr_event & UART_LSR_BI) { |
402 | port->icount.brk++; |
403 | dev_dbg(&port->dev, "%s - break error\n" , __func__); |
404 | } |
405 | |
406 | if (lsr_event & UART_LSR_FE) { |
407 | port->icount.frame++; |
408 | dev_dbg(&port->dev, "%s - frame error\n" , __func__); |
409 | } |
410 | |
411 | if (lsr_event & UART_LSR_PE) { |
412 | port->icount.parity++; |
413 | dev_dbg(&port->dev, "%s - parity error\n" , __func__); |
414 | } |
415 | |
416 | if (lsr_event & UART_LSR_OE) { |
417 | port->icount.overrun++; |
418 | dev_dbg(&port->dev, "%s - overrun error\n" , __func__); |
419 | } |
420 | } |
421 | |
422 | /* |
423 | * When something interesting happens, modem control lines XON/XOFF |
424 | * etc, the device sends an event. Process these events. |
425 | */ |
426 | static void mxuport_process_read_urb_event(struct usb_serial_port *port, |
427 | u8 buf[4], u32 event) |
428 | { |
429 | dev_dbg(&port->dev, "%s - receive event : %04x\n" , __func__, event); |
430 | |
431 | switch (event) { |
432 | case UPORT_EVENT_SEND_NEXT: |
433 | /* |
434 | * Sent as part of the flow control on device buffers. |
435 | * Not currently used. |
436 | */ |
437 | break; |
438 | case UPORT_EVENT_MSR: |
439 | mxuport_msr_event(port, buf); |
440 | break; |
441 | case UPORT_EVENT_LSR: |
442 | mxuport_lsr_event(port, buf); |
443 | break; |
444 | case UPORT_EVENT_MCR: |
445 | /* |
446 | * Event to indicate a change in XON/XOFF from the |
447 | * peer. Currently not used. We just continue |
448 | * sending the device data and it will buffer it if |
449 | * needed. This event could be used for flow control |
450 | * between the host and the device. |
451 | */ |
452 | break; |
453 | default: |
454 | dev_dbg(&port->dev, "Unexpected event\n" ); |
455 | break; |
456 | } |
457 | } |
458 | |
459 | /* |
460 | * One URB can contain data for multiple ports. Demultiplex the data, |
461 | * checking the port exists, is opened and the message is valid. |
462 | */ |
463 | static void mxuport_process_read_urb_demux_data(struct urb *urb) |
464 | { |
465 | struct usb_serial_port *port = urb->context; |
466 | struct usb_serial *serial = port->serial; |
467 | u8 *data = urb->transfer_buffer; |
468 | u8 *end = data + urb->actual_length; |
469 | struct usb_serial_port *demux_port; |
470 | u8 *ch; |
471 | u16 rcv_port; |
472 | u16 rcv_len; |
473 | |
474 | while (data < end) { |
475 | if (data + HEADER_SIZE > end) { |
476 | dev_warn(&port->dev, "%s - message with short header\n" , |
477 | __func__); |
478 | return; |
479 | } |
480 | |
481 | rcv_port = get_unaligned_be16(p: data); |
482 | if (rcv_port >= serial->num_ports) { |
483 | dev_warn(&port->dev, "%s - message for invalid port\n" , |
484 | __func__); |
485 | return; |
486 | } |
487 | |
488 | demux_port = serial->port[rcv_port]; |
489 | rcv_len = get_unaligned_be16(p: data + 2); |
490 | if (!rcv_len || data + HEADER_SIZE + rcv_len > end) { |
491 | dev_warn(&port->dev, "%s - short data\n" , __func__); |
492 | return; |
493 | } |
494 | |
495 | if (tty_port_initialized(port: &demux_port->port)) { |
496 | ch = data + HEADER_SIZE; |
497 | mxuport_process_read_urb_data(port: demux_port, data: ch, size: rcv_len); |
498 | } else { |
499 | dev_dbg(&demux_port->dev, "%s - data for closed port\n" , |
500 | __func__); |
501 | } |
502 | data += HEADER_SIZE + rcv_len; |
503 | } |
504 | } |
505 | |
506 | /* |
507 | * One URB can contain events for multiple ports. Demultiplex the event, |
508 | * checking the port exists, and is opened. |
509 | */ |
510 | static void mxuport_process_read_urb_demux_event(struct urb *urb) |
511 | { |
512 | struct usb_serial_port *port = urb->context; |
513 | struct usb_serial *serial = port->serial; |
514 | u8 *data = urb->transfer_buffer; |
515 | u8 *end = data + urb->actual_length; |
516 | struct usb_serial_port *demux_port; |
517 | u8 *ch; |
518 | u16 rcv_port; |
519 | u16 rcv_event; |
520 | |
521 | while (data < end) { |
522 | if (data + EVENT_LENGTH > end) { |
523 | dev_warn(&port->dev, "%s - message with short event\n" , |
524 | __func__); |
525 | return; |
526 | } |
527 | |
528 | rcv_port = get_unaligned_be16(p: data); |
529 | if (rcv_port >= serial->num_ports) { |
530 | dev_warn(&port->dev, "%s - message for invalid port\n" , |
531 | __func__); |
532 | return; |
533 | } |
534 | |
535 | demux_port = serial->port[rcv_port]; |
536 | if (tty_port_initialized(port: &demux_port->port)) { |
537 | ch = data + HEADER_SIZE; |
538 | rcv_event = get_unaligned_be16(p: data + 2); |
539 | mxuport_process_read_urb_event(port: demux_port, buf: ch, |
540 | event: rcv_event); |
541 | } else { |
542 | dev_dbg(&demux_port->dev, |
543 | "%s - event for closed port\n" , __func__); |
544 | } |
545 | data += EVENT_LENGTH; |
546 | } |
547 | } |
548 | |
549 | /* |
550 | * This is called when we have received data on the bulk in |
551 | * endpoint. Depending on which port it was received on, it can |
552 | * contain serial data or events. |
553 | */ |
554 | static void mxuport_process_read_urb(struct urb *urb) |
555 | { |
556 | struct usb_serial_port *port = urb->context; |
557 | struct usb_serial *serial = port->serial; |
558 | |
559 | if (port == serial->port[0]) |
560 | mxuport_process_read_urb_demux_data(urb); |
561 | |
562 | if (port == serial->port[1]) |
563 | mxuport_process_read_urb_demux_event(urb); |
564 | } |
565 | |
566 | /* |
567 | * Ask the device how many bytes it has queued to be sent out. If |
568 | * there are none, return true. |
569 | */ |
570 | static bool mxuport_tx_empty(struct usb_serial_port *port) |
571 | { |
572 | struct usb_serial *serial = port->serial; |
573 | bool is_empty = true; |
574 | u32 txlen; |
575 | u8 *len_buf; |
576 | int err; |
577 | |
578 | len_buf = kzalloc(size: 4, GFP_KERNEL); |
579 | if (!len_buf) |
580 | goto out; |
581 | |
582 | err = mxuport_recv_ctrl_urb(serial, RQ_VENDOR_GET_OUTQUEUE, value: 0, |
583 | index: port->port_number, data: len_buf, size: 4); |
584 | if (err < 0) |
585 | goto out; |
586 | |
587 | txlen = get_unaligned_be32(p: len_buf); |
588 | dev_dbg(&port->dev, "%s - tx len = %u\n" , __func__, txlen); |
589 | |
590 | if (txlen != 0) |
591 | is_empty = false; |
592 | |
593 | out: |
594 | kfree(objp: len_buf); |
595 | return is_empty; |
596 | } |
597 | |
598 | static int mxuport_set_mcr(struct usb_serial_port *port, u8 mcr_state) |
599 | { |
600 | struct usb_serial *serial = port->serial; |
601 | int err; |
602 | |
603 | dev_dbg(&port->dev, "%s - %02x\n" , __func__, mcr_state); |
604 | |
605 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_MCR, |
606 | value: mcr_state, index: port->port_number); |
607 | if (err) |
608 | dev_err(&port->dev, "%s - failed to change MCR\n" , __func__); |
609 | |
610 | return err; |
611 | } |
612 | |
613 | static int mxuport_set_dtr(struct usb_serial_port *port, int on) |
614 | { |
615 | struct mxuport_port *mxport = usb_get_serial_port_data(port); |
616 | struct usb_serial *serial = port->serial; |
617 | int err; |
618 | |
619 | mutex_lock(&mxport->mutex); |
620 | |
621 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_DTR, |
622 | value: !!on, index: port->port_number); |
623 | if (!err) { |
624 | if (on) |
625 | mxport->mcr_state |= UART_MCR_DTR; |
626 | else |
627 | mxport->mcr_state &= ~UART_MCR_DTR; |
628 | } |
629 | |
630 | mutex_unlock(lock: &mxport->mutex); |
631 | |
632 | return err; |
633 | } |
634 | |
635 | static int mxuport_set_rts(struct usb_serial_port *port, u8 state) |
636 | { |
637 | struct mxuport_port *mxport = usb_get_serial_port_data(port); |
638 | struct usb_serial *serial = port->serial; |
639 | int err; |
640 | u8 mcr_state; |
641 | |
642 | mutex_lock(&mxport->mutex); |
643 | mcr_state = mxport->mcr_state; |
644 | |
645 | switch (state) { |
646 | case MX_RTS_DISABLE: |
647 | mcr_state &= ~UART_MCR_RTS; |
648 | break; |
649 | case MX_RTS_ENABLE: |
650 | mcr_state |= UART_MCR_RTS; |
651 | break; |
652 | case MX_RTS_HW: |
653 | /* |
654 | * Do not update mxport->mcr_state when doing hardware |
655 | * flow control. |
656 | */ |
657 | break; |
658 | default: |
659 | /* |
660 | * Should not happen, but somebody might try passing |
661 | * MX_RTS_NO_CHANGE, which is not valid. |
662 | */ |
663 | err = -EINVAL; |
664 | goto out; |
665 | } |
666 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RTS, |
667 | value: state, index: port->port_number); |
668 | if (!err) |
669 | mxport->mcr_state = mcr_state; |
670 | |
671 | out: |
672 | mutex_unlock(lock: &mxport->mutex); |
673 | |
674 | return err; |
675 | } |
676 | |
677 | static void mxuport_dtr_rts(struct usb_serial_port *port, int on) |
678 | { |
679 | struct mxuport_port *mxport = usb_get_serial_port_data(port); |
680 | u8 mcr_state; |
681 | int err; |
682 | |
683 | mutex_lock(&mxport->mutex); |
684 | mcr_state = mxport->mcr_state; |
685 | |
686 | if (on) |
687 | mcr_state |= (UART_MCR_RTS | UART_MCR_DTR); |
688 | else |
689 | mcr_state &= ~(UART_MCR_RTS | UART_MCR_DTR); |
690 | |
691 | err = mxuport_set_mcr(port, mcr_state); |
692 | if (!err) |
693 | mxport->mcr_state = mcr_state; |
694 | |
695 | mutex_unlock(lock: &mxport->mutex); |
696 | } |
697 | |
698 | static int mxuport_tiocmset(struct tty_struct *tty, unsigned int set, |
699 | unsigned int clear) |
700 | { |
701 | struct usb_serial_port *port = tty->driver_data; |
702 | struct mxuport_port *mxport = usb_get_serial_port_data(port); |
703 | int err; |
704 | u8 mcr_state; |
705 | |
706 | mutex_lock(&mxport->mutex); |
707 | mcr_state = mxport->mcr_state; |
708 | |
709 | if (set & TIOCM_RTS) |
710 | mcr_state |= UART_MCR_RTS; |
711 | |
712 | if (set & TIOCM_DTR) |
713 | mcr_state |= UART_MCR_DTR; |
714 | |
715 | if (clear & TIOCM_RTS) |
716 | mcr_state &= ~UART_MCR_RTS; |
717 | |
718 | if (clear & TIOCM_DTR) |
719 | mcr_state &= ~UART_MCR_DTR; |
720 | |
721 | err = mxuport_set_mcr(port, mcr_state); |
722 | if (!err) |
723 | mxport->mcr_state = mcr_state; |
724 | |
725 | mutex_unlock(lock: &mxport->mutex); |
726 | |
727 | return err; |
728 | } |
729 | |
730 | static int mxuport_tiocmget(struct tty_struct *tty) |
731 | { |
732 | struct mxuport_port *mxport; |
733 | struct usb_serial_port *port = tty->driver_data; |
734 | unsigned int result; |
735 | unsigned long flags; |
736 | unsigned int msr; |
737 | unsigned int mcr; |
738 | |
739 | mxport = usb_get_serial_port_data(port); |
740 | |
741 | mutex_lock(&mxport->mutex); |
742 | spin_lock_irqsave(&mxport->spinlock, flags); |
743 | |
744 | msr = mxport->msr_state; |
745 | mcr = mxport->mcr_state; |
746 | |
747 | spin_unlock_irqrestore(lock: &mxport->spinlock, flags); |
748 | mutex_unlock(lock: &mxport->mutex); |
749 | |
750 | result = (((mcr & UART_MCR_DTR) ? TIOCM_DTR : 0) | /* 0x002 */ |
751 | ((mcr & UART_MCR_RTS) ? TIOCM_RTS : 0) | /* 0x004 */ |
752 | ((msr & UART_MSR_CTS) ? TIOCM_CTS : 0) | /* 0x020 */ |
753 | ((msr & UART_MSR_DCD) ? TIOCM_CAR : 0) | /* 0x040 */ |
754 | ((msr & UART_MSR_RI) ? TIOCM_RI : 0) | /* 0x080 */ |
755 | ((msr & UART_MSR_DSR) ? TIOCM_DSR : 0)); /* 0x100 */ |
756 | |
757 | dev_dbg(&port->dev, "%s - 0x%04x\n" , __func__, result); |
758 | |
759 | return result; |
760 | } |
761 | |
762 | static int mxuport_set_termios_flow(struct tty_struct *tty, |
763 | const struct ktermios *old_termios, |
764 | struct usb_serial_port *port, |
765 | struct usb_serial *serial) |
766 | { |
767 | u8 xon = START_CHAR(tty); |
768 | u8 xoff = STOP_CHAR(tty); |
769 | int enable; |
770 | int err; |
771 | u8 *buf; |
772 | u8 rts; |
773 | |
774 | buf = kmalloc(size: 2, GFP_KERNEL); |
775 | if (!buf) |
776 | return -ENOMEM; |
777 | |
778 | /* S/W flow control settings */ |
779 | if (I_IXOFF(tty) || I_IXON(tty)) { |
780 | enable = 1; |
781 | buf[0] = xon; |
782 | buf[1] = xoff; |
783 | |
784 | err = mxuport_send_ctrl_data_urb(serial, RQ_VENDOR_SET_CHARS, |
785 | value: 0, index: port->port_number, |
786 | data: buf, size: 2); |
787 | if (err) |
788 | goto out; |
789 | |
790 | dev_dbg(&port->dev, "%s - XON = 0x%02x, XOFF = 0x%02x\n" , |
791 | __func__, xon, xoff); |
792 | } else { |
793 | enable = 0; |
794 | } |
795 | |
796 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_XONXOFF, |
797 | value: enable, index: port->port_number); |
798 | if (err) |
799 | goto out; |
800 | |
801 | rts = MX_RTS_NO_CHANGE; |
802 | |
803 | /* H/W flow control settings */ |
804 | if (!old_termios || |
805 | C_CRTSCTS(tty) != (old_termios->c_cflag & CRTSCTS)) { |
806 | if (C_CRTSCTS(tty)) |
807 | rts = MX_RTS_HW; |
808 | else |
809 | rts = MX_RTS_ENABLE; |
810 | } |
811 | |
812 | if (C_BAUD(tty)) { |
813 | if (old_termios && (old_termios->c_cflag & CBAUD) == B0) { |
814 | /* Raise DTR and RTS */ |
815 | if (C_CRTSCTS(tty)) |
816 | rts = MX_RTS_HW; |
817 | else |
818 | rts = MX_RTS_ENABLE; |
819 | mxuport_set_dtr(port, on: 1); |
820 | } |
821 | } else { |
822 | /* Drop DTR and RTS */ |
823 | rts = MX_RTS_DISABLE; |
824 | mxuport_set_dtr(port, on: 0); |
825 | } |
826 | |
827 | if (rts != MX_RTS_NO_CHANGE) |
828 | err = mxuport_set_rts(port, state: rts); |
829 | |
830 | out: |
831 | kfree(objp: buf); |
832 | return err; |
833 | } |
834 | |
835 | static void mxuport_set_termios(struct tty_struct *tty, |
836 | struct usb_serial_port *port, |
837 | const struct ktermios *old_termios) |
838 | { |
839 | struct usb_serial *serial = port->serial; |
840 | u8 *buf; |
841 | u8 data_bits; |
842 | u8 stop_bits; |
843 | u8 parity; |
844 | int baud; |
845 | int err; |
846 | |
847 | if (old_termios && |
848 | !tty_termios_hw_change(a: &tty->termios, b: old_termios) && |
849 | tty->termios.c_iflag == old_termios->c_iflag) { |
850 | dev_dbg(&port->dev, "%s - nothing to change\n" , __func__); |
851 | return; |
852 | } |
853 | |
854 | buf = kmalloc(size: 4, GFP_KERNEL); |
855 | if (!buf) |
856 | return; |
857 | |
858 | /* Set data bit of termios */ |
859 | switch (C_CSIZE(tty)) { |
860 | case CS5: |
861 | data_bits = MX_WORDLENGTH_5; |
862 | break; |
863 | case CS6: |
864 | data_bits = MX_WORDLENGTH_6; |
865 | break; |
866 | case CS7: |
867 | data_bits = MX_WORDLENGTH_7; |
868 | break; |
869 | case CS8: |
870 | default: |
871 | data_bits = MX_WORDLENGTH_8; |
872 | break; |
873 | } |
874 | |
875 | /* Set parity of termios */ |
876 | if (C_PARENB(tty)) { |
877 | if (C_CMSPAR(tty)) { |
878 | if (C_PARODD(tty)) |
879 | parity = MX_PARITY_MARK; |
880 | else |
881 | parity = MX_PARITY_SPACE; |
882 | } else { |
883 | if (C_PARODD(tty)) |
884 | parity = MX_PARITY_ODD; |
885 | else |
886 | parity = MX_PARITY_EVEN; |
887 | } |
888 | } else { |
889 | parity = MX_PARITY_NONE; |
890 | } |
891 | |
892 | /* Set stop bit of termios */ |
893 | if (C_CSTOPB(tty)) |
894 | stop_bits = MX_STOP_BITS_2; |
895 | else |
896 | stop_bits = MX_STOP_BITS_1; |
897 | |
898 | buf[0] = data_bits; |
899 | buf[1] = parity; |
900 | buf[2] = stop_bits; |
901 | buf[3] = 0; |
902 | |
903 | err = mxuport_send_ctrl_data_urb(serial, RQ_VENDOR_SET_LINE, |
904 | value: 0, index: port->port_number, data: buf, size: 4); |
905 | if (err) |
906 | goto out; |
907 | |
908 | err = mxuport_set_termios_flow(tty, old_termios, port, serial); |
909 | if (err) |
910 | goto out; |
911 | |
912 | baud = tty_get_baud_rate(tty); |
913 | if (!baud) |
914 | baud = 9600; |
915 | |
916 | /* Note: Little Endian */ |
917 | put_unaligned_le32(val: baud, p: buf); |
918 | |
919 | err = mxuport_send_ctrl_data_urb(serial, RQ_VENDOR_SET_BAUD, |
920 | value: 0, index: port->port_number, |
921 | data: buf, size: 4); |
922 | if (err) |
923 | goto out; |
924 | |
925 | dev_dbg(&port->dev, "baud_rate : %d\n" , baud); |
926 | dev_dbg(&port->dev, "data_bits : %d\n" , data_bits); |
927 | dev_dbg(&port->dev, "parity : %d\n" , parity); |
928 | dev_dbg(&port->dev, "stop_bits : %d\n" , stop_bits); |
929 | |
930 | out: |
931 | kfree(objp: buf); |
932 | } |
933 | |
934 | /* |
935 | * Determine how many ports this device has dynamically. It will be |
936 | * called after the probe() callback is called, but before attach(). |
937 | */ |
938 | static int mxuport_calc_num_ports(struct usb_serial *serial, |
939 | struct usb_serial_endpoints *epds) |
940 | { |
941 | unsigned long features = (unsigned long)usb_get_serial_data(serial); |
942 | int num_ports; |
943 | int i; |
944 | |
945 | if (features & MX_UPORT_2_PORT) { |
946 | num_ports = 2; |
947 | } else if (features & MX_UPORT_4_PORT) { |
948 | num_ports = 4; |
949 | } else if (features & MX_UPORT_8_PORT) { |
950 | num_ports = 8; |
951 | } else if (features & MX_UPORT_16_PORT) { |
952 | num_ports = 16; |
953 | } else { |
954 | dev_warn(&serial->interface->dev, |
955 | "unknown device, assuming two ports\n" ); |
956 | num_ports = 2; |
957 | } |
958 | |
959 | /* |
960 | * Setup bulk-out endpoint multiplexing. All ports share the same |
961 | * bulk-out endpoint. |
962 | */ |
963 | BUILD_BUG_ON(ARRAY_SIZE(epds->bulk_out) < 16); |
964 | |
965 | for (i = 1; i < num_ports; ++i) |
966 | epds->bulk_out[i] = epds->bulk_out[0]; |
967 | |
968 | epds->num_bulk_out = num_ports; |
969 | |
970 | return num_ports; |
971 | } |
972 | |
973 | /* Get the version of the firmware currently running. */ |
974 | static int mxuport_get_fw_version(struct usb_serial *serial, u32 *version) |
975 | { |
976 | u8 *ver_buf; |
977 | int err; |
978 | |
979 | ver_buf = kzalloc(size: 4, GFP_KERNEL); |
980 | if (!ver_buf) |
981 | return -ENOMEM; |
982 | |
983 | /* Get firmware version from SDRAM */ |
984 | err = mxuport_recv_ctrl_urb(serial, RQ_VENDOR_GET_VERSION, value: 0, index: 0, |
985 | data: ver_buf, size: 4); |
986 | if (err != 4) { |
987 | err = -EIO; |
988 | goto out; |
989 | } |
990 | |
991 | *version = (ver_buf[0] << 16) | (ver_buf[1] << 8) | ver_buf[2]; |
992 | err = 0; |
993 | out: |
994 | kfree(objp: ver_buf); |
995 | return err; |
996 | } |
997 | |
998 | /* Given a firmware blob, download it to the device. */ |
999 | static int mxuport_download_fw(struct usb_serial *serial, |
1000 | const struct firmware *fw_p) |
1001 | { |
1002 | u8 *fw_buf; |
1003 | size_t txlen; |
1004 | size_t fwidx; |
1005 | int err; |
1006 | |
1007 | fw_buf = kmalloc(DOWN_BLOCK_SIZE, GFP_KERNEL); |
1008 | if (!fw_buf) |
1009 | return -ENOMEM; |
1010 | |
1011 | dev_dbg(&serial->interface->dev, "Starting firmware download...\n" ); |
1012 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_START_FW_DOWN, value: 0, index: 0); |
1013 | if (err) |
1014 | goto out; |
1015 | |
1016 | fwidx = 0; |
1017 | do { |
1018 | txlen = min_t(size_t, (fw_p->size - fwidx), DOWN_BLOCK_SIZE); |
1019 | |
1020 | memcpy(fw_buf, &fw_p->data[fwidx], txlen); |
1021 | err = mxuport_send_ctrl_data_urb(serial, RQ_VENDOR_FW_DATA, |
1022 | value: 0, index: 0, data: fw_buf, size: txlen); |
1023 | if (err) { |
1024 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_STOP_FW_DOWN, |
1025 | value: 0, index: 0); |
1026 | goto out; |
1027 | } |
1028 | |
1029 | fwidx += txlen; |
1030 | usleep_range(min: 1000, max: 2000); |
1031 | |
1032 | } while (fwidx < fw_p->size); |
1033 | |
1034 | msleep(msecs: 1000); |
1035 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_STOP_FW_DOWN, value: 0, index: 0); |
1036 | if (err) |
1037 | goto out; |
1038 | |
1039 | msleep(msecs: 1000); |
1040 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_QUERY_FW_READY, value: 0, index: 0); |
1041 | |
1042 | out: |
1043 | kfree(objp: fw_buf); |
1044 | return err; |
1045 | } |
1046 | |
1047 | static int mxuport_probe(struct usb_serial *serial, |
1048 | const struct usb_device_id *id) |
1049 | { |
1050 | u16 productid = le16_to_cpu(serial->dev->descriptor.idProduct); |
1051 | const struct firmware *fw_p = NULL; |
1052 | u32 version; |
1053 | int local_ver; |
1054 | char buf[32]; |
1055 | int err; |
1056 | |
1057 | /* Load our firmware */ |
1058 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_QUERY_FW_CONFIG, value: 0, index: 0); |
1059 | if (err) { |
1060 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_RESET_DEVICE, value: 0, index: 0); |
1061 | return err; |
1062 | } |
1063 | |
1064 | err = mxuport_get_fw_version(serial, version: &version); |
1065 | if (err < 0) |
1066 | return err; |
1067 | |
1068 | dev_dbg(&serial->interface->dev, "Device firmware version v%x.%x.%x\n" , |
1069 | (version & 0xff0000) >> 16, |
1070 | (version & 0xff00) >> 8, |
1071 | (version & 0xff)); |
1072 | |
1073 | snprintf(buf, size: sizeof(buf) - 1, fmt: "moxa/moxa-%04x.fw" , productid); |
1074 | |
1075 | err = request_firmware(fw: &fw_p, name: buf, device: &serial->interface->dev); |
1076 | if (err) { |
1077 | dev_warn(&serial->interface->dev, "Firmware %s not found\n" , |
1078 | buf); |
1079 | |
1080 | /* Use the firmware already in the device */ |
1081 | err = 0; |
1082 | } else { |
1083 | local_ver = ((fw_p->data[VER_ADDR_1] << 16) | |
1084 | (fw_p->data[VER_ADDR_2] << 8) | |
1085 | fw_p->data[VER_ADDR_3]); |
1086 | dev_dbg(&serial->interface->dev, |
1087 | "Available firmware version v%x.%x.%x\n" , |
1088 | fw_p->data[VER_ADDR_1], fw_p->data[VER_ADDR_2], |
1089 | fw_p->data[VER_ADDR_3]); |
1090 | if (local_ver > version) { |
1091 | err = mxuport_download_fw(serial, fw_p); |
1092 | if (err) |
1093 | goto out; |
1094 | err = mxuport_get_fw_version(serial, version: &version); |
1095 | if (err < 0) |
1096 | goto out; |
1097 | } |
1098 | } |
1099 | |
1100 | dev_info(&serial->interface->dev, |
1101 | "Using device firmware version v%x.%x.%x\n" , |
1102 | (version & 0xff0000) >> 16, |
1103 | (version & 0xff00) >> 8, |
1104 | (version & 0xff)); |
1105 | |
1106 | /* |
1107 | * Contains the features of this hardware. Store away for |
1108 | * later use, eg, number of ports. |
1109 | */ |
1110 | usb_set_serial_data(serial, data: (void *)id->driver_info); |
1111 | out: |
1112 | if (fw_p) |
1113 | release_firmware(fw: fw_p); |
1114 | return err; |
1115 | } |
1116 | |
1117 | |
1118 | static int mxuport_port_probe(struct usb_serial_port *port) |
1119 | { |
1120 | struct usb_serial *serial = port->serial; |
1121 | struct mxuport_port *mxport; |
1122 | int err; |
1123 | |
1124 | mxport = devm_kzalloc(dev: &port->dev, size: sizeof(struct mxuport_port), |
1125 | GFP_KERNEL); |
1126 | if (!mxport) |
1127 | return -ENOMEM; |
1128 | |
1129 | mutex_init(&mxport->mutex); |
1130 | spin_lock_init(&mxport->spinlock); |
1131 | |
1132 | /* Set the port private data */ |
1133 | usb_set_serial_port_data(port, data: mxport); |
1134 | |
1135 | /* Set FIFO (Enable) */ |
1136 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_FIFO_DISABLE, |
1137 | value: 0, index: port->port_number); |
1138 | if (err) |
1139 | return err; |
1140 | |
1141 | /* Set transmission mode (Hi-Performance) */ |
1142 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_HIGH_PERFOR, |
1143 | value: 0, index: port->port_number); |
1144 | if (err) |
1145 | return err; |
1146 | |
1147 | /* Set interface (RS-232) */ |
1148 | return mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_INTERFACE, |
1149 | MX_INT_RS232, |
1150 | index: port->port_number); |
1151 | } |
1152 | |
1153 | static int mxuport_attach(struct usb_serial *serial) |
1154 | { |
1155 | struct usb_serial_port *port0 = serial->port[0]; |
1156 | struct usb_serial_port *port1 = serial->port[1]; |
1157 | int err; |
1158 | |
1159 | /* |
1160 | * All data from the ports is received on the first bulk in |
1161 | * endpoint, with a multiplex header. The second bulk in is |
1162 | * used for events. |
1163 | * |
1164 | * Start to read from the device. |
1165 | */ |
1166 | err = usb_serial_generic_submit_read_urbs(port: port0, GFP_KERNEL); |
1167 | if (err) |
1168 | return err; |
1169 | |
1170 | err = usb_serial_generic_submit_read_urbs(port: port1, GFP_KERNEL); |
1171 | if (err) { |
1172 | usb_serial_generic_close(port: port0); |
1173 | return err; |
1174 | } |
1175 | |
1176 | return 0; |
1177 | } |
1178 | |
1179 | static void mxuport_release(struct usb_serial *serial) |
1180 | { |
1181 | struct usb_serial_port *port0 = serial->port[0]; |
1182 | struct usb_serial_port *port1 = serial->port[1]; |
1183 | |
1184 | usb_serial_generic_close(port: port1); |
1185 | usb_serial_generic_close(port: port0); |
1186 | } |
1187 | |
1188 | static int mxuport_open(struct tty_struct *tty, struct usb_serial_port *port) |
1189 | { |
1190 | struct mxuport_port *mxport = usb_get_serial_port_data(port); |
1191 | struct usb_serial *serial = port->serial; |
1192 | int err; |
1193 | |
1194 | /* Set receive host (enable) */ |
1195 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN, |
1196 | value: 1, index: port->port_number); |
1197 | if (err) |
1198 | return err; |
1199 | |
1200 | err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_OPEN, |
1201 | value: 1, index: port->port_number); |
1202 | if (err) { |
1203 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN, |
1204 | value: 0, index: port->port_number); |
1205 | return err; |
1206 | } |
1207 | |
1208 | /* Initial port termios */ |
1209 | if (tty) |
1210 | mxuport_set_termios(tty, port, NULL); |
1211 | |
1212 | /* |
1213 | * TODO: use RQ_VENDOR_GET_MSR, once we know what it |
1214 | * returns. |
1215 | */ |
1216 | mxport->msr_state = 0; |
1217 | |
1218 | return err; |
1219 | } |
1220 | |
1221 | static void mxuport_close(struct usb_serial_port *port) |
1222 | { |
1223 | struct usb_serial *serial = port->serial; |
1224 | |
1225 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_OPEN, value: 0, |
1226 | index: port->port_number); |
1227 | |
1228 | mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN, value: 0, |
1229 | index: port->port_number); |
1230 | } |
1231 | |
1232 | /* Send a break to the port. */ |
1233 | static int mxuport_break_ctl(struct tty_struct *tty, int break_state) |
1234 | { |
1235 | struct usb_serial_port *port = tty->driver_data; |
1236 | struct usb_serial *serial = port->serial; |
1237 | int enable; |
1238 | |
1239 | if (break_state == -1) { |
1240 | enable = 1; |
1241 | dev_dbg(&port->dev, "%s - sending break\n" , __func__); |
1242 | } else { |
1243 | enable = 0; |
1244 | dev_dbg(&port->dev, "%s - clearing break\n" , __func__); |
1245 | } |
1246 | |
1247 | return mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_BREAK, |
1248 | value: enable, index: port->port_number); |
1249 | } |
1250 | |
1251 | static int mxuport_resume(struct usb_serial *serial) |
1252 | { |
1253 | struct usb_serial_port *port; |
1254 | int c = 0; |
1255 | int i; |
1256 | int r; |
1257 | |
1258 | for (i = 0; i < 2; i++) { |
1259 | port = serial->port[i]; |
1260 | |
1261 | r = usb_serial_generic_submit_read_urbs(port, GFP_NOIO); |
1262 | if (r < 0) |
1263 | c++; |
1264 | } |
1265 | |
1266 | for (i = 0; i < serial->num_ports; i++) { |
1267 | port = serial->port[i]; |
1268 | if (!tty_port_initialized(port: &port->port)) |
1269 | continue; |
1270 | |
1271 | r = usb_serial_generic_write_start(port, GFP_NOIO); |
1272 | if (r < 0) |
1273 | c++; |
1274 | } |
1275 | |
1276 | return c ? -EIO : 0; |
1277 | } |
1278 | |
1279 | static struct usb_serial_driver mxuport_device = { |
1280 | .driver = { |
1281 | .owner = THIS_MODULE, |
1282 | .name = "mxuport" , |
1283 | }, |
1284 | .description = "MOXA UPort" , |
1285 | .id_table = mxuport_idtable, |
1286 | .num_bulk_in = 2, |
1287 | .num_bulk_out = 1, |
1288 | .probe = mxuport_probe, |
1289 | .port_probe = mxuport_port_probe, |
1290 | .attach = mxuport_attach, |
1291 | .release = mxuport_release, |
1292 | .calc_num_ports = mxuport_calc_num_ports, |
1293 | .open = mxuport_open, |
1294 | .close = mxuport_close, |
1295 | .set_termios = mxuport_set_termios, |
1296 | .break_ctl = mxuport_break_ctl, |
1297 | .tx_empty = mxuport_tx_empty, |
1298 | .tiocmiwait = usb_serial_generic_tiocmiwait, |
1299 | .get_icount = usb_serial_generic_get_icount, |
1300 | .throttle = mxuport_throttle, |
1301 | .unthrottle = mxuport_unthrottle, |
1302 | .tiocmget = mxuport_tiocmget, |
1303 | .tiocmset = mxuport_tiocmset, |
1304 | .dtr_rts = mxuport_dtr_rts, |
1305 | .process_read_urb = mxuport_process_read_urb, |
1306 | .prepare_write_buffer = mxuport_prepare_write_buffer, |
1307 | .resume = mxuport_resume, |
1308 | }; |
1309 | |
1310 | static struct usb_serial_driver *const serial_drivers[] = { |
1311 | &mxuport_device, NULL |
1312 | }; |
1313 | |
1314 | module_usb_serial_driver(serial_drivers, mxuport_idtable); |
1315 | |
1316 | MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>" ); |
1317 | MODULE_AUTHOR("<support@moxa.com>" ); |
1318 | MODULE_LICENSE("GPL" ); |
1319 | |