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
17 * See http://geocities.com/i0xox0i for information on this driver and the
18 * earthmate usb device.
20 * Lonnie Mendez <dignome@gmail.com>
22 * Fixed problem where setting or retreiving the serial config would fail
23 * with EPIPE. Removed CRTS toggling so the driver behaves more like
24 * other usbserial adapters. Issued new interval of 1ms instead of the
25 * default 10ms. As a result, transfer speed has been substantially
26 * increased from avg. 850bps to avg. 3300bps. initial termios has also
27 * been modified. Cleaned up code and formatting issues so it is more
28 * readable. Replaced the C++ style comments.
30 * Lonnie Mendez <dignome@gmail.com>
32 * Incorporated write buffering from pl2303 driver. Fixed bug with line
33 * handling so both lines are raised in cypress_open. (was dropping rts)
34 * Various code cleanups made as well along with other misc bug fixes.
36 * Lonnie Mendez <dignome@gmail.com>
38 * Driver modified to support dynamic line settings. Various improvments
43 * Driver first released.
47 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation
49 /* Thanks to cypress for providing references for the hid reports. */
50 /* Thanks to Jiang Zhang for providing links and for general help. */
51 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others.*/
54 #include <linux/kernel.h>
55 #include <linux/errno.h>
56 #include <linux/init.h>
57 #include <linux/slab.h>
58 #include <linux/tty.h>
59 #include <linux/tty_driver.h>
60 #include <linux/tty_flip.h>
61 #include <linux/module.h>
62 #include <linux/moduleparam.h>
63 #include <linux/spinlock.h>
64 #include <linux/usb.h>
65 #include <linux/usb/serial.h>
66 #include <linux/serial.h>
67 #include <linux/delay.h>
68 #include <linux/uaccess.h>
69 #include <asm/unaligned.h>
71 #include "cypress_m8.h"
77 static int unstable_bauds
;
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
89 static const struct usb_device_id id_table_earthmate
[] = {
90 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
91 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
92 { } /* Terminating entry */
95 static const struct usb_device_id id_table_cyphidcomrs232
[] = {
96 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
97 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
98 { } /* Terminating entry */
101 static const struct usb_device_id id_table_nokiaca42v2
[] = {
102 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
103 { } /* Terminating entry */
106 static const struct usb_device_id id_table_combined
[] = {
107 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
108 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
109 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
110 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
111 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
112 { } /* Terminating entry */
115 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
117 static struct usb_driver cypress_driver
= {
119 .probe
= usb_serial_probe
,
120 .disconnect
= usb_serial_disconnect
,
121 .id_table
= id_table_combined
,
126 packet_format_1
, /* b0:status, b1:payload count */
127 packet_format_2
/* b0[7:3]:status, b0[2:0]:payload count */
130 struct cypress_private
{
131 spinlock_t lock
; /* private lock */
132 int chiptype
; /* identifier of device, for quirks/etc */
133 int bytes_in
; /* used for statistics */
134 int bytes_out
; /* used for statistics */
135 int cmd_count
; /* used for statistics */
136 int cmd_ctrl
; /* always set this to 1 before issuing a command */
137 struct cypress_buf
*buf
; /* write buffer */
138 int write_urb_in_use
; /* write urb in use indicator */
139 int write_urb_interval
; /* interval to use for write urb */
140 int read_urb_interval
; /* interval to use for read urb */
141 int comm_is_ok
; /* true if communication is (still) ok */
142 int termios_initialized
;
143 __u8 line_control
; /* holds dtr / rts value */
144 __u8 current_status
; /* received from last read - info on dsr,cts,cd,ri,etc */
145 __u8 current_config
; /* stores the current configuration byte */
146 __u8 rx_flags
; /* throttling - used from whiteheat/ftdi_sio */
147 enum packet_format pkt_fmt
; /* format to use for packet send / receive */
148 int get_cfg_unsafe
; /* If true, the CYPRESS_GET_CONFIG is unsafe */
149 int baud_rate
; /* stores current baud rate in
151 int isthrottled
; /* if throttled, discard reads */
152 wait_queue_head_t delta_msr_wait
; /* used for TIOCMIWAIT */
153 char prev_status
, diff_status
; /* used for TIOCMIWAIT */
154 /* we pass a pointer to this as the argument sent to
155 cypress_set_termios old_termios */
156 struct ktermios tmp_termios
; /* stores the old termios settings */
159 /* write buffer structure */
161 unsigned int buf_size
;
167 /* function prototypes for the Cypress USB to serial device */
168 static int cypress_earthmate_startup(struct usb_serial
*serial
);
169 static int cypress_hidcom_startup(struct usb_serial
*serial
);
170 static int cypress_ca42v2_startup(struct usb_serial
*serial
);
171 static void cypress_release(struct usb_serial
*serial
);
172 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
173 static void cypress_close(struct usb_serial_port
*port
);
174 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
);
175 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
176 const unsigned char *buf
, int count
);
177 static void cypress_send(struct usb_serial_port
*port
);
178 static int cypress_write_room(struct tty_struct
*tty
);
179 static int cypress_ioctl(struct tty_struct
*tty
, struct file
*file
,
180 unsigned int cmd
, unsigned long arg
);
181 static void cypress_set_termios(struct tty_struct
*tty
,
182 struct usb_serial_port
*port
, struct ktermios
*old
);
183 static int cypress_tiocmget(struct tty_struct
*tty
, struct file
*file
);
184 static int cypress_tiocmset(struct tty_struct
*tty
, struct file
*file
,
185 unsigned int set
, unsigned int clear
);
186 static int cypress_chars_in_buffer(struct tty_struct
*tty
);
187 static void cypress_throttle(struct tty_struct
*tty
);
188 static void cypress_unthrottle(struct tty_struct
*tty
);
189 static void cypress_set_dead(struct usb_serial_port
*port
);
190 static void cypress_read_int_callback(struct urb
*urb
);
191 static void cypress_write_int_callback(struct urb
*urb
);
192 /* write buffer functions */
193 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
);
194 static void cypress_buf_free(struct cypress_buf
*cb
);
195 static void cypress_buf_clear(struct cypress_buf
*cb
);
196 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
);
197 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
);
198 static unsigned int cypress_buf_put(struct cypress_buf
*cb
,
199 const char *buf
, unsigned int count
);
200 static unsigned int cypress_buf_get(struct cypress_buf
*cb
,
201 char *buf
, unsigned int count
);
204 static struct usb_serial_driver cypress_earthmate_device
= {
206 .owner
= THIS_MODULE
,
209 .description
= "DeLorme Earthmate USB",
210 .usb_driver
= &cypress_driver
,
211 .id_table
= id_table_earthmate
,
213 .attach
= cypress_earthmate_startup
,
214 .release
= cypress_release
,
215 .open
= cypress_open
,
216 .close
= cypress_close
,
217 .dtr_rts
= cypress_dtr_rts
,
218 .write
= cypress_write
,
219 .write_room
= cypress_write_room
,
220 .ioctl
= cypress_ioctl
,
221 .set_termios
= cypress_set_termios
,
222 .tiocmget
= cypress_tiocmget
,
223 .tiocmset
= cypress_tiocmset
,
224 .chars_in_buffer
= cypress_chars_in_buffer
,
225 .throttle
= cypress_throttle
,
226 .unthrottle
= cypress_unthrottle
,
227 .read_int_callback
= cypress_read_int_callback
,
228 .write_int_callback
= cypress_write_int_callback
,
231 static struct usb_serial_driver cypress_hidcom_device
= {
233 .owner
= THIS_MODULE
,
236 .description
= "HID->COM RS232 Adapter",
237 .usb_driver
= &cypress_driver
,
238 .id_table
= id_table_cyphidcomrs232
,
240 .attach
= cypress_hidcom_startup
,
241 .release
= cypress_release
,
242 .open
= cypress_open
,
243 .close
= cypress_close
,
244 .dtr_rts
= cypress_dtr_rts
,
245 .write
= cypress_write
,
246 .write_room
= cypress_write_room
,
247 .ioctl
= cypress_ioctl
,
248 .set_termios
= cypress_set_termios
,
249 .tiocmget
= cypress_tiocmget
,
250 .tiocmset
= cypress_tiocmset
,
251 .chars_in_buffer
= cypress_chars_in_buffer
,
252 .throttle
= cypress_throttle
,
253 .unthrottle
= cypress_unthrottle
,
254 .read_int_callback
= cypress_read_int_callback
,
255 .write_int_callback
= cypress_write_int_callback
,
258 static struct usb_serial_driver cypress_ca42v2_device
= {
260 .owner
= THIS_MODULE
,
261 .name
= "nokiaca42v2",
263 .description
= "Nokia CA-42 V2 Adapter",
264 .usb_driver
= &cypress_driver
,
265 .id_table
= id_table_nokiaca42v2
,
267 .attach
= cypress_ca42v2_startup
,
268 .release
= cypress_release
,
269 .open
= cypress_open
,
270 .close
= cypress_close
,
271 .dtr_rts
= cypress_dtr_rts
,
272 .write
= cypress_write
,
273 .write_room
= cypress_write_room
,
274 .ioctl
= cypress_ioctl
,
275 .set_termios
= cypress_set_termios
,
276 .tiocmget
= cypress_tiocmget
,
277 .tiocmset
= cypress_tiocmset
,
278 .chars_in_buffer
= cypress_chars_in_buffer
,
279 .throttle
= cypress_throttle
,
280 .unthrottle
= cypress_unthrottle
,
281 .read_int_callback
= cypress_read_int_callback
,
282 .write_int_callback
= cypress_write_int_callback
,
285 /*****************************************************************************
286 * Cypress serial helper functions
287 *****************************************************************************/
290 static int analyze_baud_rate(struct usb_serial_port
*port
, speed_t new_rate
)
292 struct cypress_private
*priv
;
293 priv
= usb_get_serial_port_data(port
);
299 * The general purpose firmware for the Cypress M8 allows for
300 * a maximum speed of 57600bps (I have no idea whether DeLorme
301 * chose to use the general purpose firmware or not), if you
302 * need to modify this speed setting for your own project
303 * please add your own chiptype and modify the code likewise.
304 * The Cypress HID->COM device will work successfully up to
305 * 115200bps (but the actual throughput is around 3kBps).
307 if (port
->serial
->dev
->speed
== USB_SPEED_LOW
) {
309 * Mike Isely <isely@pobox.com> 2-Feb-2008: The
310 * Cypress app note that describes this mechanism
311 * states the the low-speed part can't handle more
312 * than 800 bytes/sec, in which case 4800 baud is the
313 * safest speed for a part like that.
315 if (new_rate
> 4800) {
316 dbg("%s - failed setting baud rate, device incapable "
317 "speed %d", __func__
, new_rate
);
321 switch (priv
->chiptype
) {
323 if (new_rate
<= 600) {
324 /* 300 and 600 baud rates are supported under
325 * the generic firmware, but are not used with
326 * NMEA and SiRF protocols */
327 dbg("%s - failed setting baud rate, unsupported speed "
328 "of %d on Earthmate GPS", __func__
, new_rate
);
339 /* This function can either set or retrieve the current serial line settings */
340 static int cypress_serial_control(struct tty_struct
*tty
,
341 struct usb_serial_port
*port
, speed_t baud_rate
, int data_bits
,
342 int stop_bits
, int parity_enable
, int parity_type
, int reset
,
343 int cypress_request_type
)
345 int new_baudrate
= 0, retval
= 0, tries
= 0;
346 struct cypress_private
*priv
;
348 const unsigned int feature_len
= 5;
353 priv
= usb_get_serial_port_data(port
);
355 if (!priv
->comm_is_ok
)
358 feature_buffer
= kcalloc(feature_len
, sizeof(u8
), GFP_KERNEL
);
362 switch (cypress_request_type
) {
363 case CYPRESS_SET_CONFIG
:
364 /* 0 means 'Hang up' so doesn't change the true bit rate */
365 new_baudrate
= priv
->baud_rate
;
366 if (baud_rate
&& baud_rate
!= priv
->baud_rate
) {
367 dbg("%s - baud rate is changing", __func__
);
368 retval
= analyze_baud_rate(port
, baud_rate
);
370 new_baudrate
= retval
;
371 dbg("%s - New baud rate set to %d",
372 __func__
, new_baudrate
);
375 dbg("%s - baud rate is being sent as %d",
376 __func__
, new_baudrate
);
378 /* fill the feature_buffer with new configuration */
379 put_unaligned_le32(new_baudrate
, feature_buffer
);
380 feature_buffer
[4] |= data_bits
; /* assign data bits in 2 bit space ( max 3 ) */
382 feature_buffer
[4] |= (stop_bits
<< 3); /* assign stop bits in 1 bit space */
383 feature_buffer
[4] |= (parity_enable
<< 4); /* assign parity flag in 1 bit space */
384 feature_buffer
[4] |= (parity_type
<< 5); /* assign parity type in 1 bit space */
386 feature_buffer
[4] |= (reset
<< 7); /* assign reset at end of byte, 1 bit space */
388 dbg("%s - device is being sent this feature report:",
390 dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__
,
391 feature_buffer
[0], feature_buffer
[1],
392 feature_buffer
[2], feature_buffer
[3],
396 retval
= usb_control_msg(port
->serial
->dev
,
397 usb_sndctrlpipe(port
->serial
->dev
, 0),
399 USB_DIR_OUT
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
400 0x0300, 0, feature_buffer
,
406 } while (retval
!= feature_len
&&
409 if (retval
!= feature_len
) {
410 dev_err(&port
->dev
, "%s - failed sending serial "
411 "line settings - %d\n", __func__
, retval
);
412 cypress_set_dead(port
);
414 spin_lock_irqsave(&priv
->lock
, flags
);
415 priv
->baud_rate
= new_baudrate
;
416 priv
->current_config
= feature_buffer
[4];
417 spin_unlock_irqrestore(&priv
->lock
, flags
);
418 /* If we asked for a speed change encode it */
420 tty_encode_baud_rate(tty
,
421 new_baudrate
, new_baudrate
);
424 case CYPRESS_GET_CONFIG
:
425 if (priv
->get_cfg_unsafe
) {
426 /* Not implemented for this device,
427 and if we try to do it we're likely
428 to crash the hardware. */
432 dbg("%s - retreiving serial line settings", __func__
);
434 retval
= usb_control_msg(port
->serial
->dev
,
435 usb_rcvctrlpipe(port
->serial
->dev
, 0),
437 USB_DIR_IN
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
438 0x0300, 0, feature_buffer
,
443 } while (retval
!= feature_len
444 && retval
!= -ENODEV
);
446 if (retval
!= feature_len
) {
447 dev_err(&port
->dev
, "%s - failed to retrieve serial "
448 "line settings - %d\n", __func__
, retval
);
449 cypress_set_dead(port
);
452 spin_lock_irqsave(&priv
->lock
, flags
);
453 /* store the config in one byte, and later
454 use bit masks to check values */
455 priv
->current_config
= feature_buffer
[4];
456 priv
->baud_rate
= get_unaligned_le32(feature_buffer
);
457 spin_unlock_irqrestore(&priv
->lock
, flags
);
460 spin_lock_irqsave(&priv
->lock
, flags
);
462 spin_unlock_irqrestore(&priv
->lock
, flags
);
464 kfree(feature_buffer
);
466 } /* cypress_serial_control */
469 static void cypress_set_dead(struct usb_serial_port
*port
)
471 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
474 spin_lock_irqsave(&priv
->lock
, flags
);
475 if (!priv
->comm_is_ok
) {
476 spin_unlock_irqrestore(&priv
->lock
, flags
);
479 priv
->comm_is_ok
= 0;
480 spin_unlock_irqrestore(&priv
->lock
, flags
);
482 dev_err(&port
->dev
, "cypress_m8 suspending failing port %d - "
483 "interval might be too short\n", port
->number
);
487 /*****************************************************************************
488 * Cypress serial driver functions
489 *****************************************************************************/
492 static int generic_startup(struct usb_serial
*serial
)
494 struct cypress_private
*priv
;
495 struct usb_serial_port
*port
= serial
->port
[0];
497 dbg("%s - port %d", __func__
, port
->number
);
499 priv
= kzalloc(sizeof(struct cypress_private
), GFP_KERNEL
);
503 priv
->comm_is_ok
= !0;
504 spin_lock_init(&priv
->lock
);
505 priv
->buf
= cypress_buf_alloc(CYPRESS_BUF_SIZE
);
506 if (priv
->buf
== NULL
) {
510 init_waitqueue_head(&priv
->delta_msr_wait
);
512 usb_reset_configuration(serial
->dev
);
515 priv
->line_control
= 0;
516 priv
->termios_initialized
= 0;
518 /* Default packet format setting is determined by packet size.
519 Anything with a size larger then 9 must have a separate
520 count field since the 3 bit count field is otherwise too
521 small. Otherwise we can use the slightly more compact
522 format. This is in accordance with the cypress_m8 serial
523 converter app note. */
524 if (port
->interrupt_out_size
> 9)
525 priv
->pkt_fmt
= packet_format_1
;
527 priv
->pkt_fmt
= packet_format_2
;
530 priv
->write_urb_interval
= interval
;
531 priv
->read_urb_interval
= interval
;
532 dbg("%s - port %d read & write intervals forced to %d",
533 __func__
, port
->number
, interval
);
535 priv
->write_urb_interval
= port
->interrupt_out_urb
->interval
;
536 priv
->read_urb_interval
= port
->interrupt_in_urb
->interval
;
537 dbg("%s - port %d intervals: read=%d write=%d",
538 __func__
, port
->number
,
539 priv
->read_urb_interval
, priv
->write_urb_interval
);
541 usb_set_serial_port_data(port
, priv
);
547 static int cypress_earthmate_startup(struct usb_serial
*serial
)
549 struct cypress_private
*priv
;
550 struct usb_serial_port
*port
= serial
->port
[0];
554 if (generic_startup(serial
)) {
555 dbg("%s - Failed setting up port %d", __func__
,
560 priv
= usb_get_serial_port_data(port
);
561 priv
->chiptype
= CT_EARTHMATE
;
562 /* All Earthmate devices use the separated-count packet
564 priv
->pkt_fmt
= packet_format_1
;
565 if (serial
->dev
->descriptor
.idProduct
!=
566 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB
)) {
567 /* The old original USB Earthmate seemed able to
568 handle GET_CONFIG requests; everything they've
569 produced since that time crashes if this command is
571 dbg("%s - Marking this device as unsafe for GET_CONFIG "
572 "commands", __func__
);
573 priv
->get_cfg_unsafe
= !0;
577 } /* cypress_earthmate_startup */
580 static int cypress_hidcom_startup(struct usb_serial
*serial
)
582 struct cypress_private
*priv
;
586 if (generic_startup(serial
)) {
587 dbg("%s - Failed setting up port %d", __func__
,
588 serial
->port
[0]->number
);
592 priv
= usb_get_serial_port_data(serial
->port
[0]);
593 priv
->chiptype
= CT_CYPHIDCOM
;
596 } /* cypress_hidcom_startup */
599 static int cypress_ca42v2_startup(struct usb_serial
*serial
)
601 struct cypress_private
*priv
;
605 if (generic_startup(serial
)) {
606 dbg("%s - Failed setting up port %d", __func__
,
607 serial
->port
[0]->number
);
611 priv
= usb_get_serial_port_data(serial
->port
[0]);
612 priv
->chiptype
= CT_CA42V2
;
615 } /* cypress_ca42v2_startup */
618 static void cypress_release(struct usb_serial
*serial
)
620 struct cypress_private
*priv
;
622 dbg("%s - port %d", __func__
, serial
->port
[0]->number
);
624 /* all open ports are closed at this point */
626 priv
= usb_get_serial_port_data(serial
->port
[0]);
629 cypress_buf_free(priv
->buf
);
635 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
637 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
638 struct usb_serial
*serial
= port
->serial
;
642 dbg("%s - port %d", __func__
, port
->number
);
644 if (!priv
->comm_is_ok
)
647 /* clear halts before open */
648 usb_clear_halt(serial
->dev
, 0x81);
649 usb_clear_halt(serial
->dev
, 0x02);
651 spin_lock_irqsave(&priv
->lock
, flags
);
652 /* reset read/write statistics */
657 spin_unlock_irqrestore(&priv
->lock
, flags
);
663 cypress_set_termios(tty
, port
, &priv
->tmp_termios
);
665 /* setup the port and start reading from the device */
666 if (!port
->interrupt_in_urb
) {
667 dev_err(&port
->dev
, "%s - interrupt_in_urb is empty!\n",
672 usb_fill_int_urb(port
->interrupt_in_urb
, serial
->dev
,
673 usb_rcvintpipe(serial
->dev
, port
->interrupt_in_endpointAddress
),
674 port
->interrupt_in_urb
->transfer_buffer
,
675 port
->interrupt_in_urb
->transfer_buffer_length
,
676 cypress_read_int_callback
, port
, priv
->read_urb_interval
);
677 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
681 "%s - failed submitting read urb, error %d\n",
683 cypress_set_dead(port
);
685 port
->port
.drain_delay
= 256;
689 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
)
691 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
692 /* drop dtr and rts */
693 spin_lock_irq(&priv
->lock
);
695 priv
->line_control
= 0;
697 priv
->line_control
= CONTROL_DTR
| CONTROL_RTS
;
699 spin_unlock_irq(&priv
->lock
);
700 cypress_write(NULL
, port
, NULL
, 0);
703 static void cypress_close(struct usb_serial_port
*port
)
705 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
707 dbg("%s - port %d", __func__
, port
->number
);
709 /* writing is potentially harmful, lock must be taken */
710 mutex_lock(&port
->serial
->disc_mutex
);
711 if (port
->serial
->disconnected
) {
712 mutex_unlock(&port
->serial
->disc_mutex
);
715 cypress_buf_clear(priv
->buf
);
716 dbg("%s - stopping urbs", __func__
);
717 usb_kill_urb(port
->interrupt_in_urb
);
718 usb_kill_urb(port
->interrupt_out_urb
);
722 dev_info(&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
723 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
724 mutex_unlock(&port
->serial
->disc_mutex
);
725 } /* cypress_close */
728 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
729 const unsigned char *buf
, int count
)
731 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
734 dbg("%s - port %d, %d bytes", __func__
, port
->number
, count
);
736 /* line control commands, which need to be executed immediately,
737 are not put into the buffer for obvious reasons.
739 if (priv
->cmd_ctrl
) {
747 spin_lock_irqsave(&priv
->lock
, flags
);
748 count
= cypress_buf_put(priv
->buf
, buf
, count
);
749 spin_unlock_irqrestore(&priv
->lock
, flags
);
755 } /* cypress_write */
758 static void cypress_send(struct usb_serial_port
*port
)
760 int count
= 0, result
, offset
, actual_size
;
761 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
764 if (!priv
->comm_is_ok
)
767 dbg("%s - port %d", __func__
, port
->number
);
768 dbg("%s - interrupt out size is %d", __func__
,
769 port
->interrupt_out_size
);
771 spin_lock_irqsave(&priv
->lock
, flags
);
772 if (priv
->write_urb_in_use
) {
773 dbg("%s - can't write, urb in use", __func__
);
774 spin_unlock_irqrestore(&priv
->lock
, flags
);
777 spin_unlock_irqrestore(&priv
->lock
, flags
);
780 memset(port
->interrupt_out_urb
->transfer_buffer
, 0,
781 port
->interrupt_out_size
);
783 spin_lock_irqsave(&priv
->lock
, flags
);
784 switch (priv
->pkt_fmt
) {
786 case packet_format_1
:
787 /* this is for the CY7C64013... */
789 port
->interrupt_out_buffer
[0] = priv
->line_control
;
791 case packet_format_2
:
792 /* this is for the CY7C63743... */
794 port
->interrupt_out_buffer
[0] = priv
->line_control
;
798 if (priv
->line_control
& CONTROL_RESET
)
799 priv
->line_control
&= ~CONTROL_RESET
;
801 if (priv
->cmd_ctrl
) {
803 dbg("%s - line control command being issued", __func__
);
804 spin_unlock_irqrestore(&priv
->lock
, flags
);
807 spin_unlock_irqrestore(&priv
->lock
, flags
);
809 count
= cypress_buf_get(priv
->buf
, &port
->interrupt_out_buffer
[offset
],
810 port
->interrupt_out_size
-offset
);
815 switch (priv
->pkt_fmt
) {
817 case packet_format_1
:
818 port
->interrupt_out_buffer
[1] = count
;
820 case packet_format_2
:
821 port
->interrupt_out_buffer
[0] |= count
;
824 dbg("%s - count is %d", __func__
, count
);
827 spin_lock_irqsave(&priv
->lock
, flags
);
828 priv
->write_urb_in_use
= 1;
829 spin_unlock_irqrestore(&priv
->lock
, flags
);
834 actual_size
= count
+
835 (priv
->pkt_fmt
== packet_format_1
? 2 : 1);
837 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
838 port
->interrupt_out_size
,
839 port
->interrupt_out_urb
->transfer_buffer
);
841 usb_fill_int_urb(port
->interrupt_out_urb
, port
->serial
->dev
,
842 usb_sndintpipe(port
->serial
->dev
, port
->interrupt_out_endpointAddress
),
843 port
->interrupt_out_buffer
, port
->interrupt_out_size
,
844 cypress_write_int_callback
, port
, priv
->write_urb_interval
);
845 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
848 "%s - failed submitting write urb, error %d\n",
850 priv
->write_urb_in_use
= 0;
851 cypress_set_dead(port
);
854 spin_lock_irqsave(&priv
->lock
, flags
);
858 /* do not count the line control and size bytes */
859 priv
->bytes_out
+= count
;
860 spin_unlock_irqrestore(&priv
->lock
, flags
);
862 usb_serial_port_softint(port
);
866 /* returns how much space is available in the soft buffer */
867 static int cypress_write_room(struct tty_struct
*tty
)
869 struct usb_serial_port
*port
= tty
->driver_data
;
870 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
874 dbg("%s - port %d", __func__
, port
->number
);
876 spin_lock_irqsave(&priv
->lock
, flags
);
877 room
= cypress_buf_space_avail(priv
->buf
);
878 spin_unlock_irqrestore(&priv
->lock
, flags
);
880 dbg("%s - returns %d", __func__
, room
);
885 static int cypress_tiocmget(struct tty_struct
*tty
, struct file
*file
)
887 struct usb_serial_port
*port
= tty
->driver_data
;
888 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
889 __u8 status
, control
;
890 unsigned int result
= 0;
893 dbg("%s - port %d", __func__
, port
->number
);
895 spin_lock_irqsave(&priv
->lock
, flags
);
896 control
= priv
->line_control
;
897 status
= priv
->current_status
;
898 spin_unlock_irqrestore(&priv
->lock
, flags
);
900 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
901 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
902 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
903 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
904 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
905 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
907 dbg("%s - result = %x", __func__
, result
);
913 static int cypress_tiocmset(struct tty_struct
*tty
, struct file
*file
,
914 unsigned int set
, unsigned int clear
)
916 struct usb_serial_port
*port
= tty
->driver_data
;
917 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
920 dbg("%s - port %d", __func__
, port
->number
);
922 spin_lock_irqsave(&priv
->lock
, flags
);
924 priv
->line_control
|= CONTROL_RTS
;
926 priv
->line_control
|= CONTROL_DTR
;
927 if (clear
& TIOCM_RTS
)
928 priv
->line_control
&= ~CONTROL_RTS
;
929 if (clear
& TIOCM_DTR
)
930 priv
->line_control
&= ~CONTROL_DTR
;
932 spin_unlock_irqrestore(&priv
->lock
, flags
);
934 return cypress_write(tty
, port
, NULL
, 0);
938 static int cypress_ioctl(struct tty_struct
*tty
, struct file
*file
,
939 unsigned int cmd
, unsigned long arg
)
941 struct usb_serial_port
*port
= tty
->driver_data
;
942 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
944 dbg("%s - port %d, cmd 0x%.4x", __func__
, port
->number
, cmd
);
947 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
949 while (priv
!= NULL
) {
950 interruptible_sleep_on(&priv
->delta_msr_wait
);
951 /* see if a signal did it */
952 if (signal_pending(current
))
955 char diff
= priv
->diff_status
;
957 return -EIO
; /* no change => error */
959 /* consume all events */
960 priv
->diff_status
= 0;
962 /* return 0 if caller wanted to know about
964 if (((arg
& TIOCM_RNG
) && (diff
& UART_RI
)) ||
965 ((arg
& TIOCM_DSR
) && (diff
& UART_DSR
)) ||
966 ((arg
& TIOCM_CD
) && (diff
& UART_CD
)) ||
967 ((arg
& TIOCM_CTS
) && (diff
& UART_CTS
)))
969 /* otherwise caller can't care less about what
970 * happened, and so we continue to wait for
979 dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__
, cmd
);
981 } /* cypress_ioctl */
984 static void cypress_set_termios(struct tty_struct
*tty
,
985 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
987 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
988 int data_bits
, stop_bits
, parity_type
, parity_enable
;
989 unsigned cflag
, iflag
;
994 dbg("%s - port %d", __func__
, port
->number
);
996 spin_lock_irqsave(&priv
->lock
, flags
);
997 /* We can't clean this one up as we don't know the device type
999 if (!priv
->termios_initialized
) {
1000 if (priv
->chiptype
== CT_EARTHMATE
) {
1001 *(tty
->termios
) = tty_std_termios
;
1002 tty
->termios
->c_cflag
= B4800
| CS8
| CREAD
| HUPCL
|
1004 tty
->termios
->c_ispeed
= 4800;
1005 tty
->termios
->c_ospeed
= 4800;
1006 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
1007 *(tty
->termios
) = tty_std_termios
;
1008 tty
->termios
->c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
1010 tty
->termios
->c_ispeed
= 9600;
1011 tty
->termios
->c_ospeed
= 9600;
1012 } else if (priv
->chiptype
== CT_CA42V2
) {
1013 *(tty
->termios
) = tty_std_termios
;
1014 tty
->termios
->c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
1016 tty
->termios
->c_ispeed
= 9600;
1017 tty
->termios
->c_ospeed
= 9600;
1019 priv
->termios_initialized
= 1;
1021 spin_unlock_irqrestore(&priv
->lock
, flags
);
1023 /* Unsupported features need clearing */
1024 tty
->termios
->c_cflag
&= ~(CMSPAR
|CRTSCTS
);
1026 cflag
= tty
->termios
->c_cflag
;
1027 iflag
= tty
->termios
->c_iflag
;
1029 /* check if there are new settings */
1031 spin_lock_irqsave(&priv
->lock
, flags
);
1032 priv
->tmp_termios
= *(tty
->termios
);
1033 spin_unlock_irqrestore(&priv
->lock
, flags
);
1036 /* set number of data bits, parity, stop bits */
1037 /* when parity is disabled the parity type bit is ignored */
1039 /* 1 means 2 stop bits, 0 means 1 stop bit */
1040 stop_bits
= cflag
& CSTOPB
? 1 : 0;
1042 if (cflag
& PARENB
) {
1044 /* 1 means odd parity, 0 means even parity */
1045 parity_type
= cflag
& PARODD
? 1 : 0;
1047 parity_enable
= parity_type
= 0;
1049 switch (cflag
& CSIZE
) {
1063 dev_err(&port
->dev
, "%s - CSIZE was set, but not CS5-CS8\n",
1067 spin_lock_irqsave(&priv
->lock
, flags
);
1068 oldlines
= priv
->line_control
;
1069 if ((cflag
& CBAUD
) == B0
) {
1070 /* drop dtr and rts */
1071 dbg("%s - dropping the lines, baud rate 0bps", __func__
);
1072 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
1074 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
1075 spin_unlock_irqrestore(&priv
->lock
, flags
);
1077 dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
1078 "%d data_bits (+5)", __func__
, stop_bits
,
1079 parity_enable
, parity_type
, data_bits
);
1081 cypress_serial_control(tty
, port
, tty_get_baud_rate(tty
),
1082 data_bits
, stop_bits
,
1083 parity_enable
, parity_type
,
1084 0, CYPRESS_SET_CONFIG
);
1086 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1087 * filled into the private structure this should confirm that all is
1088 * working if it returns what we just set */
1089 cypress_serial_control(tty
, port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
1091 /* Here we can define custom tty settings for devices; the main tty
1092 * termios flag base comes from empeg.c */
1094 spin_lock_irqsave(&priv
->lock
, flags
);
1095 if (priv
->chiptype
== CT_EARTHMATE
&& priv
->baud_rate
== 4800) {
1096 dbg("Using custom termios settings for a baud rate of "
1098 /* define custom termios settings for NMEA protocol */
1100 tty
->termios
->c_iflag
/* input modes - */
1101 &= ~(IGNBRK
/* disable ignore break */
1102 | BRKINT
/* disable break causes interrupt */
1103 | PARMRK
/* disable mark parity errors */
1104 | ISTRIP
/* disable clear high bit of input char */
1105 | INLCR
/* disable translate NL to CR */
1106 | IGNCR
/* disable ignore CR */
1107 | ICRNL
/* disable translate CR to NL */
1108 | IXON
); /* disable enable XON/XOFF flow control */
1110 tty
->termios
->c_oflag
/* output modes */
1111 &= ~OPOST
; /* disable postprocess output char */
1113 tty
->termios
->c_lflag
/* line discipline modes */
1114 &= ~(ECHO
/* disable echo input characters */
1115 | ECHONL
/* disable echo new line */
1116 | ICANON
/* disable erase, kill, werase, and rprnt
1117 special characters */
1118 | ISIG
/* disable interrupt, quit, and suspend
1119 special characters */
1120 | IEXTEN
); /* disable non-POSIX special characters */
1121 } /* CT_CYPHIDCOM: Application should handle this for device */
1123 linechange
= (priv
->line_control
!= oldlines
);
1124 spin_unlock_irqrestore(&priv
->lock
, flags
);
1126 /* if necessary, set lines */
1129 cypress_write(tty
, port
, NULL
, 0);
1131 } /* cypress_set_termios */
1134 /* returns amount of data still left in soft buffer */
1135 static int cypress_chars_in_buffer(struct tty_struct
*tty
)
1137 struct usb_serial_port
*port
= tty
->driver_data
;
1138 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1140 unsigned long flags
;
1142 dbg("%s - port %d", __func__
, port
->number
);
1144 spin_lock_irqsave(&priv
->lock
, flags
);
1145 chars
= cypress_buf_data_avail(priv
->buf
);
1146 spin_unlock_irqrestore(&priv
->lock
, flags
);
1148 dbg("%s - returns %d", __func__
, chars
);
1153 static void cypress_throttle(struct tty_struct
*tty
)
1155 struct usb_serial_port
*port
= tty
->driver_data
;
1156 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1158 dbg("%s - port %d", __func__
, port
->number
);
1160 spin_lock_irq(&priv
->lock
);
1161 priv
->rx_flags
= THROTTLED
;
1162 spin_unlock_irq(&priv
->lock
);
1166 static void cypress_unthrottle(struct tty_struct
*tty
)
1168 struct usb_serial_port
*port
= tty
->driver_data
;
1169 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1170 int actually_throttled
, result
;
1172 dbg("%s - port %d", __func__
, port
->number
);
1174 spin_lock_irq(&priv
->lock
);
1175 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1177 spin_unlock_irq(&priv
->lock
);
1179 if (!priv
->comm_is_ok
)
1182 if (actually_throttled
) {
1183 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1185 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
1187 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1188 "error %d\n", __func__
, result
);
1189 cypress_set_dead(port
);
1195 static void cypress_read_int_callback(struct urb
*urb
)
1197 struct usb_serial_port
*port
= urb
->context
;
1198 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1199 struct tty_struct
*tty
;
1200 unsigned char *data
= urb
->transfer_buffer
;
1201 unsigned long flags
;
1202 char tty_flag
= TTY_NORMAL
;
1207 int status
= urb
->status
;
1209 dbg("%s - port %d", __func__
, port
->number
);
1212 case 0: /* success */
1217 /* precursor to disconnect so just go away */
1220 /* Can't call usb_clear_halt while in_interrupt */
1223 /* something ugly is going on... */
1224 dev_err(&urb
->dev
->dev
,
1225 "%s - unexpected nonzero read status received: %d\n",
1227 cypress_set_dead(port
);
1231 spin_lock_irqsave(&priv
->lock
, flags
);
1232 if (priv
->rx_flags
& THROTTLED
) {
1233 dbg("%s - now throttling", __func__
);
1234 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1235 spin_unlock_irqrestore(&priv
->lock
, flags
);
1238 spin_unlock_irqrestore(&priv
->lock
, flags
);
1240 tty
= tty_port_tty_get(&port
->port
);
1242 dbg("%s - bad tty pointer - exiting", __func__
);
1246 spin_lock_irqsave(&priv
->lock
, flags
);
1247 result
= urb
->actual_length
;
1248 switch (priv
->pkt_fmt
) {
1250 case packet_format_1
:
1251 /* This is for the CY7C64013... */
1252 priv
->current_status
= data
[0] & 0xF8;
1253 bytes
= data
[1] + 2;
1258 case packet_format_2
:
1259 /* This is for the CY7C63743... */
1260 priv
->current_status
= data
[0] & 0xF8;
1261 bytes
= (data
[0] & 0x07) + 1;
1267 spin_unlock_irqrestore(&priv
->lock
, flags
);
1268 if (result
< bytes
) {
1269 dbg("%s - wrong packet size - received %d bytes but packet "
1270 "said %d bytes", __func__
, result
, bytes
);
1274 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
1275 urb
->actual_length
, data
);
1277 spin_lock_irqsave(&priv
->lock
, flags
);
1278 /* check to see if status has changed */
1279 if (priv
->current_status
!= priv
->prev_status
) {
1280 priv
->diff_status
|= priv
->current_status
^
1282 wake_up_interruptible(&priv
->delta_msr_wait
);
1283 priv
->prev_status
= priv
->current_status
;
1285 spin_unlock_irqrestore(&priv
->lock
, flags
);
1287 /* hangup, as defined in acm.c... this might be a bad place for it
1289 if (tty
&& !(tty
->termios
->c_cflag
& CLOCAL
) &&
1290 !(priv
->current_status
& UART_CD
)) {
1291 dbg("%s - calling hangup", __func__
);
1296 /* There is one error bit... I'm assuming it is a parity error
1297 * indicator as the generic firmware will set this bit to 1 if a
1298 * parity error occurs.
1299 * I can not find reference to any other error events. */
1300 spin_lock_irqsave(&priv
->lock
, flags
);
1301 if (priv
->current_status
& CYP_ERROR
) {
1302 spin_unlock_irqrestore(&priv
->lock
, flags
);
1303 tty_flag
= TTY_PARITY
;
1304 dbg("%s - Parity Error detected", __func__
);
1306 spin_unlock_irqrestore(&priv
->lock
, flags
);
1308 /* process read if there is data other than line status */
1309 if (tty
&& bytes
> i
) {
1310 tty_insert_flip_string_fixed_flag(tty
, data
+ i
,
1311 tty_flag
, bytes
- i
);
1312 tty_flip_buffer_push(tty
);
1315 spin_lock_irqsave(&priv
->lock
, flags
);
1316 /* control and status byte(s) are also counted */
1317 priv
->bytes_in
+= bytes
;
1318 spin_unlock_irqrestore(&priv
->lock
, flags
);
1323 /* Continue trying to always read */
1325 if (priv
->comm_is_ok
) {
1326 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1327 usb_rcvintpipe(port
->serial
->dev
,
1328 port
->interrupt_in_endpointAddress
),
1329 port
->interrupt_in_urb
->transfer_buffer
,
1330 port
->interrupt_in_urb
->transfer_buffer_length
,
1331 cypress_read_int_callback
, port
,
1332 priv
->read_urb_interval
);
1333 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1334 if (result
&& result
!= -EPERM
) {
1335 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting "
1336 "read urb, error %d\n", __func__
,
1338 cypress_set_dead(port
);
1343 } /* cypress_read_int_callback */
1346 static void cypress_write_int_callback(struct urb
*urb
)
1348 struct usb_serial_port
*port
= urb
->context
;
1349 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1351 int status
= urb
->status
;
1353 dbg("%s - port %d", __func__
, port
->number
);
1362 /* this urb is terminated, clean up */
1363 dbg("%s - urb shutting down with status: %d",
1365 priv
->write_urb_in_use
= 0;
1367 case -EPIPE
: /* no break needed; clear halt and resubmit */
1368 if (!priv
->comm_is_ok
)
1370 usb_clear_halt(port
->serial
->dev
, 0x02);
1371 /* error in the urb, so we have to resubmit it */
1372 dbg("%s - nonzero write bulk status received: %d",
1374 port
->interrupt_out_urb
->transfer_buffer_length
= 1;
1375 port
->interrupt_out_urb
->dev
= port
->serial
->dev
;
1376 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
1379 dev_err(&urb
->dev
->dev
,
1380 "%s - failed resubmitting write urb, error %d\n",
1382 cypress_set_dead(port
);
1385 dev_err(&urb
->dev
->dev
,
1386 "%s - unexpected nonzero write status received: %d\n",
1388 cypress_set_dead(port
);
1391 priv
->write_urb_in_use
= 0;
1393 /* send any buffered data */
1398 /*****************************************************************************
1399 * Write buffer functions - buffering code from pl2303 used
1400 *****************************************************************************/
1405 * Allocate a circular buffer and all associated memory.
1408 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
)
1411 struct cypress_buf
*cb
;
1417 cb
= kmalloc(sizeof(struct cypress_buf
), GFP_KERNEL
);
1421 cb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1422 if (cb
->buf_buf
== NULL
) {
1427 cb
->buf_size
= size
;
1428 cb
->buf_get
= cb
->buf_put
= cb
->buf_buf
;
1438 * Free the buffer and all associated memory.
1441 static void cypress_buf_free(struct cypress_buf
*cb
)
1453 * Clear out all data in the circular buffer.
1456 static void cypress_buf_clear(struct cypress_buf
*cb
)
1459 cb
->buf_get
= cb
->buf_put
;
1460 /* equivalent to a get of all data available */
1465 * cypress_buf_data_avail
1467 * Return the number of bytes of data available in the circular
1471 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
)
1474 return (cb
->buf_size
+ cb
->buf_put
- cb
->buf_get
)
1482 * cypress_buf_space_avail
1484 * Return the number of bytes of space available in the circular
1488 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
)
1491 return (cb
->buf_size
+ cb
->buf_get
- cb
->buf_put
- 1)
1501 * Copy data data from a user buffer and put it into the circular buffer.
1502 * Restrict to the amount of space available.
1504 * Return the number of bytes copied.
1507 static unsigned int cypress_buf_put(struct cypress_buf
*cb
, const char *buf
,
1517 len
= cypress_buf_space_avail(cb
);
1524 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_put
;
1526 memcpy(cb
->buf_put
, buf
, len
);
1527 memcpy(cb
->buf_buf
, buf
+len
, count
- len
);
1528 cb
->buf_put
= cb
->buf_buf
+ count
- len
;
1530 memcpy(cb
->buf_put
, buf
, count
);
1532 cb
->buf_put
+= count
;
1533 else /* count == len */
1534 cb
->buf_put
= cb
->buf_buf
;
1545 * Get data from the circular buffer and copy to the given buffer.
1546 * Restrict to the amount of data available.
1548 * Return the number of bytes copied.
1551 static unsigned int cypress_buf_get(struct cypress_buf
*cb
, char *buf
,
1561 len
= cypress_buf_data_avail(cb
);
1568 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_get
;
1570 memcpy(buf
, cb
->buf_get
, len
);
1571 memcpy(buf
+len
, cb
->buf_buf
, count
- len
);
1572 cb
->buf_get
= cb
->buf_buf
+ count
- len
;
1574 memcpy(buf
, cb
->buf_get
, count
);
1576 cb
->buf_get
+= count
;
1577 else /* count == len */
1578 cb
->buf_get
= cb
->buf_buf
;
1585 /*****************************************************************************
1587 *****************************************************************************/
1589 static int __init
cypress_init(void)
1593 dbg("%s", __func__
);
1595 retval
= usb_serial_register(&cypress_earthmate_device
);
1597 goto failed_em_register
;
1598 retval
= usb_serial_register(&cypress_hidcom_device
);
1600 goto failed_hidcom_register
;
1601 retval
= usb_serial_register(&cypress_ca42v2_device
);
1603 goto failed_ca42v2_register
;
1604 retval
= usb_register(&cypress_driver
);
1606 goto failed_usb_register
;
1608 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1612 failed_usb_register
:
1613 usb_serial_deregister(&cypress_ca42v2_device
);
1614 failed_ca42v2_register
:
1615 usb_serial_deregister(&cypress_hidcom_device
);
1616 failed_hidcom_register
:
1617 usb_serial_deregister(&cypress_earthmate_device
);
1623 static void __exit
cypress_exit(void)
1625 dbg("%s", __func__
);
1627 usb_deregister(&cypress_driver
);
1628 usb_serial_deregister(&cypress_earthmate_device
);
1629 usb_serial_deregister(&cypress_hidcom_device
);
1630 usb_serial_deregister(&cypress_ca42v2_device
);
1634 module_init(cypress_init
);
1635 module_exit(cypress_exit
);
1637 MODULE_AUTHOR(DRIVER_AUTHOR
);
1638 MODULE_DESCRIPTION(DRIVER_DESC
);
1639 MODULE_VERSION(DRIVER_VERSION
);
1640 MODULE_LICENSE("GPL");
1642 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1643 MODULE_PARM_DESC(debug
, "Debug enabled or not");
1644 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1645 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1646 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1647 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");
1648 module_param(unstable_bauds
, bool, S_IRUGO
| S_IWUSR
);
1649 MODULE_PARM_DESC(unstable_bauds
, "Allow unstable baud rates");