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