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