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