drivers/usb/serial/f81534.c

   1 /*
   2  * F81532/F81534 USB to Serial Ports Bridge
   3  *
   4  * F81532 => 2 Serial Ports
   5  * F81534 => 4 Serial Ports
   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  * Copyright (C) 2016 Feature Integration Technology Inc., (Fintek)
  13  * Copyright (C) 2016 Tom Tsai (Tom_Tsai@fintek.com.tw)
  14  * Copyright (C) 2016 Peter Hong (Peter_Hong@fintek.com.tw)
  15  *
  16  * The F81532/F81534 had 1 control endpoint for setting, 1 endpoint bulk-out
  17  * for all serial port TX and 1 endpoint bulk-in for all serial port read in
  18  * (Read Data/MSR/LSR).
  19  *
  20  * Write URB is fixed with 512bytes, per serial port used 128Bytes.
  21  * It can be described by f81534_prepare_write_buffer()
  22  *
  23  * Read URB is 512Bytes max, per serial port used 128Bytes.
  24  * It can be described by f81534_process_read_urb() and maybe received with
  25  * 128x1,2,3,4 bytes.
  26  *
  27  */
  28 #include <linux/slab.h>
  29 #include <linux/tty.h>
  30 #include <linux/tty_flip.h>
  31 #include <linux/usb.h>
  32 #include <linux/usb/serial.h>
  33 #include <linux/serial_reg.h>
  34 #include <linux/module.h>
  35 #include <linux/uaccess.h>
  36
  37 /* Serial Port register Address */
  38 #define F81534_UART_BASE_ADDRESS        0x1200
  39 #define F81534_UART_OFFSET              0x10
  40 #define F81534_DIVISOR_LSB_REG          (0x00 + F81534_UART_BASE_ADDRESS)
  41 #define F81534_DIVISOR_MSB_REG          (0x01 + F81534_UART_BASE_ADDRESS)
  42 #define F81534_FIFO_CONTROL_REG         (0x02 + F81534_UART_BASE_ADDRESS)
  43 #define F81534_LINE_CONTROL_REG         (0x03 + F81534_UART_BASE_ADDRESS)
  44 #define F81534_MODEM_CONTROL_REG        (0x04 + F81534_UART_BASE_ADDRESS)
  45 #define F81534_MODEM_STATUS_REG         (0x06 + F81534_UART_BASE_ADDRESS)
  46 #define F81534_CONFIG1_REG              (0x09 + F81534_UART_BASE_ADDRESS)
  47
  48 #define F81534_DEF_CONF_ADDRESS_START   0x3000
  49 #define F81534_DEF_CONF_SIZE            8
  50
  51 #define F81534_CUSTOM_ADDRESS_START     0x2f00
  52 #define F81534_CUSTOM_DATA_SIZE         0x10
  53 #define F81534_CUSTOM_NO_CUSTOM_DATA    0xff
  54 #define F81534_CUSTOM_VALID_TOKEN       0xf0
  55 #define F81534_CONF_OFFSET              1
  56
  57 #define F81534_MAX_DATA_BLOCK           64
  58 #define F81534_MAX_BUS_RETRY            20
  59
  60 /* Default URB timeout for USB operations */
  61 #define F81534_USB_MAX_RETRY            10
  62 #define F81534_USB_TIMEOUT              1000
  63 #define F81534_SET_GET_REGISTER         0xA0
  64
  65 #define F81534_NUM_PORT                 4
  66 #define F81534_UNUSED_PORT              0xff
  67 #define F81534_WRITE_BUFFER_SIZE        512
  68
  69 #define DRIVER_DESC                     "Fintek F81532/F81534"
  70 #define FINTEK_VENDOR_ID_1              0x1934
  71 #define FINTEK_VENDOR_ID_2              0x2C42
  72 #define FINTEK_DEVICE_ID                0x1202
  73 #define F81534_MAX_TX_SIZE              124
  74 #define F81534_MAX_RX_SIZE              124
  75 #define F81534_RECEIVE_BLOCK_SIZE       128
  76 #define F81534_MAX_RECEIVE_BLOCK_SIZE   512
  77
  78 #define F81534_TOKEN_RECEIVE            0x01
  79 #define F81534_TOKEN_WRITE              0x02
  80 #define F81534_TOKEN_TX_EMPTY           0x03
  81 #define F81534_TOKEN_MSR_CHANGE         0x04
  82
  83 /*
  84  * We used interal SPI bus to access FLASH section. We must wait the SPI bus to
  85  * idle if we performed any command.
  86  *
  87  * SPI Bus status register: F81534_BUS_REG_STATUS
  88  *      Bit 0/1 : BUSY
  89  *      Bit 2   : IDLE
  90  */
  91 #define F81534_BUS_BUSY                 (BIT(0) | BIT(1))
  92 #define F81534_BUS_IDLE                 BIT(2)
  93 #define F81534_BUS_READ_DATA            0x1004
  94 #define F81534_BUS_REG_STATUS           0x1003
  95 #define F81534_BUS_REG_START            0x1002
  96 #define F81534_BUS_REG_END              0x1001
  97
  98 #define F81534_CMD_READ                 0x03
  99
 100 #define F81534_DEFAULT_BAUD_RATE        9600
 101 #define F81534_MAX_BAUDRATE             115200
 102
 103 #define F81534_PORT_CONF_DISABLE_PORT   BIT(3)
 104 #define F81534_PORT_CONF_NOT_EXIST_PORT BIT(7)
 105 #define F81534_PORT_UNAVAILABLE         \
 106         (F81534_PORT_CONF_DISABLE_PORT | F81534_PORT_CONF_NOT_EXIST_PORT)
 107
 108 #define F81534_1X_RXTRIGGER             0xc3
 109 #define F81534_8X_RXTRIGGER             0xcf
 110
 111 static const struct usb_device_id f81534_id_table[] = {
 112         { USB_DEVICE(FINTEK_VENDOR_ID_1, FINTEK_DEVICE_ID) },
 113         { USB_DEVICE(FINTEK_VENDOR_ID_2, FINTEK_DEVICE_ID) },
 114         {}                      /* Terminating entry */
 115 };
 116
 117 #define F81534_TX_EMPTY_BIT             0
 118
 119 struct f81534_serial_private {
 120         u8 conf_data[F81534_DEF_CONF_SIZE];
 121         int tty_idx[F81534_NUM_PORT];
 122         u8 setting_idx;
 123         int opened_port;
 124         struct mutex urb_mutex;
 125 };
 126
 127 struct f81534_port_private {
 128         struct mutex mcr_mutex;
 129         unsigned long tx_empty;
 130         spinlock_t msr_lock;
 131         u8 shadow_mcr;
 132         u8 shadow_msr;
 133         u8 phy_num;
 134 };
 135
 136 static int f81534_logic_to_phy_port(struct usb_serial *serial,
 137                                         struct usb_serial_port *port)
 138 {
 139         struct f81534_serial_private *serial_priv =
 140                         usb_get_serial_data(port->serial);
 141         int count = 0;
 142         int i;
 143
 144         for (i = 0; i < F81534_NUM_PORT; ++i) {
 145                 if (serial_priv->conf_data[i] & F81534_PORT_UNAVAILABLE)
 146                         continue;
 147
 148                 if (port->port_number == count)
 149                         return i;
 150
 151                 ++count;
 152         }
 153
 154         return -ENODEV;
 155 }
 156
 157 static int f81534_set_register(struct usb_serial *serial, u16 reg, u8 data)
 158 {
 159         struct usb_interface *interface = serial->interface;
 160         struct usb_device *dev = serial->dev;
 161         size_t count = F81534_USB_MAX_RETRY;
 162         int status;
 163         u8 *tmp;
 164
 165         tmp = kmalloc(sizeof(u8), GFP_KERNEL);
 166         if (!tmp)
 167                 return -ENOMEM;
 168
 169         *tmp = data;
 170
 171         /*
 172          * Our device maybe not reply when heavily loading, We'll retry for
 173          * F81534_USB_MAX_RETRY times.
 174          */
 175         while (count--) {
 176                 status = usb_control_msg(dev, usb_sndctrlpipe(dev, 0),
 177                                          F81534_SET_GET_REGISTER,
 178                                          USB_TYPE_VENDOR | USB_DIR_OUT,
 179                                          reg, 0, tmp, sizeof(u8),
 180                                          F81534_USB_TIMEOUT);
 181                 if (status > 0) {
 182                         status = 0;
 183                         break;
 184                 } else if (status == 0) {
 185                         status = -EIO;
 186                 }
 187         }
 188
 189         if (status < 0) {
 190                 dev_err(&interface->dev, "%s: reg: %x data: %x failed: %d\n",
 191                                 __func__, reg, data, status);
 192         }
 193
 194         kfree(tmp);
 195         return status;
 196 }
 197
 198 static int f81534_get_register(struct usb_serial *serial, u16 reg, u8 *data)
 199 {
 200         struct usb_interface *interface = serial->interface;
 201         struct usb_device *dev = serial->dev;
 202         size_t count = F81534_USB_MAX_RETRY;
 203         int status;
 204         u8 *tmp;
 205
 206         tmp = kmalloc(sizeof(u8), GFP_KERNEL);
 207         if (!tmp)
 208                 return -ENOMEM;
 209
 210         /*
 211          * Our device maybe not reply when heavily loading, We'll retry for
 212          * F81534_USB_MAX_RETRY times.
 213          */
 214         while (count--) {
 215                 status = usb_control_msg(dev, usb_rcvctrlpipe(dev, 0),
 216                                          F81534_SET_GET_REGISTER,
 217                                          USB_TYPE_VENDOR | USB_DIR_IN,
 218                                          reg, 0, tmp, sizeof(u8),
 219                                          F81534_USB_TIMEOUT);
 220                 if (status > 0) {
 221                         status = 0;
 222                         break;
 223                 } else if (status == 0) {
 224                         status = -EIO;
 225                 }
 226         }
 227
 228         if (status < 0) {
 229                 dev_err(&interface->dev, "%s: reg: %x failed: %d\n", __func__,
 230                                 reg, status);
 231                 goto end;
 232         }
 233
 234         *data = *tmp;
 235
 236 end:
 237         kfree(tmp);
 238         return status;
 239 }
 240
 241 static int f81534_set_port_register(struct usb_serial_port *port, u16 reg,
 242                                         u8 data)
 243 {
 244         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 245
 246         return f81534_set_register(port->serial,
 247                         reg + port_priv->phy_num * F81534_UART_OFFSET, data);
 248 }
 249
 250 static int f81534_get_port_register(struct usb_serial_port *port, u16 reg,
 251                                         u8 *data)
 252 {
 253         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 254
 255         return f81534_get_register(port->serial,
 256                         reg + port_priv->phy_num * F81534_UART_OFFSET, data);
 257 }
 258
 259 /*
 260  * If we try to access the internal flash via SPI bus, we should check the bus
 261  * status for every command. e.g., F81534_BUS_REG_START/F81534_BUS_REG_END
 262  */
 263 static int f81534_wait_for_spi_idle(struct usb_serial *serial)
 264 {
 265         size_t count = F81534_MAX_BUS_RETRY;
 266         u8 tmp;
 267         int status;
 268
 269         do {
 270                 status = f81534_get_register(serial, F81534_BUS_REG_STATUS,
 271                                                 &tmp);
 272                 if (status)
 273                         return status;
 274
 275                 if (tmp & F81534_BUS_BUSY)
 276                         continue;
 277
 278                 if (tmp & F81534_BUS_IDLE)
 279                         break;
 280
 281         } while (--count);
 282
 283         if (!count) {
 284                 dev_err(&serial->interface->dev,
 285                                 "%s: timed out waiting for idle SPI bus\n",
 286                                 __func__);
 287                 return -EIO;
 288         }
 289
 290         return f81534_set_register(serial, F81534_BUS_REG_STATUS,
 291                                 tmp & ~F81534_BUS_IDLE);
 292 }
 293
 294 static int f81534_get_spi_register(struct usb_serial *serial, u16 reg,
 295                                         u8 *data)
 296 {
 297         int status;
 298
 299         status = f81534_get_register(serial, reg, data);
 300         if (status)
 301                 return status;
 302
 303         return f81534_wait_for_spi_idle(serial);
 304 }
 305
 306 static int f81534_set_spi_register(struct usb_serial *serial, u16 reg, u8 data)
 307 {
 308         int status;
 309
 310         status = f81534_set_register(serial, reg, data);
 311         if (status)
 312                 return status;
 313
 314         return f81534_wait_for_spi_idle(serial);
 315 }
 316
 317 static int f81534_read_flash(struct usb_serial *serial, u32 address,
 318                                 size_t size, u8 *buf)
 319 {
 320         u8 tmp_buf[F81534_MAX_DATA_BLOCK];
 321         size_t block = 0;
 322         size_t read_size;
 323         size_t count;
 324         int status;
 325         int offset;
 326         u16 reg_tmp;
 327
 328         status = f81534_set_spi_register(serial, F81534_BUS_REG_START,
 329                                         F81534_CMD_READ);
 330         if (status)
 331                 return status;
 332
 333         status = f81534_set_spi_register(serial, F81534_BUS_REG_START,
 334                                         (address >> 16) & 0xff);
 335         if (status)
 336                 return status;
 337
 338         status = f81534_set_spi_register(serial, F81534_BUS_REG_START,
 339                                         (address >> 8) & 0xff);
 340         if (status)
 341                 return status;
 342
 343         status = f81534_set_spi_register(serial, F81534_BUS_REG_START,
 344                                         (address >> 0) & 0xff);
 345         if (status)
 346                 return status;
 347
 348         /* Continuous read mode */
 349         do {
 350                 read_size = min_t(size_t, F81534_MAX_DATA_BLOCK, size);
 351
 352                 for (count = 0; count < read_size; ++count) {
 353                         /* To write F81534_BUS_REG_END when final byte */
 354                         if (size <= F81534_MAX_DATA_BLOCK &&
 355                                         read_size == count + 1)
 356                                 reg_tmp = F81534_BUS_REG_END;
 357                         else
 358                                 reg_tmp = F81534_BUS_REG_START;
 359
 360                         /*
 361                          * Dummy code, force IC to generate a read pulse, the
 362                          * set of value 0xf1 is dont care (any value is ok)
 363                          */
 364                         status = f81534_set_spi_register(serial, reg_tmp,
 365                                         0xf1);
 366                         if (status)
 367                                 return status;
 368
 369                         status = f81534_get_spi_register(serial,
 370                                                 F81534_BUS_READ_DATA,
 371                                                 &tmp_buf[count]);
 372                         if (status)
 373                                 return status;
 374
 375                         offset = count + block * F81534_MAX_DATA_BLOCK;
 376                         buf[offset] = tmp_buf[count];
 377                 }
 378
 379                 size -= read_size;
 380                 ++block;
 381         } while (size);
 382
 383         return 0;
 384 }
 385
 386 static void f81534_prepare_write_buffer(struct usb_serial_port *port, u8 *buf)
 387 {
 388         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 389         int phy_num = port_priv->phy_num;
 390         u8 tx_len;
 391         int i;
 392
 393         /*
 394          * The block layout is fixed with 4x128 Bytes, per 128 Bytes a port.
 395          * index 0: port phy idx (e.g., 0,1,2,3)
 396          * index 1: only F81534_TOKEN_WRITE
 397          * index 2: serial TX out length
 398          * index 3: fix to 0
 399          * index 4~127: serial out data block
 400          */
 401         for (i = 0; i < F81534_NUM_PORT; ++i) {
 402                 buf[i * F81534_RECEIVE_BLOCK_SIZE] = i;
 403                 buf[i * F81534_RECEIVE_BLOCK_SIZE + 1] = F81534_TOKEN_WRITE;
 404                 buf[i * F81534_RECEIVE_BLOCK_SIZE + 2] = 0;
 405                 buf[i * F81534_RECEIVE_BLOCK_SIZE + 3] = 0;
 406         }
 407
 408         tx_len = kfifo_out_locked(&port->write_fifo,
 409                                 &buf[phy_num * F81534_RECEIVE_BLOCK_SIZE + 4],
 410                                 F81534_MAX_TX_SIZE, &port->lock);
 411
 412         buf[phy_num * F81534_RECEIVE_BLOCK_SIZE + 2] = tx_len;
 413 }
 414
 415 static int f81534_submit_writer(struct usb_serial_port *port, gfp_t mem_flags)
 416 {
 417         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 418         struct urb *urb;
 419         unsigned long flags;
 420         int result;
 421
 422         /* Check is any data in write_fifo */
 423         spin_lock_irqsave(&port->lock, flags);
 424
 425         if (kfifo_is_empty(&port->write_fifo)) {
 426                 spin_unlock_irqrestore(&port->lock, flags);
 427                 return 0;
 428         }
 429
 430         spin_unlock_irqrestore(&port->lock, flags);
 431
 432         /* Check H/W is TXEMPTY */
 433         if (!test_and_clear_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty))
 434                 return 0;
 435
 436         urb = port->write_urbs[0];
 437         f81534_prepare_write_buffer(port, port->bulk_out_buffers[0]);
 438         urb->transfer_buffer_length = F81534_WRITE_BUFFER_SIZE;
 439
 440         result = usb_submit_urb(urb, mem_flags);
 441         if (result) {
 442                 set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
 443                 dev_err(&port->dev, "%s: submit failed: %d\n", __func__,
 444                                 result);
 445                 return result;
 446         }
 447
 448         usb_serial_port_softint(port);
 449         return 0;
 450 }
 451
 452 static u32 f81534_calc_baud_divisor(u32 baudrate, u32 clockrate)
 453 {
 454         if (!baudrate)
 455                 return 0;
 456
 457         /* Round to nearest divisor */
 458         return DIV_ROUND_CLOSEST(clockrate, baudrate);
 459 }
 460
 461 static int f81534_set_port_config(struct usb_serial_port *port, u32 baudrate,
 462                                         u8 lcr)
 463 {
 464         u32 divisor;
 465         int status;
 466         u8 value;
 467
 468         if (baudrate <= 1200)
 469                 value = F81534_1X_RXTRIGGER;    /* 128 FIFO & TL: 1x */
 470         else
 471                 value = F81534_8X_RXTRIGGER;    /* 128 FIFO & TL: 8x */
 472
 473         status = f81534_set_port_register(port, F81534_CONFIG1_REG, value);
 474         if (status) {
 475                 dev_err(&port->dev, "%s: CONFIG1 setting failed\n", __func__);
 476                 return status;
 477         }
 478
 479         if (baudrate <= 1200)
 480                 value = UART_FCR_TRIGGER_1 | UART_FCR_ENABLE_FIFO; /* TL: 1 */
 481         else
 482                 value = UART_FCR_R_TRIG_11 | UART_FCR_ENABLE_FIFO; /* TL: 14 */
 483
 484         status = f81534_set_port_register(port, F81534_FIFO_CONTROL_REG,
 485                                                 value);
 486         if (status) {
 487                 dev_err(&port->dev, "%s: FCR setting failed\n", __func__);
 488                 return status;
 489         }
 490
 491         divisor = f81534_calc_baud_divisor(baudrate, F81534_MAX_BAUDRATE);
 492         value = UART_LCR_DLAB;
 493         status = f81534_set_port_register(port, F81534_LINE_CONTROL_REG,
 494                                                 value);
 495         if (status) {
 496                 dev_err(&port->dev, "%s: set LCR failed\n", __func__);
 497                 return status;
 498         }
 499
 500         value = divisor & 0xff;
 501         status = f81534_set_port_register(port, F81534_DIVISOR_LSB_REG, value);
 502         if (status) {
 503                 dev_err(&port->dev, "%s: set DLAB LSB failed\n", __func__);
 504                 return status;
 505         }
 506
 507         value = (divisor >> 8) & 0xff;
 508         status = f81534_set_port_register(port, F81534_DIVISOR_MSB_REG, value);
 509         if (status) {
 510                 dev_err(&port->dev, "%s: set DLAB MSB failed\n", __func__);
 511                 return status;
 512         }
 513
 514         status = f81534_set_port_register(port, F81534_LINE_CONTROL_REG, lcr);
 515         if (status) {
 516                 dev_err(&port->dev, "%s: set LCR failed\n", __func__);
 517                 return status;
 518         }
 519
 520         return 0;
 521 }
 522
 523 static int f81534_update_mctrl(struct usb_serial_port *port, unsigned int set,
 524                                 unsigned int clear)
 525 {
 526         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 527         int status;
 528         u8 tmp;
 529
 530         if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0)
 531                 return 0;       /* no change */
 532
 533         mutex_lock(&port_priv->mcr_mutex);
 534
 535         /* 'Set' takes precedence over 'Clear' */
 536         clear &= ~set;
 537
 538         /* Always enable UART_MCR_OUT2 */
 539         tmp = UART_MCR_OUT2 | port_priv->shadow_mcr;
 540
 541         if (clear & TIOCM_DTR)
 542                 tmp &= ~UART_MCR_DTR;
 543
 544         if (clear & TIOCM_RTS)
 545                 tmp &= ~UART_MCR_RTS;
 546
 547         if (set & TIOCM_DTR)
 548                 tmp |= UART_MCR_DTR;
 549
 550         if (set & TIOCM_RTS)
 551                 tmp |= UART_MCR_RTS;
 552
 553         status = f81534_set_port_register(port, F81534_MODEM_CONTROL_REG, tmp);
 554         if (status < 0) {
 555                 dev_err(&port->dev, "%s: MCR write failed\n", __func__);
 556                 mutex_unlock(&port_priv->mcr_mutex);
 557                 return status;
 558         }
 559
 560         port_priv->shadow_mcr = tmp;
 561         mutex_unlock(&port_priv->mcr_mutex);
 562         return 0;
 563 }
 564
 565 /*
 566  * This function will search the data area with token F81534_CUSTOM_VALID_TOKEN
 567  * for latest configuration index. If nothing found
 568  * (*index = F81534_CUSTOM_NO_CUSTOM_DATA), We'll load default configure in
 569  * F81534_DEF_CONF_ADDRESS_START section.
 570  *
 571  * Due to we only use block0 to save data, so *index should be 0 or
 572  * F81534_CUSTOM_NO_CUSTOM_DATA.
 573  */
 574 static int f81534_find_config_idx(struct usb_serial *serial, u8 *index)
 575 {
 576         u8 tmp;
 577         int status;
 578
 579         status = f81534_read_flash(serial, F81534_CUSTOM_ADDRESS_START, 1,
 580                                         &tmp);
 581         if (status) {
 582                 dev_err(&serial->interface->dev, "%s: read failed: %d\n",
 583                                 __func__, status);
 584                 return status;
 585         }
 586
 587         /* We'll use the custom data when the data is valid. */
 588         if (tmp == F81534_CUSTOM_VALID_TOKEN)
 589                 *index = 0;
 590         else
 591                 *index = F81534_CUSTOM_NO_CUSTOM_DATA;
 592
 593         return 0;
 594 }
 595
 596 /*
 597  * We had 2 generation of F81532/534 IC. All has an internal storage.
 598  *
 599  * 1st is pure USB-to-TTL RS232 IC and designed for 4 ports only, no any
 600  * internal data will used. All mode and gpio control should manually set
 601  * by AP or Driver and all storage space value are 0xff. The
 602  * f81534_calc_num_ports() will run to final we marked as "oldest version"
 603  * for this IC.
 604  *
 605  * 2rd is designed to more generic to use any transceiver and this is our
 606  * mass production type. We'll save data in F81534_CUSTOM_ADDRESS_START
 607  * (0x2f00) with 9bytes. The 1st byte is a indicater. If the token is
 608  * F81534_CUSTOM_VALID_TOKEN(0xf0), the IC is 2nd gen type, the following
 609  * 4bytes save port mode (0:RS232/1:RS485 Invert/2:RS485), and the last
 610  * 4bytes save GPIO state(value from 0~7 to represent 3 GPIO output pin).
 611  * The f81534_calc_num_ports() will run to "new style" with checking
 612  * F81534_PORT_UNAVAILABLE section.
 613  */
 614 static int f81534_calc_num_ports(struct usb_serial *serial,
 615                                         struct usb_serial_endpoints *epds)
 616 {
 617         struct device *dev = &serial->interface->dev;
 618         int size_bulk_in = usb_endpoint_maxp(epds->bulk_in[0]);
 619         int size_bulk_out = usb_endpoint_maxp(epds->bulk_out[0]);
 620         u8 setting[F81534_CUSTOM_DATA_SIZE];
 621         u8 setting_idx;
 622         u8 num_port = 0;
 623         int status;
 624         size_t i;
 625
 626         if (size_bulk_out != F81534_WRITE_BUFFER_SIZE ||
 627                         size_bulk_in != F81534_MAX_RECEIVE_BLOCK_SIZE) {
 628                 dev_err(dev, "unsupported endpoint max packet size\n");
 629                 return -ENODEV;
 630         }
 631
 632         /* Check had custom setting */
 633         status = f81534_find_config_idx(serial, &setting_idx);
 634         if (status) {
 635                 dev_err(&serial->interface->dev, "%s: find idx failed: %d\n",
 636                                 __func__, status);
 637                 return status;
 638         }
 639
 640         /*
 641          * We'll read custom data only when data available, otherwise we'll
 642          * read default value instead.
 643          */
 644         if (setting_idx != F81534_CUSTOM_NO_CUSTOM_DATA) {
 645                 status = f81534_read_flash(serial,
 646                                                 F81534_CUSTOM_ADDRESS_START +
 647                                                 F81534_CONF_OFFSET,
 648                                                 sizeof(setting), setting);
 649                 if (status) {
 650                         dev_err(&serial->interface->dev,
 651                                         "%s: get custom data failed: %d\n",
 652                                         __func__, status);
 653                         return status;
 654                 }
 655
 656                 dev_dbg(&serial->interface->dev,
 657                                 "%s: read config from block: %d\n", __func__,
 658                                 setting_idx);
 659         } else {
 660                 /* Read default board setting */
 661                 status = f81534_read_flash(serial,
 662                                 F81534_DEF_CONF_ADDRESS_START, F81534_NUM_PORT,
 663                                 setting);
 664
 665                 if (status) {
 666                         dev_err(&serial->interface->dev,
 667                                         "%s: read failed: %d\n", __func__,
 668                                         status);
 669                         return status;
 670                 }
 671
 672                 dev_dbg(&serial->interface->dev, "%s: read default config\n",
 673                                 __func__);
 674         }
 675
 676         /* New style, find all possible ports */
 677         for (i = 0; i < F81534_NUM_PORT; ++i) {
 678                 if (setting[i] & F81534_PORT_UNAVAILABLE)
 679                         continue;
 680
 681                 ++num_port;
 682         }
 683
 684         if (!num_port) {
 685                 dev_warn(&serial->interface->dev,
 686                         "no config found, assuming 4 ports\n");
 687                 num_port = 4;           /* Nothing found, oldest version IC */
 688         }
 689
 690         /*
 691          * Setup bulk-out endpoint multiplexing. All ports share the same
 692          * bulk-out endpoint.
 693          */
 694         BUILD_BUG_ON(ARRAY_SIZE(epds->bulk_out) < F81534_NUM_PORT);
 695
 696         for (i = 1; i < num_port; ++i)
 697                 epds->bulk_out[i] = epds->bulk_out[0];
 698
 699         epds->num_bulk_out = num_port;
 700
 701         return num_port;
 702 }
 703
 704 static void f81534_set_termios(struct tty_struct *tty,
 705                                 struct usb_serial_port *port,
 706                                 struct ktermios *old_termios)
 707 {
 708         u8 new_lcr = 0;
 709         int status;
 710         u32 baud;
 711
 712         if (C_BAUD(tty) == B0)
 713                 f81534_update_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
 714         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 715                 f81534_update_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
 716
 717         if (C_PARENB(tty)) {
 718                 new_lcr |= UART_LCR_PARITY;
 719
 720                 if (!C_PARODD(tty))
 721                         new_lcr |= UART_LCR_EPAR;
 722
 723                 if (C_CMSPAR(tty))
 724                         new_lcr |= UART_LCR_SPAR;
 725         }
 726
 727         if (C_CSTOPB(tty))
 728                 new_lcr |= UART_LCR_STOP;
 729
 730         switch (C_CSIZE(tty)) {
 731         case CS5:
 732                 new_lcr |= UART_LCR_WLEN5;
 733                 break;
 734         case CS6:
 735                 new_lcr |= UART_LCR_WLEN6;
 736                 break;
 737         case CS7:
 738                 new_lcr |= UART_LCR_WLEN7;
 739                 break;
 740         default:
 741         case CS8:
 742                 new_lcr |= UART_LCR_WLEN8;
 743                 break;
 744         }
 745
 746         baud = tty_get_baud_rate(tty);
 747         if (!baud)
 748                 return;
 749
 750         if (baud > F81534_MAX_BAUDRATE) {
 751                 if (old_termios)
 752                         baud = tty_termios_baud_rate(old_termios);
 753                 else
 754                         baud = F81534_DEFAULT_BAUD_RATE;
 755
 756                 tty_encode_baud_rate(tty, baud, baud);
 757         }
 758
 759         dev_dbg(&port->dev, "%s: baud: %d\n", __func__, baud);
 760
 761         status = f81534_set_port_config(port, baud, new_lcr);
 762         if (status < 0) {
 763                 dev_err(&port->dev, "%s: set port config failed: %d\n",
 764                                 __func__, status);
 765         }
 766 }
 767
 768 static int f81534_submit_read_urb(struct usb_serial *serial, gfp_t flags)
 769 {
 770         return usb_serial_generic_submit_read_urbs(serial->port[0], flags);
 771 }
 772
 773 static void f81534_msr_changed(struct usb_serial_port *port, u8 msr)
 774 {
 775         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 776         struct tty_struct *tty;
 777         unsigned long flags;
 778         u8 old_msr;
 779
 780         if (!(msr & UART_MSR_ANY_DELTA))
 781                 return;
 782
 783         spin_lock_irqsave(&port_priv->msr_lock, flags);
 784         old_msr = port_priv->shadow_msr;
 785         port_priv->shadow_msr = msr;
 786         spin_unlock_irqrestore(&port_priv->msr_lock, flags);
 787
 788         dev_dbg(&port->dev, "%s: MSR from %02x to %02x\n", __func__, old_msr,
 789                         msr);
 790
 791         /* Update input line counters */
 792         if (msr & UART_MSR_DCTS)
 793                 port->icount.cts++;
 794         if (msr & UART_MSR_DDSR)
 795                 port->icount.dsr++;
 796         if (msr & UART_MSR_DDCD)
 797                 port->icount.dcd++;
 798         if (msr & UART_MSR_TERI)
 799                 port->icount.rng++;
 800
 801         wake_up_interruptible(&port->port.delta_msr_wait);
 802
 803         if (!(msr & UART_MSR_DDCD))
 804                 return;
 805
 806         dev_dbg(&port->dev, "%s: DCD Changed: phy_num: %d from %x to %x\n",
 807                         __func__, port_priv->phy_num, old_msr, msr);
 808
 809         tty = tty_port_tty_get(&port->port);
 810         if (!tty)
 811                 return;
 812
 813         usb_serial_handle_dcd_change(port, tty, msr & UART_MSR_DCD);
 814         tty_kref_put(tty);
 815 }
 816
 817 static int f81534_read_msr(struct usb_serial_port *port)
 818 {
 819         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 820         unsigned long flags;
 821         int status;
 822         u8 msr;
 823
 824         /* Get MSR initial value */
 825         status = f81534_get_port_register(port, F81534_MODEM_STATUS_REG, &msr);
 826         if (status)
 827                 return status;
 828
 829         /* Force update current state */
 830         spin_lock_irqsave(&port_priv->msr_lock, flags);
 831         port_priv->shadow_msr = msr;
 832         spin_unlock_irqrestore(&port_priv->msr_lock, flags);
 833
 834         return 0;
 835 }
 836
 837 static int f81534_open(struct tty_struct *tty, struct usb_serial_port *port)
 838 {
 839         struct f81534_serial_private *serial_priv =
 840                         usb_get_serial_data(port->serial);
 841         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 842         int status;
 843
 844         status = f81534_set_port_register(port,
 845                                 F81534_FIFO_CONTROL_REG, UART_FCR_ENABLE_FIFO |
 846                                 UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 847         if (status) {
 848                 dev_err(&port->dev, "%s: Clear FIFO failed: %d\n", __func__,
 849                                 status);
 850                 return status;
 851         }
 852
 853         if (tty)
 854                 f81534_set_termios(tty, port, NULL);
 855
 856         status = f81534_read_msr(port);
 857         if (status)
 858                 return status;
 859
 860         mutex_lock(&serial_priv->urb_mutex);
 861
 862         /* Submit Read URBs for first port opened */
 863         if (!serial_priv->opened_port) {
 864                 status = f81534_submit_read_urb(port->serial, GFP_KERNEL);
 865                 if (status)
 866                         goto exit;
 867         }
 868
 869         serial_priv->opened_port++;
 870
 871 exit:
 872         mutex_unlock(&serial_priv->urb_mutex);
 873
 874         set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
 875         return status;
 876 }
 877
 878 static void f81534_close(struct usb_serial_port *port)
 879 {
 880         struct f81534_serial_private *serial_priv =
 881                         usb_get_serial_data(port->serial);
 882         struct usb_serial_port *port0 = port->serial->port[0];
 883         unsigned long flags;
 884         size_t i;
 885
 886         usb_kill_urb(port->write_urbs[0]);
 887
 888         spin_lock_irqsave(&port->lock, flags);
 889         kfifo_reset_out(&port->write_fifo);
 890         spin_unlock_irqrestore(&port->lock, flags);
 891
 892         /* Kill Read URBs when final port closed */
 893         mutex_lock(&serial_priv->urb_mutex);
 894         serial_priv->opened_port--;
 895
 896         if (!serial_priv->opened_port) {
 897                 for (i = 0; i < ARRAY_SIZE(port0->read_urbs); ++i)
 898                         usb_kill_urb(port0->read_urbs[i]);
 899         }
 900
 901         mutex_unlock(&serial_priv->urb_mutex);
 902 }
 903
 904 static int f81534_get_serial_info(struct usb_serial_port *port,
 905                                   struct serial_struct __user *retinfo)
 906 {
 907         struct f81534_port_private *port_priv;
 908         struct serial_struct tmp;
 909
 910         port_priv = usb_get_serial_port_data(port);
 911
 912         memset(&tmp, 0, sizeof(tmp));
 913
 914         tmp.type = PORT_16550A;
 915         tmp.port = port->port_number;
 916         tmp.line = port->minor;
 917         tmp.baud_base = F81534_MAX_BAUDRATE;
 918
 919         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
 920                 return -EFAULT;
 921
 922         return 0;
 923 }
 924
 925 static int f81534_ioctl(struct tty_struct *tty, unsigned int cmd,
 926                         unsigned long arg)
 927 {
 928         struct usb_serial_port *port = tty->driver_data;
 929         struct serial_struct __user *buf = (struct serial_struct __user *)arg;
 930
 931         switch (cmd) {
 932         case TIOCGSERIAL:
 933                 return f81534_get_serial_info(port, buf);
 934         default:
 935                 break;
 936         }
 937
 938         return -ENOIOCTLCMD;
 939 }
 940
 941 static void f81534_process_per_serial_block(struct usb_serial_port *port,
 942                 u8 *data)
 943 {
 944         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 945         int phy_num = data[0];
 946         size_t read_size = 0;
 947         size_t i;
 948         char tty_flag;
 949         int status;
 950         u8 lsr;
 951
 952         /*
 953          * The block layout is 128 Bytes
 954          * index 0: port phy idx (e.g., 0,1,2,3),
 955          * index 1: It's could be
 956          *                      F81534_TOKEN_RECEIVE
 957          *                      F81534_TOKEN_TX_EMPTY
 958          *                      F81534_TOKEN_MSR_CHANGE
 959          * index 2: serial in size (data+lsr, must be even)
 960          *                      meaningful for F81534_TOKEN_RECEIVE only
 961          * index 3: current MSR with this device
 962          * index 4~127: serial in data block (data+lsr, must be even)
 963          */
 964         switch (data[1]) {
 965         case F81534_TOKEN_TX_EMPTY:
 966                 set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
 967
 968                 /* Try to submit writer */
 969                 status = f81534_submit_writer(port, GFP_ATOMIC);
 970                 if (status)
 971                         dev_err(&port->dev, "%s: submit failed\n", __func__);
 972                 return;
 973
 974         case F81534_TOKEN_MSR_CHANGE:
 975                 f81534_msr_changed(port, data[3]);
 976                 return;
 977
 978         case F81534_TOKEN_RECEIVE:
 979                 read_size = data[2];
 980                 if (read_size > F81534_MAX_RX_SIZE) {
 981                         dev_err(&port->dev,
 982                                 "%s: phy: %d read_size: %zu larger than: %d\n",
 983                                 __func__, phy_num, read_size,
 984                                 F81534_MAX_RX_SIZE);
 985                         return;
 986                 }
 987
 988                 break;
 989
 990         default:
 991                 dev_warn(&port->dev, "%s: unknown token: %02x\n", __func__,
 992                                 data[1]);
 993                 return;
 994         }
 995
 996         for (i = 4; i < 4 + read_size; i += 2) {
 997                 tty_flag = TTY_NORMAL;
 998                 lsr = data[i + 1];
 999
1000                 if (lsr & UART_LSR_BRK_ERROR_BITS) {
1001                         if (lsr & UART_LSR_BI) {
1002                                 tty_flag = TTY_BREAK;
1003                                 port->icount.brk++;
1004                                 usb_serial_handle_break(port);
1005                         } else if (lsr & UART_LSR_PE) {
1006                                 tty_flag = TTY_PARITY;
1007                                 port->icount.parity++;
1008                         } else if (lsr & UART_LSR_FE) {
1009                                 tty_flag = TTY_FRAME;
1010                                 port->icount.frame++;
1011                         }
1012
1013                         if (lsr & UART_LSR_OE) {
1014                                 port->icount.overrun++;
1015                                 tty_insert_flip_char(&port->port, 0,
1016                                                 TTY_OVERRUN);
1017                         }
1018                 }
1019
1020                 if (port->port.console && port->sysrq) {
1021                         if (usb_serial_handle_sysrq_char(port, data[i]))
1022                                 continue;
1023                 }
1024
1025                 tty_insert_flip_char(&port->port, data[i], tty_flag);
1026         }
1027
1028         tty_flip_buffer_push(&port->port);
1029 }
1030
1031 static void f81534_process_read_urb(struct urb *urb)
1032 {
1033         struct f81534_serial_private *serial_priv;
1034         struct usb_serial_port *port;
1035         struct usb_serial *serial;
1036         u8 *buf;
1037         int phy_port_num;
1038         int tty_port_num;
1039         size_t i;
1040
1041         if (!urb->actual_length ||
1042                         urb->actual_length % F81534_RECEIVE_BLOCK_SIZE) {
1043                 return;
1044         }
1045
1046         port = urb->context;
1047         serial = port->serial;
1048         buf = urb->transfer_buffer;
1049         serial_priv = usb_get_serial_data(serial);
1050
1051         for (i = 0; i < urb->actual_length; i += F81534_RECEIVE_BLOCK_SIZE) {
1052                 phy_port_num = buf[i];
1053                 if (phy_port_num >= F81534_NUM_PORT) {
1054                         dev_err(&port->dev,
1055                                 "%s: phy_port_num: %d larger than: %d\n",
1056                                 __func__, phy_port_num, F81534_NUM_PORT);
1057                         continue;
1058                 }
1059
1060                 tty_port_num = serial_priv->tty_idx[phy_port_num];
1061                 port = serial->port[tty_port_num];
1062
1063                 if (tty_port_initialized(&port->port))
1064                         f81534_process_per_serial_block(port, &buf[i]);
1065         }
1066 }
1067
1068 static void f81534_write_usb_callback(struct urb *urb)
1069 {
1070         struct usb_serial_port *port = urb->context;
1071
1072         switch (urb->status) {
1073         case 0:
1074                 break;
1075         case -ENOENT:
1076         case -ECONNRESET:
1077         case -ESHUTDOWN:
1078                 dev_dbg(&port->dev, "%s - urb stopped: %d\n",
1079                                 __func__, urb->status);
1080                 return;
1081         case -EPIPE:
1082                 dev_err(&port->dev, "%s - urb stopped: %d\n",
1083                                 __func__, urb->status);
1084                 return;
1085         default:
1086                 dev_dbg(&port->dev, "%s - nonzero urb status: %d\n",
1087                                 __func__, urb->status);
1088                 break;
1089         }
1090 }
1091
1092 static int f81534_attach(struct usb_serial *serial)
1093 {
1094         struct f81534_serial_private *serial_priv;
1095         int index = 0;
1096         int status;
1097         int i;
1098
1099         serial_priv = devm_kzalloc(&serial->interface->dev,
1100                                         sizeof(*serial_priv), GFP_KERNEL);
1101         if (!serial_priv)
1102                 return -ENOMEM;
1103
1104         usb_set_serial_data(serial, serial_priv);
1105
1106         mutex_init(&serial_priv->urb_mutex);
1107
1108         /* Check had custom setting */
1109         status = f81534_find_config_idx(serial, &serial_priv->setting_idx);
1110         if (status) {
1111                 dev_err(&serial->interface->dev, "%s: find idx failed: %d\n",
1112                                 __func__, status);
1113                 return status;
1114         }
1115
1116         /*
1117          * We'll read custom data only when data available, otherwise we'll
1118          * read default value instead.
1119          */
1120         if (serial_priv->setting_idx == F81534_CUSTOM_NO_CUSTOM_DATA) {
1121                 /*
1122                  * The default configuration layout:
1123                  *      byte 0/1/2/3: uart setting
1124                  */
1125                 status = f81534_read_flash(serial,
1126                                         F81534_DEF_CONF_ADDRESS_START,
1127                                         F81534_DEF_CONF_SIZE,
1128                                         serial_priv->conf_data);
1129                 if (status) {
1130                         dev_err(&serial->interface->dev,
1131                                         "%s: read reserve data failed: %d\n",
1132                                         __func__, status);
1133                         return status;
1134                 }
1135         } else {
1136                 /* Only read 8 bytes for mode & GPIO */
1137                 status = f81534_read_flash(serial,
1138                                                 F81534_CUSTOM_ADDRESS_START +
1139                                                 F81534_CONF_OFFSET,
1140                                                 sizeof(serial_priv->conf_data),
1141                                                 serial_priv->conf_data);
1142                 if (status) {
1143                         dev_err(&serial->interface->dev,
1144                                         "%s: idx: %d get data failed: %d\n",
1145                                         __func__, serial_priv->setting_idx,
1146                                         status);
1147                         return status;
1148                 }
1149         }
1150
1151         /* Assign phy-to-logic mapping */
1152         for (i = 0; i < F81534_NUM_PORT; ++i) {
1153                 if (serial_priv->conf_data[i] & F81534_PORT_UNAVAILABLE)
1154                         continue;
1155
1156                 serial_priv->tty_idx[i] = index++;
1157                 dev_dbg(&serial->interface->dev,
1158                                 "%s: phy_num: %d, tty_idx: %d\n", __func__, i,
1159                                 serial_priv->tty_idx[i]);
1160         }
1161
1162         return 0;
1163 }
1164
1165 static int f81534_port_probe(struct usb_serial_port *port)
1166 {
1167         struct f81534_port_private *port_priv;
1168         int ret;
1169
1170         port_priv = devm_kzalloc(&port->dev, sizeof(*port_priv), GFP_KERNEL);
1171         if (!port_priv)
1172                 return -ENOMEM;
1173
1174         spin_lock_init(&port_priv->msr_lock);
1175         mutex_init(&port_priv->mcr_mutex);
1176
1177         /* Assign logic-to-phy mapping */
1178         ret = f81534_logic_to_phy_port(port->serial, port);
1179         if (ret < 0)
1180                 return ret;
1181
1182         port_priv->phy_num = ret;
1183         usb_set_serial_port_data(port, port_priv);
1184         dev_dbg(&port->dev, "%s: port_number: %d, phy_num: %d\n", __func__,
1185                         port->port_number, port_priv->phy_num);
1186
1187         return 0;
1188 }
1189
1190 static int f81534_tiocmget(struct tty_struct *tty)
1191 {
1192         struct usb_serial_port *port = tty->driver_data;
1193         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
1194         int status;
1195         int r;
1196         u8 msr;
1197         u8 mcr;
1198
1199         /* Read current MSR from device */
1200         status = f81534_get_port_register(port, F81534_MODEM_STATUS_REG, &msr);
1201         if (status)
1202                 return status;
1203
1204         mutex_lock(&port_priv->mcr_mutex);
1205         mcr = port_priv->shadow_mcr;
1206         mutex_unlock(&port_priv->mcr_mutex);
1207
1208         r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) |
1209             (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) |
1210             (msr & UART_MSR_CTS ? TIOCM_CTS : 0) |
1211             (msr & UART_MSR_DCD ? TIOCM_CAR : 0) |
1212             (msr & UART_MSR_RI ? TIOCM_RI : 0) |
1213             (msr & UART_MSR_DSR ? TIOCM_DSR : 0);
1214
1215         return r;
1216 }
1217
1218 static int f81534_tiocmset(struct tty_struct *tty, unsigned int set,
1219                                 unsigned int clear)
1220 {
1221         struct usb_serial_port *port = tty->driver_data;
1222
1223         return f81534_update_mctrl(port, set, clear);
1224 }
1225
1226 static void f81534_dtr_rts(struct usb_serial_port *port, int on)
1227 {
1228         if (on)
1229                 f81534_update_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
1230         else
1231                 f81534_update_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
1232 }
1233
1234 static int f81534_write(struct tty_struct *tty, struct usb_serial_port *port,
1235                         const u8 *buf, int count)
1236 {
1237         int bytes_out, status;
1238
1239         if (!count)
1240                 return 0;
1241
1242         bytes_out = kfifo_in_locked(&port->write_fifo, buf, count,
1243                                         &port->lock);
1244
1245         status = f81534_submit_writer(port, GFP_ATOMIC);
1246         if (status) {
1247                 dev_err(&port->dev, "%s: submit failed\n", __func__);
1248                 return status;
1249         }
1250
1251         return bytes_out;
1252 }
1253
1254 static bool f81534_tx_empty(struct usb_serial_port *port)
1255 {
1256         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
1257
1258         return test_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
1259 }
1260
1261 static int f81534_resume(struct usb_serial *serial)
1262 {
1263         struct f81534_serial_private *serial_priv =
1264                         usb_get_serial_data(serial);
1265         struct usb_serial_port *port;
1266         int error = 0;
1267         int status;
1268         size_t i;
1269
1270         /*
1271          * We'll register port 0 bulkin when port had opened, It'll take all
1272          * port received data, MSR register change and TX_EMPTY information.
1273          */
1274         mutex_lock(&serial_priv->urb_mutex);
1275
1276         if (serial_priv->opened_port) {
1277                 status = f81534_submit_read_urb(serial, GFP_NOIO);
1278                 if (status) {
1279                         mutex_unlock(&serial_priv->urb_mutex);
1280                         return status;
1281                 }
1282         }
1283
1284         mutex_unlock(&serial_priv->urb_mutex);
1285
1286         for (i = 0; i < serial->num_ports; i++) {
1287                 port = serial->port[i];
1288                 if (!tty_port_initialized(&port->port))
1289                         continue;
1290
1291                 status = f81534_submit_writer(port, GFP_NOIO);
1292                 if (status) {
1293                         dev_err(&port->dev, "%s: submit failed\n", __func__);
1294                         ++error;
1295                 }
1296         }
1297
1298         if (error)
1299                 return -EIO;
1300
1301         return 0;
1302 }
1303
1304 static struct usb_serial_driver f81534_device = {
1305         .driver = {
1306                    .owner = THIS_MODULE,
1307                    .name = "f81534",
1308         },
1309         .description =          DRIVER_DESC,
1310         .id_table =             f81534_id_table,
1311         .num_bulk_in =          1,
1312         .num_bulk_out =         1,
1313         .open =                 f81534_open,
1314         .close =                f81534_close,
1315         .write =                f81534_write,
1316         .tx_empty =             f81534_tx_empty,
1317         .calc_num_ports =       f81534_calc_num_ports,
1318         .attach =               f81534_attach,
1319         .port_probe =           f81534_port_probe,
1320         .dtr_rts =              f81534_dtr_rts,
1321         .process_read_urb =     f81534_process_read_urb,
1322         .ioctl =                f81534_ioctl,
1323         .tiocmget =             f81534_tiocmget,
1324         .tiocmset =             f81534_tiocmset,
1325         .write_bulk_callback =  f81534_write_usb_callback,
1326         .set_termios =          f81534_set_termios,
1327         .resume =               f81534_resume,
1328 };
1329
1330 static struct usb_serial_driver *const serial_drivers[] = {
1331         &f81534_device, NULL
1332 };
1333
1334 module_usb_serial_driver(serial_drivers, f81534_id_table);
1335
1336 MODULE_DEVICE_TABLE(usb, f81534_id_table);
1337 MODULE_DESCRIPTION(DRIVER_DESC);
1338 MODULE_AUTHOR("Peter Hong <Peter_Hong@fintek.com.tw>");
1339 MODULE_AUTHOR("Tom Tsai <Tom_Tsai@fintek.com.tw>");
1340 MODULE_LICENSE("GPL");