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 ([email protected])
  14  * Copyright (C) 2016 Peter Hong ([email protected])
  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 {
 616         u8 setting[F81534_CUSTOM_DATA_SIZE];
 617         u8 setting_idx;
 618         u8 num_port = 0;
 619         int status;
 620         size_t i;
 621
 622         /* Check had custom setting */
 623         status = f81534_find_config_idx(serial, &setting_idx);
 624         if (status) {
 625                 dev_err(&serial->interface->dev, "%s: find idx failed: %d\n",
 626                                 __func__, status);
 627                 return 0;
 628         }
 629
 630         /*
 631          * We'll read custom data only when data available, otherwise we'll
 632          * read default value instead.
 633          */
 634         if (setting_idx != F81534_CUSTOM_NO_CUSTOM_DATA) {
 635                 status = f81534_read_flash(serial,
 636                                                 F81534_CUSTOM_ADDRESS_START +
 637                                                 F81534_CONF_OFFSET,
 638                                                 sizeof(setting), setting);
 639                 if (status) {
 640                         dev_err(&serial->interface->dev,
 641                                         "%s: get custom data failed: %d\n",
 642                                         __func__, status);
 643                         return 0;
 644                 }
 645
 646                 dev_dbg(&serial->interface->dev,
 647                                 "%s: read config from block: %d\n", __func__,
 648                                 setting_idx);
 649         } else {
 650                 /* Read default board setting */
 651                 status = f81534_read_flash(serial,
 652                                 F81534_DEF_CONF_ADDRESS_START, F81534_NUM_PORT,
 653                                 setting);
 654
 655                 if (status) {
 656                         dev_err(&serial->interface->dev,
 657                                         "%s: read failed: %d\n", __func__,
 658                                         status);
 659                         return 0;
 660                 }
 661
 662                 dev_dbg(&serial->interface->dev, "%s: read default config\n",
 663                                 __func__);
 664         }
 665
 666         /* New style, find all possible ports */
 667         for (i = 0; i < F81534_NUM_PORT; ++i) {
 668                 if (setting[i] & F81534_PORT_UNAVAILABLE)
 669                         continue;
 670
 671                 ++num_port;
 672         }
 673
 674         if (num_port)
 675                 return num_port;
 676
 677         dev_warn(&serial->interface->dev, "%s: Read Failed. default 4 ports\n",
 678                         __func__);
 679         return 4;               /* Nothing found, oldest version IC */
 680 }
 681
 682 static void f81534_set_termios(struct tty_struct *tty,
 683                                 struct usb_serial_port *port,
 684                                 struct ktermios *old_termios)
 685 {
 686         u8 new_lcr = 0;
 687         int status;
 688         u32 baud;
 689
 690         if (C_BAUD(tty) == B0)
 691                 f81534_update_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
 692         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 693                 f81534_update_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
 694
 695         if (C_PARENB(tty)) {
 696                 new_lcr |= UART_LCR_PARITY;
 697
 698                 if (!C_PARODD(tty))
 699                         new_lcr |= UART_LCR_EPAR;
 700
 701                 if (C_CMSPAR(tty))
 702                         new_lcr |= UART_LCR_SPAR;
 703         }
 704
 705         if (C_CSTOPB(tty))
 706                 new_lcr |= UART_LCR_STOP;
 707
 708         switch (C_CSIZE(tty)) {
 709         case CS5:
 710                 new_lcr |= UART_LCR_WLEN5;
 711                 break;
 712         case CS6:
 713                 new_lcr |= UART_LCR_WLEN6;
 714                 break;
 715         case CS7:
 716                 new_lcr |= UART_LCR_WLEN7;
 717                 break;
 718         default:
 719         case CS8:
 720                 new_lcr |= UART_LCR_WLEN8;
 721                 break;
 722         }
 723
 724         baud = tty_get_baud_rate(tty);
 725         if (!baud)
 726                 return;
 727
 728         if (baud > F81534_MAX_BAUDRATE) {
 729                 if (old_termios)
 730                         baud = tty_termios_baud_rate(old_termios);
 731                 else
 732                         baud = F81534_DEFAULT_BAUD_RATE;
 733
 734                 tty_encode_baud_rate(tty, baud, baud);
 735         }
 736
 737         dev_dbg(&port->dev, "%s: baud: %d\n", __func__, baud);
 738
 739         status = f81534_set_port_config(port, baud, new_lcr);
 740         if (status < 0) {
 741                 dev_err(&port->dev, "%s: set port config failed: %d\n",
 742                                 __func__, status);
 743         }
 744 }
 745
 746 static int f81534_submit_read_urb(struct usb_serial *serial, gfp_t flags)
 747 {
 748         return usb_serial_generic_submit_read_urbs(serial->port[0], flags);
 749 }
 750
 751 static void f81534_msr_changed(struct usb_serial_port *port, u8 msr)
 752 {
 753         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 754         struct tty_struct *tty;
 755         unsigned long flags;
 756         u8 old_msr;
 757
 758         if (!(msr & UART_MSR_ANY_DELTA))
 759                 return;
 760
 761         spin_lock_irqsave(&port_priv->msr_lock, flags);
 762         old_msr = port_priv->shadow_msr;
 763         port_priv->shadow_msr = msr;
 764         spin_unlock_irqrestore(&port_priv->msr_lock, flags);
 765
 766         dev_dbg(&port->dev, "%s: MSR from %02x to %02x\n", __func__, old_msr,
 767                         msr);
 768
 769         /* Update input line counters */
 770         if (msr & UART_MSR_DCTS)
 771                 port->icount.cts++;
 772         if (msr & UART_MSR_DDSR)
 773                 port->icount.dsr++;
 774         if (msr & UART_MSR_DDCD)
 775                 port->icount.dcd++;
 776         if (msr & UART_MSR_TERI)
 777                 port->icount.rng++;
 778
 779         wake_up_interruptible(&port->port.delta_msr_wait);
 780
 781         if (!(msr & UART_MSR_DDCD))
 782                 return;
 783
 784         dev_dbg(&port->dev, "%s: DCD Changed: phy_num: %d from %x to %x\n",
 785                         __func__, port_priv->phy_num, old_msr, msr);
 786
 787         tty = tty_port_tty_get(&port->port);
 788         if (!tty)
 789                 return;
 790
 791         usb_serial_handle_dcd_change(port, tty, msr & UART_MSR_DCD);
 792         tty_kref_put(tty);
 793 }
 794
 795 static int f81534_read_msr(struct usb_serial_port *port)
 796 {
 797         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 798         unsigned long flags;
 799         int status;
 800         u8 msr;
 801
 802         /* Get MSR initial value */
 803         status = f81534_get_port_register(port, F81534_MODEM_STATUS_REG, &msr);
 804         if (status)
 805                 return status;
 806
 807         /* Force update current state */
 808         spin_lock_irqsave(&port_priv->msr_lock, flags);
 809         port_priv->shadow_msr = msr;
 810         spin_unlock_irqrestore(&port_priv->msr_lock, flags);
 811
 812         return 0;
 813 }
 814
 815 static int f81534_open(struct tty_struct *tty, struct usb_serial_port *port)
 816 {
 817         struct f81534_serial_private *serial_priv =
 818                         usb_get_serial_data(port->serial);
 819         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 820         int status;
 821
 822         status = f81534_set_port_register(port,
 823                                 F81534_FIFO_CONTROL_REG, UART_FCR_ENABLE_FIFO |
 824                                 UART_FCR_CLEAR_RCVR | UART_FCR_CLEAR_XMIT);
 825         if (status) {
 826                 dev_err(&port->dev, "%s: Clear FIFO failed: %d\n", __func__,
 827                                 status);
 828                 return status;
 829         }
 830
 831         if (tty)
 832                 f81534_set_termios(tty, port, NULL);
 833
 834         status = f81534_read_msr(port);
 835         if (status)
 836                 return status;
 837
 838         mutex_lock(&serial_priv->urb_mutex);
 839
 840         /* Submit Read URBs for first port opened */
 841         if (!serial_priv->opened_port) {
 842                 status = f81534_submit_read_urb(port->serial, GFP_KERNEL);
 843                 if (status)
 844                         goto exit;
 845         }
 846
 847         serial_priv->opened_port++;
 848
 849 exit:
 850         mutex_unlock(&serial_priv->urb_mutex);
 851
 852         set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
 853         return status;
 854 }
 855
 856 static void f81534_close(struct usb_serial_port *port)
 857 {
 858         struct f81534_serial_private *serial_priv =
 859                         usb_get_serial_data(port->serial);
 860         struct usb_serial_port *port0 = port->serial->port[0];
 861         unsigned long flags;
 862         size_t i;
 863
 864         usb_kill_urb(port->write_urbs[0]);
 865
 866         spin_lock_irqsave(&port->lock, flags);
 867         kfifo_reset_out(&port->write_fifo);
 868         spin_unlock_irqrestore(&port->lock, flags);
 869
 870         /* Kill Read URBs when final port closed */
 871         mutex_lock(&serial_priv->urb_mutex);
 872         serial_priv->opened_port--;
 873
 874         if (!serial_priv->opened_port) {
 875                 for (i = 0; i < ARRAY_SIZE(port0->read_urbs); ++i)
 876                         usb_kill_urb(port0->read_urbs[i]);
 877         }
 878
 879         mutex_unlock(&serial_priv->urb_mutex);
 880 }
 881
 882 static int f81534_get_serial_info(struct usb_serial_port *port,
 883                                   struct serial_struct __user *retinfo)
 884 {
 885         struct f81534_port_private *port_priv;
 886         struct serial_struct tmp;
 887
 888         port_priv = usb_get_serial_port_data(port);
 889
 890         memset(&tmp, 0, sizeof(tmp));
 891
 892         tmp.type = PORT_16550A;
 893         tmp.port = port->port_number;
 894         tmp.line = port->minor;
 895         tmp.baud_base = F81534_MAX_BAUDRATE;
 896
 897         if (copy_to_user(retinfo, &tmp, sizeof(*retinfo)))
 898                 return -EFAULT;
 899
 900         return 0;
 901 }
 902
 903 static int f81534_ioctl(struct tty_struct *tty, unsigned int cmd,
 904                         unsigned long arg)
 905 {
 906         struct usb_serial_port *port = tty->driver_data;
 907         struct serial_struct __user *buf = (struct serial_struct __user *)arg;
 908
 909         switch (cmd) {
 910         case TIOCGSERIAL:
 911                 return f81534_get_serial_info(port, buf);
 912         default:
 913                 break;
 914         }
 915
 916         return -ENOIOCTLCMD;
 917 }
 918
 919 static void f81534_process_per_serial_block(struct usb_serial_port *port,
 920                 u8 *data)
 921 {
 922         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
 923         int phy_num = data[0];
 924         size_t read_size = 0;
 925         size_t i;
 926         char tty_flag;
 927         int status;
 928         u8 lsr;
 929
 930         /*
 931          * The block layout is 128 Bytes
 932          * index 0: port phy idx (e.g., 0,1,2,3),
 933          * index 1: It's could be
 934          *                      F81534_TOKEN_RECEIVE
 935          *                      F81534_TOKEN_TX_EMPTY
 936          *                      F81534_TOKEN_MSR_CHANGE
 937          * index 2: serial in size (data+lsr, must be even)
 938          *                      meaningful for F81534_TOKEN_RECEIVE only
 939          * index 3: current MSR with this device
 940          * index 4~127: serial in data block (data+lsr, must be even)
 941          */
 942         switch (data[1]) {
 943         case F81534_TOKEN_TX_EMPTY:
 944                 set_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
 945
 946                 /* Try to submit writer */
 947                 status = f81534_submit_writer(port, GFP_ATOMIC);
 948                 if (status)
 949                         dev_err(&port->dev, "%s: submit failed\n", __func__);
 950                 return;
 951
 952         case F81534_TOKEN_MSR_CHANGE:
 953                 f81534_msr_changed(port, data[3]);
 954                 return;
 955
 956         case F81534_TOKEN_RECEIVE:
 957                 read_size = data[2];
 958                 if (read_size > F81534_MAX_RX_SIZE) {
 959                         dev_err(&port->dev,
 960                                 "%s: phy: %d read_size: %zu larger than: %d\n",
 961                                 __func__, phy_num, read_size,
 962                                 F81534_MAX_RX_SIZE);
 963                         return;
 964                 }
 965
 966                 break;
 967
 968         default:
 969                 dev_warn(&port->dev, "%s: unknown token: %02x\n", __func__,
 970                                 data[1]);
 971                 return;
 972         }
 973
 974         for (i = 4; i < 4 + read_size; i += 2) {
 975                 tty_flag = TTY_NORMAL;
 976                 lsr = data[i + 1];
 977
 978                 if (lsr & UART_LSR_BRK_ERROR_BITS) {
 979                         if (lsr & UART_LSR_BI) {
 980                                 tty_flag = TTY_BREAK;
 981                                 port->icount.brk++;
 982                                 usb_serial_handle_break(port);
 983                         } else if (lsr & UART_LSR_PE) {
 984                                 tty_flag = TTY_PARITY;
 985                                 port->icount.parity++;
 986                         } else if (lsr & UART_LSR_FE) {
 987                                 tty_flag = TTY_FRAME;
 988                                 port->icount.frame++;
 989                         }
 990
 991                         if (lsr & UART_LSR_OE) {
 992                                 port->icount.overrun++;
 993                                 tty_insert_flip_char(&port->port, 0,
 994                                                 TTY_OVERRUN);
 995                         }
 996                 }
 997
 998                 if (port->port.console && port->sysrq) {
 999                         if (usb_serial_handle_sysrq_char(port, data[i]))
1000                                 continue;
1001                 }
1002
1003                 tty_insert_flip_char(&port->port, data[i], tty_flag);
1004         }
1005
1006         tty_flip_buffer_push(&port->port);
1007 }
1008
1009 static void f81534_process_read_urb(struct urb *urb)
1010 {
1011         struct f81534_serial_private *serial_priv;
1012         struct usb_serial_port *port;
1013         struct usb_serial *serial;
1014         u8 *buf;
1015         int phy_port_num;
1016         int tty_port_num;
1017         size_t i;
1018
1019         if (!urb->actual_length ||
1020                         urb->actual_length % F81534_RECEIVE_BLOCK_SIZE) {
1021                 return;
1022         }
1023
1024         port = urb->context;
1025         serial = port->serial;
1026         buf = urb->transfer_buffer;
1027         serial_priv = usb_get_serial_data(serial);
1028
1029         for (i = 0; i < urb->actual_length; i += F81534_RECEIVE_BLOCK_SIZE) {
1030                 phy_port_num = buf[i];
1031                 if (phy_port_num >= F81534_NUM_PORT) {
1032                         dev_err(&port->dev,
1033                                 "%s: phy_port_num: %d larger than: %d\n",
1034                                 __func__, phy_port_num, F81534_NUM_PORT);
1035                         continue;
1036                 }
1037
1038                 tty_port_num = serial_priv->tty_idx[phy_port_num];
1039                 port = serial->port[tty_port_num];
1040
1041                 if (tty_port_initialized(&port->port))
1042                         f81534_process_per_serial_block(port, &buf[i]);
1043         }
1044 }
1045
1046 static void f81534_write_usb_callback(struct urb *urb)
1047 {
1048         struct usb_serial_port *port = urb->context;
1049
1050         switch (urb->status) {
1051         case 0:
1052                 break;
1053         case -ENOENT:
1054         case -ECONNRESET:
1055         case -ESHUTDOWN:
1056                 dev_dbg(&port->dev, "%s - urb stopped: %d\n",
1057                                 __func__, urb->status);
1058                 return;
1059         case -EPIPE:
1060                 dev_err(&port->dev, "%s - urb stopped: %d\n",
1061                                 __func__, urb->status);
1062                 return;
1063         default:
1064                 dev_dbg(&port->dev, "%s - nonzero urb status: %d\n",
1065                                 __func__, urb->status);
1066                 break;
1067         }
1068 }
1069
1070 static int f81534_setup_ports(struct usb_serial *serial)
1071 {
1072         struct usb_serial_port *port;
1073         u8 port0_out_address;
1074         int buffer_size;
1075         size_t i;
1076
1077         /*
1078          * In our system architecture, we had 2 or 4 serial ports,
1079          * but only get 1 set of bulk in/out endpoints.
1080          *
1081          * The usb-serial subsystem will generate port 0 data,
1082          * but port 1/2/3 will not. It's will generate write URB and buffer
1083          * by following code and use the port0 read URB for read operation.
1084          */
1085         for (i = 1; i < serial->num_ports; ++i) {
1086                 port0_out_address = serial->port[0]->bulk_out_endpointAddress;
1087                 buffer_size = serial->port[0]->bulk_out_size;
1088                 port = serial->port[i];
1089
1090                 if (kfifo_alloc(&port->write_fifo, PAGE_SIZE, GFP_KERNEL))
1091                         return -ENOMEM;
1092
1093                 port->bulk_out_size = buffer_size;
1094                 port->bulk_out_endpointAddress = port0_out_address;
1095
1096                 port->write_urbs[0] = usb_alloc_urb(0, GFP_KERNEL);
1097                 if (!port->write_urbs[0])
1098                         return -ENOMEM;
1099
1100                 port->bulk_out_buffers[0] = kzalloc(buffer_size, GFP_KERNEL);
1101                 if (!port->bulk_out_buffers[0])
1102                         return -ENOMEM;
1103
1104                 usb_fill_bulk_urb(port->write_urbs[0], serial->dev,
1105                                 usb_sndbulkpipe(serial->dev,
1106                                         port0_out_address),
1107                                 port->bulk_out_buffers[0], buffer_size,
1108                                 serial->type->write_bulk_callback, port);
1109
1110                 port->write_urb = port->write_urbs[0];
1111                 port->bulk_out_buffer = port->bulk_out_buffers[0];
1112         }
1113
1114         return 0;
1115 }
1116
1117 static int f81534_probe(struct usb_serial *serial,
1118                                         const struct usb_device_id *id)
1119 {
1120         struct usb_endpoint_descriptor *endpoint;
1121         struct usb_host_interface *iface_desc;
1122         struct device *dev;
1123         int num_bulk_in = 0;
1124         int num_bulk_out = 0;
1125         int size_bulk_in = 0;
1126         int size_bulk_out = 0;
1127         int i;
1128
1129         dev = &serial->interface->dev;
1130         iface_desc = serial->interface->cur_altsetting;
1131
1132         for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i) {
1133                 endpoint = &iface_desc->endpoint[i].desc;
1134
1135                 if (usb_endpoint_is_bulk_in(endpoint)) {
1136                         ++num_bulk_in;
1137                         size_bulk_in = usb_endpoint_maxp(endpoint);
1138                 }
1139
1140                 if (usb_endpoint_is_bulk_out(endpoint)) {
1141                         ++num_bulk_out;
1142                         size_bulk_out = usb_endpoint_maxp(endpoint);
1143                 }
1144         }
1145
1146         if (num_bulk_in != 1 || num_bulk_out != 1) {
1147                 dev_err(dev, "expected endpoints not found\n");
1148                 return -ENODEV;
1149         }
1150
1151         if (size_bulk_out != F81534_WRITE_BUFFER_SIZE ||
1152                         size_bulk_in != F81534_MAX_RECEIVE_BLOCK_SIZE) {
1153                 dev_err(dev, "unsupported endpoint max packet size\n");
1154                 return -ENODEV;
1155         }
1156
1157         return 0;
1158 }
1159
1160 static int f81534_attach(struct usb_serial *serial)
1161 {
1162         struct f81534_serial_private *serial_priv;
1163         int index = 0;
1164         int status;
1165         int i;
1166
1167         serial_priv = devm_kzalloc(&serial->interface->dev,
1168                                         sizeof(*serial_priv), GFP_KERNEL);
1169         if (!serial_priv)
1170                 return -ENOMEM;
1171
1172         usb_set_serial_data(serial, serial_priv);
1173
1174         mutex_init(&serial_priv->urb_mutex);
1175
1176         status = f81534_setup_ports(serial);
1177         if (status)
1178                 return status;
1179
1180         /* Check had custom setting */
1181         status = f81534_find_config_idx(serial, &serial_priv->setting_idx);
1182         if (status) {
1183                 dev_err(&serial->interface->dev, "%s: find idx failed: %d\n",
1184                                 __func__, status);
1185                 return status;
1186         }
1187
1188         /*
1189          * We'll read custom data only when data available, otherwise we'll
1190          * read default value instead.
1191          */
1192         if (serial_priv->setting_idx == F81534_CUSTOM_NO_CUSTOM_DATA) {
1193                 /*
1194                  * The default configuration layout:
1195                  *      byte 0/1/2/3: uart setting
1196                  */
1197                 status = f81534_read_flash(serial,
1198                                         F81534_DEF_CONF_ADDRESS_START,
1199                                         F81534_DEF_CONF_SIZE,
1200                                         serial_priv->conf_data);
1201                 if (status) {
1202                         dev_err(&serial->interface->dev,
1203                                         "%s: read reserve data failed: %d\n",
1204                                         __func__, status);
1205                         return status;
1206                 }
1207         } else {
1208                 /* Only read 8 bytes for mode & GPIO */
1209                 status = f81534_read_flash(serial,
1210                                                 F81534_CUSTOM_ADDRESS_START +
1211                                                 F81534_CONF_OFFSET,
1212                                                 sizeof(serial_priv->conf_data),
1213                                                 serial_priv->conf_data);
1214                 if (status) {
1215                         dev_err(&serial->interface->dev,
1216                                         "%s: idx: %d get data failed: %d\n",
1217                                         __func__, serial_priv->setting_idx,
1218                                         status);
1219                         return status;
1220                 }
1221         }
1222
1223         /* Assign phy-to-logic mapping */
1224         for (i = 0; i < F81534_NUM_PORT; ++i) {
1225                 if (serial_priv->conf_data[i] & F81534_PORT_UNAVAILABLE)
1226                         continue;
1227
1228                 serial_priv->tty_idx[i] = index++;
1229                 dev_dbg(&serial->interface->dev,
1230                                 "%s: phy_num: %d, tty_idx: %d\n", __func__, i,
1231                                 serial_priv->tty_idx[i]);
1232         }
1233
1234         return 0;
1235 }
1236
1237 static int f81534_port_probe(struct usb_serial_port *port)
1238 {
1239         struct f81534_port_private *port_priv;
1240
1241         port_priv = devm_kzalloc(&port->dev, sizeof(*port_priv), GFP_KERNEL);
1242         if (!port_priv)
1243                 return -ENOMEM;
1244
1245         spin_lock_init(&port_priv->msr_lock);
1246         mutex_init(&port_priv->mcr_mutex);
1247
1248         /* Assign logic-to-phy mapping */
1249         port_priv->phy_num = f81534_logic_to_phy_port(port->serial, port);
1250         if (port_priv->phy_num < 0 || port_priv->phy_num >= F81534_NUM_PORT)
1251                 return -ENODEV;
1252
1253         usb_set_serial_port_data(port, port_priv);
1254         dev_dbg(&port->dev, "%s: port_number: %d, phy_num: %d\n", __func__,
1255                         port->port_number, port_priv->phy_num);
1256
1257         return 0;
1258 }
1259
1260 static int f81534_tiocmget(struct tty_struct *tty)
1261 {
1262         struct usb_serial_port *port = tty->driver_data;
1263         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
1264         int status;
1265         int r;
1266         u8 msr;
1267         u8 mcr;
1268
1269         /* Read current MSR from device */
1270         status = f81534_get_port_register(port, F81534_MODEM_STATUS_REG, &msr);
1271         if (status)
1272                 return status;
1273
1274         mutex_lock(&port_priv->mcr_mutex);
1275         mcr = port_priv->shadow_mcr;
1276         mutex_unlock(&port_priv->mcr_mutex);
1277
1278         r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) |
1279             (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) |
1280             (msr & UART_MSR_CTS ? TIOCM_CTS : 0) |
1281             (msr & UART_MSR_DCD ? TIOCM_CAR : 0) |
1282             (msr & UART_MSR_RI ? TIOCM_RI : 0) |
1283             (msr & UART_MSR_DSR ? TIOCM_DSR : 0);
1284
1285         return r;
1286 }
1287
1288 static int f81534_tiocmset(struct tty_struct *tty, unsigned int set,
1289                                 unsigned int clear)
1290 {
1291         struct usb_serial_port *port = tty->driver_data;
1292
1293         return f81534_update_mctrl(port, set, clear);
1294 }
1295
1296 static void f81534_dtr_rts(struct usb_serial_port *port, int on)
1297 {
1298         if (on)
1299                 f81534_update_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
1300         else
1301                 f81534_update_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
1302 }
1303
1304 static int f81534_write(struct tty_struct *tty, struct usb_serial_port *port,
1305                         const u8 *buf, int count)
1306 {
1307         int bytes_out, status;
1308
1309         if (!count)
1310                 return 0;
1311
1312         bytes_out = kfifo_in_locked(&port->write_fifo, buf, count,
1313                                         &port->lock);
1314
1315         status = f81534_submit_writer(port, GFP_ATOMIC);
1316         if (status) {
1317                 dev_err(&port->dev, "%s: submit failed\n", __func__);
1318                 return status;
1319         }
1320
1321         return bytes_out;
1322 }
1323
1324 static bool f81534_tx_empty(struct usb_serial_port *port)
1325 {
1326         struct f81534_port_private *port_priv = usb_get_serial_port_data(port);
1327
1328         return test_bit(F81534_TX_EMPTY_BIT, &port_priv->tx_empty);
1329 }
1330
1331 static int f81534_resume(struct usb_serial *serial)
1332 {
1333         struct f81534_serial_private *serial_priv =
1334                         usb_get_serial_data(serial);
1335         struct usb_serial_port *port;
1336         int error = 0;
1337         int status;
1338         size_t i;
1339
1340         /*
1341          * We'll register port 0 bulkin when port had opened, It'll take all
1342          * port received data, MSR register change and TX_EMPTY information.
1343          */
1344         mutex_lock(&serial_priv->urb_mutex);
1345
1346         if (serial_priv->opened_port) {
1347                 status = f81534_submit_read_urb(serial, GFP_NOIO);
1348                 if (status) {
1349                         mutex_unlock(&serial_priv->urb_mutex);
1350                         return status;
1351                 }
1352         }
1353
1354         mutex_unlock(&serial_priv->urb_mutex);
1355
1356         for (i = 0; i < serial->num_ports; i++) {
1357                 port = serial->port[i];
1358                 if (!tty_port_initialized(&port->port))
1359                         continue;
1360
1361                 status = f81534_submit_writer(port, GFP_NOIO);
1362                 if (status) {
1363                         dev_err(&port->dev, "%s: submit failed\n", __func__);
1364                         ++error;
1365                 }
1366         }
1367
1368         if (error)
1369                 return -EIO;
1370
1371         return 0;
1372 }
1373
1374 static struct usb_serial_driver f81534_device = {
1375         .driver = {
1376                    .owner = THIS_MODULE,
1377                    .name = "f81534",
1378         },
1379         .description =          DRIVER_DESC,
1380         .id_table =             f81534_id_table,
1381         .open =                 f81534_open,
1382         .close =                f81534_close,
1383         .write =                f81534_write,
1384         .tx_empty =             f81534_tx_empty,
1385         .calc_num_ports =       f81534_calc_num_ports,
1386         .probe =                f81534_probe,
1387         .attach =               f81534_attach,
1388         .port_probe =           f81534_port_probe,
1389         .dtr_rts =              f81534_dtr_rts,
1390         .process_read_urb =     f81534_process_read_urb,
1391         .ioctl =                f81534_ioctl,
1392         .tiocmget =             f81534_tiocmget,
1393         .tiocmset =             f81534_tiocmset,
1394         .write_bulk_callback =  f81534_write_usb_callback,
1395         .set_termios =          f81534_set_termios,
1396         .resume =               f81534_resume,
1397 };
1398
1399 static struct usb_serial_driver *const serial_drivers[] = {
1400         &f81534_device, NULL
1401 };
1402
1403 module_usb_serial_driver(serial_drivers, f81534_id_table);
1404
1405 MODULE_DEVICE_TABLE(usb, f81534_id_table);
1406 MODULE_DESCRIPTION(DRIVER_DESC);
1407 MODULE_AUTHOR("Peter Hong <[email protected]>");
1408 MODULE_AUTHOR("Tom Tsai <[email protected]>");
1409 MODULE_LICENSE("GPL");