drivers/usb/serial/f81232.c

   1 // SPDX-License-Identifier: GPL-2.0
   2 /*
   3  * Fintek F81232 USB to serial adaptor driver
   4  *
   5  * Copyright (C) 2012 Greg Kroah-Hartman (gregkh@linuxfoundation.org)
   6  * Copyright (C) 2012 Linux Foundation
   7  */
   8
   9 #include <linux/kernel.h>
  10 #include <linux/errno.h>
  11 #include <linux/slab.h>
  12 #include <linux/tty.h>
  13 #include <linux/tty_driver.h>
  14 #include <linux/tty_flip.h>
  15 #include <linux/serial.h>
  16 #include <linux/module.h>
  17 #include <linux/moduleparam.h>
  18 #include <linux/mutex.h>
  19 #include <linux/uaccess.h>
  20 #include <linux/usb.h>
  21 #include <linux/usb/serial.h>
  22 #include <linux/serial_reg.h>
  23
  24 static const struct usb_device_id id_table[] = {
  25         { USB_DEVICE(0x1934, 0x0706) },
  26         { }                                     /* Terminating entry */
  27 };
  28 MODULE_DEVICE_TABLE(usb, id_table);
  29
  30 /* Maximum baudrate for F81232 */
  31 #define F81232_MAX_BAUDRATE             1500000
  32 #define F81232_DEF_BAUDRATE             9600
  33
  34 /* USB Control EP parameter */
  35 #define F81232_REGISTER_REQUEST         0xa0
  36 #define F81232_GET_REGISTER             0xc0
  37 #define F81232_SET_REGISTER             0x40
  38
  39 #define SERIAL_BASE_ADDRESS             0x0120
  40 #define RECEIVE_BUFFER_REGISTER         (0x00 + SERIAL_BASE_ADDRESS)
  41 #define INTERRUPT_ENABLE_REGISTER       (0x01 + SERIAL_BASE_ADDRESS)
  42 #define FIFO_CONTROL_REGISTER           (0x02 + SERIAL_BASE_ADDRESS)
  43 #define LINE_CONTROL_REGISTER           (0x03 + SERIAL_BASE_ADDRESS)
  44 #define MODEM_CONTROL_REGISTER          (0x04 + SERIAL_BASE_ADDRESS)
  45 #define LINE_STATUS_REGISTER            (0x05 + SERIAL_BASE_ADDRESS)
  46 #define MODEM_STATUS_REGISTER           (0x06 + SERIAL_BASE_ADDRESS)
  47
  48 /*
  49  * F81232 Clock registers (106h)
  50  *
  51  * Bit1-0:      Clock source selector
  52  *                      00: 1.846MHz.
  53  *                      01: 18.46MHz.
  54  *                      10: 24MHz.
  55  *                      11: 14.77MHz.
  56  */
  57 #define F81232_CLK_REGISTER             0x106
  58 #define F81232_CLK_1_846_MHZ            0
  59 #define F81232_CLK_18_46_MHZ            BIT(0)
  60 #define F81232_CLK_24_MHZ               BIT(1)
  61 #define F81232_CLK_14_77_MHZ            (BIT(1) | BIT(0))
  62 #define F81232_CLK_MASK                 GENMASK(1, 0)
  63
  64 struct f81232_private {
  65         struct mutex lock;
  66         u8 modem_control;
  67         u8 modem_status;
  68         u8 shadow_lcr;
  69         speed_t baud_base;
  70         struct work_struct lsr_work;
  71         struct work_struct interrupt_work;
  72         struct usb_serial_port *port;
  73 };
  74
  75 static u32 const baudrate_table[] = { 115200, 921600, 1152000, 1500000 };
  76 static u8 const clock_table[] = { F81232_CLK_1_846_MHZ, F81232_CLK_14_77_MHZ,
  77                                 F81232_CLK_18_46_MHZ, F81232_CLK_24_MHZ };
  78
  79 static int calc_baud_divisor(speed_t baudrate, speed_t clockrate)
  80 {
  81         if (!baudrate)
  82                 return 0;
  83
  84         return DIV_ROUND_CLOSEST(clockrate, baudrate);
  85 }
  86
  87 static int f81232_get_register(struct usb_serial_port *port, u16 reg, u8 *val)
  88 {
  89         int status;
  90         u8 *tmp;
  91         struct usb_device *dev = port->serial->dev;
  92
  93         tmp = kmalloc(sizeof(*val), GFP_KERNEL);
  94         if (!tmp)
  95                 return -ENOMEM;
  96
  97         status = usb_control_msg(dev,
  98                                 usb_rcvctrlpipe(dev, 0),
  99                                 F81232_REGISTER_REQUEST,
 100                                 F81232_GET_REGISTER,
 101                                 reg,
 102                                 0,
 103                                 tmp,
 104                                 sizeof(*val),
 105                                 USB_CTRL_GET_TIMEOUT);
 106         if (status != sizeof(*val)) {
 107                 dev_err(&port->dev, "%s failed status: %d\n", __func__, status);
 108
 109                 if (status < 0)
 110                         status = usb_translate_errors(status);
 111                 else
 112                         status = -EIO;
 113         } else {
 114                 status = 0;
 115                 *val = *tmp;
 116         }
 117
 118         kfree(tmp);
 119         return status;
 120 }
 121
 122 static int f81232_set_register(struct usb_serial_port *port, u16 reg, u8 val)
 123 {
 124         int status;
 125         u8 *tmp;
 126         struct usb_device *dev = port->serial->dev;
 127
 128         tmp = kmalloc(sizeof(val), GFP_KERNEL);
 129         if (!tmp)
 130                 return -ENOMEM;
 131
 132         *tmp = val;
 133
 134         status = usb_control_msg(dev,
 135                                 usb_sndctrlpipe(dev, 0),
 136                                 F81232_REGISTER_REQUEST,
 137                                 F81232_SET_REGISTER,
 138                                 reg,
 139                                 0,
 140                                 tmp,
 141                                 sizeof(val),
 142                                 USB_CTRL_SET_TIMEOUT);
 143         if (status != sizeof(val)) {
 144                 dev_err(&port->dev, "%s failed status: %d\n", __func__, status);
 145
 146                 if (status < 0)
 147                         status = usb_translate_errors(status);
 148                 else
 149                         status = -EIO;
 150         } else {
 151                 status = 0;
 152         }
 153
 154         kfree(tmp);
 155         return status;
 156 }
 157
 158 static int f81232_set_mask_register(struct usb_serial_port *port, u16 reg,
 159                                         u8 mask, u8 val)
 160 {
 161         int status;
 162         u8 tmp;
 163
 164         status = f81232_get_register(port, reg, &tmp);
 165         if (status)
 166                 return status;
 167
 168         tmp = (tmp & ~mask) | (val & mask);
 169
 170         return f81232_set_register(port, reg, tmp);
 171 }
 172
 173 static void f81232_read_msr(struct usb_serial_port *port)
 174 {
 175         int status;
 176         u8 current_msr;
 177         struct tty_struct *tty;
 178         struct f81232_private *priv = usb_get_serial_port_data(port);
 179
 180         mutex_lock(&priv->lock);
 181         status = f81232_get_register(port, MODEM_STATUS_REGISTER,
 182                         &current_msr);
 183         if (status) {
 184                 dev_err(&port->dev, "%s fail, status: %d\n", __func__, status);
 185                 mutex_unlock(&priv->lock);
 186                 return;
 187         }
 188
 189         if (!(current_msr & UART_MSR_ANY_DELTA)) {
 190                 mutex_unlock(&priv->lock);
 191                 return;
 192         }
 193
 194         priv->modem_status = current_msr;
 195
 196         if (current_msr & UART_MSR_DCTS)
 197                 port->icount.cts++;
 198         if (current_msr & UART_MSR_DDSR)
 199                 port->icount.dsr++;
 200         if (current_msr & UART_MSR_TERI)
 201                 port->icount.rng++;
 202         if (current_msr & UART_MSR_DDCD) {
 203                 port->icount.dcd++;
 204                 tty = tty_port_tty_get(&port->port);
 205                 if (tty) {
 206                         usb_serial_handle_dcd_change(port, tty,
 207                                         current_msr & UART_MSR_DCD);
 208
 209                         tty_kref_put(tty);
 210                 }
 211         }
 212
 213         wake_up_interruptible(&port->port.delta_msr_wait);
 214         mutex_unlock(&priv->lock);
 215 }
 216
 217 static int f81232_set_mctrl(struct usb_serial_port *port,
 218                                            unsigned int set, unsigned int clear)
 219 {
 220         u8 val;
 221         int status;
 222         struct f81232_private *priv = usb_get_serial_port_data(port);
 223
 224         if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0)
 225                 return 0;       /* no change */
 226
 227         /* 'set' takes precedence over 'clear' */
 228         clear &= ~set;
 229
 230         /* force enable interrupt with OUT2 */
 231         mutex_lock(&priv->lock);
 232         val = UART_MCR_OUT2 | priv->modem_control;
 233
 234         if (clear & TIOCM_DTR)
 235                 val &= ~UART_MCR_DTR;
 236
 237         if (clear & TIOCM_RTS)
 238                 val &= ~UART_MCR_RTS;
 239
 240         if (set & TIOCM_DTR)
 241                 val |= UART_MCR_DTR;
 242
 243         if (set & TIOCM_RTS)
 244                 val |= UART_MCR_RTS;
 245
 246         dev_dbg(&port->dev, "%s new:%02x old:%02x\n", __func__,
 247                         val, priv->modem_control);
 248
 249         status = f81232_set_register(port, MODEM_CONTROL_REGISTER, val);
 250         if (status) {
 251                 dev_err(&port->dev, "%s set MCR status < 0\n", __func__);
 252                 mutex_unlock(&priv->lock);
 253                 return status;
 254         }
 255
 256         priv->modem_control = val;
 257         mutex_unlock(&priv->lock);
 258
 259         return 0;
 260 }
 261
 262 static void f81232_update_line_status(struct usb_serial_port *port,
 263                                       unsigned char *data,
 264                                       size_t actual_length)
 265 {
 266         struct f81232_private *priv = usb_get_serial_port_data(port);
 267
 268         if (!actual_length)
 269                 return;
 270
 271         switch (data[0] & 0x07) {
 272         case 0x00: /* msr change */
 273                 dev_dbg(&port->dev, "IIR: MSR Change: %02x\n", data[0]);
 274                 schedule_work(&priv->interrupt_work);
 275                 break;
 276         case 0x02: /* tx-empty */
 277                 break;
 278         case 0x04: /* rx data available */
 279                 break;
 280         case 0x06: /* lsr change */
 281                 /* we can forget it. the LSR will read from bulk-in */
 282                 dev_dbg(&port->dev, "IIR: LSR Change: %02x\n", data[0]);
 283                 break;
 284         }
 285 }
 286
 287 static void f81232_read_int_callback(struct urb *urb)
 288 {
 289         struct usb_serial_port *port =  urb->context;
 290         unsigned char *data = urb->transfer_buffer;
 291         unsigned int actual_length = urb->actual_length;
 292         int status = urb->status;
 293         int retval;
 294
 295         switch (status) {
 296         case 0:
 297                 /* success */
 298                 break;
 299         case -ECONNRESET:
 300         case -ENOENT:
 301         case -ESHUTDOWN:
 302                 /* this urb is terminated, clean up */
 303                 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n",
 304                         __func__, status);
 305                 return;
 306         default:
 307                 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n",
 308                         __func__, status);
 309                 goto exit;
 310         }
 311
 312         usb_serial_debug_data(&port->dev, __func__,
 313                               urb->actual_length, urb->transfer_buffer);
 314
 315         f81232_update_line_status(port, data, actual_length);
 316
 317 exit:
 318         retval = usb_submit_urb(urb, GFP_ATOMIC);
 319         if (retval)
 320                 dev_err(&urb->dev->dev,
 321                         "%s - usb_submit_urb failed with result %d\n",
 322                         __func__, retval);
 323 }
 324
 325 static void f81232_process_read_urb(struct urb *urb)
 326 {
 327         struct usb_serial_port *port = urb->context;
 328         struct f81232_private *priv = usb_get_serial_port_data(port);
 329         unsigned char *data = urb->transfer_buffer;
 330         char tty_flag;
 331         unsigned int i;
 332         u8 lsr;
 333
 334         /*
 335          * When opening the port we get a 1-byte packet with the current LSR,
 336          * which we discard.
 337          */
 338         if ((urb->actual_length < 2) || (urb->actual_length % 2))
 339                 return;
 340
 341         /* bulk-in data: [LSR(1Byte)+DATA(1Byte)][LSR(1Byte)+DATA(1Byte)]... */
 342
 343         for (i = 0; i < urb->actual_length; i += 2) {
 344                 tty_flag = TTY_NORMAL;
 345                 lsr = data[i];
 346
 347                 if (lsr & UART_LSR_BRK_ERROR_BITS) {
 348                         if (lsr & UART_LSR_BI) {
 349                                 tty_flag = TTY_BREAK;
 350                                 port->icount.brk++;
 351                                 usb_serial_handle_break(port);
 352                         } else if (lsr & UART_LSR_PE) {
 353                                 tty_flag = TTY_PARITY;
 354                                 port->icount.parity++;
 355                         } else if (lsr & UART_LSR_FE) {
 356                                 tty_flag = TTY_FRAME;
 357                                 port->icount.frame++;
 358                         }
 359
 360                         if (lsr & UART_LSR_OE) {
 361                                 port->icount.overrun++;
 362                                 schedule_work(&priv->lsr_work);
 363                                 tty_insert_flip_char(&port->port, 0,
 364                                                 TTY_OVERRUN);
 365                         }
 366                 }
 367
 368                 if (port->port.console && port->sysrq) {
 369                         if (usb_serial_handle_sysrq_char(port, data[i + 1]))
 370                                 continue;
 371                 }
 372
 373                 tty_insert_flip_char(&port->port, data[i + 1], tty_flag);
 374         }
 375
 376         tty_flip_buffer_push(&port->port);
 377 }
 378
 379 static void f81232_break_ctl(struct tty_struct *tty, int break_state)
 380 {
 381         struct usb_serial_port *port = tty->driver_data;
 382         struct f81232_private *priv = usb_get_serial_port_data(port);
 383         int status;
 384
 385         mutex_lock(&priv->lock);
 386
 387         if (break_state)
 388                 priv->shadow_lcr |= UART_LCR_SBC;
 389         else
 390                 priv->shadow_lcr &= ~UART_LCR_SBC;
 391
 392         status = f81232_set_register(port, LINE_CONTROL_REGISTER,
 393                                         priv->shadow_lcr);
 394         if (status)
 395                 dev_err(&port->dev, "set break failed: %d\n", status);
 396
 397         mutex_unlock(&priv->lock);
 398 }
 399
 400 static int f81232_find_clk(speed_t baudrate)
 401 {
 402         int idx;
 403
 404         for (idx = 0; idx < ARRAY_SIZE(baudrate_table); ++idx) {
 405                 if (baudrate <= baudrate_table[idx] &&
 406                                 baudrate_table[idx] % baudrate == 0)
 407                         return idx;
 408         }
 409
 410         return -EINVAL;
 411 }
 412
 413 static void f81232_set_baudrate(struct tty_struct *tty,
 414                                 struct usb_serial_port *port, speed_t baudrate,
 415                                 speed_t old_baudrate)
 416 {
 417         struct f81232_private *priv = usb_get_serial_port_data(port);
 418         u8 lcr;
 419         int divisor;
 420         int status = 0;
 421         int i;
 422         int idx;
 423         speed_t baud_list[] = { baudrate, old_baudrate, F81232_DEF_BAUDRATE };
 424
 425         for (i = 0; i < ARRAY_SIZE(baud_list); ++i) {
 426                 idx = f81232_find_clk(baud_list[i]);
 427                 if (idx >= 0) {
 428                         baudrate = baud_list[i];
 429                         tty_encode_baud_rate(tty, baudrate, baudrate);
 430                         break;
 431                 }
 432         }
 433
 434         if (idx < 0)
 435                 return;
 436
 437         priv->baud_base = baudrate_table[idx];
 438         divisor = calc_baud_divisor(baudrate, priv->baud_base);
 439
 440         status = f81232_set_mask_register(port, F81232_CLK_REGISTER,
 441                         F81232_CLK_MASK, clock_table[idx]);
 442         if (status) {
 443                 dev_err(&port->dev, "%s failed to set CLK_REG: %d\n",
 444                         __func__, status);
 445                 return;
 446         }
 447
 448         status = f81232_get_register(port, LINE_CONTROL_REGISTER,
 449                          &lcr); /* get LCR */
 450         if (status) {
 451                 dev_err(&port->dev, "%s failed to get LCR: %d\n",
 452                         __func__, status);
 453                 return;
 454         }
 455
 456         status = f81232_set_register(port, LINE_CONTROL_REGISTER,
 457                          lcr | UART_LCR_DLAB); /* Enable DLAB */
 458         if (status) {
 459                 dev_err(&port->dev, "%s failed to set DLAB: %d\n",
 460                         __func__, status);
 461                 return;
 462         }
 463
 464         status = f81232_set_register(port, RECEIVE_BUFFER_REGISTER,
 465                          divisor & 0x00ff); /* low */
 466         if (status) {
 467                 dev_err(&port->dev, "%s failed to set baudrate MSB: %d\n",
 468                         __func__, status);
 469                 goto reapply_lcr;
 470         }
 471
 472         status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER,
 473                          (divisor & 0xff00) >> 8); /* high */
 474         if (status) {
 475                 dev_err(&port->dev, "%s failed to set baudrate LSB: %d\n",
 476                         __func__, status);
 477         }
 478
 479 reapply_lcr:
 480         status = f81232_set_register(port, LINE_CONTROL_REGISTER,
 481                         lcr & ~UART_LCR_DLAB);
 482         if (status) {
 483                 dev_err(&port->dev, "%s failed to set DLAB: %d\n",
 484                         __func__, status);
 485         }
 486 }
 487
 488 static int f81232_port_enable(struct usb_serial_port *port)
 489 {
 490         u8 val;
 491         int status;
 492
 493         /* fifo on, trigger8, clear TX/RX*/
 494         val = UART_FCR_TRIGGER_8 | UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR |
 495                         UART_FCR_CLEAR_XMIT;
 496
 497         status = f81232_set_register(port, FIFO_CONTROL_REGISTER, val);
 498         if (status) {
 499                 dev_err(&port->dev, "%s failed to set FCR: %d\n",
 500                         __func__, status);
 501                 return status;
 502         }
 503
 504         /* MSR Interrupt only, LSR will read from Bulk-in odd byte */
 505         status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER,
 506                         UART_IER_MSI);
 507         if (status) {
 508                 dev_err(&port->dev, "%s failed to set IER: %d\n",
 509                         __func__, status);
 510                 return status;
 511         }
 512
 513         return 0;
 514 }
 515
 516 static int f81232_port_disable(struct usb_serial_port *port)
 517 {
 518         int status;
 519
 520         status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER, 0);
 521         if (status) {
 522                 dev_err(&port->dev, "%s failed to set IER: %d\n",
 523                         __func__, status);
 524                 return status;
 525         }
 526
 527         return 0;
 528 }
 529
 530 static void f81232_set_termios(struct tty_struct *tty,
 531                 struct usb_serial_port *port, struct ktermios *old_termios)
 532 {
 533         struct f81232_private *priv = usb_get_serial_port_data(port);
 534         u8 new_lcr = 0;
 535         int status = 0;
 536         speed_t baudrate;
 537         speed_t old_baud;
 538
 539         /* Don't change anything if nothing has changed */
 540         if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios))
 541                 return;
 542
 543         if (C_BAUD(tty) == B0)
 544                 f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
 545         else if (old_termios && (old_termios->c_cflag & CBAUD) == B0)
 546                 f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
 547
 548         baudrate = tty_get_baud_rate(tty);
 549         if (baudrate > 0) {
 550                 if (old_termios)
 551                         old_baud = tty_termios_baud_rate(old_termios);
 552                 else
 553                         old_baud = F81232_DEF_BAUDRATE;
 554
 555                 f81232_set_baudrate(tty, port, baudrate, old_baud);
 556         }
 557
 558         if (C_PARENB(tty)) {
 559                 new_lcr |= UART_LCR_PARITY;
 560
 561                 if (!C_PARODD(tty))
 562                         new_lcr |= UART_LCR_EPAR;
 563
 564                 if (C_CMSPAR(tty))
 565                         new_lcr |= UART_LCR_SPAR;
 566         }
 567
 568         if (C_CSTOPB(tty))
 569                 new_lcr |= UART_LCR_STOP;
 570
 571         switch (C_CSIZE(tty)) {
 572         case CS5:
 573                 new_lcr |= UART_LCR_WLEN5;
 574                 break;
 575         case CS6:
 576                 new_lcr |= UART_LCR_WLEN6;
 577                 break;
 578         case CS7:
 579                 new_lcr |= UART_LCR_WLEN7;
 580                 break;
 581         default:
 582         case CS8:
 583                 new_lcr |= UART_LCR_WLEN8;
 584                 break;
 585         }
 586
 587         mutex_lock(&priv->lock);
 588
 589         new_lcr |= (priv->shadow_lcr & UART_LCR_SBC);
 590         status = f81232_set_register(port, LINE_CONTROL_REGISTER, new_lcr);
 591         if (status) {
 592                 dev_err(&port->dev, "%s failed to set LCR: %d\n",
 593                         __func__, status);
 594         }
 595
 596         priv->shadow_lcr = new_lcr;
 597
 598         mutex_unlock(&priv->lock);
 599 }
 600
 601 static int f81232_tiocmget(struct tty_struct *tty)
 602 {
 603         int r;
 604         struct usb_serial_port *port = tty->driver_data;
 605         struct f81232_private *port_priv = usb_get_serial_port_data(port);
 606         u8 mcr, msr;
 607
 608         /* force get current MSR changed state */
 609         f81232_read_msr(port);
 610
 611         mutex_lock(&port_priv->lock);
 612         mcr = port_priv->modem_control;
 613         msr = port_priv->modem_status;
 614         mutex_unlock(&port_priv->lock);
 615
 616         r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) |
 617                 (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) |
 618                 (msr & UART_MSR_CTS ? TIOCM_CTS : 0) |
 619                 (msr & UART_MSR_DCD ? TIOCM_CAR : 0) |
 620                 (msr & UART_MSR_RI ? TIOCM_RI : 0) |
 621                 (msr & UART_MSR_DSR ? TIOCM_DSR : 0);
 622
 623         return r;
 624 }
 625
 626 static int f81232_tiocmset(struct tty_struct *tty,
 627                         unsigned int set, unsigned int clear)
 628 {
 629         struct usb_serial_port *port = tty->driver_data;
 630
 631         return f81232_set_mctrl(port, set, clear);
 632 }
 633
 634 static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port)
 635 {
 636         int result;
 637
 638         result = f81232_port_enable(port);
 639         if (result)
 640                 return result;
 641
 642         /* Setup termios */
 643         if (tty)
 644                 f81232_set_termios(tty, port, NULL);
 645
 646         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 647         if (result) {
 648                 dev_err(&port->dev, "%s - failed submitting interrupt urb,"
 649                         " error %d\n", __func__, result);
 650                 return result;
 651         }
 652
 653         result = usb_serial_generic_open(tty, port);
 654         if (result) {
 655                 usb_kill_urb(port->interrupt_in_urb);
 656                 return result;
 657         }
 658
 659         return 0;
 660 }
 661
 662 static void f81232_close(struct usb_serial_port *port)
 663 {
 664         struct f81232_private *port_priv = usb_get_serial_port_data(port);
 665
 666         f81232_port_disable(port);
 667         usb_serial_generic_close(port);
 668         usb_kill_urb(port->interrupt_in_urb);
 669         flush_work(&port_priv->interrupt_work);
 670         flush_work(&port_priv->lsr_work);
 671 }
 672
 673 static void f81232_dtr_rts(struct usb_serial_port *port, int on)
 674 {
 675         if (on)
 676                 f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0);
 677         else
 678                 f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS);
 679 }
 680
 681 static int f81232_carrier_raised(struct usb_serial_port *port)
 682 {
 683         u8 msr;
 684         struct f81232_private *priv = usb_get_serial_port_data(port);
 685
 686         mutex_lock(&priv->lock);
 687         msr = priv->modem_status;
 688         mutex_unlock(&priv->lock);
 689
 690         if (msr & UART_MSR_DCD)
 691                 return 1;
 692         return 0;
 693 }
 694
 695 static int f81232_get_serial_info(struct tty_struct *tty,
 696                 struct serial_struct *ss)
 697 {
 698         struct usb_serial_port *port = tty->driver_data;
 699         struct f81232_private *priv = usb_get_serial_port_data(port);
 700
 701         ss->type = PORT_16550A;
 702         ss->line = port->minor;
 703         ss->port = port->port_number;
 704         ss->baud_base = priv->baud_base;
 705         return 0;
 706 }
 707
 708 static void  f81232_interrupt_work(struct work_struct *work)
 709 {
 710         struct f81232_private *priv =
 711                 container_of(work, struct f81232_private, interrupt_work);
 712
 713         f81232_read_msr(priv->port);
 714 }
 715
 716 static void f81232_lsr_worker(struct work_struct *work)
 717 {
 718         struct f81232_private *priv;
 719         struct usb_serial_port *port;
 720         int status;
 721         u8 tmp;
 722
 723         priv = container_of(work, struct f81232_private, lsr_work);
 724         port = priv->port;
 725
 726         status = f81232_get_register(port, LINE_STATUS_REGISTER, &tmp);
 727         if (status)
 728                 dev_warn(&port->dev, "read LSR failed: %d\n", status);
 729 }
 730
 731 static int f81232_port_probe(struct usb_serial_port *port)
 732 {
 733         struct f81232_private *priv;
 734
 735         priv = kzalloc(sizeof(*priv), GFP_KERNEL);
 736         if (!priv)
 737                 return -ENOMEM;
 738
 739         mutex_init(&priv->lock);
 740         INIT_WORK(&priv->interrupt_work,  f81232_interrupt_work);
 741         INIT_WORK(&priv->lsr_work, f81232_lsr_worker);
 742
 743         usb_set_serial_port_data(port, priv);
 744
 745         port->port.drain_delay = 256;
 746         priv->port = port;
 747
 748         return 0;
 749 }
 750
 751 static int f81232_port_remove(struct usb_serial_port *port)
 752 {
 753         struct f81232_private *priv;
 754
 755         priv = usb_get_serial_port_data(port);
 756         kfree(priv);
 757
 758         return 0;
 759 }
 760
 761 static int f81232_suspend(struct usb_serial *serial, pm_message_t message)
 762 {
 763         struct usb_serial_port *port = serial->port[0];
 764         struct f81232_private *port_priv = usb_get_serial_port_data(port);
 765         int i;
 766
 767         for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i)
 768                 usb_kill_urb(port->read_urbs[i]);
 769
 770         usb_kill_urb(port->interrupt_in_urb);
 771
 772         if (port_priv) {
 773                 flush_work(&port_priv->interrupt_work);
 774                 flush_work(&port_priv->lsr_work);
 775         }
 776
 777         return 0;
 778 }
 779
 780 static int f81232_resume(struct usb_serial *serial)
 781 {
 782         struct usb_serial_port *port = serial->port[0];
 783         int result;
 784
 785         if (tty_port_initialized(&port->port)) {
 786                 result = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO);
 787                 if (result) {
 788                         dev_err(&port->dev, "submit interrupt urb failed: %d\n",
 789                                         result);
 790                         return result;
 791                 }
 792         }
 793
 794         return usb_serial_generic_resume(serial);
 795 }
 796
 797 static struct usb_serial_driver f81232_device = {
 798         .driver = {
 799                 .owner =        THIS_MODULE,
 800                 .name =         "f81232",
 801         },
 802         .id_table =             id_table,
 803         .num_ports =            1,
 804         .bulk_in_size =         256,
 805         .bulk_out_size =        256,
 806         .open =                 f81232_open,
 807         .close =                f81232_close,
 808         .dtr_rts =              f81232_dtr_rts,
 809         .carrier_raised =       f81232_carrier_raised,
 810         .get_serial =           f81232_get_serial_info,
 811         .break_ctl =            f81232_break_ctl,
 812         .set_termios =          f81232_set_termios,
 813         .tiocmget =             f81232_tiocmget,
 814         .tiocmset =             f81232_tiocmset,
 815         .tiocmiwait =           usb_serial_generic_tiocmiwait,
 816         .process_read_urb =     f81232_process_read_urb,
 817         .read_int_callback =    f81232_read_int_callback,
 818         .port_probe =           f81232_port_probe,
 819         .port_remove =          f81232_port_remove,
 820         .suspend =              f81232_suspend,
 821         .resume =               f81232_resume,
 822 };
 823
 824 static struct usb_serial_driver * const serial_drivers[] = {
 825         &f81232_device,
 826         NULL,
 827 };
 828
 829 module_usb_serial_driver(serial_drivers, id_table);
 830
 831 MODULE_DESCRIPTION("Fintek F81232 USB to serial adaptor driver");
 832 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org>");
 833 MODULE_AUTHOR("Peter Hong <peter_hong@fintek.com.tw>");
 834 MODULE_LICENSE("GPL v2");