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 void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 655 {
 656         struct usb_serial *serial = port->serial;
 657
 658         if (serial->dev) {
 659                 if (on)
 660                         keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
 661                 else
 662                         keyspan_pda_set_modem_info(serial, 0);
 663         }
 664 }
 665
 666 static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
 667 {
 668         struct usb_serial *serial = port->serial;
 669         unsigned char modembits;
 670
 671         /* If we can read the modem status and the DCD is low then
 672            carrier is not raised yet */
 673         if (keyspan_pda_get_modem_info(serial, &modembits) >= 0) {
 674                 if (!(modembits & (1>>6)))
 675                         return 0;
 676         }
 677         /* Carrier raised, or we failed (eg disconnected) so
 678            progress accordingly */
 679         return 1;
 680 }
 681
 682
 683 static int keyspan_pda_open(struct tty_struct *tty,
 684                         struct usb_serial_port *port, struct file *filp)
 685 {
 686         struct usb_serial *serial = port->serial;
 687         unsigned char room;
 688         int rc = 0;
 689         struct keyspan_pda_private *priv;
 690
 691         /* find out how much room is in the Tx ring */
 692         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 693                              6, /* write_room */
 694                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 695                              | USB_DIR_IN,
 696                              0, /* value */
 697                              0, /* index */
 698                              &room,
 699                              1,
 700                              2000);
 701         if (rc < 0) {
 702                 dbg("%s - roomquery failed", __func__);
 703                 goto error;
 704         }
 705         if (rc == 0) {
 706                 dbg("%s - roomquery returned 0 bytes", __func__);
 707                 rc = -EIO;
 708                 goto error;
 709         }
 710         priv = usb_get_serial_port_data(port);
 711         priv->tx_room = room;
 712         priv->tx_throttled = room ? 0 : 1;
 713
 714         /*Start reading from the device*/
 715         port->interrupt_in_urb->dev = serial->dev;
 716         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 717         if (rc) {
 718                 dbg("%s - usb_submit_urb(read int) failed", __func__);
 719                 goto error;
 720         }
 721
 722 error:
 723         return rc;
 724 }
 725 static void keyspan_pda_close(struct usb_serial_port *port)
 726 {
 727         struct usb_serial *serial = port->serial;
 728
 729         if (serial->dev) {
 730                 /* shutdown our bulk reads and writes */
 731                 usb_kill_urb(port->write_urb);
 732                 usb_kill_urb(port->interrupt_in_urb);
 733         }
 734 }
 735
 736
 737 /* download the firmware to a "fake" device (pre-renumeration) */
 738 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 739 {
 740         int response;
 741         const char *fw_name;
 742         const struct ihex_binrec *record;
 743         const struct firmware *fw;
 744
 745         /* download the firmware here ... */
 746         response = ezusb_set_reset(serial, 1);
 747
 748         if (0) { ; }
 749 #ifdef KEYSPAN
 750         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 751                 fw_name = "keyspan_pda/keyspan_pda.fw";
 752 #endif
 753 #ifdef XIRCOM
 754         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 755                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
 756                 fw_name = "keyspan_pda/xircom_pgs.fw";
 757 #endif
 758         else {
 759                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 760                         __func__);
 761                 return -ENODEV;
 762         }
 763         if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
 764                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 765                         fw_name);
 766                 return -ENOENT;
 767         }
 768         record = (const struct ihex_binrec *)fw->data;
 769
 770         while (record) {
 771                 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
 772                                              (unsigned char *)record->data,
 773                                              be16_to_cpu(record->len), 0xa0);
 774                 if (response < 0) {
 775                         dev_err(&serial->dev->dev, "ezusb_writememory failed "
 776                                 "for Keyspan PDA firmware (%d %04X %p %d)\n",
 777                                 response, be32_to_cpu(record->addr),
 778                                 record->data, be16_to_cpu(record->len));
 779                         break;
 780                 }
 781                 record = ihex_next_binrec(record);
 782         }
 783         release_firmware(fw);
 784         /* bring device out of reset. Renumeration will occur in a moment
 785            and the new device will bind to the real driver */
 786         response = ezusb_set_reset(serial, 0);
 787
 788         /* we want this device to fail to have a driver assigned to it. */
 789         return 1;
 790 }
 791
 792 static int keyspan_pda_startup(struct usb_serial *serial)
 793 {
 794
 795         struct keyspan_pda_private *priv;
 796
 797         /* allocate the private data structures for all ports. Well, for all
 798            one ports. */
 799
 800         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 801         if (!priv)
 802                 return 1; /* error */
 803         usb_set_serial_port_data(serial->port[0], priv);
 804         init_waitqueue_head(&serial->port[0]->write_wait);
 805         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 806         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 807         priv->serial = serial;
 808         priv->port = serial->port[0];
 809         return 0;
 810 }
 811
 812 static void keyspan_pda_release(struct usb_serial *serial)
 813 {
 814         dbg("%s", __func__);
 815
 816         kfree(usb_get_serial_port_data(serial->port[0]));
 817 }
 818
 819 #ifdef KEYSPAN
 820 static struct usb_serial_driver keyspan_pda_fake_device = {
 821         .driver = {
 822                 .owner =        THIS_MODULE,
 823                 .name =         "keyspan_pda_pre",
 824         },
 825         .description =          "Keyspan PDA - (prerenumeration)",
 826         .usb_driver =           &keyspan_pda_driver,
 827         .id_table =             id_table_fake,
 828         .num_ports =            1,
 829         .attach =               keyspan_pda_fake_startup,
 830 };
 831 #endif
 832
 833 #ifdef XIRCOM
 834 static struct usb_serial_driver xircom_pgs_fake_device = {
 835         .driver = {
 836                 .owner =        THIS_MODULE,
 837                 .name =         "xircom_no_firm",
 838         },
 839         .description =          "Xircom / Entregra PGS - (prerenumeration)",
 840         .usb_driver =           &keyspan_pda_driver,
 841         .id_table =             id_table_fake_xircom,
 842         .num_ports =            1,
 843         .attach =               keyspan_pda_fake_startup,
 844 };
 845 #endif
 846
 847 static struct usb_serial_driver keyspan_pda_device = {
 848         .driver = {
 849                 .owner =        THIS_MODULE,
 850                 .name =         "keyspan_pda",
 851         },
 852         .description =          "Keyspan PDA",
 853         .usb_driver =           &keyspan_pda_driver,
 854         .id_table =             id_table_std,
 855         .num_ports =            1,
 856         .dtr_rts =              keyspan_pda_dtr_rts,
 857         .carrier_raised =       keyspan_pda_carrier_raised,
 858         .open =                 keyspan_pda_open,
 859         .close =                keyspan_pda_close,
 860         .write =                keyspan_pda_write,
 861         .write_room =           keyspan_pda_write_room,
 862         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 863         .read_int_callback =    keyspan_pda_rx_interrupt,
 864         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 865         .throttle =             keyspan_pda_rx_throttle,
 866         .unthrottle =           keyspan_pda_rx_unthrottle,
 867         .set_termios =          keyspan_pda_set_termios,
 868         .break_ctl =            keyspan_pda_break_ctl,
 869         .tiocmget =             keyspan_pda_tiocmget,
 870         .tiocmset =             keyspan_pda_tiocmset,
 871         .attach =               keyspan_pda_startup,
 872         .release =              keyspan_pda_release,
 873 };
 874
 875
 876 static int __init keyspan_pda_init(void)
 877 {
 878         int retval;
 879         retval = usb_serial_register(&keyspan_pda_device);
 880         if (retval)
 881                 goto failed_pda_register;
 882 #ifdef KEYSPAN
 883         retval = usb_serial_register(&keyspan_pda_fake_device);
 884         if (retval)
 885                 goto failed_pda_fake_register;
 886 #endif
 887 #ifdef XIRCOM
 888         retval = usb_serial_register(&xircom_pgs_fake_device);
 889         if (retval)
 890                 goto failed_xircom_register;
 891 #endif
 892         retval = usb_register(&keyspan_pda_driver);
 893         if (retval)
 894                 goto failed_usb_register;
 895         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 896                DRIVER_DESC "\n");
 897         return 0;
 898 failed_usb_register:
 899 #ifdef XIRCOM
 900         usb_serial_deregister(&xircom_pgs_fake_device);
 901 failed_xircom_register:
 902 #endif /* XIRCOM */
 903 #ifdef KEYSPAN
 904         usb_serial_deregister(&keyspan_pda_fake_device);
 905 #endif
 906 #ifdef KEYSPAN
 907 failed_pda_fake_register:
 908 #endif
 909         usb_serial_deregister(&keyspan_pda_device);
 910 failed_pda_register:
 911         return retval;
 912 }
 913
 914
 915 static void __exit keyspan_pda_exit(void)
 916 {
 917         usb_deregister(&keyspan_pda_driver);
 918         usb_serial_deregister(&keyspan_pda_device);
 919 #ifdef KEYSPAN
 920         usb_serial_deregister(&keyspan_pda_fake_device);
 921 #endif
 922 #ifdef XIRCOM
 923         usb_serial_deregister(&xircom_pgs_fake_device);
 924 #endif
 925 }
 926
 927
 928 module_init(keyspan_pda_init);
 929 module_exit(keyspan_pda_exit);
 930
 931 MODULE_AUTHOR(DRIVER_AUTHOR);
 932 MODULE_DESCRIPTION(DRIVER_DESC);
 933 MODULE_LICENSE("GPL");
 934
 935 module_param(debug, bool, S_IRUGO | S_IWUSR);
 936 MODULE_PARM_DESC(debug, "Debug enabled or not");
 937