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