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