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