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