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