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