drivers/usb/serial/keyspan_pda.c

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