drivers/usb/serial/f81534.c

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