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