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