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 const 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 const 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 const 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 const 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_KERNEL))
 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         u8 *data;
 433
 434         data = kmalloc(1, GFP_KERNEL);
 435         if (!data)
 436                 return -ENOMEM;
 437
 438         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 439                              3, /* get pins */
 440                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
 441                              0, 0, data, 1, 2000);
 442         if (rc >= 0)
 443                 *value = *data;
 444
 445         kfree(data);
 446         return rc;
 447 }
 448
 449
 450 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 451                                       unsigned char value)
 452 {
 453         int rc;
 454         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 455                              3, /* set pins */
 456                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 457                              value, 0, NULL, 0, 2000);
 458         return rc;
 459 }
 460
 461 static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
 462 {
 463         struct usb_serial_port *port = tty->driver_data;
 464         struct usb_serial *serial = port->serial;
 465         int rc;
 466         unsigned char status;
 467         int value;
 468
 469         rc = keyspan_pda_get_modem_info(serial, &status);
 470         if (rc < 0)
 471                 return rc;
 472         value =
 473                 ((status & (1<<7)) ? TIOCM_DTR : 0) |
 474                 ((status & (1<<6)) ? TIOCM_CAR : 0) |
 475                 ((status & (1<<5)) ? TIOCM_RNG : 0) |
 476                 ((status & (1<<4)) ? TIOCM_DSR : 0) |
 477                 ((status & (1<<3)) ? TIOCM_CTS : 0) |
 478                 ((status & (1<<2)) ? TIOCM_RTS : 0);
 479         return value;
 480 }
 481
 482 static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
 483                                 unsigned int set, unsigned int clear)
 484 {
 485         struct usb_serial_port *port = tty->driver_data;
 486         struct usb_serial *serial = port->serial;
 487         int rc;
 488         unsigned char status;
 489
 490         rc = keyspan_pda_get_modem_info(serial, &status);
 491         if (rc < 0)
 492                 return rc;
 493
 494         if (set & TIOCM_RTS)
 495                 status |= (1<<2);
 496         if (set & TIOCM_DTR)
 497                 status |= (1<<7);
 498
 499         if (clear & TIOCM_RTS)
 500                 status &= ~(1<<2);
 501         if (clear & TIOCM_DTR)
 502                 status &= ~(1<<7);
 503         rc = keyspan_pda_set_modem_info(serial, status);
 504         return rc;
 505 }
 506
 507 static int keyspan_pda_write(struct tty_struct *tty,
 508         struct usb_serial_port *port, const unsigned char *buf, int count)
 509 {
 510         struct usb_serial *serial = port->serial;
 511         int request_unthrottle = 0;
 512         int rc = 0;
 513         struct keyspan_pda_private *priv;
 514
 515         priv = usb_get_serial_port_data(port);
 516         /* guess how much room is left in the device's ring buffer, and if we
 517            want to send more than that, check first, updating our notion of
 518            what is left. If our write will result in no room left, ask the
 519            device to give us an interrupt when the room available rises above
 520            a threshold, and hold off all writers (eventually, those using
 521            select() or poll() too) until we receive that unthrottle interrupt.
 522            Block if we can't write anything at all, otherwise write as much as
 523            we can. */
 524         dbg("keyspan_pda_write(%d)", count);
 525         if (count == 0) {
 526                 dbg(" write request of 0 bytes");
 527                 return 0;
 528         }
 529
 530         /* we might block because of:
 531            the TX urb is in-flight (wait until it completes)
 532            the device is full (wait until it says there is room)
 533         */
 534         spin_lock_bh(&port->lock);
 535         if (port->write_urb_busy || priv->tx_throttled) {
 536                 spin_unlock_bh(&port->lock);
 537                 return 0;
 538         }
 539         port->write_urb_busy = 1;
 540         spin_unlock_bh(&port->lock);
 541
 542         /* At this point the URB is in our control, nobody else can submit it
 543            again (the only sudden transition was the one from EINPROGRESS to
 544            finished).  Also, the tx process is not throttled. So we are
 545            ready to write. */
 546
 547         count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
 548
 549         /* Check if we might overrun the Tx buffer.   If so, ask the
 550            device how much room it really has.  This is done only on
 551            scheduler time, since usb_control_msg() sleeps. */
 552         if (count > priv->tx_room && !in_interrupt()) {
 553                 u8 *room;
 554
 555                 room = kmalloc(1, GFP_KERNEL);
 556                 if (!room) {
 557                         rc = -ENOMEM;
 558                         goto exit;
 559                 }
 560
 561                 rc = usb_control_msg(serial->dev,
 562                                      usb_rcvctrlpipe(serial->dev, 0),
 563                                      6, /* write_room */
 564                                      USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 565                                      | USB_DIR_IN,
 566                                      0, /* value: 0 means "remaining room" */
 567                                      0, /* index */
 568                                      room,
 569                                      1,
 570                                      2000);
 571                 if (rc > 0) {
 572                         dbg(" roomquery says %d", *room);
 573                         priv->tx_room = *room;
 574                 }
 575                 kfree(room);
 576                 if (rc < 0) {
 577                         dbg(" roomquery failed");
 578                         goto exit;
 579                 }
 580                 if (rc == 0) {
 581                         dbg(" roomquery returned 0 bytes");
 582                         rc = -EIO; /* device didn't return any data */
 583                         goto exit;
 584                 }
 585         }
 586         if (count > priv->tx_room) {
 587                 /* we're about to completely fill the Tx buffer, so
 588                    we'll be throttled afterwards. */
 589                 count = priv->tx_room;
 590                 request_unthrottle = 1;
 591         }
 592
 593         if (count) {
 594                 /* now transfer data */
 595                 memcpy(port->write_urb->transfer_buffer, buf, count);
 596                 /* send the data out the bulk port */
 597                 port->write_urb->transfer_buffer_length = count;
 598
 599                 priv->tx_room -= count;
 600
 601                 port->write_urb->dev = port->serial->dev;
 602                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 603                 if (rc) {
 604                         dbg(" usb_submit_urb(write bulk) failed");
 605                         goto exit;
 606                 }
 607         } else {
 608                 /* There wasn't any room left, so we are throttled until
 609                    the buffer empties a bit */
 610                 request_unthrottle = 1;
 611         }
 612
 613         if (request_unthrottle) {
 614                 priv->tx_throttled = 1; /* block writers */
 615                 schedule_work(&priv->unthrottle_work);
 616         }
 617
 618         rc = count;
 619 exit:
 620         if (rc < 0)
 621                 port->write_urb_busy = 0;
 622         return rc;
 623 }
 624
 625
 626 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 627 {
 628         struct usb_serial_port *port = urb->context;
 629         struct keyspan_pda_private *priv;
 630
 631         port->write_urb_busy = 0;
 632         priv = usb_get_serial_port_data(port);
 633
 634         /* queue up a wakeup at scheduler time */
 635         schedule_work(&priv->wakeup_work);
 636 }
 637
 638
 639 static int keyspan_pda_write_room(struct tty_struct *tty)
 640 {
 641         struct usb_serial_port *port = tty->driver_data;
 642         struct keyspan_pda_private *priv;
 643         priv = usb_get_serial_port_data(port);
 644         /* used by n_tty.c for processing of tabs and such. Giving it our
 645            conservative guess is probably good enough, but needs testing by
 646            running a console through the device. */
 647         return priv->tx_room;
 648 }
 649
 650
 651 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 652 {
 653         struct usb_serial_port *port = tty->driver_data;
 654         struct keyspan_pda_private *priv;
 655         unsigned long flags;
 656         int ret = 0;
 657
 658         priv = usb_get_serial_port_data(port);
 659
 660         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 661            n_tty.c:normal_poll() ) that we're not writeable. */
 662
 663         spin_lock_irqsave(&port->lock, flags);
 664         if (port->write_urb_busy || priv->tx_throttled)
 665                 ret = 256;
 666         spin_unlock_irqrestore(&port->lock, flags);
 667         return ret;
 668 }
 669
 670
 671 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 672 {
 673         struct usb_serial *serial = port->serial;
 674
 675         if (serial->dev) {
 676                 if (on)
 677                         keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
 678                 else
 679                         keyspan_pda_set_modem_info(serial, 0);
 680         }
 681 }
 682
 683 static int keyspan_pda_carrier_raised(struct usb_serial_port *port)
 684 {
 685         struct usb_serial *serial = port->serial;
 686         unsigned char modembits;
 687
 688         /* If we can read the modem status and the DCD is low then
 689            carrier is not raised yet */
 690         if (keyspan_pda_get_modem_info(serial, &modembits) >= 0) {
 691                 if (!(modembits & (1>>6)))
 692                         return 0;
 693         }
 694         /* Carrier raised, or we failed (eg disconnected) so
 695            progress accordingly */
 696         return 1;
 697 }
 698
 699
 700 static int keyspan_pda_open(struct tty_struct *tty,
 701                                         struct usb_serial_port *port)
 702 {
 703         struct usb_serial *serial = port->serial;
 704         u8 *room;
 705         int rc = 0;
 706         struct keyspan_pda_private *priv;
 707
 708         /* find out how much room is in the Tx ring */
 709         room = kmalloc(1, GFP_KERNEL);
 710         if (!room)
 711                 return -ENOMEM;
 712
 713         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 714                              6, /* write_room */
 715                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 716                              | USB_DIR_IN,
 717                              0, /* value */
 718                              0, /* index */
 719                              room,
 720                              1,
 721                              2000);
 722         if (rc < 0) {
 723                 dbg("%s - roomquery failed", __func__);
 724                 goto error;
 725         }
 726         if (rc == 0) {
 727                 dbg("%s - roomquery returned 0 bytes", __func__);
 728                 rc = -EIO;
 729                 goto error;
 730         }
 731         priv = usb_get_serial_port_data(port);
 732         priv->tx_room = *room;
 733         priv->tx_throttled = *room ? 0 : 1;
 734
 735         /*Start reading from the device*/
 736         port->interrupt_in_urb->dev = serial->dev;
 737         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 738         if (rc) {
 739                 dbg("%s - usb_submit_urb(read int) failed", __func__);
 740                 goto error;
 741         }
 742 error:
 743         kfree(room);
 744         return rc;
 745 }
 746 static void keyspan_pda_close(struct usb_serial_port *port)
 747 {
 748         struct usb_serial *serial = port->serial;
 749
 750         if (serial->dev) {
 751                 /* shutdown our bulk reads and writes */
 752                 usb_kill_urb(port->write_urb);
 753                 usb_kill_urb(port->interrupt_in_urb);
 754         }
 755 }
 756
 757
 758 /* download the firmware to a "fake" device (pre-renumeration) */
 759 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 760 {
 761         int response;
 762         const char *fw_name;
 763         const struct ihex_binrec *record;
 764         const struct firmware *fw;
 765
 766         /* download the firmware here ... */
 767         response = ezusb_set_reset(serial, 1);
 768
 769         if (0) { ; }
 770 #ifdef KEYSPAN
 771         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 772                 fw_name = "keyspan_pda/keyspan_pda.fw";
 773 #endif
 774 #ifdef XIRCOM
 775         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 776                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
 777                 fw_name = "keyspan_pda/xircom_pgs.fw";
 778 #endif
 779         else {
 780                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 781                         __func__);
 782                 return -ENODEV;
 783         }
 784         if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
 785                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 786                         fw_name);
 787                 return -ENOENT;
 788         }
 789         record = (const struct ihex_binrec *)fw->data;
 790
 791         while (record) {
 792                 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
 793                                              (unsigned char *)record->data,
 794                                              be16_to_cpu(record->len), 0xa0);
 795                 if (response < 0) {
 796                         dev_err(&serial->dev->dev, "ezusb_writememory failed "
 797                                 "for Keyspan PDA firmware (%d %04X %p %d)\n",
 798                                 response, be32_to_cpu(record->addr),
 799                                 record->data, be16_to_cpu(record->len));
 800                         break;
 801                 }
 802                 record = ihex_next_binrec(record);
 803         }
 804         release_firmware(fw);
 805         /* bring device out of reset. Renumeration will occur in a moment
 806            and the new device will bind to the real driver */
 807         response = ezusb_set_reset(serial, 0);
 808
 809         /* we want this device to fail to have a driver assigned to it. */
 810         return 1;
 811 }
 812
 813 #ifdef KEYSPAN
 814 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 815 #endif
 816 #ifdef XIRCOM
 817 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 818 #endif
 819
 820 static int keyspan_pda_startup(struct usb_serial *serial)
 821 {
 822
 823         struct keyspan_pda_private *priv;
 824
 825         /* allocate the private data structures for all ports. Well, for all
 826            one ports. */
 827
 828         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 829         if (!priv)
 830                 return 1; /* error */
 831         usb_set_serial_port_data(serial->port[0], priv);
 832         init_waitqueue_head(&serial->port[0]->write_wait);
 833         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 834         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 835         priv->serial = serial;
 836         priv->port = serial->port[0];
 837         return 0;
 838 }
 839
 840 static void keyspan_pda_release(struct usb_serial *serial)
 841 {
 842         dbg("%s", __func__);
 843
 844         kfree(usb_get_serial_port_data(serial->port[0]));
 845 }
 846
 847 #ifdef KEYSPAN
 848 static struct usb_serial_driver keyspan_pda_fake_device = {
 849         .driver = {
 850                 .owner =        THIS_MODULE,
 851                 .name =         "keyspan_pda_pre",
 852         },
 853         .description =          "Keyspan PDA - (prerenumeration)",
 854         .usb_driver =           &keyspan_pda_driver,
 855         .id_table =             id_table_fake,
 856         .num_ports =            1,
 857         .attach =               keyspan_pda_fake_startup,
 858 };
 859 #endif
 860
 861 #ifdef XIRCOM
 862 static struct usb_serial_driver xircom_pgs_fake_device = {
 863         .driver = {
 864                 .owner =        THIS_MODULE,
 865                 .name =         "xircom_no_firm",
 866         },
 867         .description =          "Xircom / Entregra PGS - (prerenumeration)",
 868         .usb_driver =           &keyspan_pda_driver,
 869         .id_table =             id_table_fake_xircom,
 870         .num_ports =            1,
 871         .attach =               keyspan_pda_fake_startup,
 872 };
 873 #endif
 874
 875 static struct usb_serial_driver keyspan_pda_device = {
 876         .driver = {
 877                 .owner =        THIS_MODULE,
 878                 .name =         "keyspan_pda",
 879         },
 880         .description =          "Keyspan PDA",
 881         .usb_driver =           &keyspan_pda_driver,
 882         .id_table =             id_table_std,
 883         .num_ports =            1,
 884         .dtr_rts =              keyspan_pda_dtr_rts,
 885         .carrier_raised =       keyspan_pda_carrier_raised,
 886         .open =                 keyspan_pda_open,
 887         .close =                keyspan_pda_close,
 888         .write =                keyspan_pda_write,
 889         .write_room =           keyspan_pda_write_room,
 890         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 891         .read_int_callback =    keyspan_pda_rx_interrupt,
 892         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 893         .throttle =             keyspan_pda_rx_throttle,
 894         .unthrottle =           keyspan_pda_rx_unthrottle,
 895         .set_termios =          keyspan_pda_set_termios,
 896         .break_ctl =            keyspan_pda_break_ctl,
 897         .tiocmget =             keyspan_pda_tiocmget,
 898         .tiocmset =             keyspan_pda_tiocmset,
 899         .attach =               keyspan_pda_startup,
 900         .release =              keyspan_pda_release,
 901 };
 902
 903
 904 static int __init keyspan_pda_init(void)
 905 {
 906         int retval;
 907         retval = usb_serial_register(&keyspan_pda_device);
 908         if (retval)
 909                 goto failed_pda_register;
 910 #ifdef KEYSPAN
 911         retval = usb_serial_register(&keyspan_pda_fake_device);
 912         if (retval)
 913                 goto failed_pda_fake_register;
 914 #endif
 915 #ifdef XIRCOM
 916         retval = usb_serial_register(&xircom_pgs_fake_device);
 917         if (retval)
 918                 goto failed_xircom_register;
 919 #endif
 920         retval = usb_register(&keyspan_pda_driver);
 921         if (retval)
 922                 goto failed_usb_register;
 923         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 924                DRIVER_DESC "\n");
 925         return 0;
 926 failed_usb_register:
 927 #ifdef XIRCOM
 928         usb_serial_deregister(&xircom_pgs_fake_device);
 929 failed_xircom_register:
 930 #endif /* XIRCOM */
 931 #ifdef KEYSPAN
 932         usb_serial_deregister(&keyspan_pda_fake_device);
 933 #endif
 934 #ifdef KEYSPAN
 935 failed_pda_fake_register:
 936 #endif
 937         usb_serial_deregister(&keyspan_pda_device);
 938 failed_pda_register:
 939         return retval;
 940 }
 941
 942
 943 static void __exit keyspan_pda_exit(void)
 944 {
 945         usb_deregister(&keyspan_pda_driver);
 946         usb_serial_deregister(&keyspan_pda_device);
 947 #ifdef KEYSPAN
 948         usb_serial_deregister(&keyspan_pda_fake_device);
 949 #endif
 950 #ifdef XIRCOM
 951         usb_serial_deregister(&xircom_pgs_fake_device);
 952 #endif
 953 }
 954
 955
 956 module_init(keyspan_pda_init);
 957 module_exit(keyspan_pda_exit);
 958
 959 MODULE_AUTHOR(DRIVER_AUTHOR);
 960 MODULE_DESCRIPTION(DRIVER_DESC);
 961 MODULE_LICENSE("GPL");
 962
 963 module_param(debug, bool, S_IRUGO | S_IWUSR);
 964 MODULE_PARM_DESC(debug, "Debug enabled or not");
 965