drivers/usb/serial/keyspan_pda.c

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