err.no Git - linux-2.6/blob - drivers/usb/serial/cypress_m8.c

   1 /*
   2  * USB Cypress M8 driver
   3  *
   4  *      Copyright (C) 2004
   5  *          Lonnie Mendez (dignome@gmail.com)
   6  *      Copyright (C) 2003,2004
   7  *          Neil Whelchel (koyama@firstlight.net)
   8  *
   9  *      This program is free software; you can redistribute it and/or modify
  10  *      it under the terms of the GNU General Public License as published by
  11  *      the Free Software Foundation; either version 2 of the License, or
  12  *      (at your option) any later version.
  13  *
  14  * See Documentation/usb/usb-serial.txt for more information on using this driver
  15  *
  16  * See http://geocities.com/i0xox0i for information on this driver and the
  17  * earthmate usb device.
  18  *
  19  *  Lonnie Mendez <dignome@gmail.com>
  20  *  4-29-2005
  21  *      Fixed problem where setting or retreiving the serial config would fail with
  22  *      EPIPE.  Removed CRTS toggling so the driver behaves more like other usbserial
  23  *      adapters.  Issued new interval of 1ms instead of the default 10ms.  As a
  24  *      result, transfer speed has been substantially increased.  From avg. 850bps to
  25  *      avg. 3300bps.  initial termios has also been modified.  Cleaned up code and
  26  *      formatting issues so it is more readable.  Replaced the C++ style comments.
  27  *
  28  *  Lonnie Mendez <dignome@gmail.com>
  29  *  12-15-2004
  30  *      Incorporated write buffering from pl2303 driver.  Fixed bug with line
  31  *      handling so both lines are raised in cypress_open. (was dropping rts)
  32  *      Various code cleanups made as well along with other misc bug fixes.
  33  *
  34  *  Lonnie Mendez <dignome@gmail.com>
  35  *  04-10-2004
  36  *      Driver modified to support dynamic line settings.  Various improvments
  37  *      and features.
  38  *
  39  *  Neil Whelchel
  40  *  10-2003
  41  *      Driver first released.
  42  *
  43  */
  44
  45 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation for linux. */
  46 /* Thanks to cypress for providing references for the hid reports. */
  47 /* Thanks to Jiang Zhang for providing links and for general help. */
  48 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others. */
  49
  50
  51 #include <linux/kernel.h>
  52 #include <linux/errno.h>
  53 #include <linux/init.h>
  54 #include <linux/slab.h>
  55 #include <linux/tty.h>
  56 #include <linux/tty_driver.h>
  57 #include <linux/tty_flip.h>
  58 #include <linux/module.h>
  59 #include <linux/moduleparam.h>
  60 #include <linux/spinlock.h>
  61 #include <linux/usb.h>
  62 #include <linux/usb/serial.h>
  63 #include <linux/serial.h>
  64 #include <linux/delay.h>
  65 #include <asm/uaccess.h>
  66
  67 #include "cypress_m8.h"
  68
  69
  70 #ifdef CONFIG_USB_SERIAL_DEBUG
  71         static int debug = 1;
  72 #else
  73         static int debug;
  74 #endif
  75 static int stats;
  76 static int interval;
  77
  78 /*
  79  * Version Information
  80  */
  81 #define DRIVER_VERSION "v1.09"
  82 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>"
  83 #define DRIVER_DESC "Cypress USB to Serial Driver"
  84
  85 /* write buffer size defines */
  86 #define CYPRESS_BUF_SIZE        1024
  87 #define CYPRESS_CLOSING_WAIT    (30*HZ)
  88
  89 static struct usb_device_id id_table_earthmate [] = {
  90         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
  91         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
  92         { }                                             /* Terminating entry */
  93 };
  94
  95 static struct usb_device_id id_table_cyphidcomrs232 [] = {
  96         { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
  97         { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) },
  98         { }                                             /* Terminating entry */
  99 };
 100
 101 static struct usb_device_id id_table_nokiaca42v2 [] = {
 102         { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
 103         { }                                             /* Terminating entry */
 104 };
 105
 106 static struct usb_device_id id_table_combined [] = {
 107         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
 108         { USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
 109         { USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
 110         { USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) },
 111         { USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
 112         { }                                             /* Terminating entry */
 113 };
 114
 115 MODULE_DEVICE_TABLE (usb, id_table_combined);
 116
 117 static struct usb_driver cypress_driver = {
 118         .name =         "cypress",
 119         .probe =        usb_serial_probe,
 120         .disconnect =   usb_serial_disconnect,
 121         .id_table =     id_table_combined,
 122         .no_dynamic_id =        1,
 123 };
 124
 125 enum packet_format {
 126         packet_format_1,  /* b0:status, b1:payload count */
 127         packet_format_2   /* b0[7:3]:status, b0[2:0]:payload count */
 128 };
 129
 130 struct cypress_private {
 131         spinlock_t lock;                   /* private lock */
 132         int chiptype;                      /* identifier of device, for quirks/etc */
 133         int bytes_in;                      /* used for statistics */
 134         int bytes_out;                     /* used for statistics */
 135         int cmd_count;                     /* used for statistics */
 136         int cmd_ctrl;                      /* always set this to 1 before issuing a command */
 137         struct cypress_buf *buf;           /* write buffer */
 138         int write_urb_in_use;              /* write urb in use indicator */
 139         int write_urb_interval;            /* interval to use for write urb */
 140         int read_urb_interval;             /* interval to use for read urb */
 141         int comm_is_ok;                    /* true if communication is (still) ok */
 142         int termios_initialized;
 143         __u8 line_control;                 /* holds dtr / rts value */
 144         __u8 current_status;               /* received from last read - info on dsr,cts,cd,ri,etc */
 145         __u8 current_config;               /* stores the current configuration byte */
 146         __u8 rx_flags;                     /* throttling - used from whiteheat/ftdi_sio */
 147         enum packet_format pkt_fmt;        /* format to use for packet send / receive */
 148         int get_cfg_unsafe;                /* If true, the CYPRESS_GET_CONFIG is unsafe */
 149         int baud_rate;                     /* stores current baud rate in integer form */
 150         int isthrottled;                   /* if throttled, discard reads */
 151         wait_queue_head_t delta_msr_wait;  /* used for TIOCMIWAIT */
 152         char prev_status, diff_status;     /* used for TIOCMIWAIT */
 153         /* we pass a pointer to this as the arguement sent to cypress_set_termios old_termios */
 154         struct ktermios tmp_termios;       /* stores the old termios settings */
 155 };
 156
 157 /* write buffer structure */
 158 struct cypress_buf {
 159         unsigned int    buf_size;
 160         char            *buf_buf;
 161         char            *buf_get;
 162         char            *buf_put;
 163 };
 164
 165 /* function prototypes for the Cypress USB to serial device */
 166 static int  cypress_earthmate_startup   (struct usb_serial *serial);
 167 static int  cypress_hidcom_startup      (struct usb_serial *serial);
 168 static int  cypress_ca42v2_startup      (struct usb_serial *serial);
 169 static void cypress_shutdown            (struct usb_serial *serial);
 170 static int  cypress_open                (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
 171 static void cypress_close               (struct tty_struct *tty, struct usb_serial_port *port, struct file *filp);
 172 static int  cypress_write               (struct tty_struct *tty, struct usb_serial_port *port, const unsigned char *buf, int count);
 173 static void cypress_send                (struct usb_serial_port *port);
 174 static int  cypress_write_room          (struct tty_struct *tty);
 175 static int  cypress_ioctl               (struct tty_struct *tty, struct file * file, unsigned int cmd, unsigned long arg);
 176 static void cypress_set_termios         (struct tty_struct *tty, struct usb_serial_port *port, struct ktermios * old);
 177 static int  cypress_tiocmget            (struct tty_struct *tty, struct file *file);
 178 static int  cypress_tiocmset            (struct tty_struct *tty, struct file *file, unsigned int set, unsigned int clear);
 179 static int  cypress_chars_in_buffer     (struct tty_struct *tty);
 180 static void cypress_throttle            (struct tty_struct *tty);
 181 static void cypress_unthrottle          (struct tty_struct *tty);
 182 static void cypress_set_dead            (struct usb_serial_port *port);
 183 static void cypress_read_int_callback   (struct urb *urb);
 184 static void cypress_write_int_callback  (struct urb *urb);
 185 /* write buffer functions */
 186 static struct cypress_buf *cypress_buf_alloc(unsigned int size);
 187 static void               cypress_buf_free(struct cypress_buf *cb);
 188 static void               cypress_buf_clear(struct cypress_buf *cb);
 189 static unsigned int       cypress_buf_data_avail(struct cypress_buf *cb);
 190 static unsigned int       cypress_buf_space_avail(struct cypress_buf *cb);
 191 static unsigned int       cypress_buf_put(struct cypress_buf *cb, const char *buf, unsigned int count);
 192 static unsigned int       cypress_buf_get(struct cypress_buf *cb, char *buf, unsigned int count);
 193
 194
 195 static struct usb_serial_driver cypress_earthmate_device = {
 196         .driver = {
 197                 .owner =                THIS_MODULE,
 198                 .name =                 "earthmate",
 199         },
 200         .description =                  "DeLorme Earthmate USB",
 201         .usb_driver =                   &cypress_driver,
 202         .id_table =                     id_table_earthmate,
 203         .num_ports =                    1,
 204         .attach =                       cypress_earthmate_startup,
 205         .shutdown =                     cypress_shutdown,
 206         .open =                         cypress_open,
 207         .close =                        cypress_close,
 208         .write =                        cypress_write,
 209         .write_room =                   cypress_write_room,
 210         .ioctl =                        cypress_ioctl,
 211         .set_termios =                  cypress_set_termios,
 212         .tiocmget =                     cypress_tiocmget,
 213         .tiocmset =                     cypress_tiocmset,
 214         .chars_in_buffer =              cypress_chars_in_buffer,
 215         .throttle =                     cypress_throttle,
 216         .unthrottle =                   cypress_unthrottle,
 217         .read_int_callback =            cypress_read_int_callback,
 218         .write_int_callback =           cypress_write_int_callback,
 219 };
 220
 221 static struct usb_serial_driver cypress_hidcom_device = {
 222         .driver = {
 223                 .owner =                THIS_MODULE,
 224                 .name =                 "cyphidcom",
 225         },
 226         .description =                  "HID->COM RS232 Adapter",
 227         .usb_driver =                   &cypress_driver,
 228         .id_table =                     id_table_cyphidcomrs232,
 229         .num_ports =                    1,
 230         .attach =                       cypress_hidcom_startup,
 231         .shutdown =                     cypress_shutdown,
 232         .open =                         cypress_open,
 233         .close =                        cypress_close,
 234         .write =                        cypress_write,
 235         .write_room =                   cypress_write_room,
 236         .ioctl =                        cypress_ioctl,
 237         .set_termios =                  cypress_set_termios,
 238         .tiocmget =                     cypress_tiocmget,
 239         .tiocmset =                     cypress_tiocmset,
 240         .chars_in_buffer =              cypress_chars_in_buffer,
 241         .throttle =                     cypress_throttle,
 242         .unthrottle =                   cypress_unthrottle,
 243         .read_int_callback =            cypress_read_int_callback,
 244         .write_int_callback =           cypress_write_int_callback,
 245 };
 246
 247 static struct usb_serial_driver cypress_ca42v2_device = {
 248         .driver = {
 249                 .owner =                THIS_MODULE,
 250                 .name =                 "nokiaca42v2",
 251         },
 252         .description =                  "Nokia CA-42 V2 Adapter",
 253         .usb_driver =                   &cypress_driver,
 254         .id_table =                     id_table_nokiaca42v2,
 255         .num_ports =                    1,
 256         .attach =                       cypress_ca42v2_startup,
 257         .shutdown =                     cypress_shutdown,
 258         .open =                         cypress_open,
 259         .close =                        cypress_close,
 260         .write =                        cypress_write,
 261         .write_room =                   cypress_write_room,
 262         .ioctl =                        cypress_ioctl,
 263         .set_termios =                  cypress_set_termios,
 264         .tiocmget =                     cypress_tiocmget,
 265         .tiocmset =                     cypress_tiocmset,
 266         .chars_in_buffer =              cypress_chars_in_buffer,
 267         .throttle =                     cypress_throttle,
 268         .unthrottle =                   cypress_unthrottle,
 269         .read_int_callback =            cypress_read_int_callback,
 270         .write_int_callback =           cypress_write_int_callback,
 271 };
 272
 273 /*****************************************************************************
 274  * Cypress serial helper functions
 275  *****************************************************************************/
 276
 277
 278 static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
 279 {
 280         struct cypress_private *priv;
 281         priv = usb_get_serial_port_data(port);
 282
 283         /*
 284          * The general purpose firmware for the Cypress M8 allows for
 285          * a maximum speed of 57600bps (I have no idea whether DeLorme
 286          * chose to use the general purpose firmware or not), if you
 287          * need to modify this speed setting for your own project
 288          * please add your own chiptype and modify the code likewise.
 289          * The Cypress HID->COM device will work successfully up to
 290          * 115200bps (but the actual throughput is around 3kBps).
 291          */
 292         if (port->serial->dev->speed == USB_SPEED_LOW) {
 293                 /*
 294                  * Mike Isely <isely@pobox.com> 2-Feb-2008: The
 295                  * Cypress app note that describes this mechanism
 296                  * states the the low-speed part can't handle more
 297                  * than 800 bytes/sec, in which case 4800 baud is the
 298                  * safest speed for a part like that.
 299                  */
 300                 if (new_rate > 4800) {
 301                         dbg("%s - failed setting baud rate, device incapable "
 302                             "speed %d", __func__, new_rate);
 303                         return -1;
 304                 }
 305         }
 306         switch (priv->chiptype) {
 307         case CT_EARTHMATE:
 308                 if (new_rate <= 600) {
 309                         /* 300 and 600 baud rates are supported under
 310                          * the generic firmware, but are not used with
 311                          * NMEA and SiRF protocols */
 312                         dbg("%s - failed setting baud rate, unsupported speed "
 313                             "of %d on Earthmate GPS", __func__, new_rate);
 314                         return -1;
 315                 }
 316                 break;
 317         default:
 318                 break;
 319         }
 320         return new_rate;
 321 }
 322
 323
 324 /* This function can either set or retrieve the current serial line settings */
 325 static int cypress_serial_control (struct tty_struct *tty,
 326         struct usb_serial_port *port, speed_t baud_rate, int data_bits,
 327         int stop_bits, int parity_enable, int parity_type, int reset,
 328         int cypress_request_type)
 329 {
 330         int new_baudrate = 0, retval = 0, tries = 0;
 331         struct cypress_private *priv;
 332         __u8 feature_buffer[5];
 333         unsigned long flags;
 334
 335         dbg("%s", __func__);
 336
 337         priv = usb_get_serial_port_data(port);
 338
 339         if (!priv->comm_is_ok)
 340                 return -ENODEV;
 341
 342         switch(cypress_request_type) {
 343                 case CYPRESS_SET_CONFIG:
 344                         new_baudrate = priv->baud_rate;
 345                         /* 0 means 'Hang up' so doesn't change the true bit rate */
 346                         if (baud_rate == 0)
 347                                 new_baudrate = priv->baud_rate;
 348                         /* Change of speed ? */
 349                         else if (baud_rate != priv->baud_rate) {
 350                                 dbg("%s - baud rate is changing", __func__);
 351                                 retval = analyze_baud_rate(port, baud_rate);
 352                                 if (retval >=  0) {
 353                                         new_baudrate = retval;
 354                                         dbg("%s - New baud rate set to %d",
 355                                             __func__, new_baudrate);
 356                                 }
 357                         }
 358                         dbg("%s - baud rate is being sent as %d", __func__, new_baudrate);
 359
 360                         memset(feature_buffer, 0, sizeof(feature_buffer));
 361                         /* fill the feature_buffer with new configuration */
 362                         *((u_int32_t *)feature_buffer) = new_baudrate;
 363
 364                         feature_buffer[4] |= data_bits;   /* assign data bits in 2 bit space ( max 3 ) */
 365                         /* 1 bit gap */
 366                         feature_buffer[4] |= (stop_bits << 3);   /* assign stop bits in 1 bit space */
 367                         feature_buffer[4] |= (parity_enable << 4);   /* assign parity flag in 1 bit space */
 368                         feature_buffer[4] |= (parity_type << 5);   /* assign parity type in 1 bit space */
 369                         /* 1 bit gap */
 370                         feature_buffer[4] |= (reset << 7);   /* assign reset at end of byte, 1 bit space */
 371
 372                         dbg("%s - device is being sent this feature report:", __func__);
 373                         dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__, feature_buffer[0], feature_buffer[1],
 374                             feature_buffer[2], feature_buffer[3], feature_buffer[4]);
 375
 376                         do {
 377                                 retval = usb_control_msg(port->serial->dev,
 378                                                 usb_sndctrlpipe(port->serial->dev, 0),
 379                                                 HID_REQ_SET_REPORT,
 380                                                 USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS,
 381                                                 0x0300, 0, feature_buffer,
 382                                                 sizeof(feature_buffer), 500);
 383
 384                                 if (tries++ >= 3)
 385                                         break;
 386
 387                         } while (retval != sizeof(feature_buffer) &&
 388                                  retval != -ENODEV);
 389
 390                         if (retval != sizeof(feature_buffer)) {
 391                                 err("%s - failed sending serial line settings - %d", __func__, retval);
 392                                 cypress_set_dead(port);
 393                         } else {
 394                                 spin_lock_irqsave(&priv->lock, flags);
 395                                 priv->baud_rate = new_baudrate;
 396                                 priv->current_config = feature_buffer[4];
 397                                 spin_unlock_irqrestore(&priv->lock, flags);
 398                                 /* If we asked for a speed change encode it */
 399                                 if (baud_rate)
 400                                         tty_encode_baud_rate(tty,
 401                                                         new_baudrate, new_baudrate);
 402                         }
 403                 break;
 404                 case CYPRESS_GET_CONFIG:
 405                         if (priv->get_cfg_unsafe) {
 406                                 /* Not implemented for this device,
 407                                    and if we try to do it we're likely
 408                                    to crash the hardware. */
 409                                 return -ENOTTY;
 410                         }
 411                         dbg("%s - retreiving serial line settings", __func__);
 412                         /* set initial values in feature buffer */
 413                         memset(feature_buffer, 0, sizeof(feature_buffer));
 414
 415                         do {
 416                                 retval = usb_control_msg(port->serial->dev,
 417                                                 usb_rcvctrlpipe(port->serial->dev, 0),
 418                                                 HID_REQ_GET_REPORT,
 419                                                 USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS,
 420                                                 0x0300, 0, feature_buffer,
 421                                                 sizeof(feature_buffer), 500);
 422
 423                                 if (tries++ >= 3)
 424                                         break;
 425
 426                         } while (retval != sizeof(feature_buffer) &&
 427                                  retval != -ENODEV);
 428
 429                         if (retval != sizeof(feature_buffer)) {
 430                                 err("%s - failed to retrieve serial line settings - %d", __func__, retval);
 431                                 cypress_set_dead(port);
 432                                 return retval;
 433                         } else {
 434                                 spin_lock_irqsave(&priv->lock, flags);
 435
 436                                 /* store the config in one byte, and later use bit masks to check values */
 437                                 priv->current_config = feature_buffer[4];
 438                                 priv->baud_rate = *((u_int32_t *)feature_buffer);
 439                                 spin_unlock_irqrestore(&priv->lock, flags);
 440                         }
 441         }
 442         spin_lock_irqsave(&priv->lock, flags);
 443         ++priv->cmd_count;
 444         spin_unlock_irqrestore(&priv->lock, flags);
 445
 446         return retval;
 447 } /* cypress_serial_control */
 448
 449
 450 static void cypress_set_dead(struct usb_serial_port *port)
 451 {
 452         struct cypress_private *priv = usb_get_serial_port_data(port);
 453         unsigned long flags;
 454
 455         spin_lock_irqsave(&priv->lock, flags);
 456         if (!priv->comm_is_ok) {
 457                 spin_unlock_irqrestore(&priv->lock, flags);
 458                 return;
 459         }
 460         priv->comm_is_ok = 0;
 461         spin_unlock_irqrestore(&priv->lock, flags);
 462
 463         err("cypress_m8 suspending failing port %d - interval might be too short",
 464             port->number);
 465 }
 466
 467
 468 /*****************************************************************************
 469  * Cypress serial driver functions
 470  *****************************************************************************/
 471
 472
 473 static int generic_startup (struct usb_serial *serial)
 474 {
 475         struct cypress_private *priv;
 476         struct usb_serial_port *port = serial->port[0];
 477
 478         dbg("%s - port %d", __func__, port->number);
 479
 480         priv = kzalloc(sizeof (struct cypress_private), GFP_KERNEL);
 481         if (!priv)
 482                 return -ENOMEM;
 483
 484         priv->comm_is_ok = !0;
 485         spin_lock_init(&priv->lock);
 486         priv->buf = cypress_buf_alloc(CYPRESS_BUF_SIZE);
 487         if (priv->buf == NULL) {
 488                 kfree(priv);
 489                 return -ENOMEM;
 490         }
 491         init_waitqueue_head(&priv->delta_msr_wait);
 492
 493         usb_reset_configuration (serial->dev);
 494
 495         priv->cmd_ctrl = 0;
 496         priv->line_control = 0;
 497         priv->termios_initialized = 0;
 498         priv->rx_flags = 0;
 499         /* Default packet format setting is determined by packet size.
 500            Anything with a size larger then 9 must have a separate
 501            count field since the 3 bit count field is otherwise too
 502            small.  Otherwise we can use the slightly more compact
 503            format.  This is in accordance with the cypress_m8 serial
 504            converter app note. */
 505         if (port->interrupt_out_size > 9) {
 506                 priv->pkt_fmt = packet_format_1;
 507         } else {
 508                 priv->pkt_fmt = packet_format_2;
 509         }
 510         if (interval > 0) {
 511                 priv->write_urb_interval = interval;
 512                 priv->read_urb_interval = interval;
 513                 dbg("%s - port %d read & write intervals forced to %d",
 514                     __func__,port->number,interval);
 515         } else {
 516                 priv->write_urb_interval = port->interrupt_out_urb->interval;
 517                 priv->read_urb_interval = port->interrupt_in_urb->interval;
 518                 dbg("%s - port %d intervals: read=%d write=%d",
 519                     __func__,port->number,
 520                     priv->read_urb_interval,priv->write_urb_interval);
 521         }
 522         usb_set_serial_port_data(port, priv);
 523
 524         return 0;
 525 }
 526
 527
 528 static int cypress_earthmate_startup (struct usb_serial *serial)
 529 {
 530         struct cypress_private *priv;
 531         struct usb_serial_port *port = serial->port[0];
 532
 533         dbg("%s", __func__);
 534
 535         if (generic_startup(serial)) {
 536                 dbg("%s - Failed setting up port %d", __func__,
 537                                 port->number);
 538                 return 1;
 539         }
 540
 541         priv = usb_get_serial_port_data(port);
 542         priv->chiptype = CT_EARTHMATE;
 543         /* All Earthmate devices use the separated-count packet
 544            format!  Idiotic. */
 545         priv->pkt_fmt = packet_format_1;
 546         if (serial->dev->descriptor.idProduct != cpu_to_le16(PRODUCT_ID_EARTHMATEUSB)) {
 547                 /* The old original USB Earthmate seemed able to
 548                    handle GET_CONFIG requests; everything they've
 549                    produced since that time crashes if this command is
 550                    attempted :-( */
 551                 dbg("%s - Marking this device as unsafe for GET_CONFIG "
 552                     "commands", __func__);
 553                 priv->get_cfg_unsafe = !0;
 554         }
 555
 556         return 0;
 557 } /* cypress_earthmate_startup */
 558
 559
 560 static int cypress_hidcom_startup (struct usb_serial *serial)
 561 {
 562         struct cypress_private *priv;
 563
 564         dbg("%s", __func__);
 565
 566         if (generic_startup(serial)) {
 567                 dbg("%s - Failed setting up port %d", __func__,
 568                                 serial->port[0]->number);
 569                 return 1;
 570         }
 571
 572         priv = usb_get_serial_port_data(serial->port[0]);
 573         priv->chiptype = CT_CYPHIDCOM;
 574
 575         return 0;
 576 } /* cypress_hidcom_startup */
 577
 578
 579 static int cypress_ca42v2_startup (struct usb_serial *serial)
 580 {
 581         struct cypress_private *priv;
 582
 583         dbg("%s", __func__);
 584
 585         if (generic_startup(serial)) {
 586                 dbg("%s - Failed setting up port %d", __func__,
 587                                 serial->port[0]->number);
 588                 return 1;
 589         }
 590
 591         priv = usb_get_serial_port_data(serial->port[0]);
 592         priv->chiptype = CT_CA42V2;
 593
 594         return 0;
 595 } /* cypress_ca42v2_startup */
 596
 597
 598 static void cypress_shutdown (struct usb_serial *serial)
 599 {
 600         struct cypress_private *priv;
 601
 602         dbg ("%s - port %d", __func__, serial->port[0]->number);
 603
 604         /* all open ports are closed at this point */
 605
 606         priv = usb_get_serial_port_data(serial->port[0]);
 607
 608         if (priv) {
 609                 cypress_buf_free(priv->buf);
 610                 kfree(priv);
 611                 usb_set_serial_port_data(serial->port[0], NULL);
 612         }
 613 }
 614
 615
 616 static int cypress_open(struct tty_struct *tty,
 617                         struct usb_serial_port *port, struct file *filp)
 618 {
 619         struct cypress_private *priv = usb_get_serial_port_data(port);
 620         struct usb_serial *serial = port->serial;
 621         unsigned long flags;
 622         int result = 0;
 623
 624         dbg("%s - port %d", __func__, port->number);
 625
 626         if (!priv->comm_is_ok)
 627                 return -EIO;
 628
 629         /* clear halts before open */
 630         usb_clear_halt(serial->dev, 0x81);
 631         usb_clear_halt(serial->dev, 0x02);
 632
 633         spin_lock_irqsave(&priv->lock, flags);
 634         /* reset read/write statistics */
 635         priv->bytes_in = 0;
 636         priv->bytes_out = 0;
 637         priv->cmd_count = 0;
 638         priv->rx_flags = 0;
 639         spin_unlock_irqrestore(&priv->lock, flags);
 640
 641         /* setting to zero could cause data loss */
 642         if (tty)
 643                 tty->low_latency = 1;
 644
 645         /* raise both lines and set termios */
 646         spin_lock_irqsave(&priv->lock, flags);
 647         priv->line_control = CONTROL_DTR | CONTROL_RTS;
 648         priv->cmd_ctrl = 1;
 649         spin_unlock_irqrestore(&priv->lock, flags);
 650         result = cypress_write(tty, port, NULL, 0);
 651
 652         if (result) {
 653                 dev_err(&port->dev, "%s - failed setting the control lines - error %d\n", __func__, result);
 654                 return result;
 655         } else
 656                 dbg("%s - success setting the control lines", __func__);
 657
 658         if (tty)
 659                 cypress_set_termios(tty, port, &priv->tmp_termios);
 660
 661         /* setup the port and start reading from the device */
 662         if(!port->interrupt_in_urb){
 663                 err("%s - interrupt_in_urb is empty!", __func__);
 664                 return(-1);
 665         }
 666
 667         usb_fill_int_urb(port->interrupt_in_urb, serial->dev,
 668                 usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),
 669                 port->interrupt_in_urb->transfer_buffer, port->interrupt_in_urb->transfer_buffer_length,
 670                 cypress_read_int_callback, port, priv->read_urb_interval);
 671         result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
 672
 673         if (result){
 674                 dev_err(&port->dev, "%s - failed submitting read urb, error %d\n", __func__, result);
 675                 cypress_set_dead(port);
 676         }
 677
 678         return result;
 679 } /* cypress_open */
 680
 681
 682 static void cypress_close(struct tty_struct *tty,
 683                         struct usb_serial_port *port, struct file * filp)
 684 {
 685         struct cypress_private *priv = usb_get_serial_port_data(port);
 686         unsigned int c_cflag;
 687         int bps;
 688         long timeout;
 689         wait_queue_t wait;
 690
 691         dbg("%s - port %d", __func__, port->number);
 692
 693         /* wait for data to drain from buffer */
 694         spin_lock_irq(&priv->lock);
 695         timeout = CYPRESS_CLOSING_WAIT;
 696         init_waitqueue_entry(&wait, current);
 697         add_wait_queue(&tty->write_wait, &wait);
 698         for (;;) {
 699                 set_current_state(TASK_INTERRUPTIBLE);
 700                 if (cypress_buf_data_avail(priv->buf) == 0
 701                 || timeout == 0 || signal_pending(current)
 702                 /* without mutex, allowed due to harmless failure mode */
 703                 || port->serial->disconnected)
 704                         break;
 705                 spin_unlock_irq(&priv->lock);
 706                 timeout = schedule_timeout(timeout);
 707                 spin_lock_irq(&priv->lock);
 708         }
 709         set_current_state(TASK_RUNNING);
 710         remove_wait_queue(&tty->write_wait, &wait);
 711         /* clear out any remaining data in the buffer */
 712         cypress_buf_clear(priv->buf);
 713         spin_unlock_irq(&priv->lock);
 714
 715         /* writing is potentially harmful, lock must be taken */
 716         mutex_lock(&port->serial->disc_mutex);
 717         if (port->serial->disconnected) {
 718                 mutex_unlock(&port->serial->disc_mutex);
 719                 return;
 720         }
 721         /* wait for characters to drain from device */
 722         if (tty) {
 723                 bps = tty_get_baud_rate(tty);
 724                 if (bps > 1200)
 725                         timeout = max((HZ*2560)/bps,HZ/10);
 726                 else
 727                         timeout = 2*HZ;
 728                 schedule_timeout_interruptible(timeout);
 729         }
 730
 731         dbg("%s - stopping urbs", __func__);
 732         usb_kill_urb (port->interrupt_in_urb);
 733         usb_kill_urb (port->interrupt_out_urb);
 734
 735         if (tty) {
 736                 c_cflag = tty->termios->c_cflag;
 737                 if (c_cflag & HUPCL) {
 738                         /* drop dtr and rts */
 739                         priv = usb_get_serial_port_data(port);
 740                         spin_lock_irq(&priv->lock);
 741                         priv->line_control = 0;
 742                         priv->cmd_ctrl = 1;
 743                         spin_unlock_irq(&priv->lock);
 744                         cypress_write(tty, port, NULL, 0);
 745                 }
 746         }
 747
 748         if (stats)
 749                 dev_info (&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
 750                           priv->bytes_in, priv->bytes_out, priv->cmd_count);
 751         mutex_unlock(&port->serial->disc_mutex);
 752 } /* cypress_close */
 753
 754
 755 static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
 756                                         const unsigned char *buf, int count)
 757 {
 758         struct cypress_private *priv = usb_get_serial_port_data(port);
 759         unsigned long flags;
 760
 761         dbg("%s - port %d, %d bytes", __func__, port->number, count);
 762
 763         /* line control commands, which need to be executed immediately,
 764            are not put into the buffer for obvious reasons.
 765          */
 766         if (priv->cmd_ctrl) {
 767                 count = 0;
 768                 goto finish;
 769         }
 770
 771         if (!count)
 772                 return count;
 773
 774         spin_lock_irqsave(&priv->lock, flags);
 775         count = cypress_buf_put(priv->buf, buf, count);
 776         spin_unlock_irqrestore(&priv->lock, flags);
 777
 778 finish:
 779         cypress_send(port);
 780
 781         return count;
 782 } /* cypress_write */
 783
 784
 785 static void cypress_send(struct usb_serial_port *port)
 786 {
 787         int count = 0, result, offset, actual_size;
 788         struct cypress_private *priv = usb_get_serial_port_data(port);
 789         unsigned long flags;
 790
 791         if (!priv->comm_is_ok)
 792                 return;
 793
 794         dbg("%s - port %d", __func__, port->number);
 795         dbg("%s - interrupt out size is %d", __func__, port->interrupt_out_size);
 796
 797         spin_lock_irqsave(&priv->lock, flags);
 798         if (priv->write_urb_in_use) {
 799                 dbg("%s - can't write, urb in use", __func__);
 800                 spin_unlock_irqrestore(&priv->lock, flags);
 801                 return;
 802         }
 803         spin_unlock_irqrestore(&priv->lock, flags);
 804
 805         /* clear buffer */
 806         memset(port->interrupt_out_urb->transfer_buffer, 0, port->interrupt_out_size);
 807
 808         spin_lock_irqsave(&priv->lock, flags);
 809         switch (priv->pkt_fmt) {
 810         default:
 811         case packet_format_1:
 812                 /* this is for the CY7C64013... */
 813                 offset = 2;
 814                 port->interrupt_out_buffer[0] = priv->line_control;
 815                 break;
 816         case packet_format_2:
 817                 /* this is for the CY7C63743... */
 818                 offset = 1;
 819                 port->interrupt_out_buffer[0] = priv->line_control;
 820                 break;
 821         }
 822
 823         if (priv->line_control & CONTROL_RESET)
 824                 priv->line_control &= ~CONTROL_RESET;
 825
 826         if (priv->cmd_ctrl) {
 827                 priv->cmd_count++;
 828                 dbg("%s - line control command being issued", __func__);
 829                 spin_unlock_irqrestore(&priv->lock, flags);
 830                 goto send;
 831         } else
 832                 spin_unlock_irqrestore(&priv->lock, flags);
 833
 834         count = cypress_buf_get(priv->buf, &port->interrupt_out_buffer[offset],
 835                                 port->interrupt_out_size-offset);
 836
 837         if (count == 0) {
 838                 return;
 839         }
 840
 841         switch (priv->pkt_fmt) {
 842         default:
 843         case packet_format_1:
 844                 port->interrupt_out_buffer[1] = count;
 845                 break;
 846         case packet_format_2:
 847                 port->interrupt_out_buffer[0] |= count;
 848         }
 849
 850         dbg("%s - count is %d", __func__, count);
 851
 852 send:
 853         spin_lock_irqsave(&priv->lock, flags);
 854         priv->write_urb_in_use = 1;
 855         spin_unlock_irqrestore(&priv->lock, flags);
 856
 857         if (priv->cmd_ctrl)
 858                 actual_size = 1;
 859         else
 860                 actual_size = count +
 861                               (priv->pkt_fmt == packet_format_1 ? 2 : 1);
 862
 863         usb_serial_debug_data(debug, &port->dev, __func__, port->interrupt_out_size,
 864                               port->interrupt_out_urb->transfer_buffer);
 865
 866         usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev,
 867                 usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress),
 868                 port->interrupt_out_buffer, port->interrupt_out_size,
 869                 cypress_write_int_callback, port, priv->write_urb_interval);
 870         result = usb_submit_urb (port->interrupt_out_urb, GFP_ATOMIC);
 871         if (result) {
 872                 dev_err(&port->dev, "%s - failed submitting write urb, error %d\n", __func__,
 873                         result);
 874                 priv->write_urb_in_use = 0;
 875                 cypress_set_dead(port);
 876         }
 877
 878         spin_lock_irqsave(&priv->lock, flags);
 879         if (priv->cmd_ctrl) {
 880                 priv->cmd_ctrl = 0;
 881         }
 882         priv->bytes_out += count; /* do not count the line control and size bytes */
 883         spin_unlock_irqrestore(&priv->lock, flags);
 884
 885         usb_serial_port_softint(port);
 886 } /* cypress_send */
 887
 888
 889 /* returns how much space is available in the soft buffer */
 890 static int cypress_write_room(struct tty_struct *tty)
 891 {
 892         struct usb_serial_port *port = tty->driver_data;
 893         struct cypress_private *priv = usb_get_serial_port_data(port);
 894         int room = 0;
 895         unsigned long flags;
 896
 897         dbg("%s - port %d", __func__, port->number);
 898
 899         spin_lock_irqsave(&priv->lock, flags);
 900         room = cypress_buf_space_avail(priv->buf);
 901         spin_unlock_irqrestore(&priv->lock, flags);
 902
 903         dbg("%s - returns %d", __func__, room);
 904         return room;
 905 }
 906
 907
 908 static int cypress_tiocmget(struct tty_struct *tty, struct file *file)
 909 {
 910         struct usb_serial_port *port = tty->driver_data;
 911         struct cypress_private *priv = usb_get_serial_port_data(port);
 912         __u8 status, control;
 913         unsigned int result = 0;
 914         unsigned long flags;
 915
 916         dbg("%s - port %d", __func__, port->number);
 917
 918         spin_lock_irqsave(&priv->lock, flags);
 919         control = priv->line_control;
 920         status = priv->current_status;
 921         spin_unlock_irqrestore(&priv->lock, flags);
 922
 923         result = ((control & CONTROL_DTR)        ? TIOCM_DTR : 0)
 924                 | ((control & CONTROL_RTS)       ? TIOCM_RTS : 0)
 925                 | ((status & UART_CTS)        ? TIOCM_CTS : 0)
 926                 | ((status & UART_DSR)        ? TIOCM_DSR : 0)
 927                 | ((status & UART_RI)         ? TIOCM_RI  : 0)
 928                 | ((status & UART_CD)         ? TIOCM_CD  : 0);
 929
 930         dbg("%s - result = %x", __func__, result);
 931
 932         return result;
 933 }
 934
 935
 936 static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
 937                                unsigned int set, unsigned int clear)
 938 {
 939         struct usb_serial_port *port = tty->driver_data;
 940         struct cypress_private *priv = usb_get_serial_port_data(port);
 941         unsigned long flags;
 942
 943         dbg("%s - port %d", __func__, port->number);
 944
 945         spin_lock_irqsave(&priv->lock, flags);
 946         if (set & TIOCM_RTS)
 947                 priv->line_control |= CONTROL_RTS;
 948         if (set & TIOCM_DTR)
 949                 priv->line_control |= CONTROL_DTR;
 950         if (clear & TIOCM_RTS)
 951                 priv->line_control &= ~CONTROL_RTS;
 952         if (clear & TIOCM_DTR)
 953                 priv->line_control &= ~CONTROL_DTR;
 954         priv->cmd_ctrl = 1;
 955         spin_unlock_irqrestore(&priv->lock, flags);
 956
 957         return cypress_write(tty, port, NULL, 0);
 958 }
 959
 960
 961 static int cypress_ioctl(struct tty_struct *tty, struct file * file,
 962                                         unsigned int cmd, unsigned long arg)
 963 {
 964         struct usb_serial_port *port = tty->driver_data;
 965         struct cypress_private *priv = usb_get_serial_port_data(port);
 966
 967         dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
 968
 969         switch (cmd) {
 970                 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
 971                 case TIOCMIWAIT:
 972                         while (priv != NULL) {
 973                                 interruptible_sleep_on(&priv->delta_msr_wait);
 974                                 /* see if a signal did it */
 975                                 if (signal_pending(current))
 976                                         return -ERESTARTSYS;
 977                                 else {
 978                                         char diff = priv->diff_status;
 979
 980                                         if (diff == 0) {
 981                                                 return -EIO; /* no change => error */
 982                                         }
 983
 984                                         /* consume all events */
 985                                         priv->diff_status = 0;
 986
 987                                         /* return 0 if caller wanted to know about these bits */
 988                                         if ( ((arg & TIOCM_RNG) && (diff & UART_RI)) ||
 989                                              ((arg & TIOCM_DSR) && (diff & UART_DSR)) ||
 990                                              ((arg & TIOCM_CD) && (diff & UART_CD)) ||
 991                                              ((arg & TIOCM_CTS) && (diff & UART_CTS)) ) {
 992                                                 return 0;
 993                                         }
 994                                         /* otherwise caller can't care less about what happened,
 995                                          * and so we continue to wait for more events.
 996                                          */
 997                                 }
 998                         }
 999                         return 0;
1000                 default:
1001                         break;
1002         }
1003         dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd);
1004         return -ENOIOCTLCMD;
1005 } /* cypress_ioctl */
1006
1007
1008 static void cypress_set_termios(struct tty_struct *tty,
1009         struct usb_serial_port *port, struct ktermios *old_termios)
1010 {
1011         struct cypress_private *priv = usb_get_serial_port_data(port);
1012         int data_bits, stop_bits, parity_type, parity_enable;
1013         unsigned cflag, iflag;
1014         unsigned long flags;
1015         __u8 oldlines;
1016         int linechange = 0;
1017
1018         dbg("%s - port %d", __func__, port->number);
1019
1020         spin_lock_irqsave(&priv->lock, flags);
1021         if (!priv->termios_initialized) {
1022                 if (priv->chiptype == CT_EARTHMATE) {
1023                         *(tty->termios) = tty_std_termios;
1024                         tty->termios->c_cflag = B4800 | CS8 | CREAD | HUPCL |
1025                                 CLOCAL;
1026                         tty->termios->c_ispeed = 4800;
1027                         tty->termios->c_ospeed = 4800;
1028                 } else if (priv->chiptype == CT_CYPHIDCOM) {
1029                         *(tty->termios) = tty_std_termios;
1030                         tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
1031                                 CLOCAL;
1032                         tty->termios->c_ispeed = 9600;
1033                         tty->termios->c_ospeed = 9600;
1034                 } else if (priv->chiptype == CT_CA42V2) {
1035                         *(tty->termios) = tty_std_termios;
1036                         tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
1037                                 CLOCAL;
1038                         tty->termios->c_ispeed = 9600;
1039                         tty->termios->c_ospeed = 9600;
1040                 }
1041                 priv->termios_initialized = 1;
1042         }
1043         spin_unlock_irqrestore(&priv->lock, flags);
1044
1045         /* Unsupported features need clearing */
1046         tty->termios->c_cflag &= ~(CMSPAR|CRTSCTS);
1047
1048         cflag = tty->termios->c_cflag;
1049         iflag = tty->termios->c_iflag;
1050
1051         /* check if there are new settings */
1052         if (old_termios) {
1053                 spin_lock_irqsave(&priv->lock, flags);
1054                 priv->tmp_termios = *(tty->termios);
1055                 spin_unlock_irqrestore(&priv->lock, flags);
1056         }
1057
1058         /* set number of data bits, parity, stop bits */
1059         /* when parity is disabled the parity type bit is ignored */
1060
1061         /* 1 means 2 stop bits, 0 means 1 stop bit */
1062         stop_bits = cflag & CSTOPB ? 1 : 0;
1063
1064         if (cflag & PARENB) {
1065                 parity_enable = 1;
1066                 /* 1 means odd parity, 0 means even parity */
1067                 parity_type = cflag & PARODD ? 1 : 0;
1068         } else
1069                 parity_enable = parity_type = 0;
1070
1071         if (cflag & CSIZE) {
1072                 switch (cflag & CSIZE) {
1073                         case CS5:
1074                                 data_bits = 0;
1075                                 break;
1076                         case CS6:
1077                                 data_bits = 1;
1078                                 break;
1079                         case CS7:
1080                                 data_bits = 2;
1081                                 break;
1082                         case CS8:
1083                                 data_bits = 3;
1084                                 break;
1085                         default:
1086                                 err("%s - CSIZE was set, but not CS5-CS8",
1087                                                 __func__);
1088                                 data_bits = 3;
1089                 }
1090         } else
1091                 data_bits = 3;
1092
1093         spin_lock_irqsave(&priv->lock, flags);
1094         oldlines = priv->line_control;
1095         if ((cflag & CBAUD) == B0) {
1096                 /* drop dtr and rts */
1097                 dbg("%s - dropping the lines, baud rate 0bps", __func__);
1098                 priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
1099         } else
1100                 priv->line_control = (CONTROL_DTR | CONTROL_RTS);
1101         spin_unlock_irqrestore(&priv->lock, flags);
1102
1103         dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
1104                         "%d data_bits (+5)", __func__, stop_bits,
1105                         parity_enable, parity_type, data_bits);
1106
1107         cypress_serial_control(tty, port, tty_get_baud_rate(tty), data_bits, stop_bits,
1108                         parity_enable, parity_type, 0, CYPRESS_SET_CONFIG);
1109
1110         /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1111          * filled into the private structure this should confirm that all is
1112          * working if it returns what we just set */
1113         cypress_serial_control(tty, port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
1114
1115         /* Here we can define custom tty settings for devices; the main tty
1116          * termios flag base comes from empeg.c */
1117
1118         spin_lock_irqsave(&priv->lock, flags);
1119         if ( (priv->chiptype == CT_EARTHMATE) && (priv->baud_rate == 4800) ) {
1120                 dbg("Using custom termios settings for a baud rate of "
1121                                 "4800bps.");
1122                 /* define custom termios settings for NMEA protocol */
1123
1124                 tty->termios->c_iflag /* input modes - */
1125                         &= ~(IGNBRK  /* disable ignore break */
1126                         | BRKINT     /* disable break causes interrupt */
1127                         | PARMRK     /* disable mark parity errors */
1128                         | ISTRIP     /* disable clear high bit of input char */
1129                         | INLCR      /* disable translate NL to CR */
1130                         | IGNCR      /* disable ignore CR */
1131                         | ICRNL      /* disable translate CR to NL */
1132                         | IXON);     /* disable enable XON/XOFF flow control */
1133
1134                 tty->termios->c_oflag /* output modes */
1135                         &= ~OPOST;    /* disable postprocess output char */
1136
1137                 tty->termios->c_lflag /* line discipline modes */
1138                         &= ~(ECHO     /* disable echo input characters */
1139                         | ECHONL      /* disable echo new line */
1140                         | ICANON      /* disable erase, kill, werase, and rprnt
1141                                          special characters */
1142                         | ISIG        /* disable interrupt, quit, and suspend
1143                                          special characters */
1144                         | IEXTEN);    /* disable non-POSIX special characters */
1145         } /* CT_CYPHIDCOM: Application should handle this for device */
1146
1147         linechange = (priv->line_control != oldlines);
1148         spin_unlock_irqrestore(&priv->lock, flags);
1149
1150         /* if necessary, set lines */
1151         if (linechange) {
1152                 priv->cmd_ctrl = 1;
1153                 cypress_write(tty, port, NULL, 0);
1154         }
1155 } /* cypress_set_termios */
1156
1157
1158 /* returns amount of data still left in soft buffer */
1159 static int cypress_chars_in_buffer(struct tty_struct *tty)
1160 {
1161         struct usb_serial_port *port = tty->driver_data;
1162         struct cypress_private *priv = usb_get_serial_port_data(port);
1163         int chars = 0;
1164         unsigned long flags;
1165
1166         dbg("%s - port %d", __func__, port->number);
1167
1168         spin_lock_irqsave(&priv->lock, flags);
1169         chars = cypress_buf_data_avail(priv->buf);
1170         spin_unlock_irqrestore(&priv->lock, flags);
1171
1172         dbg("%s - returns %d", __func__, chars);
1173         return chars;
1174 }
1175
1176
1177 static void cypress_throttle(struct tty_struct *tty)
1178 {
1179         struct usb_serial_port *port = tty->driver_data;
1180         struct cypress_private *priv = usb_get_serial_port_data(port);
1181         unsigned long flags;
1182
1183         dbg("%s - port %d", __func__, port->number);
1184
1185         spin_lock_irqsave(&priv->lock, flags);
1186         priv->rx_flags = THROTTLED;
1187         spin_unlock_irqrestore(&priv->lock, flags);
1188 }
1189
1190
1191 static void cypress_unthrottle(struct tty_struct *tty)
1192 {
1193         struct usb_serial_port *port = tty->driver_data;
1194         struct cypress_private *priv = usb_get_serial_port_data(port);
1195         int actually_throttled, result;
1196         unsigned long flags;
1197
1198         dbg("%s - port %d", __func__, port->number);
1199
1200         spin_lock_irqsave(&priv->lock, flags);
1201         actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
1202         priv->rx_flags = 0;
1203         spin_unlock_irqrestore(&priv->lock, flags);
1204
1205         if (!priv->comm_is_ok)
1206                 return;
1207
1208         if (actually_throttled) {
1209                 port->interrupt_in_urb->dev = port->serial->dev;
1210
1211                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
1212                 if (result) {
1213                         dev_err(&port->dev, "%s - failed submitting read urb, "
1214                                         "error %d\n", __func__, result);
1215                         cypress_set_dead(port);
1216                 }
1217         }
1218 }
1219
1220
1221 static void cypress_read_int_callback(struct urb *urb)
1222 {
1223         struct usb_serial_port *port = urb->context;
1224         struct cypress_private *priv = usb_get_serial_port_data(port);
1225         struct tty_struct *tty;
1226         unsigned char *data = urb->transfer_buffer;
1227         unsigned long flags;
1228         char tty_flag = TTY_NORMAL;
1229         int havedata = 0;
1230         int bytes = 0;
1231         int result;
1232         int i = 0;
1233         int status = urb->status;
1234
1235         dbg("%s - port %d", __func__, port->number);
1236
1237         switch (status) {
1238         case 0: /* success */
1239                 break;
1240         case -ECONNRESET:
1241         case -ENOENT:
1242         case -ESHUTDOWN:
1243                 /* precursor to disconnect so just go away */
1244                 return;
1245         case -EPIPE:
1246                 usb_clear_halt(port->serial->dev,0x81);
1247                 break;
1248         default:
1249                 /* something ugly is going on... */
1250                 dev_err(&urb->dev->dev,"%s - unexpected nonzero read status received: %d\n",
1251                         __func__, status);
1252                 cypress_set_dead(port);
1253                 return;
1254         }
1255
1256         spin_lock_irqsave(&priv->lock, flags);
1257         if (priv->rx_flags & THROTTLED) {
1258                 dbg("%s - now throttling", __func__);
1259                 priv->rx_flags |= ACTUALLY_THROTTLED;
1260                 spin_unlock_irqrestore(&priv->lock, flags);
1261                 return;
1262         }
1263         spin_unlock_irqrestore(&priv->lock, flags);
1264
1265         tty = port->port.tty;
1266         if (!tty) {
1267                 dbg("%s - bad tty pointer - exiting", __func__);
1268                 return;
1269         }
1270
1271         spin_lock_irqsave(&priv->lock, flags);
1272         result = urb->actual_length;
1273         switch (priv->pkt_fmt) {
1274         default:
1275         case packet_format_1:
1276                 /* This is for the CY7C64013... */
1277                 priv->current_status = data[0] & 0xF8;
1278                 bytes = data[1] + 2;
1279                 i = 2;
1280                 if (bytes > 2)
1281                         havedata = 1;
1282                 break;
1283         case packet_format_2:
1284                 /* This is for the CY7C63743... */
1285                 priv->current_status = data[0] & 0xF8;
1286                 bytes = (data[0] & 0x07) + 1;
1287                 i = 1;
1288                 if (bytes > 1)
1289                         havedata = 1;
1290                 break;
1291         }
1292         spin_unlock_irqrestore(&priv->lock, flags);
1293         if (result < bytes) {
1294                 dbg("%s - wrong packet size - received %d bytes but packet "
1295                     "said %d bytes", __func__, result, bytes);
1296                 goto continue_read;
1297         }
1298
1299         usb_serial_debug_data (debug, &port->dev, __func__,
1300                         urb->actual_length, data);
1301
1302         spin_lock_irqsave(&priv->lock, flags);
1303         /* check to see if status has changed */
1304         if (priv->current_status != priv->prev_status) {
1305                 priv->diff_status |= priv->current_status ^
1306                         priv->prev_status;
1307                 wake_up_interruptible(&priv->delta_msr_wait);
1308                 priv->prev_status = priv->current_status;
1309         }
1310         spin_unlock_irqrestore(&priv->lock, flags);
1311
1312         /* hangup, as defined in acm.c... this might be a bad place for it
1313          * though */
1314         if (tty && !(tty->termios->c_cflag & CLOCAL) &&
1315                         !(priv->current_status & UART_CD)) {
1316                 dbg("%s - calling hangup", __func__);
1317                 tty_hangup(tty);
1318                 goto continue_read;
1319         }
1320
1321         /* There is one error bit... I'm assuming it is a parity error
1322          * indicator as the generic firmware will set this bit to 1 if a
1323          * parity error occurs.
1324          * I can not find reference to any other error events. */
1325         spin_lock_irqsave(&priv->lock, flags);
1326         if (priv->current_status & CYP_ERROR) {
1327                 spin_unlock_irqrestore(&priv->lock, flags);
1328                 tty_flag = TTY_PARITY;
1329                 dbg("%s - Parity Error detected", __func__);
1330         } else
1331                 spin_unlock_irqrestore(&priv->lock, flags);
1332
1333         /* process read if there is data other than line status */
1334         if (tty && (bytes > i)) {
1335                 bytes = tty_buffer_request_room(tty, bytes);
1336                 for (; i < bytes ; ++i) {
1337                         dbg("pushing byte number %d - %d - %c", i, data[i],
1338                                         data[i]);
1339                         tty_insert_flip_char(tty, data[i], tty_flag);
1340                 }
1341                 tty_flip_buffer_push(port->port.tty);
1342         }
1343
1344         spin_lock_irqsave(&priv->lock, flags);
1345         /* control and status byte(s) are also counted */
1346         priv->bytes_in += bytes;
1347         spin_unlock_irqrestore(&priv->lock, flags);
1348
1349 continue_read:
1350
1351         /* Continue trying to always read... unless the port has closed. */
1352
1353         if (port->port.count > 0 && priv->comm_is_ok) {
1354                 usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
1355                                 usb_rcvintpipe(port->serial->dev,
1356                                         port->interrupt_in_endpointAddress),
1357                                 port->interrupt_in_urb->transfer_buffer,
1358                                 port->interrupt_in_urb->transfer_buffer_length,
1359                                 cypress_read_int_callback, port, priv->read_urb_interval);
1360                 result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
1361                 if (result) {
1362                         dev_err(&urb->dev->dev, "%s - failed resubmitting "
1363                                         "read urb, error %d\n", __func__,
1364                                         result);
1365                         cypress_set_dead(port);
1366                 }
1367         }
1368
1369         return;
1370 } /* cypress_read_int_callback */
1371
1372
1373 static void cypress_write_int_callback(struct urb *urb)
1374 {
1375         struct usb_serial_port *port = urb->context;
1376         struct cypress_private *priv = usb_get_serial_port_data(port);
1377         int result;
1378         int status = urb->status;
1379
1380         dbg("%s - port %d", __func__, port->number);
1381
1382         switch (status) {
1383                 case 0:
1384                         /* success */
1385                         break;
1386                 case -ECONNRESET:
1387                 case -ENOENT:
1388                 case -ESHUTDOWN:
1389                         /* this urb is terminated, clean up */
1390                         dbg("%s - urb shutting down with status: %d",
1391                             __func__, status);
1392                         priv->write_urb_in_use = 0;
1393                         return;
1394                 case -EPIPE: /* no break needed; clear halt and resubmit */
1395                         if (!priv->comm_is_ok)
1396                                 break;
1397                         usb_clear_halt(port->serial->dev, 0x02);
1398                         /* error in the urb, so we have to resubmit it */
1399                         dbg("%s - nonzero write bulk status received: %d",
1400                             __func__, status);
1401                         port->interrupt_out_urb->transfer_buffer_length = 1;
1402                         port->interrupt_out_urb->dev = port->serial->dev;
1403                         result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC);
1404                         if (!result)
1405                                 return;
1406                         dev_err(&urb->dev->dev, "%s - failed resubmitting write urb, error %d\n",
1407                                 __func__, result);
1408                         cypress_set_dead(port);
1409                         break;
1410                 default:
1411                         dev_err(&urb->dev->dev,"%s - unexpected nonzero write status received: %d\n",
1412                                 __func__, status);
1413                         cypress_set_dead(port);
1414                         break;
1415         }
1416
1417         priv->write_urb_in_use = 0;
1418
1419         /* send any buffered data */
1420         cypress_send(port);
1421 }
1422
1423
1424 /*****************************************************************************
1425  * Write buffer functions - buffering code from pl2303 used
1426  *****************************************************************************/
1427
1428 /*
1429  * cypress_buf_alloc
1430  *
1431  * Allocate a circular buffer and all associated memory.
1432  */
1433
1434 static struct cypress_buf *cypress_buf_alloc(unsigned int size)
1435 {
1436
1437         struct cypress_buf *cb;
1438
1439
1440         if (size == 0)
1441                 return NULL;
1442
1443         cb = kmalloc(sizeof(struct cypress_buf), GFP_KERNEL);
1444         if (cb == NULL)
1445                 return NULL;
1446
1447         cb->buf_buf = kmalloc(size, GFP_KERNEL);
1448         if (cb->buf_buf == NULL) {
1449                 kfree(cb);
1450                 return NULL;
1451         }
1452
1453         cb->buf_size = size;
1454         cb->buf_get = cb->buf_put = cb->buf_buf;
1455
1456         return cb;
1457
1458 }
1459
1460
1461 /*
1462  * cypress_buf_free
1463  *
1464  * Free the buffer and all associated memory.
1465  */
1466
1467 static void cypress_buf_free(struct cypress_buf *cb)
1468 {
1469         if (cb) {
1470                 kfree(cb->buf_buf);
1471                 kfree(cb);
1472         }
1473 }
1474
1475
1476 /*
1477  * cypress_buf_clear
1478  *
1479  * Clear out all data in the circular buffer.
1480  */
1481
1482 static void cypress_buf_clear(struct cypress_buf *cb)
1483 {
1484         if (cb != NULL)
1485                 cb->buf_get = cb->buf_put;
1486                 /* equivalent to a get of all data available */
1487 }
1488
1489
1490 /*
1491  * cypress_buf_data_avail
1492  *
1493  * Return the number of bytes of data available in the circular
1494  * buffer.
1495  */
1496
1497 static unsigned int cypress_buf_data_avail(struct cypress_buf *cb)
1498 {
1499         if (cb != NULL)
1500                 return ((cb->buf_size + cb->buf_put - cb->buf_get) % cb->buf_size);
1501         else
1502                 return 0;
1503 }
1504
1505
1506 /*
1507  * cypress_buf_space_avail
1508  *
1509  * Return the number of bytes of space available in the circular
1510  * buffer.
1511  */
1512
1513 static unsigned int cypress_buf_space_avail(struct cypress_buf *cb)
1514 {
1515         if (cb != NULL)
1516                 return ((cb->buf_size + cb->buf_get - cb->buf_put - 1) % cb->buf_size);
1517         else
1518                 return 0;
1519 }
1520
1521
1522 /*
1523  * cypress_buf_put
1524  *
1525  * Copy data data from a user buffer and put it into the circular buffer.
1526  * Restrict to the amount of space available.
1527  *
1528  * Return the number of bytes copied.
1529  */
1530
1531 static unsigned int cypress_buf_put(struct cypress_buf *cb, const char *buf,
1532         unsigned int count)
1533 {
1534
1535         unsigned int len;
1536
1537
1538         if (cb == NULL)
1539                 return 0;
1540
1541         len  = cypress_buf_space_avail(cb);
1542         if (count > len)
1543                 count = len;
1544
1545         if (count == 0)
1546                 return 0;
1547
1548         len = cb->buf_buf + cb->buf_size - cb->buf_put;
1549         if (count > len) {
1550                 memcpy(cb->buf_put, buf, len);
1551                 memcpy(cb->buf_buf, buf+len, count - len);
1552                 cb->buf_put = cb->buf_buf + count - len;
1553         } else {
1554                 memcpy(cb->buf_put, buf, count);
1555                 if (count < len)
1556                         cb->buf_put += count;
1557                 else /* count == len */
1558                         cb->buf_put = cb->buf_buf;
1559         }
1560
1561         return count;
1562
1563 }
1564
1565
1566 /*
1567  * cypress_buf_get
1568  *
1569  * Get data from the circular buffer and copy to the given buffer.
1570  * Restrict to the amount of data available.
1571  *
1572  * Return the number of bytes copied.
1573  */
1574
1575 static unsigned int cypress_buf_get(struct cypress_buf *cb, char *buf,
1576         unsigned int count)
1577 {
1578
1579         unsigned int len;
1580
1581
1582         if (cb == NULL)
1583                 return 0;
1584
1585         len = cypress_buf_data_avail(cb);
1586         if (count > len)
1587                 count = len;
1588
1589         if (count == 0)
1590                 return 0;
1591
1592         len = cb->buf_buf + cb->buf_size - cb->buf_get;
1593         if (count > len) {
1594                 memcpy(buf, cb->buf_get, len);
1595                 memcpy(buf+len, cb->buf_buf, count - len);
1596                 cb->buf_get = cb->buf_buf + count - len;
1597         } else {
1598                 memcpy(buf, cb->buf_get, count);
1599                 if (count < len)
1600                         cb->buf_get += count;
1601                 else /* count == len */
1602                         cb->buf_get = cb->buf_buf;
1603         }
1604
1605         return count;
1606
1607 }
1608
1609 /*****************************************************************************
1610  * Module functions
1611  *****************************************************************************/
1612
1613 static int __init cypress_init(void)
1614 {
1615         int retval;
1616
1617         dbg("%s", __func__);
1618
1619         retval = usb_serial_register(&cypress_earthmate_device);
1620         if (retval)
1621                 goto failed_em_register;
1622         retval = usb_serial_register(&cypress_hidcom_device);
1623         if (retval)
1624                 goto failed_hidcom_register;
1625         retval = usb_serial_register(&cypress_ca42v2_device);
1626         if (retval)
1627                 goto failed_ca42v2_register;
1628         retval = usb_register(&cypress_driver);
1629         if (retval)
1630                 goto failed_usb_register;
1631
1632         info(DRIVER_DESC " " DRIVER_VERSION);
1633         return 0;
1634
1635 failed_usb_register:
1636         usb_serial_deregister(&cypress_ca42v2_device);
1637 failed_ca42v2_register:
1638         usb_serial_deregister(&cypress_hidcom_device);
1639 failed_hidcom_register:
1640         usb_serial_deregister(&cypress_earthmate_device);
1641 failed_em_register:
1642         return retval;
1643 }
1644
1645
1646 static void __exit cypress_exit (void)
1647 {
1648         dbg("%s", __func__);
1649
1650         usb_deregister (&cypress_driver);
1651         usb_serial_deregister (&cypress_earthmate_device);
1652         usb_serial_deregister (&cypress_hidcom_device);
1653         usb_serial_deregister (&cypress_ca42v2_device);
1654 }
1655
1656
1657 module_init(cypress_init);
1658 module_exit(cypress_exit);
1659
1660 MODULE_AUTHOR( DRIVER_AUTHOR );
1661 MODULE_DESCRIPTION( DRIVER_DESC );
1662 MODULE_VERSION( DRIVER_VERSION );
1663 MODULE_LICENSE("GPL");
1664
1665 module_param(debug, bool, S_IRUGO | S_IWUSR);
1666 MODULE_PARM_DESC(debug, "Debug enabled or not");
1667 module_param(stats, bool, S_IRUGO | S_IWUSR);
1668 MODULE_PARM_DESC(stats, "Enable statistics or not");
1669 module_param(interval, int, S_IRUGO | S_IWUSR);
1670 MODULE_PARM_DESC(interval, "Overrides interrupt interval");