1 // SPDX-License-Identifier: GPL-2.0+
3 * USB Cypress M8 driver
6 * Lonnie Mendez (dignome@gmail.com)
7 * Copyright (C) 2003,2004
8 * Neil Whelchel (koyama@firstlight.net)
10 * See Documentation/usb/usb-serial.rst for more information on using this
13 * See http://geocities.com/i0xox0i for information on this driver and the
14 * earthmate usb device.
17 /* Thanks to Neil Whelchel for writing the first cypress m8 implementation
19 /* Thanks to cypress for providing references for the hid reports. */
20 /* Thanks to Jiang Zhang for providing links and for general help. */
21 /* Code originates and was built up from ftdi_sio, belkin, pl2303 and others.*/
24 #include <linux/kernel.h>
25 #include <linux/errno.h>
26 #include <linux/slab.h>
27 #include <linux/tty.h>
28 #include <linux/tty_driver.h>
29 #include <linux/tty_flip.h>
30 #include <linux/module.h>
31 #include <linux/moduleparam.h>
32 #include <linux/spinlock.h>
33 #include <linux/usb.h>
34 #include <linux/usb/serial.h>
35 #include <linux/serial.h>
36 #include <linux/kfifo.h>
37 #include <linux/delay.h>
38 #include <linux/uaccess.h>
39 #include <asm/unaligned.h>
41 #include "cypress_m8.h"
46 static bool unstable_bauds
;
48 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>"
49 #define DRIVER_DESC "Cypress USB to Serial Driver"
51 /* write buffer size defines */
52 #define CYPRESS_BUF_SIZE 1024
54 static const struct usb_device_id id_table_earthmate
[] = {
55 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
56 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
57 { } /* Terminating entry */
60 static const struct usb_device_id id_table_cyphidcomrs232
[] = {
61 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
62 { USB_DEVICE(VENDOR_ID_SAI
, PRODUCT_ID_CYPHIDCOM
) },
63 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
64 { USB_DEVICE(VENDOR_ID_FRWD
, PRODUCT_ID_CYPHIDCOM_FRWD
) },
65 { } /* Terminating entry */
68 static const struct usb_device_id id_table_nokiaca42v2
[] = {
69 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
70 { } /* Terminating entry */
73 static const struct usb_device_id id_table_combined
[] = {
74 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
75 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
76 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
77 { USB_DEVICE(VENDOR_ID_SAI
, PRODUCT_ID_CYPHIDCOM
) },
78 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
79 { USB_DEVICE(VENDOR_ID_FRWD
, PRODUCT_ID_CYPHIDCOM_FRWD
) },
80 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
81 { } /* Terminating entry */
84 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
87 packet_format_1
, /* b0:status, b1:payload count */
88 packet_format_2
/* b0[7:3]:status, b0[2:0]:payload count */
91 struct cypress_private
{
92 spinlock_t lock
; /* private lock */
93 int chiptype
; /* identifier of device, for quirks/etc */
94 int bytes_in
; /* used for statistics */
95 int bytes_out
; /* used for statistics */
96 int cmd_count
; /* used for statistics */
97 int cmd_ctrl
; /* always set this to 1 before issuing a command */
98 struct kfifo write_fifo
; /* write fifo */
99 int write_urb_in_use
; /* write urb in use indicator */
100 int write_urb_interval
; /* interval to use for write urb */
101 int read_urb_interval
; /* interval to use for read urb */
102 int comm_is_ok
; /* true if communication is (still) ok */
103 __u8 line_control
; /* holds dtr / rts value */
104 __u8 current_status
; /* received from last read - info on dsr,cts,cd,ri,etc */
105 __u8 current_config
; /* stores the current configuration byte */
106 __u8 rx_flags
; /* throttling - used from whiteheat/ftdi_sio */
107 enum packet_format pkt_fmt
; /* format to use for packet send / receive */
108 int get_cfg_unsafe
; /* If true, the CYPRESS_GET_CONFIG is unsafe */
109 int baud_rate
; /* stores current baud rate in
111 char prev_status
; /* used for TIOCMIWAIT */
114 /* function prototypes for the Cypress USB to serial device */
115 static int cypress_earthmate_port_probe(struct usb_serial_port
*port
);
116 static int cypress_hidcom_port_probe(struct usb_serial_port
*port
);
117 static int cypress_ca42v2_port_probe(struct usb_serial_port
*port
);
118 static int cypress_port_remove(struct usb_serial_port
*port
);
119 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
120 static void cypress_close(struct usb_serial_port
*port
);
121 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
);
122 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
123 const unsigned char *buf
, int count
);
124 static void cypress_send(struct usb_serial_port
*port
);
125 static int cypress_write_room(struct tty_struct
*tty
);
126 static void cypress_earthmate_init_termios(struct tty_struct
*tty
);
127 static void cypress_set_termios(struct tty_struct
*tty
,
128 struct usb_serial_port
*port
, struct ktermios
*old
);
129 static int cypress_tiocmget(struct tty_struct
*tty
);
130 static int cypress_tiocmset(struct tty_struct
*tty
,
131 unsigned int set
, unsigned int clear
);
132 static int cypress_chars_in_buffer(struct tty_struct
*tty
);
133 static void cypress_throttle(struct tty_struct
*tty
);
134 static void cypress_unthrottle(struct tty_struct
*tty
);
135 static void cypress_set_dead(struct usb_serial_port
*port
);
136 static void cypress_read_int_callback(struct urb
*urb
);
137 static void cypress_write_int_callback(struct urb
*urb
);
139 static struct usb_serial_driver cypress_earthmate_device
= {
141 .owner
= THIS_MODULE
,
144 .description
= "DeLorme Earthmate USB",
145 .id_table
= id_table_earthmate
,
147 .port_probe
= cypress_earthmate_port_probe
,
148 .port_remove
= cypress_port_remove
,
149 .open
= cypress_open
,
150 .close
= cypress_close
,
151 .dtr_rts
= cypress_dtr_rts
,
152 .write
= cypress_write
,
153 .write_room
= cypress_write_room
,
154 .init_termios
= cypress_earthmate_init_termios
,
155 .set_termios
= cypress_set_termios
,
156 .tiocmget
= cypress_tiocmget
,
157 .tiocmset
= cypress_tiocmset
,
158 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
159 .chars_in_buffer
= cypress_chars_in_buffer
,
160 .throttle
= cypress_throttle
,
161 .unthrottle
= cypress_unthrottle
,
162 .read_int_callback
= cypress_read_int_callback
,
163 .write_int_callback
= cypress_write_int_callback
,
166 static struct usb_serial_driver cypress_hidcom_device
= {
168 .owner
= THIS_MODULE
,
171 .description
= "HID->COM RS232 Adapter",
172 .id_table
= id_table_cyphidcomrs232
,
174 .port_probe
= cypress_hidcom_port_probe
,
175 .port_remove
= cypress_port_remove
,
176 .open
= cypress_open
,
177 .close
= cypress_close
,
178 .dtr_rts
= cypress_dtr_rts
,
179 .write
= cypress_write
,
180 .write_room
= cypress_write_room
,
181 .set_termios
= cypress_set_termios
,
182 .tiocmget
= cypress_tiocmget
,
183 .tiocmset
= cypress_tiocmset
,
184 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
185 .chars_in_buffer
= cypress_chars_in_buffer
,
186 .throttle
= cypress_throttle
,
187 .unthrottle
= cypress_unthrottle
,
188 .read_int_callback
= cypress_read_int_callback
,
189 .write_int_callback
= cypress_write_int_callback
,
192 static struct usb_serial_driver cypress_ca42v2_device
= {
194 .owner
= THIS_MODULE
,
195 .name
= "nokiaca42v2",
197 .description
= "Nokia CA-42 V2 Adapter",
198 .id_table
= id_table_nokiaca42v2
,
200 .port_probe
= cypress_ca42v2_port_probe
,
201 .port_remove
= cypress_port_remove
,
202 .open
= cypress_open
,
203 .close
= cypress_close
,
204 .dtr_rts
= cypress_dtr_rts
,
205 .write
= cypress_write
,
206 .write_room
= cypress_write_room
,
207 .set_termios
= cypress_set_termios
,
208 .tiocmget
= cypress_tiocmget
,
209 .tiocmset
= cypress_tiocmset
,
210 .tiocmiwait
= usb_serial_generic_tiocmiwait
,
211 .chars_in_buffer
= cypress_chars_in_buffer
,
212 .throttle
= cypress_throttle
,
213 .unthrottle
= cypress_unthrottle
,
214 .read_int_callback
= cypress_read_int_callback
,
215 .write_int_callback
= cypress_write_int_callback
,
218 static struct usb_serial_driver
* const serial_drivers
[] = {
219 &cypress_earthmate_device
, &cypress_hidcom_device
,
220 &cypress_ca42v2_device
, NULL
223 /*****************************************************************************
224 * Cypress serial helper functions
225 *****************************************************************************/
227 /* FRWD Dongle hidcom needs to skip reset and speed checks */
228 static inline bool is_frwd(struct usb_device
*dev
)
230 return ((le16_to_cpu(dev
->descriptor
.idVendor
) == VENDOR_ID_FRWD
) &&
231 (le16_to_cpu(dev
->descriptor
.idProduct
) == PRODUCT_ID_CYPHIDCOM_FRWD
));
234 static int analyze_baud_rate(struct usb_serial_port
*port
, speed_t new_rate
)
236 struct cypress_private
*priv
;
237 priv
= usb_get_serial_port_data(port
);
242 /* FRWD Dongle uses 115200 bps */
243 if (is_frwd(port
->serial
->dev
))
247 * The general purpose firmware for the Cypress M8 allows for
248 * a maximum speed of 57600bps (I have no idea whether DeLorme
249 * chose to use the general purpose firmware or not), if you
250 * need to modify this speed setting for your own project
251 * please add your own chiptype and modify the code likewise.
252 * The Cypress HID->COM device will work successfully up to
253 * 115200bps (but the actual throughput is around 3kBps).
255 if (port
->serial
->dev
->speed
== USB_SPEED_LOW
) {
257 * Mike Isely <isely@pobox.com> 2-Feb-2008: The
258 * Cypress app note that describes this mechanism
259 * states the the low-speed part can't handle more
260 * than 800 bytes/sec, in which case 4800 baud is the
261 * safest speed for a part like that.
263 if (new_rate
> 4800) {
265 "%s - failed setting baud rate, device incapable speed %d\n",
270 switch (priv
->chiptype
) {
272 if (new_rate
<= 600) {
273 /* 300 and 600 baud rates are supported under
274 * the generic firmware, but are not used with
275 * NMEA and SiRF protocols */
277 "%s - failed setting baud rate, unsupported speed of %d on Earthmate GPS\n",
289 /* This function can either set or retrieve the current serial line settings */
290 static int cypress_serial_control(struct tty_struct
*tty
,
291 struct usb_serial_port
*port
, speed_t baud_rate
, int data_bits
,
292 int stop_bits
, int parity_enable
, int parity_type
, int reset
,
293 int cypress_request_type
)
295 int new_baudrate
= 0, retval
= 0, tries
= 0;
296 struct cypress_private
*priv
;
297 struct device
*dev
= &port
->dev
;
299 const unsigned int feature_len
= 5;
302 priv
= usb_get_serial_port_data(port
);
304 if (!priv
->comm_is_ok
)
307 feature_buffer
= kcalloc(feature_len
, sizeof(u8
), GFP_KERNEL
);
311 switch (cypress_request_type
) {
312 case CYPRESS_SET_CONFIG
:
313 /* 0 means 'Hang up' so doesn't change the true bit rate */
314 new_baudrate
= priv
->baud_rate
;
315 if (baud_rate
&& baud_rate
!= priv
->baud_rate
) {
316 dev_dbg(dev
, "%s - baud rate is changing\n", __func__
);
317 retval
= analyze_baud_rate(port
, baud_rate
);
319 new_baudrate
= retval
;
320 dev_dbg(dev
, "%s - New baud rate set to %d\n",
321 __func__
, new_baudrate
);
324 dev_dbg(dev
, "%s - baud rate is being sent as %d\n", __func__
,
327 /* fill the feature_buffer with new configuration */
328 put_unaligned_le32(new_baudrate
, feature_buffer
);
329 feature_buffer
[4] |= data_bits
; /* assign data bits in 2 bit space ( max 3 ) */
331 feature_buffer
[4] |= (stop_bits
<< 3); /* assign stop bits in 1 bit space */
332 feature_buffer
[4] |= (parity_enable
<< 4); /* assign parity flag in 1 bit space */
333 feature_buffer
[4] |= (parity_type
<< 5); /* assign parity type in 1 bit space */
335 feature_buffer
[4] |= (reset
<< 7); /* assign reset at end of byte, 1 bit space */
337 dev_dbg(dev
, "%s - device is being sent this feature report:\n", __func__
);
338 dev_dbg(dev
, "%s - %02X - %02X - %02X - %02X - %02X\n", __func__
,
339 feature_buffer
[0], feature_buffer
[1],
340 feature_buffer
[2], feature_buffer
[3],
344 retval
= usb_control_msg(port
->serial
->dev
,
345 usb_sndctrlpipe(port
->serial
->dev
, 0),
347 USB_DIR_OUT
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
348 0x0300, 0, feature_buffer
,
354 } while (retval
!= feature_len
&&
357 if (retval
!= feature_len
) {
358 dev_err(dev
, "%s - failed sending serial line settings - %d\n",
360 cypress_set_dead(port
);
362 spin_lock_irqsave(&priv
->lock
, flags
);
363 priv
->baud_rate
= new_baudrate
;
364 priv
->current_config
= feature_buffer
[4];
365 spin_unlock_irqrestore(&priv
->lock
, flags
);
366 /* If we asked for a speed change encode it */
368 tty_encode_baud_rate(tty
,
369 new_baudrate
, new_baudrate
);
372 case CYPRESS_GET_CONFIG
:
373 if (priv
->get_cfg_unsafe
) {
374 /* Not implemented for this device,
375 and if we try to do it we're likely
376 to crash the hardware. */
380 dev_dbg(dev
, "%s - retrieving serial line settings\n", __func__
);
382 retval
= usb_control_msg(port
->serial
->dev
,
383 usb_rcvctrlpipe(port
->serial
->dev
, 0),
385 USB_DIR_IN
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
386 0x0300, 0, feature_buffer
,
391 } while (retval
!= feature_len
392 && retval
!= -ENODEV
);
394 if (retval
!= feature_len
) {
395 dev_err(dev
, "%s - failed to retrieve serial line settings - %d\n",
397 cypress_set_dead(port
);
400 spin_lock_irqsave(&priv
->lock
, flags
);
401 /* store the config in one byte, and later
402 use bit masks to check values */
403 priv
->current_config
= feature_buffer
[4];
404 priv
->baud_rate
= get_unaligned_le32(feature_buffer
);
405 spin_unlock_irqrestore(&priv
->lock
, flags
);
408 spin_lock_irqsave(&priv
->lock
, flags
);
410 spin_unlock_irqrestore(&priv
->lock
, flags
);
412 kfree(feature_buffer
);
414 } /* cypress_serial_control */
417 static void cypress_set_dead(struct usb_serial_port
*port
)
419 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
422 spin_lock_irqsave(&priv
->lock
, flags
);
423 if (!priv
->comm_is_ok
) {
424 spin_unlock_irqrestore(&priv
->lock
, flags
);
427 priv
->comm_is_ok
= 0;
428 spin_unlock_irqrestore(&priv
->lock
, flags
);
430 dev_err(&port
->dev
, "cypress_m8 suspending failing port %d - "
431 "interval might be too short\n", port
->port_number
);
435 /*****************************************************************************
436 * Cypress serial driver functions
437 *****************************************************************************/
440 static int cypress_generic_port_probe(struct usb_serial_port
*port
)
442 struct usb_serial
*serial
= port
->serial
;
443 struct cypress_private
*priv
;
445 if (!port
->interrupt_out_urb
|| !port
->interrupt_in_urb
) {
446 dev_err(&port
->dev
, "required endpoint is missing\n");
450 priv
= kzalloc(sizeof(struct cypress_private
), GFP_KERNEL
);
454 priv
->comm_is_ok
= !0;
455 spin_lock_init(&priv
->lock
);
456 if (kfifo_alloc(&priv
->write_fifo
, CYPRESS_BUF_SIZE
, GFP_KERNEL
)) {
461 /* Skip reset for FRWD device. It is a workaound:
462 device hangs if it receives SET_CONFIGURE in Configured
464 if (!is_frwd(serial
->dev
))
465 usb_reset_configuration(serial
->dev
);
468 priv
->line_control
= 0;
470 /* Default packet format setting is determined by packet size.
471 Anything with a size larger then 9 must have a separate
472 count field since the 3 bit count field is otherwise too
473 small. Otherwise we can use the slightly more compact
474 format. This is in accordance with the cypress_m8 serial
475 converter app note. */
476 if (port
->interrupt_out_size
> 9)
477 priv
->pkt_fmt
= packet_format_1
;
479 priv
->pkt_fmt
= packet_format_2
;
482 priv
->write_urb_interval
= interval
;
483 priv
->read_urb_interval
= interval
;
484 dev_dbg(&port
->dev
, "%s - read & write intervals forced to %d\n",
487 priv
->write_urb_interval
= port
->interrupt_out_urb
->interval
;
488 priv
->read_urb_interval
= port
->interrupt_in_urb
->interval
;
489 dev_dbg(&port
->dev
, "%s - intervals: read=%d write=%d\n",
490 __func__
, priv
->read_urb_interval
,
491 priv
->write_urb_interval
);
493 usb_set_serial_port_data(port
, priv
);
495 port
->port
.drain_delay
= 256;
501 static int cypress_earthmate_port_probe(struct usb_serial_port
*port
)
503 struct usb_serial
*serial
= port
->serial
;
504 struct cypress_private
*priv
;
507 ret
= cypress_generic_port_probe(port
);
509 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
513 priv
= usb_get_serial_port_data(port
);
514 priv
->chiptype
= CT_EARTHMATE
;
515 /* All Earthmate devices use the separated-count packet
517 priv
->pkt_fmt
= packet_format_1
;
518 if (serial
->dev
->descriptor
.idProduct
!=
519 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB
)) {
520 /* The old original USB Earthmate seemed able to
521 handle GET_CONFIG requests; everything they've
522 produced since that time crashes if this command is
525 "%s - Marking this device as unsafe for GET_CONFIG commands\n",
527 priv
->get_cfg_unsafe
= !0;
533 static int cypress_hidcom_port_probe(struct usb_serial_port
*port
)
535 struct cypress_private
*priv
;
538 ret
= cypress_generic_port_probe(port
);
540 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
544 priv
= usb_get_serial_port_data(port
);
545 priv
->chiptype
= CT_CYPHIDCOM
;
550 static int cypress_ca42v2_port_probe(struct usb_serial_port
*port
)
552 struct cypress_private
*priv
;
555 ret
= cypress_generic_port_probe(port
);
557 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
561 priv
= usb_get_serial_port_data(port
);
562 priv
->chiptype
= CT_CA42V2
;
567 static int cypress_port_remove(struct usb_serial_port
*port
)
569 struct cypress_private
*priv
;
571 priv
= usb_get_serial_port_data(port
);
573 kfifo_free(&priv
->write_fifo
);
579 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
581 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
582 struct usb_serial
*serial
= port
->serial
;
586 if (!priv
->comm_is_ok
)
589 /* clear halts before open */
590 usb_clear_halt(serial
->dev
, 0x81);
591 usb_clear_halt(serial
->dev
, 0x02);
593 spin_lock_irqsave(&priv
->lock
, flags
);
594 /* reset read/write statistics */
599 spin_unlock_irqrestore(&priv
->lock
, flags
);
605 cypress_set_termios(tty
, port
, NULL
);
607 /* setup the port and start reading from the device */
608 usb_fill_int_urb(port
->interrupt_in_urb
, serial
->dev
,
609 usb_rcvintpipe(serial
->dev
, port
->interrupt_in_endpointAddress
),
610 port
->interrupt_in_urb
->transfer_buffer
,
611 port
->interrupt_in_urb
->transfer_buffer_length
,
612 cypress_read_int_callback
, port
, priv
->read_urb_interval
);
613 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
617 "%s - failed submitting read urb, error %d\n",
619 cypress_set_dead(port
);
625 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
)
627 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
628 /* drop dtr and rts */
629 spin_lock_irq(&priv
->lock
);
631 priv
->line_control
= 0;
633 priv
->line_control
= CONTROL_DTR
| CONTROL_RTS
;
635 spin_unlock_irq(&priv
->lock
);
636 cypress_write(NULL
, port
, NULL
, 0);
639 static void cypress_close(struct usb_serial_port
*port
)
641 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
644 spin_lock_irqsave(&priv
->lock
, flags
);
645 kfifo_reset_out(&priv
->write_fifo
);
646 spin_unlock_irqrestore(&priv
->lock
, flags
);
648 dev_dbg(&port
->dev
, "%s - stopping urbs\n", __func__
);
649 usb_kill_urb(port
->interrupt_in_urb
);
650 usb_kill_urb(port
->interrupt_out_urb
);
653 dev_info(&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
654 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
655 } /* cypress_close */
658 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
659 const unsigned char *buf
, int count
)
661 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
663 dev_dbg(&port
->dev
, "%s - %d bytes\n", __func__
, count
);
665 /* line control commands, which need to be executed immediately,
666 are not put into the buffer for obvious reasons.
668 if (priv
->cmd_ctrl
) {
676 count
= kfifo_in_locked(&priv
->write_fifo
, buf
, count
, &priv
->lock
);
682 } /* cypress_write */
685 static void cypress_send(struct usb_serial_port
*port
)
687 int count
= 0, result
, offset
, actual_size
;
688 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
689 struct device
*dev
= &port
->dev
;
692 if (!priv
->comm_is_ok
)
695 dev_dbg(dev
, "%s - interrupt out size is %d\n", __func__
,
696 port
->interrupt_out_size
);
698 spin_lock_irqsave(&priv
->lock
, flags
);
699 if (priv
->write_urb_in_use
) {
700 dev_dbg(dev
, "%s - can't write, urb in use\n", __func__
);
701 spin_unlock_irqrestore(&priv
->lock
, flags
);
704 spin_unlock_irqrestore(&priv
->lock
, flags
);
707 memset(port
->interrupt_out_urb
->transfer_buffer
, 0,
708 port
->interrupt_out_size
);
710 spin_lock_irqsave(&priv
->lock
, flags
);
711 switch (priv
->pkt_fmt
) {
713 case packet_format_1
:
714 /* this is for the CY7C64013... */
716 port
->interrupt_out_buffer
[0] = priv
->line_control
;
718 case packet_format_2
:
719 /* this is for the CY7C63743... */
721 port
->interrupt_out_buffer
[0] = priv
->line_control
;
725 if (priv
->line_control
& CONTROL_RESET
)
726 priv
->line_control
&= ~CONTROL_RESET
;
728 if (priv
->cmd_ctrl
) {
730 dev_dbg(dev
, "%s - line control command being issued\n", __func__
);
731 spin_unlock_irqrestore(&priv
->lock
, flags
);
734 spin_unlock_irqrestore(&priv
->lock
, flags
);
736 count
= kfifo_out_locked(&priv
->write_fifo
,
737 &port
->interrupt_out_buffer
[offset
],
738 port
->interrupt_out_size
- offset
,
743 switch (priv
->pkt_fmt
) {
745 case packet_format_1
:
746 port
->interrupt_out_buffer
[1] = count
;
748 case packet_format_2
:
749 port
->interrupt_out_buffer
[0] |= count
;
752 dev_dbg(dev
, "%s - count is %d\n", __func__
, count
);
755 spin_lock_irqsave(&priv
->lock
, flags
);
756 priv
->write_urb_in_use
= 1;
757 spin_unlock_irqrestore(&priv
->lock
, flags
);
762 actual_size
= count
+
763 (priv
->pkt_fmt
== packet_format_1
? 2 : 1);
765 usb_serial_debug_data(dev
, __func__
, port
->interrupt_out_size
,
766 port
->interrupt_out_urb
->transfer_buffer
);
768 usb_fill_int_urb(port
->interrupt_out_urb
, port
->serial
->dev
,
769 usb_sndintpipe(port
->serial
->dev
, port
->interrupt_out_endpointAddress
),
770 port
->interrupt_out_buffer
, actual_size
,
771 cypress_write_int_callback
, port
, priv
->write_urb_interval
);
772 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
774 dev_err_console(port
,
775 "%s - failed submitting write urb, error %d\n",
777 priv
->write_urb_in_use
= 0;
778 cypress_set_dead(port
);
781 spin_lock_irqsave(&priv
->lock
, flags
);
785 /* do not count the line control and size bytes */
786 priv
->bytes_out
+= count
;
787 spin_unlock_irqrestore(&priv
->lock
, flags
);
789 usb_serial_port_softint(port
);
793 /* returns how much space is available in the soft buffer */
794 static int cypress_write_room(struct tty_struct
*tty
)
796 struct usb_serial_port
*port
= tty
->driver_data
;
797 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
801 spin_lock_irqsave(&priv
->lock
, flags
);
802 room
= kfifo_avail(&priv
->write_fifo
);
803 spin_unlock_irqrestore(&priv
->lock
, flags
);
805 dev_dbg(&port
->dev
, "%s - returns %d\n", __func__
, room
);
810 static int cypress_tiocmget(struct tty_struct
*tty
)
812 struct usb_serial_port
*port
= tty
->driver_data
;
813 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
814 __u8 status
, control
;
815 unsigned int result
= 0;
818 spin_lock_irqsave(&priv
->lock
, flags
);
819 control
= priv
->line_control
;
820 status
= priv
->current_status
;
821 spin_unlock_irqrestore(&priv
->lock
, flags
);
823 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
824 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
825 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
826 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
827 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
828 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
830 dev_dbg(&port
->dev
, "%s - result = %x\n", __func__
, result
);
836 static int cypress_tiocmset(struct tty_struct
*tty
,
837 unsigned int set
, unsigned int clear
)
839 struct usb_serial_port
*port
= tty
->driver_data
;
840 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
843 spin_lock_irqsave(&priv
->lock
, flags
);
845 priv
->line_control
|= CONTROL_RTS
;
847 priv
->line_control
|= CONTROL_DTR
;
848 if (clear
& TIOCM_RTS
)
849 priv
->line_control
&= ~CONTROL_RTS
;
850 if (clear
& TIOCM_DTR
)
851 priv
->line_control
&= ~CONTROL_DTR
;
853 spin_unlock_irqrestore(&priv
->lock
, flags
);
855 return cypress_write(tty
, port
, NULL
, 0);
858 static void cypress_earthmate_init_termios(struct tty_struct
*tty
)
860 tty_encode_baud_rate(tty
, 4800, 4800);
863 static void cypress_set_termios(struct tty_struct
*tty
,
864 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
866 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
867 struct device
*dev
= &port
->dev
;
868 int data_bits
, stop_bits
, parity_type
, parity_enable
;
874 /* Unsupported features need clearing */
875 tty
->termios
.c_cflag
&= ~(CMSPAR
|CRTSCTS
);
877 cflag
= tty
->termios
.c_cflag
;
879 /* set number of data bits, parity, stop bits */
880 /* when parity is disabled the parity type bit is ignored */
882 /* 1 means 2 stop bits, 0 means 1 stop bit */
883 stop_bits
= cflag
& CSTOPB
? 1 : 0;
885 if (cflag
& PARENB
) {
887 /* 1 means odd parity, 0 means even parity */
888 parity_type
= cflag
& PARODD
? 1 : 0;
890 parity_enable
= parity_type
= 0;
892 switch (cflag
& CSIZE
) {
906 dev_err(dev
, "%s - CSIZE was set, but not CS5-CS8\n", __func__
);
909 spin_lock_irqsave(&priv
->lock
, flags
);
910 oldlines
= priv
->line_control
;
911 if ((cflag
& CBAUD
) == B0
) {
912 /* drop dtr and rts */
913 dev_dbg(dev
, "%s - dropping the lines, baud rate 0bps\n", __func__
);
914 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
916 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
917 spin_unlock_irqrestore(&priv
->lock
, flags
);
919 dev_dbg(dev
, "%s - sending %d stop_bits, %d parity_enable, %d parity_type, %d data_bits (+5)\n",
920 __func__
, stop_bits
, parity_enable
, parity_type
, data_bits
);
922 cypress_serial_control(tty
, port
, tty_get_baud_rate(tty
),
923 data_bits
, stop_bits
,
924 parity_enable
, parity_type
,
925 0, CYPRESS_SET_CONFIG
);
927 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
928 * filled into the private structure this should confirm that all is
929 * working if it returns what we just set */
930 cypress_serial_control(tty
, port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
932 /* Here we can define custom tty settings for devices; the main tty
933 * termios flag base comes from empeg.c */
935 spin_lock_irqsave(&priv
->lock
, flags
);
936 if (priv
->chiptype
== CT_EARTHMATE
&& priv
->baud_rate
== 4800) {
937 dev_dbg(dev
, "Using custom termios settings for a baud rate of 4800bps.\n");
938 /* define custom termios settings for NMEA protocol */
940 tty
->termios
.c_iflag
/* input modes - */
941 &= ~(IGNBRK
/* disable ignore break */
942 | BRKINT
/* disable break causes interrupt */
943 | PARMRK
/* disable mark parity errors */
944 | ISTRIP
/* disable clear high bit of input char */
945 | INLCR
/* disable translate NL to CR */
946 | IGNCR
/* disable ignore CR */
947 | ICRNL
/* disable translate CR to NL */
948 | IXON
); /* disable enable XON/XOFF flow control */
950 tty
->termios
.c_oflag
/* output modes */
951 &= ~OPOST
; /* disable postprocess output char */
953 tty
->termios
.c_lflag
/* line discipline modes */
954 &= ~(ECHO
/* disable echo input characters */
955 | ECHONL
/* disable echo new line */
956 | ICANON
/* disable erase, kill, werase, and rprnt
957 special characters */
958 | ISIG
/* disable interrupt, quit, and suspend
959 special characters */
960 | IEXTEN
); /* disable non-POSIX special characters */
961 } /* CT_CYPHIDCOM: Application should handle this for device */
963 linechange
= (priv
->line_control
!= oldlines
);
964 spin_unlock_irqrestore(&priv
->lock
, flags
);
966 /* if necessary, set lines */
969 cypress_write(tty
, port
, NULL
, 0);
971 } /* cypress_set_termios */
974 /* returns amount of data still left in soft buffer */
975 static int cypress_chars_in_buffer(struct tty_struct
*tty
)
977 struct usb_serial_port
*port
= tty
->driver_data
;
978 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
982 spin_lock_irqsave(&priv
->lock
, flags
);
983 chars
= kfifo_len(&priv
->write_fifo
);
984 spin_unlock_irqrestore(&priv
->lock
, flags
);
986 dev_dbg(&port
->dev
, "%s - returns %d\n", __func__
, chars
);
991 static void cypress_throttle(struct tty_struct
*tty
)
993 struct usb_serial_port
*port
= tty
->driver_data
;
994 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
996 spin_lock_irq(&priv
->lock
);
997 priv
->rx_flags
= THROTTLED
;
998 spin_unlock_irq(&priv
->lock
);
1002 static void cypress_unthrottle(struct tty_struct
*tty
)
1004 struct usb_serial_port
*port
= tty
->driver_data
;
1005 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1006 int actually_throttled
, result
;
1008 spin_lock_irq(&priv
->lock
);
1009 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1011 spin_unlock_irq(&priv
->lock
);
1013 if (!priv
->comm_is_ok
)
1016 if (actually_throttled
) {
1017 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
1019 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1020 "error %d\n", __func__
, result
);
1021 cypress_set_dead(port
);
1027 static void cypress_read_int_callback(struct urb
*urb
)
1029 struct usb_serial_port
*port
= urb
->context
;
1030 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1031 struct device
*dev
= &urb
->dev
->dev
;
1032 struct tty_struct
*tty
;
1033 unsigned char *data
= urb
->transfer_buffer
;
1034 unsigned long flags
;
1035 char tty_flag
= TTY_NORMAL
;
1039 int status
= urb
->status
;
1042 case 0: /* success */
1047 /* precursor to disconnect so just go away */
1050 /* Can't call usb_clear_halt while in_interrupt */
1053 /* something ugly is going on... */
1054 dev_err(dev
, "%s - unexpected nonzero read status received: %d\n",
1056 cypress_set_dead(port
);
1060 spin_lock_irqsave(&priv
->lock
, flags
);
1061 if (priv
->rx_flags
& THROTTLED
) {
1062 dev_dbg(dev
, "%s - now throttling\n", __func__
);
1063 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1064 spin_unlock_irqrestore(&priv
->lock
, flags
);
1067 spin_unlock_irqrestore(&priv
->lock
, flags
);
1069 tty
= tty_port_tty_get(&port
->port
);
1071 dev_dbg(dev
, "%s - bad tty pointer - exiting\n", __func__
);
1075 spin_lock_irqsave(&priv
->lock
, flags
);
1076 result
= urb
->actual_length
;
1077 switch (priv
->pkt_fmt
) {
1079 case packet_format_1
:
1080 /* This is for the CY7C64013... */
1081 priv
->current_status
= data
[0] & 0xF8;
1082 bytes
= data
[1] + 2;
1085 case packet_format_2
:
1086 /* This is for the CY7C63743... */
1087 priv
->current_status
= data
[0] & 0xF8;
1088 bytes
= (data
[0] & 0x07) + 1;
1092 spin_unlock_irqrestore(&priv
->lock
, flags
);
1093 if (result
< bytes
) {
1095 "%s - wrong packet size - received %d bytes but packet said %d bytes\n",
1096 __func__
, result
, bytes
);
1100 usb_serial_debug_data(&port
->dev
, __func__
, urb
->actual_length
, data
);
1102 spin_lock_irqsave(&priv
->lock
, flags
);
1103 /* check to see if status has changed */
1104 if (priv
->current_status
!= priv
->prev_status
) {
1105 u8 delta
= priv
->current_status
^ priv
->prev_status
;
1107 if (delta
& UART_MSR_MASK
) {
1108 if (delta
& UART_CTS
)
1110 if (delta
& UART_DSR
)
1112 if (delta
& UART_RI
)
1114 if (delta
& UART_CD
)
1117 wake_up_interruptible(&port
->port
.delta_msr_wait
);
1120 priv
->prev_status
= priv
->current_status
;
1122 spin_unlock_irqrestore(&priv
->lock
, flags
);
1124 /* hangup, as defined in acm.c... this might be a bad place for it
1126 if (tty
&& !C_CLOCAL(tty
) && !(priv
->current_status
& UART_CD
)) {
1127 dev_dbg(dev
, "%s - calling hangup\n", __func__
);
1132 /* There is one error bit... I'm assuming it is a parity error
1133 * indicator as the generic firmware will set this bit to 1 if a
1134 * parity error occurs.
1135 * I can not find reference to any other error events. */
1136 spin_lock_irqsave(&priv
->lock
, flags
);
1137 if (priv
->current_status
& CYP_ERROR
) {
1138 spin_unlock_irqrestore(&priv
->lock
, flags
);
1139 tty_flag
= TTY_PARITY
;
1140 dev_dbg(dev
, "%s - Parity Error detected\n", __func__
);
1142 spin_unlock_irqrestore(&priv
->lock
, flags
);
1144 /* process read if there is data other than line status */
1146 tty_insert_flip_string_fixed_flag(&port
->port
, data
+ i
,
1147 tty_flag
, bytes
- i
);
1148 tty_flip_buffer_push(&port
->port
);
1151 spin_lock_irqsave(&priv
->lock
, flags
);
1152 /* control and status byte(s) are also counted */
1153 priv
->bytes_in
+= bytes
;
1154 spin_unlock_irqrestore(&priv
->lock
, flags
);
1159 /* Continue trying to always read */
1161 if (priv
->comm_is_ok
) {
1162 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1163 usb_rcvintpipe(port
->serial
->dev
,
1164 port
->interrupt_in_endpointAddress
),
1165 port
->interrupt_in_urb
->transfer_buffer
,
1166 port
->interrupt_in_urb
->transfer_buffer_length
,
1167 cypress_read_int_callback
, port
,
1168 priv
->read_urb_interval
);
1169 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1170 if (result
&& result
!= -EPERM
) {
1171 dev_err(dev
, "%s - failed resubmitting read urb, error %d\n",
1173 cypress_set_dead(port
);
1176 } /* cypress_read_int_callback */
1179 static void cypress_write_int_callback(struct urb
*urb
)
1181 struct usb_serial_port
*port
= urb
->context
;
1182 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1183 struct device
*dev
= &urb
->dev
->dev
;
1184 int status
= urb
->status
;
1193 /* this urb is terminated, clean up */
1194 dev_dbg(dev
, "%s - urb shutting down with status: %d\n",
1196 priv
->write_urb_in_use
= 0;
1199 /* Cannot call usb_clear_halt while in_interrupt */
1202 dev_err(dev
, "%s - unexpected nonzero write status received: %d\n",
1204 cypress_set_dead(port
);
1207 priv
->write_urb_in_use
= 0;
1209 /* send any buffered data */
1213 module_usb_serial_driver(serial_drivers
, id_table_combined
);
1215 MODULE_AUTHOR(DRIVER_AUTHOR
);
1216 MODULE_DESCRIPTION(DRIVER_DESC
);
1217 MODULE_LICENSE("GPL");
1219 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1220 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1221 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1222 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");
1223 module_param(unstable_bauds
, bool, S_IRUGO
| S_IWUSR
);
1224 MODULE_PARM_DESC(unstable_bauds
, "Allow unstable baud rates");