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 * 9 * See Documentation/usb/usb-serial.txt for more information on using this 10 * driver 11 */ 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 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */ 29 #if IS_ENABLED(CONFIG_USB_SERIAL_KEYSPAN_PDA) 30 #define KEYSPAN 31 #else 32 #undef KEYSPAN 33 #endif 34 #if IS_ENABLED(CONFIG_USB_SERIAL_XIRCOM) 35 #define XIRCOM 36 #else 37 #undef XIRCOM 38 #endif 39 40 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>" 41 #define DRIVER_DESC "USB Keyspan PDA Converter driver" 42 43 struct keyspan_pda_private { 44 int tx_room; 45 int tx_throttled; 46 struct work_struct wakeup_work; 47 struct work_struct unthrottle_work; 48 struct usb_serial *serial; 49 struct usb_serial_port *port; 50 }; 51 52 53 #define KEYSPAN_VENDOR_ID 0x06cd 54 #define KEYSPAN_PDA_FAKE_ID 0x0103 55 #define KEYSPAN_PDA_ID 0x0104 /* no clue */ 56 57 /* For Xircom PGSDB9 and older Entrega version of the same device */ 58 #define XIRCOM_VENDOR_ID 0x085a 59 #define XIRCOM_FAKE_ID 0x8027 60 #define XIRCOM_FAKE_ID_2 0x8025 /* "PGMFHUB" serial */ 61 #define ENTREGA_VENDOR_ID 0x1645 62 #define ENTREGA_FAKE_ID 0x8093 63 64 static const struct usb_device_id id_table_combined[] = { 65 #ifdef KEYSPAN 66 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) }, 67 #endif 68 #ifdef XIRCOM 69 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) }, 70 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) }, 71 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) }, 72 #endif 73 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) }, 74 { } /* Terminating entry */ 75 }; 76 77 MODULE_DEVICE_TABLE(usb, id_table_combined); 78 79 static const struct usb_device_id id_table_std[] = { 80 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) }, 81 { } /* Terminating entry */ 82 }; 83 84 #ifdef KEYSPAN 85 static const struct usb_device_id id_table_fake[] = { 86 { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) }, 87 { } /* Terminating entry */ 88 }; 89 #endif 90 91 #ifdef XIRCOM 92 static const struct usb_device_id id_table_fake_xircom[] = { 93 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) }, 94 { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) }, 95 { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) }, 96 { } 97 }; 98 #endif 99 100 static void keyspan_pda_wakeup_write(struct work_struct *work) 101 { 102 struct keyspan_pda_private *priv = 103 container_of(work, struct keyspan_pda_private, wakeup_work); 104 struct usb_serial_port *port = priv->port; 105 106 tty_port_tty_wakeup(&port->port); 107 } 108 109 static void keyspan_pda_request_unthrottle(struct work_struct *work) 110 { 111 struct keyspan_pda_private *priv = 112 container_of(work, struct keyspan_pda_private, unthrottle_work); 113 struct usb_serial *serial = priv->serial; 114 int result; 115 116 /* ask the device to tell us when the tx buffer becomes 117 sufficiently empty */ 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 16, /* value: 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 133 134 static void keyspan_pda_rx_interrupt(struct urb *urb) 135 { 136 struct usb_serial_port *port = urb->context; 137 unsigned char *data = urb->transfer_buffer; 138 unsigned int len = urb->actual_length; 139 int retval; 140 int status = urb->status; 141 struct keyspan_pda_private *priv; 142 priv = usb_get_serial_port_data(port); 143 144 switch (status) { 145 case 0: 146 /* success */ 147 break; 148 case -ECONNRESET: 149 case -ENOENT: 150 case -ESHUTDOWN: 151 /* this urb is terminated, clean up */ 152 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status); 153 return; 154 default: 155 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status); 156 goto exit; 157 } 158 159 if (len < 1) { 160 dev_warn(&port->dev, "short message received\n"); 161 goto exit; 162 } 163 164 /* see if the message is data or a status interrupt */ 165 switch (data[0]) { 166 case 0: 167 /* rest of message is rx data */ 168 if (len < 2) 169 break; 170 tty_insert_flip_string(&port->port, data + 1, len - 1); 171 tty_flip_buffer_push(&port->port); 172 break; 173 case 1: 174 /* status interrupt */ 175 if (len < 3) { 176 dev_warn(&port->dev, "short interrupt message received\n"); 177 break; 178 } 179 dev_dbg(&port->dev, "rx int, d1=%d, d2=%d\n", data[1], data[2]); 180 switch (data[1]) { 181 case 1: /* modemline change */ 182 break; 183 case 2: /* tx unthrottle interrupt */ 184 priv->tx_throttled = 0; 185 /* queue up a wakeup at scheduler time */ 186 schedule_work(&priv->wakeup_work); 187 break; 188 default: 189 break; 190 } 191 break; 192 default: 193 break; 194 } 195 196 exit: 197 retval = usb_submit_urb(urb, GFP_ATOMIC); 198 if (retval) 199 dev_err(&port->dev, 200 "%s - usb_submit_urb failed with result %d\n", 201 __func__, retval); 202 } 203 204 205 static void keyspan_pda_rx_throttle(struct tty_struct *tty) 206 { 207 /* stop receiving characters. We just turn off the URB request, and 208 let chars pile up in the device. If we're doing hardware 209 flowcontrol, the device will signal the other end when its buffer 210 fills up. If we're doing XON/XOFF, this would be a good time to 211 send an XOFF, although it might make sense to foist that off 212 upon the device too. */ 213 struct usb_serial_port *port = tty->driver_data; 214 215 usb_kill_urb(port->interrupt_in_urb); 216 } 217 218 219 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty) 220 { 221 struct usb_serial_port *port = tty->driver_data; 222 /* just restart the receive interrupt URB */ 223 224 if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL)) 225 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n"); 226 } 227 228 229 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud) 230 { 231 int rc; 232 int bindex; 233 234 switch (baud) { 235 case 110: 236 bindex = 0; 237 break; 238 case 300: 239 bindex = 1; 240 break; 241 case 1200: 242 bindex = 2; 243 break; 244 case 2400: 245 bindex = 3; 246 break; 247 case 4800: 248 bindex = 4; 249 break; 250 case 9600: 251 bindex = 5; 252 break; 253 case 19200: 254 bindex = 6; 255 break; 256 case 38400: 257 bindex = 7; 258 break; 259 case 57600: 260 bindex = 8; 261 break; 262 case 115200: 263 bindex = 9; 264 break; 265 default: 266 bindex = 5; /* Default to 9600 */ 267 baud = 9600; 268 } 269 270 /* rather than figure out how to sleep while waiting for this 271 to complete, I just use the "legacy" API. */ 272 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 273 0, /* set baud */ 274 USB_TYPE_VENDOR 275 | USB_RECIP_INTERFACE 276 | USB_DIR_OUT, /* type */ 277 bindex, /* value */ 278 0, /* index */ 279 NULL, /* &data */ 280 0, /* size */ 281 2000); /* timeout */ 282 if (rc < 0) 283 return 0; 284 return baud; 285 } 286 287 288 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state) 289 { 290 struct usb_serial_port *port = tty->driver_data; 291 struct usb_serial *serial = port->serial; 292 int value; 293 int result; 294 295 if (break_state == -1) 296 value = 1; /* start break */ 297 else 298 value = 0; /* clear break */ 299 result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 300 4, /* set break */ 301 USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT, 302 value, 0, NULL, 0, 2000); 303 if (result < 0) 304 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n", 305 __func__, result); 306 /* there is something funky about this.. the TCSBRK that 'cu' performs 307 ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4 308 seconds apart, but it feels like the break sent isn't as long as it 309 is on /dev/ttyS0 */ 310 } 311 312 313 static void keyspan_pda_set_termios(struct tty_struct *tty, 314 struct usb_serial_port *port, struct ktermios *old_termios) 315 { 316 struct usb_serial *serial = port->serial; 317 speed_t speed; 318 319 /* cflag specifies lots of stuff: number of stop bits, parity, number 320 of data bits, baud. What can the device actually handle?: 321 CSTOPB (1 stop bit or 2) 322 PARENB (parity) 323 CSIZE (5bit .. 8bit) 324 There is minimal hw support for parity (a PSW bit seems to hold the 325 parity of whatever is in the accumulator). The UART either deals 326 with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data, 327 1 special, stop). So, with firmware changes, we could do: 328 8N1: 10 bit 329 8N2: 11 bit, extra bit always (mark?) 330 8[EOMS]1: 11 bit, extra bit is parity 331 7[EOMS]1: 10 bit, b0/b7 is parity 332 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?) 333 334 HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS 335 bit. 336 337 For now, just do baud. */ 338 339 speed = tty_get_baud_rate(tty); 340 speed = keyspan_pda_setbaud(serial, speed); 341 342 if (speed == 0) { 343 dev_dbg(&port->dev, "can't handle requested baud rate\n"); 344 /* It hasn't changed so.. */ 345 speed = tty_termios_baud_rate(old_termios); 346 } 347 /* Only speed can change so copy the old h/w parameters 348 then encode the new speed */ 349 tty_termios_copy_hw(&tty->termios, old_termios); 350 tty_encode_baud_rate(tty, speed, speed); 351 } 352 353 354 /* modem control pins: DTR and RTS are outputs and can be controlled. 355 DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be 356 read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */ 357 358 static int keyspan_pda_get_modem_info(struct usb_serial *serial, 359 unsigned char *value) 360 { 361 int rc; 362 u8 *data; 363 364 data = kmalloc(1, GFP_KERNEL); 365 if (!data) 366 return -ENOMEM; 367 368 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 369 3, /* get pins */ 370 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN, 371 0, 0, data, 1, 2000); 372 if (rc >= 0) 373 *value = *data; 374 375 kfree(data); 376 return rc; 377 } 378 379 380 static int keyspan_pda_set_modem_info(struct usb_serial *serial, 381 unsigned char value) 382 { 383 int rc; 384 rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), 385 3, /* set pins */ 386 USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT, 387 value, 0, NULL, 0, 2000); 388 return rc; 389 } 390 391 static int keyspan_pda_tiocmget(struct tty_struct *tty) 392 { 393 struct usb_serial_port *port = tty->driver_data; 394 struct usb_serial *serial = port->serial; 395 int rc; 396 unsigned char status; 397 int value; 398 399 rc = keyspan_pda_get_modem_info(serial, &status); 400 if (rc < 0) 401 return rc; 402 value = 403 ((status & (1<<7)) ? TIOCM_DTR : 0) | 404 ((status & (1<<6)) ? TIOCM_CAR : 0) | 405 ((status & (1<<5)) ? TIOCM_RNG : 0) | 406 ((status & (1<<4)) ? TIOCM_DSR : 0) | 407 ((status & (1<<3)) ? TIOCM_CTS : 0) | 408 ((status & (1<<2)) ? TIOCM_RTS : 0); 409 return value; 410 } 411 412 static int keyspan_pda_tiocmset(struct tty_struct *tty, 413 unsigned int set, unsigned int clear) 414 { 415 struct usb_serial_port *port = tty->driver_data; 416 struct usb_serial *serial = port->serial; 417 int rc; 418 unsigned char status; 419 420 rc = keyspan_pda_get_modem_info(serial, &status); 421 if (rc < 0) 422 return rc; 423 424 if (set & TIOCM_RTS) 425 status |= (1<<2); 426 if (set & TIOCM_DTR) 427 status |= (1<<7); 428 429 if (clear & TIOCM_RTS) 430 status &= ~(1<<2); 431 if (clear & TIOCM_DTR) 432 status &= ~(1<<7); 433 rc = keyspan_pda_set_modem_info(serial, status); 434 return rc; 435 } 436 437 static int keyspan_pda_write(struct tty_struct *tty, 438 struct usb_serial_port *port, const unsigned char *buf, int count) 439 { 440 struct usb_serial *serial = port->serial; 441 int request_unthrottle = 0; 442 int rc = 0; 443 struct keyspan_pda_private *priv; 444 445 priv = usb_get_serial_port_data(port); 446 /* guess how much room is left in the device's ring buffer, and if we 447 want to send more than that, check first, updating our notion of 448 what is left. If our write will result in no room left, ask the 449 device to give us an interrupt when the room available rises above 450 a threshold, and hold off all writers (eventually, those using 451 select() or poll() too) until we receive that unthrottle interrupt. 452 Block if we can't write anything at all, otherwise write as much as 453 we can. */ 454 if (count == 0) { 455 dev_dbg(&port->dev, "write request of 0 bytes\n"); 456 return 0; 457 } 458 459 /* we might block because of: 460 the TX urb is in-flight (wait until it completes) 461 the device is full (wait until it says there is room) 462 */ 463 spin_lock_bh(&port->lock); 464 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) { 465 spin_unlock_bh(&port->lock); 466 return 0; 467 } 468 clear_bit(0, &port->write_urbs_free); 469 spin_unlock_bh(&port->lock); 470 471 /* At this point the URB is in our control, nobody else can submit it 472 again (the only sudden transition was the one from EINPROGRESS to 473 finished). Also, the tx process is not throttled. So we are 474 ready to write. */ 475 476 count = (count > port->bulk_out_size) ? port->bulk_out_size : count; 477 478 /* Check if we might overrun the Tx buffer. If so, ask the 479 device how much room it really has. This is done only on 480 scheduler time, since usb_control_msg() sleeps. */ 481 if (count > priv->tx_room && !in_interrupt()) { 482 u8 *room; 483 484 room = kmalloc(1, GFP_KERNEL); 485 if (!room) { 486 rc = -ENOMEM; 487 goto exit; 488 } 489 490 rc = usb_control_msg(serial->dev, 491 usb_rcvctrlpipe(serial->dev, 0), 492 6, /* write_room */ 493 USB_TYPE_VENDOR | USB_RECIP_INTERFACE 494 | USB_DIR_IN, 495 0, /* value: 0 means "remaining room" */ 496 0, /* index */ 497 room, 498 1, 499 2000); 500 if (rc > 0) { 501 dev_dbg(&port->dev, "roomquery says %d\n", *room); 502 priv->tx_room = *room; 503 } 504 kfree(room); 505 if (rc < 0) { 506 dev_dbg(&port->dev, "roomquery failed\n"); 507 goto exit; 508 } 509 if (rc == 0) { 510 dev_dbg(&port->dev, "roomquery returned 0 bytes\n"); 511 rc = -EIO; /* device didn't return any data */ 512 goto exit; 513 } 514 } 515 if (count > priv->tx_room) { 516 /* we're about to completely fill the Tx buffer, so 517 we'll be throttled afterwards. */ 518 count = priv->tx_room; 519 request_unthrottle = 1; 520 } 521 522 if (count) { 523 /* now transfer data */ 524 memcpy(port->write_urb->transfer_buffer, buf, count); 525 /* send the data out the bulk port */ 526 port->write_urb->transfer_buffer_length = count; 527 528 priv->tx_room -= count; 529 530 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC); 531 if (rc) { 532 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n"); 533 goto exit; 534 } 535 } else { 536 /* There wasn't any room left, so we are throttled until 537 the buffer empties a bit */ 538 request_unthrottle = 1; 539 } 540 541 if (request_unthrottle) { 542 priv->tx_throttled = 1; /* block writers */ 543 schedule_work(&priv->unthrottle_work); 544 } 545 546 rc = count; 547 exit: 548 if (rc < 0) 549 set_bit(0, &port->write_urbs_free); 550 return rc; 551 } 552 553 554 static void keyspan_pda_write_bulk_callback(struct urb *urb) 555 { 556 struct usb_serial_port *port = urb->context; 557 struct keyspan_pda_private *priv; 558 559 set_bit(0, &port->write_urbs_free); 560 priv = usb_get_serial_port_data(port); 561 562 /* queue up a wakeup at scheduler time */ 563 schedule_work(&priv->wakeup_work); 564 } 565 566 567 static int keyspan_pda_write_room(struct tty_struct *tty) 568 { 569 struct usb_serial_port *port = tty->driver_data; 570 struct keyspan_pda_private *priv; 571 priv = usb_get_serial_port_data(port); 572 /* used by n_tty.c for processing of tabs and such. Giving it our 573 conservative guess is probably good enough, but needs testing by 574 running a console through the device. */ 575 return priv->tx_room; 576 } 577 578 579 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty) 580 { 581 struct usb_serial_port *port = tty->driver_data; 582 struct keyspan_pda_private *priv; 583 unsigned long flags; 584 int ret = 0; 585 586 priv = usb_get_serial_port_data(port); 587 588 /* when throttled, return at least WAKEUP_CHARS to tell select() (via 589 n_tty.c:normal_poll() ) that we're not writeable. */ 590 591 spin_lock_irqsave(&port->lock, flags); 592 if (!test_bit(0, &port->write_urbs_free) || priv->tx_throttled) 593 ret = 256; 594 spin_unlock_irqrestore(&port->lock, flags); 595 return ret; 596 } 597 598 599 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on) 600 { 601 struct usb_serial *serial = port->serial; 602 603 if (on) 604 keyspan_pda_set_modem_info(serial, (1 << 7) | (1 << 2)); 605 else 606 keyspan_pda_set_modem_info(serial, 0); 607 } 608 609 610 static int keyspan_pda_open(struct tty_struct *tty, 611 struct usb_serial_port *port) 612 { 613 struct usb_serial *serial = port->serial; 614 u8 *room; 615 int rc = 0; 616 struct keyspan_pda_private *priv; 617 618 /* find out how much room is in the Tx ring */ 619 room = kmalloc(1, GFP_KERNEL); 620 if (!room) 621 return -ENOMEM; 622 623 rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0), 624 6, /* write_room */ 625 USB_TYPE_VENDOR | USB_RECIP_INTERFACE 626 | USB_DIR_IN, 627 0, /* value */ 628 0, /* index */ 629 room, 630 1, 631 2000); 632 if (rc < 0) { 633 dev_dbg(&port->dev, "%s - roomquery failed\n", __func__); 634 goto error; 635 } 636 if (rc == 0) { 637 dev_dbg(&port->dev, "%s - roomquery returned 0 bytes\n", __func__); 638 rc = -EIO; 639 goto error; 640 } 641 priv = usb_get_serial_port_data(port); 642 priv->tx_room = *room; 643 priv->tx_throttled = *room ? 0 : 1; 644 645 /*Start reading from the device*/ 646 rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); 647 if (rc) { 648 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__); 649 goto error; 650 } 651 error: 652 kfree(room); 653 return rc; 654 } 655 static void keyspan_pda_close(struct usb_serial_port *port) 656 { 657 usb_kill_urb(port->write_urb); 658 usb_kill_urb(port->interrupt_in_urb); 659 } 660 661 662 /* download the firmware to a "fake" device (pre-renumeration) */ 663 static int keyspan_pda_fake_startup(struct usb_serial *serial) 664 { 665 int response; 666 const char *fw_name; 667 668 /* download the firmware here ... */ 669 response = ezusb_fx1_set_reset(serial->dev, 1); 670 671 if (0) { ; } 672 #ifdef KEYSPAN 673 else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID) 674 fw_name = "keyspan_pda/keyspan_pda.fw"; 675 #endif 676 #ifdef XIRCOM 677 else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) || 678 (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID)) 679 fw_name = "keyspan_pda/xircom_pgs.fw"; 680 #endif 681 else { 682 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n", 683 __func__); 684 return -ENODEV; 685 } 686 687 if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) { 688 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n", 689 fw_name); 690 return -ENOENT; 691 } 692 693 /* after downloading firmware Renumeration will occur in a 694 moment and the new device will bind to the real driver */ 695 696 /* we want this device to fail to have a driver assigned to it. */ 697 return 1; 698 } 699 700 #ifdef KEYSPAN 701 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw"); 702 #endif 703 #ifdef XIRCOM 704 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw"); 705 #endif 706 707 static int keyspan_pda_port_probe(struct usb_serial_port *port) 708 { 709 710 struct keyspan_pda_private *priv; 711 712 priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL); 713 if (!priv) 714 return -ENOMEM; 715 716 INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write); 717 INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle); 718 priv->serial = port->serial; 719 priv->port = port; 720 721 usb_set_serial_port_data(port, priv); 722 723 return 0; 724 } 725 726 static int keyspan_pda_port_remove(struct usb_serial_port *port) 727 { 728 struct keyspan_pda_private *priv; 729 730 priv = usb_get_serial_port_data(port); 731 kfree(priv); 732 733 return 0; 734 } 735 736 #ifdef KEYSPAN 737 static struct usb_serial_driver keyspan_pda_fake_device = { 738 .driver = { 739 .owner = THIS_MODULE, 740 .name = "keyspan_pda_pre", 741 }, 742 .description = "Keyspan PDA - (prerenumeration)", 743 .id_table = id_table_fake, 744 .num_ports = 1, 745 .attach = keyspan_pda_fake_startup, 746 }; 747 #endif 748 749 #ifdef XIRCOM 750 static struct usb_serial_driver xircom_pgs_fake_device = { 751 .driver = { 752 .owner = THIS_MODULE, 753 .name = "xircom_no_firm", 754 }, 755 .description = "Xircom / Entrega PGS - (prerenumeration)", 756 .id_table = id_table_fake_xircom, 757 .num_ports = 1, 758 .attach = keyspan_pda_fake_startup, 759 }; 760 #endif 761 762 static struct usb_serial_driver keyspan_pda_device = { 763 .driver = { 764 .owner = THIS_MODULE, 765 .name = "keyspan_pda", 766 }, 767 .description = "Keyspan PDA", 768 .id_table = id_table_std, 769 .num_ports = 1, 770 .num_bulk_out = 1, 771 .num_interrupt_in = 1, 772 .dtr_rts = keyspan_pda_dtr_rts, 773 .open = keyspan_pda_open, 774 .close = keyspan_pda_close, 775 .write = keyspan_pda_write, 776 .write_room = keyspan_pda_write_room, 777 .write_bulk_callback = keyspan_pda_write_bulk_callback, 778 .read_int_callback = keyspan_pda_rx_interrupt, 779 .chars_in_buffer = keyspan_pda_chars_in_buffer, 780 .throttle = keyspan_pda_rx_throttle, 781 .unthrottle = keyspan_pda_rx_unthrottle, 782 .set_termios = keyspan_pda_set_termios, 783 .break_ctl = keyspan_pda_break_ctl, 784 .tiocmget = keyspan_pda_tiocmget, 785 .tiocmset = keyspan_pda_tiocmset, 786 .port_probe = keyspan_pda_port_probe, 787 .port_remove = keyspan_pda_port_remove, 788 }; 789 790 static struct usb_serial_driver * const serial_drivers[] = { 791 &keyspan_pda_device, 792 #ifdef KEYSPAN 793 &keyspan_pda_fake_device, 794 #endif 795 #ifdef XIRCOM 796 &xircom_pgs_fake_device, 797 #endif 798 NULL 799 }; 800 801 module_usb_serial_driver(serial_drivers, id_table_combined); 802 803 MODULE_AUTHOR(DRIVER_AUTHOR); 804 MODULE_DESCRIPTION(DRIVER_DESC); 805 MODULE_LICENSE("GPL"); 806