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