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  * Copyright (C) 2020 Johan Hovold <johan@kernel.org>
   9  *
  10  * See Documentation/usb/usb-serial.rst for more information on using this
  11  * driver
  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 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>, Johan Hovold <johan@kernel.org>"
  29 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
  30
  31 #define KEYSPAN_TX_THRESHOLD    128
  32
  33 struct keyspan_pda_private {
  34         int                     tx_room;
  35         struct work_struct      unthrottle_work;
  36         struct usb_serial       *serial;
  37         struct usb_serial_port  *port;
  38 };
  39
  40 static int keyspan_pda_write_start(struct usb_serial_port *port);
  41
  42 #define KEYSPAN_VENDOR_ID               0x06cd
  43 #define KEYSPAN_PDA_FAKE_ID             0x0103
  44 #define KEYSPAN_PDA_ID                  0x0104 /* no clue */
  45
  46 /* For Xircom PGSDB9 and older Entrega version of the same device */
  47 #define XIRCOM_VENDOR_ID                0x085a
  48 #define XIRCOM_FAKE_ID                  0x8027
  49 #define XIRCOM_FAKE_ID_2                0x8025 /* "PGMFHUB" serial */
  50 #define ENTREGA_VENDOR_ID               0x1645
  51 #define ENTREGA_FAKE_ID                 0x8093
  52
  53 static const struct usb_device_id id_table_combined[] = {
  54         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
  55         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
  56         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
  57         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
  58         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
  59         { }                                             /* Terminating entry */
  60 };
  61 MODULE_DEVICE_TABLE(usb, id_table_combined);
  62
  63 static const struct usb_device_id id_table_std[] = {
  64         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
  65         { }                                             /* Terminating entry */
  66 };
  67
  68 static const struct usb_device_id id_table_fake[] = {
  69         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
  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         { }                                             /* Terminating entry */
  74 };
  75
  76 static int keyspan_pda_get_write_room(struct keyspan_pda_private *priv)
  77 {
  78         struct usb_serial_port *port = priv->port;
  79         struct usb_serial *serial = port->serial;
  80         u8 room;
  81         int rc;
  82
  83         rc = usb_control_msg_recv(serial->dev,
  84                                   0,
  85                                   6, /* write_room */
  86                                   USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
  87                                   0, /* value: 0 means "remaining room" */
  88                                   0, /* index */
  89                                   &room,
  90                                   1,
  91                                   2000,
  92                                   GFP_KERNEL);
  93         if (rc) {
  94                 dev_dbg(&port->dev, "roomquery failed: %d\n", rc);
  95                 return rc;
  96         }
  97
  98         dev_dbg(&port->dev, "roomquery says %d\n", room);
  99
 100         return room;
 101 }
 102
 103 static void keyspan_pda_request_unthrottle(struct work_struct *work)
 104 {
 105         struct keyspan_pda_private *priv =
 106                 container_of(work, struct keyspan_pda_private, unthrottle_work);
 107         struct usb_serial_port *port = priv->port;
 108         struct usb_serial *serial = port->serial;
 109         unsigned long flags;
 110         int result;
 111
 112         dev_dbg(&port->dev, "%s\n", __func__);
 113
 114         /*
 115          * Ask the device to tell us when the tx buffer becomes
 116          * sufficiently empty.
 117          */
 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                                  KEYSPAN_TX_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          * Need to check available space after requesting notification in case
 133          * buffer is already empty so that no notification is sent.
 134          */
 135         result = keyspan_pda_get_write_room(priv);
 136         if (result > KEYSPAN_TX_THRESHOLD) {
 137                 spin_lock_irqsave(&port->lock, flags);
 138                 priv->tx_room = max(priv->tx_room, result);
 139                 spin_unlock_irqrestore(&port->lock, flags);
 140
 141                 usb_serial_port_softint(port);
 142         }
 143 }
 144
 145 static void keyspan_pda_rx_interrupt(struct urb *urb)
 146 {
 147         struct usb_serial_port *port = urb->context;
 148         unsigned char *data = urb->transfer_buffer;
 149         unsigned int len = urb->actual_length;
 150         int retval;
 151         int status = urb->status;
 152         struct keyspan_pda_private *priv;
 153         unsigned long flags;
 154
 155         priv = usb_get_serial_port_data(port);
 156
 157         switch (status) {
 158         case 0:
 159                 /* success */
 160                 break;
 161         case -ECONNRESET:
 162         case -ENOENT:
 163         case -ESHUTDOWN:
 164                 /* this urb is terminated, clean up */
 165                 dev_dbg(&urb->dev->dev, "%s - urb shutting down with status: %d\n", __func__, status);
 166                 return;
 167         default:
 168                 dev_dbg(&urb->dev->dev, "%s - nonzero urb status received: %d\n", __func__, status);
 169                 goto exit;
 170         }
 171
 172         if (len < 1) {
 173                 dev_warn(&port->dev, "short message received\n");
 174                 goto exit;
 175         }
 176
 177         /* see if the message is data or a status interrupt */
 178         switch (data[0]) {
 179         case 0:
 180                  /* rest of message is rx data */
 181                 if (len < 2)
 182                         break;
 183                 tty_insert_flip_string(&port->port, data + 1, len - 1);
 184                 tty_flip_buffer_push(&port->port);
 185                 break;
 186         case 1:
 187                 /* status interrupt */
 188                 if (len < 2) {
 189                         dev_warn(&port->dev, "short interrupt message received\n");
 190                         break;
 191                 }
 192                 dev_dbg(&port->dev, "rx int, d1=%d\n", data[1]);
 193                 switch (data[1]) {
 194                 case 1: /* modemline change */
 195                         break;
 196                 case 2: /* tx unthrottle interrupt */
 197                         spin_lock_irqsave(&port->lock, flags);
 198                         priv->tx_room = max(priv->tx_room, KEYSPAN_TX_THRESHOLD);
 199                         spin_unlock_irqrestore(&port->lock, flags);
 200
 201                         keyspan_pda_write_start(port);
 202
 203                         usb_serial_port_softint(port);
 204                         break;
 205                 default:
 206                         break;
 207                 }
 208                 break;
 209         default:
 210                 break;
 211         }
 212
 213 exit:
 214         retval = usb_submit_urb(urb, GFP_ATOMIC);
 215         if (retval)
 216                 dev_err(&port->dev,
 217                         "%s - usb_submit_urb failed with result %d\n",
 218                         __func__, retval);
 219 }
 220
 221 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 222 {
 223         struct usb_serial_port *port = tty->driver_data;
 224
 225         /*
 226          * Stop receiving characters. We just turn off the URB request, and
 227          * let chars pile up in the device. If we're doing hardware
 228          * flowcontrol, the device will signal the other end when its buffer
 229          * fills up. If we're doing XON/XOFF, this would be a good time to
 230          * send an XOFF, although it might make sense to foist that off upon
 231          * the device too.
 232          */
 233         usb_kill_urb(port->interrupt_in_urb);
 234 }
 235
 236 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 237 {
 238         struct usb_serial_port *port = tty->driver_data;
 239
 240         /* just restart the receive interrupt URB */
 241         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
 242                 dev_dbg(&port->dev, "usb_submit_urb(read urb) failed\n");
 243 }
 244
 245 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
 246 {
 247         int rc;
 248         int bindex;
 249
 250         switch (baud) {
 251         case 110:
 252                 bindex = 0;
 253                 break;
 254         case 300:
 255                 bindex = 1;
 256                 break;
 257         case 1200:
 258                 bindex = 2;
 259                 break;
 260         case 2400:
 261                 bindex = 3;
 262                 break;
 263         case 4800:
 264                 bindex = 4;
 265                 break;
 266         case 9600:
 267                 bindex = 5;
 268                 break;
 269         case 19200:
 270                 bindex = 6;
 271                 break;
 272         case 38400:
 273                 bindex = 7;
 274                 break;
 275         case 57600:
 276                 bindex = 8;
 277                 break;
 278         case 115200:
 279                 bindex = 9;
 280                 break;
 281         default:
 282                 bindex = 5;     /* Default to 9600 */
 283                 baud = 9600;
 284         }
 285
 286         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 287                              0, /* set baud */
 288                              USB_TYPE_VENDOR
 289                              | USB_RECIP_INTERFACE
 290                              | USB_DIR_OUT, /* type */
 291                              bindex, /* value */
 292                              0, /* index */
 293                              NULL, /* &data */
 294                              0, /* size */
 295                              2000); /* timeout */
 296         if (rc < 0)
 297                 return 0;
 298
 299         return baud;
 300 }
 301
 302 static int keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 303 {
 304         struct usb_serial_port *port = tty->driver_data;
 305         struct usb_serial *serial = port->serial;
 306         int value;
 307         int result;
 308
 309         if (break_state == -1)
 310                 value = 1; /* start break */
 311         else
 312                 value = 0; /* clear break */
 313
 314         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 315                         4, /* set break */
 316                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
 317                         value, 0, NULL, 0, 2000);
 318         if (result < 0) {
 319                 dev_dbg(&port->dev, "%s - error %d from usb_control_msg\n",
 320                         __func__, result);
 321                 return result;
 322         }
 323
 324         return 0;
 325 }
 326
 327 static void keyspan_pda_set_termios(struct tty_struct *tty,
 328                                     struct usb_serial_port *port,
 329                                     const struct ktermios *old_termios)
 330 {
 331         struct usb_serial *serial = port->serial;
 332         speed_t speed;
 333
 334         /*
 335          * cflag specifies lots of stuff: number of stop bits, parity, number
 336          * of data bits, baud. What can the device actually handle?:
 337          * CSTOPB (1 stop bit or 2)
 338          * PARENB (parity)
 339          * CSIZE (5bit .. 8bit)
 340          * There is minimal hw support for parity (a PSW bit seems to hold the
 341          * parity of whatever is in the accumulator). The UART either deals
 342          * with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
 343          * 1 special, stop). So, with firmware changes, we could do:
 344          * 8N1: 10 bit
 345          * 8N2: 11 bit, extra bit always (mark?)
 346          * 8[EOMS]1: 11 bit, extra bit is parity
 347          * 7[EOMS]1: 10 bit, b0/b7 is parity
 348          * 7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
 349          *
 350          * HW flow control is dictated by the tty->termios.c_cflags & CRTSCTS
 351          * bit.
 352          *
 353          * For now, just do baud.
 354          */
 355         speed = tty_get_baud_rate(tty);
 356         speed = keyspan_pda_setbaud(serial, speed);
 357
 358         if (speed == 0) {
 359                 dev_dbg(&port->dev, "can't handle requested baud rate\n");
 360                 /* It hasn't changed so.. */
 361                 speed = tty_termios_baud_rate(old_termios);
 362         }
 363         /*
 364          * Only speed can change so copy the old h/w parameters then encode
 365          * the new speed.
 366          */
 367         tty_termios_copy_hw(&tty->termios, old_termios);
 368         tty_encode_baud_rate(tty, speed, speed);
 369 }
 370
 371 /*
 372  * Modem control pins: DTR and RTS are outputs and can be controlled.
 373  * DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
 374  * read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused.
 375  */
 376 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
 377                                       unsigned char *value)
 378 {
 379         int rc;
 380         u8 data;
 381
 382         rc = usb_control_msg_recv(serial->dev, 0,
 383                                   3, /* get pins */
 384                                   USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_IN,
 385                                   0,
 386                                   0,
 387                                   &data,
 388                                   1,
 389                                   2000,
 390                                   GFP_KERNEL);
 391         if (rc == 0)
 392                 *value = data;
 393
 394         return rc;
 395 }
 396
 397 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 398                                       unsigned char value)
 399 {
 400         int rc;
 401         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 402                              3, /* set pins */
 403                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 404                              value, 0, NULL, 0, 2000);
 405         return rc;
 406 }
 407
 408 static int keyspan_pda_tiocmget(struct tty_struct *tty)
 409 {
 410         struct usb_serial_port *port = tty->driver_data;
 411         struct usb_serial *serial = port->serial;
 412         int rc;
 413         unsigned char status;
 414         int value;
 415
 416         rc = keyspan_pda_get_modem_info(serial, &status);
 417         if (rc < 0)
 418                 return rc;
 419
 420         value = ((status & BIT(7)) ? TIOCM_DTR : 0) |
 421                 ((status & BIT(6)) ? TIOCM_CAR : 0) |
 422                 ((status & BIT(5)) ? TIOCM_RNG : 0) |
 423                 ((status & BIT(4)) ? TIOCM_DSR : 0) |
 424                 ((status & BIT(3)) ? TIOCM_CTS : 0) |
 425                 ((status & BIT(2)) ? TIOCM_RTS : 0);
 426
 427         return value;
 428 }
 429
 430 static int keyspan_pda_tiocmset(struct tty_struct *tty,
 431                                 unsigned int set, unsigned int clear)
 432 {
 433         struct usb_serial_port *port = tty->driver_data;
 434         struct usb_serial *serial = port->serial;
 435         int rc;
 436         unsigned char status;
 437
 438         rc = keyspan_pda_get_modem_info(serial, &status);
 439         if (rc < 0)
 440                 return rc;
 441
 442         if (set & TIOCM_RTS)
 443                 status |= BIT(2);
 444         if (set & TIOCM_DTR)
 445                 status |= BIT(7);
 446
 447         if (clear & TIOCM_RTS)
 448                 status &= ~BIT(2);
 449         if (clear & TIOCM_DTR)
 450                 status &= ~BIT(7);
 451         rc = keyspan_pda_set_modem_info(serial, status);
 452         return rc;
 453 }
 454
 455 static int keyspan_pda_write_start(struct usb_serial_port *port)
 456 {
 457         struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
 458         unsigned long flags;
 459         struct urb *urb;
 460         int count;
 461         int room;
 462         int rc;
 463
 464         /*
 465          * Guess how much room is left in the device's ring buffer. If our
 466          * write will result in no room left, ask the device to give us an
 467          * interrupt when the room available rises above a threshold but also
 468          * query how much room is currently available (in case our guess was
 469          * too conservative and the buffer is already empty when the
 470          * unthrottle work is scheduled).
 471          */
 472
 473         /*
 474          * We might block because of:
 475          * the TX urb is in-flight (wait until it completes)
 476          * the device is full (wait until it says there is room)
 477          */
 478         spin_lock_irqsave(&port->lock, flags);
 479
 480         room = priv->tx_room;
 481         count = kfifo_len(&port->write_fifo);
 482
 483         if (!test_bit(0, &port->write_urbs_free) || count == 0 || room == 0) {
 484                 spin_unlock_irqrestore(&port->lock, flags);
 485                 return 0;
 486         }
 487         __clear_bit(0, &port->write_urbs_free);
 488
 489         if (count > room)
 490                 count = room;
 491         if (count > port->bulk_out_size)
 492                 count = port->bulk_out_size;
 493
 494         urb = port->write_urb;
 495         count = kfifo_out(&port->write_fifo, urb->transfer_buffer, count);
 496         urb->transfer_buffer_length = count;
 497
 498         port->tx_bytes += count;
 499         priv->tx_room -= count;
 500
 501         spin_unlock_irqrestore(&port->lock, flags);
 502
 503         dev_dbg(&port->dev, "%s - count = %d, txroom = %d\n", __func__, count, room);
 504
 505         rc = usb_submit_urb(urb, GFP_ATOMIC);
 506         if (rc) {
 507                 dev_dbg(&port->dev, "usb_submit_urb(write bulk) failed\n");
 508
 509                 spin_lock_irqsave(&port->lock, flags);
 510                 port->tx_bytes -= count;
 511                 priv->tx_room = max(priv->tx_room, room + count);
 512                 __set_bit(0, &port->write_urbs_free);
 513                 spin_unlock_irqrestore(&port->lock, flags);
 514
 515                 return rc;
 516         }
 517
 518         if (count == room)
 519                 schedule_work(&priv->unthrottle_work);
 520
 521         return count;
 522 }
 523
 524 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 525 {
 526         struct usb_serial_port *port = urb->context;
 527         unsigned long flags;
 528
 529         spin_lock_irqsave(&port->lock, flags);
 530         port->tx_bytes -= urb->transfer_buffer_length;
 531         __set_bit(0, &port->write_urbs_free);
 532         spin_unlock_irqrestore(&port->lock, flags);
 533
 534         keyspan_pda_write_start(port);
 535
 536         usb_serial_port_softint(port);
 537 }
 538
 539 static int keyspan_pda_write(struct tty_struct *tty, struct usb_serial_port *port,
 540                 const unsigned char *buf, int count)
 541 {
 542         int rc;
 543
 544         dev_dbg(&port->dev, "%s - count = %d\n", __func__, count);
 545
 546         if (!count)
 547                 return 0;
 548
 549         count = kfifo_in_locked(&port->write_fifo, buf, count, &port->lock);
 550
 551         rc = keyspan_pda_write_start(port);
 552         if (rc)
 553                 return rc;
 554
 555         return count;
 556 }
 557
 558 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 559 {
 560         struct usb_serial *serial = port->serial;
 561
 562         if (on)
 563                 keyspan_pda_set_modem_info(serial, BIT(7) | BIT(2));
 564         else
 565                 keyspan_pda_set_modem_info(serial, 0);
 566 }
 567
 568
 569 static int keyspan_pda_open(struct tty_struct *tty,
 570                                         struct usb_serial_port *port)
 571 {
 572         struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
 573         int rc;
 574
 575         /* find out how much room is in the Tx ring */
 576         rc = keyspan_pda_get_write_room(priv);
 577         if (rc < 0)
 578                 return rc;
 579
 580         spin_lock_irq(&port->lock);
 581         priv->tx_room = rc;
 582         spin_unlock_irq(&port->lock);
 583
 584         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 585         if (rc) {
 586                 dev_dbg(&port->dev, "%s - usb_submit_urb(read int) failed\n", __func__);
 587                 return rc;
 588         }
 589
 590         return 0;
 591 }
 592
 593 static void keyspan_pda_close(struct usb_serial_port *port)
 594 {
 595         struct keyspan_pda_private *priv = usb_get_serial_port_data(port);
 596
 597         /*
 598          * Stop the interrupt URB first as its completion handler may submit
 599          * the write URB.
 600          */
 601         usb_kill_urb(port->interrupt_in_urb);
 602         usb_kill_urb(port->write_urb);
 603
 604         cancel_work_sync(&priv->unthrottle_work);
 605
 606         spin_lock_irq(&port->lock);
 607         kfifo_reset(&port->write_fifo);
 608         spin_unlock_irq(&port->lock);
 609 }
 610
 611 /* download the firmware to a "fake" device (pre-renumeration) */
 612 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 613 {
 614         unsigned int vid = le16_to_cpu(serial->dev->descriptor.idVendor);
 615         const char *fw_name;
 616
 617         /* download the firmware here ... */
 618         ezusb_fx1_set_reset(serial->dev, 1);
 619
 620         switch (vid) {
 621         case KEYSPAN_VENDOR_ID:
 622                 fw_name = "keyspan_pda/keyspan_pda.fw";
 623                 break;
 624         case XIRCOM_VENDOR_ID:
 625         case ENTREGA_VENDOR_ID:
 626                 fw_name = "keyspan_pda/xircom_pgs.fw";
 627                 break;
 628         default:
 629                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 630                         __func__);
 631                 return -ENODEV;
 632         }
 633
 634         if (ezusb_fx1_ihex_firmware_download(serial->dev, fw_name) < 0) {
 635                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 636                         fw_name);
 637                 return -ENOENT;
 638         }
 639
 640         /*
 641          * After downloading firmware renumeration will occur in a moment and
 642          * the new device will bind to the real driver.
 643          */
 644
 645         /* We want this device to fail to have a driver assigned to it. */
 646         return 1;
 647 }
 648
 649 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 650 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 651
 652 static int keyspan_pda_port_probe(struct usb_serial_port *port)
 653 {
 654
 655         struct keyspan_pda_private *priv;
 656
 657         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 658         if (!priv)
 659                 return -ENOMEM;
 660
 661         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 662         priv->port = port;
 663
 664         usb_set_serial_port_data(port, priv);
 665
 666         return 0;
 667 }
 668
 669 static void keyspan_pda_port_remove(struct usb_serial_port *port)
 670 {
 671         struct keyspan_pda_private *priv;
 672
 673         priv = usb_get_serial_port_data(port);
 674         kfree(priv);
 675 }
 676
 677 static struct usb_serial_driver keyspan_pda_fake_device = {
 678         .driver = {
 679                 .name =         "keyspan_pda_pre",
 680         },
 681         .description =          "Keyspan PDA - (prerenumeration)",
 682         .id_table =             id_table_fake,
 683         .num_ports =            1,
 684         .attach =               keyspan_pda_fake_startup,
 685 };
 686
 687 static struct usb_serial_driver keyspan_pda_device = {
 688         .driver = {
 689                 .name =         "keyspan_pda",
 690         },
 691         .description =          "Keyspan PDA",
 692         .id_table =             id_table_std,
 693         .num_ports =            1,
 694         .num_bulk_out =         1,
 695         .num_interrupt_in =     1,
 696         .dtr_rts =              keyspan_pda_dtr_rts,
 697         .open =                 keyspan_pda_open,
 698         .close =                keyspan_pda_close,
 699         .write =                keyspan_pda_write,
 700         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 701         .read_int_callback =    keyspan_pda_rx_interrupt,
 702         .throttle =             keyspan_pda_rx_throttle,
 703         .unthrottle =           keyspan_pda_rx_unthrottle,
 704         .set_termios =          keyspan_pda_set_termios,
 705         .break_ctl =            keyspan_pda_break_ctl,
 706         .tiocmget =             keyspan_pda_tiocmget,
 707         .tiocmset =             keyspan_pda_tiocmset,
 708         .port_probe =           keyspan_pda_port_probe,
 709         .port_remove =          keyspan_pda_port_remove,
 710 };
 711
 712 static struct usb_serial_driver * const serial_drivers[] = {
 713         &keyspan_pda_device,
 714         &keyspan_pda_fake_device,
 715         NULL
 716 };
 717
 718 module_usb_serial_driver(serial_drivers, id_table_combined);
 719
 720 MODULE_AUTHOR(DRIVER_AUTHOR);
 721 MODULE_DESCRIPTION(DRIVER_DESC);
 722 MODULE_LICENSE("GPL");