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