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