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