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