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