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
;
53 #define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>"
54 #define DRIVER_DESC "Cypress USB to Serial Driver"
56 /* write buffer size defines */
57 #define CYPRESS_BUF_SIZE 1024
59 static const struct usb_device_id id_table_earthmate
[] = {
60 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
61 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
62 { } /* Terminating entry */
65 static const struct usb_device_id id_table_cyphidcomrs232
[] = {
66 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
67 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
68 { } /* Terminating entry */
71 static const struct usb_device_id id_table_nokiaca42v2
[] = {
72 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
73 { } /* Terminating entry */
76 static const struct usb_device_id id_table_combined
[] = {
77 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB
) },
78 { USB_DEVICE(VENDOR_ID_DELORME
, PRODUCT_ID_EARTHMATEUSB_LT20
) },
79 { USB_DEVICE(VENDOR_ID_CYPRESS
, PRODUCT_ID_CYPHIDCOM
) },
80 { USB_DEVICE(VENDOR_ID_POWERCOM
, PRODUCT_ID_UPS
) },
81 { USB_DEVICE(VENDOR_ID_DAZZLE
, PRODUCT_ID_CA42
) },
82 { } /* Terminating entry */
85 MODULE_DEVICE_TABLE(usb
, id_table_combined
);
88 packet_format_1
, /* b0:status, b1:payload count */
89 packet_format_2
/* b0[7:3]:status, b0[2:0]:payload count */
92 struct cypress_private
{
93 spinlock_t lock
; /* private lock */
94 int chiptype
; /* identifier of device, for quirks/etc */
95 int bytes_in
; /* used for statistics */
96 int bytes_out
; /* used for statistics */
97 int cmd_count
; /* used for statistics */
98 int cmd_ctrl
; /* always set this to 1 before issuing a command */
99 struct kfifo write_fifo
; /* write fifo */
100 int write_urb_in_use
; /* write urb in use indicator */
101 int write_urb_interval
; /* interval to use for write urb */
102 int read_urb_interval
; /* interval to use for read urb */
103 int comm_is_ok
; /* true if communication is (still) ok */
104 int termios_initialized
;
105 __u8 line_control
; /* holds dtr / rts value */
106 __u8 current_status
; /* received from last read - info on dsr,cts,cd,ri,etc */
107 __u8 current_config
; /* stores the current configuration byte */
108 __u8 rx_flags
; /* throttling - used from whiteheat/ftdi_sio */
109 enum packet_format pkt_fmt
; /* format to use for packet send / receive */
110 int get_cfg_unsafe
; /* If true, the CYPRESS_GET_CONFIG is unsafe */
111 int baud_rate
; /* stores current baud rate in
113 int isthrottled
; /* if throttled, discard reads */
114 char prev_status
, diff_status
; /* used for TIOCMIWAIT */
115 /* we pass a pointer to this as the argument sent to
116 cypress_set_termios old_termios */
117 struct ktermios tmp_termios
; /* stores the old termios settings */
120 /* function prototypes for the Cypress USB to serial device */
121 static int cypress_earthmate_port_probe(struct usb_serial_port
*port
);
122 static int cypress_hidcom_port_probe(struct usb_serial_port
*port
);
123 static int cypress_ca42v2_port_probe(struct usb_serial_port
*port
);
124 static int cypress_port_remove(struct usb_serial_port
*port
);
125 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
);
126 static void cypress_close(struct usb_serial_port
*port
);
127 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
);
128 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
129 const unsigned char *buf
, int count
);
130 static void cypress_send(struct usb_serial_port
*port
);
131 static int cypress_write_room(struct tty_struct
*tty
);
132 static int cypress_ioctl(struct tty_struct
*tty
,
133 unsigned int cmd
, unsigned long arg
);
134 static void cypress_set_termios(struct tty_struct
*tty
,
135 struct usb_serial_port
*port
, struct ktermios
*old
);
136 static int cypress_tiocmget(struct tty_struct
*tty
);
137 static int cypress_tiocmset(struct tty_struct
*tty
,
138 unsigned int set
, unsigned int clear
);
139 static int cypress_chars_in_buffer(struct tty_struct
*tty
);
140 static void cypress_throttle(struct tty_struct
*tty
);
141 static void cypress_unthrottle(struct tty_struct
*tty
);
142 static void cypress_set_dead(struct usb_serial_port
*port
);
143 static void cypress_read_int_callback(struct urb
*urb
);
144 static void cypress_write_int_callback(struct urb
*urb
);
146 static struct usb_serial_driver cypress_earthmate_device
= {
148 .owner
= THIS_MODULE
,
151 .description
= "DeLorme Earthmate USB",
152 .id_table
= id_table_earthmate
,
154 .port_probe
= cypress_earthmate_port_probe
,
155 .port_remove
= cypress_port_remove
,
156 .open
= cypress_open
,
157 .close
= cypress_close
,
158 .dtr_rts
= cypress_dtr_rts
,
159 .write
= cypress_write
,
160 .write_room
= cypress_write_room
,
161 .ioctl
= cypress_ioctl
,
162 .set_termios
= cypress_set_termios
,
163 .tiocmget
= cypress_tiocmget
,
164 .tiocmset
= cypress_tiocmset
,
165 .chars_in_buffer
= cypress_chars_in_buffer
,
166 .throttle
= cypress_throttle
,
167 .unthrottle
= cypress_unthrottle
,
168 .read_int_callback
= cypress_read_int_callback
,
169 .write_int_callback
= cypress_write_int_callback
,
172 static struct usb_serial_driver cypress_hidcom_device
= {
174 .owner
= THIS_MODULE
,
177 .description
= "HID->COM RS232 Adapter",
178 .id_table
= id_table_cyphidcomrs232
,
180 .port_probe
= cypress_hidcom_port_probe
,
181 .port_remove
= cypress_port_remove
,
182 .open
= cypress_open
,
183 .close
= cypress_close
,
184 .dtr_rts
= cypress_dtr_rts
,
185 .write
= cypress_write
,
186 .write_room
= cypress_write_room
,
187 .ioctl
= cypress_ioctl
,
188 .set_termios
= cypress_set_termios
,
189 .tiocmget
= cypress_tiocmget
,
190 .tiocmset
= cypress_tiocmset
,
191 .chars_in_buffer
= cypress_chars_in_buffer
,
192 .throttle
= cypress_throttle
,
193 .unthrottle
= cypress_unthrottle
,
194 .read_int_callback
= cypress_read_int_callback
,
195 .write_int_callback
= cypress_write_int_callback
,
198 static struct usb_serial_driver cypress_ca42v2_device
= {
200 .owner
= THIS_MODULE
,
201 .name
= "nokiaca42v2",
203 .description
= "Nokia CA-42 V2 Adapter",
204 .id_table
= id_table_nokiaca42v2
,
206 .port_probe
= cypress_ca42v2_port_probe
,
207 .port_remove
= cypress_port_remove
,
208 .open
= cypress_open
,
209 .close
= cypress_close
,
210 .dtr_rts
= cypress_dtr_rts
,
211 .write
= cypress_write
,
212 .write_room
= cypress_write_room
,
213 .ioctl
= cypress_ioctl
,
214 .set_termios
= cypress_set_termios
,
215 .tiocmget
= cypress_tiocmget
,
216 .tiocmset
= cypress_tiocmset
,
217 .chars_in_buffer
= cypress_chars_in_buffer
,
218 .throttle
= cypress_throttle
,
219 .unthrottle
= cypress_unthrottle
,
220 .read_int_callback
= cypress_read_int_callback
,
221 .write_int_callback
= cypress_write_int_callback
,
224 static struct usb_serial_driver
* const serial_drivers
[] = {
225 &cypress_earthmate_device
, &cypress_hidcom_device
,
226 &cypress_ca42v2_device
, NULL
229 /*****************************************************************************
230 * Cypress serial helper functions
231 *****************************************************************************/
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
);
243 * The general purpose firmware for the Cypress M8 allows for
244 * a maximum speed of 57600bps (I have no idea whether DeLorme
245 * chose to use the general purpose firmware or not), if you
246 * need to modify this speed setting for your own project
247 * please add your own chiptype and modify the code likewise.
248 * The Cypress HID->COM device will work successfully up to
249 * 115200bps (but the actual throughput is around 3kBps).
251 if (port
->serial
->dev
->speed
== USB_SPEED_LOW
) {
253 * Mike Isely <isely@pobox.com> 2-Feb-2008: The
254 * Cypress app note that describes this mechanism
255 * states the the low-speed part can't handle more
256 * than 800 bytes/sec, in which case 4800 baud is the
257 * safest speed for a part like that.
259 if (new_rate
> 4800) {
261 "%s - failed setting baud rate, device incapable speed %d\n",
266 switch (priv
->chiptype
) {
268 if (new_rate
<= 600) {
269 /* 300 and 600 baud rates are supported under
270 * the generic firmware, but are not used with
271 * NMEA and SiRF protocols */
273 "%s - failed setting baud rate, unsupported speed of %d on Earthmate GPS",
285 /* This function can either set or retrieve the current serial line settings */
286 static int cypress_serial_control(struct tty_struct
*tty
,
287 struct usb_serial_port
*port
, speed_t baud_rate
, int data_bits
,
288 int stop_bits
, int parity_enable
, int parity_type
, int reset
,
289 int cypress_request_type
)
291 int new_baudrate
= 0, retval
= 0, tries
= 0;
292 struct cypress_private
*priv
;
293 struct device
*dev
= &port
->dev
;
295 const unsigned int feature_len
= 5;
298 priv
= usb_get_serial_port_data(port
);
300 if (!priv
->comm_is_ok
)
303 feature_buffer
= kcalloc(feature_len
, sizeof(u8
), GFP_KERNEL
);
307 switch (cypress_request_type
) {
308 case CYPRESS_SET_CONFIG
:
309 /* 0 means 'Hang up' so doesn't change the true bit rate */
310 new_baudrate
= priv
->baud_rate
;
311 if (baud_rate
&& baud_rate
!= priv
->baud_rate
) {
312 dev_dbg(dev
, "%s - baud rate is changing\n", __func__
);
313 retval
= analyze_baud_rate(port
, baud_rate
);
315 new_baudrate
= retval
;
316 dev_dbg(dev
, "%s - New baud rate set to %d\n",
317 __func__
, new_baudrate
);
320 dev_dbg(dev
, "%s - baud rate is being sent as %d\n", __func__
,
323 /* fill the feature_buffer with new configuration */
324 put_unaligned_le32(new_baudrate
, feature_buffer
);
325 feature_buffer
[4] |= data_bits
; /* assign data bits in 2 bit space ( max 3 ) */
327 feature_buffer
[4] |= (stop_bits
<< 3); /* assign stop bits in 1 bit space */
328 feature_buffer
[4] |= (parity_enable
<< 4); /* assign parity flag in 1 bit space */
329 feature_buffer
[4] |= (parity_type
<< 5); /* assign parity type in 1 bit space */
331 feature_buffer
[4] |= (reset
<< 7); /* assign reset at end of byte, 1 bit space */
333 dev_dbg(dev
, "%s - device is being sent this feature report:\n", __func__
);
334 dev_dbg(dev
, "%s - %02X - %02X - %02X - %02X - %02X\n", __func__
,
335 feature_buffer
[0], feature_buffer
[1],
336 feature_buffer
[2], feature_buffer
[3],
340 retval
= usb_control_msg(port
->serial
->dev
,
341 usb_sndctrlpipe(port
->serial
->dev
, 0),
343 USB_DIR_OUT
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
344 0x0300, 0, feature_buffer
,
350 } while (retval
!= feature_len
&&
353 if (retval
!= feature_len
) {
354 dev_err(dev
, "%s - failed sending serial line settings - %d\n",
356 cypress_set_dead(port
);
358 spin_lock_irqsave(&priv
->lock
, flags
);
359 priv
->baud_rate
= new_baudrate
;
360 priv
->current_config
= feature_buffer
[4];
361 spin_unlock_irqrestore(&priv
->lock
, flags
);
362 /* If we asked for a speed change encode it */
364 tty_encode_baud_rate(tty
,
365 new_baudrate
, new_baudrate
);
368 case CYPRESS_GET_CONFIG
:
369 if (priv
->get_cfg_unsafe
) {
370 /* Not implemented for this device,
371 and if we try to do it we're likely
372 to crash the hardware. */
376 dev_dbg(dev
, "%s - retreiving serial line settings\n", __func__
);
378 retval
= usb_control_msg(port
->serial
->dev
,
379 usb_rcvctrlpipe(port
->serial
->dev
, 0),
381 USB_DIR_IN
| USB_RECIP_INTERFACE
| USB_TYPE_CLASS
,
382 0x0300, 0, feature_buffer
,
387 } while (retval
!= feature_len
388 && retval
!= -ENODEV
);
390 if (retval
!= feature_len
) {
391 dev_err(dev
, "%s - failed to retrieve serial line settings - %d\n",
393 cypress_set_dead(port
);
396 spin_lock_irqsave(&priv
->lock
, flags
);
397 /* store the config in one byte, and later
398 use bit masks to check values */
399 priv
->current_config
= feature_buffer
[4];
400 priv
->baud_rate
= get_unaligned_le32(feature_buffer
);
401 spin_unlock_irqrestore(&priv
->lock
, flags
);
404 spin_lock_irqsave(&priv
->lock
, flags
);
406 spin_unlock_irqrestore(&priv
->lock
, flags
);
408 kfree(feature_buffer
);
410 } /* cypress_serial_control */
413 static void cypress_set_dead(struct usb_serial_port
*port
)
415 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
418 spin_lock_irqsave(&priv
->lock
, flags
);
419 if (!priv
->comm_is_ok
) {
420 spin_unlock_irqrestore(&priv
->lock
, flags
);
423 priv
->comm_is_ok
= 0;
424 spin_unlock_irqrestore(&priv
->lock
, flags
);
426 dev_err(&port
->dev
, "cypress_m8 suspending failing port %d - "
427 "interval might be too short\n", port
->number
);
431 /*****************************************************************************
432 * Cypress serial driver functions
433 *****************************************************************************/
436 static int cypress_generic_port_probe(struct usb_serial_port
*port
)
438 struct usb_serial
*serial
= port
->serial
;
439 struct cypress_private
*priv
;
441 priv
= kzalloc(sizeof(struct cypress_private
), GFP_KERNEL
);
445 priv
->comm_is_ok
= !0;
446 spin_lock_init(&priv
->lock
);
447 if (kfifo_alloc(&priv
->write_fifo
, CYPRESS_BUF_SIZE
, GFP_KERNEL
)) {
452 usb_reset_configuration(serial
->dev
);
455 priv
->line_control
= 0;
456 priv
->termios_initialized
= 0;
458 /* Default packet format setting is determined by packet size.
459 Anything with a size larger then 9 must have a separate
460 count field since the 3 bit count field is otherwise too
461 small. Otherwise we can use the slightly more compact
462 format. This is in accordance with the cypress_m8 serial
463 converter app note. */
464 if (port
->interrupt_out_size
> 9)
465 priv
->pkt_fmt
= packet_format_1
;
467 priv
->pkt_fmt
= packet_format_2
;
470 priv
->write_urb_interval
= interval
;
471 priv
->read_urb_interval
= interval
;
472 dev_dbg(&port
->dev
, "%s - read & write intervals forced to %d\n",
475 priv
->write_urb_interval
= port
->interrupt_out_urb
->interval
;
476 priv
->read_urb_interval
= port
->interrupt_in_urb
->interval
;
477 dev_dbg(&port
->dev
, "%s - intervals: read=%d write=%d\n",
478 __func__
, priv
->read_urb_interval
,
479 priv
->write_urb_interval
);
481 usb_set_serial_port_data(port
, priv
);
487 static int cypress_earthmate_port_probe(struct usb_serial_port
*port
)
489 struct usb_serial
*serial
= port
->serial
;
490 struct cypress_private
*priv
;
493 ret
= cypress_generic_port_probe(port
);
495 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
499 priv
= usb_get_serial_port_data(port
);
500 priv
->chiptype
= CT_EARTHMATE
;
501 /* All Earthmate devices use the separated-count packet
503 priv
->pkt_fmt
= packet_format_1
;
504 if (serial
->dev
->descriptor
.idProduct
!=
505 cpu_to_le16(PRODUCT_ID_EARTHMATEUSB
)) {
506 /* The old original USB Earthmate seemed able to
507 handle GET_CONFIG requests; everything they've
508 produced since that time crashes if this command is
511 "%s - Marking this device as unsafe for GET_CONFIG commands\n",
513 priv
->get_cfg_unsafe
= !0;
519 static int cypress_hidcom_port_probe(struct usb_serial_port
*port
)
521 struct cypress_private
*priv
;
524 ret
= cypress_generic_port_probe(port
);
526 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
530 priv
= usb_get_serial_port_data(port
);
531 priv
->chiptype
= CT_CYPHIDCOM
;
536 static int cypress_ca42v2_port_probe(struct usb_serial_port
*port
)
538 struct cypress_private
*priv
;
541 ret
= cypress_generic_port_probe(port
);
543 dev_dbg(&port
->dev
, "%s - Failed setting up port\n", __func__
);
547 priv
= usb_get_serial_port_data(port
);
548 priv
->chiptype
= CT_CA42V2
;
553 static int cypress_port_remove(struct usb_serial_port
*port
)
555 struct cypress_private
*priv
;
557 priv
= usb_get_serial_port_data(port
);
559 kfifo_free(&priv
->write_fifo
);
565 static int cypress_open(struct tty_struct
*tty
, struct usb_serial_port
*port
)
567 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
568 struct usb_serial
*serial
= port
->serial
;
572 if (!priv
->comm_is_ok
)
575 /* clear halts before open */
576 usb_clear_halt(serial
->dev
, 0x81);
577 usb_clear_halt(serial
->dev
, 0x02);
579 spin_lock_irqsave(&priv
->lock
, flags
);
580 /* reset read/write statistics */
585 spin_unlock_irqrestore(&priv
->lock
, flags
);
591 cypress_set_termios(tty
, port
, &priv
->tmp_termios
);
593 /* setup the port and start reading from the device */
594 if (!port
->interrupt_in_urb
) {
595 dev_err(&port
->dev
, "%s - interrupt_in_urb is empty!\n",
600 usb_fill_int_urb(port
->interrupt_in_urb
, serial
->dev
,
601 usb_rcvintpipe(serial
->dev
, port
->interrupt_in_endpointAddress
),
602 port
->interrupt_in_urb
->transfer_buffer
,
603 port
->interrupt_in_urb
->transfer_buffer_length
,
604 cypress_read_int_callback
, port
, priv
->read_urb_interval
);
605 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
609 "%s - failed submitting read urb, error %d\n",
611 cypress_set_dead(port
);
613 port
->port
.drain_delay
= 256;
617 static void cypress_dtr_rts(struct usb_serial_port
*port
, int on
)
619 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
620 /* drop dtr and rts */
621 spin_lock_irq(&priv
->lock
);
623 priv
->line_control
= 0;
625 priv
->line_control
= CONTROL_DTR
| CONTROL_RTS
;
627 spin_unlock_irq(&priv
->lock
);
628 cypress_write(NULL
, port
, NULL
, 0);
631 static void cypress_close(struct usb_serial_port
*port
)
633 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
636 /* writing is potentially harmful, lock must be taken */
637 mutex_lock(&port
->serial
->disc_mutex
);
638 if (port
->serial
->disconnected
) {
639 mutex_unlock(&port
->serial
->disc_mutex
);
642 spin_lock_irqsave(&priv
->lock
, flags
);
643 kfifo_reset_out(&priv
->write_fifo
);
644 spin_unlock_irqrestore(&priv
->lock
, flags
);
646 dev_dbg(&port
->dev
, "%s - stopping urbs\n", __func__
);
647 usb_kill_urb(port
->interrupt_in_urb
);
648 usb_kill_urb(port
->interrupt_out_urb
);
651 dev_info(&port
->dev
, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
652 priv
->bytes_in
, priv
->bytes_out
, priv
->cmd_count
);
653 mutex_unlock(&port
->serial
->disc_mutex
);
654 } /* cypress_close */
657 static int cypress_write(struct tty_struct
*tty
, struct usb_serial_port
*port
,
658 const unsigned char *buf
, int count
)
660 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
662 dev_dbg(&port
->dev
, "%s - port %d, %d bytes\n", __func__
, port
->number
, count
);
664 /* line control commands, which need to be executed immediately,
665 are not put into the buffer for obvious reasons.
667 if (priv
->cmd_ctrl
) {
675 count
= kfifo_in_locked(&priv
->write_fifo
, buf
, count
, &priv
->lock
);
681 } /* cypress_write */
684 static void cypress_send(struct usb_serial_port
*port
)
686 int count
= 0, result
, offset
, actual_size
;
687 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
688 struct device
*dev
= &port
->dev
;
691 if (!priv
->comm_is_ok
)
694 dev_dbg(dev
, "%s - interrupt out size is %d\n", __func__
,
695 port
->interrupt_out_size
);
697 spin_lock_irqsave(&priv
->lock
, flags
);
698 if (priv
->write_urb_in_use
) {
699 dev_dbg(dev
, "%s - can't write, urb in use\n", __func__
);
700 spin_unlock_irqrestore(&priv
->lock
, flags
);
703 spin_unlock_irqrestore(&priv
->lock
, flags
);
706 memset(port
->interrupt_out_urb
->transfer_buffer
, 0,
707 port
->interrupt_out_size
);
709 spin_lock_irqsave(&priv
->lock
, flags
);
710 switch (priv
->pkt_fmt
) {
712 case packet_format_1
:
713 /* this is for the CY7C64013... */
715 port
->interrupt_out_buffer
[0] = priv
->line_control
;
717 case packet_format_2
:
718 /* this is for the CY7C63743... */
720 port
->interrupt_out_buffer
[0] = priv
->line_control
;
724 if (priv
->line_control
& CONTROL_RESET
)
725 priv
->line_control
&= ~CONTROL_RESET
;
727 if (priv
->cmd_ctrl
) {
729 dev_dbg(dev
, "%s - line control command being issued\n", __func__
);
730 spin_unlock_irqrestore(&priv
->lock
, flags
);
733 spin_unlock_irqrestore(&priv
->lock
, flags
);
735 count
= kfifo_out_locked(&priv
->write_fifo
,
736 &port
->interrupt_out_buffer
[offset
],
737 port
->interrupt_out_size
- offset
,
742 switch (priv
->pkt_fmt
) {
744 case packet_format_1
:
745 port
->interrupt_out_buffer
[1] = count
;
747 case packet_format_2
:
748 port
->interrupt_out_buffer
[0] |= count
;
751 dev_dbg(dev
, "%s - count is %d\n", __func__
, count
);
754 spin_lock_irqsave(&priv
->lock
, flags
);
755 priv
->write_urb_in_use
= 1;
756 spin_unlock_irqrestore(&priv
->lock
, flags
);
761 actual_size
= count
+
762 (priv
->pkt_fmt
== packet_format_1
? 2 : 1);
764 usb_serial_debug_data(dev
, __func__
, port
->interrupt_out_size
,
765 port
->interrupt_out_urb
->transfer_buffer
);
767 usb_fill_int_urb(port
->interrupt_out_urb
, port
->serial
->dev
,
768 usb_sndintpipe(port
->serial
->dev
, port
->interrupt_out_endpointAddress
),
769 port
->interrupt_out_buffer
, port
->interrupt_out_size
,
770 cypress_write_int_callback
, port
, priv
->write_urb_interval
);
771 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
773 dev_err_console(port
,
774 "%s - failed submitting write urb, error %d\n",
776 priv
->write_urb_in_use
= 0;
777 cypress_set_dead(port
);
780 spin_lock_irqsave(&priv
->lock
, flags
);
784 /* do not count the line control and size bytes */
785 priv
->bytes_out
+= count
;
786 spin_unlock_irqrestore(&priv
->lock
, flags
);
788 usb_serial_port_softint(port
);
792 /* returns how much space is available in the soft buffer */
793 static int cypress_write_room(struct tty_struct
*tty
)
795 struct usb_serial_port
*port
= tty
->driver_data
;
796 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
800 spin_lock_irqsave(&priv
->lock
, flags
);
801 room
= kfifo_avail(&priv
->write_fifo
);
802 spin_unlock_irqrestore(&priv
->lock
, flags
);
804 dev_dbg(&port
->dev
, "%s - returns %d\n", __func__
, room
);
809 static int cypress_tiocmget(struct tty_struct
*tty
)
811 struct usb_serial_port
*port
= tty
->driver_data
;
812 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
813 __u8 status
, control
;
814 unsigned int result
= 0;
817 spin_lock_irqsave(&priv
->lock
, flags
);
818 control
= priv
->line_control
;
819 status
= priv
->current_status
;
820 spin_unlock_irqrestore(&priv
->lock
, flags
);
822 result
= ((control
& CONTROL_DTR
) ? TIOCM_DTR
: 0)
823 | ((control
& CONTROL_RTS
) ? TIOCM_RTS
: 0)
824 | ((status
& UART_CTS
) ? TIOCM_CTS
: 0)
825 | ((status
& UART_DSR
) ? TIOCM_DSR
: 0)
826 | ((status
& UART_RI
) ? TIOCM_RI
: 0)
827 | ((status
& UART_CD
) ? TIOCM_CD
: 0);
829 dev_dbg(&port
->dev
, "%s - result = %x\n", __func__
, result
);
835 static int cypress_tiocmset(struct tty_struct
*tty
,
836 unsigned int set
, unsigned int clear
)
838 struct usb_serial_port
*port
= tty
->driver_data
;
839 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
842 spin_lock_irqsave(&priv
->lock
, flags
);
844 priv
->line_control
|= CONTROL_RTS
;
846 priv
->line_control
|= CONTROL_DTR
;
847 if (clear
& TIOCM_RTS
)
848 priv
->line_control
&= ~CONTROL_RTS
;
849 if (clear
& TIOCM_DTR
)
850 priv
->line_control
&= ~CONTROL_DTR
;
852 spin_unlock_irqrestore(&priv
->lock
, flags
);
854 return cypress_write(tty
, port
, NULL
, 0);
858 static int cypress_ioctl(struct tty_struct
*tty
,
859 unsigned int cmd
, unsigned long arg
)
861 struct usb_serial_port
*port
= tty
->driver_data
;
862 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
864 dev_dbg(&port
->dev
, "%s - port %d, cmd 0x%.4x\n", __func__
, port
->number
, cmd
);
867 /* This code comes from drivers/char/serial.c and ftdi_sio.c */
870 interruptible_sleep_on(&port
->delta_msr_wait
);
871 /* see if a signal did it */
872 if (signal_pending(current
))
875 if (port
->serial
->disconnected
)
879 char diff
= priv
->diff_status
;
881 return -EIO
; /* no change => error */
883 /* consume all events */
884 priv
->diff_status
= 0;
886 /* return 0 if caller wanted to know about
888 if (((arg
& TIOCM_RNG
) && (diff
& UART_RI
)) ||
889 ((arg
& TIOCM_DSR
) && (diff
& UART_DSR
)) ||
890 ((arg
& TIOCM_CD
) && (diff
& UART_CD
)) ||
891 ((arg
& TIOCM_CTS
) && (diff
& UART_CTS
)))
893 /* otherwise caller can't care less about what
894 * happened, and so we continue to wait for
903 dev_dbg(&port
->dev
, "%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h\n", __func__
, cmd
);
905 } /* cypress_ioctl */
908 static void cypress_set_termios(struct tty_struct
*tty
,
909 struct usb_serial_port
*port
, struct ktermios
*old_termios
)
911 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
912 struct device
*dev
= &port
->dev
;
913 int data_bits
, stop_bits
, parity_type
, parity_enable
;
914 unsigned cflag
, iflag
;
919 spin_lock_irqsave(&priv
->lock
, flags
);
920 /* We can't clean this one up as we don't know the device type
922 if (!priv
->termios_initialized
) {
923 if (priv
->chiptype
== CT_EARTHMATE
) {
924 tty
->termios
= tty_std_termios
;
925 tty
->termios
.c_cflag
= B4800
| CS8
| CREAD
| HUPCL
|
927 tty
->termios
.c_ispeed
= 4800;
928 tty
->termios
.c_ospeed
= 4800;
929 } else if (priv
->chiptype
== CT_CYPHIDCOM
) {
930 tty
->termios
= tty_std_termios
;
931 tty
->termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
933 tty
->termios
.c_ispeed
= 9600;
934 tty
->termios
.c_ospeed
= 9600;
935 } else if (priv
->chiptype
== CT_CA42V2
) {
936 tty
->termios
= tty_std_termios
;
937 tty
->termios
.c_cflag
= B9600
| CS8
| CREAD
| HUPCL
|
939 tty
->termios
.c_ispeed
= 9600;
940 tty
->termios
.c_ospeed
= 9600;
942 priv
->termios_initialized
= 1;
944 spin_unlock_irqrestore(&priv
->lock
, flags
);
946 /* Unsupported features need clearing */
947 tty
->termios
.c_cflag
&= ~(CMSPAR
|CRTSCTS
);
949 cflag
= tty
->termios
.c_cflag
;
950 iflag
= tty
->termios
.c_iflag
;
952 /* check if there are new settings */
954 spin_lock_irqsave(&priv
->lock
, flags
);
955 priv
->tmp_termios
= tty
->termios
;
956 spin_unlock_irqrestore(&priv
->lock
, flags
);
959 /* set number of data bits, parity, stop bits */
960 /* when parity is disabled the parity type bit is ignored */
962 /* 1 means 2 stop bits, 0 means 1 stop bit */
963 stop_bits
= cflag
& CSTOPB
? 1 : 0;
965 if (cflag
& PARENB
) {
967 /* 1 means odd parity, 0 means even parity */
968 parity_type
= cflag
& PARODD
? 1 : 0;
970 parity_enable
= parity_type
= 0;
972 switch (cflag
& CSIZE
) {
986 dev_err(dev
, "%s - CSIZE was set, but not CS5-CS8\n", __func__
);
989 spin_lock_irqsave(&priv
->lock
, flags
);
990 oldlines
= priv
->line_control
;
991 if ((cflag
& CBAUD
) == B0
) {
992 /* drop dtr and rts */
993 dev_dbg(dev
, "%s - dropping the lines, baud rate 0bps\n", __func__
);
994 priv
->line_control
&= ~(CONTROL_DTR
| CONTROL_RTS
);
996 priv
->line_control
= (CONTROL_DTR
| CONTROL_RTS
);
997 spin_unlock_irqrestore(&priv
->lock
, flags
);
999 dev_dbg(dev
, "%s - sending %d stop_bits, %d parity_enable, %d parity_type, %d data_bits (+5)\n",
1000 __func__
, stop_bits
, parity_enable
, parity_type
, data_bits
);
1002 cypress_serial_control(tty
, port
, tty_get_baud_rate(tty
),
1003 data_bits
, stop_bits
,
1004 parity_enable
, parity_type
,
1005 0, CYPRESS_SET_CONFIG
);
1007 /* we perform a CYPRESS_GET_CONFIG so that the current settings are
1008 * filled into the private structure this should confirm that all is
1009 * working if it returns what we just set */
1010 cypress_serial_control(tty
, port
, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG
);
1012 /* Here we can define custom tty settings for devices; the main tty
1013 * termios flag base comes from empeg.c */
1015 spin_lock_irqsave(&priv
->lock
, flags
);
1016 if (priv
->chiptype
== CT_EARTHMATE
&& priv
->baud_rate
== 4800) {
1017 dev_dbg(dev
, "Using custom termios settings for a baud rate of 4800bps.\n");
1018 /* define custom termios settings for NMEA protocol */
1020 tty
->termios
.c_iflag
/* input modes - */
1021 &= ~(IGNBRK
/* disable ignore break */
1022 | BRKINT
/* disable break causes interrupt */
1023 | PARMRK
/* disable mark parity errors */
1024 | ISTRIP
/* disable clear high bit of input char */
1025 | INLCR
/* disable translate NL to CR */
1026 | IGNCR
/* disable ignore CR */
1027 | ICRNL
/* disable translate CR to NL */
1028 | IXON
); /* disable enable XON/XOFF flow control */
1030 tty
->termios
.c_oflag
/* output modes */
1031 &= ~OPOST
; /* disable postprocess output char */
1033 tty
->termios
.c_lflag
/* line discipline modes */
1034 &= ~(ECHO
/* disable echo input characters */
1035 | ECHONL
/* disable echo new line */
1036 | ICANON
/* disable erase, kill, werase, and rprnt
1037 special characters */
1038 | ISIG
/* disable interrupt, quit, and suspend
1039 special characters */
1040 | IEXTEN
); /* disable non-POSIX special characters */
1041 } /* CT_CYPHIDCOM: Application should handle this for device */
1043 linechange
= (priv
->line_control
!= oldlines
);
1044 spin_unlock_irqrestore(&priv
->lock
, flags
);
1046 /* if necessary, set lines */
1049 cypress_write(tty
, port
, NULL
, 0);
1051 } /* cypress_set_termios */
1054 /* returns amount of data still left in soft buffer */
1055 static int cypress_chars_in_buffer(struct tty_struct
*tty
)
1057 struct usb_serial_port
*port
= tty
->driver_data
;
1058 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1060 unsigned long flags
;
1062 spin_lock_irqsave(&priv
->lock
, flags
);
1063 chars
= kfifo_len(&priv
->write_fifo
);
1064 spin_unlock_irqrestore(&priv
->lock
, flags
);
1066 dev_dbg(&port
->dev
, "%s - returns %d\n", __func__
, chars
);
1071 static void cypress_throttle(struct tty_struct
*tty
)
1073 struct usb_serial_port
*port
= tty
->driver_data
;
1074 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1076 spin_lock_irq(&priv
->lock
);
1077 priv
->rx_flags
= THROTTLED
;
1078 spin_unlock_irq(&priv
->lock
);
1082 static void cypress_unthrottle(struct tty_struct
*tty
)
1084 struct usb_serial_port
*port
= tty
->driver_data
;
1085 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1086 int actually_throttled
, result
;
1088 spin_lock_irq(&priv
->lock
);
1089 actually_throttled
= priv
->rx_flags
& ACTUALLY_THROTTLED
;
1091 spin_unlock_irq(&priv
->lock
);
1093 if (!priv
->comm_is_ok
)
1096 if (actually_throttled
) {
1097 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_KERNEL
);
1099 dev_err(&port
->dev
, "%s - failed submitting read urb, "
1100 "error %d\n", __func__
, result
);
1101 cypress_set_dead(port
);
1107 static void cypress_read_int_callback(struct urb
*urb
)
1109 struct usb_serial_port
*port
= urb
->context
;
1110 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1111 struct device
*dev
= &urb
->dev
->dev
;
1112 struct tty_struct
*tty
;
1113 unsigned char *data
= urb
->transfer_buffer
;
1114 unsigned long flags
;
1115 char tty_flag
= TTY_NORMAL
;
1120 int status
= urb
->status
;
1123 case 0: /* success */
1128 /* precursor to disconnect so just go away */
1131 /* Can't call usb_clear_halt while in_interrupt */
1134 /* something ugly is going on... */
1135 dev_err(dev
, "%s - unexpected nonzero read status received: %d\n",
1137 cypress_set_dead(port
);
1141 spin_lock_irqsave(&priv
->lock
, flags
);
1142 if (priv
->rx_flags
& THROTTLED
) {
1143 dev_dbg(dev
, "%s - now throttling\n", __func__
);
1144 priv
->rx_flags
|= ACTUALLY_THROTTLED
;
1145 spin_unlock_irqrestore(&priv
->lock
, flags
);
1148 spin_unlock_irqrestore(&priv
->lock
, flags
);
1150 tty
= tty_port_tty_get(&port
->port
);
1152 dev_dbg(dev
, "%s - bad tty pointer - exiting\n", __func__
);
1156 spin_lock_irqsave(&priv
->lock
, flags
);
1157 result
= urb
->actual_length
;
1158 switch (priv
->pkt_fmt
) {
1160 case packet_format_1
:
1161 /* This is for the CY7C64013... */
1162 priv
->current_status
= data
[0] & 0xF8;
1163 bytes
= data
[1] + 2;
1168 case packet_format_2
:
1169 /* This is for the CY7C63743... */
1170 priv
->current_status
= data
[0] & 0xF8;
1171 bytes
= (data
[0] & 0x07) + 1;
1177 spin_unlock_irqrestore(&priv
->lock
, flags
);
1178 if (result
< bytes
) {
1180 "%s - wrong packet size - received %d bytes but packet said %d bytes\n",
1181 __func__
, result
, bytes
);
1185 usb_serial_debug_data(&port
->dev
, __func__
, urb
->actual_length
, data
);
1187 spin_lock_irqsave(&priv
->lock
, flags
);
1188 /* check to see if status has changed */
1189 if (priv
->current_status
!= priv
->prev_status
) {
1190 priv
->diff_status
|= priv
->current_status
^
1192 wake_up_interruptible(&port
->delta_msr_wait
);
1193 priv
->prev_status
= priv
->current_status
;
1195 spin_unlock_irqrestore(&priv
->lock
, flags
);
1197 /* hangup, as defined in acm.c... this might be a bad place for it
1199 if (tty
&& !(tty
->termios
.c_cflag
& CLOCAL
) &&
1200 !(priv
->current_status
& UART_CD
)) {
1201 dev_dbg(dev
, "%s - calling hangup\n", __func__
);
1206 /* There is one error bit... I'm assuming it is a parity error
1207 * indicator as the generic firmware will set this bit to 1 if a
1208 * parity error occurs.
1209 * I can not find reference to any other error events. */
1210 spin_lock_irqsave(&priv
->lock
, flags
);
1211 if (priv
->current_status
& CYP_ERROR
) {
1212 spin_unlock_irqrestore(&priv
->lock
, flags
);
1213 tty_flag
= TTY_PARITY
;
1214 dev_dbg(dev
, "%s - Parity Error detected\n", __func__
);
1216 spin_unlock_irqrestore(&priv
->lock
, flags
);
1218 /* process read if there is data other than line status */
1220 tty_insert_flip_string_fixed_flag(&port
->port
, data
+ i
,
1221 tty_flag
, bytes
- i
);
1222 tty_flip_buffer_push(&port
->port
);
1225 spin_lock_irqsave(&priv
->lock
, flags
);
1226 /* control and status byte(s) are also counted */
1227 priv
->bytes_in
+= bytes
;
1228 spin_unlock_irqrestore(&priv
->lock
, flags
);
1233 /* Continue trying to always read */
1235 if (priv
->comm_is_ok
) {
1236 usb_fill_int_urb(port
->interrupt_in_urb
, port
->serial
->dev
,
1237 usb_rcvintpipe(port
->serial
->dev
,
1238 port
->interrupt_in_endpointAddress
),
1239 port
->interrupt_in_urb
->transfer_buffer
,
1240 port
->interrupt_in_urb
->transfer_buffer_length
,
1241 cypress_read_int_callback
, port
,
1242 priv
->read_urb_interval
);
1243 result
= usb_submit_urb(port
->interrupt_in_urb
, GFP_ATOMIC
);
1244 if (result
&& result
!= -EPERM
) {
1245 dev_err(dev
, "%s - failed resubmitting read urb, error %d\n",
1247 cypress_set_dead(port
);
1250 } /* cypress_read_int_callback */
1253 static void cypress_write_int_callback(struct urb
*urb
)
1255 struct usb_serial_port
*port
= urb
->context
;
1256 struct cypress_private
*priv
= usb_get_serial_port_data(port
);
1257 struct device
*dev
= &urb
->dev
->dev
;
1259 int status
= urb
->status
;
1268 /* this urb is terminated, clean up */
1269 dev_dbg(dev
, "%s - urb shutting down with status: %d\n",
1271 priv
->write_urb_in_use
= 0;
1273 case -EPIPE
: /* no break needed; clear halt and resubmit */
1274 if (!priv
->comm_is_ok
)
1276 usb_clear_halt(port
->serial
->dev
, 0x02);
1277 /* error in the urb, so we have to resubmit it */
1278 dev_dbg(dev
, "%s - nonzero write bulk status received: %d\n",
1280 port
->interrupt_out_urb
->transfer_buffer_length
= 1;
1281 result
= usb_submit_urb(port
->interrupt_out_urb
, GFP_ATOMIC
);
1284 dev_err(dev
, "%s - failed resubmitting write urb, error %d\n",
1286 cypress_set_dead(port
);
1289 dev_err(dev
, "%s - unexpected nonzero write status received: %d\n",
1291 cypress_set_dead(port
);
1294 priv
->write_urb_in_use
= 0;
1296 /* send any buffered data */
1300 module_usb_serial_driver(serial_drivers
, id_table_combined
);
1302 MODULE_AUTHOR(DRIVER_AUTHOR
);
1303 MODULE_DESCRIPTION(DRIVER_DESC
);
1304 MODULE_LICENSE("GPL");
1306 module_param(stats
, bool, S_IRUGO
| S_IWUSR
);
1307 MODULE_PARM_DESC(stats
, "Enable statistics or not");
1308 module_param(interval
, int, S_IRUGO
| S_IWUSR
);
1309 MODULE_PARM_DESC(interval
, "Overrides interrupt interval");
1310 module_param(unstable_bauds
, bool, S_IRUGO
| S_IWUSR
);
1311 MODULE_PARM_DESC(unstable_bauds
, "Allow unstable baud rates");