Version:  2.0.40 2.2.26 2.4.37 2.6.39 3.0 3.1 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15

Linux/drivers/usb/serial/mxuport.c

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

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us