drivers/usb/serial/keyspan_pda.c

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