drivers/usb/serial/keyspan_pda.c

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