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