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