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 set_current_state(TASK_INTERRUPTIBLE
);
614 schedule_timeout(timeout
);
616 dbg("%s - stopping urbs", __FUNCTION__
);
617 usb_kill_urb (port
->interrupt_in_urb
);
618 usb_kill_urb (port
->interrupt_out_urb
);
621 c_cflag
= port
->tty
->termios
->c_cflag
;
622 if (c_cflag
& HUPCL
) {
623 /* drop dtr and rts */
624 priv
= usb_get_serial_port_data(port
);
625 spin_lock_irqsave(&priv
->lock
, flags
);
626 priv
->line_control
= 0;
628 spin_unlock_irqrestore(&priv
->lock
, flags
);
629 cypress_write(port
, NULL
, 0);
634 dev_info (&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
635 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
636 } /* cypress_close */
639 static int cypress_write(struct usb_serial_port
*port
, const unsigned char *buf
, int count
)
641 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
644 dbg("%s - port %d, %d bytes", __FUNCTION__
, port
->number
, count
);
646 /* line control commands, which need to be executed immediately,
647 are not put into the buffer for obvious reasons.
649 if (priv
->cmd_ctrl
) {
657 spin_lock_irqsave(&priv
->lock
, flags
);
658 count
= cypress_buf_put(priv
->buf
, buf
, count
);
659 spin_unlock_irqrestore(&priv
->lock
, flags
);
665 } /* cypress_write */
668 static void cypress_send(struct usb_serial_port
*port
)
670 int count
= 0, result
, offset
, actual_size
;
671 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
674 dbg("%s - port %d", __FUNCTION__
, port
->number
);
675 dbg("%s - interrupt out size is %d", __FUNCTION__
, port
->interrupt_out_size
);
677 spin_lock_irqsave(&priv
->lock
, flags
);
678 if (priv
->write_urb_in_use
) {
679 dbg("%s - can't write, urb in use", __FUNCTION__
);
680 spin_unlock_irqrestore(&priv
->lock
, flags
);
683 spin_unlock_irqrestore(&priv
->lock
, flags
);
686 memset(port
->interrupt_out_urb
->transfer_buffer
, 0, port
->interrupt_out_size
);
688 spin_lock_irqsave(&priv
->lock
, flags
);
689 switch (port
->interrupt_out_size
) {
691 /* this is for the CY7C64013... */
693 port
->interrupt_out_buffer
[0] = priv
->line_control
;
696 /* this is for the CY7C63743... */
698 port
->interrupt_out_buffer
[0] = priv
->line_control
;
701 dbg("%s - wrong packet size", __FUNCTION__
);
702 spin_unlock_irqrestore(&priv
->lock
, flags
);
706 if (priv
->line_control
& CONTROL_RESET
)
707 priv
->line_control
&= ~CONTROL_RESET
;
709 if (priv
->cmd_ctrl
) {
711 dbg("%s - line control command being issued", __FUNCTION__
);
712 spin_unlock_irqrestore(&priv
->lock
, flags
);
715 spin_unlock_irqrestore(&priv
->lock
, flags
);
717 count
= cypress_buf_get(priv
->buf
, &port
->interrupt_out_buffer
[offset
],
718 port
->interrupt_out_size
-offset
);
724 switch (port
->interrupt_out_size
) {
726 port
->interrupt_out_buffer
[1] = count
;
729 port
->interrupt_out_buffer
[0] |= count
;
732 dbg("%s - count is %d", __FUNCTION__
, count
);
735 spin_lock_irqsave(&priv
->lock
, flags
);
736 priv
->write_urb_in_use
= 1;
737 spin_unlock_irqrestore(&priv
->lock
, flags
);
742 actual_size
= count
+ (port
->interrupt_out_size
== 32 ? 2 : 1);
744 usb_serial_debug_data(debug
, &port
->dev
, __FUNCTION__
, port
->interrupt_out_size
,
745 port
->interrupt_out_urb
->transfer_buffer
);
747 port
->interrupt_out_urb
->transfer_buffer_length
= actual_size
;
748 port
->interrupt_out_urb
->dev
= port
->serial
->dev
;
749 port
->interrupt_out_urb
->interval
= interval
;
750 result
= usb_submit_urb (port
->interrupt_out_urb
, GFP_ATOMIC
);
752 dev_err(&port
->dev
, "%s - failed submitting write urb, error %d\n", __FUNCTION__
,
754 priv
->write_urb_in_use
= 0;
757 spin_lock_irqsave(&priv
->lock
, flags
);
758 if (priv
->cmd_ctrl
) {
761 priv
->bytes_out
+= count
; /* do not count the line control and size bytes */
762 spin_unlock_irqrestore(&priv
->lock
, flags
);
764 schedule_work(&port
->work
);
768 /* returns how much space is available in the soft buffer */
769 static int cypress_write_room(struct usb_serial_port
*port
)
771 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
775 dbg("%s - port %d", __FUNCTION__
, port
->number
);
777 spin_lock_irqsave(&priv
->lock
, flags
);
778 room
= cypress_buf_space_avail(priv
->buf
);
779 spin_unlock_irqrestore(&priv
->lock
, flags
);
781 dbg("%s - returns %d", __FUNCTION__
, room
);
786 static int cypress_tiocmget (struct usb_serial_port
*port
, struct file
*file
)
788 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
789 __u8 status
, control
;
790 unsigned int result
= 0;
793 dbg("%s - port %d", __FUNCTION__
, port
->number
);
795 spin_lock_irqsave(&priv
->lock
, flags
);
796 control
= priv
->line_control
;
797 status
= priv
->current_status
;
798 spin_unlock_irqrestore(&priv
->lock
, flags
);
800 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
801 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
802 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
803 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
804 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
805 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
807 dbg("%s - result = %x", __FUNCTION__
, result
);
813 static int cypress_tiocmset (struct usb_serial_port
*port
, struct file
*file
,
814 unsigned int set
, unsigned int clear
)
816 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
819 dbg("%s - port %d", __FUNCTION__
, port
->number
);
821 spin_lock_irqsave(&priv
->lock
, flags
);
823 priv
->line_control
|= CONTROL_RTS
;
825 priv
->line_control
|= CONTROL_DTR
;
826 if (clear
& TIOCM_RTS
)
827 priv
->line_control
&= ~CONTROL_RTS
;
828 if (clear
& TIOCM_DTR
)
829 priv
->line_control
&= ~CONTROL_DTR
;
830 spin_unlock_irqrestore(&priv
->lock
, flags
);
833 return cypress_write(port
, NULL
, 0);
837 static int cypress_ioctl (struct usb_serial_port
*port
, struct file
* file
, unsigned int cmd
, unsigned long arg
)
839 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
841 dbg("%s - port %d, cmd 0x%.4x", __FUNCTION__
, port
->number
, cmd
);
845 if (copy_to_user((void __user
*)arg
, port
->tty
->termios
, sizeof(struct termios
))) {
851 if (copy_from_user(port
->tty
->termios
, (void __user
*)arg
, sizeof(struct termios
))) {
854 /* here we need to call cypress_set_termios to invoke the new settings */
855 cypress_set_termios(port
, &priv
->tmp_termios
);
858 /* these are called when setting baud rate from gpsd */
860 if (copy_to_user((void __user
*)arg
, port
->tty
->termios
, sizeof(struct termios
))) {
866 if (copy_from_user(port
->tty
->termios
, (void __user
*)arg
, sizeof(struct termios
))) {
869 /* here we need to call cypress_set_termios to invoke the new settings */
870 cypress_set_termios(port
, &priv
->tmp_termios
);
873 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
875 while (priv
!= NULL
) {
876 interruptible_sleep_on(&priv
->delta_msr_wait
);
877 /* see if a signal did it */
878 if (signal_pending(current
))
881 char diff
= priv
->diff_status
;
884 return -EIO
; /* no change => error */
887 /* consume all events */
888 priv
->diff_status
= 0;
890 /* return 0 if caller wanted to know about these bits */
891 if ( ((arg
& TIOCM_RNG
) && (diff
& UART_RI
)) ||
892 ((arg
& TIOCM_DSR
) && (diff
& UART_DSR
)) ||
893 ((arg
& TIOCM_CD
) && (diff
& UART_CD
)) ||
894 ((arg
& TIOCM_CTS
) && (diff
& UART_CTS
)) ) {
897 /* otherwise caller can't care less about what happened,
898 * and so we continue to wait for more events.
908 dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __FUNCTION__
, cmd
);
911 } /* cypress_ioctl */
914 static void cypress_set_termios (struct usb_serial_port
*port
,
915 struct termios
*old_termios
)
917 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
918 struct tty_struct
*tty
;
919 int data_bits
, stop_bits
, parity_type
, parity_enable
;
920 unsigned cflag
, iflag
, baud_mask
;
925 dbg("%s - port %d", __FUNCTION__
, port
->number
);
928 if ((!tty
) || (!tty
->termios
)) {
929 dbg("%s - no tty structures", __FUNCTION__
);
933 spin_lock_irqsave(&priv
->lock
, flags
);
934 if (!priv
->termios_initialized
) {
935 if (priv
->chiptype
== CT_EARTHMATE
) {
936 *(tty
->termios
) = tty_std_termios
;
937 tty
->termios
->c_cflag
= B4800
| CS8
| CREAD
| HUPCL
|
939 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
940 *(tty
->termios
) = tty_std_termios
;
941 tty
->termios
->c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
944 priv
->termios_initialized
= 1;
946 spin_unlock_irqrestore(&priv
->lock
, flags
);
948 cflag
= tty
->termios
->c_cflag
;
949 iflag
= tty
->termios
->c_iflag
;
951 /* check if there are new settings */
953 if ((cflag
!= old_termios
->c_cflag
) ||
954 (RELEVANT_IFLAG(iflag
) !=
955 RELEVANT_IFLAG(old_termios
->c_iflag
))) {
956 dbg("%s - attempting to set new termios settings",
958 /* should make a copy of this in case something goes
959 * wrong in the function, we can restore it */
960 spin_lock_irqsave(&priv
->lock
, flags
);
961 priv
->tmp_termios
= *(tty
->termios
);
962 spin_unlock_irqrestore(&priv
->lock
, flags
);
964 dbg("%s - nothing to do, exiting", __FUNCTION__
);
970 /* set number of data bits, parity, stop bits */
971 /* when parity is disabled the parity type bit is ignored */
973 /* 1 means 2 stop bits, 0 means 1 stop bit */
974 stop_bits
= cflag
& CSTOPB
? 1 : 0;
976 if (cflag
& PARENB
) {
978 /* 1 means odd parity, 0 means even parity */
979 parity_type
= cflag
& PARODD
? 1 : 0;
981 parity_enable
= parity_type
= 0;
984 switch (cflag
& CSIZE
) {
998 err("%s - CSIZE was set, but not CS5-CS8",
1005 spin_lock_irqsave(&priv
->lock
, flags
);
1006 oldlines
= priv
->line_control
;
1007 if ((cflag
& CBAUD
) == B0
) {
1008 /* drop dtr and rts */
1009 dbg("%s - dropping the lines, baud rate 0bps", __FUNCTION__
);
1011 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
1013 baud_mask
= (cflag
& CBAUD
);
1016 dbg("%s - setting baud 300bps", __FUNCTION__
);
1019 dbg("%s - setting baud 600bps", __FUNCTION__
);
1022 dbg("%s - setting baud 1200bps", __FUNCTION__
);
1025 dbg("%s - setting baud 2400bps", __FUNCTION__
);
1028 dbg("%s - setting baud 4800bps", __FUNCTION__
);
1031 dbg("%s - setting baud 9600bps", __FUNCTION__
);
1034 dbg("%s - setting baud 19200bps", __FUNCTION__
);
1037 dbg("%s - setting baud 38400bps", __FUNCTION__
);
1040 dbg("%s - setting baud 57600bps", __FUNCTION__
);
1043 dbg("%s - setting baud 115200bps", __FUNCTION__
);
1046 dbg("%s - unknown masked baud rate", __FUNCTION__
);
1048 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
1050 spin_unlock_irqrestore(&priv
->lock
, flags
);
1052 dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
1053 "%d data_bits (+5)", __FUNCTION__
, stop_bits
,
1054 parity_enable
, parity_type
, data_bits
);
1056 cypress_serial_control(port
, baud_mask
, data_bits
, stop_bits
,
1057 parity_enable
, parity_type
, 0, CYPRESS_SET_CONFIG
);
1059 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1060 * filled into the private structure this should confirm that all is
1061 * working if it returns what we just set */
1062 cypress_serial_control(port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
1064 /* Here we can define custom tty settings for devices; the main tty
1065 * termios flag base comes from empeg.c */
1067 spin_lock_irqsave(&priv
->lock
, flags
);
1068 if ( (priv
->chiptype
== CT_EARTHMATE
) && (priv
->baud_rate
== 4800) ) {
1069 dbg("Using custom termios settings for a baud rate of "
1071 /* define custom termios settings for NMEA protocol */
1073 tty
->termios
->c_iflag
/* input modes - */
1074 &= ~(IGNBRK
/* disable ignore break */
1075 | BRKINT
/* disable break causes interrupt */
1076 | PARMRK
/* disable mark parity errors */
1077 | ISTRIP
/* disable clear high bit of input char */
1078 | INLCR
/* disable translate NL to CR */
1079 | IGNCR
/* disable ignore CR */
1080 | ICRNL
/* disable translate CR to NL */
1081 | IXON
); /* disable enable XON/XOFF flow control */
1083 tty
->termios
->c_oflag
/* output modes */
1084 &= ~OPOST
; /* disable postprocess output char */
1086 tty
->termios
->c_lflag
/* line discipline modes */
1087 &= ~(ECHO
/* disable echo input characters */
1088 | ECHONL
/* disable echo new line */
1089 | ICANON
/* disable erase, kill, werase, and rprnt
1090 special characters */
1091 | ISIG
/* disable interrupt, quit, and suspend
1092 special characters */
1093 | IEXTEN
); /* disable non-POSIX special characters */
1094 } /* CT_CYPHIDCOM: Application should handle this for device */
1096 linechange
= (priv
->line_control
!= oldlines
);
1097 spin_unlock_irqrestore(&priv
->lock
, flags
);
1099 /* if necessary, set lines */
1102 cypress_write(port
, NULL
, 0);
1104 } /* cypress_set_termios */
1107 /* returns amount of data still left in soft buffer */
1108 static int cypress_chars_in_buffer(struct usb_serial_port
*port
)
1110 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1112 unsigned long flags
;
1114 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1116 spin_lock_irqsave(&priv
->lock
, flags
);
1117 chars
= cypress_buf_data_avail(priv
->buf
);
1118 spin_unlock_irqrestore(&priv
->lock
, flags
);
1120 dbg("%s - returns %d", __FUNCTION__
, chars
);
1125 static void cypress_throttle (struct usb_serial_port
*port
)
1127 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1128 unsigned long flags
;
1130 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1132 spin_lock_irqsave(&priv
->lock
, flags
);
1133 priv
->rx_flags
= THROTTLED
;
1134 spin_unlock_irqrestore(&priv
->lock
, flags
);
1138 static void cypress_unthrottle (struct usb_serial_port
*port
)
1140 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1141 int actually_throttled
, result
;
1142 unsigned long flags
;
1144 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1146 spin_lock_irqsave(&priv
->lock
, flags
);
1147 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1149 spin_unlock_irqrestore(&priv
->lock
, flags
);
1151 if (actually_throttled
) {
1152 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1154 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1156 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1157 "error %d\n", __FUNCTION__
, result
);
1162 static void cypress_read_int_callback(struct urb
*urb
, struct pt_regs
*regs
)
1164 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1165 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1166 struct tty_struct
*tty
;
1167 unsigned char *data
= urb
->transfer_buffer
;
1168 unsigned long flags
;
1169 char tty_flag
= TTY_NORMAL
;
1175 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1178 dbg("%s - nonzero read status received: %d", __FUNCTION__
,
1183 spin_lock_irqsave(&priv
->lock
, flags
);
1184 if (priv
->rx_flags
& THROTTLED
) {
1185 dbg("%s - now throttling", __FUNCTION__
);
1186 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1187 spin_unlock_irqrestore(&priv
->lock
, flags
);
1190 spin_unlock_irqrestore(&priv
->lock
, flags
);
1194 dbg("%s - bad tty pointer - exiting", __FUNCTION__
);
1198 spin_lock_irqsave(&priv
->lock
, flags
);
1199 switch(urb
->actual_length
) {
1201 /* This is for the CY7C64013... */
1202 priv
->current_status
= data
[0] & 0xF8;
1203 bytes
= data
[1] + 2;
1209 /* This is for the CY7C63743... */
1210 priv
->current_status
= data
[0] & 0xF8;
1211 bytes
= (data
[0] & 0x07) + 1;
1217 dbg("%s - wrong packet size - received %d bytes",
1218 __FUNCTION__
, urb
->actual_length
);
1219 spin_unlock_irqrestore(&priv
->lock
, flags
);
1222 spin_unlock_irqrestore(&priv
->lock
, flags
);
1224 usb_serial_debug_data (debug
, &port
->dev
, __FUNCTION__
,
1225 urb
->actual_length
, data
);
1227 spin_lock_irqsave(&priv
->lock
, flags
);
1228 /* check to see if status has changed */
1230 if (priv
->current_status
!= priv
->prev_status
) {
1231 priv
->diff_status
|= priv
->current_status
^
1233 wake_up_interruptible(&priv
->delta_msr_wait
);
1234 priv
->prev_status
= priv
->current_status
;
1237 spin_unlock_irqrestore(&priv
->lock
, flags
);
1239 /* hangup, as defined in acm.c... this might be a bad place for it
1241 if (tty
&& !(tty
->termios
->c_cflag
& CLOCAL
) &&
1242 !(priv
->current_status
& UART_CD
)) {
1243 dbg("%s - calling hangup", __FUNCTION__
);
1248 /* There is one error bit... I'm assuming it is a parity error
1249 * indicator as the generic firmware will set this bit to 1 if a
1250 * parity error occurs.
1251 * I can not find reference to any other error events. */
1252 spin_lock_irqsave(&priv
->lock
, flags
);
1253 if (priv
->current_status
& CYP_ERROR
) {
1254 spin_unlock_irqrestore(&priv
->lock
, flags
);
1255 tty_flag
= TTY_PARITY
;
1256 dbg("%s - Parity Error detected", __FUNCTION__
);
1258 spin_unlock_irqrestore(&priv
->lock
, flags
);
1260 /* process read if there is data other than line status */
1261 if (tty
&& (bytes
> i
)) {
1262 for (; i
< bytes
; ++i
) {
1263 dbg("pushing byte number %d - %d - %c", i
, data
[i
],
1265 if(tty
->flip
.count
>= TTY_FLIPBUF_SIZE
) {
1266 tty_flip_buffer_push(tty
);
1268 tty_insert_flip_char(tty
, data
[i
], tty_flag
);
1270 tty_flip_buffer_push(port
->tty
);
1273 spin_lock_irqsave(&priv
->lock
, flags
);
1274 /* control and status byte(s) are also counted */
1275 priv
->bytes_in
+= bytes
;
1276 spin_unlock_irqrestore(&priv
->lock
, flags
);
1280 /* Continue trying to always read... unless the port has closed. */
1282 if (port
->open_count
> 0) {
1283 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1284 usb_rcvintpipe(port
->serial
->dev
,
1285 port
->interrupt_in_endpointAddress
),
1286 port
->interrupt_in_urb
->transfer_buffer
,
1287 port
->interrupt_in_urb
->transfer_buffer_length
,
1288 cypress_read_int_callback
, port
, interval
);
1289 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1291 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting "
1292 "read urb, error %d\n", __FUNCTION__
,
1297 } /* cypress_read_int_callback */
1300 static void cypress_write_int_callback(struct urb
*urb
, struct pt_regs
*regs
)
1302 struct usb_serial_port
*port
= (struct usb_serial_port
*)urb
->context
;
1303 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1306 dbg("%s - port %d", __FUNCTION__
, port
->number
);
1308 switch (urb
->status
) {
1315 /* this urb is terminated, clean up */
1316 dbg("%s - urb shutting down with status: %d", __FUNCTION__
, urb
->status
);
1317 priv
->write_urb_in_use
= 0;
1319 case -EPIPE
: /* no break needed */
1320 usb_clear_halt(port
->serial
->dev
, 0x02);
1322 /* error in the urb, so we have to resubmit it */
1323 dbg("%s - Overflow in write", __FUNCTION__
);
1324 dbg("%s - nonzero write bulk status received: %d", __FUNCTION__
, urb
->status
);
1325 port
->interrupt_out_urb
->transfer_buffer_length
= 1;
1326 port
->interrupt_out_urb
->dev
= port
->serial
->dev
;
1327 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
1329 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting write urb, error %d\n",
1330 __FUNCTION__
, result
);
1335 priv
->write_urb_in_use
= 0;
1337 /* send any buffered data */
1342 /*****************************************************************************
1343 * Write buffer functions - buffering code from pl2303 used
1344 *****************************************************************************/
1349 * Allocate a circular buffer and all associated memory.
1352 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
)
1355 struct cypress_buf
*cb
;
1361 cb
= (struct cypress_buf
*)kmalloc(sizeof(struct cypress_buf
), GFP_KERNEL
);
1365 cb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1366 if (cb
->buf_buf
== NULL
) {
1371 cb
->buf_size
= size
;
1372 cb
->buf_get
= cb
->buf_put
= cb
->buf_buf
;
1382 * Free the buffer and all associated memory.
1385 static void cypress_buf_free(struct cypress_buf
*cb
)
1397 * Clear out all data in the circular buffer.
1400 static void cypress_buf_clear(struct cypress_buf
*cb
)
1403 cb
->buf_get
= cb
->buf_put
;
1404 /* equivalent to a get of all data available */
1409 * cypress_buf_data_avail
1411 * Return the number of bytes of data available in the circular
1415 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
)
1418 return ((cb
->buf_size
+ cb
->buf_put
- cb
->buf_get
) % cb
->buf_size
);
1425 * cypress_buf_space_avail
1427 * Return the number of bytes of space available in the circular
1431 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
)
1434 return ((cb
->buf_size
+ cb
->buf_get
- cb
->buf_put
- 1) % cb
->buf_size
);
1443 * Copy data data from a user buffer and put it into the circular buffer.
1444 * Restrict to the amount of space available.
1446 * Return the number of bytes copied.
1449 static unsigned int cypress_buf_put(struct cypress_buf
*cb
, const char *buf
,
1459 len
= cypress_buf_space_avail(cb
);
1466 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_put
;
1468 memcpy(cb
->buf_put
, buf
, len
);
1469 memcpy(cb
->buf_buf
, buf
+len
, count
- len
);
1470 cb
->buf_put
= cb
->buf_buf
+ count
- len
;
1472 memcpy(cb
->buf_put
, buf
, count
);
1474 cb
->buf_put
+= count
;
1475 else /* count == len */
1476 cb
->buf_put
= cb
->buf_buf
;
1487 * Get data from the circular buffer and copy to the given buffer.
1488 * Restrict to the amount of data available.
1490 * Return the number of bytes copied.
1493 static unsigned int cypress_buf_get(struct cypress_buf
*cb
, char *buf
,
1503 len
= cypress_buf_data_avail(cb
);
1510 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_get
;
1512 memcpy(buf
, cb
->buf_get
, len
);
1513 memcpy(buf
+len
, cb
->buf_buf
, count
- len
);
1514 cb
->buf_get
= cb
->buf_buf
+ count
- len
;
1516 memcpy(buf
, cb
->buf_get
, count
);
1518 cb
->buf_get
+= count
;
1519 else /* count == len */
1520 cb
->buf_get
= cb
->buf_buf
;
1527 /*****************************************************************************
1529 *****************************************************************************/
1531 static int __init
cypress_init(void)
1535 dbg("%s", __FUNCTION__
);
1537 retval
= usb_serial_register(&cypress_earthmate_device
);
1539 goto failed_em_register
;
1540 retval
= usb_serial_register(&cypress_hidcom_device
);
1542 goto failed_hidcom_register
;
1543 retval
= usb_register(&cypress_driver
);
1545 goto failed_usb_register
;
1547 info(DRIVER_DESC
" " DRIVER_VERSION
);
1549 failed_usb_register
:
1550 usb_deregister(&cypress_driver
);
1551 failed_hidcom_register
:
1552 usb_serial_deregister(&cypress_hidcom_device
);
1554 usb_serial_deregister(&cypress_earthmate_device
);
1560 static void __exit
cypress_exit (void)
1562 dbg("%s", __FUNCTION__
);
1564 usb_deregister (&cypress_driver
);
1565 usb_serial_deregister (&cypress_earthmate_device
);
1566 usb_serial_deregister (&cypress_hidcom_device
);
1570 module_init(cypress_init
);
1571 module_exit(cypress_exit
);
1573 MODULE_AUTHOR( DRIVER_AUTHOR
);
1574 MODULE_DESCRIPTION( DRIVER_DESC
);
1575 MODULE_VERSION( DRIVER_VERSION
);
1576 MODULE_LICENSE("GPL");
1578 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1579 MODULE_PARM_DESC(debug
, "Debug enabled or not");
1580 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1581 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1582 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1583 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");