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.
21 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation
23 /* Thanks to cypress for providing references for the hid reports. */
24 /* Thanks to Jiang Zhang for providing links and for general help. */
25 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others.*/
28 #include <linux/kernel.h>
29 #include <linux/errno.h>
30 #include <linux/init.h>
31 #include <linux/slab.h>
32 #include <linux/tty.h>
33 #include <linux/tty_driver.h>
34 #include <linux/tty_flip.h>
35 #include <linux/module.h>
36 #include <linux/moduleparam.h>
37 #include <linux/spinlock.h>
38 #include <linux/usb.h>
39 #include <linux/usb/serial.h>
40 #include <linux/serial.h>
41 #include <linux/kfifo.h>
42 #include <linux/delay.h>
43 #include <linux/uaccess.h>
44 #include <asm/unaligned.h>
46 #include "cypress_m8.h"
51 static bool unstable_bauds
;
56 #define DRIVER_VERSION "v1.10"
57 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>"
58 #define DRIVER_DESC "Cypress USB to Serial Driver"
60 /* write buffer size defines */
61 #define CYPRESS_BUF_SIZE 1024
63 static const struct usb_device_id id_table_earthmate
[] = {
64 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
65 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
66 { } /* Terminating entry */
69 static const struct usb_device_id id_table_cyphidcomrs232
[] = {
70 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
71 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
72 { } /* Terminating entry */
75 static const struct usb_device_id id_table_nokiaca42v2
[] = {
76 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
77 { } /* Terminating entry */
80 static const struct usb_device_id id_table_combined
[] = {
81 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
82 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
83 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
84 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
85 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
86 { } /* Terminating entry */
89 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
92 packet_format_1
, /* b0:status, b1:payload count */
93 packet_format_2
/* b0[7:3]:status, b0[2:0]:payload count */
96 struct cypress_private
{
97 spinlock_t lock
; /* private lock */
98 int chiptype
; /* identifier of device, for quirks/etc */
99 int bytes_in
; /* used for statistics */
100 int bytes_out
; /* used for statistics */
101 int cmd_count
; /* used for statistics */
102 int cmd_ctrl
; /* always set this to 1 before issuing a command */
103 struct kfifo write_fifo
; /* write fifo */
104 int write_urb_in_use
; /* write urb in use indicator */
105 int write_urb_interval
; /* interval to use for write urb */
106 int read_urb_interval
; /* interval to use for read urb */
107 int comm_is_ok
; /* true if communication is (still) ok */
108 int termios_initialized
;
109 __u8 line_control
; /* holds dtr / rts value */
110 __u8 current_status
; /* received from last read - info on dsr,cts,cd,ri,etc */
111 __u8 current_config
; /* stores the current configuration byte */
112 __u8 rx_flags
; /* throttling - used from whiteheat/ftdi_sio */
113 enum packet_format pkt_fmt
; /* format to use for packet send / receive */
114 int get_cfg_unsafe
; /* If true, the CYPRESS_GET_CONFIG is unsafe */
115 int baud_rate
; /* stores current baud rate in
117 int isthrottled
; /* if throttled, discard reads */
118 wait_queue_head_t delta_msr_wait
; /* used for TIOCMIWAIT */
119 char prev_status
, diff_status
; /* used for TIOCMIWAIT */
120 /* we pass a pointer to this as the argument sent to
121 cypress_set_termios old_termios */
122 struct ktermios tmp_termios
; /* stores the old termios settings */
125 /* function prototypes for the Cypress USB to serial device */
126 static int cypress_earthmate_startup(struct usb_serial
*serial
);
127 static int cypress_hidcom_startup(struct usb_serial
*serial
);
128 static int cypress_ca42v2_startup(struct usb_serial
*serial
);
129 static void cypress_release(struct usb_serial
*serial
);
130 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
131 static void cypress_close(struct usb_serial_port
*port
);
132 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
);
133 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
134 const unsigned char *buf
, int count
);
135 static void cypress_send(struct usb_serial_port
*port
);
136 static int cypress_write_room(struct tty_struct
*tty
);
137 static int cypress_ioctl(struct tty_struct
*tty
,
138 unsigned int cmd
, unsigned long arg
);
139 static void cypress_set_termios(struct tty_struct
*tty
,
140 struct usb_serial_port
*port
, struct ktermios
*old
);
141 static int cypress_tiocmget(struct tty_struct
*tty
);
142 static int cypress_tiocmset(struct tty_struct
*tty
,
143 unsigned int set
, unsigned int clear
);
144 static int cypress_chars_in_buffer(struct tty_struct
*tty
);
145 static void cypress_throttle(struct tty_struct
*tty
);
146 static void cypress_unthrottle(struct tty_struct
*tty
);
147 static void cypress_set_dead(struct usb_serial_port
*port
);
148 static void cypress_read_int_callback(struct urb
*urb
);
149 static void cypress_write_int_callback(struct urb
*urb
);
151 static struct usb_serial_driver cypress_earthmate_device
= {
153 .owner
= THIS_MODULE
,
156 .description
= "DeLorme Earthmate USB",
157 .id_table
= id_table_earthmate
,
159 .attach
= cypress_earthmate_startup
,
160 .release
= cypress_release
,
161 .open
= cypress_open
,
162 .close
= cypress_close
,
163 .dtr_rts
= cypress_dtr_rts
,
164 .write
= cypress_write
,
165 .write_room
= cypress_write_room
,
166 .ioctl
= cypress_ioctl
,
167 .set_termios
= cypress_set_termios
,
168 .tiocmget
= cypress_tiocmget
,
169 .tiocmset
= cypress_tiocmset
,
170 .chars_in_buffer
= cypress_chars_in_buffer
,
171 .throttle
= cypress_throttle
,
172 .unthrottle
= cypress_unthrottle
,
173 .read_int_callback
= cypress_read_int_callback
,
174 .write_int_callback
= cypress_write_int_callback
,
177 static struct usb_serial_driver cypress_hidcom_device
= {
179 .owner
= THIS_MODULE
,
182 .description
= "HID->COM RS232 Adapter",
183 .id_table
= id_table_cyphidcomrs232
,
185 .attach
= cypress_hidcom_startup
,
186 .release
= cypress_release
,
187 .open
= cypress_open
,
188 .close
= cypress_close
,
189 .dtr_rts
= cypress_dtr_rts
,
190 .write
= cypress_write
,
191 .write_room
= cypress_write_room
,
192 .ioctl
= cypress_ioctl
,
193 .set_termios
= cypress_set_termios
,
194 .tiocmget
= cypress_tiocmget
,
195 .tiocmset
= cypress_tiocmset
,
196 .chars_in_buffer
= cypress_chars_in_buffer
,
197 .throttle
= cypress_throttle
,
198 .unthrottle
= cypress_unthrottle
,
199 .read_int_callback
= cypress_read_int_callback
,
200 .write_int_callback
= cypress_write_int_callback
,
203 static struct usb_serial_driver cypress_ca42v2_device
= {
205 .owner
= THIS_MODULE
,
206 .name
= "nokiaca42v2",
208 .description
= "Nokia CA-42 V2 Adapter",
209 .id_table
= id_table_nokiaca42v2
,
211 .attach
= cypress_ca42v2_startup
,
212 .release
= cypress_release
,
213 .open
= cypress_open
,
214 .close
= cypress_close
,
215 .dtr_rts
= cypress_dtr_rts
,
216 .write
= cypress_write
,
217 .write_room
= cypress_write_room
,
218 .ioctl
= cypress_ioctl
,
219 .set_termios
= cypress_set_termios
,
220 .tiocmget
= cypress_tiocmget
,
221 .tiocmset
= cypress_tiocmset
,
222 .chars_in_buffer
= cypress_chars_in_buffer
,
223 .throttle
= cypress_throttle
,
224 .unthrottle
= cypress_unthrottle
,
225 .read_int_callback
= cypress_read_int_callback
,
226 .write_int_callback
= cypress_write_int_callback
,
229 static struct usb_serial_driver
* const serial_drivers
[] = {
230 &cypress_earthmate_device
, &cypress_hidcom_device
,
231 &cypress_ca42v2_device
, NULL
234 /*****************************************************************************
235 * Cypress serial helper functions
236 *****************************************************************************/
239 static int analyze_baud_rate(struct usb_serial_port
*port
, speed_t new_rate
)
241 struct cypress_private
*priv
;
242 priv
= usb_get_serial_port_data(port
);
248 * The general purpose firmware for the Cypress M8 allows for
249 * a maximum speed of 57600bps (I have no idea whether DeLorme
250 * chose to use the general purpose firmware or not), if you
251 * need to modify this speed setting for your own project
252 * please add your own chiptype and modify the code likewise.
253 * The Cypress HID->COM device will work successfully up to
254 * 115200bps (but the actual throughput is around 3kBps).
256 if (port
->serial
->dev
->speed
== USB_SPEED_LOW
) {
258 * Mike Isely <isely@pobox.com> 2-Feb-2008: The
259 * Cypress app note that describes this mechanism
260 * states the the low-speed part can't handle more
261 * than 800 bytes/sec, in which case 4800 baud is the
262 * safest speed for a part like that.
264 if (new_rate
> 4800) {
266 "%s - failed setting baud rate, device incapable speed %d\n",
271 switch (priv
->chiptype
) {
273 if (new_rate
<= 600) {
274 /* 300 and 600 baud rates are supported under
275 * the generic firmware, but are not used with
276 * NMEA and SiRF protocols */
278 "%s - failed setting baud rate, unsupported speed of %d on Earthmate GPS",
290 /* This function can either set or retrieve the current serial line settings */
291 static int cypress_serial_control(struct tty_struct
*tty
,
292 struct usb_serial_port
*port
, speed_t baud_rate
, int data_bits
,
293 int stop_bits
, int parity_enable
, int parity_type
, int reset
,
294 int cypress_request_type
)
296 int new_baudrate
= 0, retval
= 0, tries
= 0;
297 struct cypress_private
*priv
;
298 struct device
*dev
= &port
->dev
;
300 const unsigned int feature_len
= 5;
303 priv
= usb_get_serial_port_data(port
);
305 if (!priv
->comm_is_ok
)
308 feature_buffer
= kcalloc(feature_len
, sizeof(u8
), GFP_KERNEL
);
312 switch (cypress_request_type
) {
313 case CYPRESS_SET_CONFIG
:
314 /* 0 means 'Hang up' so doesn't change the true bit rate */
315 new_baudrate
= priv
->baud_rate
;
316 if (baud_rate
&& baud_rate
!= priv
->baud_rate
) {
317 dev_dbg(dev
, "%s - baud rate is changing\n", __func__
);
318 retval
= analyze_baud_rate(port
, baud_rate
);
320 new_baudrate
= retval
;
321 dev_dbg(dev
, "%s - New baud rate set to %d\n",
322 __func__
, new_baudrate
);
325 dev_dbg(dev
, "%s - baud rate is being sent as %d\n", __func__
,
328 /* fill the feature_buffer with new configuration */
329 put_unaligned_le32(new_baudrate
, feature_buffer
);
330 feature_buffer
[4] |= data_bits
; /* assign data bits in 2 bit space ( max 3 ) */
332 feature_buffer
[4] |= (stop_bits
<< 3); /* assign stop bits in 1 bit space */
333 feature_buffer
[4] |= (parity_enable
<< 4); /* assign parity flag in 1 bit space */
334 feature_buffer
[4] |= (parity_type
<< 5); /* assign parity type in 1 bit space */
336 feature_buffer
[4] |= (reset
<< 7); /* assign reset at end of byte, 1 bit space */
338 dev_dbg(dev
, "%s - device is being sent this feature report:\n", __func__
);
339 dev_dbg(dev
, "%s - %02X - %02X - %02X - %02X - %02X\n", __func__
,
340 feature_buffer
[0], feature_buffer
[1],
341 feature_buffer
[2], feature_buffer
[3],
345 retval
= usb_control_msg(port
->serial
->dev
,
346 usb_sndctrlpipe(port
->serial
->dev
, 0),
348 USB_DIR_OUT
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
349 0x0300, 0, feature_buffer
,
355 } while (retval
!= feature_len
&&
358 if (retval
!= feature_len
) {
359 dev_err(dev
, "%s - failed sending serial line settings - %d\n",
361 cypress_set_dead(port
);
363 spin_lock_irqsave(&priv
->lock
, flags
);
364 priv
->baud_rate
= new_baudrate
;
365 priv
->current_config
= feature_buffer
[4];
366 spin_unlock_irqrestore(&priv
->lock
, flags
);
367 /* If we asked for a speed change encode it */
369 tty_encode_baud_rate(tty
,
370 new_baudrate
, new_baudrate
);
373 case CYPRESS_GET_CONFIG
:
374 if (priv
->get_cfg_unsafe
) {
375 /* Not implemented for this device,
376 and if we try to do it we're likely
377 to crash the hardware. */
381 dev_dbg(dev
, "%s - retreiving serial line settings\n", __func__
);
383 retval
= usb_control_msg(port
->serial
->dev
,
384 usb_rcvctrlpipe(port
->serial
->dev
, 0),
386 USB_DIR_IN
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
387 0x0300, 0, feature_buffer
,
392 } while (retval
!= feature_len
393 && retval
!= -ENODEV
);
395 if (retval
!= feature_len
) {
396 dev_err(dev
, "%s - failed to retrieve serial line settings - %d\n",
398 cypress_set_dead(port
);
401 spin_lock_irqsave(&priv
->lock
, flags
);
402 /* store the config in one byte, and later
403 use bit masks to check values */
404 priv
->current_config
= feature_buffer
[4];
405 priv
->baud_rate
= get_unaligned_le32(feature_buffer
);
406 spin_unlock_irqrestore(&priv
->lock
, flags
);
409 spin_lock_irqsave(&priv
->lock
, flags
);
411 spin_unlock_irqrestore(&priv
->lock
, flags
);
413 kfree(feature_buffer
);
415 } /* cypress_serial_control */
418 static void cypress_set_dead(struct usb_serial_port
*port
)
420 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
423 spin_lock_irqsave(&priv
->lock
, flags
);
424 if (!priv
->comm_is_ok
) {
425 spin_unlock_irqrestore(&priv
->lock
, flags
);
428 priv
->comm_is_ok
= 0;
429 spin_unlock_irqrestore(&priv
->lock
, flags
);
431 dev_err(&port
->dev
, "cypress_m8 suspending failing port %d - "
432 "interval might be too short\n", port
->number
);
436 /*****************************************************************************
437 * Cypress serial driver functions
438 *****************************************************************************/
441 static int generic_startup(struct usb_serial
*serial
)
443 struct cypress_private
*priv
;
444 struct usb_serial_port
*port
= serial
->port
[0];
446 priv
= kzalloc(sizeof(struct cypress_private
), GFP_KERNEL
);
450 priv
->comm_is_ok
= !0;
451 spin_lock_init(&priv
->lock
);
452 if (kfifo_alloc(&priv
->write_fifo
, CYPRESS_BUF_SIZE
, GFP_KERNEL
)) {
456 init_waitqueue_head(&priv
->delta_msr_wait
);
458 usb_reset_configuration(serial
->dev
);
461 priv
->line_control
= 0;
462 priv
->termios_initialized
= 0;
464 /* Default packet format setting is determined by packet size.
465 Anything with a size larger then 9 must have a separate
466 count field since the 3 bit count field is otherwise too
467 small. Otherwise we can use the slightly more compact
468 format. This is in accordance with the cypress_m8 serial
469 converter app note. */
470 if (port
->interrupt_out_size
> 9)
471 priv
->pkt_fmt
= packet_format_1
;
473 priv
->pkt_fmt
= packet_format_2
;
476 priv
->write_urb_interval
= interval
;
477 priv
->read_urb_interval
= interval
;
478 dev_dbg(&port
->dev
, "%s - read & write intervals forced to %d\n",
481 priv
->write_urb_interval
= port
->interrupt_out_urb
->interval
;
482 priv
->read_urb_interval
= port
->interrupt_in_urb
->interval
;
483 dev_dbg(&port
->dev
, "%s - intervals: read=%d write=%d\n",
484 __func__
, priv
->read_urb_interval
,
485 priv
->write_urb_interval
);
487 usb_set_serial_port_data(port
, priv
);
493 static int cypress_earthmate_startup(struct usb_serial
*serial
)
495 struct cypress_private
*priv
;
496 struct usb_serial_port
*port
= serial
->port
[0];
498 if (generic_startup(serial
)) {
499 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
503 priv
= usb_get_serial_port_data(port
);
504 priv
->chiptype
= CT_EARTHMATE
;
505 /* All Earthmate devices use the separated-count packet
507 priv
->pkt_fmt
= packet_format_1
;
508 if (serial
->dev
->descriptor
.idProduct
!=
509 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB
)) {
510 /* The old original USB Earthmate seemed able to
511 handle GET_CONFIG requests; everything they've
512 produced since that time crashes if this command is
515 "%s - Marking this device as unsafe for GET_CONFIG commands\n",
517 priv
->get_cfg_unsafe
= !0;
521 } /* cypress_earthmate_startup */
524 static int cypress_hidcom_startup(struct usb_serial
*serial
)
526 struct cypress_private
*priv
;
527 struct usb_serial_port
*port
= serial
->port
[0];
529 if (generic_startup(serial
)) {
530 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
534 priv
= usb_get_serial_port_data(port
);
535 priv
->chiptype
= CT_CYPHIDCOM
;
538 } /* cypress_hidcom_startup */
541 static int cypress_ca42v2_startup(struct usb_serial
*serial
)
543 struct cypress_private
*priv
;
544 struct usb_serial_port
*port
= serial
->port
[0];
546 if (generic_startup(serial
)) {
547 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
551 priv
= usb_get_serial_port_data(port
);
552 priv
->chiptype
= CT_CA42V2
;
555 } /* cypress_ca42v2_startup */
558 static void cypress_release(struct usb_serial
*serial
)
560 struct cypress_private
*priv
;
562 /* all open ports are closed at this point */
563 priv
= usb_get_serial_port_data(serial
->port
[0]);
566 kfifo_free(&priv
->write_fifo
);
572 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
574 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
575 struct usb_serial
*serial
= port
->serial
;
579 if (!priv
->comm_is_ok
)
582 /* clear halts before open */
583 usb_clear_halt(serial
->dev
, 0x81);
584 usb_clear_halt(serial
->dev
, 0x02);
586 spin_lock_irqsave(&priv
->lock
, flags
);
587 /* reset read/write statistics */
592 spin_unlock_irqrestore(&priv
->lock
, flags
);
598 cypress_set_termios(tty
, port
, &priv
->tmp_termios
);
600 /* setup the port and start reading from the device */
601 if (!port
->interrupt_in_urb
) {
602 dev_err(&port
->dev
, "%s - interrupt_in_urb is empty!\n",
607 usb_fill_int_urb(port
->interrupt_in_urb
, serial
->dev
,
608 usb_rcvintpipe(serial
->dev
, port
->interrupt_in_endpointAddress
),
609 port
->interrupt_in_urb
->transfer_buffer
,
610 port
->interrupt_in_urb
->transfer_buffer_length
,
611 cypress_read_int_callback
, port
, priv
->read_urb_interval
);
612 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
616 "%s - failed submitting read urb, error %d\n",
618 cypress_set_dead(port
);
620 port
->port
.drain_delay
= 256;
624 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
)
626 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
627 /* drop dtr and rts */
628 spin_lock_irq(&priv
->lock
);
630 priv
->line_control
= 0;
632 priv
->line_control
= CONTROL_DTR
| CONTROL_RTS
;
634 spin_unlock_irq(&priv
->lock
);
635 cypress_write(NULL
, port
, NULL
, 0);
638 static void cypress_close(struct usb_serial_port
*port
)
640 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
643 /* writing is potentially harmful, lock must be taken */
644 mutex_lock(&port
->serial
->disc_mutex
);
645 if (port
->serial
->disconnected
) {
646 mutex_unlock(&port
->serial
->disc_mutex
);
649 spin_lock_irqsave(&priv
->lock
, flags
);
650 kfifo_reset_out(&priv
->write_fifo
);
651 spin_unlock_irqrestore(&priv
->lock
, flags
);
653 dev_dbg(&port
->dev
, "%s - stopping urbs\n", __func__
);
654 usb_kill_urb(port
->interrupt_in_urb
);
655 usb_kill_urb(port
->interrupt_out_urb
);
658 dev_info(&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
659 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
660 mutex_unlock(&port
->serial
->disc_mutex
);
661 } /* cypress_close */
664 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
665 const unsigned char *buf
, int count
)
667 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
669 dev_dbg(&port
->dev
, "%s - port %d, %d bytes\n", __func__
, port
->number
, count
);
671 /* line control commands, which need to be executed immediately,
672 are not put into the buffer for obvious reasons.
674 if (priv
->cmd_ctrl
) {
682 count
= kfifo_in_locked(&priv
->write_fifo
, buf
, count
, &priv
->lock
);
688 } /* cypress_write */
691 static void cypress_send(struct usb_serial_port
*port
)
693 int count
= 0, result
, offset
, actual_size
;
694 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
695 struct device
*dev
= &port
->dev
;
698 if (!priv
->comm_is_ok
)
701 dev_dbg(dev
, "%s - interrupt out size is %d\n", __func__
,
702 port
->interrupt_out_size
);
704 spin_lock_irqsave(&priv
->lock
, flags
);
705 if (priv
->write_urb_in_use
) {
706 dev_dbg(dev
, "%s - can't write, urb in use\n", __func__
);
707 spin_unlock_irqrestore(&priv
->lock
, flags
);
710 spin_unlock_irqrestore(&priv
->lock
, flags
);
713 memset(port
->interrupt_out_urb
->transfer_buffer
, 0,
714 port
->interrupt_out_size
);
716 spin_lock_irqsave(&priv
->lock
, flags
);
717 switch (priv
->pkt_fmt
) {
719 case packet_format_1
:
720 /* this is for the CY7C64013... */
722 port
->interrupt_out_buffer
[0] = priv
->line_control
;
724 case packet_format_2
:
725 /* this is for the CY7C63743... */
727 port
->interrupt_out_buffer
[0] = priv
->line_control
;
731 if (priv
->line_control
& CONTROL_RESET
)
732 priv
->line_control
&= ~CONTROL_RESET
;
734 if (priv
->cmd_ctrl
) {
736 dev_dbg(dev
, "%s - line control command being issued\n", __func__
);
737 spin_unlock_irqrestore(&priv
->lock
, flags
);
740 spin_unlock_irqrestore(&priv
->lock
, flags
);
742 count
= kfifo_out_locked(&priv
->write_fifo
,
743 &port
->interrupt_out_buffer
[offset
],
744 port
->interrupt_out_size
- offset
,
749 switch (priv
->pkt_fmt
) {
751 case packet_format_1
:
752 port
->interrupt_out_buffer
[1] = count
;
754 case packet_format_2
:
755 port
->interrupt_out_buffer
[0] |= count
;
758 dev_dbg(dev
, "%s - count is %d\n", __func__
, count
);
761 spin_lock_irqsave(&priv
->lock
, flags
);
762 priv
->write_urb_in_use
= 1;
763 spin_unlock_irqrestore(&priv
->lock
, flags
);
768 actual_size
= count
+
769 (priv
->pkt_fmt
== packet_format_1
? 2 : 1);
771 usb_serial_debug_data(dev
, __func__
, port
->interrupt_out_size
,
772 port
->interrupt_out_urb
->transfer_buffer
);
774 usb_fill_int_urb(port
->interrupt_out_urb
, port
->serial
->dev
,
775 usb_sndintpipe(port
->serial
->dev
, port
->interrupt_out_endpointAddress
),
776 port
->interrupt_out_buffer
, port
->interrupt_out_size
,
777 cypress_write_int_callback
, port
, priv
->write_urb_interval
);
778 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
780 dev_err_console(port
,
781 "%s - failed submitting write urb, error %d\n",
783 priv
->write_urb_in_use
= 0;
784 cypress_set_dead(port
);
787 spin_lock_irqsave(&priv
->lock
, flags
);
791 /* do not count the line control and size bytes */
792 priv
->bytes_out
+= count
;
793 spin_unlock_irqrestore(&priv
->lock
, flags
);
795 usb_serial_port_softint(port
);
799 /* returns how much space is available in the soft buffer */
800 static int cypress_write_room(struct tty_struct
*tty
)
802 struct usb_serial_port
*port
= tty
->driver_data
;
803 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
807 spin_lock_irqsave(&priv
->lock
, flags
);
808 room
= kfifo_avail(&priv
->write_fifo
);
809 spin_unlock_irqrestore(&priv
->lock
, flags
);
811 dev_dbg(&port
->dev
, "%s - returns %d\n", __func__
, room
);
816 static int cypress_tiocmget(struct tty_struct
*tty
)
818 struct usb_serial_port
*port
= tty
->driver_data
;
819 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
820 __u8 status
, control
;
821 unsigned int result
= 0;
824 spin_lock_irqsave(&priv
->lock
, flags
);
825 control
= priv
->line_control
;
826 status
= priv
->current_status
;
827 spin_unlock_irqrestore(&priv
->lock
, flags
);
829 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
830 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
831 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
832 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
833 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
834 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
836 dev_dbg(&port
->dev
, "%s - result = %x\n", __func__
, result
);
842 static int cypress_tiocmset(struct tty_struct
*tty
,
843 unsigned int set
, unsigned int clear
)
845 struct usb_serial_port
*port
= tty
->driver_data
;
846 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
849 spin_lock_irqsave(&priv
->lock
, flags
);
851 priv
->line_control
|= CONTROL_RTS
;
853 priv
->line_control
|= CONTROL_DTR
;
854 if (clear
& TIOCM_RTS
)
855 priv
->line_control
&= ~CONTROL_RTS
;
856 if (clear
& TIOCM_DTR
)
857 priv
->line_control
&= ~CONTROL_DTR
;
859 spin_unlock_irqrestore(&priv
->lock
, flags
);
861 return cypress_write(tty
, port
, NULL
, 0);
865 static int cypress_ioctl(struct tty_struct
*tty
,
866 unsigned int cmd
, unsigned long arg
)
868 struct usb_serial_port
*port
= tty
->driver_data
;
869 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
871 dev_dbg(&port
->dev
, "%s - port %d, cmd 0x%.4x\n", __func__
, port
->number
, cmd
);
874 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
876 while (priv
!= NULL
) {
877 interruptible_sleep_on(&priv
->delta_msr_wait
);
878 /* see if a signal did it */
879 if (signal_pending(current
))
882 char diff
= priv
->diff_status
;
884 return -EIO
; /* no change => error */
886 /* consume all events */
887 priv
->diff_status
= 0;
889 /* return 0 if caller wanted to know about
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
)))
896 /* otherwise caller can't care less about what
897 * happened, and so we continue to wait for
906 dev_dbg(&port
->dev
, "%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h\n", __func__
, cmd
);
908 } /* cypress_ioctl */
911 static void cypress_set_termios(struct tty_struct
*tty
,
912 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
914 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
915 struct device
*dev
= &port
->dev
;
916 int data_bits
, stop_bits
, parity_type
, parity_enable
;
917 unsigned cflag
, iflag
;
922 spin_lock_irqsave(&priv
->lock
, flags
);
923 /* We can't clean this one up as we don't know the device type
925 if (!priv
->termios_initialized
) {
926 if (priv
->chiptype
== CT_EARTHMATE
) {
927 tty
->termios
= tty_std_termios
;
928 tty
->termios
.c_cflag
= B4800
| CS8
| CREAD
| HUPCL
|
930 tty
->termios
.c_ispeed
= 4800;
931 tty
->termios
.c_ospeed
= 4800;
932 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
933 tty
->termios
= tty_std_termios
;
934 tty
->termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
936 tty
->termios
.c_ispeed
= 9600;
937 tty
->termios
.c_ospeed
= 9600;
938 } else if (priv
->chiptype
== CT_CA42V2
) {
939 tty
->termios
= tty_std_termios
;
940 tty
->termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
942 tty
->termios
.c_ispeed
= 9600;
943 tty
->termios
.c_ospeed
= 9600;
945 priv
->termios_initialized
= 1;
947 spin_unlock_irqrestore(&priv
->lock
, flags
);
949 /* Unsupported features need clearing */
950 tty
->termios
.c_cflag
&= ~(CMSPAR
|CRTSCTS
);
952 cflag
= tty
->termios
.c_cflag
;
953 iflag
= tty
->termios
.c_iflag
;
955 /* check if there are new settings */
957 spin_lock_irqsave(&priv
->lock
, flags
);
958 priv
->tmp_termios
= tty
->termios
;
959 spin_unlock_irqrestore(&priv
->lock
, flags
);
962 /* set number of data bits, parity, stop bits */
963 /* when parity is disabled the parity type bit is ignored */
965 /* 1 means 2 stop bits, 0 means 1 stop bit */
966 stop_bits
= cflag
& CSTOPB
? 1 : 0;
968 if (cflag
& PARENB
) {
970 /* 1 means odd parity, 0 means even parity */
971 parity_type
= cflag
& PARODD
? 1 : 0;
973 parity_enable
= parity_type
= 0;
975 switch (cflag
& CSIZE
) {
989 dev_err(dev
, "%s - CSIZE was set, but not CS5-CS8\n", __func__
);
992 spin_lock_irqsave(&priv
->lock
, flags
);
993 oldlines
= priv
->line_control
;
994 if ((cflag
& CBAUD
) == B0
) {
995 /* drop dtr and rts */
996 dev_dbg(dev
, "%s - dropping the lines, baud rate 0bps\n", __func__
);
997 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
999 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
1000 spin_unlock_irqrestore(&priv
->lock
, flags
);
1002 dev_dbg(dev
, "%s - sending %d stop_bits, %d parity_enable, %d parity_type, %d data_bits (+5)\n",
1003 __func__
, stop_bits
, parity_enable
, parity_type
, data_bits
);
1005 cypress_serial_control(tty
, port
, tty_get_baud_rate(tty
),
1006 data_bits
, stop_bits
,
1007 parity_enable
, parity_type
,
1008 0, CYPRESS_SET_CONFIG
);
1010 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1011 * filled into the private structure this should confirm that all is
1012 * working if it returns what we just set */
1013 cypress_serial_control(tty
, port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
1015 /* Here we can define custom tty settings for devices; the main tty
1016 * termios flag base comes from empeg.c */
1018 spin_lock_irqsave(&priv
->lock
, flags
);
1019 if (priv
->chiptype
== CT_EARTHMATE
&& priv
->baud_rate
== 4800) {
1020 dev_dbg(dev
, "Using custom termios settings for a baud rate of 4800bps.\n");
1021 /* define custom termios settings for NMEA protocol */
1023 tty
->termios
.c_iflag
/* input modes - */
1024 &= ~(IGNBRK
/* disable ignore break */
1025 | BRKINT
/* disable break causes interrupt */
1026 | PARMRK
/* disable mark parity errors */
1027 | ISTRIP
/* disable clear high bit of input char */
1028 | INLCR
/* disable translate NL to CR */
1029 | IGNCR
/* disable ignore CR */
1030 | ICRNL
/* disable translate CR to NL */
1031 | IXON
); /* disable enable XON/XOFF flow control */
1033 tty
->termios
.c_oflag
/* output modes */
1034 &= ~OPOST
; /* disable postprocess output char */
1036 tty
->termios
.c_lflag
/* line discipline modes */
1037 &= ~(ECHO
/* disable echo input characters */
1038 | ECHONL
/* disable echo new line */
1039 | ICANON
/* disable erase, kill, werase, and rprnt
1040 special characters */
1041 | ISIG
/* disable interrupt, quit, and suspend
1042 special characters */
1043 | IEXTEN
); /* disable non-POSIX special characters */
1044 } /* CT_CYPHIDCOM: Application should handle this for device */
1046 linechange
= (priv
->line_control
!= oldlines
);
1047 spin_unlock_irqrestore(&priv
->lock
, flags
);
1049 /* if necessary, set lines */
1052 cypress_write(tty
, port
, NULL
, 0);
1054 } /* cypress_set_termios */
1057 /* returns amount of data still left in soft buffer */
1058 static int cypress_chars_in_buffer(struct tty_struct
*tty
)
1060 struct usb_serial_port
*port
= tty
->driver_data
;
1061 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1063 unsigned long flags
;
1065 spin_lock_irqsave(&priv
->lock
, flags
);
1066 chars
= kfifo_len(&priv
->write_fifo
);
1067 spin_unlock_irqrestore(&priv
->lock
, flags
);
1069 dev_dbg(&port
->dev
, "%s - returns %d\n", __func__
, chars
);
1074 static void cypress_throttle(struct tty_struct
*tty
)
1076 struct usb_serial_port
*port
= tty
->driver_data
;
1077 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1079 spin_lock_irq(&priv
->lock
);
1080 priv
->rx_flags
= THROTTLED
;
1081 spin_unlock_irq(&priv
->lock
);
1085 static void cypress_unthrottle(struct tty_struct
*tty
)
1087 struct usb_serial_port
*port
= tty
->driver_data
;
1088 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1089 int actually_throttled
, result
;
1091 spin_lock_irq(&priv
->lock
);
1092 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1094 spin_unlock_irq(&priv
->lock
);
1096 if (!priv
->comm_is_ok
)
1099 if (actually_throttled
) {
1100 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
1102 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1103 "error %d\n", __func__
, result
);
1104 cypress_set_dead(port
);
1110 static void cypress_read_int_callback(struct urb
*urb
)
1112 struct usb_serial_port
*port
= urb
->context
;
1113 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1114 struct device
*dev
= &urb
->dev
->dev
;
1115 struct tty_struct
*tty
;
1116 unsigned char *data
= urb
->transfer_buffer
;
1117 unsigned long flags
;
1118 char tty_flag
= TTY_NORMAL
;
1123 int status
= urb
->status
;
1126 case 0: /* success */
1131 /* precursor to disconnect so just go away */
1134 /* Can't call usb_clear_halt while in_interrupt */
1137 /* something ugly is going on... */
1138 dev_err(dev
, "%s - unexpected nonzero read status received: %d\n",
1140 cypress_set_dead(port
);
1144 spin_lock_irqsave(&priv
->lock
, flags
);
1145 if (priv
->rx_flags
& THROTTLED
) {
1146 dev_dbg(dev
, "%s - now throttling\n", __func__
);
1147 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1148 spin_unlock_irqrestore(&priv
->lock
, flags
);
1151 spin_unlock_irqrestore(&priv
->lock
, flags
);
1153 tty
= tty_port_tty_get(&port
->port
);
1155 dev_dbg(dev
, "%s - bad tty pointer - exiting\n", __func__
);
1159 spin_lock_irqsave(&priv
->lock
, flags
);
1160 result
= urb
->actual_length
;
1161 switch (priv
->pkt_fmt
) {
1163 case packet_format_1
:
1164 /* This is for the CY7C64013... */
1165 priv
->current_status
= data
[0] & 0xF8;
1166 bytes
= data
[1] + 2;
1171 case packet_format_2
:
1172 /* This is for the CY7C63743... */
1173 priv
->current_status
= data
[0] & 0xF8;
1174 bytes
= (data
[0] & 0x07) + 1;
1180 spin_unlock_irqrestore(&priv
->lock
, flags
);
1181 if (result
< bytes
) {
1183 "%s - wrong packet size - received %d bytes but packet said %d bytes\n",
1184 __func__
, result
, bytes
);
1188 usb_serial_debug_data(&port
->dev
, __func__
, urb
->actual_length
, data
);
1190 spin_lock_irqsave(&priv
->lock
, flags
);
1191 /* check to see if status has changed */
1192 if (priv
->current_status
!= priv
->prev_status
) {
1193 priv
->diff_status
|= priv
->current_status
^
1195 wake_up_interruptible(&priv
->delta_msr_wait
);
1196 priv
->prev_status
= priv
->current_status
;
1198 spin_unlock_irqrestore(&priv
->lock
, flags
);
1200 /* hangup, as defined in acm.c... this might be a bad place for it
1202 if (tty
&& !(tty
->termios
.c_cflag
& CLOCAL
) &&
1203 !(priv
->current_status
& UART_CD
)) {
1204 dev_dbg(dev
, "%s - calling hangup\n", __func__
);
1209 /* There is one error bit... I'm assuming it is a parity error
1210 * indicator as the generic firmware will set this bit to 1 if a
1211 * parity error occurs.
1212 * I can not find reference to any other error events. */
1213 spin_lock_irqsave(&priv
->lock
, flags
);
1214 if (priv
->current_status
& CYP_ERROR
) {
1215 spin_unlock_irqrestore(&priv
->lock
, flags
);
1216 tty_flag
= TTY_PARITY
;
1217 dev_dbg(dev
, "%s - Parity Error detected\n", __func__
);
1219 spin_unlock_irqrestore(&priv
->lock
, flags
);
1221 /* process read if there is data other than line status */
1222 if (tty
&& bytes
> i
) {
1223 tty_insert_flip_string_fixed_flag(tty
, data
+ i
,
1224 tty_flag
, bytes
- i
);
1225 tty_flip_buffer_push(tty
);
1228 spin_lock_irqsave(&priv
->lock
, flags
);
1229 /* control and status byte(s) are also counted */
1230 priv
->bytes_in
+= bytes
;
1231 spin_unlock_irqrestore(&priv
->lock
, flags
);
1236 /* Continue trying to always read */
1238 if (priv
->comm_is_ok
) {
1239 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1240 usb_rcvintpipe(port
->serial
->dev
,
1241 port
->interrupt_in_endpointAddress
),
1242 port
->interrupt_in_urb
->transfer_buffer
,
1243 port
->interrupt_in_urb
->transfer_buffer_length
,
1244 cypress_read_int_callback
, port
,
1245 priv
->read_urb_interval
);
1246 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1247 if (result
&& result
!= -EPERM
) {
1248 dev_err(dev
, "%s - failed resubmitting read urb, error %d\n",
1250 cypress_set_dead(port
);
1253 } /* cypress_read_int_callback */
1256 static void cypress_write_int_callback(struct urb
*urb
)
1258 struct usb_serial_port
*port
= urb
->context
;
1259 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1260 struct device
*dev
= &urb
->dev
->dev
;
1262 int status
= urb
->status
;
1271 /* this urb is terminated, clean up */
1272 dev_dbg(dev
, "%s - urb shutting down with status: %d\n",
1274 priv
->write_urb_in_use
= 0;
1276 case -EPIPE
: /* no break needed; clear halt and resubmit */
1277 if (!priv
->comm_is_ok
)
1279 usb_clear_halt(port
->serial
->dev
, 0x02);
1280 /* error in the urb, so we have to resubmit it */
1281 dev_dbg(dev
, "%s - nonzero write bulk status received: %d\n",
1283 port
->interrupt_out_urb
->transfer_buffer_length
= 1;
1284 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
1287 dev_err(dev
, "%s - failed resubmitting write urb, error %d\n",
1289 cypress_set_dead(port
);
1292 dev_err(dev
, "%s - unexpected nonzero write status received: %d\n",
1294 cypress_set_dead(port
);
1297 priv
->write_urb_in_use
= 0;
1299 /* send any buffered data */
1303 module_usb_serial_driver(serial_drivers
, id_table_combined
);
1305 MODULE_AUTHOR(DRIVER_AUTHOR
);
1306 MODULE_DESCRIPTION(DRIVER_DESC
);
1307 MODULE_VERSION(DRIVER_VERSION
);
1308 MODULE_LICENSE("GPL");
1310 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1311 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1312 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1313 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");
1314 module_param(unstable_bauds
, bool, S_IRUGO
| S_IWUSR
);
1315 MODULE_PARM_DESC(unstable_bauds
, "Allow unstable baud rates");