1 // SPDX-License-Identifier: GPL-2.0 2 /* 3 * Fintek F81232 USB to serial adaptor driver 4 * Fintek F81532A/534A/535/536 USB to 2/4/8/12 serial adaptor driver 5 * 6 * Copyright (C) 2012 Greg Kroah-Hartman (gregkh@linuxfoundation.org) 7 * Copyright (C) 2012 Linux Foundation 8 */ 9 10 #include <linux/kernel.h> 11 #include <linux/errno.h> 12 #include <linux/slab.h> 13 #include <linux/tty.h> 14 #include <linux/tty_flip.h> 15 #include <linux/serial.h> 16 #include <linux/module.h> 17 #include <linux/mutex.h> 18 #include <linux/usb.h> 19 #include <linux/usb/serial.h> 20 #include <linux/serial_reg.h> 21 22 #define F81232_ID \ 23 { USB_DEVICE(0x1934, 0x0706) } /* 1 port UART device */ 24 25 #define F81534A_SERIES_ID \ 26 { USB_DEVICE(0x2c42, 0x1602) }, /* In-Box 2 port UART device */ \ 27 { USB_DEVICE(0x2c42, 0x1604) }, /* In-Box 4 port UART device */ \ 28 { USB_DEVICE(0x2c42, 0x1605) }, /* In-Box 8 port UART device */ \ 29 { USB_DEVICE(0x2c42, 0x1606) }, /* In-Box 12 port UART device */ \ 30 { USB_DEVICE(0x2c42, 0x1608) }, /* Non-Flash type */ \ 31 { USB_DEVICE(0x2c42, 0x1632) }, /* 2 port UART device */ \ 32 { USB_DEVICE(0x2c42, 0x1634) }, /* 4 port UART device */ \ 33 { USB_DEVICE(0x2c42, 0x1635) }, /* 8 port UART device */ \ 34 { USB_DEVICE(0x2c42, 0x1636) } /* 12 port UART device */ 35 36 #define F81534A_CTRL_ID \ 37 { USB_DEVICE(0x2c42, 0x16f8) } /* Global control device */ 38 39 static const struct usb_device_id f81232_id_table[] = { 40 F81232_ID, 41 { } /* Terminating entry */ 42 }; 43 44 static const struct usb_device_id f81534a_id_table[] = { 45 F81534A_SERIES_ID, 46 { } /* Terminating entry */ 47 }; 48 49 static const struct usb_device_id f81534a_ctrl_id_table[] = { 50 F81534A_CTRL_ID, 51 { } /* Terminating entry */ 52 }; 53 54 static const struct usb_device_id combined_id_table[] = { 55 F81232_ID, 56 F81534A_SERIES_ID, 57 F81534A_CTRL_ID, 58 { } /* Terminating entry */ 59 }; 60 MODULE_DEVICE_TABLE(usb, combined_id_table); 61 62 /* Maximum baudrate for F81232 */ 63 #define F81232_MAX_BAUDRATE 1500000 64 #define F81232_DEF_BAUDRATE 9600 65 66 /* USB Control EP parameter */ 67 #define F81232_REGISTER_REQUEST 0xa0 68 #define F81232_GET_REGISTER 0xc0 69 #define F81232_SET_REGISTER 0x40 70 71 #define SERIAL_BASE_ADDRESS 0x0120 72 #define RECEIVE_BUFFER_REGISTER (0x00 + SERIAL_BASE_ADDRESS) 73 #define INTERRUPT_ENABLE_REGISTER (0x01 + SERIAL_BASE_ADDRESS) 74 #define FIFO_CONTROL_REGISTER (0x02 + SERIAL_BASE_ADDRESS) 75 #define LINE_CONTROL_REGISTER (0x03 + SERIAL_BASE_ADDRESS) 76 #define MODEM_CONTROL_REGISTER (0x04 + SERIAL_BASE_ADDRESS) 77 #define LINE_STATUS_REGISTER (0x05 + SERIAL_BASE_ADDRESS) 78 #define MODEM_STATUS_REGISTER (0x06 + SERIAL_BASE_ADDRESS) 79 80 /* 81 * F81232 Clock registers (106h) 82 * 83 * Bit1-0: Clock source selector 84 * 00: 1.846MHz. 85 * 01: 18.46MHz. 86 * 10: 24MHz. 87 * 11: 14.77MHz. 88 */ 89 #define F81232_CLK_REGISTER 0x106 90 #define F81232_CLK_1_846_MHZ 0 91 #define F81232_CLK_18_46_MHZ BIT(0) 92 #define F81232_CLK_24_MHZ BIT(1) 93 #define F81232_CLK_14_77_MHZ (BIT(1) | BIT(0)) 94 #define F81232_CLK_MASK GENMASK(1, 0) 95 96 #define F81534A_MODE_REG 0x107 97 #define F81534A_TRIGGER_MASK GENMASK(3, 2) 98 #define F81534A_TRIGGER_MULTIPLE_4X BIT(3) 99 #define F81534A_FIFO_128BYTE (BIT(1) | BIT(0)) 100 101 /* Serial port self GPIO control, 2bytes [control&output data][input data] */ 102 #define F81534A_GPIO_REG 0x10e 103 #define F81534A_GPIO_MODE2_DIR BIT(6) /* 1: input, 0: output */ 104 #define F81534A_GPIO_MODE1_DIR BIT(5) 105 #define F81534A_GPIO_MODE0_DIR BIT(4) 106 #define F81534A_GPIO_MODE2_OUTPUT BIT(2) 107 #define F81534A_GPIO_MODE1_OUTPUT BIT(1) 108 #define F81534A_GPIO_MODE0_OUTPUT BIT(0) 109 110 #define F81534A_CTRL_CMD_ENABLE_PORT 0x116 111 112 struct f81232_private { 113 struct mutex lock; 114 u8 modem_control; 115 u8 modem_status; 116 u8 shadow_lcr; 117 speed_t baud_base; 118 struct work_struct lsr_work; 119 struct work_struct interrupt_work; 120 struct usb_serial_port *port; 121 }; 122 123 static u32 const baudrate_table[] = { 115200, 921600, 1152000, 1500000 }; 124 static u8 const clock_table[] = { F81232_CLK_1_846_MHZ, F81232_CLK_14_77_MHZ, 125 F81232_CLK_18_46_MHZ, F81232_CLK_24_MHZ }; 126 127 static int calc_baud_divisor(speed_t baudrate, speed_t clockrate) 128 { 129 return DIV_ROUND_CLOSEST(clockrate, baudrate); 130 } 131 132 static int f81232_get_register(struct usb_serial_port *port, u16 reg, u8 *val) 133 { 134 int status; 135 struct usb_device *dev = port->serial->dev; 136 137 status = usb_control_msg_recv(dev, 138 0, 139 F81232_REGISTER_REQUEST, 140 F81232_GET_REGISTER, 141 reg, 142 0, 143 val, 144 sizeof(*val), 145 USB_CTRL_GET_TIMEOUT, 146 GFP_KERNEL); 147 if (status) { 148 dev_err(&port->dev, "%s failed status: %d\n", __func__, status); 149 status = usb_translate_errors(status); 150 } 151 152 return status; 153 } 154 155 static int f81232_set_register(struct usb_serial_port *port, u16 reg, u8 val) 156 { 157 int status; 158 struct usb_device *dev = port->serial->dev; 159 160 status = usb_control_msg_send(dev, 161 0, 162 F81232_REGISTER_REQUEST, 163 F81232_SET_REGISTER, 164 reg, 165 0, 166 &val, 167 sizeof(val), 168 USB_CTRL_SET_TIMEOUT, 169 GFP_KERNEL); 170 if (status) { 171 dev_err(&port->dev, "%s failed status: %d\n", __func__, status); 172 status = usb_translate_errors(status); 173 } 174 175 return status; 176 } 177 178 static int f81232_set_mask_register(struct usb_serial_port *port, u16 reg, 179 u8 mask, u8 val) 180 { 181 int status; 182 u8 tmp; 183 184 status = f81232_get_register(port, reg, &tmp); 185 if (status) 186 return status; 187 188 tmp = (tmp & ~mask) | (val & mask); 189 190 return f81232_set_register(port, reg, tmp); 191 } 192 193 static void f81232_read_msr(struct usb_serial_port *port) 194 { 195 int status; 196 u8 current_msr; 197 struct tty_struct *tty; 198 struct f81232_private *priv = usb_get_serial_port_data(port); 199 200 mutex_lock(&priv->lock); 201 status = f81232_get_register(port, MODEM_STATUS_REGISTER, 202 ¤t_msr); 203 if (status) { 204 dev_err(&port->dev, "%s fail, status: %d\n", __func__, status); 205 mutex_unlock(&priv->lock); 206 return; 207 } 208 209 if (!(current_msr & UART_MSR_ANY_DELTA)) { 210 mutex_unlock(&priv->lock); 211 return; 212 } 213 214 priv->modem_status = current_msr; 215 216 if (current_msr & UART_MSR_DCTS) 217 port->icount.cts++; 218 if (current_msr & UART_MSR_DDSR) 219 port->icount.dsr++; 220 if (current_msr & UART_MSR_TERI) 221 port->icount.rng++; 222 if (current_msr & UART_MSR_DDCD) { 223 port->icount.dcd++; 224 tty = tty_port_tty_get(&port->port); 225 if (tty) { 226 usb_serial_handle_dcd_change(port, tty, 227 current_msr & UART_MSR_DCD); 228 229 tty_kref_put(tty); 230 } 231 } 232 233 wake_up_interruptible(&port->port.delta_msr_wait); 234 mutex_unlock(&priv->lock); 235 } 236 237 static int f81232_set_mctrl(struct usb_serial_port *port, 238 unsigned int set, unsigned int clear) 239 { 240 u8 val; 241 int status; 242 struct f81232_private *priv = usb_get_serial_port_data(port); 243 244 if (((set | clear) & (TIOCM_DTR | TIOCM_RTS)) == 0) 245 return 0; /* no change */ 246 247 /* 'set' takes precedence over 'clear' */ 248 clear &= ~set; 249 250 /* force enable interrupt with OUT2 */ 251 mutex_lock(&priv->lock); 252 val = UART_MCR_OUT2 | priv->modem_control; 253 254 if (clear & TIOCM_DTR) 255 val &= ~UART_MCR_DTR; 256 257 if (clear & TIOCM_RTS) 258 val &= ~UART_MCR_RTS; 259 260 if (set & TIOCM_DTR) 261 val |= UART_MCR_DTR; 262 263 if (set & TIOCM_RTS) 264 val |= UART_MCR_RTS; 265 266 dev_dbg(&port->dev, "%s new:%02x old:%02x\n", __func__, 267 val, priv->modem_control); 268 269 status = f81232_set_register(port, MODEM_CONTROL_REGISTER, val); 270 if (status) { 271 dev_err(&port->dev, "%s set MCR status < 0\n", __func__); 272 mutex_unlock(&priv->lock); 273 return status; 274 } 275 276 priv->modem_control = val; 277 mutex_unlock(&priv->lock); 278 279 return 0; 280 } 281 282 static void f81232_update_line_status(struct usb_serial_port *port, 283 unsigned char *data, 284 size_t actual_length) 285 { 286 struct f81232_private *priv = usb_get_serial_port_data(port); 287 288 if (!actual_length) 289 return; 290 291 switch (data[0] & 0x07) { 292 case 0x00: /* msr change */ 293 dev_dbg(&port->dev, "IIR: MSR Change: %02x\n", data[0]); 294 schedule_work(&priv->interrupt_work); 295 break; 296 case 0x02: /* tx-empty */ 297 break; 298 case 0x04: /* rx data available */ 299 break; 300 case 0x06: /* lsr change */ 301 /* we can forget it. the LSR will read from bulk-in */ 302 dev_dbg(&port->dev, "IIR: LSR Change: %02x\n", data[0]); 303 break; 304 } 305 } 306 307 static void f81232_read_int_callback(struct urb *urb) 308 { 309 struct usb_serial_port *port = urb->context; 310 unsigned char *data = urb->transfer_buffer; 311 unsigned int actual_length = urb->actual_length; 312 int status = urb->status; 313 int retval; 314 315 switch (status) { 316 case 0: 317 /* success */ 318 break; 319 case -ECONNRESET: 320 case -ENOENT: 321 case -ESHUTDOWN: 322 /* this urb is terminated, clean up */ 323 dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n", 324 __func__, status); 325 return; 326 default: 327 dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n", 328 __func__, status); 329 goto exit; 330 } 331 332 usb_serial_debug_data(&port->dev, __func__, 333 urb->actual_length, urb->transfer_buffer); 334 335 f81232_update_line_status(port, data, actual_length); 336 337 exit: 338 retval = usb_submit_urb(urb, GFP_ATOMIC); 339 if (retval) 340 dev_err(&urb->dev->dev, 341 "%s - usb_submit_urb failed with result %d\n", 342 __func__, retval); 343 } 344 345 static char f81232_handle_lsr(struct usb_serial_port *port, u8 lsr) 346 { 347 struct f81232_private *priv = usb_get_serial_port_data(port); 348 char tty_flag = TTY_NORMAL; 349 350 if (!(lsr & UART_LSR_BRK_ERROR_BITS)) 351 return tty_flag; 352 353 if (lsr & UART_LSR_BI) { 354 tty_flag = TTY_BREAK; 355 port->icount.brk++; 356 usb_serial_handle_break(port); 357 } else if (lsr & UART_LSR_PE) { 358 tty_flag = TTY_PARITY; 359 port->icount.parity++; 360 } else if (lsr & UART_LSR_FE) { 361 tty_flag = TTY_FRAME; 362 port->icount.frame++; 363 } 364 365 if (lsr & UART_LSR_OE) { 366 port->icount.overrun++; 367 schedule_work(&priv->lsr_work); 368 tty_insert_flip_char(&port->port, 0, TTY_OVERRUN); 369 } 370 371 return tty_flag; 372 } 373 374 static void f81232_process_read_urb(struct urb *urb) 375 { 376 struct usb_serial_port *port = urb->context; 377 unsigned char *data = urb->transfer_buffer; 378 char tty_flag; 379 unsigned int i; 380 u8 lsr; 381 382 /* 383 * When opening the port we get a 1-byte packet with the current LSR, 384 * which we discard. 385 */ 386 if ((urb->actual_length < 2) || (urb->actual_length % 2)) 387 return; 388 389 /* bulk-in data: [LSR(1Byte)+DATA(1Byte)][LSR(1Byte)+DATA(1Byte)]... */ 390 391 for (i = 0; i < urb->actual_length; i += 2) { 392 lsr = data[i]; 393 tty_flag = f81232_handle_lsr(port, lsr); 394 395 if (port->sysrq) { 396 if (usb_serial_handle_sysrq_char(port, data[i + 1])) 397 continue; 398 } 399 400 tty_insert_flip_char(&port->port, data[i + 1], tty_flag); 401 } 402 403 tty_flip_buffer_push(&port->port); 404 } 405 406 static void f81534a_process_read_urb(struct urb *urb) 407 { 408 struct usb_serial_port *port = urb->context; 409 unsigned char *data = urb->transfer_buffer; 410 char tty_flag; 411 unsigned int i; 412 u8 lsr; 413 u8 len; 414 415 if (urb->actual_length < 3) { 416 dev_err(&port->dev, "short message received: %d\n", 417 urb->actual_length); 418 return; 419 } 420 421 len = data[0]; 422 if (len != urb->actual_length) { 423 dev_err(&port->dev, "malformed message received: %d (%d)\n", 424 urb->actual_length, len); 425 return; 426 } 427 428 /* bulk-in data: [LEN][Data.....][LSR] */ 429 lsr = data[len - 1]; 430 tty_flag = f81232_handle_lsr(port, lsr); 431 432 if (port->sysrq) { 433 for (i = 1; i < len - 1; ++i) { 434 if (!usb_serial_handle_sysrq_char(port, data[i])) { 435 tty_insert_flip_char(&port->port, data[i], 436 tty_flag); 437 } 438 } 439 } else { 440 tty_insert_flip_string_fixed_flag(&port->port, &data[1], 441 tty_flag, len - 2); 442 } 443 444 tty_flip_buffer_push(&port->port); 445 } 446 447 static int f81232_break_ctl(struct tty_struct *tty, int break_state) 448 { 449 struct usb_serial_port *port = tty->driver_data; 450 struct f81232_private *priv = usb_get_serial_port_data(port); 451 int status; 452 453 mutex_lock(&priv->lock); 454 455 if (break_state) 456 priv->shadow_lcr |= UART_LCR_SBC; 457 else 458 priv->shadow_lcr &= ~UART_LCR_SBC; 459 460 status = f81232_set_register(port, LINE_CONTROL_REGISTER, 461 priv->shadow_lcr); 462 if (status) 463 dev_err(&port->dev, "set break failed: %d\n", status); 464 465 mutex_unlock(&priv->lock); 466 467 return status; 468 } 469 470 static int f81232_find_clk(speed_t baudrate) 471 { 472 int idx; 473 474 for (idx = 0; idx < ARRAY_SIZE(baudrate_table); ++idx) { 475 if (baudrate <= baudrate_table[idx] && 476 baudrate_table[idx] % baudrate == 0) 477 return idx; 478 } 479 480 return -EINVAL; 481 } 482 483 static void f81232_set_baudrate(struct tty_struct *tty, 484 struct usb_serial_port *port, speed_t baudrate, 485 speed_t old_baudrate) 486 { 487 struct f81232_private *priv = usb_get_serial_port_data(port); 488 u8 lcr; 489 int divisor; 490 int status = 0; 491 int i; 492 int idx; 493 speed_t baud_list[] = { baudrate, old_baudrate, F81232_DEF_BAUDRATE }; 494 495 for (i = 0; i < ARRAY_SIZE(baud_list); ++i) { 496 baudrate = baud_list[i]; 497 if (baudrate == 0) { 498 tty_encode_baud_rate(tty, 0, 0); 499 return; 500 } 501 502 idx = f81232_find_clk(baudrate); 503 if (idx >= 0) { 504 tty_encode_baud_rate(tty, baudrate, baudrate); 505 break; 506 } 507 } 508 509 if (idx < 0) 510 return; 511 512 priv->baud_base = baudrate_table[idx]; 513 divisor = calc_baud_divisor(baudrate, priv->baud_base); 514 515 status = f81232_set_mask_register(port, F81232_CLK_REGISTER, 516 F81232_CLK_MASK, clock_table[idx]); 517 if (status) { 518 dev_err(&port->dev, "%s failed to set CLK_REG: %d\n", 519 __func__, status); 520 return; 521 } 522 523 status = f81232_get_register(port, LINE_CONTROL_REGISTER, 524 &lcr); /* get LCR */ 525 if (status) { 526 dev_err(&port->dev, "%s failed to get LCR: %d\n", 527 __func__, status); 528 return; 529 } 530 531 status = f81232_set_register(port, LINE_CONTROL_REGISTER, 532 lcr | UART_LCR_DLAB); /* Enable DLAB */ 533 if (status) { 534 dev_err(&port->dev, "%s failed to set DLAB: %d\n", 535 __func__, status); 536 return; 537 } 538 539 status = f81232_set_register(port, RECEIVE_BUFFER_REGISTER, 540 divisor & 0x00ff); /* low */ 541 if (status) { 542 dev_err(&port->dev, "%s failed to set baudrate MSB: %d\n", 543 __func__, status); 544 goto reapply_lcr; 545 } 546 547 status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER, 548 (divisor & 0xff00) >> 8); /* high */ 549 if (status) { 550 dev_err(&port->dev, "%s failed to set baudrate LSB: %d\n", 551 __func__, status); 552 } 553 554 reapply_lcr: 555 status = f81232_set_register(port, LINE_CONTROL_REGISTER, 556 lcr & ~UART_LCR_DLAB); 557 if (status) { 558 dev_err(&port->dev, "%s failed to set DLAB: %d\n", 559 __func__, status); 560 } 561 } 562 563 static int f81232_port_enable(struct usb_serial_port *port) 564 { 565 u8 val; 566 int status; 567 568 /* fifo on, trigger8, clear TX/RX*/ 569 val = UART_FCR_TRIGGER_8 | UART_FCR_ENABLE_FIFO | UART_FCR_CLEAR_RCVR | 570 UART_FCR_CLEAR_XMIT; 571 572 status = f81232_set_register(port, FIFO_CONTROL_REGISTER, val); 573 if (status) { 574 dev_err(&port->dev, "%s failed to set FCR: %d\n", 575 __func__, status); 576 return status; 577 } 578 579 /* MSR Interrupt only, LSR will read from Bulk-in odd byte */ 580 status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER, 581 UART_IER_MSI); 582 if (status) { 583 dev_err(&port->dev, "%s failed to set IER: %d\n", 584 __func__, status); 585 return status; 586 } 587 588 return 0; 589 } 590 591 static int f81232_port_disable(struct usb_serial_port *port) 592 { 593 int status; 594 595 status = f81232_set_register(port, INTERRUPT_ENABLE_REGISTER, 0); 596 if (status) { 597 dev_err(&port->dev, "%s failed to set IER: %d\n", 598 __func__, status); 599 return status; 600 } 601 602 return 0; 603 } 604 605 static void f81232_set_termios(struct tty_struct *tty, 606 struct usb_serial_port *port, 607 const struct ktermios *old_termios) 608 { 609 struct f81232_private *priv = usb_get_serial_port_data(port); 610 u8 new_lcr = 0; 611 int status = 0; 612 speed_t baudrate; 613 speed_t old_baud; 614 615 /* Don't change anything if nothing has changed */ 616 if (old_termios && !tty_termios_hw_change(&tty->termios, old_termios)) 617 return; 618 619 if (C_BAUD(tty) == B0) 620 f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS); 621 else if (old_termios && (old_termios->c_cflag & CBAUD) == B0) 622 f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0); 623 624 baudrate = tty_get_baud_rate(tty); 625 if (baudrate > 0) { 626 if (old_termios) 627 old_baud = tty_termios_baud_rate(old_termios); 628 else 629 old_baud = F81232_DEF_BAUDRATE; 630 631 f81232_set_baudrate(tty, port, baudrate, old_baud); 632 } 633 634 if (C_PARENB(tty)) { 635 new_lcr |= UART_LCR_PARITY; 636 637 if (!C_PARODD(tty)) 638 new_lcr |= UART_LCR_EPAR; 639 640 if (C_CMSPAR(tty)) 641 new_lcr |= UART_LCR_SPAR; 642 } 643 644 if (C_CSTOPB(tty)) 645 new_lcr |= UART_LCR_STOP; 646 647 new_lcr |= UART_LCR_WLEN(tty_get_char_size(tty->termios.c_cflag)); 648 649 mutex_lock(&priv->lock); 650 651 new_lcr |= (priv->shadow_lcr & UART_LCR_SBC); 652 status = f81232_set_register(port, LINE_CONTROL_REGISTER, new_lcr); 653 if (status) { 654 dev_err(&port->dev, "%s failed to set LCR: %d\n", 655 __func__, status); 656 } 657 658 priv->shadow_lcr = new_lcr; 659 660 mutex_unlock(&priv->lock); 661 } 662 663 static int f81232_tiocmget(struct tty_struct *tty) 664 { 665 int r; 666 struct usb_serial_port *port = tty->driver_data; 667 struct f81232_private *port_priv = usb_get_serial_port_data(port); 668 u8 mcr, msr; 669 670 /* force get current MSR changed state */ 671 f81232_read_msr(port); 672 673 mutex_lock(&port_priv->lock); 674 mcr = port_priv->modem_control; 675 msr = port_priv->modem_status; 676 mutex_unlock(&port_priv->lock); 677 678 r = (mcr & UART_MCR_DTR ? TIOCM_DTR : 0) | 679 (mcr & UART_MCR_RTS ? TIOCM_RTS : 0) | 680 (msr & UART_MSR_CTS ? TIOCM_CTS : 0) | 681 (msr & UART_MSR_DCD ? TIOCM_CAR : 0) | 682 (msr & UART_MSR_RI ? TIOCM_RI : 0) | 683 (msr & UART_MSR_DSR ? TIOCM_DSR : 0); 684 685 return r; 686 } 687 688 static int f81232_tiocmset(struct tty_struct *tty, 689 unsigned int set, unsigned int clear) 690 { 691 struct usb_serial_port *port = tty->driver_data; 692 693 return f81232_set_mctrl(port, set, clear); 694 } 695 696 static int f81232_open(struct tty_struct *tty, struct usb_serial_port *port) 697 { 698 int result; 699 700 result = f81232_port_enable(port); 701 if (result) 702 return result; 703 704 /* Setup termios */ 705 if (tty) 706 f81232_set_termios(tty, port, NULL); 707 708 result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 709 if (result) { 710 dev_err(&port->dev, "%s - failed submitting interrupt urb," 711 " error %d\n", __func__, result); 712 return result; 713 } 714 715 result = usb_serial_generic_open(tty, port); 716 if (result) { 717 usb_kill_urb(port->interrupt_in_urb); 718 return result; 719 } 720 721 return 0; 722 } 723 724 static int f81534a_open(struct tty_struct *tty, struct usb_serial_port *port) 725 { 726 int status; 727 u8 mask; 728 u8 val; 729 730 val = F81534A_TRIGGER_MULTIPLE_4X | F81534A_FIFO_128BYTE; 731 mask = F81534A_TRIGGER_MASK | F81534A_FIFO_128BYTE; 732 733 status = f81232_set_mask_register(port, F81534A_MODE_REG, mask, val); 734 if (status) { 735 dev_err(&port->dev, "failed to set MODE_REG: %d\n", status); 736 return status; 737 } 738 739 return f81232_open(tty, port); 740 } 741 742 static void f81232_close(struct usb_serial_port *port) 743 { 744 struct f81232_private *port_priv = usb_get_serial_port_data(port); 745 746 f81232_port_disable(port); 747 usb_serial_generic_close(port); 748 usb_kill_urb(port->interrupt_in_urb); 749 flush_work(&port_priv->interrupt_work); 750 flush_work(&port_priv->lsr_work); 751 } 752 753 static void f81232_dtr_rts(struct usb_serial_port *port, int on) 754 { 755 if (on) 756 f81232_set_mctrl(port, TIOCM_DTR | TIOCM_RTS, 0); 757 else 758 f81232_set_mctrl(port, 0, TIOCM_DTR | TIOCM_RTS); 759 } 760 761 static bool f81232_tx_empty(struct usb_serial_port *port) 762 { 763 int status; 764 u8 tmp; 765 766 status = f81232_get_register(port, LINE_STATUS_REGISTER, &tmp); 767 if (!status) { 768 if ((tmp & UART_LSR_TEMT) != UART_LSR_TEMT) 769 return false; 770 } 771 772 return true; 773 } 774 775 static int f81232_carrier_raised(struct usb_serial_port *port) 776 { 777 u8 msr; 778 struct f81232_private *priv = usb_get_serial_port_data(port); 779 780 mutex_lock(&priv->lock); 781 msr = priv->modem_status; 782 mutex_unlock(&priv->lock); 783 784 if (msr & UART_MSR_DCD) 785 return 1; 786 return 0; 787 } 788 789 static void f81232_get_serial(struct tty_struct *tty, struct serial_struct *ss) 790 { 791 struct usb_serial_port *port = tty->driver_data; 792 struct f81232_private *priv = usb_get_serial_port_data(port); 793 794 ss->baud_base = priv->baud_base; 795 } 796 797 static void f81232_interrupt_work(struct work_struct *work) 798 { 799 struct f81232_private *priv = 800 container_of(work, struct f81232_private, interrupt_work); 801 802 f81232_read_msr(priv->port); 803 } 804 805 static void f81232_lsr_worker(struct work_struct *work) 806 { 807 struct f81232_private *priv; 808 struct usb_serial_port *port; 809 int status; 810 u8 tmp; 811 812 priv = container_of(work, struct f81232_private, lsr_work); 813 port = priv->port; 814 815 status = f81232_get_register(port, LINE_STATUS_REGISTER, &tmp); 816 if (status) 817 dev_warn(&port->dev, "read LSR failed: %d\n", status); 818 } 819 820 static int f81534a_ctrl_set_register(struct usb_interface *intf, u16 reg, 821 u16 size, void *val) 822 { 823 return usb_control_msg_send(interface_to_usbdev(intf), 824 0, 825 F81232_REGISTER_REQUEST, 826 F81232_SET_REGISTER, 827 reg, 828 0, 829 val, 830 size, 831 USB_CTRL_SET_TIMEOUT, 832 GFP_KERNEL); 833 } 834 835 static int f81534a_ctrl_get_register(struct usb_interface *intf, u16 reg, 836 u16 size, void *val) 837 { 838 return usb_control_msg_recv(interface_to_usbdev(intf), 839 0, 840 F81232_REGISTER_REQUEST, 841 F81232_GET_REGISTER, 842 reg, 843 0, 844 val, 845 size, 846 USB_CTRL_GET_TIMEOUT, 847 GFP_KERNEL); 848 } 849 850 static int f81534a_ctrl_enable_all_ports(struct usb_interface *intf, bool en) 851 { 852 unsigned char enable[2] = {0}; 853 int status; 854 855 /* 856 * Enable all available serial ports, define as following: 857 * bit 15 : Reset behavior (when HUB got soft reset) 858 * 0: maintain all serial port enabled state. 859 * 1: disable all serial port. 860 * bit 0~11 : Serial port enable bit. 861 */ 862 if (en) { 863 /* 864 * The Fintek F81532A/534A/535/536 family relies on the 865 * F81534A_CTRL_CMD_ENABLE_PORT (116h) register during 866 * initialization to both determine serial port status and 867 * control port creation. 868 * 869 * If the driver experiences fast load/unload cycles, the 870 * device state may becomes unstable, resulting in the 871 * incomplete generation of serial ports. 872 * 873 * Performing a dummy read operation on the register prior 874 * to the initial write command resolves the issue. 875 * 876 * This clears the device's stale internal state. Subsequent 877 * write operations will correctly generate all serial ports. 878 */ 879 status = f81534a_ctrl_get_register(intf, 880 F81534A_CTRL_CMD_ENABLE_PORT, 881 sizeof(enable), 882 enable); 883 if (status) 884 return status; 885 886 enable[0] = 0xff; 887 enable[1] = 0x8f; 888 } 889 890 status = f81534a_ctrl_set_register(intf, F81534A_CTRL_CMD_ENABLE_PORT, 891 sizeof(enable), enable); 892 if (status) 893 dev_err(&intf->dev, "failed to enable ports: %d\n", status); 894 895 return status; 896 } 897 898 static int f81534a_ctrl_probe(struct usb_interface *intf, 899 const struct usb_device_id *id) 900 { 901 return f81534a_ctrl_enable_all_ports(intf, true); 902 } 903 904 static void f81534a_ctrl_disconnect(struct usb_interface *intf) 905 { 906 f81534a_ctrl_enable_all_ports(intf, false); 907 } 908 909 static int f81534a_ctrl_resume(struct usb_interface *intf) 910 { 911 return f81534a_ctrl_enable_all_ports(intf, true); 912 } 913 914 static int f81232_port_probe(struct usb_serial_port *port) 915 { 916 struct f81232_private *priv; 917 918 priv = devm_kzalloc(&port->dev, sizeof(*priv), GFP_KERNEL); 919 if (!priv) 920 return -ENOMEM; 921 922 mutex_init(&priv->lock); 923 INIT_WORK(&priv->interrupt_work, f81232_interrupt_work); 924 INIT_WORK(&priv->lsr_work, f81232_lsr_worker); 925 926 usb_set_serial_port_data(port, priv); 927 928 priv->port = port; 929 930 return 0; 931 } 932 933 static int f81534a_port_probe(struct usb_serial_port *port) 934 { 935 int status; 936 937 /* tri-state with pull-high, default RS232 Mode */ 938 status = f81232_set_register(port, F81534A_GPIO_REG, 939 F81534A_GPIO_MODE2_DIR); 940 if (status) 941 return status; 942 943 return f81232_port_probe(port); 944 } 945 946 static int f81232_suspend(struct usb_serial *serial, pm_message_t message) 947 { 948 struct usb_serial_port *port = serial->port[0]; 949 struct f81232_private *port_priv = usb_get_serial_port_data(port); 950 int i; 951 952 for (i = 0; i < ARRAY_SIZE(port->read_urbs); ++i) 953 usb_kill_urb(port->read_urbs[i]); 954 955 usb_kill_urb(port->interrupt_in_urb); 956 957 if (port_priv) { 958 flush_work(&port_priv->interrupt_work); 959 flush_work(&port_priv->lsr_work); 960 } 961 962 return 0; 963 } 964 965 static int f81232_resume(struct usb_serial *serial) 966 { 967 struct usb_serial_port *port = serial->port[0]; 968 int result; 969 970 if (tty_port_initialized(&port->port)) { 971 result = usb_submit_urb(port->interrupt_in_urb, GFP_NOIO); 972 if (result) { 973 dev_err(&port->dev, "submit interrupt urb failed: %d\n", 974 result); 975 return result; 976 } 977 } 978 979 return usb_serial_generic_resume(serial); 980 } 981 982 static struct usb_serial_driver f81232_device = { 983 .driver = { 984 .name = "f81232", 985 }, 986 .id_table = f81232_id_table, 987 .num_ports = 1, 988 .bulk_in_size = 256, 989 .bulk_out_size = 256, 990 .open = f81232_open, 991 .close = f81232_close, 992 .dtr_rts = f81232_dtr_rts, 993 .carrier_raised = f81232_carrier_raised, 994 .get_serial = f81232_get_serial, 995 .break_ctl = f81232_break_ctl, 996 .set_termios = f81232_set_termios, 997 .tiocmget = f81232_tiocmget, 998 .tiocmset = f81232_tiocmset, 999 .tiocmiwait = usb_serial_generic_tiocmiwait, 1000 .tx_empty = f81232_tx_empty, 1001 .process_read_urb = f81232_process_read_urb, 1002 .read_int_callback = f81232_read_int_callback, 1003 .port_probe = f81232_port_probe, 1004 .suspend = f81232_suspend, 1005 .resume = f81232_resume, 1006 }; 1007 1008 static struct usb_serial_driver f81534a_device = { 1009 .driver = { 1010 .name = "f81534a", 1011 }, 1012 .id_table = f81534a_id_table, 1013 .num_ports = 1, 1014 .open = f81534a_open, 1015 .close = f81232_close, 1016 .dtr_rts = f81232_dtr_rts, 1017 .carrier_raised = f81232_carrier_raised, 1018 .get_serial = f81232_get_serial, 1019 .break_ctl = f81232_break_ctl, 1020 .set_termios = f81232_set_termios, 1021 .tiocmget = f81232_tiocmget, 1022 .tiocmset = f81232_tiocmset, 1023 .tiocmiwait = usb_serial_generic_tiocmiwait, 1024 .tx_empty = f81232_tx_empty, 1025 .process_read_urb = f81534a_process_read_urb, 1026 .read_int_callback = f81232_read_int_callback, 1027 .port_probe = f81534a_port_probe, 1028 .suspend = f81232_suspend, 1029 .resume = f81232_resume, 1030 }; 1031 1032 static struct usb_serial_driver * const serial_drivers[] = { 1033 &f81232_device, 1034 &f81534a_device, 1035 NULL, 1036 }; 1037 1038 static struct usb_driver f81534a_ctrl_driver = { 1039 .name = "f81534a_ctrl", 1040 .id_table = f81534a_ctrl_id_table, 1041 .probe = f81534a_ctrl_probe, 1042 .disconnect = f81534a_ctrl_disconnect, 1043 .resume = f81534a_ctrl_resume, 1044 }; 1045 1046 static int __init f81232_init(void) 1047 { 1048 int status; 1049 1050 status = usb_register_driver(&f81534a_ctrl_driver, THIS_MODULE, 1051 KBUILD_MODNAME); 1052 if (status) 1053 return status; 1054 1055 status = usb_serial_register_drivers(serial_drivers, KBUILD_MODNAME, 1056 combined_id_table); 1057 if (status) { 1058 usb_deregister(&f81534a_ctrl_driver); 1059 return status; 1060 } 1061 1062 return 0; 1063 } 1064 1065 static void __exit f81232_exit(void) 1066 { 1067 usb_serial_deregister_drivers(serial_drivers); 1068 usb_deregister(&f81534a_ctrl_driver); 1069 } 1070 1071 module_init(f81232_init); 1072 module_exit(f81232_exit); 1073 1074 MODULE_DESCRIPTION("Fintek F81232/532A/534A/535/536 USB to serial driver"); 1075 MODULE_AUTHOR("Greg Kroah-Hartman <gregkh@linuxfoundation.org>"); 1076 MODULE_AUTHOR("Peter Hong <peter_hong@fintek.com.tw>"); 1077 MODULE_LICENSE("GPL v2"); 1078