git.oblomov.eu Git - linux-2.6/blob - drivers/usb/serial/keyspan_pda.c

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