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