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