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