git.oblomov.eu Git - linux-2.6/blob - 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                                  2000);
 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_kill_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                              2000); /* 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, 2000);
 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, 2000);
 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, 2000);
 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,
 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                                      2000);
 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                 memcpy (port->write_urb->transfer_buffer, buf, count);
 571                 /* send the data out the bulk port */
 572                 port->write_urb->transfer_buffer_length = count;
 573
 574                 priv->tx_room -= count;
 575
 576                 port->write_urb->dev = port->serial->dev;
 577                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 578                 if (rc) {
 579                         dbg(" usb_submit_urb(write bulk) failed");
 580                         goto exit;
 581                 }
 582         }
 583         else {
 584                 /* There wasn't any room left, so we are throttled until
 585                    the buffer empties a bit */
 586                 request_unthrottle = 1;
 587         }
 588
 589         if (request_unthrottle) {
 590                 priv->tx_throttled = 1; /* block writers */
 591                 schedule_work(&priv->unthrottle_work);
 592         }
 593
 594         rc = count;
 595 exit:
 596         return rc;
 597 }
 598
 599
 600 static void keyspan_pda_write_bulk_callback (struct urb *urb, struct pt_regs *regs)
 601 {
 602         struct usb_serial_port *port = (struct usb_serial_port *)urb->context;
 603         struct keyspan_pda_private *priv;
 604
 605         priv = usb_get_serial_port_data(port);
 606
 607         /* queue up a wakeup at scheduler time */
 608         schedule_work(&priv->wakeup_work);
 609 }
 610
 611
 612 static int keyspan_pda_write_room (struct usb_serial_port *port)
 613 {
 614         struct keyspan_pda_private *priv;
 615
 616         priv = usb_get_serial_port_data(port);
 617
 618         /* used by n_tty.c for processing of tabs and such. Giving it our
 619            conservative guess is probably good enough, but needs testing by
 620            running a console through the device. */
 621
 622         return (priv->tx_room);
 623 }
 624
 625
 626 static int keyspan_pda_chars_in_buffer (struct usb_serial_port *port)
 627 {
 628         struct keyspan_pda_private *priv;
 629
 630         priv = usb_get_serial_port_data(port);
 631
 632         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 633            n_tty.c:normal_poll() ) that we're not writeable. */
 634         if( port->write_urb->status == -EINPROGRESS || priv->tx_throttled )
 635                 return 256;
 636         return 0;
 637 }
 638
 639
 640 static int keyspan_pda_open (struct usb_serial_port *port, struct file *filp)
 641 {
 642         struct usb_serial *serial = port->serial;
 643         unsigned char room;
 644         int rc = 0;
 645         struct keyspan_pda_private *priv;
 646
 647         /* find out how much room is in the Tx ring */
 648         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 649                              6, /* write_room */
 650                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 651                              | USB_DIR_IN,
 652                              0, /* value */
 653                              0, /* index */
 654                              &room,
 655                              1,
 656                              2000);
 657         if (rc < 0) {
 658                 dbg("%s - roomquery failed", __FUNCTION__);
 659                 goto error;
 660         }
 661         if (rc == 0) {
 662                 dbg("%s - roomquery returned 0 bytes", __FUNCTION__);
 663                 rc = -EIO;
 664                 goto error;
 665         }
 666         priv = usb_get_serial_port_data(port);
 667         priv->tx_room = room;
 668         priv->tx_throttled = room ? 0 : 1;
 669
 670         /* the normal serial device seems to always turn on DTR and RTS here,
 671            so do the same */
 672         if (port->tty->termios->c_cflag & CBAUD)
 673                 keyspan_pda_set_modem_info(serial, (1<<7) | (1<<2) );
 674         else
 675                 keyspan_pda_set_modem_info(serial, 0);
 676
 677         /*Start reading from the device*/
 678         port->interrupt_in_urb->dev = serial->dev;
 679         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 680         if (rc) {
 681                 dbg("%s - usb_submit_urb(read int) failed", __FUNCTION__);
 682                 goto error;
 683         }
 684
 685 error:
 686         return rc;
 687 }
 688
 689
 690 static void keyspan_pda_close(struct usb_serial_port *port, struct file *filp)
 691 {
 692         struct usb_serial *serial = port->serial;
 693
 694         if (serial->dev) {
 695                 /* the normal serial device seems to always shut off DTR and RTS now */
 696                 if (port->tty->termios->c_cflag & HUPCL)
 697                         keyspan_pda_set_modem_info(serial, 0);
 698
 699                 /* shutdown our bulk reads and writes */
 700                 usb_kill_urb(port->write_urb);
 701                 usb_kill_urb(port->interrupt_in_urb);
 702         }
 703 }
 704
 705
 706 /* download the firmware to a "fake" device (pre-renumeration) */
 707 static int keyspan_pda_fake_startup (struct usb_serial *serial)
 708 {
 709         int response;
 710         const struct ezusb_hex_record *record = NULL;
 711
 712         /* download the firmware here ... */
 713         response = ezusb_set_reset(serial, 1);
 714
 715 #ifdef KEYSPAN
 716         if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 717                 record = &keyspan_pda_firmware[0];
 718 #endif
 719 #ifdef XIRCOM
 720         if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 721             (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
 722                 record = &xircom_pgs_firmware[0];
 723 #endif
 724         if (record == NULL) {
 725                 err("%s: unknown vendor, aborting.", __FUNCTION__);
 726                 return -ENODEV;
 727         }
 728
 729         while(record->address != 0xffff) {
 730                 response = ezusb_writememory(serial, record->address,
 731                                              (unsigned char *)record->data,
 732                                              record->data_size, 0xa0);
 733                 if (response < 0) {
 734                         err("ezusb_writememory failed for Keyspan PDA "
 735                             "firmware (%d %04X %p %d)",
 736                             response,
 737                             record->address, record->data, record->data_size);
 738                         break;
 739                 }
 740                 record++;
 741         }
 742         /* bring device out of reset. Renumeration will occur in a moment
 743            and the new device will bind to the real driver */
 744         response = ezusb_set_reset(serial, 0);
 745
 746         /* we want this device to fail to have a driver assigned to it. */
 747         return (1);
 748 }
 749
 750 static int keyspan_pda_startup (struct usb_serial *serial)
 751 {
 752
 753         struct keyspan_pda_private *priv;
 754
 755         /* allocate the private data structures for all ports. Well, for all
 756            one ports. */
 757
 758         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 759         if (!priv)
 760                 return (1); /* error */
 761         usb_set_serial_port_data(serial->port[0], priv);
 762         init_waitqueue_head(&serial->port[0]->write_wait);
 763         INIT_WORK(&priv->wakeup_work, (void *)keyspan_pda_wakeup_write,
 764                         (void *)(serial->port[0]));
 765         INIT_WORK(&priv->unthrottle_work,
 766                         (void *)keyspan_pda_request_unthrottle,
 767                         (void *)(serial));
 768         return (0);
 769 }
 770
 771 static void keyspan_pda_shutdown (struct usb_serial *serial)
 772 {
 773         dbg("%s", __FUNCTION__);
 774
 775         kfree(usb_get_serial_port_data(serial->port[0]));
 776 }
 777
 778 #ifdef KEYSPAN
 779 static struct usb_serial_device_type keyspan_pda_fake_device = {
 780         .owner =                THIS_MODULE,
 781         .name =                 "Keyspan PDA - (prerenumeration)",
 782         .short_name =           "keyspan_pda_pre",
 783         .id_table =             id_table_fake,
 784         .num_interrupt_in =     NUM_DONT_CARE,
 785         .num_bulk_in =          NUM_DONT_CARE,
 786         .num_bulk_out =         NUM_DONT_CARE,
 787         .num_ports =            1,
 788         .attach =               keyspan_pda_fake_startup,
 789 };
 790 #endif
 791
 792 #ifdef XIRCOM
 793 static struct usb_serial_device_type xircom_pgs_fake_device = {
 794         .owner =                THIS_MODULE,
 795         .name =                 "Xircom / Entregra PGS - (prerenumeration)",
 796         .short_name =           "xircom_no_firm",
 797         .id_table =             id_table_fake_xircom,
 798         .num_interrupt_in =     NUM_DONT_CARE,
 799         .num_bulk_in =          NUM_DONT_CARE,
 800         .num_bulk_out =         NUM_DONT_CARE,
 801         .num_ports =            1,
 802         .attach =               keyspan_pda_fake_startup,
 803 };
 804 #endif
 805
 806 static struct usb_serial_device_type keyspan_pda_device = {
 807         .owner =                THIS_MODULE,
 808         .name =                 "Keyspan PDA",
 809         .short_name =           "keyspan_pda",
 810         .id_table =             id_table_std,
 811         .num_interrupt_in =     1,
 812         .num_bulk_in =          0,
 813         .num_bulk_out =         1,
 814         .num_ports =            1,
 815         .open =                 keyspan_pda_open,
 816         .close =                keyspan_pda_close,
 817         .write =                keyspan_pda_write,
 818         .write_room =           keyspan_pda_write_room,
 819         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 820         .read_int_callback =    keyspan_pda_rx_interrupt,
 821         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 822         .throttle =             keyspan_pda_rx_throttle,
 823         .unthrottle =           keyspan_pda_rx_unthrottle,
 824         .ioctl =                keyspan_pda_ioctl,
 825         .set_termios =          keyspan_pda_set_termios,
 826         .break_ctl =            keyspan_pda_break_ctl,
 827         .tiocmget =             keyspan_pda_tiocmget,
 828         .tiocmset =             keyspan_pda_tiocmset,
 829         .attach =               keyspan_pda_startup,
 830         .shutdown =             keyspan_pda_shutdown,
 831 };
 832
 833
 834 static int __init keyspan_pda_init (void)
 835 {
 836         int retval;
 837         retval = usb_serial_register(&keyspan_pda_device);
 838         if (retval)
 839                 goto failed_pda_register;
 840 #ifdef KEYSPAN
 841         retval = usb_serial_register(&keyspan_pda_fake_device);
 842         if (retval)
 843                 goto failed_pda_fake_register;
 844 #endif
 845 #ifdef XIRCOM
 846         retval = usb_serial_register(&xircom_pgs_fake_device);
 847         if (retval)
 848                 goto failed_xircom_register;
 849 #endif
 850         retval = usb_register(&keyspan_pda_driver);
 851         if (retval)
 852                 goto failed_usb_register;
 853         info(DRIVER_DESC " " DRIVER_VERSION);
 854         return 0;
 855 failed_usb_register:
 856 #ifdef XIRCOM
 857         usb_serial_deregister(&xircom_pgs_fake_device);
 858 failed_xircom_register:
 859 #endif /* XIRCOM */
 860 #ifdef KEYSPAN
 861         usb_serial_deregister(&keyspan_pda_fake_device);
 862 #endif
 863 #ifdef KEYSPAN
 864 failed_pda_fake_register:
 865 #endif
 866         usb_serial_deregister(&keyspan_pda_device);
 867 failed_pda_register:
 868         return retval;
 869 }
 870
 871
 872 static void __exit keyspan_pda_exit (void)
 873 {
 874         usb_deregister (&keyspan_pda_driver);
 875         usb_serial_deregister (&keyspan_pda_device);
 876 #ifdef KEYSPAN
 877         usb_serial_deregister (&keyspan_pda_fake_device);
 878 #endif
 879 #ifdef XIRCOM
 880         usb_serial_deregister (&xircom_pgs_fake_device);
 881 #endif
 882 }
 883
 884
 885 module_init(keyspan_pda_init);
 886 module_exit(keyspan_pda_exit);
 887
 888 MODULE_AUTHOR( DRIVER_AUTHOR );
 889 MODULE_DESCRIPTION( DRIVER_DESC );
 890 MODULE_LICENSE("GPL");
 891
 892 module_param(debug, bool, S_IRUGO | S_IWUSR);
 893 MODULE_PARM_DESC(debug, "Debug enabled or not");
 894