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