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 }
 296
 297
 298 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
 299 {
 300         int rc;
 301         int bindex;
 302
 303         switch (baud) {
 304         case 110:
 305                 bindex = 0;
 306                 break;
 307         case 300:
 308                 bindex = 1;
 309                 break;
 310         case 1200:
 311                 bindex = 2;
 312                 break;
 313         case 2400:
 314                 bindex = 3;
 315                 break;
 316         case 4800:
 317                 bindex = 4;
 318                 break;
 319         case 9600:
 320                 bindex = 5;
 321                 break;
 322         case 19200:
 323                 bindex = 6;
 324                 break;
 325         case 38400:
 326                 bindex = 7;
 327                 break;
 328         case 57600:
 329                 bindex = 8;
 330                 break;
 331         case 115200:
 332                 bindex = 9;
 333                 break;
 334         default:
 335                 bindex = 5;     /* Default to 9600 */
 336                 baud = 9600;
 337         }
 338
 339         /* rather than figure out how to sleep while waiting for this
 340            to complete, I just use the "legacy" API. */
 341         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 342                              0, /* set baud */
 343                              USB_TYPE_VENDOR
 344                              | USB_RECIP_INTERFACE
 345                              | USB_DIR_OUT, /* type */
 346                              bindex, /* value */
 347                              0, /* index */
 348                              NULL, /* &data */
 349                              0, /* size */
 350                              2000); /* timeout */
 351         if (rc < 0)
 352                 return 0;
 353         return baud;
 354 }
 355
 356
 357 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 358 {
 359         struct usb_serial_port *port = tty->driver_data;
 360         struct usb_serial *serial = port->serial;
 361         int value;
 362         int result;
 363
 364         if (break_state == -1)
 365                 value = 1; /* start break */
 366         else
 367                 value = 0; /* clear break */
 368         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 369                         4, /* set break */
 370                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
 371                         value, 0, NULL, 0, 2000);
 372         if (result < 0)
 373                 dbg("%s - error %d from usb_control_msg",
 374                     __func__, result);
 375         /* there is something funky about this.. the TCSBRK that 'cu' performs
 376            ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
 377            seconds apart, but it feels like the break sent isn't as long as it
 378            is on /dev/ttyS0 */
 379 }
 380
 381
 382 static void keyspan_pda_set_termios(struct tty_struct *tty,
 383                 struct usb_serial_port *port, struct ktermios *old_termios)
 384 {
 385         struct usb_serial *serial = port->serial;
 386         speed_t speed;
 387
 388         /* cflag specifies lots of stuff: number of stop bits, parity, number
 389            of data bits, baud. What can the device actually handle?:
 390            CSTOPB (1 stop bit or 2)
 391            PARENB (parity)
 392            CSIZE (5bit .. 8bit)
 393            There is minimal hw support for parity (a PSW bit seems to hold the
 394            parity of whatever is in the accumulator). The UART either deals
 395            with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
 396            1 special, stop). So, with firmware changes, we could do:
 397            8N1: 10 bit
 398            8N2: 11 bit, extra bit always (mark?)
 399            8[EOMS]1: 11 bit, extra bit is parity
 400            7[EOMS]1: 10 bit, b0/b7 is parity
 401            7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
 402
 403            HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
 404            bit.
 405
 406            For now, just do baud. */
 407
 408         speed = tty_get_baud_rate(tty);
 409         speed = keyspan_pda_setbaud(serial, speed);
 410
 411         if (speed == 0) {
 412                 dbg("can't handle requested baud rate");
 413                 /* It hasn't changed so.. */
 414                 speed = tty_termios_baud_rate(old_termios);
 415         }
 416         /* Only speed can change so copy the old h/w parameters
 417            then encode the new speed */
 418         tty_termios_copy_hw(tty->termios, old_termios);
 419         tty_encode_baud_rate(tty, speed, speed);
 420 }
 421
 422
 423 /* modem control pins: DTR and RTS are outputs and can be controlled.
 424    DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
 425    read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
 426
 427 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
 428                                       unsigned char *value)
 429 {
 430         int rc;
 431         u8 *data;
 432
 433         data = kmalloc(1, GFP_KERNEL);
 434         if (!data)
 435                 return -ENOMEM;
 436
 437         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 438                              3, /* get pins */
 439                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
 440                              0, 0, data, 1, 2000);
 441         if (rc >= 0)
 442                 *value = *data;
 443
 444         kfree(data);
 445         return rc;
 446 }
 447
 448
 449 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 450                                       unsigned char value)
 451 {
 452         int rc;
 453         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 454                              3, /* set pins */
 455                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 456                              value, 0, NULL, 0, 2000);
 457         return rc;
 458 }
 459
 460 static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
 461 {
 462         struct usb_serial_port *port = tty->driver_data;
 463         struct usb_serial *serial = port->serial;
 464         int rc;
 465         unsigned char status;
 466         int value;
 467
 468         rc = keyspan_pda_get_modem_info(serial, &status);
 469         if (rc < 0)
 470                 return rc;
 471         value =
 472                 ((status & (1<<7)) ? TIOCM_DTR : 0) |
 473                 ((status & (1<<6)) ? TIOCM_CAR : 0) |
 474                 ((status & (1<<5)) ? TIOCM_RNG : 0) |
 475                 ((status & (1<<4)) ? TIOCM_DSR : 0) |
 476                 ((status & (1<<3)) ? TIOCM_CTS : 0) |
 477                 ((status & (1<<2)) ? TIOCM_RTS : 0);
 478         return value;
 479 }
 480
 481 static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
 482                                 unsigned int set, unsigned int clear)
 483 {
 484         struct usb_serial_port *port = tty->driver_data;
 485         struct usb_serial *serial = port->serial;
 486         int rc;
 487         unsigned char status;
 488
 489         rc = keyspan_pda_get_modem_info(serial, &status);
 490         if (rc < 0)
 491                 return rc;
 492
 493         if (set & TIOCM_RTS)
 494                 status |= (1<<2);
 495         if (set & TIOCM_DTR)
 496                 status |= (1<<7);
 497
 498         if (clear & TIOCM_RTS)
 499                 status &= ~(1<<2);
 500         if (clear & TIOCM_DTR)
 501                 status &= ~(1<<7);
 502         rc = keyspan_pda_set_modem_info(serial, status);
 503         return rc;
 504 }
 505
 506 static int keyspan_pda_write(struct tty_struct *tty,
 507         struct usb_serial_port *port, const unsigned char *buf, int count)
 508 {
 509         struct usb_serial *serial = port->serial;
 510         int request_unthrottle = 0;
 511         int rc = 0;
 512         struct keyspan_pda_private *priv;
 513
 514         priv = usb_get_serial_port_data(port);
 515         /* guess how much room is left in the device's ring buffer, and if we
 516            want to send more than that, check first, updating our notion of
 517            what is left. If our write will result in no room left, ask the
 518            device to give us an interrupt when the room available rises above
 519            a threshold, and hold off all writers (eventually, those using
 520            select() or poll() too) until we receive that unthrottle interrupt.
 521            Block if we can't write anything at all, otherwise write as much as
 522            we can. */
 523         dbg("keyspan_pda_write(%d)", count);
 524         if (count == 0) {
 525                 dbg(" write request of 0 bytes");
 526                 return 0;
 527         }
 528
 529         /* we might block because of:
 530            the TX urb is in-flight (wait until it completes)
 531            the device is full (wait until it says there is room)
 532         */
 533         spin_lock_bh(&port->lock);
 534         if (port->write_urb_busy || priv->tx_throttled) {
 535                 spin_unlock_bh(&port->lock);
 536                 return 0;
 537         }
 538         port->write_urb_busy = 1;
 539         spin_unlock_bh(&port->lock);
 540
 541         /* At this point the URB is in our control, nobody else can submit it
 542            again (the only sudden transition was the one from EINPROGRESS to
 543            finished).  Also, the tx process is not throttled. So we are
 544            ready to write. */
 545
 546         count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
 547
 548         /* Check if we might overrun the Tx buffer.   If so, ask the
 549            device how much room it really has.  This is done only on
 550            scheduler time, since usb_control_msg() sleeps. */
 551         if (count > priv->tx_room && !in_interrupt()) {
 552                 u8 *room;
 553
 554                 room = kmalloc(1, GFP_KERNEL);
 555                 if (!room) {
 556                         rc = -ENOMEM;
 557                         goto exit;
 558                 }
 559
 560                 rc = usb_control_msg(serial->dev,
 561                                      usb_rcvctrlpipe(serial->dev, 0),
 562                                      6, /* write_room */
 563                                      USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 564                                      | USB_DIR_IN,
 565                                      0, /* value: 0 means "remaining room" */
 566                                      0, /* index */
 567                                      room,
 568                                      1,
 569                                      2000);
 570                 if (rc > 0) {
 571                         dbg(" roomquery says %d", *room);
 572                         priv->tx_room = *room;
 573                 }
 574                 kfree(room);
 575                 if (rc < 0) {
 576                         dbg(" roomquery failed");
 577                         goto exit;
 578                 }
 579                 if (rc == 0) {
 580                         dbg(" roomquery returned 0 bytes");
 581                         rc = -EIO; /* device didn't return any data */
 582                         goto exit;
 583                 }
 584         }
 585         if (count > priv->tx_room) {
 586                 /* we're about to completely fill the Tx buffer, so
 587                    we'll be throttled afterwards. */
 588                 count = priv->tx_room;
 589                 request_unthrottle = 1;
 590         }
 591
 592         if (count) {
 593                 /* now transfer data */
 594                 memcpy(port->write_urb->transfer_buffer, buf, count);
 595                 /* send the data out the bulk port */
 596                 port->write_urb->transfer_buffer_length = count;
 597
 598                 priv->tx_room -= count;
 599
 600                 port->write_urb->dev = port->serial->dev;
 601                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 602                 if (rc) {
 603                         dbg(" usb_submit_urb(write bulk) failed");
 604                         goto exit;
 605                 }
 606         } else {
 607                 /* There wasn't any room left, so we are throttled until
 608                    the buffer empties a bit */
 609                 request_unthrottle = 1;
 610         }
 611
 612         if (request_unthrottle) {
 613                 priv->tx_throttled = 1; /* block writers */
 614                 schedule_work(&priv->unthrottle_work);
 615         }
 616
 617         rc = count;
 618 exit:
 619         if (rc < 0)
 620                 port->write_urb_busy = 0;
 621         return rc;
 622 }
 623
 624
 625 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 626 {
 627         struct usb_serial_port *port = urb->context;
 628         struct keyspan_pda_private *priv;
 629
 630         port->write_urb_busy = 0;
 631         priv = usb_get_serial_port_data(port);
 632
 633         /* queue up a wakeup at scheduler time */
 634         schedule_work(&priv->wakeup_work);
 635 }
 636
 637
 638 static int keyspan_pda_write_room(struct tty_struct *tty)
 639 {
 640         struct usb_serial_port *port = tty->driver_data;
 641         struct keyspan_pda_private *priv;
 642         priv = usb_get_serial_port_data(port);
 643         /* used by n_tty.c for processing of tabs and such. Giving it our
 644            conservative guess is probably good enough, but needs testing by
 645            running a console through the device. */
 646         return priv->tx_room;
 647 }
 648
 649
 650 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 651 {
 652         struct usb_serial_port *port = tty->driver_data;
 653         struct keyspan_pda_private *priv;
 654         unsigned long flags;
 655         int ret = 0;
 656
 657         priv = usb_get_serial_port_data(port);
 658
 659         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 660            n_tty.c:normal_poll() ) that we're not writeable. */
 661
 662         spin_lock_irqsave(&port->lock, flags);
 663         if (port->write_urb_busy || priv->tx_throttled)
 664                 ret = 256;
 665         spin_unlock_irqrestore(&port->lock, flags);
 666         return ret;
 667 }
 668
 669
 670 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 671 {
 672         struct usb_serial *serial = port->serial;
 673
 674         if (serial->dev) {
 675                 if (on)
 676                         keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
 677                 else
 678                         keyspan_pda_set_modem_info(serial, 0);
 679         }
 680 }
 681
 682
 683 static int keyspan_pda_open(struct tty_struct *tty,
 684                                         struct usb_serial_port *port)
 685 {
 686         struct usb_serial *serial = port->serial;
 687         u8 *room;
 688         int rc = 0;
 689         struct keyspan_pda_private *priv;
 690
 691         /* find out how much room is in the Tx ring */
 692         room = kmalloc(1, GFP_KERNEL);
 693         if (!room)
 694                 return -ENOMEM;
 695
 696         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 697                              6, /* write_room */
 698                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 699                              | USB_DIR_IN,
 700                              0, /* value */
 701                              0, /* index */
 702                              room,
 703                              1,
 704                              2000);
 705         if (rc < 0) {
 706                 dbg("%s - roomquery failed", __func__);
 707                 goto error;
 708         }
 709         if (rc == 0) {
 710                 dbg("%s - roomquery returned 0 bytes", __func__);
 711                 rc = -EIO;
 712                 goto error;
 713         }
 714         priv = usb_get_serial_port_data(port);
 715         priv->tx_room = *room;
 716         priv->tx_throttled = *room ? 0 : 1;
 717
 718         /*Start reading from the device*/
 719         port->interrupt_in_urb->dev = serial->dev;
 720         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 721         if (rc) {
 722                 dbg("%s - usb_submit_urb(read int) failed", __func__);
 723                 goto error;
 724         }
 725 error:
 726         kfree(room);
 727         return rc;
 728 }
 729 static void keyspan_pda_close(struct usb_serial_port *port)
 730 {
 731         struct usb_serial *serial = port->serial;
 732
 733         if (serial->dev) {
 734                 /* shutdown our bulk reads and writes */
 735                 usb_kill_urb(port->write_urb);
 736                 usb_kill_urb(port->interrupt_in_urb);
 737         }
 738 }
 739
 740
 741 /* download the firmware to a "fake" device (pre-renumeration) */
 742 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 743 {
 744         int response;
 745         const char *fw_name;
 746         const struct ihex_binrec *record;
 747         const struct firmware *fw;
 748
 749         /* download the firmware here ... */
 750         response = ezusb_set_reset(serial, 1);
 751
 752         if (0) { ; }
 753 #ifdef KEYSPAN
 754         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 755                 fw_name = "keyspan_pda/keyspan_pda.fw";
 756 #endif
 757 #ifdef XIRCOM
 758         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 759                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
 760                 fw_name = "keyspan_pda/xircom_pgs.fw";
 761 #endif
 762         else {
 763                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 764                         __func__);
 765                 return -ENODEV;
 766         }
 767         if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
 768                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 769                         fw_name);
 770                 return -ENOENT;
 771         }
 772         record = (const struct ihex_binrec *)fw->data;
 773
 774         while (record) {
 775                 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
 776                                              (unsigned char *)record->data,
 777                                              be16_to_cpu(record->len), 0xa0);
 778                 if (response < 0) {
 779                         dev_err(&serial->dev->dev, "ezusb_writememory failed "
 780                                 "for Keyspan PDA firmware (%d %04X %p %d)\n",
 781                                 response, be32_to_cpu(record->addr),
 782                                 record->data, be16_to_cpu(record->len));
 783                         break;
 784                 }
 785                 record = ihex_next_binrec(record);
 786         }
 787         release_firmware(fw);
 788         /* bring device out of reset. Renumeration will occur in a moment
 789            and the new device will bind to the real driver */
 790         response = ezusb_set_reset(serial, 0);
 791
 792         /* we want this device to fail to have a driver assigned to it. */
 793         return 1;
 794 }
 795
 796 #ifdef KEYSPAN
 797 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 798 #endif
 799 #ifdef XIRCOM
 800 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 801 #endif
 802
 803 static int keyspan_pda_startup(struct usb_serial *serial)
 804 {
 805
 806         struct keyspan_pda_private *priv;
 807
 808         /* allocate the private data structures for all ports. Well, for all
 809            one ports. */
 810
 811         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 812         if (!priv)
 813                 return 1; /* error */
 814         usb_set_serial_port_data(serial->port[0], priv);
 815         init_waitqueue_head(&serial->port[0]->write_wait);
 816         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 817         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 818         priv->serial = serial;
 819         priv->port = serial->port[0];
 820         return 0;
 821 }
 822
 823 static void keyspan_pda_release(struct usb_serial *serial)
 824 {
 825         dbg("%s", __func__);
 826
 827         kfree(usb_get_serial_port_data(serial->port[0]));
 828 }
 829
 830 #ifdef KEYSPAN
 831 static struct usb_serial_driver keyspan_pda_fake_device = {
 832         .driver = {
 833                 .owner =        THIS_MODULE,
 834                 .name =         "keyspan_pda_pre",
 835         },
 836         .description =          "Keyspan PDA - (prerenumeration)",
 837         .usb_driver =           &keyspan_pda_driver,
 838         .id_table =             id_table_fake,
 839         .num_ports =            1,
 840         .attach =               keyspan_pda_fake_startup,
 841 };
 842 #endif
 843
 844 #ifdef XIRCOM
 845 static struct usb_serial_driver xircom_pgs_fake_device = {
 846         .driver = {
 847                 .owner =        THIS_MODULE,
 848                 .name =         "xircom_no_firm",
 849         },
 850         .description =          "Xircom / Entregra PGS - (prerenumeration)",
 851         .usb_driver =           &keyspan_pda_driver,
 852         .id_table =             id_table_fake_xircom,
 853         .num_ports =            1,
 854         .attach =               keyspan_pda_fake_startup,
 855 };
 856 #endif
 857
 858 static struct usb_serial_driver keyspan_pda_device = {
 859         .driver = {
 860                 .owner =        THIS_MODULE,
 861                 .name =         "keyspan_pda",
 862         },
 863         .description =          "Keyspan PDA",
 864         .usb_driver =           &keyspan_pda_driver,
 865         .id_table =             id_table_std,
 866         .num_ports =            1,
 867         .dtr_rts =              keyspan_pda_dtr_rts,
 868         .open =                 keyspan_pda_open,
 869         .close =                keyspan_pda_close,
 870         .write =                keyspan_pda_write,
 871         .write_room =           keyspan_pda_write_room,
 872         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 873         .read_int_callback =    keyspan_pda_rx_interrupt,
 874         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 875         .throttle =             keyspan_pda_rx_throttle,
 876         .unthrottle =           keyspan_pda_rx_unthrottle,
 877         .set_termios =          keyspan_pda_set_termios,
 878         .break_ctl =            keyspan_pda_break_ctl,
 879         .tiocmget =             keyspan_pda_tiocmget,
 880         .tiocmset =             keyspan_pda_tiocmset,
 881         .attach =               keyspan_pda_startup,
 882         .release =              keyspan_pda_release,
 883 };
 884
 885
 886 static int __init keyspan_pda_init(void)
 887 {
 888         int retval;
 889         retval = usb_serial_register(&keyspan_pda_device);
 890         if (retval)
 891                 goto failed_pda_register;
 892 #ifdef KEYSPAN
 893         retval = usb_serial_register(&keyspan_pda_fake_device);
 894         if (retval)
 895                 goto failed_pda_fake_register;
 896 #endif
 897 #ifdef XIRCOM
 898         retval = usb_serial_register(&xircom_pgs_fake_device);
 899         if (retval)
 900                 goto failed_xircom_register;
 901 #endif
 902         retval = usb_register(&keyspan_pda_driver);
 903         if (retval)
 904                 goto failed_usb_register;
 905         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 906                DRIVER_DESC "\n");
 907         return 0;
 908 failed_usb_register:
 909 #ifdef XIRCOM
 910         usb_serial_deregister(&xircom_pgs_fake_device);
 911 failed_xircom_register:
 912 #endif /* XIRCOM */
 913 #ifdef KEYSPAN
 914         usb_serial_deregister(&keyspan_pda_fake_device);
 915 #endif
 916 #ifdef KEYSPAN
 917 failed_pda_fake_register:
 918 #endif
 919         usb_serial_deregister(&keyspan_pda_device);
 920 failed_pda_register:
 921         return retval;
 922 }
 923
 924
 925 static void __exit keyspan_pda_exit(void)
 926 {
 927         usb_deregister(&keyspan_pda_driver);
 928         usb_serial_deregister(&keyspan_pda_device);
 929 #ifdef KEYSPAN
 930         usb_serial_deregister(&keyspan_pda_fake_device);
 931 #endif
 932 #ifdef XIRCOM
 933         usb_serial_deregister(&xircom_pgs_fake_device);
 934 #endif
 935 }
 936
 937
 938 module_init(keyspan_pda_init);
 939 module_exit(keyspan_pda_exit);
 940
 941 MODULE_AUTHOR(DRIVER_AUTHOR);
 942 MODULE_DESCRIPTION(DRIVER_DESC);
 943 MODULE_LICENSE("GPL");
 944
 945 module_param(debug, bool, S_IRUGO | S_IWUSR);
 946 MODULE_PARM_DESC(debug, "Debug enabled or not");
 947