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