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