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         if (tty)
 177                 tty_wakeup(tty);
 178         tty_kref_put(tty);
 179 }
 180
 181 static void keyspan_pda_request_unthrottle(struct work_struct *work)
 182 {
 183         struct keyspan_pda_private *priv =
 184                 container_of(work, struct keyspan_pda_private, unthrottle_work);
 185         struct usb_serial *serial = priv->serial;
 186         int result;
 187
 188         dbg(" request_unthrottle");
 189         /* ask the device to tell us when the tx buffer becomes
 190            sufficiently empty */
 191         result = usb_control_msg(serial->dev,
 192                                  usb_sndctrlpipe(serial->dev, 0),
 193                                  7, /* request_unthrottle */
 194                                  USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 195                                  | USB_DIR_OUT,
 196                                  16, /* value: threshold */
 197                                  0, /* index */
 198                                  NULL,
 199                                  0,
 200                                  2000);
 201         if (result < 0)
 202                 dbg("%s - error %d from usb_control_msg",
 203                     __func__, result);
 204 }
 205
 206
 207 static void keyspan_pda_rx_interrupt(struct urb *urb)
 208 {
 209         struct usb_serial_port *port = urb->context;
 210         struct tty_struct *tty;
 211         unsigned char *data = urb->transfer_buffer;
 212         int retval;
 213         int status = urb->status;
 214         struct keyspan_pda_private *priv;
 215         priv = usb_get_serial_port_data(port);
 216
 217         switch (status) {
 218         case 0:
 219                 /* success */
 220                 break;
 221         case -ECONNRESET:
 222         case -ENOENT:
 223         case -ESHUTDOWN:
 224                 /* this urb is terminated, clean up */
 225                 dbg("%s - urb shutting down with status: %d",
 226                     __func__, status);
 227                 return;
 228         default:
 229                 dbg("%s - nonzero urb status received: %d",
 230                     __func__, status);
 231                 goto exit;
 232         }
 233
 234         /* see if the message is data or a status interrupt */
 235         switch (data[0]) {
 236         case 0:
 237                 tty = tty_port_tty_get(&port->port);
 238                  /* rest of message is rx data */
 239                 if (tty && urb->actual_length) {
 240                         tty_insert_flip_string(tty, data + 1,
 241                                                 urb->actual_length - 1);
 242                         tty_flip_buffer_push(tty);
 243                 }
 244                 tty_kref_put(tty);
 245                 break;
 246         case 1:
 247                 /* status interrupt */
 248                 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
 249                 switch (data[1]) {
 250                 case 1: /* modemline change */
 251                         break;
 252                 case 2: /* tx unthrottle interrupt */
 253                         priv->tx_throttled = 0;
 254                         /* queue up a wakeup at scheduler time */
 255                         schedule_work(&priv->wakeup_work);
 256                         break;
 257                 default:
 258                         break;
 259                 }
 260                 break;
 261         default:
 262                 break;
 263         }
 264
 265 exit:
 266         retval = usb_submit_urb(urb, GFP_ATOMIC);
 267         if (retval)
 268                 dev_err(&port->dev,
 269                         "%s - usb_submit_urb failed with result %d",
 270                         __func__, retval);
 271 }
 272
 273
 274 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 275 {
 276         /* stop receiving characters. We just turn off the URB request, and
 277            let chars pile up in the device. If we're doing hardware
 278            flowcontrol, the device will signal the other end when its buffer
 279            fills up. If we're doing XON/XOFF, this would be a good time to
 280            send an XOFF, although it might make sense to foist that off
 281            upon the device too. */
 282         struct usb_serial_port *port = tty->driver_data;
 283         dbg("keyspan_pda_rx_throttle port %d", port->number);
 284         usb_kill_urb(port->interrupt_in_urb);
 285 }
 286
 287
 288 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 289 {
 290         struct usb_serial_port *port = tty->driver_data;
 291         /* just restart the receive interrupt URB */
 292         dbg("keyspan_pda_rx_unthrottle port %d", port->number);
 293         port->interrupt_in_urb->dev = port->serial->dev;
 294         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
 295                 dbg(" usb_submit_urb(read urb) failed");
 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)
 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,
 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
 684 static int keyspan_pda_open(struct tty_struct *tty,
 685                                         struct usb_serial_port *port)
 686 {
 687         struct usb_serial *serial = port->serial;
 688         u8 *room;
 689         int rc = 0;
 690         struct keyspan_pda_private *priv;
 691
 692         /* find out how much room is in the Tx ring */
 693         room = kmalloc(1, GFP_KERNEL);
 694         if (!room)
 695                 return -ENOMEM;
 696
 697         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 698                              6, /* write_room */
 699                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 700                              | USB_DIR_IN,
 701                              0, /* value */
 702                              0, /* index */
 703                              room,
 704                              1,
 705                              2000);
 706         if (rc < 0) {
 707                 dbg("%s - roomquery failed", __func__);
 708                 goto error;
 709         }
 710         if (rc == 0) {
 711                 dbg("%s - roomquery returned 0 bytes", __func__);
 712                 rc = -EIO;
 713                 goto error;
 714         }
 715         priv = usb_get_serial_port_data(port);
 716         priv->tx_room = *room;
 717         priv->tx_throttled = *room ? 0 : 1;
 718
 719         /*Start reading from the device*/
 720         port->interrupt_in_urb->dev = serial->dev;
 721         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 722         if (rc) {
 723                 dbg("%s - usb_submit_urb(read int) failed", __func__);
 724                 goto error;
 725         }
 726 error:
 727         kfree(room);
 728         return rc;
 729 }
 730 static void keyspan_pda_close(struct usb_serial_port *port)
 731 {
 732         struct usb_serial *serial = port->serial;
 733
 734         if (serial->dev) {
 735                 /* shutdown our bulk reads and writes */
 736                 usb_kill_urb(port->write_urb);
 737                 usb_kill_urb(port->interrupt_in_urb);
 738         }
 739 }
 740
 741
 742 /* download the firmware to a "fake" device (pre-renumeration) */
 743 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 744 {
 745         int response;
 746         const char *fw_name;
 747         const struct ihex_binrec *record;
 748         const struct firmware *fw;
 749
 750         /* download the firmware here ... */
 751         response = ezusb_set_reset(serial, 1);
 752
 753         if (0) { ; }
 754 #ifdef KEYSPAN
 755         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 756                 fw_name = "keyspan_pda/keyspan_pda.fw";
 757 #endif
 758 #ifdef XIRCOM
 759         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 760                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
 761                 fw_name = "keyspan_pda/xircom_pgs.fw";
 762 #endif
 763         else {
 764                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 765                         __func__);
 766                 return -ENODEV;
 767         }
 768         if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
 769                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 770                         fw_name);
 771                 return -ENOENT;
 772         }
 773         record = (const struct ihex_binrec *)fw->data;
 774
 775         while (record) {
 776                 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
 777                                              (unsigned char *)record->data,
 778                                              be16_to_cpu(record->len), 0xa0);
 779                 if (response < 0) {
 780                         dev_err(&serial->dev->dev, "ezusb_writememory failed "
 781                                 "for Keyspan PDA firmware (%d %04X %p %d)\n",
 782                                 response, be32_to_cpu(record->addr),
 783                                 record->data, be16_to_cpu(record->len));
 784                         break;
 785                 }
 786                 record = ihex_next_binrec(record);
 787         }
 788         release_firmware(fw);
 789         /* bring device out of reset. Renumeration will occur in a moment
 790            and the new device will bind to the real driver */
 791         response = ezusb_set_reset(serial, 0);
 792
 793         /* we want this device to fail to have a driver assigned to it. */
 794         return 1;
 795 }
 796
 797 #ifdef KEYSPAN
 798 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 799 #endif
 800 #ifdef XIRCOM
 801 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 802 #endif
 803
 804 static int keyspan_pda_startup(struct usb_serial *serial)
 805 {
 806
 807         struct keyspan_pda_private *priv;
 808
 809         /* allocate the private data structures for all ports. Well, for all
 810            one ports. */
 811
 812         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 813         if (!priv)
 814                 return 1; /* error */
 815         usb_set_serial_port_data(serial->port[0], priv);
 816         init_waitqueue_head(&serial->port[0]->write_wait);
 817         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 818         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 819         priv->serial = serial;
 820         priv->port = serial->port[0];
 821         return 0;
 822 }
 823
 824 static void keyspan_pda_release(struct usb_serial *serial)
 825 {
 826         dbg("%s", __func__);
 827
 828         kfree(usb_get_serial_port_data(serial->port[0]));
 829 }
 830
 831 #ifdef KEYSPAN
 832 static struct usb_serial_driver keyspan_pda_fake_device = {
 833         .driver = {
 834                 .owner =        THIS_MODULE,
 835                 .name =         "keyspan_pda_pre",
 836         },
 837         .description =          "Keyspan PDA - (prerenumeration)",
 838         .usb_driver =           &keyspan_pda_driver,
 839         .id_table =             id_table_fake,
 840         .num_ports =            1,
 841         .attach =               keyspan_pda_fake_startup,
 842 };
 843 #endif
 844
 845 #ifdef XIRCOM
 846 static struct usb_serial_driver xircom_pgs_fake_device = {
 847         .driver = {
 848                 .owner =        THIS_MODULE,
 849                 .name =         "xircom_no_firm",
 850         },
 851         .description =          "Xircom / Entregra PGS - (prerenumeration)",
 852         .usb_driver =           &keyspan_pda_driver,
 853         .id_table =             id_table_fake_xircom,
 854         .num_ports =            1,
 855         .attach =               keyspan_pda_fake_startup,
 856 };
 857 #endif
 858
 859 static struct usb_serial_driver keyspan_pda_device = {
 860         .driver = {
 861                 .owner =        THIS_MODULE,
 862                 .name =         "keyspan_pda",
 863         },
 864         .description =          "Keyspan PDA",
 865         .usb_driver =           &keyspan_pda_driver,
 866         .id_table =             id_table_std,
 867         .num_ports =            1,
 868         .dtr_rts =              keyspan_pda_dtr_rts,
 869         .open =                 keyspan_pda_open,
 870         .close =                keyspan_pda_close,
 871         .write =                keyspan_pda_write,
 872         .write_room =           keyspan_pda_write_room,
 873         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 874         .read_int_callback =    keyspan_pda_rx_interrupt,
 875         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 876         .throttle =             keyspan_pda_rx_throttle,
 877         .unthrottle =           keyspan_pda_rx_unthrottle,
 878         .set_termios =          keyspan_pda_set_termios,
 879         .break_ctl =            keyspan_pda_break_ctl,
 880         .tiocmget =             keyspan_pda_tiocmget,
 881         .tiocmset =             keyspan_pda_tiocmset,
 882         .attach =               keyspan_pda_startup,
 883         .release =              keyspan_pda_release,
 884 };
 885
 886
 887 static int __init keyspan_pda_init(void)
 888 {
 889         int retval;
 890         retval = usb_serial_register(&keyspan_pda_device);
 891         if (retval)
 892                 goto failed_pda_register;
 893 #ifdef KEYSPAN
 894         retval = usb_serial_register(&keyspan_pda_fake_device);
 895         if (retval)
 896                 goto failed_pda_fake_register;
 897 #endif
 898 #ifdef XIRCOM
 899         retval = usb_serial_register(&xircom_pgs_fake_device);
 900         if (retval)
 901                 goto failed_xircom_register;
 902 #endif
 903         retval = usb_register(&keyspan_pda_driver);
 904         if (retval)
 905                 goto failed_usb_register;
 906         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 907                DRIVER_DESC "\n");
 908         return 0;
 909 failed_usb_register:
 910 #ifdef XIRCOM
 911         usb_serial_deregister(&xircom_pgs_fake_device);
 912 failed_xircom_register:
 913 #endif /* XIRCOM */
 914 #ifdef KEYSPAN
 915         usb_serial_deregister(&keyspan_pda_fake_device);
 916 #endif
 917 #ifdef KEYSPAN
 918 failed_pda_fake_register:
 919 #endif
 920         usb_serial_deregister(&keyspan_pda_device);
 921 failed_pda_register:
 922         return retval;
 923 }
 924
 925
 926 static void __exit keyspan_pda_exit(void)
 927 {
 928         usb_deregister(&keyspan_pda_driver);
 929         usb_serial_deregister(&keyspan_pda_device);
 930 #ifdef KEYSPAN
 931         usb_serial_deregister(&keyspan_pda_fake_device);
 932 #endif
 933 #ifdef XIRCOM
 934         usb_serial_deregister(&xircom_pgs_fake_device);
 935 #endif
 936 }
 937
 938
 939 module_init(keyspan_pda_init);
 940 module_exit(keyspan_pda_exit);
 941
 942 MODULE_AUTHOR(DRIVER_AUTHOR);
 943 MODULE_DESCRIPTION(DRIVER_DESC);
 944 MODULE_LICENSE("GPL");
 945
 946 module_param(debug, bool, S_IRUGO | S_IWUSR);
 947 MODULE_PARM_DESC(debug, "Debug enabled or not");
 948