kernel/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         return mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_INTERFACE,
1141                                      MX_INT_RS232,
1142                                      port->port_number);
1143 }
1144
1145 static int mxuport_alloc_write_urb(struct usb_serial *serial,
1146                                    struct usb_serial_port *port,
1147                                    struct usb_serial_port *port0,
1148                                    int j)
1149 {
1150         struct usb_device *dev = interface_to_usbdev(serial->interface);
1151
1152         set_bit(j, &port->write_urbs_free);
1153         port->write_urbs[j] = usb_alloc_urb(0, GFP_KERNEL);
1154         if (!port->write_urbs[j])
1155                 return -ENOMEM;
1156
1157         port->bulk_out_buffers[j] = kmalloc(port0->bulk_out_size, GFP_KERNEL);
1158         if (!port->bulk_out_buffers[j])
1159                 return -ENOMEM;
1160
1161         usb_fill_bulk_urb(port->write_urbs[j], dev,
1162                           usb_sndbulkpipe(dev, port->bulk_out_endpointAddress),
1163                           port->bulk_out_buffers[j],
1164                           port->bulk_out_size,
1165                           serial->type->write_bulk_callback,
1166                           port);
1167         return 0;
1168 }
1169
1170
1171 static int mxuport_alloc_write_urbs(struct usb_serial *serial,
1172                                     struct usb_serial_port *port,
1173                                     struct usb_serial_port *port0)
1174 {
1175         int j;
1176         int ret;
1177
1178         for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
1179                 ret = mxuport_alloc_write_urb(serial, port, port0, j);
1180                 if (ret)
1181                         return ret;
1182         }
1183         return 0;
1184 }
1185
1186
1187 static int mxuport_attach(struct usb_serial *serial)
1188 {
1189         struct usb_serial_port *port0 = serial->port[0];
1190         struct usb_serial_port *port1 = serial->port[1];
1191         struct usb_serial_port *port;
1192         int err;
1193         int i;
1194         int j;
1195
1196         /*
1197          * Throw away all but the first allocated write URBs so we can
1198          * set them up again to fit the multiplexing scheme.
1199          */
1200         for (i = 1; i < serial->num_bulk_out; ++i) {
1201                 port = serial->port[i];
1202                 for (j = 0; j < ARRAY_SIZE(port->write_urbs); ++j) {
1203                         usb_free_urb(port->write_urbs[j]);
1204                         kfree(port->bulk_out_buffers[j]);
1205                         port->write_urbs[j] = NULL;
1206                         port->bulk_out_buffers[j] = NULL;
1207                 }
1208                 port->write_urbs_free = 0;
1209         }
1210
1211         /*
1212          * All write data is sent over the first bulk out endpoint,
1213          * with an added header to indicate the port. Allocate URBs
1214          * for each port to the first bulk out endpoint.
1215          */
1216         for (i = 1; i < serial->num_ports; ++i) {
1217                 port = serial->port[i];
1218                 port->bulk_out_size = port0->bulk_out_size;
1219                 port->bulk_out_endpointAddress =
1220                         port0->bulk_out_endpointAddress;
1221
1222                 err = mxuport_alloc_write_urbs(serial, port, port0);
1223                 if (err)
1224                         return err;
1225
1226                 port->write_urb = port->write_urbs[0];
1227                 port->bulk_out_buffer = port->bulk_out_buffers[0];
1228
1229                 /*
1230                  * Ensure each port has a fifo. The framework only
1231                  * allocates a fifo to ports with a bulk out endpoint,
1232                  * where as we need one for every port.
1233                  */
1234                 if (!kfifo_initialized(&port->write_fifo)) {
1235                         err = kfifo_alloc(&port->write_fifo, PAGE_SIZE,
1236                                           GFP_KERNEL);
1237                         if (err)
1238                                 return err;
1239                 }
1240         }
1241
1242         /*
1243          * All data from the ports is received on the first bulk in
1244          * endpoint, with a multiplex header. The second bulk in is
1245          * used for events.
1246          *
1247          * Start to read from the device.
1248          */
1249         err = usb_serial_generic_submit_read_urbs(port0, GFP_KERNEL);
1250         if (err)
1251                 return err;
1252
1253         err = usb_serial_generic_submit_read_urbs(port1, GFP_KERNEL);
1254         if (err) {
1255                 usb_serial_generic_close(port0);
1256                 return err;
1257         }
1258
1259         return 0;
1260 }
1261
1262 static void mxuport_release(struct usb_serial *serial)
1263 {
1264         struct usb_serial_port *port0 = serial->port[0];
1265         struct usb_serial_port *port1 = serial->port[1];
1266
1267         usb_serial_generic_close(port1);
1268         usb_serial_generic_close(port0);
1269 }
1270
1271 static int mxuport_open(struct tty_struct *tty, struct usb_serial_port *port)
1272 {
1273         struct mxuport_port *mxport = usb_get_serial_port_data(port);
1274         struct usb_serial *serial = port->serial;
1275         int err;
1276
1277         /* Set receive host (enable) */
1278         err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN,
1279                                     1, port->port_number);
1280         if (err)
1281                 return err;
1282
1283         err = mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_OPEN,
1284                                     1, port->port_number);
1285         if (err) {
1286                 mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN,
1287                                       0, port->port_number);
1288                 return err;
1289         }
1290
1291         /* Initial port termios */
1292         if (tty)
1293                 mxuport_set_termios(tty, port, NULL);
1294
1295         /*
1296          * TODO: use RQ_VENDOR_GET_MSR, once we know what it
1297          * returns.
1298          */
1299         mxport->msr_state = 0;
1300
1301         return err;
1302 }
1303
1304 static void mxuport_close(struct usb_serial_port *port)
1305 {
1306         struct usb_serial *serial = port->serial;
1307
1308         mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_OPEN, 0,
1309                               port->port_number);
1310
1311         mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_RX_HOST_EN, 0,
1312                               port->port_number);
1313 }
1314
1315 /* Send a break to the port. */
1316 static void mxuport_break_ctl(struct tty_struct *tty, int break_state)
1317 {
1318         struct usb_serial_port *port = tty->driver_data;
1319         struct usb_serial *serial = port->serial;
1320         int enable;
1321
1322         if (break_state == -1) {
1323                 enable = 1;
1324                 dev_dbg(&port->dev, "%s - sending break\n", __func__);
1325         } else {
1326                 enable = 0;
1327                 dev_dbg(&port->dev, "%s - clearing break\n", __func__);
1328         }
1329
1330         mxuport_send_ctrl_urb(serial, RQ_VENDOR_SET_BREAK,
1331                               enable, port->port_number);
1332 }
1333
1334 static int mxuport_resume(struct usb_serial *serial)
1335 {
1336         struct usb_serial_port *port;
1337         int c = 0;
1338         int i;
1339         int r;
1340
1341         for (i = 0; i < 2; i++) {
1342                 port = serial->port[i];
1343
1344                 r = usb_serial_generic_submit_read_urbs(port, GFP_NOIO);
1345                 if (r < 0)
1346                         c++;
1347         }
1348
1349         for (i = 0; i < serial->num_ports; i++) {
1350                 port = serial->port[i];
1351                 if (!test_bit(ASYNCB_INITIALIZED, &port->port.flags))
1352                         continue;
1353
1354                 r = usb_serial_generic_write_start(port, GFP_NOIO);
1355                 if (r < 0)
1356                         c++;
1357         }
1358
1359         return c ? -EIO : 0;
1360 }
1361
1362 static struct usb_serial_driver mxuport_device = {
1363         .driver = {
1364                 .owner =        THIS_MODULE,
1365                 .name =         "mxuport",
1366         },
1367         .description            = "MOXA UPort",
1368         .id_table               = mxuport_idtable,
1369         .num_ports              = 0,
1370         .probe                  = mxuport_probe,
1371         .port_probe             = mxuport_port_probe,
1372         .attach                 = mxuport_attach,
1373         .release                = mxuport_release,
1374         .calc_num_ports         = mxuport_calc_num_ports,
1375         .open                   = mxuport_open,
1376         .close                  = mxuport_close,
1377         .set_termios            = mxuport_set_termios,
1378         .break_ctl              = mxuport_break_ctl,
1379         .tx_empty               = mxuport_tx_empty,
1380         .tiocmiwait             = usb_serial_generic_tiocmiwait,
1381         .get_icount             = usb_serial_generic_get_icount,
1382         .throttle               = mxuport_throttle,
1383         .unthrottle             = mxuport_unthrottle,
1384         .tiocmget               = mxuport_tiocmget,
1385         .tiocmset               = mxuport_tiocmset,
1386         .dtr_rts                = mxuport_dtr_rts,
1387         .process_read_urb       = mxuport_process_read_urb,
1388         .prepare_write_buffer   = mxuport_prepare_write_buffer,
1389         .resume                 = mxuport_resume,
1390 };
1391
1392 static struct usb_serial_driver *const serial_drivers[] = {
1393         &mxuport_device, NULL
1394 };
1395
1396 module_usb_serial_driver(serial_drivers, mxuport_idtable);
1397
1398 MODULE_AUTHOR("Andrew Lunn <andrew@lunn.ch>");
1399 MODULE_AUTHOR("<support@moxa.com>");
1400 MODULE_LICENSE("GPL");