2 * USB Cypress M8 driver
5 * Lonnie Mendez (dignome@gmail.com)
6 * Copyright (C) 2003,2004
7 * Neil Whelchel (koyama@firstlight.net)
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.
14 * See Documentation/usb/usb-serial.txt for more information on using this driver
16 * See http://geocities.com/i0xox0i for information on this driver and the
17 * earthmate usb device.
19 * Lonnie Mendez <dignome@gmail.com>
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.
28 * Lonnie Mendez <dignome@gmail.com>
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.
34 * Lonnie Mendez <dignome@gmail.com>
36 * Driver modified to support dynamic line settings. Various improvments
41 * Driver first released.
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. */
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>
67 #include "usb-serial.h"
68 #include "cypress_m8.h"
71 #ifdef CONFIG_USB_SERIAL_DEBUG
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"
86 /* write buffer size defines */
87 #define CYPRESS_BUF_SIZE 1024
88 #define CYPRESS_CLOSING_WAIT (30*HZ)
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 */
96 static struct usb_device_id id_table_cyphidcomrs232
[] = {
97 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
98 { } /* Terminating entry */
101 static struct usb_device_id id_table_combined
[] = {
102 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
103 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
104 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
105 { } /* Terminating entry */
108 MODULE_DEVICE_TABLE (usb
, id_table_combined
);
110 static struct usb_driver cypress_driver
= {
112 .probe
= usb_serial_probe
,
113 .disconnect
= usb_serial_disconnect
,
114 .id_table
= id_table_combined
,
117 struct cypress_private
{
118 spinlock_t lock
; /* private lock */
119 int chiptype
; /* identifier of device, for quirks/etc */
120 int bytes_in
; /* used for statistics */
121 int bytes_out
; /* used for statistics */
122 int cmd_count
; /* used for statistics */
123 int cmd_ctrl
; /* always set this to 1 before issuing a command */
124 struct cypress_buf
*buf
; /* write buffer */
125 int write_urb_in_use
; /* write urb in use indicator */
126 int termios_initialized
;
127 __u8 line_control
; /* holds dtr / rts value */
128 __u8 current_status
; /* received from last read - info on dsr,cts,cd,ri,etc */
129 __u8 current_config
; /* stores the current configuration byte */
130 __u8 rx_flags
; /* throttling - used from whiteheat/ftdi_sio */
131 int baud_rate
; /* stores current baud rate in integer form */
132 int cbr_mask
; /* stores current baud rate in masked form */
133 int isthrottled
; /* if throttled, discard reads */
134 wait_queue_head_t delta_msr_wait
; /* used for TIOCMIWAIT */
135 char prev_status
, diff_status
; /* used for TIOCMIWAIT */
136 /* we pass a pointer to this as the arguement sent to cypress_set_termios old_termios */
137 struct termios tmp_termios
; /* stores the old termios settings */
140 /* write buffer structure */
142 unsigned int buf_size
;
148 /* function prototypes for the Cypress USB to serial device */
149 static int cypress_earthmate_startup (struct usb_serial
*serial
);
150 static int cypress_hidcom_startup (struct usb_serial
*serial
);
151 static void cypress_shutdown (struct usb_serial
*serial
);
152 static int cypress_open (struct usb_serial_port
*port
, struct file
*filp
);
153 static void cypress_close (struct usb_serial_port
*port
, struct file
*filp
);
154 static int cypress_write (struct usb_serial_port
*port
, const unsigned char *buf
, int count
);
155 static void cypress_send (struct usb_serial_port
*port
);
156 static int cypress_write_room (struct usb_serial_port
*port
);
157 static int cypress_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
);
158 static void cypress_set_termios (struct usb_serial_port
*port
, struct termios
* old
);
159 static int cypress_tiocmget (struct usb_serial_port
*port
, struct file
*file
);
160 static int cypress_tiocmset (struct usb_serial_port
*port
, struct file
*file
, unsigned int set
, unsigned int clear
);
161 static int cypress_chars_in_buffer (struct usb_serial_port
*port
);
162 static void cypress_throttle (struct usb_serial_port
*port
);
163 static void cypress_unthrottle (struct usb_serial_port
*port
);
164 static void cypress_read_int_callback (struct urb
*urb
, struct pt_regs
*regs
);
165 static void cypress_write_int_callback (struct urb
*urb
, struct pt_regs
*regs
);
166 /* baud helper functions */
167 static int mask_to_rate (unsigned mask
);
168 static unsigned rate_to_mask (int rate
);
169 /* write buffer functions */
170 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
);
171 static void cypress_buf_free(struct cypress_buf
*cb
);
172 static void cypress_buf_clear(struct cypress_buf
*cb
);
173 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
);
174 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
);
175 static unsigned int cypress_buf_put(struct cypress_buf
*cb
, const char *buf
, unsigned int count
);
176 static unsigned int cypress_buf_get(struct cypress_buf
*cb
, char *buf
, unsigned int count
);
179 static struct usb_serial_device_type cypress_earthmate_device
= {
180 .owner
= THIS_MODULE
,
181 .name
= "DeLorme Earthmate USB",
182 .short_name
= "earthmate",
183 .id_table
= id_table_earthmate
,
184 .num_interrupt_in
= 1,
185 .num_interrupt_out
= 1,
186 .num_bulk_in
= NUM_DONT_CARE
,
187 .num_bulk_out
= NUM_DONT_CARE
,
189 .attach
= cypress_earthmate_startup
,
190 .shutdown
= cypress_shutdown
,
191 .open
= cypress_open
,
192 .close
= cypress_close
,
193 .write
= cypress_write
,
194 .write_room
= cypress_write_room
,
195 .ioctl
= cypress_ioctl
,
196 .set_termios
= cypress_set_termios
,
197 .tiocmget
= cypress_tiocmget
,
198 .tiocmset
= cypress_tiocmset
,
199 .chars_in_buffer
= cypress_chars_in_buffer
,
200 .throttle
= cypress_throttle
,
201 .unthrottle
= cypress_unthrottle
,
202 .read_int_callback
= cypress_read_int_callback
,
203 .write_int_callback
= cypress_write_int_callback
,
206 static struct usb_serial_device_type cypress_hidcom_device
= {
207 .owner
= THIS_MODULE
,
208 .name
= "HID->COM RS232 Adapter",
209 .short_name
= "cyphidcom",
210 .id_table
= id_table_cyphidcomrs232
,
211 .num_interrupt_in
= 1,
212 .num_interrupt_out
= 1,
213 .num_bulk_in
= NUM_DONT_CARE
,
214 .num_bulk_out
= NUM_DONT_CARE
,
216 .attach
= cypress_hidcom_startup
,
217 .shutdown
= cypress_shutdown
,
218 .open
= cypress_open
,
219 .close
= cypress_close
,
220 .write
= cypress_write
,
221 .write_room
= cypress_write_room
,
222 .ioctl
= cypress_ioctl
,
223 .set_termios
= cypress_set_termios
,
224 .tiocmget
= cypress_tiocmget
,
225 .tiocmset
= cypress_tiocmset
,
226 .chars_in_buffer
= cypress_chars_in_buffer
,
227 .throttle
= cypress_throttle
,
228 .unthrottle
= cypress_unthrottle
,
229 .read_int_callback
= cypress_read_int_callback
,
230 .write_int_callback
= cypress_write_int_callback
,
234 /*****************************************************************************
235 * Cypress serial helper functions
236 *****************************************************************************/
239 /* This function can either set or retrieve the current serial line settings */
240 static int cypress_serial_control (struct usb_serial_port
*port
, unsigned baud_mask
, int data_bits
, int stop_bits
,
241 int parity_enable
, int parity_type
, int reset
, int cypress_request_type
)
243 int new_baudrate
= 0, retval
= 0, tries
= 0;
244 struct cypress_private
*priv
;
245 __u8 feature_buffer
[8];
248 dbg("%s", __FUNCTION__
);
250 priv
= usb_get_serial_port_data(port
);
252 switch(cypress_request_type
) {
253 case CYPRESS_SET_CONFIG
:
256 * The general purpose firmware for the Cypress M8 allows for a maximum speed
257 * of 57600bps (I have no idea whether DeLorme chose to use the general purpose
258 * firmware or not), if you need to modify this speed setting for your own
259 * project please add your own chiptype and modify the code likewise. The
260 * Cypress HID->COM device will work successfully up to 115200bps (but the
261 * actual throughput is around 3kBps).
263 if (baud_mask
!= priv
->cbr_mask
) {
264 dbg("%s - baud rate is changing", __FUNCTION__
);
265 if ( priv
->chiptype
== CT_EARTHMATE
) {
266 /* 300 and 600 baud rates are supported under the generic firmware,
267 * but are not used with NMEA and SiRF protocols */
269 if ( (baud_mask
== B300
) || (baud_mask
== B600
) ) {
270 err("%s - failed setting baud rate, unsupported speed",
272 new_baudrate
= priv
->baud_rate
;
273 } else if ( (new_baudrate
= mask_to_rate(baud_mask
)) == -1) {
274 err("%s - failed setting baud rate, unsupported speed",
276 new_baudrate
= priv
->baud_rate
;
278 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
279 if ( (new_baudrate
= mask_to_rate(baud_mask
)) == -1) {
280 err("%s - failed setting baud rate, unsupported speed",
282 new_baudrate
= priv
->baud_rate
;
284 } else if (priv
->chiptype
== CT_GENERIC
) {
285 if ( (new_baudrate
= mask_to_rate(baud_mask
)) == -1) {
286 err("%s - failed setting baud rate, unsupported speed",
288 new_baudrate
= priv
->baud_rate
;
291 info("%s - please define your chiptype", __FUNCTION__
);
292 new_baudrate
= priv
->baud_rate
;
294 } else { /* baud rate not changing, keep the old */
295 new_baudrate
= priv
->baud_rate
;
297 dbg("%s - baud rate is being sent as %d", __FUNCTION__
, new_baudrate
);
299 memset(feature_buffer
, 0, 8);
300 /* fill the feature_buffer with new configuration */
301 *((u_int32_t
*)feature_buffer
) = new_baudrate
;
303 feature_buffer
[4] |= data_bits
; /* assign data bits in 2 bit space ( max 3 ) */
305 feature_buffer
[4] |= (stop_bits
<< 3); /* assign stop bits in 1 bit space */
306 feature_buffer
[4] |= (parity_enable
<< 4); /* assign parity flag in 1 bit space */
307 feature_buffer
[4] |= (parity_type
<< 5); /* assign parity type in 1 bit space */
309 feature_buffer
[4] |= (reset
<< 7); /* assign reset at end of byte, 1 bit space */
311 dbg("%s - device is being sent this feature report:", __FUNCTION__
);
312 dbg("%s - %02X - %02X - %02X - %02X - %02X", __FUNCTION__
, feature_buffer
[0], feature_buffer
[1],
313 feature_buffer
[2], feature_buffer
[3], feature_buffer
[4]);
316 retval
= usb_control_msg (port
->serial
->dev
, usb_sndctrlpipe(port
->serial
->dev
, 0),
317 HID_REQ_SET_REPORT
, USB_DIR_OUT
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
318 0x0300, 0, feature_buffer
, 8, 500);
324 usb_clear_halt(port
->serial
->dev
, 0x00);
325 } while (retval
!= 8 && retval
!= ENODEV
);
328 err("%s - failed sending serial line settings - %d", __FUNCTION__
, retval
);
330 spin_lock_irqsave(&priv
->lock
, flags
);
331 priv
->baud_rate
= new_baudrate
;
332 priv
->cbr_mask
= baud_mask
;
333 priv
->current_config
= feature_buffer
[4];
334 spin_unlock_irqrestore(&priv
->lock
, flags
);
337 case CYPRESS_GET_CONFIG
:
338 dbg("%s - retreiving serial line settings", __FUNCTION__
);
339 /* set initial values in feature buffer */
340 memset(feature_buffer
, 0, 8);
343 retval
= usb_control_msg (port
->serial
->dev
, usb_rcvctrlpipe(port
->serial
->dev
, 0),
344 HID_REQ_GET_REPORT
, USB_DIR_IN
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
345 0x0300, 0, feature_buffer
, 8, 500);
351 usb_clear_halt(port
->serial
->dev
, 0x00);
352 } while (retval
!= 5 && retval
!= ENODEV
);
355 err("%s - failed to retreive serial line settings - %d", __FUNCTION__
, retval
);
358 spin_lock_irqsave(&priv
->lock
, flags
);
360 /* store the config in one byte, and later use bit masks to check values */
361 priv
->current_config
= feature_buffer
[4];
362 priv
->baud_rate
= *((u_int32_t
*)feature_buffer
);
364 if ( (priv
->cbr_mask
= rate_to_mask(priv
->baud_rate
)) == 0x40)
365 dbg("%s - failed setting the baud mask (not defined)", __FUNCTION__
);
366 spin_unlock_irqrestore(&priv
->lock
, flags
);
369 spin_lock_irqsave(&priv
->lock
, flags
);
371 spin_unlock_irqrestore(&priv
->lock
, flags
);
374 } /* cypress_serial_control */
377 /* given a baud mask, it will return integer baud on success */
378 static int mask_to_rate (unsigned mask
)
383 case B0
: rate
= 0; break;
384 case B300
: rate
= 300; break;
385 case B600
: rate
= 600; break;
386 case B1200
: rate
= 1200; break;
387 case B2400
: rate
= 2400; break;
388 case B4800
: rate
= 4800; break;
389 case B9600
: rate
= 9600; break;
390 case B19200
: rate
= 19200; break;
391 case B38400
: rate
= 38400; break;
392 case B57600
: rate
= 57600; break;
393 case B115200
: rate
= 115200; break;
401 static unsigned rate_to_mask (int rate
)
406 case 0: mask
= B0
; break;
407 case 300: mask
= B300
; break;
408 case 600: mask
= B600
; break;
409 case 1200: mask
= B1200
; break;
410 case 2400: mask
= B2400
; break;
411 case 4800: mask
= B4800
; break;
412 case 9600: mask
= B9600
; break;
413 case 19200: mask
= B19200
; break;
414 case 38400: mask
= B38400
; break;
415 case 57600: mask
= B57600
; break;
416 case 115200: mask
= B115200
; break;
417 default: mask
= 0x40;
422 /*****************************************************************************
423 * Cypress serial driver functions
424 *****************************************************************************/
427 static int generic_startup (struct usb_serial
*serial
)
429 struct cypress_private
*priv
;
431 dbg("%s - port %d", __FUNCTION__
, serial
->port
[0]->number
);
433 priv
= kmalloc(sizeof (struct cypress_private
), GFP_KERNEL
);
437 memset(priv
, 0x00, sizeof (struct cypress_private
));
438 spin_lock_init(&priv
->lock
);
439 priv
->buf
= cypress_buf_alloc(CYPRESS_BUF_SIZE
);
440 if (priv
->buf
== NULL
) {
444 init_waitqueue_head(&priv
->delta_msr_wait
);
446 usb_reset_configuration (serial
->dev
);
450 priv
->line_control
= 0;
451 priv
->termios_initialized
= 0;
453 priv
->cbr_mask
= B300
;
454 usb_set_serial_port_data(serial
->port
[0], priv
);
460 static int cypress_earthmate_startup (struct usb_serial
*serial
)
462 struct cypress_private
*priv
;
464 dbg("%s", __FUNCTION__
);
466 if (generic_startup(serial
)) {
467 dbg("%s - Failed setting up port %d", __FUNCTION__
,
468 serial
->port
[0]->number
);
472 priv
= usb_get_serial_port_data(serial
->port
[0]);
473 priv
->chiptype
= CT_EARTHMATE
;
476 } /* cypress_earthmate_startup */
479 static int cypress_hidcom_startup (struct usb_serial
*serial
)
481 struct cypress_private
*priv
;
483 dbg("%s", __FUNCTION__
);
485 if (generic_startup(serial
)) {
486 dbg("%s - Failed setting up port %d", __FUNCTION__
,
487 serial
->port
[0]->number
);
491 priv
= usb_get_serial_port_data(serial
->port
[0]);
492 priv
->chiptype
= CT_CYPHIDCOM
;
495 } /* cypress_hidcom_startup */
498 static void cypress_shutdown (struct usb_serial
*serial
)
500 struct cypress_private
*priv
;
502 dbg ("%s - port %d", __FUNCTION__
, serial
->port
[0]->number
);
504 /* all open ports are closed at this point */
506 priv
= usb_get_serial_port_data(serial
->port
[0]);
509 cypress_buf_free(priv
->buf
);
511 usb_set_serial_port_data(serial
->port
[0], NULL
);
516 static int cypress_open (struct usb_serial_port
*port
, struct file
*filp
)
518 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
519 struct usb_serial
*serial
= port
->serial
;
523 dbg("%s - port %d", __FUNCTION__
, port
->number
);
525 /* clear halts before open */
526 usb_clear_halt(serial
->dev
, 0x81);
527 usb_clear_halt(serial
->dev
, 0x02);
529 spin_lock_irqsave(&priv
->lock
, flags
);
530 /* reset read/write statistics */
535 spin_unlock_irqrestore(&priv
->lock
, flags
);
537 /* setting to zero could cause data loss */
538 port
->tty
->low_latency
= 1;
540 /* raise both lines and set termios */
541 spin_lock_irqsave(&priv
->lock
, flags
);
542 priv
->line_control
= CONTROL_DTR
| CONTROL_RTS
;
544 spin_unlock_irqrestore(&priv
->lock
, flags
);
545 result
= cypress_write(port
, NULL
, 0);
548 dev_err(&port
->dev
, "%s - failed setting the control lines - error %d\n", __FUNCTION__
, result
);
551 dbg("%s - success setting the control lines", __FUNCTION__
);
553 cypress_set_termios(port
, &priv
->tmp_termios
);
555 /* setup the port and start reading from the device */
556 if(!port
->interrupt_in_urb
){
557 err("%s - interrupt_in_urb is empty!", __FUNCTION__
);
561 usb_fill_int_urb(port
->interrupt_in_urb
, serial
->dev
,
562 usb_rcvintpipe(serial
->dev
, port
->interrupt_in_endpointAddress
),
563 port
->interrupt_in_urb
->transfer_buffer
, port
->interrupt_in_urb
->transfer_buffer_length
,
564 cypress_read_int_callback
, port
, interval
);
565 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
568 dev_err(&port
->dev
, "%s - failed submitting read urb, error %d\n", __FUNCTION__
, result
);
575 static void cypress_close(struct usb_serial_port
*port
, struct file
* filp
)
577 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
578 unsigned int c_cflag
;
584 dbg("%s - port %d", __FUNCTION__
, port
->number
);
586 /* wait for data to drain from buffer */
587 spin_lock_irqsave(&priv
->lock
, flags
);
588 timeout
= CYPRESS_CLOSING_WAIT
;
589 init_waitqueue_entry(&wait
, current
);
590 add_wait_queue(&port
->tty
->write_wait
, &wait
);
592 set_current_state(TASK_INTERRUPTIBLE
);
593 if (cypress_buf_data_avail(priv
->buf
) == 0
594 || timeout
== 0 || signal_pending(current
)
595 || !usb_get_intfdata(port
->serial
->interface
))
597 spin_unlock_irqrestore(&priv
->lock
, flags
);
598 timeout
= schedule_timeout(timeout
);
599 spin_lock_irqsave(&priv
->lock
, flags
);
601 set_current_state(TASK_RUNNING
);
602 remove_wait_queue(&port
->tty
->write_wait
, &wait
);
603 /* clear out any remaining data in the buffer */
604 cypress_buf_clear(priv
->buf
);
605 spin_unlock_irqrestore(&priv
->lock
, flags
);
607 /* wait for characters to drain from device */
608 bps
= tty_get_baud_rate(port
->tty
);
610 timeout
= max((HZ
*2560)/bps
,HZ
/10);
613 schedule_timeout_interruptible(timeout
);
615 dbg("%s - stopping urbs", __FUNCTION__
);
616 usb_kill_urb (port
->interrupt_in_urb
);
617 usb_kill_urb (port
->interrupt_out_urb
);
620 c_cflag
= port
->tty
->termios
->c_cflag
;
621 if (c_cflag
& HUPCL
) {
622 /* drop dtr and rts */
623 priv
= usb_get_serial_port_data(port
);
624 spin_lock_irqsave(&priv
->lock
, flags
);
625 priv
->line_control
= 0;
627 spin_unlock_irqrestore(&priv
->lock
, flags
);
628 cypress_write(port
, NULL
, 0);
633 dev_info (&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
634 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
635 } /* cypress_close */
638 static int cypress_write(struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
640 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
643 dbg("%s - port %d, %d bytes", __FUNCTION__
, port
->number
, count
);
645 /* line control commands, which need to be executed immediately,
646 are not put into the buffer for obvious reasons.
648 if (priv
->cmd_ctrl
) {
656 spin_lock_irqsave(&priv
->lock
, flags
);
657 count
= cypress_buf_put(priv
->buf
, buf
, count
);
658 spin_unlock_irqrestore(&priv
->lock
, flags
);
664 } /* cypress_write */
667 static void cypress_send(struct usb_serial_port
*port
)
669 int count
= 0, result
, offset
, actual_size
;
670 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
673 dbg("%s - port %d", __FUNCTION__
, port
->number
);
674 dbg("%s - interrupt out size is %d", __FUNCTION__
, port
->interrupt_out_size
);
676 spin_lock_irqsave(&priv
->lock
, flags
);
677 if (priv
->write_urb_in_use
) {
678 dbg("%s - can't write, urb in use", __FUNCTION__
);
679 spin_unlock_irqrestore(&priv
->lock
, flags
);
682 spin_unlock_irqrestore(&priv
->lock
, flags
);
685 memset(port
->interrupt_out_urb
->transfer_buffer
, 0, port
->interrupt_out_size
);
687 spin_lock_irqsave(&priv
->lock
, flags
);
688 switch (port
->interrupt_out_size
) {
690 /* this is for the CY7C64013... */
692 port
->interrupt_out_buffer
[0] = priv
->line_control
;
695 /* this is for the CY7C63743... */
697 port
->interrupt_out_buffer
[0] = priv
->line_control
;
700 dbg("%s - wrong packet size", __FUNCTION__
);
701 spin_unlock_irqrestore(&priv
->lock
, flags
);
705 if (priv
->line_control
& CONTROL_RESET
)
706 priv
->line_control
&= ~CONTROL_RESET
;
708 if (priv
->cmd_ctrl
) {
710 dbg("%s - line control command being issued", __FUNCTION__
);
711 spin_unlock_irqrestore(&priv
->lock
, flags
);
714 spin_unlock_irqrestore(&priv
->lock
, flags
);
716 count
= cypress_buf_get(priv
->buf
, &port
->interrupt_out_buffer
[offset
],
717 port
->interrupt_out_size
-offset
);
723 switch (port
->interrupt_out_size
) {
725 port
->interrupt_out_buffer
[1] = count
;
728 port
->interrupt_out_buffer
[0] |= count
;
731 dbg("%s - count is %d", __FUNCTION__
, count
);
734 spin_lock_irqsave(&priv
->lock
, flags
);
735 priv
->write_urb_in_use
= 1;
736 spin_unlock_irqrestore(&priv
->lock
, flags
);
741 actual_size
= count
+ (port
->interrupt_out_size
== 32 ? 2 : 1);
743 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, port
->interrupt_out_size
,
744 port
->interrupt_out_urb
->transfer_buffer
);
746 port
->interrupt_out_urb
->transfer_buffer_length
= actual_size
;
747 port
->interrupt_out_urb
->dev
= port
->serial
->dev
;
748 port
->interrupt_out_urb
->interval
= interval
;
749 result
= usb_submit_urb (port
->interrupt_out_urb
, GFP_ATOMIC
);
751 dev_err(&port
->dev
, "%s - failed submitting write urb, error %d\n", __FUNCTION__
,
753 priv
->write_urb_in_use
= 0;
756 spin_lock_irqsave(&priv
->lock
, flags
);
757 if (priv
->cmd_ctrl
) {
760 priv
->bytes_out
+= count
; /* do not count the line control and size bytes */
761 spin_unlock_irqrestore(&priv
->lock
, flags
);
763 schedule_work(&port
->work
);
767 /* returns how much space is available in the soft buffer */
768 static int cypress_write_room(struct usb_serial_port
*port
)
770 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
774 dbg("%s - port %d", __FUNCTION__
, port
->number
);
776 spin_lock_irqsave(&priv
->lock
, flags
);
777 room
= cypress_buf_space_avail(priv
->buf
);
778 spin_unlock_irqrestore(&priv
->lock
, flags
);
780 dbg("%s - returns %d", __FUNCTION__
, room
);
785 static int cypress_tiocmget (struct usb_serial_port
*port
, struct file
*file
)
787 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
788 __u8 status
, control
;
789 unsigned int result
= 0;
792 dbg("%s - port %d", __FUNCTION__
, port
->number
);
794 spin_lock_irqsave(&priv
->lock
, flags
);
795 control
= priv
->line_control
;
796 status
= priv
->current_status
;
797 spin_unlock_irqrestore(&priv
->lock
, flags
);
799 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
800 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
801 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
802 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
803 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
804 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
806 dbg("%s - result = %x", __FUNCTION__
, result
);
812 static int cypress_tiocmset (struct usb_serial_port
*port
, struct file
*file
,
813 unsigned int set
, unsigned int clear
)
815 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
818 dbg("%s - port %d", __FUNCTION__
, port
->number
);
820 spin_lock_irqsave(&priv
->lock
, flags
);
822 priv
->line_control
|= CONTROL_RTS
;
824 priv
->line_control
|= CONTROL_DTR
;
825 if (clear
& TIOCM_RTS
)
826 priv
->line_control
&= ~CONTROL_RTS
;
827 if (clear
& TIOCM_DTR
)
828 priv
->line_control
&= ~CONTROL_DTR
;
829 spin_unlock_irqrestore(&priv
->lock
, flags
);
832 return cypress_write(port
, NULL
, 0);
836 static int cypress_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
838 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
840 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__
, port
->number
, cmd
);
844 if (copy_to_user((void __user
*)arg
, port
->tty
->termios
, sizeof(struct termios
))) {
850 if (copy_from_user(port
->tty
->termios
, (void __user
*)arg
, sizeof(struct termios
))) {
853 /* here we need to call cypress_set_termios to invoke the new settings */
854 cypress_set_termios(port
, &priv
->tmp_termios
);
857 /* these are called when setting baud rate from gpsd */
859 if (copy_to_user((void __user
*)arg
, port
->tty
->termios
, sizeof(struct termios
))) {
865 if (copy_from_user(port
->tty
->termios
, (void __user
*)arg
, sizeof(struct termios
))) {
868 /* here we need to call cypress_set_termios to invoke the new settings */
869 cypress_set_termios(port
, &priv
->tmp_termios
);
872 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
874 while (priv
!= NULL
) {
875 interruptible_sleep_on(&priv
->delta_msr_wait
);
876 /* see if a signal did it */
877 if (signal_pending(current
))
880 char diff
= priv
->diff_status
;
883 return -EIO
; /* no change => error */
886 /* consume all events */
887 priv
->diff_status
= 0;
889 /* return 0 if caller wanted to know about these bits */
890 if ( ((arg
& TIOCM_RNG
) && (diff
& UART_RI
)) ||
891 ((arg
& TIOCM_DSR
) && (diff
& UART_DSR
)) ||
892 ((arg
& TIOCM_CD
) && (diff
& UART_CD
)) ||
893 ((arg
& TIOCM_CTS
) && (diff
& UART_CTS
)) ) {
896 /* otherwise caller can't care less about what happened,
897 * and so we continue to wait for more events.
907 dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __FUNCTION__
, cmd
);
910 } /* cypress_ioctl */
913 static void cypress_set_termios (struct usb_serial_port
*port
,
914 struct termios
*old_termios
)
916 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
917 struct tty_struct
*tty
;
918 int data_bits
, stop_bits
, parity_type
, parity_enable
;
919 unsigned cflag
, iflag
, baud_mask
;
924 dbg("%s - port %d", __FUNCTION__
, port
->number
);
927 if ((!tty
) || (!tty
->termios
)) {
928 dbg("%s - no tty structures", __FUNCTION__
);
932 spin_lock_irqsave(&priv
->lock
, flags
);
933 if (!priv
->termios_initialized
) {
934 if (priv
->chiptype
== CT_EARTHMATE
) {
935 *(tty
->termios
) = tty_std_termios
;
936 tty
->termios
->c_cflag
= B4800
| CS8
| CREAD
| HUPCL
|
938 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
939 *(tty
->termios
) = tty_std_termios
;
940 tty
->termios
->c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
943 priv
->termios_initialized
= 1;
945 spin_unlock_irqrestore(&priv
->lock
, flags
);
947 cflag
= tty
->termios
->c_cflag
;
948 iflag
= tty
->termios
->c_iflag
;
950 /* check if there are new settings */
952 if ((cflag
!= old_termios
->c_cflag
) ||
953 (RELEVANT_IFLAG(iflag
) !=
954 RELEVANT_IFLAG(old_termios
->c_iflag
))) {
955 dbg("%s - attempting to set new termios settings",
957 /* should make a copy of this in case something goes
958 * wrong in the function, we can restore it */
959 spin_lock_irqsave(&priv
->lock
, flags
);
960 priv
->tmp_termios
= *(tty
->termios
);
961 spin_unlock_irqrestore(&priv
->lock
, flags
);
963 dbg("%s - nothing to do, exiting", __FUNCTION__
);
969 /* set number of data bits, parity, stop bits */
970 /* when parity is disabled the parity type bit is ignored */
972 /* 1 means 2 stop bits, 0 means 1 stop bit */
973 stop_bits
= cflag
& CSTOPB
? 1 : 0;
975 if (cflag
& PARENB
) {
977 /* 1 means odd parity, 0 means even parity */
978 parity_type
= cflag
& PARODD
? 1 : 0;
980 parity_enable
= parity_type
= 0;
983 switch (cflag
& CSIZE
) {
997 err("%s - CSIZE was set, but not CS5-CS8",
1004 spin_lock_irqsave(&priv
->lock
, flags
);
1005 oldlines
= priv
->line_control
;
1006 if ((cflag
& CBAUD
) == B0
) {
1007 /* drop dtr and rts */
1008 dbg("%s - dropping the lines, baud rate 0bps", __FUNCTION__
);
1010 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
1012 baud_mask
= (cflag
& CBAUD
);
1015 dbg("%s - setting baud 300bps", __FUNCTION__
);
1018 dbg("%s - setting baud 600bps", __FUNCTION__
);
1021 dbg("%s - setting baud 1200bps", __FUNCTION__
);
1024 dbg("%s - setting baud 2400bps", __FUNCTION__
);
1027 dbg("%s - setting baud 4800bps", __FUNCTION__
);
1030 dbg("%s - setting baud 9600bps", __FUNCTION__
);
1033 dbg("%s - setting baud 19200bps", __FUNCTION__
);
1036 dbg("%s - setting baud 38400bps", __FUNCTION__
);
1039 dbg("%s - setting baud 57600bps", __FUNCTION__
);
1042 dbg("%s - setting baud 115200bps", __FUNCTION__
);
1045 dbg("%s - unknown masked baud rate", __FUNCTION__
);
1047 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
1049 spin_unlock_irqrestore(&priv
->lock
, flags
);
1051 dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
1052 "%d data_bits (+5)", __FUNCTION__
, stop_bits
,
1053 parity_enable
, parity_type
, data_bits
);
1055 cypress_serial_control(port
, baud_mask
, data_bits
, stop_bits
,
1056 parity_enable
, parity_type
, 0, CYPRESS_SET_CONFIG
);
1058 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1059 * filled into the private structure this should confirm that all is
1060 * working if it returns what we just set */
1061 cypress_serial_control(port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
1063 /* Here we can define custom tty settings for devices; the main tty
1064 * termios flag base comes from empeg.c */
1066 spin_lock_irqsave(&priv
->lock
, flags
);
1067 if ( (priv
->chiptype
== CT_EARTHMATE
) && (priv
->baud_rate
== 4800) ) {
1068 dbg("Using custom termios settings for a baud rate of "
1070 /* define custom termios settings for NMEA protocol */
1072 tty
->termios
->c_iflag
/* input modes - */
1073 &= ~(IGNBRK
/* disable ignore break */
1074 | BRKINT
/* disable break causes interrupt */
1075 | PARMRK
/* disable mark parity errors */
1076 | ISTRIP
/* disable clear high bit of input char */
1077 | INLCR
/* disable translate NL to CR */
1078 | IGNCR
/* disable ignore CR */
1079 | ICRNL
/* disable translate CR to NL */
1080 | IXON
); /* disable enable XON/XOFF flow control */
1082 tty
->termios
->c_oflag
/* output modes */
1083 &= ~OPOST
; /* disable postprocess output char */
1085 tty
->termios
->c_lflag
/* line discipline modes */
1086 &= ~(ECHO
/* disable echo input characters */
1087 | ECHONL
/* disable echo new line */
1088 | ICANON
/* disable erase, kill, werase, and rprnt
1089 special characters */
1090 | ISIG
/* disable interrupt, quit, and suspend
1091 special characters */
1092 | IEXTEN
); /* disable non-POSIX special characters */
1093 } /* CT_CYPHIDCOM: Application should handle this for device */
1095 linechange
= (priv
->line_control
!= oldlines
);
1096 spin_unlock_irqrestore(&priv
->lock
, flags
);
1098 /* if necessary, set lines */
1101 cypress_write(port
, NULL
, 0);
1103 } /* cypress_set_termios */
1106 /* returns amount of data still left in soft buffer */
1107 static int cypress_chars_in_buffer(struct usb_serial_port
*port
)
1109 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1111 unsigned long flags
;
1113 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1115 spin_lock_irqsave(&priv
->lock
, flags
);
1116 chars
= cypress_buf_data_avail(priv
->buf
);
1117 spin_unlock_irqrestore(&priv
->lock
, flags
);
1119 dbg("%s - returns %d", __FUNCTION__
, chars
);
1124 static void cypress_throttle (struct usb_serial_port
*port
)
1126 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1127 unsigned long flags
;
1129 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1131 spin_lock_irqsave(&priv
->lock
, flags
);
1132 priv
->rx_flags
= THROTTLED
;
1133 spin_unlock_irqrestore(&priv
->lock
, flags
);
1137 static void cypress_unthrottle (struct usb_serial_port
*port
)
1139 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1140 int actually_throttled
, result
;
1141 unsigned long flags
;
1143 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1145 spin_lock_irqsave(&priv
->lock
, flags
);
1146 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1148 spin_unlock_irqrestore(&priv
->lock
, flags
);
1150 if (actually_throttled
) {
1151 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1153 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1155 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1156 "error %d\n", __FUNCTION__
, result
);
1161 static void cypress_read_int_callback(struct urb
*urb
, struct pt_regs
*regs
)
1163 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1164 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1165 struct tty_struct
*tty
;
1166 unsigned char *data
= urb
->transfer_buffer
;
1167 unsigned long flags
;
1168 char tty_flag
= TTY_NORMAL
;
1174 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1177 dbg("%s - nonzero read status received: %d", __FUNCTION__
,
1182 spin_lock_irqsave(&priv
->lock
, flags
);
1183 if (priv
->rx_flags
& THROTTLED
) {
1184 dbg("%s - now throttling", __FUNCTION__
);
1185 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1186 spin_unlock_irqrestore(&priv
->lock
, flags
);
1189 spin_unlock_irqrestore(&priv
->lock
, flags
);
1193 dbg("%s - bad tty pointer - exiting", __FUNCTION__
);
1197 spin_lock_irqsave(&priv
->lock
, flags
);
1198 switch(urb
->actual_length
) {
1200 /* This is for the CY7C64013... */
1201 priv
->current_status
= data
[0] & 0xF8;
1202 bytes
= data
[1] + 2;
1208 /* This is for the CY7C63743... */
1209 priv
->current_status
= data
[0] & 0xF8;
1210 bytes
= (data
[0] & 0x07) + 1;
1216 dbg("%s - wrong packet size - received %d bytes",
1217 __FUNCTION__
, urb
->actual_length
);
1218 spin_unlock_irqrestore(&priv
->lock
, flags
);
1221 spin_unlock_irqrestore(&priv
->lock
, flags
);
1223 usb_serial_debug_data (debug
, &port
->dev
, __FUNCTION__
,
1224 urb
->actual_length
, data
);
1226 spin_lock_irqsave(&priv
->lock
, flags
);
1227 /* check to see if status has changed */
1229 if (priv
->current_status
!= priv
->prev_status
) {
1230 priv
->diff_status
|= priv
->current_status
^
1232 wake_up_interruptible(&priv
->delta_msr_wait
);
1233 priv
->prev_status
= priv
->current_status
;
1236 spin_unlock_irqrestore(&priv
->lock
, flags
);
1238 /* hangup, as defined in acm.c... this might be a bad place for it
1240 if (tty
&& !(tty
->termios
->c_cflag
& CLOCAL
) &&
1241 !(priv
->current_status
& UART_CD
)) {
1242 dbg("%s - calling hangup", __FUNCTION__
);
1247 /* There is one error bit... I'm assuming it is a parity error
1248 * indicator as the generic firmware will set this bit to 1 if a
1249 * parity error occurs.
1250 * I can not find reference to any other error events. */
1251 spin_lock_irqsave(&priv
->lock
, flags
);
1252 if (priv
->current_status
& CYP_ERROR
) {
1253 spin_unlock_irqrestore(&priv
->lock
, flags
);
1254 tty_flag
= TTY_PARITY
;
1255 dbg("%s - Parity Error detected", __FUNCTION__
);
1257 spin_unlock_irqrestore(&priv
->lock
, flags
);
1259 /* process read if there is data other than line status */
1260 if (tty
&& (bytes
> i
)) {
1261 for (; i
< bytes
; ++i
) {
1262 dbg("pushing byte number %d - %d - %c", i
, data
[i
],
1264 if(tty
->flip
.count
>= TTY_FLIPBUF_SIZE
) {
1265 tty_flip_buffer_push(tty
);
1267 tty_insert_flip_char(tty
, data
[i
], tty_flag
);
1269 tty_flip_buffer_push(port
->tty
);
1272 spin_lock_irqsave(&priv
->lock
, flags
);
1273 /* control and status byte(s) are also counted */
1274 priv
->bytes_in
+= bytes
;
1275 spin_unlock_irqrestore(&priv
->lock
, flags
);
1279 /* Continue trying to always read... unless the port has closed. */
1281 if (port
->open_count
> 0) {
1282 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1283 usb_rcvintpipe(port
->serial
->dev
,
1284 port
->interrupt_in_endpointAddress
),
1285 port
->interrupt_in_urb
->transfer_buffer
,
1286 port
->interrupt_in_urb
->transfer_buffer_length
,
1287 cypress_read_int_callback
, port
, interval
);
1288 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1290 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting "
1291 "read urb, error %d\n", __FUNCTION__
,
1296 } /* cypress_read_int_callback */
1299 static void cypress_write_int_callback(struct urb
*urb
, struct pt_regs
*regs
)
1301 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1302 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1305 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1307 switch (urb
->status
) {
1314 /* this urb is terminated, clean up */
1315 dbg("%s - urb shutting down with status: %d", __FUNCTION__
, urb
->status
);
1316 priv
->write_urb_in_use
= 0;
1318 case -EPIPE
: /* no break needed */
1319 usb_clear_halt(port
->serial
->dev
, 0x02);
1321 /* error in the urb, so we have to resubmit it */
1322 dbg("%s - Overflow in write", __FUNCTION__
);
1323 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
1324 port
->interrupt_out_urb
->transfer_buffer_length
= 1;
1325 port
->interrupt_out_urb
->dev
= port
->serial
->dev
;
1326 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
1328 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting write urb, error %d\n",
1329 __FUNCTION__
, result
);
1334 priv
->write_urb_in_use
= 0;
1336 /* send any buffered data */
1341 /*****************************************************************************
1342 * Write buffer functions - buffering code from pl2303 used
1343 *****************************************************************************/
1348 * Allocate a circular buffer and all associated memory.
1351 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
)
1354 struct cypress_buf
*cb
;
1360 cb
= (struct cypress_buf
*)kmalloc(sizeof(struct cypress_buf
), GFP_KERNEL
);
1364 cb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1365 if (cb
->buf_buf
== NULL
) {
1370 cb
->buf_size
= size
;
1371 cb
->buf_get
= cb
->buf_put
= cb
->buf_buf
;
1381 * Free the buffer and all associated memory.
1384 static void cypress_buf_free(struct cypress_buf
*cb
)
1396 * Clear out all data in the circular buffer.
1399 static void cypress_buf_clear(struct cypress_buf
*cb
)
1402 cb
->buf_get
= cb
->buf_put
;
1403 /* equivalent to a get of all data available */
1408 * cypress_buf_data_avail
1410 * Return the number of bytes of data available in the circular
1414 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
)
1417 return ((cb
->buf_size
+ cb
->buf_put
- cb
->buf_get
) % cb
->buf_size
);
1424 * cypress_buf_space_avail
1426 * Return the number of bytes of space available in the circular
1430 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
)
1433 return ((cb
->buf_size
+ cb
->buf_get
- cb
->buf_put
- 1) % cb
->buf_size
);
1442 * Copy data data from a user buffer and put it into the circular buffer.
1443 * Restrict to the amount of space available.
1445 * Return the number of bytes copied.
1448 static unsigned int cypress_buf_put(struct cypress_buf
*cb
, const char *buf
,
1458 len
= cypress_buf_space_avail(cb
);
1465 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_put
;
1467 memcpy(cb
->buf_put
, buf
, len
);
1468 memcpy(cb
->buf_buf
, buf
+len
, count
- len
);
1469 cb
->buf_put
= cb
->buf_buf
+ count
- len
;
1471 memcpy(cb
->buf_put
, buf
, count
);
1473 cb
->buf_put
+= count
;
1474 else /* count == len */
1475 cb
->buf_put
= cb
->buf_buf
;
1486 * Get data from the circular buffer and copy to the given buffer.
1487 * Restrict to the amount of data available.
1489 * Return the number of bytes copied.
1492 static unsigned int cypress_buf_get(struct cypress_buf
*cb
, char *buf
,
1502 len
= cypress_buf_data_avail(cb
);
1509 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_get
;
1511 memcpy(buf
, cb
->buf_get
, len
);
1512 memcpy(buf
+len
, cb
->buf_buf
, count
- len
);
1513 cb
->buf_get
= cb
->buf_buf
+ count
- len
;
1515 memcpy(buf
, cb
->buf_get
, count
);
1517 cb
->buf_get
+= count
;
1518 else /* count == len */
1519 cb
->buf_get
= cb
->buf_buf
;
1526 /*****************************************************************************
1528 *****************************************************************************/
1530 static int __init
cypress_init(void)
1534 dbg("%s", __FUNCTION__
);
1536 retval
= usb_serial_register(&cypress_earthmate_device
);
1538 goto failed_em_register
;
1539 retval
= usb_serial_register(&cypress_hidcom_device
);
1541 goto failed_hidcom_register
;
1542 retval
= usb_register(&cypress_driver
);
1544 goto failed_usb_register
;
1546 info(DRIVER_DESC
" " DRIVER_VERSION
);
1548 failed_usb_register
:
1549 usb_deregister(&cypress_driver
);
1550 failed_hidcom_register
:
1551 usb_serial_deregister(&cypress_hidcom_device
);
1553 usb_serial_deregister(&cypress_earthmate_device
);
1559 static void __exit
cypress_exit (void)
1561 dbg("%s", __FUNCTION__
);
1563 usb_deregister (&cypress_driver
);
1564 usb_serial_deregister (&cypress_earthmate_device
);
1565 usb_serial_deregister (&cypress_hidcom_device
);
1569 module_init(cypress_init
);
1570 module_exit(cypress_exit
);
1572 MODULE_AUTHOR( DRIVER_AUTHOR
);
1573 MODULE_DESCRIPTION( DRIVER_DESC
);
1574 MODULE_VERSION( DRIVER_VERSION
);
1575 MODULE_LICENSE("GPL");
1577 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1578 MODULE_PARM_DESC(debug
, "Debug enabled or not");
1579 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1580 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1581 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1582 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");