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