drivers/usb/serial/keyspan_pda.c

   1 /*
   2  * USB Keyspan PDA / Xircom / Entregra Converter driver
   3  *
   4  * Copyright (C) 1999 - 2001 Greg Kroah-Hartman <greg@kroah.com>
   5  * Copyright (C) 1999, 2000 Brian Warner        <warner@lothar.com>
   6  * Copyright (C) 2000 Al Borchers               <borchers@steinerpoint.com>
   7  *
   8  *      This program is free software; you can redistribute it and/or modify
   9  *      it under the terms of the GNU General Public License as published by
  10  *      the Free Software Foundation; either version 2 of the License, or
  11  *      (at your option) any later version.
  12  *
  13  * See Documentation/usb/usb-serial.txt for more information on using this
  14  * driver
  15  *
  16  * (09/07/2001) gkh
  17  *      cleaned up the Xircom support.  Added ids for Entregra device which is
  18  *      the same as the Xircom device.  Enabled the code to be compiled for
  19  *      either Xircom or Keyspan devices.
  20  *
  21  * (08/11/2001) Cristian M. Craciunescu
  22  *      support for Xircom PGSDB9
  23  *
  24  * (05/31/2001) gkh
  25  *      switched from using spinlock to a semaphore, which fixes lots of
  26  *      problems.
  27  *
  28  * (04/08/2001) gb
  29  *      Identify version on module load.
  30  *
  31  * (11/01/2000) Adam J. Richter
  32  *      usb_device_id table support
  33  *
  34  * (10/05/2000) gkh
  35  *      Fixed bug with urb->dev not being set properly, now that the usb
  36  *      core needs it.
  37  *
  38  * (08/28/2000) gkh
  39  *      Added locks for SMP safeness.
  40  *      Fixed MOD_INC and MOD_DEC logic and the ability to open a port more
  41  *      than once.
  42  *
  43  * (07/20/2000) borchers
  44  *      - keyspan_pda_write no longer sleeps if it is called on interrupt time;
  45  *        PPP and the line discipline with stty echo on can call write on
  46  *        interrupt time and this would cause an oops if write slept
  47  *      - if keyspan_pda_write is in an interrupt, it will not call
  48  *        usb_control_msg (which sleeps) to query the room in the device
  49  *        buffer, it simply uses the current room value it has
  50  *      - if the urb is busy or if it is throttled keyspan_pda_write just
  51  *        returns 0, rather than sleeping to wait for this to change; the
  52  *        write_chan code in n_tty.c will sleep if needed before calling
  53  *        keyspan_pda_write again
  54  *      - if the device needs to be unthrottled, write now queues up the
  55  *        call to usb_control_msg (which sleeps) to unthrottle the device
  56  *      - the wakeups from keyspan_pda_write_bulk_callback are queued rather
  57  *        than done directly from the callback to avoid the race in write_chan
  58  *      - keyspan_pda_chars_in_buffer also indicates its buffer is full if the
  59  *        urb status is -EINPROGRESS, meaning it cannot write at the moment
  60  *
  61  * (07/19/2000) gkh
  62  *      Added module_init and module_exit functions to handle the fact that this
  63  *      driver is a loadable module now.
  64  *
  65  * (03/26/2000) gkh
  66  *      Split driver up into device specific pieces.
  67  *
  68  */
  69
  70
  71 #include <linux/kernel.h>
  72 #include <linux/errno.h>
  73 #include <linux/init.h>
  74 #include <linux/slab.h>
  75 #include <linux/tty.h>
  76 #include <linux/tty_driver.h>
  77 #include <linux/tty_flip.h>
  78 #include <linux/module.h>
  79 #include <linux/spinlock.h>
  80 #include <linux/workqueue.h>
  81 #include <linux/firmware.h>
  82 #include <linux/ihex.h>
  83 #include <linux/uaccess.h>
  84 #include <linux/usb.h>
  85 #include <linux/usb/serial.h>
  86
  87 static int debug;
  88
  89 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */
  90 #if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
  91         #define KEYSPAN
  92 #else
  93         #undef KEYSPAN
  94 #endif
  95 #if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
  96         #define XIRCOM
  97 #else
  98         #undef XIRCOM
  99 #endif
 100
 101 /*
 102  * Version Information
 103  */
 104 #define DRIVER_VERSION "v1.1"
 105 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
 106 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
 107
 108 struct keyspan_pda_private {
 109         int                     tx_room;
 110         int                     tx_throttled;
 111         struct work_struct                      wakeup_work;
 112         struct work_struct                      unthrottle_work;
 113         struct usb_serial       *serial;
 114         struct usb_serial_port  *port;
 115 };
 116
 117
 118 #define KEYSPAN_VENDOR_ID               0x06cd
 119 #define KEYSPAN_PDA_FAKE_ID             0x0103
 120 #define KEYSPAN_PDA_ID                  0x0104 /* no clue */
 121
 122 /* For Xircom PGSDB9 and older Entregra version of the same device */
 123 #define XIRCOM_VENDOR_ID                0x085a
 124 #define XIRCOM_FAKE_ID                  0x8027
 125 #define ENTREGRA_VENDOR_ID              0x1645
 126 #define ENTREGRA_FAKE_ID                0x8093
 127
 128 static struct usb_device_id id_table_combined [] = {
 129 #ifdef KEYSPAN
 130         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 131 #endif
 132 #ifdef XIRCOM
 133         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 134         { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
 135 #endif
 136         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 137         { }                                             /* Terminating entry */
 138 };
 139
 140 MODULE_DEVICE_TABLE(usb, id_table_combined);
 141
 142 static struct usb_driver keyspan_pda_driver = {
 143         .name =         "keyspan_pda",
 144         .probe =        usb_serial_probe,
 145         .disconnect =   usb_serial_disconnect,
 146         .id_table =     id_table_combined,
 147         .no_dynamic_id =        1,
 148 };
 149
 150 static struct usb_device_id id_table_std [] = {
 151         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 152         { }                                             /* Terminating entry */
 153 };
 154
 155 #ifdef KEYSPAN
 156 static struct usb_device_id id_table_fake [] = {
 157         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 158         { }                                             /* Terminating entry */
 159 };
 160 #endif
 161
 162 #ifdef XIRCOM
 163 static struct usb_device_id id_table_fake_xircom [] = {
 164         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 165         { USB_DEVICE(ENTREGRA_VENDOR_ID, ENTREGRA_FAKE_ID) },
 166         { }
 167 };
 168 #endif
 169
 170 static void keyspan_pda_wakeup_write(struct work_struct *work)
 171 {
 172         struct keyspan_pda_private *priv =
 173                 container_of(work, struct keyspan_pda_private, wakeup_work);
 174         struct usb_serial_port *port = priv->port;
 175
 176         tty_wakeup(port->port.tty);
 177 }
 178
 179 static void keyspan_pda_request_unthrottle(struct work_struct *work)
 180 {
 181         struct keyspan_pda_private *priv =
 182                 container_of(work, struct keyspan_pda_private, unthrottle_work);
 183         struct usb_serial *serial = priv->serial;
 184         int result;
 185
 186         dbg(" request_unthrottle");
 187         /* ask the device to tell us when the tx buffer becomes
 188            sufficiently empty */
 189         result = usb_control_msg(serial->dev,
 190                                  usb_sndctrlpipe(serial->dev, 0),
 191                                  7, /* request_unthrottle */
 192                                  USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 193                                  | USB_DIR_OUT,
 194                                  16, /* value: threshold */
 195                                  0, /* index */
 196                                  NULL,
 197                                  0,
 198                                  2000);
 199         if (result < 0)
 200                 dbg("%s - error %d from usb_control_msg",
 201                     __func__, result);
 202 }
 203
 204
 205 static void keyspan_pda_rx_interrupt(struct urb *urb)
 206 {
 207         struct usb_serial_port *port = urb->context;
 208         struct tty_struct *tty = port->port.tty;
 209         unsigned char *data = urb->transfer_buffer;
 210         int retval;
 211         int status = urb->status;
 212         struct keyspan_pda_private *priv;
 213         priv = usb_get_serial_port_data(port);
 214
 215         switch (status) {
 216         case 0:
 217                 /* success */
 218                 break;
 219         case -ECONNRESET:
 220         case -ENOENT:
 221         case -ESHUTDOWN:
 222                 /* this urb is terminated, clean up */
 223                 dbg("%s - urb shutting down with status: %d",
 224                     __func__, status);
 225                 return;
 226         default:
 227                 dbg("%s - nonzero urb status received: %d",
 228                     __func__, status);
 229                 goto exit;
 230         }
 231
 232         /* see if the message is data or a status interrupt */
 233         switch (data[0]) {
 234         case 0:
 235                 /* rest of message is rx data */
 236                 if (urb->actual_length) {
 237                         tty_insert_flip_string(tty, data + 1,
 238                                                 urb->actual_length - 1);
 239                         tty_flip_buffer_push(tty);
 240                 }
 241                 break;
 242         case 1:
 243                 /* status interrupt */
 244                 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
 245                 switch (data[1]) {
 246                 case 1: /* modemline change */
 247                         break;
 248                 case 2: /* tx unthrottle interrupt */
 249                         priv->tx_throttled = 0;
 250                         /* queue up a wakeup at scheduler time */
 251                         schedule_work(&priv->wakeup_work);
 252                         break;
 253                 default:
 254                         break;
 255                 }
 256                 break;
 257         default:
 258                 break;
 259         }
 260
 261 exit:
 262         retval = usb_submit_urb(urb, GFP_ATOMIC);
 263         if (retval)
 264                 err("%s - usb_submit_urb failed with result %d",
 265                      __func__, retval);
 266 }
 267
 268
 269 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 270 {
 271         /* stop receiving characters. We just turn off the URB request, and
 272            let chars pile up in the device. If we're doing hardware
 273            flowcontrol, the device will signal the other end when its buffer
 274            fills up. If we're doing XON/XOFF, this would be a good time to
 275            send an XOFF, although it might make sense to foist that off
 276            upon the device too. */
 277         struct usb_serial_port *port = tty->driver_data;
 278         dbg("keyspan_pda_rx_throttle port %d", port->number);
 279         usb_kill_urb(port->interrupt_in_urb);
 280 }
 281
 282
 283 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 284 {
 285         struct usb_serial_port *port = tty->driver_data;
 286         /* just restart the receive interrupt URB */
 287         dbg("keyspan_pda_rx_unthrottle port %d", port->number);
 288         port->interrupt_in_urb->dev = port->serial->dev;
 289         if (usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC))
 290                 dbg(" usb_submit_urb(read urb) failed");
 291         return;
 292 }
 293
 294
 295 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
 296 {
 297         int rc;
 298         int bindex;
 299
 300         switch (baud) {
 301         case 110:
 302                 bindex = 0;
 303                 break;
 304         case 300:
 305                 bindex = 1;
 306                 break;
 307         case 1200:
 308                 bindex = 2;
 309                 break;
 310         case 2400:
 311                 bindex = 3;
 312                 break;
 313         case 4800:
 314                 bindex = 4;
 315                 break;
 316         case 9600:
 317                 bindex = 5;
 318                 break;
 319         case 19200:
 320                 bindex = 6;
 321                 break;
 322         case 38400:
 323                 bindex = 7;
 324                 break;
 325         case 57600:
 326                 bindex = 8;
 327                 break;
 328         case 115200:
 329                 bindex = 9;
 330                 break;
 331         default:
 332                 bindex = 5;     /* Default to 9600 */
 333                 baud = 9600;
 334         }
 335
 336         /* rather than figure out how to sleep while waiting for this
 337            to complete, I just use the "legacy" API. */
 338         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 339                              0, /* set baud */
 340                              USB_TYPE_VENDOR
 341                              | USB_RECIP_INTERFACE
 342                              | USB_DIR_OUT, /* type */
 343                              bindex, /* value */
 344                              0, /* index */
 345                              NULL, /* &data */
 346                              0, /* size */
 347                              2000); /* timeout */
 348         if (rc < 0)
 349                 return 0;
 350         return baud;
 351 }
 352
 353
 354 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 355 {
 356         struct usb_serial_port *port = tty->driver_data;
 357         struct usb_serial *serial = port->serial;
 358         int value;
 359         int result;
 360
 361         if (break_state == -1)
 362                 value = 1; /* start break */
 363         else
 364                 value = 0; /* clear break */
 365         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 366                         4, /* set break */
 367                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
 368                         value, 0, NULL, 0, 2000);
 369         if (result < 0)
 370                 dbg("%s - error %d from usb_control_msg",
 371                     __func__, result);
 372         /* there is something funky about this.. the TCSBRK that 'cu' performs
 373            ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
 374            seconds apart, but it feels like the break sent isn't as long as it
 375            is on /dev/ttyS0 */
 376 }
 377
 378
 379 static void keyspan_pda_set_termios(struct tty_struct *tty,
 380                 struct usb_serial_port *port, struct ktermios *old_termios)
 381 {
 382         struct usb_serial *serial = port->serial;
 383         speed_t speed;
 384
 385         /* cflag specifies lots of stuff: number of stop bits, parity, number
 386            of data bits, baud. What can the device actually handle?:
 387            CSTOPB (1 stop bit or 2)
 388            PARENB (parity)
 389            CSIZE (5bit .. 8bit)
 390            There is minimal hw support for parity (a PSW bit seems to hold the
 391            parity of whatever is in the accumulator). The UART either deals
 392            with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
 393            1 special, stop). So, with firmware changes, we could do:
 394            8N1: 10 bit
 395            8N2: 11 bit, extra bit always (mark?)
 396            8[EOMS]1: 11 bit, extra bit is parity
 397            7[EOMS]1: 10 bit, b0/b7 is parity
 398            7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
 399
 400            HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
 401            bit.
 402
 403            For now, just do baud. */
 404
 405         speed = tty_get_baud_rate(tty);
 406         speed = keyspan_pda_setbaud(serial, speed);
 407
 408         if (speed == 0) {
 409                 dbg("can't handle requested baud rate");
 410                 /* It hasn't changed so.. */
 411                 speed = tty_termios_baud_rate(old_termios);
 412         }
 413         /* Only speed can change so copy the old h/w parameters
 414            then encode the new speed */
 415         tty_termios_copy_hw(tty->termios, old_termios);
 416         tty_encode_baud_rate(tty, speed, speed);
 417 }
 418
 419
 420 /* modem control pins: DTR and RTS are outputs and can be controlled.
 421    DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
 422    read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
 423
 424 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
 425                                       unsigned char *value)
 426 {
 427         int rc;
 428         unsigned char data;
 429         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 430                              3, /* get pins */
 431                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
 432                              0, 0, &data, 1, 2000);
 433         if (rc >= 0)
 434                 *value = data;
 435         return rc;
 436 }
 437
 438
 439 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 440                                       unsigned char value)
 441 {
 442         int rc;
 443         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 444                              3, /* set pins */
 445                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 446                              value, 0, NULL, 0, 2000);
 447         return rc;
 448 }
 449
 450 static int keyspan_pda_tiocmget(struct tty_struct *tty, struct file *file)
 451 {
 452         struct usb_serial_port *port = tty->driver_data;
 453         struct usb_serial *serial = port->serial;
 454         int rc;
 455         unsigned char status;
 456         int value;
 457
 458         rc = keyspan_pda_get_modem_info(serial, &status);
 459         if (rc < 0)
 460                 return rc;
 461         value =
 462                 ((status & (1<<7)) ? TIOCM_DTR : 0) |
 463                 ((status & (1<<6)) ? TIOCM_CAR : 0) |
 464                 ((status & (1<<5)) ? TIOCM_RNG : 0) |
 465                 ((status & (1<<4)) ? TIOCM_DSR : 0) |
 466                 ((status & (1<<3)) ? TIOCM_CTS : 0) |
 467                 ((status & (1<<2)) ? TIOCM_RTS : 0);
 468         return value;
 469 }
 470
 471 static int keyspan_pda_tiocmset(struct tty_struct *tty, struct file *file,
 472                                 unsigned int set, unsigned int clear)
 473 {
 474         struct usb_serial_port *port = tty->driver_data;
 475         struct usb_serial *serial = port->serial;
 476         int rc;
 477         unsigned char status;
 478
 479         rc = keyspan_pda_get_modem_info(serial, &status);
 480         if (rc < 0)
 481                 return rc;
 482
 483         if (set & TIOCM_RTS)
 484                 status |= (1<<2);
 485         if (set & TIOCM_DTR)
 486                 status |= (1<<7);
 487
 488         if (clear & TIOCM_RTS)
 489                 status &= ~(1<<2);
 490         if (clear & TIOCM_DTR)
 491                 status &= ~(1<<7);
 492         rc = keyspan_pda_set_modem_info(serial, status);
 493         return rc;
 494 }
 495
 496 static int keyspan_pda_write(struct tty_struct *tty,
 497         struct usb_serial_port *port, const unsigned char *buf, int count)
 498 {
 499         struct usb_serial *serial = port->serial;
 500         int request_unthrottle = 0;
 501         int rc = 0;
 502         struct keyspan_pda_private *priv;
 503
 504         priv = usb_get_serial_port_data(port);
 505         /* guess how much room is left in the device's ring buffer, and if we
 506            want to send more than that, check first, updating our notion of
 507            what is left. If our write will result in no room left, ask the
 508            device to give us an interrupt when the room available rises above
 509            a threshold, and hold off all writers (eventually, those using
 510            select() or poll() too) until we receive that unthrottle interrupt.
 511            Block if we can't write anything at all, otherwise write as much as
 512            we can. */
 513         dbg("keyspan_pda_write(%d)", count);
 514         if (count == 0) {
 515                 dbg(" write request of 0 bytes");
 516                 return 0;
 517         }
 518
 519         /* we might block because of:
 520            the TX urb is in-flight (wait until it completes)
 521            the device is full (wait until it says there is room)
 522         */
 523         spin_lock_bh(&port->lock);
 524         if (port->write_urb_busy || priv->tx_throttled) {
 525                 spin_unlock_bh(&port->lock);
 526                 return 0;
 527         }
 528         port->write_urb_busy = 1;
 529         spin_unlock_bh(&port->lock);
 530
 531         /* At this point the URB is in our control, nobody else can submit it
 532            again (the only sudden transition was the one from EINPROGRESS to
 533            finished).  Also, the tx process is not throttled. So we are
 534            ready to write. */
 535
 536         count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
 537
 538         /* Check if we might overrun the Tx buffer.   If so, ask the
 539            device how much room it really has.  This is done only on
 540            scheduler time, since usb_control_msg() sleeps. */
 541         if (count > priv->tx_room && !in_interrupt()) {
 542                 unsigned char room;
 543                 rc = usb_control_msg(serial->dev,
 544                                      usb_rcvctrlpipe(serial->dev, 0),
 545                                      6, /* write_room */
 546                                      USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 547                                      | USB_DIR_IN,
 548                                      0, /* value: 0 means "remaining room" */
 549                                      0, /* index */
 550                                      &room,
 551                                      1,
 552                                      2000);
 553                 if (rc < 0) {
 554                         dbg(" roomquery failed");
 555                         goto exit;
 556                 }
 557                 if (rc == 0) {
 558                         dbg(" roomquery returned 0 bytes");
 559                         rc = -EIO; /* device didn't return any data */
 560                         goto exit;
 561                 }
 562                 dbg(" roomquery says %d", room);
 563                 priv->tx_room = room;
 564         }
 565         if (count > priv->tx_room) {
 566                 /* we're about to completely fill the Tx buffer, so
 567                    we'll be throttled afterwards. */
 568                 count = priv->tx_room;
 569                 request_unthrottle = 1;
 570         }
 571
 572         if (count) {
 573                 /* now transfer data */
 574                 memcpy(port->write_urb->transfer_buffer, buf, count);
 575                 /* send the data out the bulk port */
 576                 port->write_urb->transfer_buffer_length = count;
 577
 578                 priv->tx_room -= count;
 579
 580                 port->write_urb->dev = port->serial->dev;
 581                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 582                 if (rc) {
 583                         dbg(" usb_submit_urb(write bulk) failed");
 584                         goto exit;
 585                 }
 586         } else {
 587                 /* There wasn't any room left, so we are throttled until
 588                    the buffer empties a bit */
 589                 request_unthrottle = 1;
 590         }
 591
 592         if (request_unthrottle) {
 593                 priv->tx_throttled = 1; /* block writers */
 594                 schedule_work(&priv->unthrottle_work);
 595         }
 596
 597         rc = count;
 598 exit:
 599         if (rc < 0)
 600                 port->write_urb_busy = 0;
 601         return rc;
 602 }
 603
 604
 605 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 606 {
 607         struct usb_serial_port *port = urb->context;
 608         struct keyspan_pda_private *priv;
 609
 610         port->write_urb_busy = 0;
 611         priv = usb_get_serial_port_data(port);
 612
 613         /* queue up a wakeup at scheduler time */
 614         schedule_work(&priv->wakeup_work);
 615 }
 616
 617
 618 static int keyspan_pda_write_room(struct tty_struct *tty)
 619 {
 620         struct usb_serial_port *port = tty->driver_data;
 621         struct keyspan_pda_private *priv;
 622         priv = usb_get_serial_port_data(port);
 623         /* used by n_tty.c for processing of tabs and such. Giving it our
 624            conservative guess is probably good enough, but needs testing by
 625            running a console through the device. */
 626         return priv->tx_room;
 627 }
 628
 629
 630 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 631 {
 632         struct usb_serial_port *port = tty->driver_data;
 633         struct keyspan_pda_private *priv;
 634         unsigned long flags;
 635         int ret = 0;
 636
 637         priv = usb_get_serial_port_data(port);
 638
 639         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 640            n_tty.c:normal_poll() ) that we're not writeable. */
 641
 642         spin_lock_irqsave(&port->lock, flags);
 643         if (port->write_urb_busy || priv->tx_throttled)
 644                 ret = 256;
 645         spin_unlock_irqrestore(&port->lock, flags);
 646         return ret;
 647 }
 648
 649
 650 static int keyspan_pda_open(struct tty_struct *tty,
 651                         struct usb_serial_port *port, struct file *filp)
 652 {
 653         struct usb_serial *serial = port->serial;
 654         unsigned char room;
 655         int rc = 0;
 656         struct keyspan_pda_private *priv;
 657
 658         /* find out how much room is in the Tx ring */
 659         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 660                              6, /* write_room */
 661                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 662                              | USB_DIR_IN,
 663                              0, /* value */
 664                              0, /* index */
 665                              &room,
 666                              1,
 667                              2000);
 668         if (rc < 0) {
 669                 dbg("%s - roomquery failed", __func__);
 670                 goto error;
 671         }
 672         if (rc == 0) {
 673                 dbg("%s - roomquery returned 0 bytes", __func__);
 674                 rc = -EIO;
 675                 goto error;
 676         }
 677         priv = usb_get_serial_port_data(port);
 678         priv->tx_room = room;
 679         priv->tx_throttled = room ? 0 : 1;
 680
 681         /* the normal serial device seems to always turn on DTR and RTS here,
 682            so do the same */
 683         if (tty && (tty->termios->c_cflag & CBAUD))
 684                 keyspan_pda_set_modem_info(serial, (1<<7) | (1<<2));
 685         else
 686                 keyspan_pda_set_modem_info(serial, 0);
 687
 688         /*Start reading from the device*/
 689         port->interrupt_in_urb->dev = serial->dev;
 690         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 691         if (rc) {
 692                 dbg("%s - usb_submit_urb(read int) failed", __func__);
 693                 goto error;
 694         }
 695
 696 error:
 697         return rc;
 698 }
 699
 700
 701 static void keyspan_pda_close(struct tty_struct *tty,
 702                         struct usb_serial_port *port, struct file *filp)
 703 {
 704         struct usb_serial *serial = port->serial;
 705
 706         if (serial->dev) {
 707                 /* the normal serial device seems to always shut
 708                    off DTR and RTS now */
 709                 if (tty->termios->c_cflag & HUPCL)
 710                         keyspan_pda_set_modem_info(serial, 0);
 711
 712                 /* shutdown our bulk reads and writes */
 713                 usb_kill_urb(port->write_urb);
 714                 usb_kill_urb(port->interrupt_in_urb);
 715         }
 716 }
 717
 718
 719 /* download the firmware to a "fake" device (pre-renumeration) */
 720 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 721 {
 722         int response;
 723         const char *fw_name;
 724         const struct ihex_binrec *record;
 725         const struct firmware *fw;
 726
 727         /* download the firmware here ... */
 728         response = ezusb_set_reset(serial, 1);
 729
 730         if (0) { ; }
 731 #ifdef KEYSPAN
 732         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 733                 fw_name = "keyspan_pda/keyspan_pda.fw";
 734 #endif
 735 #ifdef XIRCOM
 736         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 737                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGRA_VENDOR_ID))
 738                 fw_name = "keyspan_pda/xircom_pgs.fw";
 739 #endif
 740         else {
 741                 err("%s: unknown vendor, aborting.", __func__);
 742                 return -ENODEV;
 743         }
 744         if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
 745                 err("failed to load firmware \"%s\"\n", fw_name);
 746                 return -ENOENT;
 747         }
 748         record = (const struct ihex_binrec *)fw->data;
 749
 750         while (record) {
 751                 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
 752                                              (unsigned char *)record->data,
 753                                              be16_to_cpu(record->len), 0xa0);
 754                 if (response < 0) {
 755                         err("ezusb_writememory failed for Keyspan PDA "
 756                             "firmware (%d %04X %p %d)",
 757                             response, be32_to_cpu(record->addr),
 758                             record->data, be16_to_cpu(record->len));
 759                         break;
 760                 }
 761                 record = ihex_next_binrec(record);
 762         }
 763         release_firmware(fw);
 764         /* bring device out of reset. Renumeration will occur in a moment
 765            and the new device will bind to the real driver */
 766         response = ezusb_set_reset(serial, 0);
 767
 768         /* we want this device to fail to have a driver assigned to it. */
 769         return 1;
 770 }
 771
 772 static int keyspan_pda_startup(struct usb_serial *serial)
 773 {
 774
 775         struct keyspan_pda_private *priv;
 776
 777         /* allocate the private data structures for all ports. Well, for all
 778            one ports. */
 779
 780         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 781         if (!priv)
 782                 return 1; /* error */
 783         usb_set_serial_port_data(serial->port[0], priv);
 784         init_waitqueue_head(&serial->port[0]->write_wait);
 785         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 786         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 787         priv->serial = serial;
 788         priv->port = serial->port[0];
 789         return 0;
 790 }
 791
 792 static void keyspan_pda_shutdown(struct usb_serial *serial)
 793 {
 794         dbg("%s", __func__);
 795
 796         kfree(usb_get_serial_port_data(serial->port[0]));
 797 }
 798
 799 #ifdef KEYSPAN
 800 static struct usb_serial_driver keyspan_pda_fake_device = {
 801         .driver = {
 802                 .owner =        THIS_MODULE,
 803                 .name =         "keyspan_pda_pre",
 804         },
 805         .description =          "Keyspan PDA - (prerenumeration)",
 806         .usb_driver =           &keyspan_pda_driver,
 807         .id_table =             id_table_fake,
 808         .num_ports =            1,
 809         .attach =               keyspan_pda_fake_startup,
 810 };
 811 #endif
 812
 813 #ifdef XIRCOM
 814 static struct usb_serial_driver xircom_pgs_fake_device = {
 815         .driver = {
 816                 .owner =        THIS_MODULE,
 817                 .name =         "xircom_no_firm",
 818         },
 819         .description =          "Xircom / Entregra PGS - (prerenumeration)",
 820         .usb_driver =           &keyspan_pda_driver,
 821         .id_table =             id_table_fake_xircom,
 822         .num_ports =            1,
 823         .attach =               keyspan_pda_fake_startup,
 824 };
 825 #endif
 826
 827 static struct usb_serial_driver keyspan_pda_device = {
 828         .driver = {
 829                 .owner =        THIS_MODULE,
 830                 .name =         "keyspan_pda",
 831         },
 832         .description =          "Keyspan PDA",
 833         .usb_driver =           &keyspan_pda_driver,
 834         .id_table =             id_table_std,
 835         .num_ports =            1,
 836         .open =                 keyspan_pda_open,
 837         .close =                keyspan_pda_close,
 838         .write =                keyspan_pda_write,
 839         .write_room =           keyspan_pda_write_room,
 840         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 841         .read_int_callback =    keyspan_pda_rx_interrupt,
 842         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 843         .throttle =             keyspan_pda_rx_throttle,
 844         .unthrottle =           keyspan_pda_rx_unthrottle,
 845         .set_termios =          keyspan_pda_set_termios,
 846         .break_ctl =            keyspan_pda_break_ctl,
 847         .tiocmget =             keyspan_pda_tiocmget,
 848         .tiocmset =             keyspan_pda_tiocmset,
 849         .attach =               keyspan_pda_startup,
 850         .shutdown =             keyspan_pda_shutdown,
 851 };
 852
 853
 854 static int __init keyspan_pda_init(void)
 855 {
 856         int retval;
 857         retval = usb_serial_register(&keyspan_pda_device);
 858         if (retval)
 859                 goto failed_pda_register;
 860 #ifdef KEYSPAN
 861         retval = usb_serial_register(&keyspan_pda_fake_device);
 862         if (retval)
 863                 goto failed_pda_fake_register;
 864 #endif
 865 #ifdef XIRCOM
 866         retval = usb_serial_register(&xircom_pgs_fake_device);
 867         if (retval)
 868                 goto failed_xircom_register;
 869 #endif
 870         retval = usb_register(&keyspan_pda_driver);
 871         if (retval)
 872                 goto failed_usb_register;
 873         info(DRIVER_DESC " " DRIVER_VERSION);
 874         return 0;
 875 failed_usb_register:
 876 #ifdef XIRCOM
 877         usb_serial_deregister(&xircom_pgs_fake_device);
 878 failed_xircom_register:
 879 #endif /* XIRCOM */
 880 #ifdef KEYSPAN
 881         usb_serial_deregister(&keyspan_pda_fake_device);
 882 #endif
 883 #ifdef KEYSPAN
 884 failed_pda_fake_register:
 885 #endif
 886         usb_serial_deregister(&keyspan_pda_device);
 887 failed_pda_register:
 888         return retval;
 889 }
 890
 891
 892 static void __exit keyspan_pda_exit(void)
 893 {
 894         usb_deregister(&keyspan_pda_driver);
 895         usb_serial_deregister(&keyspan_pda_device);
 896 #ifdef KEYSPAN
 897         usb_serial_deregister(&keyspan_pda_fake_device);
 898 #endif
 899 #ifdef XIRCOM
 900         usb_serial_deregister(&xircom_pgs_fake_device);
 901 #endif
 902 }
 903
 904
 905 module_init(keyspan_pda_init);
 906 module_exit(keyspan_pda_exit);
 907
 908 MODULE_AUTHOR(DRIVER_AUTHOR);
 909 MODULE_DESCRIPTION(DRIVER_DESC);
 910 MODULE_LICENSE("GPL");
 911
 912 module_param(debug, bool, S_IRUGO | S_IWUSR);
 913 MODULE_PARM_DESC(debug, "Debug enabled or not");
 914