drivers/usb/serial/keyspan_pda.c

   1 /*
   2  * USB Keyspan PDA / Xircom / Entrega 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  * (09/07/2001) gkh
  17  *      cleaned up the Xircom support.  Added ids for Entregra device which is
  18  *      the same as the Xircom device.  Enabled the code to be compiled for
  19  *      either Xircom or Keyspan devices.
  20  *
  21  * (08/11/2001) Cristian M. Craciunescu
  22  *      support for Xircom PGSDB9
  23  *
  24  * (05/31/2001) gkh
  25  *      switched from using spinlock to a semaphore, which fixes lots of
  26  *      problems.
  27  *
  28  * (04/08/2001) gb
  29  *      Identify version on module load.
  30  *
  31  * (11/01/2000) Adam J. Richter
  32  *      usb_device_id table support
  33  *
  34  * (10/05/2000) gkh
  35  *      Fixed bug with urb->dev not being set properly, now that the usb
  36  *      core needs it.
  37  *
  38  * (08/28/2000) gkh
  39  *      Added locks for SMP safeness.
  40  *      Fixed MOD_INC and MOD_DEC logic and the ability to open a port more
  41  *      than once.
  42  *
  43  * (07/20/2000) borchers
  44  *      - keyspan_pda_write no longer sleeps if it is called on interrupt time;
  45  *        PPP and the line discipline with stty echo on can call write on
  46  *        interrupt time and this would cause an oops if write slept
  47  *      - if keyspan_pda_write is in an interrupt, it will not call
  48  *        usb_control_msg (which sleeps) to query the room in the device
  49  *        buffer, it simply uses the current room value it has
  50  *      - if the urb is busy or if it is throttled keyspan_pda_write just
  51  *        returns 0, rather than sleeping to wait for this to change; the
  52  *        write_chan code in n_tty.c will sleep if needed before calling
  53  *        keyspan_pda_write again
  54  *      - if the device needs to be unthrottled, write now queues up the
  55  *        call to usb_control_msg (which sleeps) to unthrottle the device
  56  *      - the wakeups from keyspan_pda_write_bulk_callback are queued rather
  57  *        than done directly from the callback to avoid the race in write_chan
  58  *      - keyspan_pda_chars_in_buffer also indicates its buffer is full if the
  59  *        urb status is -EINPROGRESS, meaning it cannot write at the moment
  60  *
  61  * (07/19/2000) gkh
  62  *      Added module_init and module_exit functions to handle the fact that this
  63  *      driver is a loadable module now.
  64  *
  65  * (03/26/2000) gkh
  66  *      Split driver up into device specific pieces.
  67  *
  68  */
  69
  70
  71 #include <linux/kernel.h>
  72 #include <linux/errno.h>
  73 #include <linux/init.h>
  74 #include <linux/slab.h>
  75 #include <linux/tty.h>
  76 #include <linux/tty_driver.h>
  77 #include <linux/tty_flip.h>
  78 #include <linux/module.h>
  79 #include <linux/spinlock.h>
  80 #include <linux/workqueue.h>
  81 #include <linux/firmware.h>
  82 #include <linux/ihex.h>
  83 #include <linux/uaccess.h>
  84 #include <linux/usb.h>
  85 #include <linux/usb/serial.h>
  86
  87 static int debug;
  88
  89 /* make a simple define to handle if we are compiling keyspan_pda or xircom support */
  90 #if defined(CONFIG_USB_SERIAL_KEYSPAN_PDA) || defined(CONFIG_USB_SERIAL_KEYSPAN_PDA_MODULE)
  91         #define KEYSPAN
  92 #else
  93         #undef KEYSPAN
  94 #endif
  95 #if defined(CONFIG_USB_SERIAL_XIRCOM) || defined(CONFIG_USB_SERIAL_XIRCOM_MODULE)
  96         #define XIRCOM
  97 #else
  98         #undef XIRCOM
  99 #endif
 100
 101 /*
 102  * Version Information
 103  */
 104 #define DRIVER_VERSION "v1.1"
 105 #define DRIVER_AUTHOR "Brian Warner <warner@lothar.com>"
 106 #define DRIVER_DESC "USB Keyspan PDA Converter driver"
 107
 108 struct keyspan_pda_private {
 109         int                     tx_room;
 110         int                     tx_throttled;
 111         struct work_struct                      wakeup_work;
 112         struct work_struct                      unthrottle_work;
 113         struct usb_serial       *serial;
 114         struct usb_serial_port  *port;
 115 };
 116
 117
 118 #define KEYSPAN_VENDOR_ID               0x06cd
 119 #define KEYSPAN_PDA_FAKE_ID             0x0103
 120 #define KEYSPAN_PDA_ID                  0x0104 /* no clue */
 121
 122 /* For Xircom PGSDB9 and older Entrega version of the same device */
 123 #define XIRCOM_VENDOR_ID                0x085a
 124 #define XIRCOM_FAKE_ID                  0x8027
 125 #define XIRCOM_FAKE_ID_2                0x8025 /* "PGMFHUB" serial */
 126 #define ENTREGA_VENDOR_ID               0x1645
 127 #define ENTREGA_FAKE_ID                 0x8093
 128
 129 static const struct usb_device_id id_table_combined[] = {
 130 #ifdef KEYSPAN
 131         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 132 #endif
 133 #ifdef XIRCOM
 134         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 135         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
 136         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 137 #endif
 138         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 139         { }                                             /* Terminating entry */
 140 };
 141
 142 MODULE_DEVICE_TABLE(usb, id_table_combined);
 143
 144 static struct usb_driver keyspan_pda_driver = {
 145         .name =         "keyspan_pda",
 146         .probe =        usb_serial_probe,
 147         .disconnect =   usb_serial_disconnect,
 148         .id_table =     id_table_combined,
 149         .no_dynamic_id =        1,
 150 };
 151
 152 static const struct usb_device_id id_table_std[] = {
 153         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_ID) },
 154         { }                                             /* Terminating entry */
 155 };
 156
 157 #ifdef KEYSPAN
 158 static const struct usb_device_id id_table_fake[] = {
 159         { USB_DEVICE(KEYSPAN_VENDOR_ID, KEYSPAN_PDA_FAKE_ID) },
 160         { }                                             /* Terminating entry */
 161 };
 162 #endif
 163
 164 #ifdef XIRCOM
 165 static const struct usb_device_id id_table_fake_xircom[] = {
 166         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID) },
 167         { USB_DEVICE(XIRCOM_VENDOR_ID, XIRCOM_FAKE_ID_2) },
 168         { USB_DEVICE(ENTREGA_VENDOR_ID, ENTREGA_FAKE_ID) },
 169         { }
 170 };
 171 #endif
 172
 173 static void keyspan_pda_wakeup_write(struct work_struct *work)
 174 {
 175         struct keyspan_pda_private *priv =
 176                 container_of(work, struct keyspan_pda_private, wakeup_work);
 177         struct usb_serial_port *port = priv->port;
 178         struct tty_struct *tty = tty_port_tty_get(&port->port);
 179         if (tty)
 180                 tty_wakeup(tty);
 181         tty_kref_put(tty);
 182 }
 183
 184 static void keyspan_pda_request_unthrottle(struct work_struct *work)
 185 {
 186         struct keyspan_pda_private *priv =
 187                 container_of(work, struct keyspan_pda_private, unthrottle_work);
 188         struct usb_serial *serial = priv->serial;
 189         int result;
 190
 191         dbg(" request_unthrottle");
 192         /* ask the device to tell us when the tx buffer becomes
 193            sufficiently empty */
 194         result = usb_control_msg(serial->dev,
 195                                  usb_sndctrlpipe(serial->dev, 0),
 196                                  7, /* request_unthrottle */
 197                                  USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 198                                  | USB_DIR_OUT,
 199                                  16, /* value: threshold */
 200                                  0, /* index */
 201                                  NULL,
 202                                  0,
 203                                  2000);
 204         if (result < 0)
 205                 dbg("%s - error %d from usb_control_msg",
 206                     __func__, result);
 207 }
 208
 209
 210 static void keyspan_pda_rx_interrupt(struct urb *urb)
 211 {
 212         struct usb_serial_port *port = urb->context;
 213         struct tty_struct *tty;
 214         unsigned char *data = urb->transfer_buffer;
 215         unsigned int len = urb->actual_length;
 216         int retval;
 217         int status = urb->status;
 218         struct keyspan_pda_private *priv;
 219         priv = usb_get_serial_port_data(port);
 220
 221         switch (status) {
 222         case 0:
 223                 /* success */
 224                 break;
 225         case -ECONNRESET:
 226         case -ENOENT:
 227         case -ESHUTDOWN:
 228                 /* this urb is terminated, clean up */
 229                 dbg("%s - urb shutting down with status: %d",
 230                     __func__, status);
 231                 return;
 232         default:
 233                 dbg("%s - nonzero urb status received: %d",
 234                     __func__, status);
 235                 goto exit;
 236         }
 237
 238         if (len < 1) {
 239                 dev_warn(&port->dev, "short message received\n");
 240                 goto exit;
 241         }
 242
 243         /* see if the message is data or a status interrupt */
 244         switch (data[0]) {
 245         case 0:
 246                 tty = tty_port_tty_get(&port->port);
 247                  /* rest of message is rx data */
 248                 if (!tty || len < 2)
 249                         break;
 250                 tty_insert_flip_string(tty, data + 1, len - 1);
 251                 tty_flip_buffer_push(tty);
 252                 tty_kref_put(tty);
 253                 break;
 254         case 1:
 255                 /* status interrupt */
 256                 if (len < 3) {
 257                         dev_warn(&port->dev, "short interrupt message received\n");
 258                         break;
 259                 }
 260                 dbg(" rx int, d1=%d, d2=%d", data[1], data[2]);
 261                 switch (data[1]) {
 262                 case 1: /* modemline change */
 263                         break;
 264                 case 2: /* tx unthrottle interrupt */
 265                         priv->tx_throttled = 0;
 266                         /* queue up a wakeup at scheduler time */
 267                         schedule_work(&priv->wakeup_work);
 268                         break;
 269                 default:
 270                         break;
 271                 }
 272                 break;
 273         default:
 274                 break;
 275         }
 276
 277 exit:
 278         retval = usb_submit_urb(urb, GFP_ATOMIC);
 279         if (retval)
 280                 dev_err(&port->dev,
 281                         "%s - usb_submit_urb failed with result %d",
 282                         __func__, retval);
 283 }
 284
 285
 286 static void keyspan_pda_rx_throttle(struct tty_struct *tty)
 287 {
 288         /* stop receiving characters. We just turn off the URB request, and
 289            let chars pile up in the device. If we're doing hardware
 290            flowcontrol, the device will signal the other end when its buffer
 291            fills up. If we're doing XON/XOFF, this would be a good time to
 292            send an XOFF, although it might make sense to foist that off
 293            upon the device too. */
 294         struct usb_serial_port *port = tty->driver_data;
 295         dbg("keyspan_pda_rx_throttle port %d", port->number);
 296         usb_kill_urb(port->interrupt_in_urb);
 297 }
 298
 299
 300 static void keyspan_pda_rx_unthrottle(struct tty_struct *tty)
 301 {
 302         struct usb_serial_port *port = tty->driver_data;
 303         /* just restart the receive interrupt URB */
 304         dbg("keyspan_pda_rx_unthrottle port %d", port->number);
 305         port->interrupt_in_urb->dev = port->serial->dev;
 306         if (usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL))
 307                 dbg(" usb_submit_urb(read urb) failed");
 308 }
 309
 310
 311 static speed_t keyspan_pda_setbaud(struct usb_serial *serial, speed_t baud)
 312 {
 313         int rc;
 314         int bindex;
 315
 316         switch (baud) {
 317         case 110:
 318                 bindex = 0;
 319                 break;
 320         case 300:
 321                 bindex = 1;
 322                 break;
 323         case 1200:
 324                 bindex = 2;
 325                 break;
 326         case 2400:
 327                 bindex = 3;
 328                 break;
 329         case 4800:
 330                 bindex = 4;
 331                 break;
 332         case 9600:
 333                 bindex = 5;
 334                 break;
 335         case 19200:
 336                 bindex = 6;
 337                 break;
 338         case 38400:
 339                 bindex = 7;
 340                 break;
 341         case 57600:
 342                 bindex = 8;
 343                 break;
 344         case 115200:
 345                 bindex = 9;
 346                 break;
 347         default:
 348                 bindex = 5;     /* Default to 9600 */
 349                 baud = 9600;
 350         }
 351
 352         /* rather than figure out how to sleep while waiting for this
 353            to complete, I just use the "legacy" API. */
 354         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 355                              0, /* set baud */
 356                              USB_TYPE_VENDOR
 357                              | USB_RECIP_INTERFACE
 358                              | USB_DIR_OUT, /* type */
 359                              bindex, /* value */
 360                              0, /* index */
 361                              NULL, /* &data */
 362                              0, /* size */
 363                              2000); /* timeout */
 364         if (rc < 0)
 365                 return 0;
 366         return baud;
 367 }
 368
 369
 370 static void keyspan_pda_break_ctl(struct tty_struct *tty, int break_state)
 371 {
 372         struct usb_serial_port *port = tty->driver_data;
 373         struct usb_serial *serial = port->serial;
 374         int value;
 375         int result;
 376
 377         if (break_state == -1)
 378                 value = 1; /* start break */
 379         else
 380                 value = 0; /* clear break */
 381         result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 382                         4, /* set break */
 383                         USB_TYPE_VENDOR | USB_RECIP_INTERFACE | USB_DIR_OUT,
 384                         value, 0, NULL, 0, 2000);
 385         if (result < 0)
 386                 dbg("%s - error %d from usb_control_msg",
 387                     __func__, result);
 388         /* there is something funky about this.. the TCSBRK that 'cu' performs
 389            ought to translate into a break_ctl(-1),break_ctl(0) pair HZ/4
 390            seconds apart, but it feels like the break sent isn't as long as it
 391            is on /dev/ttyS0 */
 392 }
 393
 394
 395 static void keyspan_pda_set_termios(struct tty_struct *tty,
 396                 struct usb_serial_port *port, struct ktermios *old_termios)
 397 {
 398         struct usb_serial *serial = port->serial;
 399         speed_t speed;
 400
 401         /* cflag specifies lots of stuff: number of stop bits, parity, number
 402            of data bits, baud. What can the device actually handle?:
 403            CSTOPB (1 stop bit or 2)
 404            PARENB (parity)
 405            CSIZE (5bit .. 8bit)
 406            There is minimal hw support for parity (a PSW bit seems to hold the
 407            parity of whatever is in the accumulator). The UART either deals
 408            with 10 bits (start, 8 data, stop) or 11 bits (start, 8 data,
 409            1 special, stop). So, with firmware changes, we could do:
 410            8N1: 10 bit
 411            8N2: 11 bit, extra bit always (mark?)
 412            8[EOMS]1: 11 bit, extra bit is parity
 413            7[EOMS]1: 10 bit, b0/b7 is parity
 414            7[EOMS]2: 11 bit, b0/b7 is parity, extra bit always (mark?)
 415
 416            HW flow control is dictated by the tty->termios->c_cflags & CRTSCTS
 417            bit.
 418
 419            For now, just do baud. */
 420
 421         speed = tty_get_baud_rate(tty);
 422         speed = keyspan_pda_setbaud(serial, speed);
 423
 424         if (speed == 0) {
 425                 dbg("can't handle requested baud rate");
 426                 /* It hasn't changed so.. */
 427                 speed = tty_termios_baud_rate(old_termios);
 428         }
 429         /* Only speed can change so copy the old h/w parameters
 430            then encode the new speed */
 431         tty_termios_copy_hw(tty->termios, old_termios);
 432         tty_encode_baud_rate(tty, speed, speed);
 433 }
 434
 435
 436 /* modem control pins: DTR and RTS are outputs and can be controlled.
 437    DCD, RI, DSR, CTS are inputs and can be read. All outputs can also be
 438    read. The byte passed is: DTR(b7) DCD RI DSR CTS RTS(b2) unused unused */
 439
 440 static int keyspan_pda_get_modem_info(struct usb_serial *serial,
 441                                       unsigned char *value)
 442 {
 443         int rc;
 444         u8 *data;
 445
 446         data = kmalloc(1, GFP_KERNEL);
 447         if (!data)
 448                 return -ENOMEM;
 449
 450         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 451                              3, /* get pins */
 452                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_IN,
 453                              0, 0, data, 1, 2000);
 454         if (rc >= 0)
 455                 *value = *data;
 456
 457         kfree(data);
 458         return rc;
 459 }
 460
 461
 462 static int keyspan_pda_set_modem_info(struct usb_serial *serial,
 463                                       unsigned char value)
 464 {
 465         int rc;
 466         rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
 467                              3, /* set pins */
 468                              USB_TYPE_VENDOR|USB_RECIP_INTERFACE|USB_DIR_OUT,
 469                              value, 0, NULL, 0, 2000);
 470         return rc;
 471 }
 472
 473 static int keyspan_pda_tiocmget(struct tty_struct *tty)
 474 {
 475         struct usb_serial_port *port = tty->driver_data;
 476         struct usb_serial *serial = port->serial;
 477         int rc;
 478         unsigned char status;
 479         int value;
 480
 481         rc = keyspan_pda_get_modem_info(serial, &status);
 482         if (rc < 0)
 483                 return rc;
 484         value =
 485                 ((status & (1<<7)) ? TIOCM_DTR : 0) |
 486                 ((status & (1<<6)) ? TIOCM_CAR : 0) |
 487                 ((status & (1<<5)) ? TIOCM_RNG : 0) |
 488                 ((status & (1<<4)) ? TIOCM_DSR : 0) |
 489                 ((status & (1<<3)) ? TIOCM_CTS : 0) |
 490                 ((status & (1<<2)) ? TIOCM_RTS : 0);
 491         return value;
 492 }
 493
 494 static int keyspan_pda_tiocmset(struct tty_struct *tty,
 495                                 unsigned int set, unsigned int clear)
 496 {
 497         struct usb_serial_port *port = tty->driver_data;
 498         struct usb_serial *serial = port->serial;
 499         int rc;
 500         unsigned char status;
 501
 502         rc = keyspan_pda_get_modem_info(serial, &status);
 503         if (rc < 0)
 504                 return rc;
 505
 506         if (set & TIOCM_RTS)
 507                 status |= (1<<2);
 508         if (set & TIOCM_DTR)
 509                 status |= (1<<7);
 510
 511         if (clear & TIOCM_RTS)
 512                 status &= ~(1<<2);
 513         if (clear & TIOCM_DTR)
 514                 status &= ~(1<<7);
 515         rc = keyspan_pda_set_modem_info(serial, status);
 516         return rc;
 517 }
 518
 519 static int keyspan_pda_write(struct tty_struct *tty,
 520         struct usb_serial_port *port, const unsigned char *buf, int count)
 521 {
 522         struct usb_serial *serial = port->serial;
 523         int request_unthrottle = 0;
 524         int rc = 0;
 525         struct keyspan_pda_private *priv;
 526
 527         priv = usb_get_serial_port_data(port);
 528         /* guess how much room is left in the device's ring buffer, and if we
 529            want to send more than that, check first, updating our notion of
 530            what is left. If our write will result in no room left, ask the
 531            device to give us an interrupt when the room available rises above
 532            a threshold, and hold off all writers (eventually, those using
 533            select() or poll() too) until we receive that unthrottle interrupt.
 534            Block if we can't write anything at all, otherwise write as much as
 535            we can. */
 536         dbg("keyspan_pda_write(%d)", count);
 537         if (count == 0) {
 538                 dbg(" write request of 0 bytes");
 539                 return 0;
 540         }
 541
 542         /* we might block because of:
 543            the TX urb is in-flight (wait until it completes)
 544            the device is full (wait until it says there is room)
 545         */
 546         spin_lock_bh(&port->lock);
 547         if (port->write_urb_busy || priv->tx_throttled) {
 548                 spin_unlock_bh(&port->lock);
 549                 return 0;
 550         }
 551         port->write_urb_busy = 1;
 552         spin_unlock_bh(&port->lock);
 553
 554         /* At this point the URB is in our control, nobody else can submit it
 555            again (the only sudden transition was the one from EINPROGRESS to
 556            finished).  Also, the tx process is not throttled. So we are
 557            ready to write. */
 558
 559         count = (count > port->bulk_out_size) ? port->bulk_out_size : count;
 560
 561         /* Check if we might overrun the Tx buffer.   If so, ask the
 562            device how much room it really has.  This is done only on
 563            scheduler time, since usb_control_msg() sleeps. */
 564         if (count > priv->tx_room && !in_interrupt()) {
 565                 u8 *room;
 566
 567                 room = kmalloc(1, GFP_KERNEL);
 568                 if (!room) {
 569                         rc = -ENOMEM;
 570                         goto exit;
 571                 }
 572
 573                 rc = usb_control_msg(serial->dev,
 574                                      usb_rcvctrlpipe(serial->dev, 0),
 575                                      6, /* write_room */
 576                                      USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 577                                      | USB_DIR_IN,
 578                                      0, /* value: 0 means "remaining room" */
 579                                      0, /* index */
 580                                      room,
 581                                      1,
 582                                      2000);
 583                 if (rc > 0) {
 584                         dbg(" roomquery says %d", *room);
 585                         priv->tx_room = *room;
 586                 }
 587                 kfree(room);
 588                 if (rc < 0) {
 589                         dbg(" roomquery failed");
 590                         goto exit;
 591                 }
 592                 if (rc == 0) {
 593                         dbg(" roomquery returned 0 bytes");
 594                         rc = -EIO; /* device didn't return any data */
 595                         goto exit;
 596                 }
 597         }
 598         if (count > priv->tx_room) {
 599                 /* we're about to completely fill the Tx buffer, so
 600                    we'll be throttled afterwards. */
 601                 count = priv->tx_room;
 602                 request_unthrottle = 1;
 603         }
 604
 605         if (count) {
 606                 /* now transfer data */
 607                 memcpy(port->write_urb->transfer_buffer, buf, count);
 608                 /* send the data out the bulk port */
 609                 port->write_urb->transfer_buffer_length = count;
 610
 611                 priv->tx_room -= count;
 612
 613                 port->write_urb->dev = port->serial->dev;
 614                 rc = usb_submit_urb(port->write_urb, GFP_ATOMIC);
 615                 if (rc) {
 616                         dbg(" usb_submit_urb(write bulk) failed");
 617                         goto exit;
 618                 }
 619         } else {
 620                 /* There wasn't any room left, so we are throttled until
 621                    the buffer empties a bit */
 622                 request_unthrottle = 1;
 623         }
 624
 625         if (request_unthrottle) {
 626                 priv->tx_throttled = 1; /* block writers */
 627                 schedule_work(&priv->unthrottle_work);
 628         }
 629
 630         rc = count;
 631 exit:
 632         if (rc < 0)
 633                 port->write_urb_busy = 0;
 634         return rc;
 635 }
 636
 637
 638 static void keyspan_pda_write_bulk_callback(struct urb *urb)
 639 {
 640         struct usb_serial_port *port = urb->context;
 641         struct keyspan_pda_private *priv;
 642
 643         port->write_urb_busy = 0;
 644         priv = usb_get_serial_port_data(port);
 645
 646         /* queue up a wakeup at scheduler time */
 647         schedule_work(&priv->wakeup_work);
 648 }
 649
 650
 651 static int keyspan_pda_write_room(struct tty_struct *tty)
 652 {
 653         struct usb_serial_port *port = tty->driver_data;
 654         struct keyspan_pda_private *priv;
 655         priv = usb_get_serial_port_data(port);
 656         /* used by n_tty.c for processing of tabs and such. Giving it our
 657            conservative guess is probably good enough, but needs testing by
 658            running a console through the device. */
 659         return priv->tx_room;
 660 }
 661
 662
 663 static int keyspan_pda_chars_in_buffer(struct tty_struct *tty)
 664 {
 665         struct usb_serial_port *port = tty->driver_data;
 666         struct keyspan_pda_private *priv;
 667         unsigned long flags;
 668         int ret = 0;
 669
 670         priv = usb_get_serial_port_data(port);
 671
 672         /* when throttled, return at least WAKEUP_CHARS to tell select() (via
 673            n_tty.c:normal_poll() ) that we're not writeable. */
 674
 675         spin_lock_irqsave(&port->lock, flags);
 676         if (port->write_urb_busy || priv->tx_throttled)
 677                 ret = 256;
 678         spin_unlock_irqrestore(&port->lock, flags);
 679         return ret;
 680 }
 681
 682
 683 static void keyspan_pda_dtr_rts(struct usb_serial_port *port, int on)
 684 {
 685         struct usb_serial *serial = port->serial;
 686
 687         if (serial->dev) {
 688                 if (on)
 689                         keyspan_pda_set_modem_info(serial, (1<<7) | (1<< 2));
 690                 else
 691                         keyspan_pda_set_modem_info(serial, 0);
 692         }
 693 }
 694
 695
 696 static int keyspan_pda_open(struct tty_struct *tty,
 697                                         struct usb_serial_port *port)
 698 {
 699         struct usb_serial *serial = port->serial;
 700         u8 *room;
 701         int rc = 0;
 702         struct keyspan_pda_private *priv;
 703
 704         /* find out how much room is in the Tx ring */
 705         room = kmalloc(1, GFP_KERNEL);
 706         if (!room)
 707                 return -ENOMEM;
 708
 709         rc = usb_control_msg(serial->dev, usb_rcvctrlpipe(serial->dev, 0),
 710                              6, /* write_room */
 711                              USB_TYPE_VENDOR | USB_RECIP_INTERFACE
 712                              | USB_DIR_IN,
 713                              0, /* value */
 714                              0, /* index */
 715                              room,
 716                              1,
 717                              2000);
 718         if (rc < 0) {
 719                 dbg("%s - roomquery failed", __func__);
 720                 goto error;
 721         }
 722         if (rc == 0) {
 723                 dbg("%s - roomquery returned 0 bytes", __func__);
 724                 rc = -EIO;
 725                 goto error;
 726         }
 727         priv = usb_get_serial_port_data(port);
 728         priv->tx_room = *room;
 729         priv->tx_throttled = *room ? 0 : 1;
 730
 731         /*Start reading from the device*/
 732         port->interrupt_in_urb->dev = serial->dev;
 733         rc = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 734         if (rc) {
 735                 dbg("%s - usb_submit_urb(read int) failed", __func__);
 736                 goto error;
 737         }
 738 error:
 739         kfree(room);
 740         return rc;
 741 }
 742 static void keyspan_pda_close(struct usb_serial_port *port)
 743 {
 744         struct usb_serial *serial = port->serial;
 745
 746         if (serial->dev) {
 747                 /* shutdown our bulk reads and writes */
 748                 usb_kill_urb(port->write_urb);
 749                 usb_kill_urb(port->interrupt_in_urb);
 750         }
 751 }
 752
 753
 754 /* download the firmware to a "fake" device (pre-renumeration) */
 755 static int keyspan_pda_fake_startup(struct usb_serial *serial)
 756 {
 757         int response;
 758         const char *fw_name;
 759         const struct ihex_binrec *record;
 760         const struct firmware *fw;
 761
 762         /* download the firmware here ... */
 763         response = ezusb_set_reset(serial, 1);
 764
 765         if (0) { ; }
 766 #ifdef KEYSPAN
 767         else if (le16_to_cpu(serial->dev->descriptor.idVendor) == KEYSPAN_VENDOR_ID)
 768                 fw_name = "keyspan_pda/keyspan_pda.fw";
 769 #endif
 770 #ifdef XIRCOM
 771         else if ((le16_to_cpu(serial->dev->descriptor.idVendor) == XIRCOM_VENDOR_ID) ||
 772                  (le16_to_cpu(serial->dev->descriptor.idVendor) == ENTREGA_VENDOR_ID))
 773                 fw_name = "keyspan_pda/xircom_pgs.fw";
 774 #endif
 775         else {
 776                 dev_err(&serial->dev->dev, "%s: unknown vendor, aborting.\n",
 777                         __func__);
 778                 return -ENODEV;
 779         }
 780         if (request_ihex_firmware(&fw, fw_name, &serial->dev->dev)) {
 781                 dev_err(&serial->dev->dev, "failed to load firmware \"%s\"\n",
 782                         fw_name);
 783                 return -ENOENT;
 784         }
 785         record = (const struct ihex_binrec *)fw->data;
 786
 787         while (record) {
 788                 response = ezusb_writememory(serial, be32_to_cpu(record->addr),
 789                                              (unsigned char *)record->data,
 790                                              be16_to_cpu(record->len), 0xa0);
 791                 if (response < 0) {
 792                         dev_err(&serial->dev->dev, "ezusb_writememory failed "
 793                                 "for Keyspan PDA firmware (%d %04X %p %d)\n",
 794                                 response, be32_to_cpu(record->addr),
 795                                 record->data, be16_to_cpu(record->len));
 796                         break;
 797                 }
 798                 record = ihex_next_binrec(record);
 799         }
 800         release_firmware(fw);
 801         /* bring device out of reset. Renumeration will occur in a moment
 802            and the new device will bind to the real driver */
 803         response = ezusb_set_reset(serial, 0);
 804
 805         /* we want this device to fail to have a driver assigned to it. */
 806         return 1;
 807 }
 808
 809 #ifdef KEYSPAN
 810 MODULE_FIRMWARE("keyspan_pda/keyspan_pda.fw");
 811 #endif
 812 #ifdef XIRCOM
 813 MODULE_FIRMWARE("keyspan_pda/xircom_pgs.fw");
 814 #endif
 815
 816 static int keyspan_pda_startup(struct usb_serial *serial)
 817 {
 818         unsigned char num_ports = serial->num_ports;
 819         struct keyspan_pda_private *priv;
 820
 821         if (serial->num_bulk_out < num_ports ||
 822                         serial->num_interrupt_in < num_ports) {
 823                 dev_err(&serial->interface->dev, "missing endpoints\n");
 824                 return -ENODEV;
 825         }
 826
 827         /* allocate the private data structures for all ports. Well, for all
 828            one ports. */
 829
 830         priv = kmalloc(sizeof(struct keyspan_pda_private), GFP_KERNEL);
 831         if (!priv)
 832                 return 1; /* error */
 833         usb_set_serial_port_data(serial->port[0], priv);
 834         init_waitqueue_head(&serial->port[0]->write_wait);
 835         INIT_WORK(&priv->wakeup_work, keyspan_pda_wakeup_write);
 836         INIT_WORK(&priv->unthrottle_work, keyspan_pda_request_unthrottle);
 837         priv->serial = serial;
 838         priv->port = serial->port[0];
 839         return 0;
 840 }
 841
 842 static void keyspan_pda_release(struct usb_serial *serial)
 843 {
 844         dbg("%s", __func__);
 845
 846         kfree(usb_get_serial_port_data(serial->port[0]));
 847 }
 848
 849 #ifdef KEYSPAN
 850 static struct usb_serial_driver keyspan_pda_fake_device = {
 851         .driver = {
 852                 .owner =        THIS_MODULE,
 853                 .name =         "keyspan_pda_pre",
 854         },
 855         .description =          "Keyspan PDA - (prerenumeration)",
 856         .usb_driver =           &keyspan_pda_driver,
 857         .id_table =             id_table_fake,
 858         .num_ports =            1,
 859         .attach =               keyspan_pda_fake_startup,
 860 };
 861 #endif
 862
 863 #ifdef XIRCOM
 864 static struct usb_serial_driver xircom_pgs_fake_device = {
 865         .driver = {
 866                 .owner =        THIS_MODULE,
 867                 .name =         "xircom_no_firm",
 868         },
 869         .description =          "Xircom / Entrega PGS - (prerenumeration)",
 870         .usb_driver =           &keyspan_pda_driver,
 871         .id_table =             id_table_fake_xircom,
 872         .num_ports =            1,
 873         .attach =               keyspan_pda_fake_startup,
 874 };
 875 #endif
 876
 877 static struct usb_serial_driver keyspan_pda_device = {
 878         .driver = {
 879                 .owner =        THIS_MODULE,
 880                 .name =         "keyspan_pda",
 881         },
 882         .description =          "Keyspan PDA",
 883         .usb_driver =           &keyspan_pda_driver,
 884         .id_table =             id_table_std,
 885         .num_ports =            1,
 886         .dtr_rts =              keyspan_pda_dtr_rts,
 887         .open =                 keyspan_pda_open,
 888         .close =                keyspan_pda_close,
 889         .write =                keyspan_pda_write,
 890         .write_room =           keyspan_pda_write_room,
 891         .write_bulk_callback =  keyspan_pda_write_bulk_callback,
 892         .read_int_callback =    keyspan_pda_rx_interrupt,
 893         .chars_in_buffer =      keyspan_pda_chars_in_buffer,
 894         .throttle =             keyspan_pda_rx_throttle,
 895         .unthrottle =           keyspan_pda_rx_unthrottle,
 896         .set_termios =          keyspan_pda_set_termios,
 897         .break_ctl =            keyspan_pda_break_ctl,
 898         .tiocmget =             keyspan_pda_tiocmget,
 899         .tiocmset =             keyspan_pda_tiocmset,
 900         .attach =               keyspan_pda_startup,
 901         .release =              keyspan_pda_release,
 902 };
 903
 904
 905 static int __init keyspan_pda_init(void)
 906 {
 907         int retval;
 908         retval = usb_serial_register(&keyspan_pda_device);
 909         if (retval)
 910                 goto failed_pda_register;
 911 #ifdef KEYSPAN
 912         retval = usb_serial_register(&keyspan_pda_fake_device);
 913         if (retval)
 914                 goto failed_pda_fake_register;
 915 #endif
 916 #ifdef XIRCOM
 917         retval = usb_serial_register(&xircom_pgs_fake_device);
 918         if (retval)
 919                 goto failed_xircom_register;
 920 #endif
 921         retval = usb_register(&keyspan_pda_driver);
 922         if (retval)
 923                 goto failed_usb_register;
 924         printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
 925                DRIVER_DESC "\n");
 926         return 0;
 927 failed_usb_register:
 928 #ifdef XIRCOM
 929         usb_serial_deregister(&xircom_pgs_fake_device);
 930 failed_xircom_register:
 931 #endif /* XIRCOM */
 932 #ifdef KEYSPAN
 933         usb_serial_deregister(&keyspan_pda_fake_device);
 934 #endif
 935 #ifdef KEYSPAN
 936 failed_pda_fake_register:
 937 #endif
 938         usb_serial_deregister(&keyspan_pda_device);
 939 failed_pda_register:
 940         return retval;
 941 }
 942
 943
 944 static void __exit keyspan_pda_exit(void)
 945 {
 946         usb_deregister(&keyspan_pda_driver);
 947         usb_serial_deregister(&keyspan_pda_device);
 948 #ifdef KEYSPAN
 949         usb_serial_deregister(&keyspan_pda_fake_device);
 950 #endif
 951 #ifdef XIRCOM
 952         usb_serial_deregister(&xircom_pgs_fake_device);
 953 #endif
 954 }
 955
 956
 957 module_init(keyspan_pda_init);
 958 module_exit(keyspan_pda_exit);
 959
 960 MODULE_AUTHOR(DRIVER_AUTHOR);
 961 MODULE_DESCRIPTION(DRIVER_DESC);
 962 MODULE_LICENSE("GPL");
 963
 964 module_param(debug, bool, S_IRUGO | S_IWUSR);
 965 MODULE_PARM_DESC(debug, "Debug enabled or not");
 966