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