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
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 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
99 { } /* Terminating entry */
102 static struct usb_device_id id_table_nokiaca42v2
[] = {
103 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
104 { } /* Terminating entry */
107 static struct usb_device_id id_table_combined
[] = {
108 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
109 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
110 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
111 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
112 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
113 { } /* Terminating entry */
116 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
118 static struct usb_driver cypress_driver
= {
120 .probe
= usb_serial_probe
,
121 .disconnect
= usb_serial_disconnect
,
122 .id_table
= id_table_combined
,
127 packet_format_1
, /* b0:status, b1:payload count */
128 packet_format_2
/* b0[7:3]:status, b0[2:0]:payload count */
131 struct cypress_private
{
132 spinlock_t lock
; /* private lock */
133 int chiptype
; /* identifier of device, for quirks/etc */
134 int bytes_in
; /* used for statistics */
135 int bytes_out
; /* used for statistics */
136 int cmd_count
; /* used for statistics */
137 int cmd_ctrl
; /* always set this to 1 before issuing a command */
138 struct cypress_buf
*buf
; /* write buffer */
139 int write_urb_in_use
; /* write urb in use indicator */
140 int write_urb_interval
; /* interval to use for write urb */
141 int read_urb_interval
; /* interval to use for read urb */
142 int comm_is_ok
; /* true if communication is (still) ok */
143 int termios_initialized
;
144 __u8 line_control
; /* holds dtr / rts value */
145 __u8 current_status
; /* received from last read - info on dsr,cts,cd,ri,etc */
146 __u8 current_config
; /* stores the current configuration byte */
147 __u8 rx_flags
; /* throttling - used from whiteheat/ftdi_sio */
148 enum packet_format pkt_fmt
; /* format to use for packet send / receive */
149 int get_cfg_unsafe
; /* If true, the CYPRESS_GET_CONFIG is unsafe */
150 int baud_rate
; /* stores current baud rate in
152 int isthrottled
; /* if throttled, discard reads */
153 wait_queue_head_t delta_msr_wait
; /* used for TIOCMIWAIT */
154 char prev_status
, diff_status
; /* used for TIOCMIWAIT */
155 /* we pass a pointer to this as the arguement sent to
156 cypress_set_termios old_termios */
157 struct ktermios tmp_termios
; /* stores the old termios settings */
160 /* write buffer structure */
162 unsigned int buf_size
;
168 /* function prototypes for the Cypress USB to serial device */
169 static int cypress_earthmate_startup(struct usb_serial
*serial
);
170 static int cypress_hidcom_startup(struct usb_serial
*serial
);
171 static int cypress_ca42v2_startup(struct usb_serial
*serial
);
172 static void cypress_release(struct usb_serial
*serial
);
173 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
174 static void cypress_close(struct usb_serial_port
*port
);
175 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
);
176 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
177 const unsigned char *buf
, int count
);
178 static void cypress_send(struct usb_serial_port
*port
);
179 static int cypress_write_room(struct tty_struct
*tty
);
180 static int cypress_ioctl(struct tty_struct
*tty
, struct file
*file
,
181 unsigned int cmd
, unsigned long arg
);
182 static void cypress_set_termios(struct tty_struct
*tty
,
183 struct usb_serial_port
*port
, struct ktermios
*old
);
184 static int cypress_tiocmget(struct tty_struct
*tty
, struct file
*file
);
185 static int cypress_tiocmset(struct tty_struct
*tty
, struct file
*file
,
186 unsigned int set
, unsigned int clear
);
187 static int cypress_chars_in_buffer(struct tty_struct
*tty
);
188 static void cypress_throttle(struct tty_struct
*tty
);
189 static void cypress_unthrottle(struct tty_struct
*tty
);
190 static void cypress_set_dead(struct usb_serial_port
*port
);
191 static void cypress_read_int_callback(struct urb
*urb
);
192 static void cypress_write_int_callback(struct urb
*urb
);
193 /* write buffer functions */
194 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
);
195 static void cypress_buf_free(struct cypress_buf
*cb
);
196 static void cypress_buf_clear(struct cypress_buf
*cb
);
197 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
);
198 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
);
199 static unsigned int cypress_buf_put(struct cypress_buf
*cb
,
200 const char *buf
, unsigned int count
);
201 static unsigned int cypress_buf_get(struct cypress_buf
*cb
,
202 char *buf
, unsigned int count
);
205 static struct usb_serial_driver cypress_earthmate_device
= {
207 .owner
= THIS_MODULE
,
210 .description
= "DeLorme Earthmate USB",
211 .usb_driver
= &cypress_driver
,
212 .id_table
= id_table_earthmate
,
214 .attach
= cypress_earthmate_startup
,
215 .release
= cypress_release
,
216 .open
= cypress_open
,
217 .close
= cypress_close
,
218 .dtr_rts
= cypress_dtr_rts
,
219 .write
= cypress_write
,
220 .write_room
= cypress_write_room
,
221 .ioctl
= cypress_ioctl
,
222 .set_termios
= cypress_set_termios
,
223 .tiocmget
= cypress_tiocmget
,
224 .tiocmset
= cypress_tiocmset
,
225 .chars_in_buffer
= cypress_chars_in_buffer
,
226 .throttle
= cypress_throttle
,
227 .unthrottle
= cypress_unthrottle
,
228 .read_int_callback
= cypress_read_int_callback
,
229 .write_int_callback
= cypress_write_int_callback
,
232 static struct usb_serial_driver cypress_hidcom_device
= {
234 .owner
= THIS_MODULE
,
237 .description
= "HID->COM RS232 Adapter",
238 .usb_driver
= &cypress_driver
,
239 .id_table
= id_table_cyphidcomrs232
,
241 .attach
= cypress_hidcom_startup
,
242 .release
= cypress_release
,
243 .open
= cypress_open
,
244 .close
= cypress_close
,
245 .dtr_rts
= cypress_dtr_rts
,
246 .write
= cypress_write
,
247 .write_room
= cypress_write_room
,
248 .ioctl
= cypress_ioctl
,
249 .set_termios
= cypress_set_termios
,
250 .tiocmget
= cypress_tiocmget
,
251 .tiocmset
= cypress_tiocmset
,
252 .chars_in_buffer
= cypress_chars_in_buffer
,
253 .throttle
= cypress_throttle
,
254 .unthrottle
= cypress_unthrottle
,
255 .read_int_callback
= cypress_read_int_callback
,
256 .write_int_callback
= cypress_write_int_callback
,
259 static struct usb_serial_driver cypress_ca42v2_device
= {
261 .owner
= THIS_MODULE
,
262 .name
= "nokiaca42v2",
264 .description
= "Nokia CA-42 V2 Adapter",
265 .usb_driver
= &cypress_driver
,
266 .id_table
= id_table_nokiaca42v2
,
268 .attach
= cypress_ca42v2_startup
,
269 .release
= cypress_release
,
270 .open
= cypress_open
,
271 .close
= cypress_close
,
272 .dtr_rts
= cypress_dtr_rts
,
273 .write
= cypress_write
,
274 .write_room
= cypress_write_room
,
275 .ioctl
= cypress_ioctl
,
276 .set_termios
= cypress_set_termios
,
277 .tiocmget
= cypress_tiocmget
,
278 .tiocmset
= cypress_tiocmset
,
279 .chars_in_buffer
= cypress_chars_in_buffer
,
280 .throttle
= cypress_throttle
,
281 .unthrottle
= cypress_unthrottle
,
282 .read_int_callback
= cypress_read_int_callback
,
283 .write_int_callback
= cypress_write_int_callback
,
286 /*****************************************************************************
287 * Cypress serial helper functions
288 *****************************************************************************/
291 static int analyze_baud_rate(struct usb_serial_port
*port
, speed_t new_rate
)
293 struct cypress_private
*priv
;
294 priv
= usb_get_serial_port_data(port
);
300 * The general purpose firmware for the Cypress M8 allows for
301 * a maximum speed of 57600bps (I have no idea whether DeLorme
302 * chose to use the general purpose firmware or not), if you
303 * need to modify this speed setting for your own project
304 * please add your own chiptype and modify the code likewise.
305 * The Cypress HID->COM device will work successfully up to
306 * 115200bps (but the actual throughput is around 3kBps).
308 if (port
->serial
->dev
->speed
== USB_SPEED_LOW
) {
310 * Mike Isely <isely@pobox.com> 2-Feb-2008: The
311 * Cypress app note that describes this mechanism
312 * states the the low-speed part can't handle more
313 * than 800 bytes/sec, in which case 4800 baud is the
314 * safest speed for a part like that.
316 if (new_rate
> 4800) {
317 dbg("%s - failed setting baud rate, device incapable "
318 "speed %d", __func__
, new_rate
);
322 switch (priv
->chiptype
) {
324 if (new_rate
<= 600) {
325 /* 300 and 600 baud rates are supported under
326 * the generic firmware, but are not used with
327 * NMEA and SiRF protocols */
328 dbg("%s - failed setting baud rate, unsupported speed "
329 "of %d on Earthmate GPS", __func__
, new_rate
);
340 /* This function can either set or retrieve the current serial line settings */
341 static int cypress_serial_control(struct tty_struct
*tty
,
342 struct usb_serial_port
*port
, speed_t baud_rate
, int data_bits
,
343 int stop_bits
, int parity_enable
, int parity_type
, int reset
,
344 int cypress_request_type
)
346 int new_baudrate
= 0, retval
= 0, tries
= 0;
347 struct cypress_private
*priv
;
349 const unsigned int feature_len
= 5;
354 priv
= usb_get_serial_port_data(port
);
356 if (!priv
->comm_is_ok
)
359 feature_buffer
= kcalloc(feature_len
, sizeof(u8
), GFP_KERNEL
);
363 switch (cypress_request_type
) {
364 case CYPRESS_SET_CONFIG
:
365 /* 0 means 'Hang up' so doesn't change the true bit rate */
366 new_baudrate
= priv
->baud_rate
;
367 if (baud_rate
&& baud_rate
!= priv
->baud_rate
) {
368 dbg("%s - baud rate is changing", __func__
);
369 retval
= analyze_baud_rate(port
, baud_rate
);
371 new_baudrate
= retval
;
372 dbg("%s - New baud rate set to %d",
373 __func__
, new_baudrate
);
376 dbg("%s - baud rate is being sent as %d",
377 __func__
, new_baudrate
);
379 /* fill the feature_buffer with new configuration */
380 put_unaligned_le32(new_baudrate
, feature_buffer
);
381 feature_buffer
[4] |= data_bits
; /* assign data bits in 2 bit space ( max 3 ) */
383 feature_buffer
[4] |= (stop_bits
<< 3); /* assign stop bits in 1 bit space */
384 feature_buffer
[4] |= (parity_enable
<< 4); /* assign parity flag in 1 bit space */
385 feature_buffer
[4] |= (parity_type
<< 5); /* assign parity type in 1 bit space */
387 feature_buffer
[4] |= (reset
<< 7); /* assign reset at end of byte, 1 bit space */
389 dbg("%s - device is being sent this feature report:",
391 dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__
,
392 feature_buffer
[0], feature_buffer
[1],
393 feature_buffer
[2], feature_buffer
[3],
397 retval
= usb_control_msg(port
->serial
->dev
,
398 usb_sndctrlpipe(port
->serial
->dev
, 0),
400 USB_DIR_OUT
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
401 0x0300, 0, feature_buffer
,
407 } while (retval
!= feature_len
&&
410 if (retval
!= feature_len
) {
411 dev_err(&port
->dev
, "%s - failed sending serial "
412 "line settings - %d\n", __func__
, retval
);
413 cypress_set_dead(port
);
415 spin_lock_irqsave(&priv
->lock
, flags
);
416 priv
->baud_rate
= new_baudrate
;
417 priv
->current_config
= feature_buffer
[4];
418 spin_unlock_irqrestore(&priv
->lock
, flags
);
419 /* If we asked for a speed change encode it */
421 tty_encode_baud_rate(tty
,
422 new_baudrate
, new_baudrate
);
425 case CYPRESS_GET_CONFIG
:
426 if (priv
->get_cfg_unsafe
) {
427 /* Not implemented for this device,
428 and if we try to do it we're likely
429 to crash the hardware. */
433 dbg("%s - retreiving serial line settings", __func__
);
435 retval
= usb_control_msg(port
->serial
->dev
,
436 usb_rcvctrlpipe(port
->serial
->dev
, 0),
438 USB_DIR_IN
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
439 0x0300, 0, feature_buffer
,
444 } while (retval
!= feature_len
445 && retval
!= -ENODEV
);
447 if (retval
!= feature_len
) {
448 dev_err(&port
->dev
, "%s - failed to retrieve serial "
449 "line settings - %d\n", __func__
, retval
);
450 cypress_set_dead(port
);
453 spin_lock_irqsave(&priv
->lock
, flags
);
454 /* store the config in one byte, and later
455 use bit masks to check values */
456 priv
->current_config
= feature_buffer
[4];
457 priv
->baud_rate
= get_unaligned_le32(feature_buffer
);
458 spin_unlock_irqrestore(&priv
->lock
, flags
);
461 spin_lock_irqsave(&priv
->lock
, flags
);
463 spin_unlock_irqrestore(&priv
->lock
, flags
);
465 kfree(feature_buffer
);
467 } /* cypress_serial_control */
470 static void cypress_set_dead(struct usb_serial_port
*port
)
472 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
475 spin_lock_irqsave(&priv
->lock
, flags
);
476 if (!priv
->comm_is_ok
) {
477 spin_unlock_irqrestore(&priv
->lock
, flags
);
480 priv
->comm_is_ok
= 0;
481 spin_unlock_irqrestore(&priv
->lock
, flags
);
483 dev_err(&port
->dev
, "cypress_m8 suspending failing port %d - "
484 "interval might be too short\n", port
->number
);
488 /*****************************************************************************
489 * Cypress serial driver functions
490 *****************************************************************************/
493 static int generic_startup(struct usb_serial
*serial
)
495 struct cypress_private
*priv
;
496 struct usb_serial_port
*port
= serial
->port
[0];
498 dbg("%s - port %d", __func__
, port
->number
);
500 priv
= kzalloc(sizeof(struct cypress_private
), GFP_KERNEL
);
504 priv
->comm_is_ok
= !0;
505 spin_lock_init(&priv
->lock
);
506 priv
->buf
= cypress_buf_alloc(CYPRESS_BUF_SIZE
);
507 if (priv
->buf
== NULL
) {
511 init_waitqueue_head(&priv
->delta_msr_wait
);
513 usb_reset_configuration(serial
->dev
);
516 priv
->line_control
= 0;
517 priv
->termios_initialized
= 0;
519 /* Default packet format setting is determined by packet size.
520 Anything with a size larger then 9 must have a separate
521 count field since the 3 bit count field is otherwise too
522 small. Otherwise we can use the slightly more compact
523 format. This is in accordance with the cypress_m8 serial
524 converter app note. */
525 if (port
->interrupt_out_size
> 9)
526 priv
->pkt_fmt
= packet_format_1
;
528 priv
->pkt_fmt
= packet_format_2
;
531 priv
->write_urb_interval
= interval
;
532 priv
->read_urb_interval
= interval
;
533 dbg("%s - port %d read & write intervals forced to %d",
534 __func__
, port
->number
, interval
);
536 priv
->write_urb_interval
= port
->interrupt_out_urb
->interval
;
537 priv
->read_urb_interval
= port
->interrupt_in_urb
->interval
;
538 dbg("%s - port %d intervals: read=%d write=%d",
539 __func__
, port
->number
,
540 priv
->read_urb_interval
, priv
->write_urb_interval
);
542 usb_set_serial_port_data(port
, priv
);
548 static int cypress_earthmate_startup(struct usb_serial
*serial
)
550 struct cypress_private
*priv
;
551 struct usb_serial_port
*port
= serial
->port
[0];
555 if (generic_startup(serial
)) {
556 dbg("%s - Failed setting up port %d", __func__
,
561 priv
= usb_get_serial_port_data(port
);
562 priv
->chiptype
= CT_EARTHMATE
;
563 /* All Earthmate devices use the separated-count packet
565 priv
->pkt_fmt
= packet_format_1
;
566 if (serial
->dev
->descriptor
.idProduct
!=
567 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB
)) {
568 /* The old original USB Earthmate seemed able to
569 handle GET_CONFIG requests; everything they've
570 produced since that time crashes if this command is
572 dbg("%s - Marking this device as unsafe for GET_CONFIG "
573 "commands", __func__
);
574 priv
->get_cfg_unsafe
= !0;
578 } /* cypress_earthmate_startup */
581 static int cypress_hidcom_startup(struct usb_serial
*serial
)
583 struct cypress_private
*priv
;
587 if (generic_startup(serial
)) {
588 dbg("%s - Failed setting up port %d", __func__
,
589 serial
->port
[0]->number
);
593 priv
= usb_get_serial_port_data(serial
->port
[0]);
594 priv
->chiptype
= CT_CYPHIDCOM
;
597 } /* cypress_hidcom_startup */
600 static int cypress_ca42v2_startup(struct usb_serial
*serial
)
602 struct cypress_private
*priv
;
606 if (generic_startup(serial
)) {
607 dbg("%s - Failed setting up port %d", __func__
,
608 serial
->port
[0]->number
);
612 priv
= usb_get_serial_port_data(serial
->port
[0]);
613 priv
->chiptype
= CT_CA42V2
;
616 } /* cypress_ca42v2_startup */
619 static void cypress_release(struct usb_serial
*serial
)
621 struct cypress_private
*priv
;
623 dbg("%s - port %d", __func__
, serial
->port
[0]->number
);
625 /* all open ports are closed at this point */
627 priv
= usb_get_serial_port_data(serial
->port
[0]);
630 cypress_buf_free(priv
->buf
);
636 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
638 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
639 struct usb_serial
*serial
= port
->serial
;
643 dbg("%s - port %d", __func__
, port
->number
);
645 if (!priv
->comm_is_ok
)
648 /* clear halts before open */
649 usb_clear_halt(serial
->dev
, 0x81);
650 usb_clear_halt(serial
->dev
, 0x02);
652 spin_lock_irqsave(&priv
->lock
, flags
);
653 /* reset read/write statistics */
658 spin_unlock_irqrestore(&priv
->lock
, flags
);
664 cypress_set_termios(tty
, port
, &priv
->tmp_termios
);
666 /* setup the port and start reading from the device */
667 if (!port
->interrupt_in_urb
) {
668 dev_err(&port
->dev
, "%s - interrupt_in_urb is empty!\n",
673 usb_fill_int_urb(port
->interrupt_in_urb
, serial
->dev
,
674 usb_rcvintpipe(serial
->dev
, port
->interrupt_in_endpointAddress
),
675 port
->interrupt_in_urb
->transfer_buffer
,
676 port
->interrupt_in_urb
->transfer_buffer_length
,
677 cypress_read_int_callback
, port
, priv
->read_urb_interval
);
678 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
682 "%s - failed submitting read urb, error %d\n",
684 cypress_set_dead(port
);
686 port
->port
.drain_delay
= 256;
690 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
)
692 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
693 /* drop dtr and rts */
694 priv
= usb_get_serial_port_data(port
);
695 spin_lock_irq(&priv
->lock
);
697 priv
->line_control
= 0;
699 priv
->line_control
= CONTROL_DTR
| CONTROL_RTS
;
701 spin_unlock_irq(&priv
->lock
);
702 cypress_write(NULL
, port
, NULL
, 0);
705 static void cypress_close(struct usb_serial_port
*port
)
707 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
709 dbg("%s - port %d", __func__
, port
->number
);
711 /* writing is potentially harmful, lock must be taken */
712 mutex_lock(&port
->serial
->disc_mutex
);
713 if (port
->serial
->disconnected
) {
714 mutex_unlock(&port
->serial
->disc_mutex
);
717 cypress_buf_clear(priv
->buf
);
718 dbg("%s - stopping urbs", __func__
);
719 usb_kill_urb(port
->interrupt_in_urb
);
720 usb_kill_urb(port
->interrupt_out_urb
);
724 dev_info(&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
725 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
726 mutex_unlock(&port
->serial
->disc_mutex
);
727 } /* cypress_close */
730 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
731 const unsigned char *buf
, int count
)
733 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
736 dbg("%s - port %d, %d bytes", __func__
, port
->number
, count
);
738 /* line control commands, which need to be executed immediately,
739 are not put into the buffer for obvious reasons.
741 if (priv
->cmd_ctrl
) {
749 spin_lock_irqsave(&priv
->lock
, flags
);
750 count
= cypress_buf_put(priv
->buf
, buf
, count
);
751 spin_unlock_irqrestore(&priv
->lock
, flags
);
757 } /* cypress_write */
760 static void cypress_send(struct usb_serial_port
*port
)
762 int count
= 0, result
, offset
, actual_size
;
763 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
766 if (!priv
->comm_is_ok
)
769 dbg("%s - port %d", __func__
, port
->number
);
770 dbg("%s - interrupt out size is %d", __func__
,
771 port
->interrupt_out_size
);
773 spin_lock_irqsave(&priv
->lock
, flags
);
774 if (priv
->write_urb_in_use
) {
775 dbg("%s - can't write, urb in use", __func__
);
776 spin_unlock_irqrestore(&priv
->lock
, flags
);
779 spin_unlock_irqrestore(&priv
->lock
, flags
);
782 memset(port
->interrupt_out_urb
->transfer_buffer
, 0,
783 port
->interrupt_out_size
);
785 spin_lock_irqsave(&priv
->lock
, flags
);
786 switch (priv
->pkt_fmt
) {
788 case packet_format_1
:
789 /* this is for the CY7C64013... */
791 port
->interrupt_out_buffer
[0] = priv
->line_control
;
793 case packet_format_2
:
794 /* this is for the CY7C63743... */
796 port
->interrupt_out_buffer
[0] = priv
->line_control
;
800 if (priv
->line_control
& CONTROL_RESET
)
801 priv
->line_control
&= ~CONTROL_RESET
;
803 if (priv
->cmd_ctrl
) {
805 dbg("%s - line control command being issued", __func__
);
806 spin_unlock_irqrestore(&priv
->lock
, flags
);
809 spin_unlock_irqrestore(&priv
->lock
, flags
);
811 count
= cypress_buf_get(priv
->buf
, &port
->interrupt_out_buffer
[offset
],
812 port
->interrupt_out_size
-offset
);
817 switch (priv
->pkt_fmt
) {
819 case packet_format_1
:
820 port
->interrupt_out_buffer
[1] = count
;
822 case packet_format_2
:
823 port
->interrupt_out_buffer
[0] |= count
;
826 dbg("%s - count is %d", __func__
, count
);
829 spin_lock_irqsave(&priv
->lock
, flags
);
830 priv
->write_urb_in_use
= 1;
831 spin_unlock_irqrestore(&priv
->lock
, flags
);
836 actual_size
= count
+
837 (priv
->pkt_fmt
== packet_format_1
? 2 : 1);
839 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
840 port
->interrupt_out_size
,
841 port
->interrupt_out_urb
->transfer_buffer
);
843 usb_fill_int_urb(port
->interrupt_out_urb
, port
->serial
->dev
,
844 usb_sndintpipe(port
->serial
->dev
, port
->interrupt_out_endpointAddress
),
845 port
->interrupt_out_buffer
, port
->interrupt_out_size
,
846 cypress_write_int_callback
, port
, priv
->write_urb_interval
);
847 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
850 "%s - failed submitting write urb, error %d\n",
852 priv
->write_urb_in_use
= 0;
853 cypress_set_dead(port
);
856 spin_lock_irqsave(&priv
->lock
, flags
);
860 /* do not count the line control and size bytes */
861 priv
->bytes_out
+= count
;
862 spin_unlock_irqrestore(&priv
->lock
, flags
);
864 usb_serial_port_softint(port
);
868 /* returns how much space is available in the soft buffer */
869 static int cypress_write_room(struct tty_struct
*tty
)
871 struct usb_serial_port
*port
= tty
->driver_data
;
872 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
876 dbg("%s - port %d", __func__
, port
->number
);
878 spin_lock_irqsave(&priv
->lock
, flags
);
879 room
= cypress_buf_space_avail(priv
->buf
);
880 spin_unlock_irqrestore(&priv
->lock
, flags
);
882 dbg("%s - returns %d", __func__
, room
);
887 static int cypress_tiocmget(struct tty_struct
*tty
, struct file
*file
)
889 struct usb_serial_port
*port
= tty
->driver_data
;
890 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
891 __u8 status
, control
;
892 unsigned int result
= 0;
895 dbg("%s - port %d", __func__
, port
->number
);
897 spin_lock_irqsave(&priv
->lock
, flags
);
898 control
= priv
->line_control
;
899 status
= priv
->current_status
;
900 spin_unlock_irqrestore(&priv
->lock
, flags
);
902 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
903 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
904 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
905 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
906 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
907 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
909 dbg("%s - result = %x", __func__
, result
);
915 static int cypress_tiocmset(struct tty_struct
*tty
, struct file
*file
,
916 unsigned int set
, unsigned int clear
)
918 struct usb_serial_port
*port
= tty
->driver_data
;
919 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
922 dbg("%s - port %d", __func__
, port
->number
);
924 spin_lock_irqsave(&priv
->lock
, flags
);
926 priv
->line_control
|= CONTROL_RTS
;
928 priv
->line_control
|= CONTROL_DTR
;
929 if (clear
& TIOCM_RTS
)
930 priv
->line_control
&= ~CONTROL_RTS
;
931 if (clear
& TIOCM_DTR
)
932 priv
->line_control
&= ~CONTROL_DTR
;
934 spin_unlock_irqrestore(&priv
->lock
, flags
);
936 return cypress_write(tty
, port
, NULL
, 0);
940 static int cypress_ioctl(struct tty_struct
*tty
, struct file
*file
,
941 unsigned int cmd
, unsigned long arg
)
943 struct usb_serial_port
*port
= tty
->driver_data
;
944 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
946 dbg("%s - port %d, cmd 0x%.4x", __func__
, port
->number
, cmd
);
949 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
951 while (priv
!= NULL
) {
952 interruptible_sleep_on(&priv
->delta_msr_wait
);
953 /* see if a signal did it */
954 if (signal_pending(current
))
957 char diff
= priv
->diff_status
;
959 return -EIO
; /* no change => error */
961 /* consume all events */
962 priv
->diff_status
= 0;
964 /* return 0 if caller wanted to know about
966 if (((arg
& TIOCM_RNG
) && (diff
& UART_RI
)) ||
967 ((arg
& TIOCM_DSR
) && (diff
& UART_DSR
)) ||
968 ((arg
& TIOCM_CD
) && (diff
& UART_CD
)) ||
969 ((arg
& TIOCM_CTS
) && (diff
& UART_CTS
)))
971 /* otherwise caller can't care less about what
972 * happened, and so we continue to wait for
981 dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__
, cmd
);
983 } /* cypress_ioctl */
986 static void cypress_set_termios(struct tty_struct
*tty
,
987 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
989 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
990 int data_bits
, stop_bits
, parity_type
, parity_enable
;
991 unsigned cflag
, iflag
;
996 dbg("%s - port %d", __func__
, port
->number
);
998 spin_lock_irqsave(&priv
->lock
, flags
);
999 /* We can't clean this one up as we don't know the device type
1001 if (!priv
->termios_initialized
) {
1002 if (priv
->chiptype
== CT_EARTHMATE
) {
1003 *(tty
->termios
) = tty_std_termios
;
1004 tty
->termios
->c_cflag
= B4800
| CS8
| CREAD
| HUPCL
|
1006 tty
->termios
->c_ispeed
= 4800;
1007 tty
->termios
->c_ospeed
= 4800;
1008 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
1009 *(tty
->termios
) = tty_std_termios
;
1010 tty
->termios
->c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
1012 tty
->termios
->c_ispeed
= 9600;
1013 tty
->termios
->c_ospeed
= 9600;
1014 } else if (priv
->chiptype
== CT_CA42V2
) {
1015 *(tty
->termios
) = tty_std_termios
;
1016 tty
->termios
->c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
1018 tty
->termios
->c_ispeed
= 9600;
1019 tty
->termios
->c_ospeed
= 9600;
1021 priv
->termios_initialized
= 1;
1023 spin_unlock_irqrestore(&priv
->lock
, flags
);
1025 /* Unsupported features need clearing */
1026 tty
->termios
->c_cflag
&= ~(CMSPAR
|CRTSCTS
);
1028 cflag
= tty
->termios
->c_cflag
;
1029 iflag
= tty
->termios
->c_iflag
;
1031 /* check if there are new settings */
1033 spin_lock_irqsave(&priv
->lock
, flags
);
1034 priv
->tmp_termios
= *(tty
->termios
);
1035 spin_unlock_irqrestore(&priv
->lock
, flags
);
1038 /* set number of data bits, parity, stop bits */
1039 /* when parity is disabled the parity type bit is ignored */
1041 /* 1 means 2 stop bits, 0 means 1 stop bit */
1042 stop_bits
= cflag
& CSTOPB
? 1 : 0;
1044 if (cflag
& PARENB
) {
1046 /* 1 means odd parity, 0 means even parity */
1047 parity_type
= cflag
& PARODD
? 1 : 0;
1049 parity_enable
= parity_type
= 0;
1051 switch (cflag
& CSIZE
) {
1065 dev_err(&port
->dev
, "%s - CSIZE was set, but not CS5-CS8\n",
1069 spin_lock_irqsave(&priv
->lock
, flags
);
1070 oldlines
= priv
->line_control
;
1071 if ((cflag
& CBAUD
) == B0
) {
1072 /* drop dtr and rts */
1073 dbg("%s - dropping the lines, baud rate 0bps", __func__
);
1074 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
1076 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
1077 spin_unlock_irqrestore(&priv
->lock
, flags
);
1079 dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
1080 "%d data_bits (+5)", __func__
, stop_bits
,
1081 parity_enable
, parity_type
, data_bits
);
1083 cypress_serial_control(tty
, port
, tty_get_baud_rate(tty
),
1084 data_bits
, stop_bits
,
1085 parity_enable
, parity_type
,
1086 0, CYPRESS_SET_CONFIG
);
1088 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1089 * filled into the private structure this should confirm that all is
1090 * working if it returns what we just set */
1091 cypress_serial_control(tty
, port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
1093 /* Here we can define custom tty settings for devices; the main tty
1094 * termios flag base comes from empeg.c */
1096 spin_lock_irqsave(&priv
->lock
, flags
);
1097 if (priv
->chiptype
== CT_EARTHMATE
&& priv
->baud_rate
== 4800) {
1098 dbg("Using custom termios settings for a baud rate of "
1100 /* define custom termios settings for NMEA protocol */
1102 tty
->termios
->c_iflag
/* input modes - */
1103 &= ~(IGNBRK
/* disable ignore break */
1104 | BRKINT
/* disable break causes interrupt */
1105 | PARMRK
/* disable mark parity errors */
1106 | ISTRIP
/* disable clear high bit of input char */
1107 | INLCR
/* disable translate NL to CR */
1108 | IGNCR
/* disable ignore CR */
1109 | ICRNL
/* disable translate CR to NL */
1110 | IXON
); /* disable enable XON/XOFF flow control */
1112 tty
->termios
->c_oflag
/* output modes */
1113 &= ~OPOST
; /* disable postprocess output char */
1115 tty
->termios
->c_lflag
/* line discipline modes */
1116 &= ~(ECHO
/* disable echo input characters */
1117 | ECHONL
/* disable echo new line */
1118 | ICANON
/* disable erase, kill, werase, and rprnt
1119 special characters */
1120 | ISIG
/* disable interrupt, quit, and suspend
1121 special characters */
1122 | IEXTEN
); /* disable non-POSIX special characters */
1123 } /* CT_CYPHIDCOM: Application should handle this for device */
1125 linechange
= (priv
->line_control
!= oldlines
);
1126 spin_unlock_irqrestore(&priv
->lock
, flags
);
1128 /* if necessary, set lines */
1131 cypress_write(tty
, port
, NULL
, 0);
1133 } /* cypress_set_termios */
1136 /* returns amount of data still left in soft buffer */
1137 static int cypress_chars_in_buffer(struct tty_struct
*tty
)
1139 struct usb_serial_port
*port
= tty
->driver_data
;
1140 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1142 unsigned long flags
;
1144 dbg("%s - port %d", __func__
, port
->number
);
1146 spin_lock_irqsave(&priv
->lock
, flags
);
1147 chars
= cypress_buf_data_avail(priv
->buf
);
1148 spin_unlock_irqrestore(&priv
->lock
, flags
);
1150 dbg("%s - returns %d", __func__
, chars
);
1155 static void cypress_throttle(struct tty_struct
*tty
)
1157 struct usb_serial_port
*port
= tty
->driver_data
;
1158 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1160 dbg("%s - port %d", __func__
, port
->number
);
1162 spin_lock_irq(&priv
->lock
);
1163 priv
->rx_flags
= THROTTLED
;
1164 spin_unlock_irq(&priv
->lock
);
1168 static void cypress_unthrottle(struct tty_struct
*tty
)
1170 struct usb_serial_port
*port
= tty
->driver_data
;
1171 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1172 int actually_throttled
, result
;
1174 dbg("%s - port %d", __func__
, port
->number
);
1176 spin_lock_irq(&priv
->lock
);
1177 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1179 spin_unlock_irq(&priv
->lock
);
1181 if (!priv
->comm_is_ok
)
1184 if (actually_throttled
) {
1185 port
->interrupt_in_urb
->dev
= port
->serial
->dev
;
1187 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
1189 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1190 "error %d\n", __func__
, result
);
1191 cypress_set_dead(port
);
1197 static void cypress_read_int_callback(struct urb
*urb
)
1199 struct usb_serial_port
*port
= urb
->context
;
1200 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1201 struct tty_struct
*tty
;
1202 unsigned char *data
= urb
->transfer_buffer
;
1203 unsigned long flags
;
1204 char tty_flag
= TTY_NORMAL
;
1209 int status
= urb
->status
;
1211 dbg("%s - port %d", __func__
, port
->number
);
1214 case 0: /* success */
1219 /* precursor to disconnect so just go away */
1222 /* Can't call usb_clear_halt while in_interrupt */
1225 /* something ugly is going on... */
1226 dev_err(&urb
->dev
->dev
,
1227 "%s - unexpected nonzero read status received: %d\n",
1229 cypress_set_dead(port
);
1233 spin_lock_irqsave(&priv
->lock
, flags
);
1234 if (priv
->rx_flags
& THROTTLED
) {
1235 dbg("%s - now throttling", __func__
);
1236 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1237 spin_unlock_irqrestore(&priv
->lock
, flags
);
1240 spin_unlock_irqrestore(&priv
->lock
, flags
);
1242 tty
= tty_port_tty_get(&port
->port
);
1244 dbg("%s - bad tty pointer - exiting", __func__
);
1248 spin_lock_irqsave(&priv
->lock
, flags
);
1249 result
= urb
->actual_length
;
1250 switch (priv
->pkt_fmt
) {
1252 case packet_format_1
:
1253 /* This is for the CY7C64013... */
1254 priv
->current_status
= data
[0] & 0xF8;
1255 bytes
= data
[1] + 2;
1260 case packet_format_2
:
1261 /* This is for the CY7C63743... */
1262 priv
->current_status
= data
[0] & 0xF8;
1263 bytes
= (data
[0] & 0x07) + 1;
1269 spin_unlock_irqrestore(&priv
->lock
, flags
);
1270 if (result
< bytes
) {
1271 dbg("%s - wrong packet size - received %d bytes but packet "
1272 "said %d bytes", __func__
, result
, bytes
);
1276 usb_serial_debug_data(debug
, &port
->dev
, __func__
,
1277 urb
->actual_length
, data
);
1279 spin_lock_irqsave(&priv
->lock
, flags
);
1280 /* check to see if status has changed */
1281 if (priv
->current_status
!= priv
->prev_status
) {
1282 priv
->diff_status
|= priv
->current_status
^
1284 wake_up_interruptible(&priv
->delta_msr_wait
);
1285 priv
->prev_status
= priv
->current_status
;
1287 spin_unlock_irqrestore(&priv
->lock
, flags
);
1289 /* hangup, as defined in acm.c... this might be a bad place for it
1291 if (tty
&& !(tty
->termios
->c_cflag
& CLOCAL
) &&
1292 !(priv
->current_status
& UART_CD
)) {
1293 dbg("%s - calling hangup", __func__
);
1298 /* There is one error bit... I'm assuming it is a parity error
1299 * indicator as the generic firmware will set this bit to 1 if a
1300 * parity error occurs.
1301 * I can not find reference to any other error events. */
1302 spin_lock_irqsave(&priv
->lock
, flags
);
1303 if (priv
->current_status
& CYP_ERROR
) {
1304 spin_unlock_irqrestore(&priv
->lock
, flags
);
1305 tty_flag
= TTY_PARITY
;
1306 dbg("%s - Parity Error detected", __func__
);
1308 spin_unlock_irqrestore(&priv
->lock
, flags
);
1310 /* process read if there is data other than line status */
1311 if (tty
&& (bytes
> i
)) {
1312 bytes
= tty_buffer_request_room(tty
, bytes
);
1313 for (; i
< bytes
; ++i
) {
1314 dbg("pushing byte number %d - %d - %c", i
, data
[i
],
1316 tty_insert_flip_char(tty
, data
[i
], tty_flag
);
1318 tty_flip_buffer_push(tty
);
1321 spin_lock_irqsave(&priv
->lock
, flags
);
1322 /* control and status byte(s) are also counted */
1323 priv
->bytes_in
+= bytes
;
1324 spin_unlock_irqrestore(&priv
->lock
, flags
);
1329 /* Continue trying to always read... unless the port has closed. */
1331 if (port
->port
.count
> 0 && priv
->comm_is_ok
) {
1332 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1333 usb_rcvintpipe(port
->serial
->dev
,
1334 port
->interrupt_in_endpointAddress
),
1335 port
->interrupt_in_urb
->transfer_buffer
,
1336 port
->interrupt_in_urb
->transfer_buffer_length
,
1337 cypress_read_int_callback
, port
,
1338 priv
->read_urb_interval
);
1339 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1341 dev_err(&urb
->dev
->dev
, "%s - failed resubmitting "
1342 "read urb, error %d\n", __func__
,
1344 cypress_set_dead(port
);
1349 } /* cypress_read_int_callback */
1352 static void cypress_write_int_callback(struct urb
*urb
)
1354 struct usb_serial_port
*port
= urb
->context
;
1355 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1357 int status
= urb
->status
;
1359 dbg("%s - port %d", __func__
, port
->number
);
1368 /* this urb is terminated, clean up */
1369 dbg("%s - urb shutting down with status: %d",
1371 priv
->write_urb_in_use
= 0;
1373 case -EPIPE
: /* no break needed; clear halt and resubmit */
1374 if (!priv
->comm_is_ok
)
1376 usb_clear_halt(port
->serial
->dev
, 0x02);
1377 /* error in the urb, so we have to resubmit it */
1378 dbg("%s - nonzero write bulk status received: %d",
1380 port
->interrupt_out_urb
->transfer_buffer_length
= 1;
1381 port
->interrupt_out_urb
->dev
= port
->serial
->dev
;
1382 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
1385 dev_err(&urb
->dev
->dev
,
1386 "%s - failed resubmitting write urb, error %d\n",
1388 cypress_set_dead(port
);
1391 dev_err(&urb
->dev
->dev
,
1392 "%s - unexpected nonzero write status received: %d\n",
1394 cypress_set_dead(port
);
1397 priv
->write_urb_in_use
= 0;
1399 /* send any buffered data */
1404 /*****************************************************************************
1405 * Write buffer functions - buffering code from pl2303 used
1406 *****************************************************************************/
1411 * Allocate a circular buffer and all associated memory.
1414 static struct cypress_buf
*cypress_buf_alloc(unsigned int size
)
1417 struct cypress_buf
*cb
;
1423 cb
= kmalloc(sizeof(struct cypress_buf
), GFP_KERNEL
);
1427 cb
->buf_buf
= kmalloc(size
, GFP_KERNEL
);
1428 if (cb
->buf_buf
== NULL
) {
1433 cb
->buf_size
= size
;
1434 cb
->buf_get
= cb
->buf_put
= cb
->buf_buf
;
1444 * Free the buffer and all associated memory.
1447 static void cypress_buf_free(struct cypress_buf
*cb
)
1459 * Clear out all data in the circular buffer.
1462 static void cypress_buf_clear(struct cypress_buf
*cb
)
1465 cb
->buf_get
= cb
->buf_put
;
1466 /* equivalent to a get of all data available */
1471 * cypress_buf_data_avail
1473 * Return the number of bytes of data available in the circular
1477 static unsigned int cypress_buf_data_avail(struct cypress_buf
*cb
)
1480 return (cb
->buf_size
+ cb
->buf_put
- cb
->buf_get
)
1488 * cypress_buf_space_avail
1490 * Return the number of bytes of space available in the circular
1494 static unsigned int cypress_buf_space_avail(struct cypress_buf
*cb
)
1497 return (cb
->buf_size
+ cb
->buf_get
- cb
->buf_put
- 1)
1507 * Copy data data from a user buffer and put it into the circular buffer.
1508 * Restrict to the amount of space available.
1510 * Return the number of bytes copied.
1513 static unsigned int cypress_buf_put(struct cypress_buf
*cb
, const char *buf
,
1523 len
= cypress_buf_space_avail(cb
);
1530 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_put
;
1532 memcpy(cb
->buf_put
, buf
, len
);
1533 memcpy(cb
->buf_buf
, buf
+len
, count
- len
);
1534 cb
->buf_put
= cb
->buf_buf
+ count
- len
;
1536 memcpy(cb
->buf_put
, buf
, count
);
1538 cb
->buf_put
+= count
;
1539 else /* count == len */
1540 cb
->buf_put
= cb
->buf_buf
;
1551 * Get data from the circular buffer and copy to the given buffer.
1552 * Restrict to the amount of data available.
1554 * Return the number of bytes copied.
1557 static unsigned int cypress_buf_get(struct cypress_buf
*cb
, char *buf
,
1567 len
= cypress_buf_data_avail(cb
);
1574 len
= cb
->buf_buf
+ cb
->buf_size
- cb
->buf_get
;
1576 memcpy(buf
, cb
->buf_get
, len
);
1577 memcpy(buf
+len
, cb
->buf_buf
, count
- len
);
1578 cb
->buf_get
= cb
->buf_buf
+ count
- len
;
1580 memcpy(buf
, cb
->buf_get
, count
);
1582 cb
->buf_get
+= count
;
1583 else /* count == len */
1584 cb
->buf_get
= cb
->buf_buf
;
1591 /*****************************************************************************
1593 *****************************************************************************/
1595 static int __init
cypress_init(void)
1599 dbg("%s", __func__
);
1601 retval
= usb_serial_register(&cypress_earthmate_device
);
1603 goto failed_em_register
;
1604 retval
= usb_serial_register(&cypress_hidcom_device
);
1606 goto failed_hidcom_register
;
1607 retval
= usb_serial_register(&cypress_ca42v2_device
);
1609 goto failed_ca42v2_register
;
1610 retval
= usb_register(&cypress_driver
);
1612 goto failed_usb_register
;
1614 printk(KERN_INFO KBUILD_MODNAME
": " DRIVER_VERSION
":"
1618 failed_usb_register
:
1619 usb_serial_deregister(&cypress_ca42v2_device
);
1620 failed_ca42v2_register
:
1621 usb_serial_deregister(&cypress_hidcom_device
);
1622 failed_hidcom_register
:
1623 usb_serial_deregister(&cypress_earthmate_device
);
1629 static void __exit
cypress_exit(void)
1631 dbg("%s", __func__
);
1633 usb_deregister(&cypress_driver
);
1634 usb_serial_deregister(&cypress_earthmate_device
);
1635 usb_serial_deregister(&cypress_hidcom_device
);
1636 usb_serial_deregister(&cypress_ca42v2_device
);
1640 module_init(cypress_init
);
1641 module_exit(cypress_exit
);
1643 MODULE_AUTHOR(DRIVER_AUTHOR
);
1644 MODULE_DESCRIPTION(DRIVER_DESC
);
1645 MODULE_VERSION(DRIVER_VERSION
);
1646 MODULE_LICENSE("GPL");
1648 module_param(debug
, bool, S_IRUGO
| S_IWUSR
);
1649 MODULE_PARM_DESC(debug
, "Debug enabled or not");
1650 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1651 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1652 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1653 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");
1654 module_param(unstable_bauds
, bool, S_IRUGO
| S_IWUSR
);
1655 MODULE_PARM_DESC(unstable_bauds
, "Allow unstable baud rates");