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