1 // SPDX-License-Identifier: GPL-2.0+ 2 /* 3 * USB Keyspan PDA / Xircom / Entrega Converter driver 4 * 5 * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com> 6 * Copyright (C) 1999, 2000 Brian Warner <warner@lothar.com> 7 * Copyright (C) 2000 Al Borchers <borchers@steinerpoint.com> 8 * Copyright (C) 2020 Johan Hovold <johan@kernel.org> 9 * 10 * See Documentation/usb/usb-serial.rst for more information on using this 11 * driver 12 */ 13 14 #include <linux/kernel.h> 15 #include <linux/errno.h> 16 #include <linux/slab.h> 17 #include <linux/tty.h> 18 #include <linux/tty_driver.h> 19 #include <linux/tty_flip.h> 20 #include <linux/module.h> 21 #include <linux/spinlock.h> 22 #include <linux/workqueue.h> 23 #include <linux/uaccess.h> 24 #include <linux/usb.h> 25 #include <linux/usb/serial.h> 26 #include <linux/usb/ezusb.h> 27 28 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>, Johan Hovold <johan@kernel.org>" 29 #define DRIVER_DESC "USB Keyspan PDA Converter driver" 30 31 #define KEYSPAN_TX_THRESHOLD 128 32 33 struct keyspan_pda_private { 34 int tx_room; 35 struct work_struct unthrottle_work; 36 struct usb_serial *serial; 37 struct usb_serial_port *port; 38 }; 39 40 static int keyspan_pda_write_start(struct usb_serial_port *port); 41 42 #define KEYSPAN_VENDOR_ID 0x06cd 43 #define KEYSPAN_PDA_FAKE_ID 0x0103 44 #define KEYSPAN_PDA_ID 0x0104 /* no clue */ 45 46 /* For Xircom PGSDB9 and older Entrega version of the same device */ 47 #define XIRCOM_VENDOR_ID 0x085a 48 #define XIRCOM_FAKE_ID 0x8027 49 #define XIRCOM_FAKE_ID_2 0x8025 /* "PGMFHUB" serial */ 50 #define ENTREGA_VENDOR_ID 0x1645 51 #define ENTREGA_FAKE_ID 0x8093 52 53 static const struct usb_device_id id_table_combined[] = { 54 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) }, 55 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) }, 56 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) }, 57 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) }, 58 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) }, 59 { } /* Terminating entry */ 60 }; 61 MODULE_DEVICE_TABLE(usb, id_table_combined); 62 63 static const struct usb_device_id id_table_std[] = { 64 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) }, 65 { } /* Terminating entry */ 66 }; 67 68 static const struct usb_device_id id_table_fake[] = { 69 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) }, 70 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) }, 71 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) }, 72 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) }, 73 { } /* Terminating entry */ 74 }; 75 76 static int keyspan_pda_get_write_room(struct keyspan_pda_private *priv) 77 { 78 struct usb_serial_port *port = priv->port; 79 struct usb_serial *serial = port->serial; 80 u8 *room; 81 int rc; 82 83 room = kmalloc(1, GFP_KERNEL); 84 if (!room) 85 return -ENOMEM; 86 87 rc = usb_control_msg(serial->dev, 88 usb_rcvctrlpipe(serial->dev, 0), 89 6, /* write_room */ 90 USB_TYPE_VENDOR | USB_RECIP_INTERFACE 91 | USB_DIR_IN, 92 0, /* value: 0 means "remaining room" */ 93 0, /* index */ 94 room, 95 1, 96 2000); 97 if (rc != 1) { 98 if (rc >= 0) 99 rc = -EIO; 100 dev_dbg(&port->dev, "roomquery failed: %d\n", rc); 101 goto out_free; 102 } 103 104 dev_dbg(&port->dev, "roomquery says %d\n", *room); 105 rc = *room; 106 out_free: 107 kfree(room); 108 109 return rc; 110 } 111 112 static void keyspan_pda_request_unthrottle(struct work_struct *work) 113 { 114 struct keyspan_pda_private *priv = 115 container_of(work, struct keyspan_pda_private, unthrottle_work); 116 struct usb_serial_port *port = priv->port; 117 struct usb_serial *serial = port->serial; 118 unsigned long flags; 119 int result; 120 121 dev_dbg(&port->dev, "%s\n", __func__); 122 123 /* 124 * Ask the device to tell us when the tx buffer becomes 125 * sufficiently empty. 126 */ 127 result = usb_control_msg(serial->dev, 128 usb_sndctrlpipe(serial->dev, 0), 129 7, /* request_unthrottle */ 130 USB_TYPE_VENDOR | USB_RECIP_INTERFACE 131 | USB_DIR_OUT, 132 KEYSPAN_TX_THRESHOLD, 133 0, /* index */ 134 NULL, 135 0, 136 2000); 137 if (result < 0) 138 dev_dbg(&serial->dev->dev, "%s - error %d from usb_control_msg\n", 139 __func__, result); 140 /* 141 * Need to check available space after requesting notification in case 142 * buffer is already empty so that no notification is sent. 143 */ 144 result = keyspan_pda_get_write_room(priv); 145 if (result > KEYSPAN_TX_THRESHOLD) { 146 spin_lock_irqsave(&port->lock, flags); 147 priv->tx_room = max(priv->tx_room, result); 148 spin_unlock_irqrestore(&port->lock, flags); 149 150 usb_serial_port_softint(port); 151 } 152 } 153 154 static void keyspan_pda_rx_interrupt(struct urb *urb) 155 { 156 struct usb_serial_port *port = urb->context; 157 unsigned char *data = urb->transfer_buffer; 158 unsigned int len = urb->actual_length; 159 int retval; 160 int status = urb->status; 161 struct keyspan_pda_private *priv; 162 unsigned long flags; 163 164 priv = usb_get_serial_port_data(port); 165 166 switch (status) { 167 case 0: 168 /* success */ 169 break; 170 case -ECONNRESET: 171 case -ENOENT: 172 case -ESHUTDOWN: 173 /* this urb is terminated, clean up */ 174 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status); 175 return; 176 default: 177 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status); 178 goto exit; 179 } 180 181 if (len < 1) { 182 dev_warn(&port->dev, "short message received\n"); 183 goto exit; 184 } 185 186 /* see if the message is data or a status interrupt */ 187 switch (data[0]) { 188 case 0: 189 /* rest of message is rx data */ 190 if (len < 2) 191 break; 192 tty_insert_flip_string(&port->port, data + 1, len - 1); 193 tty_flip_buffer_push(&port->port); 194 break; 195 case 1: 196 /* status interrupt */ 197 if (len < 2) { 198 dev_warn(&port->dev, "short interrupt message received\n"); 199 break; 200 } 201 dev_dbg(&port->dev, "rx int, d1=%d\n", data[1]); 202 switch (data[1]) { 203 case 1: /* modemline change */ 204 break; 205 case 2: /* tx unthrottle interrupt */ 206 spin_lock_irqsave(&port->lock, flags); 207 priv->tx_room = max(priv->tx_room, KEYSPAN_TX_THRESHOLD); 208 spin_unlock_irqrestore(&port->lock, flags); 209 210 keyspan_pda_write_start(port); 211 212 usb_serial_port_softint(port); 213 break; 214 default: 215 break; 216 } 217 break; 218 default: 219 break; 220 } 221 222 exit: 223 retval = usb_submit_urb(urb, GFP_ATOMIC); 224 if (retval) 225 dev_err(&port->dev, 226 "%s - usb_submit_urb failed with result %d\n", 227 __func__, retval); 228 } 229 230 static void keyspan_pda_rx_throttle(struct tty_struct *tty) 231 { 232 struct usb_serial_port *port = tty->driver_data; 233 234 /* 235 * Stop receiving characters. We just turn off the URB request, and 236 * let chars pile up in the device. If we're doing hardware 237 * flowcontrol, the device will signal the other end when its buffer 238 * fills up. If we're doing XON/XOFF, this would be a good time to 239 * send an XOFF, although it might make sense to foist that off upon 240 * the device too. 241 */ 242 usb_kill_urb(port->interrupt_in_urb); 243 } 244 245 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty) 246 { 247 struct usb_serial_port *port = tty->driver_data; 248 249 /* just restart the receive interrupt URB */ 250 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL)) 251 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n"); 252 } 253 254 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud) 255 { 256 int rc; 257 int bindex; 258 259 switch (baud) { 260 case 110: 261 bindex = 0; 262 break; 263 case 300: 264 bindex = 1; 265 break; 266 case 1200: 267 bindex = 2; 268 break; 269 case 2400: 270 bindex = 3; 271 break; 272 case 4800: 273 bindex = 4; 274 break; 275 case 9600: 276 bindex = 5; 277 break; 278 case 19200: 279 bindex = 6; 280 break; 281 case 38400: 282 bindex = 7; 283 break; 284 case 57600: 285 bindex = 8; 286 break; 287 case 115200: 288 bindex = 9; 289 break; 290 default: 291 bindex = 5; /* Default to 9600 */ 292 baud = 9600; 293 } 294 295 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 296 0, /* set baud */ 297 USB_TYPE_VENDOR 298 | USB_RECIP_INTERFACE 299 | USB_DIR_OUT, /* type */ 300 bindex, /* value */ 301 0, /* index */ 302 NULL, /* &data */ 303 0, /* size */ 304 2000); /* timeout */ 305 if (rc < 0) 306 return 0; 307 308 return baud; 309 } 310 311 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state) 312 { 313 struct usb_serial_port *port = tty->driver_data; 314 struct usb_serial *serial = port->serial; 315 int value; 316 int result; 317 318 if (break_state == -1) 319 value = 1; /* start break */ 320 else 321 value = 0; /* clear break */ 322 323 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 324 4, /* set break */ 325 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT, 326 value, 0, NULL, 0, 2000); 327 if (result < 0) 328 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n", 329 __func__, result); 330 } 331 332 static void keyspan_pda_set_termios(struct tty_struct *tty, 333 struct usb_serial_port *port, struct ktermios *old_termios) 334 { 335 struct usb_serial *serial = port->serial; 336 speed_t speed; 337 338 /* 339 * cflag specifies lots of stuff: number of stop bits, parity, number 340 * of data bits, baud. What can the device actually handle?: 341 * CSTOPB (1 stop bit or 2) 342 * PARENB (parity) 343 * CSIZE (5bit .. 8bit) 344 * There is minimal hw support for parity (a PSW bit seems to hold the 345 * parity of whatever is in the accumulator). The UART either deals 346 * with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data, 347 * 1 special, stop). So, with firmware changes, we could do: 348 * 8N1: 10 bit 349 * 8N2: 11 bit, extra bit always (mark?) 350 * 8[EOMS]1: 11 bit, extra bit is parity 351 * 7[EOMS]1: 10 bit, b0/b7 is parity 352 * 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?) 353 * 354 * HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS 355 * bit. 356 * 357 * For now, just do baud. 358 */ 359 speed = tty_get_baud_rate(tty); 360 speed = keyspan_pda_setbaud(serial, speed); 361 362 if (speed == 0) { 363 dev_dbg(&port->dev, "can't handle requested baud rate\n"); 364 /* It hasn't changed so.. */ 365 speed = tty_termios_baud_rate(old_termios); 366 } 367 /* 368 * Only speed can change so copy the old h/w parameters then encode 369 * the new speed. 370 */ 371 tty_termios_copy_hw(&tty->termios, old_termios); 372 tty_encode_baud_rate(tty, speed, speed); 373 } 374 375 /* 376 * Modem control pins: DTR and RTS are outputs and can be controlled. 377 * DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be 378 * read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused. 379 */ 380 static int keyspan_pda_get_modem_info(struct usb_serial *serial, 381 unsigned char *value) 382 { 383 int rc; 384 u8 *data; 385 386 data = kmalloc(1, GFP_KERNEL); 387 if (!data) 388 return -ENOMEM; 389 390 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 391 3, /* get pins */ 392 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN, 393 0, 0, data, 1, 2000); 394 if (rc == 1) 395 *value = *data; 396 else if (rc >= 0) 397 rc = -EIO; 398 399 kfree(data); 400 return rc; 401 } 402 403 static int keyspan_pda_set_modem_info(struct usb_serial *serial, 404 unsigned char value) 405 { 406 int rc; 407 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 408 3, /* set pins */ 409 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT, 410 value, 0, NULL, 0, 2000); 411 return rc; 412 } 413 414 static int keyspan_pda_tiocmget(struct tty_struct *tty) 415 { 416 struct usb_serial_port *port = tty->driver_data; 417 struct usb_serial *serial = port->serial; 418 int rc; 419 unsigned char status; 420 int value; 421 422 rc = keyspan_pda_get_modem_info(serial, &status); 423 if (rc < 0) 424 return rc; 425 426 value = ((status & BIT(7)) ? TIOCM_DTR : 0) | 427 ((status & BIT(6)) ? TIOCM_CAR : 0) | 428 ((status & BIT(5)) ? TIOCM_RNG : 0) | 429 ((status & BIT(4)) ? TIOCM_DSR : 0) | 430 ((status & BIT(3)) ? TIOCM_CTS : 0) | 431 ((status & BIT(2)) ? TIOCM_RTS : 0); 432 433 return value; 434 } 435 436 static int keyspan_pda_tiocmset(struct tty_struct *tty, 437 unsigned int set, unsigned int clear) 438 { 439 struct usb_serial_port *port = tty->driver_data; 440 struct usb_serial *serial = port->serial; 441 int rc; 442 unsigned char status; 443 444 rc = keyspan_pda_get_modem_info(serial, &status); 445 if (rc < 0) 446 return rc; 447 448 if (set & TIOCM_RTS) 449 status |= BIT(2); 450 if (set & TIOCM_DTR) 451 status |= BIT(7); 452 453 if (clear & TIOCM_RTS) 454 status &= ~BIT(2); 455 if (clear & TIOCM_DTR) 456 status &= ~BIT(7); 457 rc = keyspan_pda_set_modem_info(serial, status); 458 return rc; 459 } 460 461 static int keyspan_pda_write_start(struct usb_serial_port *port) 462 { 463 struct keyspan_pda_private *priv = usb_get_serial_port_data(port); 464 unsigned long flags; 465 struct urb *urb; 466 int count; 467 int room; 468 int rc; 469 470 /* 471 * Guess how much room is left in the device's ring buffer. If our 472 * write will result in no room left, ask the device to give us an 473 * interrupt when the room available rises above a threshold but also 474 * query how much room is currently available (in case our guess was 475 * too conservative and the buffer is already empty when the 476 * unthrottle work is scheduled). 477 */ 478 479 /* 480 * We might block because of: 481 * the TX urb is in-flight (wait until it completes) 482 * the device is full (wait until it says there is room) 483 */ 484 spin_lock_irqsave(&port->lock, flags); 485 486 room = priv->tx_room; 487 count = kfifo_len(&port->write_fifo); 488 489 if (!test_bit(0, &port->write_urbs_free) || count == 0 || room == 0) { 490 spin_unlock_irqrestore(&port->lock, flags); 491 return 0; 492 } 493 __clear_bit(0, &port->write_urbs_free); 494 495 if (count > room) 496 count = room; 497 if (count > port->bulk_out_size) 498 count = port->bulk_out_size; 499 500 urb = port->write_urb; 501 count = kfifo_out(&port->write_fifo, urb->transfer_buffer, count); 502 urb->transfer_buffer_length = count; 503 504 port->tx_bytes += count; 505 priv->tx_room -= count; 506 507 spin_unlock_irqrestore(&port->lock, flags); 508 509 dev_dbg(&port->dev, "%s - count = %d, txroom = %d\n", __func__, count, room); 510 511 rc = usb_submit_urb(urb, GFP_ATOMIC); 512 if (rc) { 513 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n"); 514 515 spin_lock_irqsave(&port->lock, flags); 516 port->tx_bytes -= count; 517 priv->tx_room = max(priv->tx_room, room + count); 518 __set_bit(0, &port->write_urbs_free); 519 spin_unlock_irqrestore(&port->lock, flags); 520 521 return rc; 522 } 523 524 if (count == room) 525 schedule_work(&priv->unthrottle_work); 526 527 return count; 528 } 529 530 static void keyspan_pda_write_bulk_callback(struct urb *urb) 531 { 532 struct usb_serial_port *port = urb->context; 533 unsigned long flags; 534 535 spin_lock_irqsave(&port->lock, flags); 536 port->tx_bytes -= urb->transfer_buffer_length; 537 __set_bit(0, &port->write_urbs_free); 538 spin_unlock_irqrestore(&port->lock, flags); 539 540 keyspan_pda_write_start(port); 541 542 usb_serial_port_softint(port); 543 } 544 545 static int keyspan_pda_write(struct tty_struct *tty, struct usb_serial_port *port, 546 const unsigned char *buf, int count) 547 { 548 int rc; 549 550 dev_dbg(&port->dev, "%s - count = %d\n", __func__, count); 551 552 if (!count) 553 return 0; 554 555 count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock); 556 557 rc = keyspan_pda_write_start(port); 558 if (rc) 559 return rc; 560 561 return count; 562 } 563 564 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on) 565 { 566 struct usb_serial *serial = port->serial; 567 568 if (on) 569 keyspan_pda_set_modem_info(serial, BIT(7) | BIT(2)); 570 else 571 keyspan_pda_set_modem_info(serial, 0); 572 } 573 574 575 static int keyspan_pda_open(struct tty_struct *tty, 576 struct usb_serial_port *port) 577 { 578 struct keyspan_pda_private *priv = usb_get_serial_port_data(port); 579 int rc; 580 581 /* find out how much room is in the Tx ring */ 582 rc = keyspan_pda_get_write_room(priv); 583 if (rc < 0) 584 return rc; 585 586 spin_lock_irq(&port->lock); 587 priv->tx_room = rc; 588 spin_unlock_irq(&port->lock); 589 590 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 591 if (rc) { 592 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__); 593 return rc; 594 } 595 596 return 0; 597 } 598 599 static void keyspan_pda_close(struct usb_serial_port *port) 600 { 601 struct keyspan_pda_private *priv = usb_get_serial_port_data(port); 602 603 /* 604 * Stop the interrupt URB first as its completion handler may submit 605 * the write URB. 606 */ 607 usb_kill_urb(port->interrupt_in_urb); 608 usb_kill_urb(port->write_urb); 609 610 cancel_work_sync(&priv->unthrottle_work); 611 612 spin_lock_irq(&port->lock); 613 kfifo_reset(&port->write_fifo); 614 spin_unlock_irq(&port->lock); 615 } 616 617 /* download the firmware to a "fake" device (pre-renumeration) */ 618 static int keyspan_pda_fake_startup(struct usb_serial *serial) 619 { 620 unsigned int vid = le16_to_cpu(serial->dev->descriptor.idVendor); 621 const char *fw_name; 622 623 /* download the firmware here ... */ 624 ezusb_fx1_set_reset(serial->dev, 1); 625 626 switch (vid) { 627 case KEYSPAN_VENDOR_ID: 628 fw_name = "keyspan_pda/keyspan_pda.fw"; 629 break; 630 case XIRCOM_VENDOR_ID: 631 case ENTREGA_VENDOR_ID: 632 fw_name = "keyspan_pda/xircom_pgs.fw"; 633 break; 634 default: 635 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n", 636 __func__); 637 return -ENODEV; 638 } 639 640 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) { 641 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n", 642 fw_name); 643 return -ENOENT; 644 } 645 646 /* 647 * After downloading firmware renumeration will occur in a moment and 648 * the new device will bind to the real driver. 649 */ 650 651 /* We want this device to fail to have a driver assigned to it. */ 652 return 1; 653 } 654 655 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw"); 656 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw"); 657 658 static int keyspan_pda_port_probe(struct usb_serial_port *port) 659 { 660 661 struct keyspan_pda_private *priv; 662 663 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL); 664 if (!priv) 665 return -ENOMEM; 666 667 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle); 668 priv->port = port; 669 670 usb_set_serial_port_data(port, priv); 671 672 return 0; 673 } 674 675 static void keyspan_pda_port_remove(struct usb_serial_port *port) 676 { 677 struct keyspan_pda_private *priv; 678 679 priv = usb_get_serial_port_data(port); 680 kfree(priv); 681 } 682 683 static struct usb_serial_driver keyspan_pda_fake_device = { 684 .driver = { 685 .owner = THIS_MODULE, 686 .name = "keyspan_pda_pre", 687 }, 688 .description = "Keyspan PDA - (prerenumeration)", 689 .id_table = id_table_fake, 690 .num_ports = 1, 691 .attach = keyspan_pda_fake_startup, 692 }; 693 694 static struct usb_serial_driver keyspan_pda_device = { 695 .driver = { 696 .owner = THIS_MODULE, 697 .name = "keyspan_pda", 698 }, 699 .description = "Keyspan PDA", 700 .id_table = id_table_std, 701 .num_ports = 1, 702 .num_bulk_out = 1, 703 .num_interrupt_in = 1, 704 .dtr_rts = keyspan_pda_dtr_rts, 705 .open = keyspan_pda_open, 706 .close = keyspan_pda_close, 707 .write = keyspan_pda_write, 708 .write_bulk_callback = keyspan_pda_write_bulk_callback, 709 .read_int_callback = keyspan_pda_rx_interrupt, 710 .throttle = keyspan_pda_rx_throttle, 711 .unthrottle = keyspan_pda_rx_unthrottle, 712 .set_termios = keyspan_pda_set_termios, 713 .break_ctl = keyspan_pda_break_ctl, 714 .tiocmget = keyspan_pda_tiocmget, 715 .tiocmset = keyspan_pda_tiocmset, 716 .port_probe = keyspan_pda_port_probe, 717 .port_remove = keyspan_pda_port_remove, 718 }; 719 720 static struct usb_serial_driver * const serial_drivers[] = { 721 &keyspan_pda_device, 722 &keyspan_pda_fake_device, 723 NULL 724 }; 725 726 module_usb_serial_driver(serial_drivers, id_table_combined); 727 728 MODULE_AUTHOR(DRIVER_AUTHOR); 729 MODULE_DESCRIPTION(DRIVER_DESC); 730 MODULE_LICENSE("GPL"); 731