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