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