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