drivers/usb/serial/keyspan_pda.c

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