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