2005-04-17 05:20:36 +07:00
|
|
|
/*
|
|
|
|
* USB Cypress M8 driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2004
|
2008-07-22 17:10:36 +07:00
|
|
|
* Lonnie Mendez (dignome@gmail.com)
|
2005-04-17 05:20:36 +07:00
|
|
|
* Copyright (C) 2003,2004
|
|
|
|
* Neil Whelchel (koyama@firstlight.net)
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or modify
|
|
|
|
* it under the terms of the GNU General Public License as published by
|
|
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
|
|
* (at your option) any later version.
|
|
|
|
*
|
2008-07-22 17:10:36 +07:00
|
|
|
* See Documentation/usb/usb-serial.txt for more information on using this
|
|
|
|
* driver
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* See http://geocities.com/i0xox0i for information on this driver and the
|
|
|
|
* earthmate usb device.
|
|
|
|
*
|
2005-05-04 05:02:20 +07:00
|
|
|
* Lonnie Mendez <dignome@gmail.com>
|
|
|
|
* 4-29-2005
|
2008-07-22 17:10:36 +07:00
|
|
|
* Fixed problem where setting or retreiving the serial config would fail
|
|
|
|
* with EPIPE. Removed CRTS toggling so the driver behaves more like
|
|
|
|
* other usbserial adapters. Issued new interval of 1ms instead of the
|
|
|
|
* default 10ms. As a result, transfer speed has been substantially
|
|
|
|
* increased from avg. 850bps to avg. 3300bps. initial termios has also
|
|
|
|
* been modified. Cleaned up code and formatting issues so it is more
|
|
|
|
* readable. Replaced the C++ style comments.
|
2005-04-17 05:20:36 +07:00
|
|
|
*
|
|
|
|
* Lonnie Mendez <dignome@gmail.com>
|
|
|
|
* 12-15-2004
|
|
|
|
* Incorporated write buffering from pl2303 driver. Fixed bug with line
|
|
|
|
* handling so both lines are raised in cypress_open. (was dropping rts)
|
|
|
|
* Various code cleanups made as well along with other misc bug fixes.
|
|
|
|
*
|
|
|
|
* Lonnie Mendez <dignome@gmail.com>
|
|
|
|
* 04-10-2004
|
|
|
|
* Driver modified to support dynamic line settings. Various improvments
|
|
|
|
* and features.
|
|
|
|
*
|
|
|
|
* Neil Whelchel
|
|
|
|
* 10-2003
|
|
|
|
* Driver first released.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
/* Thanks to Neil Whelchel for writing the first cypress m8 implementation
|
|
|
|
for linux. */
|
2005-04-17 05:20:36 +07:00
|
|
|
/* Thanks to cypress for providing references for the hid reports. */
|
|
|
|
/* Thanks to Jiang Zhang for providing links and for general help. */
|
2008-07-22 17:10:36 +07:00
|
|
|
/* Code originates and was built up from ftdi_sio, belkin, pl2303 and others.*/
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
#include <linux/kernel.h>
|
|
|
|
#include <linux/errno.h>
|
|
|
|
#include <linux/init.h>
|
|
|
|
#include <linux/slab.h>
|
|
|
|
#include <linux/tty.h>
|
|
|
|
#include <linux/tty_driver.h>
|
|
|
|
#include <linux/tty_flip.h>
|
|
|
|
#include <linux/module.h>
|
|
|
|
#include <linux/moduleparam.h>
|
|
|
|
#include <linux/spinlock.h>
|
|
|
|
#include <linux/usb.h>
|
2006-07-12 11:22:58 +07:00
|
|
|
#include <linux/usb/serial.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
#include <linux/serial.h>
|
|
|
|
#include <linux/delay.h>
|
2008-07-22 17:10:36 +07:00
|
|
|
#include <linux/uaccess.h>
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
#include "cypress_m8.h"
|
|
|
|
|
|
|
|
|
2009-12-19 04:33:01 +07:00
|
|
|
static int debug;
|
2005-04-17 05:20:36 +07:00
|
|
|
static int stats;
|
2005-05-04 05:02:20 +07:00
|
|
|
static int interval;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*
|
|
|
|
* Version Information
|
|
|
|
*/
|
2005-05-04 05:02:20 +07:00
|
|
|
#define DRIVER_VERSION "v1.09"
|
2005-04-17 05:20:36 +07:00
|
|
|
#define DRIVER_AUTHOR "Lonnie Mendez <dignome@gmail.com>, Neil Whelchel <koyama@firstlight.net>"
|
|
|
|
#define DRIVER_DESC "Cypress USB to Serial Driver"
|
|
|
|
|
|
|
|
/* write buffer size defines */
|
|
|
|
#define CYPRESS_BUF_SIZE 1024
|
|
|
|
#define CYPRESS_CLOSING_WAIT (30*HZ)
|
|
|
|
|
|
|
|
static struct usb_device_id id_table_earthmate [] = {
|
|
|
|
{ USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
|
2005-05-11 05:09:52 +07:00
|
|
|
{ USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
|
2005-04-17 05:20:36 +07:00
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
|
|
|
static struct usb_device_id id_table_cyphidcomrs232 [] = {
|
|
|
|
{ USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
|
2008-03-05 06:25:10 +07:00
|
|
|
{ USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) },
|
2005-04-17 05:20:36 +07:00
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2006-03-01 23:45:24 +07:00
|
|
|
static struct usb_device_id id_table_nokiaca42v2 [] = {
|
|
|
|
{ USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
static struct usb_device_id id_table_combined [] = {
|
|
|
|
{ USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB) },
|
2005-05-11 05:09:52 +07:00
|
|
|
{ USB_DEVICE(VENDOR_ID_DELORME, PRODUCT_ID_EARTHMATEUSB_LT20) },
|
2005-04-17 05:20:36 +07:00
|
|
|
{ USB_DEVICE(VENDOR_ID_CYPRESS, PRODUCT_ID_CYPHIDCOM) },
|
2008-03-05 06:25:10 +07:00
|
|
|
{ USB_DEVICE(VENDOR_ID_POWERCOM, PRODUCT_ID_UPS) },
|
2006-03-01 23:45:24 +07:00
|
|
|
{ USB_DEVICE(VENDOR_ID_DAZZLE, PRODUCT_ID_CA42) },
|
2005-04-17 05:20:36 +07:00
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
MODULE_DEVICE_TABLE(usb, id_table_combined);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
static struct usb_driver cypress_driver = {
|
|
|
|
.name = "cypress",
|
|
|
|
.probe = usb_serial_probe,
|
|
|
|
.disconnect = usb_serial_disconnect,
|
|
|
|
.id_table = id_table_combined,
|
2005-11-17 04:41:28 +07:00
|
|
|
.no_dynamic_id = 1,
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
2008-02-11 09:23:19 +07:00
|
|
|
enum packet_format {
|
|
|
|
packet_format_1, /* b0:status, b1:payload count */
|
|
|
|
packet_format_2 /* b0[7:3]:status, b0[2:0]:payload count */
|
|
|
|
};
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private {
|
|
|
|
spinlock_t lock; /* private lock */
|
|
|
|
int chiptype; /* identifier of device, for quirks/etc */
|
|
|
|
int bytes_in; /* used for statistics */
|
|
|
|
int bytes_out; /* used for statistics */
|
|
|
|
int cmd_count; /* used for statistics */
|
|
|
|
int cmd_ctrl; /* always set this to 1 before issuing a command */
|
|
|
|
struct cypress_buf *buf; /* write buffer */
|
|
|
|
int write_urb_in_use; /* write urb in use indicator */
|
2006-08-30 10:06:59 +07:00
|
|
|
int write_urb_interval; /* interval to use for write urb */
|
|
|
|
int read_urb_interval; /* interval to use for read urb */
|
2006-08-30 10:07:11 +07:00
|
|
|
int comm_is_ok; /* true if communication is (still) ok */
|
2005-04-17 05:20:36 +07:00
|
|
|
int termios_initialized;
|
|
|
|
__u8 line_control; /* holds dtr / rts value */
|
|
|
|
__u8 current_status; /* received from last read - info on dsr,cts,cd,ri,etc */
|
|
|
|
__u8 current_config; /* stores the current configuration byte */
|
|
|
|
__u8 rx_flags; /* throttling - used from whiteheat/ftdi_sio */
|
2008-02-11 09:23:19 +07:00
|
|
|
enum packet_format pkt_fmt; /* format to use for packet send / receive */
|
2008-02-11 09:23:24 +07:00
|
|
|
int get_cfg_unsafe; /* If true, the CYPRESS_GET_CONFIG is unsafe */
|
2008-07-22 17:10:36 +07:00
|
|
|
int baud_rate; /* stores current baud rate in
|
|
|
|
integer form */
|
2005-04-17 05:20:36 +07:00
|
|
|
int isthrottled; /* if throttled, discard reads */
|
|
|
|
wait_queue_head_t delta_msr_wait; /* used for TIOCMIWAIT */
|
|
|
|
char prev_status, diff_status; /* used for TIOCMIWAIT */
|
2008-07-22 17:10:36 +07:00
|
|
|
/* we pass a pointer to this as the arguement sent to
|
|
|
|
cypress_set_termios old_termios */
|
2006-12-08 17:38:45 +07:00
|
|
|
struct ktermios tmp_termios; /* stores the old termios settings */
|
2005-04-17 05:20:36 +07:00
|
|
|
};
|
|
|
|
|
|
|
|
/* write buffer structure */
|
|
|
|
struct cypress_buf {
|
|
|
|
unsigned int buf_size;
|
|
|
|
char *buf_buf;
|
|
|
|
char *buf_get;
|
|
|
|
char *buf_put;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* function prototypes for the Cypress USB to serial device */
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_earthmate_startup(struct usb_serial *serial);
|
|
|
|
static int cypress_hidcom_startup(struct usb_serial *serial);
|
|
|
|
static int cypress_ca42v2_startup(struct usb_serial *serial);
|
2009-06-02 22:53:55 +07:00
|
|
|
static void cypress_release(struct usb_serial *serial);
|
2009-09-20 03:13:26 +07:00
|
|
|
static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port);
|
2009-06-11 18:26:29 +07:00
|
|
|
static void cypress_close(struct usb_serial_port *port);
|
|
|
|
static void cypress_dtr_rts(struct usb_serial_port *port, int on);
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|
|
|
const unsigned char *buf, int count);
|
|
|
|
static void cypress_send(struct usb_serial_port *port);
|
|
|
|
static int cypress_write_room(struct tty_struct *tty);
|
|
|
|
static int cypress_ioctl(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int cmd, unsigned long arg);
|
|
|
|
static void cypress_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old);
|
|
|
|
static int cypress_tiocmget(struct tty_struct *tty, struct file *file);
|
|
|
|
static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int set, unsigned int clear);
|
|
|
|
static int cypress_chars_in_buffer(struct tty_struct *tty);
|
|
|
|
static void cypress_throttle(struct tty_struct *tty);
|
|
|
|
static void cypress_unthrottle(struct tty_struct *tty);
|
|
|
|
static void cypress_set_dead(struct usb_serial_port *port);
|
|
|
|
static void cypress_read_int_callback(struct urb *urb);
|
|
|
|
static void cypress_write_int_callback(struct urb *urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
/* write buffer functions */
|
|
|
|
static struct cypress_buf *cypress_buf_alloc(unsigned int size);
|
2008-07-22 17:10:36 +07:00
|
|
|
static void cypress_buf_free(struct cypress_buf *cb);
|
|
|
|
static void cypress_buf_clear(struct cypress_buf *cb);
|
|
|
|
static unsigned int cypress_buf_data_avail(struct cypress_buf *cb);
|
|
|
|
static unsigned int cypress_buf_space_avail(struct cypress_buf *cb);
|
|
|
|
static unsigned int cypress_buf_put(struct cypress_buf *cb,
|
|
|
|
const char *buf, unsigned int count);
|
|
|
|
static unsigned int cypress_buf_get(struct cypress_buf *cb,
|
|
|
|
char *buf, unsigned int count);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
2005-06-21 11:15:16 +07:00
|
|
|
static struct usb_serial_driver cypress_earthmate_device = {
|
2005-06-21 11:15:16 +07:00
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2005-06-21 11:15:16 +07:00
|
|
|
.name = "earthmate",
|
2005-06-21 11:15:16 +07:00
|
|
|
},
|
2005-06-21 11:15:16 +07:00
|
|
|
.description = "DeLorme Earthmate USB",
|
2006-12-18 03:50:24 +07:00
|
|
|
.usb_driver = &cypress_driver,
|
2005-04-17 05:20:36 +07:00
|
|
|
.id_table = id_table_earthmate,
|
|
|
|
.num_ports = 1,
|
|
|
|
.attach = cypress_earthmate_startup,
|
2009-06-02 22:53:55 +07:00
|
|
|
.release = cypress_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
.open = cypress_open,
|
|
|
|
.close = cypress_close,
|
2009-06-11 18:26:29 +07:00
|
|
|
.dtr_rts = cypress_dtr_rts,
|
2005-04-17 05:20:36 +07:00
|
|
|
.write = cypress_write,
|
|
|
|
.write_room = cypress_write_room,
|
|
|
|
.ioctl = cypress_ioctl,
|
|
|
|
.set_termios = cypress_set_termios,
|
|
|
|
.tiocmget = cypress_tiocmget,
|
|
|
|
.tiocmset = cypress_tiocmset,
|
|
|
|
.chars_in_buffer = cypress_chars_in_buffer,
|
|
|
|
.throttle = cypress_throttle,
|
|
|
|
.unthrottle = cypress_unthrottle,
|
|
|
|
.read_int_callback = cypress_read_int_callback,
|
|
|
|
.write_int_callback = cypress_write_int_callback,
|
|
|
|
};
|
|
|
|
|
2005-06-21 11:15:16 +07:00
|
|
|
static struct usb_serial_driver cypress_hidcom_device = {
|
2005-06-21 11:15:16 +07:00
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2005-06-21 11:15:16 +07:00
|
|
|
.name = "cyphidcom",
|
2005-06-21 11:15:16 +07:00
|
|
|
},
|
2005-06-21 11:15:16 +07:00
|
|
|
.description = "HID->COM RS232 Adapter",
|
2006-12-18 03:50:24 +07:00
|
|
|
.usb_driver = &cypress_driver,
|
2005-04-17 05:20:36 +07:00
|
|
|
.id_table = id_table_cyphidcomrs232,
|
|
|
|
.num_ports = 1,
|
|
|
|
.attach = cypress_hidcom_startup,
|
2009-06-02 22:53:55 +07:00
|
|
|
.release = cypress_release,
|
2005-04-17 05:20:36 +07:00
|
|
|
.open = cypress_open,
|
|
|
|
.close = cypress_close,
|
2009-06-11 18:26:29 +07:00
|
|
|
.dtr_rts = cypress_dtr_rts,
|
2005-04-17 05:20:36 +07:00
|
|
|
.write = cypress_write,
|
|
|
|
.write_room = cypress_write_room,
|
|
|
|
.ioctl = cypress_ioctl,
|
|
|
|
.set_termios = cypress_set_termios,
|
|
|
|
.tiocmget = cypress_tiocmget,
|
|
|
|
.tiocmset = cypress_tiocmset,
|
|
|
|
.chars_in_buffer = cypress_chars_in_buffer,
|
|
|
|
.throttle = cypress_throttle,
|
|
|
|
.unthrottle = cypress_unthrottle,
|
|
|
|
.read_int_callback = cypress_read_int_callback,
|
|
|
|
.write_int_callback = cypress_write_int_callback,
|
|
|
|
};
|
|
|
|
|
2006-03-01 23:45:24 +07:00
|
|
|
static struct usb_serial_driver cypress_ca42v2_device = {
|
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2008-07-22 17:10:36 +07:00
|
|
|
.name = "nokiaca42v2",
|
2006-03-01 23:45:24 +07:00
|
|
|
},
|
|
|
|
.description = "Nokia CA-42 V2 Adapter",
|
2006-12-18 03:50:24 +07:00
|
|
|
.usb_driver = &cypress_driver,
|
2006-03-01 23:45:24 +07:00
|
|
|
.id_table = id_table_nokiaca42v2,
|
|
|
|
.num_ports = 1,
|
|
|
|
.attach = cypress_ca42v2_startup,
|
2009-06-02 22:53:55 +07:00
|
|
|
.release = cypress_release,
|
2006-03-01 23:45:24 +07:00
|
|
|
.open = cypress_open,
|
|
|
|
.close = cypress_close,
|
2009-06-11 18:26:29 +07:00
|
|
|
.dtr_rts = cypress_dtr_rts,
|
2006-03-01 23:45:24 +07:00
|
|
|
.write = cypress_write,
|
|
|
|
.write_room = cypress_write_room,
|
|
|
|
.ioctl = cypress_ioctl,
|
|
|
|
.set_termios = cypress_set_termios,
|
|
|
|
.tiocmget = cypress_tiocmget,
|
|
|
|
.tiocmset = cypress_tiocmset,
|
|
|
|
.chars_in_buffer = cypress_chars_in_buffer,
|
|
|
|
.throttle = cypress_throttle,
|
|
|
|
.unthrottle = cypress_unthrottle,
|
|
|
|
.read_int_callback = cypress_read_int_callback,
|
|
|
|
.write_int_callback = cypress_write_int_callback,
|
|
|
|
};
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Cypress serial helper functions
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
|
2008-03-11 04:59:28 +07:00
|
|
|
static int analyze_baud_rate(struct usb_serial_port *port, speed_t new_rate)
|
2008-02-11 09:23:32 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv;
|
|
|
|
priv = usb_get_serial_port_data(port);
|
|
|
|
|
|
|
|
/*
|
|
|
|
* The general purpose firmware for the Cypress M8 allows for
|
|
|
|
* a maximum speed of 57600bps (I have no idea whether DeLorme
|
|
|
|
* chose to use the general purpose firmware or not), if you
|
|
|
|
* need to modify this speed setting for your own project
|
|
|
|
* please add your own chiptype and modify the code likewise.
|
|
|
|
* The Cypress HID->COM device will work successfully up to
|
|
|
|
* 115200bps (but the actual throughput is around 3kBps).
|
|
|
|
*/
|
|
|
|
if (port->serial->dev->speed == USB_SPEED_LOW) {
|
|
|
|
/*
|
|
|
|
* Mike Isely <isely@pobox.com> 2-Feb-2008: The
|
|
|
|
* Cypress app note that describes this mechanism
|
|
|
|
* states the the low-speed part can't handle more
|
|
|
|
* than 800 bytes/sec, in which case 4800 baud is the
|
|
|
|
* safest speed for a part like that.
|
|
|
|
*/
|
|
|
|
if (new_rate > 4800) {
|
|
|
|
dbg("%s - failed setting baud rate, device incapable "
|
|
|
|
"speed %d", __func__, new_rate);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
switch (priv->chiptype) {
|
|
|
|
case CT_EARTHMATE:
|
|
|
|
if (new_rate <= 600) {
|
|
|
|
/* 300 and 600 baud rates are supported under
|
|
|
|
* the generic firmware, but are not used with
|
|
|
|
* NMEA and SiRF protocols */
|
|
|
|
dbg("%s - failed setting baud rate, unsupported speed "
|
|
|
|
"of %d on Earthmate GPS", __func__, new_rate);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
return new_rate;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-05-04 08:07:24 +07:00
|
|
|
/* This function can either set or retrieve the current serial line settings */
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_serial_control(struct tty_struct *tty,
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port, speed_t baud_rate, int data_bits,
|
|
|
|
int stop_bits, int parity_enable, int parity_type, int reset,
|
|
|
|
int cypress_request_type)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2005-05-04 05:02:20 +07:00
|
|
|
int new_baudrate = 0, retval = 0, tries = 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv;
|
2008-02-11 09:23:14 +07:00
|
|
|
__u8 feature_buffer[5];
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s", __func__);
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
priv = usb_get_serial_port_data(port);
|
|
|
|
|
2006-08-30 10:07:11 +07:00
|
|
|
if (!priv->comm_is_ok)
|
|
|
|
return -ENODEV;
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
switch (cypress_request_type) {
|
|
|
|
case CYPRESS_SET_CONFIG:
|
|
|
|
new_baudrate = priv->baud_rate;
|
|
|
|
/* 0 means 'Hang up' so doesn't change the true bit rate */
|
|
|
|
if (baud_rate == 0)
|
2008-02-11 09:23:32 +07:00
|
|
|
new_baudrate = priv->baud_rate;
|
2008-07-22 17:10:36 +07:00
|
|
|
/* Change of speed ? */
|
|
|
|
else if (baud_rate != priv->baud_rate) {
|
|
|
|
dbg("%s - baud rate is changing", __func__);
|
|
|
|
retval = analyze_baud_rate(port, baud_rate);
|
|
|
|
if (retval >= 0) {
|
|
|
|
new_baudrate = retval;
|
|
|
|
dbg("%s - New baud rate set to %d",
|
|
|
|
__func__, new_baudrate);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-07-22 17:10:36 +07:00
|
|
|
}
|
|
|
|
dbg("%s - baud rate is being sent as %d",
|
|
|
|
__func__, new_baudrate);
|
|
|
|
|
|
|
|
memset(feature_buffer, 0, sizeof(feature_buffer));
|
|
|
|
/* fill the feature_buffer with new configuration */
|
|
|
|
*((u_int32_t *)feature_buffer) = new_baudrate;
|
|
|
|
feature_buffer[4] |= data_bits; /* assign data bits in 2 bit space ( max 3 ) */
|
|
|
|
/* 1 bit gap */
|
|
|
|
feature_buffer[4] |= (stop_bits << 3); /* assign stop bits in 1 bit space */
|
|
|
|
feature_buffer[4] |= (parity_enable << 4); /* assign parity flag in 1 bit space */
|
|
|
|
feature_buffer[4] |= (parity_type << 5); /* assign parity type in 1 bit space */
|
|
|
|
/* 1 bit gap */
|
|
|
|
feature_buffer[4] |= (reset << 7); /* assign reset at end of byte, 1 bit space */
|
|
|
|
|
|
|
|
dbg("%s - device is being sent this feature report:",
|
|
|
|
__func__);
|
|
|
|
dbg("%s - %02X - %02X - %02X - %02X - %02X", __func__,
|
|
|
|
feature_buffer[0], feature_buffer[1],
|
|
|
|
feature_buffer[2], feature_buffer[3],
|
|
|
|
feature_buffer[4]);
|
|
|
|
|
|
|
|
do {
|
|
|
|
retval = usb_control_msg(port->serial->dev,
|
|
|
|
usb_sndctrlpipe(port->serial->dev, 0),
|
|
|
|
HID_REQ_SET_REPORT,
|
|
|
|
USB_DIR_OUT | USB_RECIP_INTERFACE | USB_TYPE_CLASS,
|
|
|
|
0x0300, 0, feature_buffer,
|
|
|
|
sizeof(feature_buffer), 500);
|
|
|
|
|
|
|
|
if (tries++ >= 3)
|
|
|
|
break;
|
|
|
|
|
|
|
|
} while (retval != sizeof(feature_buffer) &&
|
|
|
|
retval != -ENODEV);
|
|
|
|
|
|
|
|
if (retval != sizeof(feature_buffer)) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&port->dev, "%s - failed sending serial "
|
|
|
|
"line settings - %d\n", __func__, retval);
|
2008-07-22 17:10:36 +07:00
|
|
|
cypress_set_dead(port);
|
|
|
|
} else {
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->baud_rate = new_baudrate;
|
|
|
|
priv->current_config = feature_buffer[4];
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
/* If we asked for a speed change encode it */
|
|
|
|
if (baud_rate)
|
|
|
|
tty_encode_baud_rate(tty,
|
|
|
|
new_baudrate, new_baudrate);
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
case CYPRESS_GET_CONFIG:
|
|
|
|
if (priv->get_cfg_unsafe) {
|
|
|
|
/* Not implemented for this device,
|
|
|
|
and if we try to do it we're likely
|
|
|
|
to crash the hardware. */
|
|
|
|
return -ENOTTY;
|
|
|
|
}
|
|
|
|
dbg("%s - retreiving serial line settings", __func__);
|
|
|
|
/* set initial values in feature buffer */
|
|
|
|
memset(feature_buffer, 0, sizeof(feature_buffer));
|
|
|
|
|
|
|
|
do {
|
|
|
|
retval = usb_control_msg(port->serial->dev,
|
|
|
|
usb_rcvctrlpipe(port->serial->dev, 0),
|
|
|
|
HID_REQ_GET_REPORT,
|
|
|
|
USB_DIR_IN | USB_RECIP_INTERFACE | USB_TYPE_CLASS,
|
|
|
|
0x0300, 0, feature_buffer,
|
|
|
|
sizeof(feature_buffer), 500);
|
|
|
|
|
|
|
|
if (tries++ >= 3)
|
|
|
|
break;
|
|
|
|
} while (retval != sizeof(feature_buffer)
|
|
|
|
&& retval != -ENODEV);
|
|
|
|
|
|
|
|
if (retval != sizeof(feature_buffer)) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&port->dev, "%s - failed to retrieve serial "
|
|
|
|
"line settings - %d\n", __func__, retval);
|
2008-07-22 17:10:36 +07:00
|
|
|
cypress_set_dead(port);
|
|
|
|
return retval;
|
|
|
|
} else {
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
/* store the config in one byte, and later
|
|
|
|
use bit masks to check values */
|
|
|
|
priv->current_config = feature_buffer[4];
|
|
|
|
priv->baud_rate = *((u_int32_t *)feature_buffer);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-05-04 05:02:20 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
++priv->cmd_count;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
} /* cypress_serial_control */
|
|
|
|
|
|
|
|
|
2006-08-30 10:07:11 +07:00
|
|
|
static void cypress_set_dead(struct usb_serial_port *port)
|
|
|
|
{
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (!priv->comm_is_ok) {
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
priv->comm_is_ok = 0;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&port->dev, "cypress_m8 suspending failing port %d - "
|
|
|
|
"interval might be too short\n", port->number);
|
2006-08-30 10:07:11 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/*****************************************************************************
|
|
|
|
* Cypress serial driver functions
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
static int generic_startup(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv;
|
2006-08-30 10:06:59 +07:00
|
|
|
struct usb_serial_port *port = serial->port[0];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
priv = kzalloc(sizeof(struct cypress_private), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!priv)
|
|
|
|
return -ENOMEM;
|
|
|
|
|
2006-08-30 10:07:11 +07:00
|
|
|
priv->comm_is_ok = !0;
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_init(&priv->lock);
|
|
|
|
priv->buf = cypress_buf_alloc(CYPRESS_BUF_SIZE);
|
|
|
|
if (priv->buf == NULL) {
|
|
|
|
kfree(priv);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
init_waitqueue_head(&priv->delta_msr_wait);
|
2008-07-22 17:10:36 +07:00
|
|
|
|
|
|
|
usb_reset_configuration(serial->dev);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->cmd_ctrl = 0;
|
|
|
|
priv->line_control = 0;
|
|
|
|
priv->termios_initialized = 0;
|
|
|
|
priv->rx_flags = 0;
|
2008-02-11 09:23:19 +07:00
|
|
|
/* Default packet format setting is determined by packet size.
|
|
|
|
Anything with a size larger then 9 must have a separate
|
|
|
|
count field since the 3 bit count field is otherwise too
|
|
|
|
small. Otherwise we can use the slightly more compact
|
|
|
|
format. This is in accordance with the cypress_m8 serial
|
|
|
|
converter app note. */
|
2008-07-22 17:10:36 +07:00
|
|
|
if (port->interrupt_out_size > 9)
|
2008-02-11 09:23:19 +07:00
|
|
|
priv->pkt_fmt = packet_format_1;
|
2008-07-22 17:10:36 +07:00
|
|
|
else
|
2008-02-11 09:23:19 +07:00
|
|
|
priv->pkt_fmt = packet_format_2;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2006-08-30 10:06:59 +07:00
|
|
|
if (interval > 0) {
|
|
|
|
priv->write_urb_interval = interval;
|
|
|
|
priv->read_urb_interval = interval;
|
|
|
|
dbg("%s - port %d read & write intervals forced to %d",
|
2008-07-22 17:10:36 +07:00
|
|
|
__func__, port->number, interval);
|
2006-08-30 10:06:59 +07:00
|
|
|
} else {
|
|
|
|
priv->write_urb_interval = port->interrupt_out_urb->interval;
|
|
|
|
priv->read_urb_interval = port->interrupt_in_urb->interval;
|
|
|
|
dbg("%s - port %d intervals: read=%d write=%d",
|
2008-07-22 17:10:36 +07:00
|
|
|
__func__, port->number,
|
|
|
|
priv->read_urb_interval, priv->write_urb_interval);
|
2006-08-30 10:06:59 +07:00
|
|
|
}
|
|
|
|
usb_set_serial_port_data(port, priv);
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
return 0;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_earthmate_startup(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv;
|
2008-02-11 09:23:24 +07:00
|
|
|
struct usb_serial_port *port = serial->port[0];
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (generic_startup(serial)) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - Failed setting up port %d", __func__,
|
2008-02-11 09:23:24 +07:00
|
|
|
port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
2008-02-11 09:23:24 +07:00
|
|
|
priv = usb_get_serial_port_data(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->chiptype = CT_EARTHMATE;
|
2008-02-11 09:23:19 +07:00
|
|
|
/* All Earthmate devices use the separated-count packet
|
|
|
|
format! Idiotic. */
|
|
|
|
priv->pkt_fmt = packet_format_1;
|
2008-07-22 17:10:36 +07:00
|
|
|
if (serial->dev->descriptor.idProduct !=
|
|
|
|
cpu_to_le16(PRODUCT_ID_EARTHMATEUSB)) {
|
2008-02-11 09:23:24 +07:00
|
|
|
/* The old original USB Earthmate seemed able to
|
|
|
|
handle GET_CONFIG requests; everything they've
|
|
|
|
produced since that time crashes if this command is
|
|
|
|
attempted :-( */
|
|
|
|
dbg("%s - Marking this device as unsafe for GET_CONFIG "
|
|
|
|
"commands", __func__);
|
|
|
|
priv->get_cfg_unsafe = !0;
|
|
|
|
}
|
2005-07-13 05:21:31 +07:00
|
|
|
|
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
} /* cypress_earthmate_startup */
|
|
|
|
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_hidcom_startup(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
if (generic_startup(serial)) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - Failed setting up port %d", __func__,
|
2005-07-13 05:21:31 +07:00
|
|
|
serial->port[0]->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv = usb_get_serial_port_data(serial->port[0]);
|
|
|
|
priv->chiptype = CT_CYPHIDCOM;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
return 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
} /* cypress_hidcom_startup */
|
|
|
|
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_ca42v2_startup(struct usb_serial *serial)
|
2006-03-01 23:45:24 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s", __func__);
|
2006-03-01 23:45:24 +07:00
|
|
|
|
|
|
|
if (generic_startup(serial)) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - Failed setting up port %d", __func__,
|
2006-03-01 23:45:24 +07:00
|
|
|
serial->port[0]->number);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
priv = usb_get_serial_port_data(serial->port[0]);
|
|
|
|
priv->chiptype = CT_CA42V2;
|
|
|
|
|
|
|
|
return 0;
|
|
|
|
} /* cypress_ca42v2_startup */
|
|
|
|
|
|
|
|
|
2009-06-02 22:53:55 +07:00
|
|
|
static void cypress_release(struct usb_serial *serial)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv;
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
dbg("%s - port %d", __func__, serial->port[0]->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* all open ports are closed at this point */
|
|
|
|
|
|
|
|
priv = usb_get_serial_port_data(serial->port[0]);
|
|
|
|
|
|
|
|
if (priv) {
|
|
|
|
cypress_buf_free(priv->buf);
|
|
|
|
kfree(priv);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2009-09-20 03:13:26 +07:00
|
|
|
static int cypress_open(struct tty_struct *tty, struct usb_serial_port *port)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
unsigned long flags;
|
|
|
|
int result = 0;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-08-30 10:07:11 +07:00
|
|
|
if (!priv->comm_is_ok)
|
|
|
|
return -EIO;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* clear halts before open */
|
|
|
|
usb_clear_halt(serial->dev, 0x81);
|
|
|
|
usb_clear_halt(serial->dev, 0x02);
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
/* reset read/write statistics */
|
|
|
|
priv->bytes_in = 0;
|
|
|
|
priv->bytes_out = 0;
|
|
|
|
priv->cmd_count = 0;
|
|
|
|
priv->rx_flags = 0;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
/* Set termios */
|
2009-09-20 03:13:33 +07:00
|
|
|
cypress_send(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
if (tty)
|
|
|
|
cypress_set_termios(tty, port, &priv->tmp_termios);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* setup the port and start reading from the device */
|
2008-07-22 17:10:36 +07:00
|
|
|
if (!port->interrupt_in_urb) {
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&port->dev, "%s - interrupt_in_urb is empty!\n",
|
|
|
|
__func__);
|
2008-07-22 17:10:36 +07:00
|
|
|
return -1;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
usb_fill_int_urb(port->interrupt_in_urb, serial->dev,
|
|
|
|
usb_rcvintpipe(serial->dev, port->interrupt_in_endpointAddress),
|
2008-07-22 17:10:36 +07:00
|
|
|
port->interrupt_in_urb->transfer_buffer,
|
|
|
|
port->interrupt_in_urb->transfer_buffer_length,
|
2006-08-30 10:06:59 +07:00
|
|
|
cypress_read_int_callback, port, priv->read_urb_interval);
|
2005-04-17 05:20:36 +07:00
|
|
|
result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
if (result) {
|
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s - failed submitting read urb, error %d\n",
|
|
|
|
__func__, result);
|
2006-08-30 10:07:11 +07:00
|
|
|
cypress_set_dead(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2009-06-11 18:26:29 +07:00
|
|
|
port->port.drain_delay = 256;
|
2005-04-17 05:20:36 +07:00
|
|
|
return result;
|
|
|
|
} /* cypress_open */
|
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
static void cypress_dtr_rts(struct usb_serial_port *port, int on)
|
|
|
|
{
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
/* drop dtr and rts */
|
|
|
|
priv = usb_get_serial_port_data(port);
|
|
|
|
spin_lock_irq(&priv->lock);
|
|
|
|
if (on == 0)
|
|
|
|
priv->line_control = 0;
|
|
|
|
else
|
|
|
|
priv->line_control = CONTROL_DTR | CONTROL_RTS;
|
|
|
|
priv->cmd_ctrl = 1;
|
|
|
|
spin_unlock_irq(&priv->lock);
|
|
|
|
cypress_write(NULL, port, NULL, 0);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-06-11 18:26:29 +07:00
|
|
|
static void cypress_close(struct usb_serial_port *port)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-01-22 21:54:54 +07:00
|
|
|
/* writing is potentially harmful, lock must be taken */
|
|
|
|
mutex_lock(&port->serial->disc_mutex);
|
|
|
|
if (port->serial->disconnected) {
|
|
|
|
mutex_unlock(&port->serial->disc_mutex);
|
|
|
|
return;
|
|
|
|
}
|
2009-06-11 18:26:29 +07:00
|
|
|
cypress_buf_clear(priv->buf);
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - stopping urbs", __func__);
|
2008-07-22 17:10:36 +07:00
|
|
|
usb_kill_urb(port->interrupt_in_urb);
|
|
|
|
usb_kill_urb(port->interrupt_out_urb);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
|
|
|
|
if (stats)
|
2008-07-22 17:10:36 +07:00
|
|
|
dev_info(&port->dev, "Statistics: %d Bytes In | %d Bytes Out | %d Commands Issued\n",
|
|
|
|
priv->bytes_in, priv->bytes_out, priv->cmd_count);
|
2008-01-22 21:54:54 +07:00
|
|
|
mutex_unlock(&port->serial->disc_mutex);
|
2005-04-17 05:20:36 +07:00
|
|
|
} /* cypress_close */
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static int cypress_write(struct tty_struct *tty, struct usb_serial_port *port,
|
|
|
|
const unsigned char *buf, int count)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d, %d bytes", __func__, port->number, count);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* line control commands, which need to be executed immediately,
|
|
|
|
are not put into the buffer for obvious reasons.
|
|
|
|
*/
|
|
|
|
if (priv->cmd_ctrl) {
|
|
|
|
count = 0;
|
|
|
|
goto finish;
|
|
|
|
}
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!count)
|
|
|
|
return count;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
count = cypress_buf_put(priv->buf, buf, count);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
finish:
|
|
|
|
cypress_send(port);
|
|
|
|
|
|
|
|
return count;
|
|
|
|
} /* cypress_write */
|
|
|
|
|
|
|
|
|
|
|
|
static void cypress_send(struct usb_serial_port *port)
|
|
|
|
{
|
|
|
|
int count = 0, result, offset, actual_size;
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2006-08-30 10:07:11 +07:00
|
|
|
if (!priv->comm_is_ok)
|
|
|
|
return;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2008-07-22 17:10:36 +07:00
|
|
|
dbg("%s - interrupt out size is %d", __func__,
|
|
|
|
port->interrupt_out_size);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (priv->write_urb_in_use) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - can't write, urb in use", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* clear buffer */
|
2008-07-22 17:10:36 +07:00
|
|
|
memset(port->interrupt_out_urb->transfer_buffer, 0,
|
|
|
|
port->interrupt_out_size);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-02-11 09:23:19 +07:00
|
|
|
switch (priv->pkt_fmt) {
|
|
|
|
default:
|
|
|
|
case packet_format_1:
|
|
|
|
/* this is for the CY7C64013... */
|
|
|
|
offset = 2;
|
|
|
|
port->interrupt_out_buffer[0] = priv->line_control;
|
|
|
|
break;
|
|
|
|
case packet_format_2:
|
|
|
|
/* this is for the CY7C63743... */
|
|
|
|
offset = 1;
|
|
|
|
port->interrupt_out_buffer[0] = priv->line_control;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
if (priv->line_control & CONTROL_RESET)
|
|
|
|
priv->line_control &= ~CONTROL_RESET;
|
|
|
|
|
|
|
|
if (priv->cmd_ctrl) {
|
|
|
|
priv->cmd_count++;
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - line control command being issued", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
goto send;
|
|
|
|
} else
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
count = cypress_buf_get(priv->buf, &port->interrupt_out_buffer[offset],
|
|
|
|
port->interrupt_out_size-offset);
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
if (count == 0)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
|
2008-02-11 09:23:19 +07:00
|
|
|
switch (priv->pkt_fmt) {
|
|
|
|
default:
|
|
|
|
case packet_format_1:
|
|
|
|
port->interrupt_out_buffer[1] = count;
|
|
|
|
break;
|
|
|
|
case packet_format_2:
|
|
|
|
port->interrupt_out_buffer[0] |= count;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - count is %d", __func__, count);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
send:
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->write_urb_in_use = 1;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
if (priv->cmd_ctrl)
|
|
|
|
actual_size = 1;
|
|
|
|
else
|
2008-02-11 09:23:19 +07:00
|
|
|
actual_size = count +
|
|
|
|
(priv->pkt_fmt == packet_format_1 ? 2 : 1);
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
|
|
|
port->interrupt_out_size,
|
|
|
|
port->interrupt_out_urb->transfer_buffer);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-08-30 10:07:04 +07:00
|
|
|
usb_fill_int_urb(port->interrupt_out_urb, port->serial->dev,
|
|
|
|
usb_sndintpipe(port->serial->dev, port->interrupt_out_endpointAddress),
|
|
|
|
port->interrupt_out_buffer, port->interrupt_out_size,
|
|
|
|
cypress_write_int_callback, port, priv->write_urb_interval);
|
2008-07-22 17:10:36 +07:00
|
|
|
result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (result) {
|
2008-07-22 17:10:36 +07:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s - failed submitting write urb, error %d\n",
|
|
|
|
__func__, result);
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->write_urb_in_use = 0;
|
2006-08-30 10:07:11 +07:00
|
|
|
cypress_set_dead(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-07-22 17:10:36 +07:00
|
|
|
if (priv->cmd_ctrl)
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->cmd_ctrl = 0;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
|
|
|
/* do not count the line control and size bytes */
|
|
|
|
priv->bytes_out += count;
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2006-05-23 11:58:49 +07:00
|
|
|
usb_serial_port_softint(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
} /* cypress_send */
|
|
|
|
|
|
|
|
|
|
|
|
/* returns how much space is available in the soft buffer */
|
2008-07-22 17:09:07 +07:00
|
|
|
static int cypress_write_room(struct tty_struct *tty)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int room = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
room = cypress_buf_space_avail(priv->buf);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - returns %d", __func__, room);
|
2005-04-17 05:20:36 +07:00
|
|
|
return room;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static int cypress_tiocmget(struct tty_struct *tty, struct file *file)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
__u8 status, control;
|
|
|
|
unsigned int result = 0;
|
|
|
|
unsigned long flags;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
control = priv->line_control;
|
|
|
|
status = priv->current_status;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
result = ((control & CONTROL_DTR) ? TIOCM_DTR : 0)
|
|
|
|
| ((control & CONTROL_RTS) ? TIOCM_RTS : 0)
|
|
|
|
| ((status & UART_CTS) ? TIOCM_CTS : 0)
|
|
|
|
| ((status & UART_DSR) ? TIOCM_DSR : 0)
|
|
|
|
| ((status & UART_RI) ? TIOCM_RI : 0)
|
|
|
|
| ((status & UART_CD) ? TIOCM_CD : 0);
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - result = %x", __func__, result);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static int cypress_tiocmset(struct tty_struct *tty, struct file *file,
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned int set, unsigned int clear)
|
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
priv->line_control |= CONTROL_RTS;
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
priv->line_control |= CONTROL_DTR;
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
priv->line_control &= ~CONTROL_RTS;
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
priv->line_control &= ~CONTROL_DTR;
|
2008-03-11 04:59:28 +07:00
|
|
|
priv->cmd_ctrl = 1;
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
return cypress_write(tty, port, NULL, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
static int cypress_ioctl(struct tty_struct *tty, struct file *file,
|
2008-07-22 17:09:07 +07:00
|
|
|
unsigned int cmd, unsigned long arg)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d, cmd 0x%.4x", __func__, port->number, cmd);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
switch (cmd) {
|
2008-07-22 17:10:36 +07:00
|
|
|
/* This code comes from drivers/char/serial.c and ftdi_sio.c */
|
|
|
|
case TIOCMIWAIT:
|
|
|
|
while (priv != NULL) {
|
|
|
|
interruptible_sleep_on(&priv->delta_msr_wait);
|
|
|
|
/* see if a signal did it */
|
|
|
|
if (signal_pending(current))
|
|
|
|
return -ERESTARTSYS;
|
|
|
|
else {
|
|
|
|
char diff = priv->diff_status;
|
|
|
|
if (diff == 0)
|
|
|
|
return -EIO; /* no change => error */
|
|
|
|
|
|
|
|
/* consume all events */
|
|
|
|
priv->diff_status = 0;
|
|
|
|
|
|
|
|
/* return 0 if caller wanted to know about
|
|
|
|
these bits */
|
|
|
|
if (((arg & TIOCM_RNG) && (diff & UART_RI)) ||
|
|
|
|
((arg & TIOCM_DSR) && (diff & UART_DSR)) ||
|
|
|
|
((arg & TIOCM_CD) && (diff & UART_CD)) ||
|
|
|
|
((arg & TIOCM_CTS) && (diff & UART_CTS)))
|
|
|
|
return 0;
|
|
|
|
/* otherwise caller can't care less about what
|
|
|
|
* happened, and so we continue to wait for
|
|
|
|
* more events.
|
|
|
|
*/
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-07-22 17:10:36 +07:00
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
default:
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - arg not supported - it was 0x%04x - check include/asm/ioctls.h", __func__, cmd);
|
2005-04-17 05:20:36 +07:00
|
|
|
return -ENOIOCTLCMD;
|
|
|
|
} /* cypress_ioctl */
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static void cypress_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old_termios)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int data_bits, stop_bits, parity_type, parity_enable;
|
2008-03-11 04:59:28 +07:00
|
|
|
unsigned cflag, iflag;
|
2005-04-17 05:20:36 +07:00
|
|
|
unsigned long flags;
|
|
|
|
__u8 oldlines;
|
2005-05-04 05:02:20 +07:00
|
|
|
int linechange = 0;
|
2005-07-13 05:21:31 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2009-09-20 03:13:33 +07:00
|
|
|
/* We can't clean this one up as we don't know the device type
|
|
|
|
early enough */
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!priv->termios_initialized) {
|
|
|
|
if (priv->chiptype == CT_EARTHMATE) {
|
|
|
|
*(tty->termios) = tty_std_termios;
|
2005-07-13 05:21:31 +07:00
|
|
|
tty->termios->c_cflag = B4800 | CS8 | CREAD | HUPCL |
|
|
|
|
CLOCAL;
|
2008-03-11 04:59:28 +07:00
|
|
|
tty->termios->c_ispeed = 4800;
|
|
|
|
tty->termios->c_ospeed = 4800;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else if (priv->chiptype == CT_CYPHIDCOM) {
|
|
|
|
*(tty->termios) = tty_std_termios;
|
2005-07-13 05:21:31 +07:00
|
|
|
tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
|
|
|
|
CLOCAL;
|
2008-03-11 04:59:28 +07:00
|
|
|
tty->termios->c_ispeed = 9600;
|
|
|
|
tty->termios->c_ospeed = 9600;
|
2006-03-01 23:45:24 +07:00
|
|
|
} else if (priv->chiptype == CT_CA42V2) {
|
|
|
|
*(tty->termios) = tty_std_termios;
|
|
|
|
tty->termios->c_cflag = B9600 | CS8 | CREAD | HUPCL |
|
|
|
|
CLOCAL;
|
2008-03-11 04:59:28 +07:00
|
|
|
tty->termios->c_ispeed = 9600;
|
|
|
|
tty->termios->c_ospeed = 9600;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
priv->termios_initialized = 1;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-03-11 04:59:28 +07:00
|
|
|
/* Unsupported features need clearing */
|
|
|
|
tty->termios->c_cflag &= ~(CMSPAR|CRTSCTS);
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
cflag = tty->termios->c_cflag;
|
|
|
|
iflag = tty->termios->c_iflag;
|
|
|
|
|
|
|
|
/* check if there are new settings */
|
|
|
|
if (old_termios) {
|
2008-03-11 04:59:28 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
priv->tmp_termios = *(tty->termios);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
/* set number of data bits, parity, stop bits */
|
|
|
|
/* when parity is disabled the parity type bit is ignored */
|
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
/* 1 means 2 stop bits, 0 means 1 stop bit */
|
|
|
|
stop_bits = cflag & CSTOPB ? 1 : 0;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (cflag & PARENB) {
|
|
|
|
parity_enable = 1;
|
2005-07-13 05:21:31 +07:00
|
|
|
/* 1 means odd parity, 0 means even parity */
|
|
|
|
parity_type = cflag & PARODD ? 1 : 0;
|
2005-04-17 05:20:36 +07:00
|
|
|
} else
|
|
|
|
parity_enable = parity_type = 0;
|
|
|
|
|
2008-07-22 17:10:53 +07:00
|
|
|
switch (cflag & CSIZE) {
|
|
|
|
case CS5:
|
|
|
|
data_bits = 0;
|
|
|
|
break;
|
|
|
|
case CS6:
|
|
|
|
data_bits = 1;
|
|
|
|
break;
|
|
|
|
case CS7:
|
|
|
|
data_bits = 2;
|
|
|
|
break;
|
|
|
|
case CS8:
|
2005-04-17 05:20:36 +07:00
|
|
|
data_bits = 3;
|
2008-07-22 17:10:53 +07:00
|
|
|
break;
|
|
|
|
default:
|
2008-08-21 06:56:34 +07:00
|
|
|
dev_err(&port->dev, "%s - CSIZE was set, but not CS5-CS8\n",
|
|
|
|
__func__);
|
2008-07-22 17:10:53 +07:00
|
|
|
data_bits = 3;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
oldlines = priv->line_control;
|
|
|
|
if ((cflag & CBAUD) == B0) {
|
|
|
|
/* drop dtr and rts */
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - dropping the lines, baud rate 0bps", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->line_control &= ~(CONTROL_DTR | CONTROL_RTS);
|
2008-03-11 04:59:28 +07:00
|
|
|
} else
|
2005-05-04 05:02:20 +07:00
|
|
|
priv->line_control = (CONTROL_DTR | CONTROL_RTS);
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
dbg("%s - sending %d stop_bits, %d parity_enable, %d parity_type, "
|
2008-03-04 07:08:34 +07:00
|
|
|
"%d data_bits (+5)", __func__, stop_bits,
|
2005-07-13 05:21:31 +07:00
|
|
|
parity_enable, parity_type, data_bits);
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
cypress_serial_control(tty, port, tty_get_baud_rate(tty),
|
|
|
|
data_bits, stop_bits,
|
|
|
|
parity_enable, parity_type,
|
|
|
|
0, CYPRESS_SET_CONFIG);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
/* we perform a CYPRESS_GET_CONFIG so that the current settings are
|
|
|
|
* filled into the private structure this should confirm that all is
|
|
|
|
* working if it returns what we just set */
|
2008-07-22 17:09:07 +07:00
|
|
|
cypress_serial_control(tty, port, 0, 0, 0, 0, 0, 0, CYPRESS_GET_CONFIG);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
/* Here we can define custom tty settings for devices; the main tty
|
|
|
|
* termios flag base comes from empeg.c */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-07-22 17:10:36 +07:00
|
|
|
if (priv->chiptype == CT_EARTHMATE && priv->baud_rate == 4800) {
|
2005-07-13 05:21:31 +07:00
|
|
|
dbg("Using custom termios settings for a baud rate of "
|
|
|
|
"4800bps.");
|
2005-04-17 05:20:36 +07:00
|
|
|
/* define custom termios settings for NMEA protocol */
|
|
|
|
|
|
|
|
tty->termios->c_iflag /* input modes - */
|
2005-07-13 05:21:31 +07:00
|
|
|
&= ~(IGNBRK /* disable ignore break */
|
|
|
|
| BRKINT /* disable break causes interrupt */
|
|
|
|
| PARMRK /* disable mark parity errors */
|
|
|
|
| ISTRIP /* disable clear high bit of input char */
|
|
|
|
| INLCR /* disable translate NL to CR */
|
|
|
|
| IGNCR /* disable ignore CR */
|
|
|
|
| ICRNL /* disable translate CR to NL */
|
|
|
|
| IXON); /* disable enable XON/XOFF flow control */
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
tty->termios->c_oflag /* output modes */
|
2005-07-13 05:21:31 +07:00
|
|
|
&= ~OPOST; /* disable postprocess output char */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
tty->termios->c_lflag /* line discipline modes */
|
|
|
|
&= ~(ECHO /* disable echo input characters */
|
|
|
|
| ECHONL /* disable echo new line */
|
|
|
|
| ICANON /* disable erase, kill, werase, and rprnt
|
|
|
|
special characters */
|
|
|
|
| ISIG /* disable interrupt, quit, and suspend
|
|
|
|
special characters */
|
|
|
|
| IEXTEN); /* disable non-POSIX special characters */
|
2005-05-04 05:02:20 +07:00
|
|
|
} /* CT_CYPHIDCOM: Application should handle this for device */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
linechange = (priv->line_control != oldlines);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* if necessary, set lines */
|
2005-05-04 05:02:20 +07:00
|
|
|
if (linechange) {
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->cmd_ctrl = 1;
|
2008-07-22 17:09:07 +07:00
|
|
|
cypress_write(tty, port, NULL, 0);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
} /* cypress_set_termios */
|
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* returns amount of data still left in soft buffer */
|
2008-07-22 17:09:07 +07:00
|
|
|
static int cypress_chars_in_buffer(struct tty_struct *tty)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int chars = 0;
|
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
chars = cypress_buf_data_avail(priv->buf);
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - returns %d", __func__, chars);
|
2005-04-17 05:20:36 +07:00
|
|
|
return chars;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static void cypress_throttle(struct tty_struct *tty)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-10-07 15:50:23 +07:00
|
|
|
spin_lock_irq(&priv->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->rx_flags = THROTTLED;
|
2009-10-07 15:50:23 +07:00
|
|
|
spin_unlock_irq(&priv->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
static void cypress_unthrottle(struct tty_struct *tty)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-07-22 17:09:07 +07:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int actually_throttled, result;
|
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2009-10-07 15:50:23 +07:00
|
|
|
spin_lock_irq(&priv->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
actually_throttled = priv->rx_flags & ACTUALLY_THROTTLED;
|
|
|
|
priv->rx_flags = 0;
|
2009-10-07 15:50:23 +07:00
|
|
|
spin_unlock_irq(&priv->lock);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2006-08-30 10:07:11 +07:00
|
|
|
if (!priv->comm_is_ok)
|
|
|
|
return;
|
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
if (actually_throttled) {
|
|
|
|
port->interrupt_in_urb->dev = port->serial->dev;
|
|
|
|
|
2009-10-07 15:50:23 +07:00
|
|
|
result = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL);
|
2006-08-30 10:07:11 +07:00
|
|
|
if (result) {
|
2005-07-13 05:21:31 +07:00
|
|
|
dev_err(&port->dev, "%s - failed submitting read urb, "
|
2008-03-04 07:08:34 +07:00
|
|
|
"error %d\n", __func__, result);
|
2006-08-30 10:07:11 +07:00
|
|
|
cypress_set_dead(port);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
static void cypress_read_int_callback(struct urb *urb)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-02-24 17:41:47 +07:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
struct tty_struct *tty;
|
|
|
|
unsigned char *data = urb->transfer_buffer;
|
|
|
|
unsigned long flags;
|
2005-07-13 05:21:31 +07:00
|
|
|
char tty_flag = TTY_NORMAL;
|
2005-04-17 05:20:36 +07:00
|
|
|
int havedata = 0;
|
|
|
|
int bytes = 0;
|
|
|
|
int result;
|
|
|
|
int i = 0;
|
2007-06-16 05:44:13 +07:00
|
|
|
int status = urb->status;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2007-06-16 05:44:13 +07:00
|
|
|
switch (status) {
|
2006-08-30 10:07:11 +07:00
|
|
|
case 0: /* success */
|
|
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
|
|
case -ENOENT:
|
|
|
|
case -ESHUTDOWN:
|
|
|
|
/* precursor to disconnect so just go away */
|
|
|
|
return;
|
|
|
|
case -EPIPE:
|
2009-07-09 23:59:57 +07:00
|
|
|
/* Can't call usb_clear_halt while in_interrupt */
|
|
|
|
/* FALLS THROUGH */
|
2006-08-30 10:07:11 +07:00
|
|
|
default:
|
|
|
|
/* something ugly is going on... */
|
2008-07-22 17:10:36 +07:00
|
|
|
dev_err(&urb->dev->dev,
|
|
|
|
"%s - unexpected nonzero read status received: %d\n",
|
|
|
|
__func__, status);
|
2006-08-30 10:07:11 +07:00
|
|
|
cypress_set_dead(port);
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (priv->rx_flags & THROTTLED) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - now throttling", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
priv->rx_flags |= ACTUALLY_THROTTLED;
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2008-10-13 16:39:46 +07:00
|
|
|
tty = tty_port_tty_get(&port->port);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (!tty) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - bad tty pointer - exiting", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-02-11 09:23:19 +07:00
|
|
|
result = urb->actual_length;
|
|
|
|
switch (priv->pkt_fmt) {
|
|
|
|
default:
|
|
|
|
case packet_format_1:
|
|
|
|
/* This is for the CY7C64013... */
|
|
|
|
priv->current_status = data[0] & 0xF8;
|
|
|
|
bytes = data[1] + 2;
|
|
|
|
i = 2;
|
|
|
|
if (bytes > 2)
|
|
|
|
havedata = 1;
|
|
|
|
break;
|
|
|
|
case packet_format_2:
|
|
|
|
/* This is for the CY7C63743... */
|
|
|
|
priv->current_status = data[0] & 0xF8;
|
|
|
|
bytes = (data[0] & 0x07) + 1;
|
|
|
|
i = 1;
|
|
|
|
if (bytes > 1)
|
|
|
|
havedata = 1;
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-02-11 09:23:19 +07:00
|
|
|
if (result < bytes) {
|
|
|
|
dbg("%s - wrong packet size - received %d bytes but packet "
|
|
|
|
"said %d bytes", __func__, result, bytes);
|
|
|
|
goto continue_read;
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
|
|
|
urb->actual_length, data);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
/* check to see if status has changed */
|
2008-02-11 09:23:28 +07:00
|
|
|
if (priv->current_status != priv->prev_status) {
|
|
|
|
priv->diff_status |= priv->current_status ^
|
|
|
|
priv->prev_status;
|
|
|
|
wake_up_interruptible(&priv->delta_msr_wait);
|
|
|
|
priv->prev_status = priv->current_status;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-07-13 05:21:31 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
/* hangup, as defined in acm.c... this might be a bad place for it
|
|
|
|
* though */
|
|
|
|
if (tty && !(tty->termios->c_cflag & CLOCAL) &&
|
|
|
|
!(priv->current_status & UART_CD)) {
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - calling hangup", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
tty_hangup(tty);
|
|
|
|
goto continue_read;
|
|
|
|
}
|
|
|
|
|
2005-07-13 05:21:31 +07:00
|
|
|
/* There is one error bit... I'm assuming it is a parity error
|
|
|
|
* indicator as the generic firmware will set this bit to 1 if a
|
|
|
|
* parity error occurs.
|
|
|
|
* I can not find reference to any other error events. */
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
if (priv->current_status & CYP_ERROR) {
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
tty_flag = TTY_PARITY;
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - Parity Error detected", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
} else
|
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
/* process read if there is data other than line status */
|
|
|
|
if (tty && (bytes > i)) {
|
[PATCH] TTY layer buffering revamp
The API and code have been through various bits of initial review by
serial driver people but they definitely need to live somewhere for a
while so the unconverted drivers can get knocked into shape, existing
drivers that have been updated can be better tuned and bugs whacked out.
This replaces the tty flip buffers with kmalloc objects in rings. In the
normal situation for an IRQ driven serial port at typical speeds the
behaviour is pretty much the same, two buffers end up allocated and the
kernel cycles between them as before.
When there are delays or at high speed we now behave far better as the
buffer pool can grow a bit rather than lose characters. This also means
that we can operate at higher speeds reliably.
For drivers that receive characters in blocks (DMA based, USB and
especially virtualisation) the layer allows a lot of driver specific
code that works around the tty layer with private secondary queues to be
removed. The IBM folks need this sort of layer, the smart serial port
people do, the virtualisers do (because a virtualised tty typically
operates at infinite speed rather than emulating 9600 baud).
Finally many drivers had invalid and unsafe attempts to avoid buffer
overflows by directly invoking tty methods extracted out of the innards
of work queue structs. These are no longer needed and all go away. That
fixes various random hangs with serial ports on overflow.
The other change in here is to optimise the receive_room path that is
used by some callers. It turns out that only one ldisc uses receive room
except asa constant and it updates it far far less than the value is
read. We thus make it a variable not a function call.
I expect the code to contain bugs due to the size alone but I'll be
watching and squashing them and feeding out new patches as it goes.
Because the buffers now dynamically expand you should only run out of
buffering when the kernel runs out of memory for real. That means a lot of
the horrible hacks high performance drivers used to do just aren't needed any
more.
Description:
tty_insert_flip_char is an old API and continues to work as before, as does
tty_flip_buffer_push() [this is why many drivers dont need modification]. It
does now also return the number of chars inserted
There are also
tty_buffer_request_room(tty, len)
which asks for a buffer block of the length requested and returns the space
found. This improves efficiency with hardware that knows how much to
transfer.
and tty_insert_flip_string_flags(tty, str, flags, len)
to insert a string of characters and flags
For a smart interface the usual code is
len = tty_request_buffer_room(tty, amount_hardware_says);
tty_insert_flip_string(tty, buffer_from_card, len);
More description!
At the moment tty buffers are attached directly to the tty. This is causing a
lot of the problems related to tty layer locking, also problems at high speed
and also with bursty data (such as occurs in virtualised environments)
I'm working on ripping out the flip buffers and replacing them with a pool of
dynamically allocated buffers. This allows both for old style "byte I/O"
devices and also helps virtualisation and smart devices where large blocks of
data suddenely materialise and need storing.
So far so good. Lots of drivers reference tty->flip.*. Several of them also
call directly and unsafely into function pointers it provides. This will all
break. Most drivers can use tty_insert_flip_char which can be kept as an API
but others need more.
At the moment I've added the following interfaces, if people think more will
be needed now is a good time to say
int tty_buffer_request_room(tty, size)
Try and ensure at least size bytes are available, returns actual room (may be
zero). At the moment it just uses the flipbuf space but that will change.
Repeated calls without characters being added are not cumulative. (ie if you
call it with 1, 1, 1, and then 4 you'll have four characters of space. The
other functions will also try and grow buffers in future but this will be a
more efficient way when you know block sizes.
int tty_insert_flip_char(tty, ch, flag)
As before insert a character if there is room. Now returns 1 for success, 0
for failure.
int tty_insert_flip_string(tty, str, len)
Insert a block of non error characters. Returns the number inserted.
int tty_prepare_flip_string(tty, strptr, len)
Adjust the buffer to allow len characters to be added. Returns a buffer
pointer in strptr and the length available. This allows for hardware that
needs to use functions like insl or mencpy_fromio.
Signed-off-by: Alan Cox <alan@redhat.com>
Cc: Paul Fulghum <paulkf@microgate.com>
Signed-off-by: Hirokazu Takata <takata@linux-m32r.org>
Signed-off-by: Serge Hallyn <serue@us.ibm.com>
Signed-off-by: Jeff Dike <jdike@addtoit.com>
Signed-off-by: John Hawkes <hawkes@sgi.com>
Signed-off-by: Martin Schwidefsky <schwidefsky@de.ibm.com>
Signed-off-by: Adrian Bunk <bunk@stusta.de>
Signed-off-by: Andrew Morton <akpm@osdl.org>
Signed-off-by: Linus Torvalds <torvalds@osdl.org>
2006-01-10 11:54:13 +07:00
|
|
|
bytes = tty_buffer_request_room(tty, bytes);
|
2005-04-17 05:20:36 +07:00
|
|
|
for (; i < bytes ; ++i) {
|
2005-07-13 05:21:31 +07:00
|
|
|
dbg("pushing byte number %d - %d - %c", i, data[i],
|
|
|
|
data[i]);
|
2005-04-17 05:20:36 +07:00
|
|
|
tty_insert_flip_char(tty, data[i], tty_flag);
|
|
|
|
}
|
2008-10-13 16:39:46 +07:00
|
|
|
tty_flip_buffer_push(tty);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-07-13 05:21:31 +07:00
|
|
|
/* control and status byte(s) are also counted */
|
|
|
|
priv->bytes_in += bytes;
|
2005-04-17 05:20:36 +07:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
|
|
|
continue_read:
|
2008-10-13 16:39:46 +07:00
|
|
|
tty_kref_put(tty);
|
2005-07-13 05:21:31 +07:00
|
|
|
|
|
|
|
/* Continue trying to always read... unless the port has closed. */
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:09:07 +07:00
|
|
|
if (port->port.count > 0 && priv->comm_is_ok) {
|
2005-07-13 05:21:31 +07:00
|
|
|
usb_fill_int_urb(port->interrupt_in_urb, port->serial->dev,
|
|
|
|
usb_rcvintpipe(port->serial->dev,
|
|
|
|
port->interrupt_in_endpointAddress),
|
|
|
|
port->interrupt_in_urb->transfer_buffer,
|
|
|
|
port->interrupt_in_urb->transfer_buffer_length,
|
2008-07-22 17:10:36 +07:00
|
|
|
cypress_read_int_callback, port,
|
|
|
|
priv->read_urb_interval);
|
2005-07-13 05:21:31 +07:00
|
|
|
result = usb_submit_urb(port->interrupt_in_urb, GFP_ATOMIC);
|
2006-08-30 10:07:11 +07:00
|
|
|
if (result) {
|
2005-07-13 05:21:31 +07:00
|
|
|
dev_err(&urb->dev->dev, "%s - failed resubmitting "
|
2008-03-04 07:08:34 +07:00
|
|
|
"read urb, error %d\n", __func__,
|
2005-07-13 05:21:31 +07:00
|
|
|
result);
|
2006-08-30 10:07:11 +07:00
|
|
|
cypress_set_dead(port);
|
|
|
|
}
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
2005-07-13 05:21:31 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
|
|
|
} /* cypress_read_int_callback */
|
|
|
|
|
|
|
|
|
IRQ: Maintain regs pointer globally rather than passing to IRQ handlers
Maintain a per-CPU global "struct pt_regs *" variable which can be used instead
of passing regs around manually through all ~1800 interrupt handlers in the
Linux kernel.
The regs pointer is used in few places, but it potentially costs both stack
space and code to pass it around. On the FRV arch, removing the regs parameter
from all the genirq function results in a 20% speed up of the IRQ exit path
(ie: from leaving timer_interrupt() to leaving do_IRQ()).
Where appropriate, an arch may override the generic storage facility and do
something different with the variable. On FRV, for instance, the address is
maintained in GR28 at all times inside the kernel as part of general exception
handling.
Having looked over the code, it appears that the parameter may be handed down
through up to twenty or so layers of functions. Consider a USB character
device attached to a USB hub, attached to a USB controller that posts its
interrupts through a cascaded auxiliary interrupt controller. A character
device driver may want to pass regs to the sysrq handler through the input
layer which adds another few layers of parameter passing.
I've build this code with allyesconfig for x86_64 and i386. I've runtested the
main part of the code on FRV and i386, though I can't test most of the drivers.
I've also done partial conversion for powerpc and MIPS - these at least compile
with minimal configurations.
This will affect all archs. Mostly the changes should be relatively easy.
Take do_IRQ(), store the regs pointer at the beginning, saving the old one:
struct pt_regs *old_regs = set_irq_regs(regs);
And put the old one back at the end:
set_irq_regs(old_regs);
Don't pass regs through to generic_handle_irq() or __do_IRQ().
In timer_interrupt(), this sort of change will be necessary:
- update_process_times(user_mode(regs));
- profile_tick(CPU_PROFILING, regs);
+ update_process_times(user_mode(get_irq_regs()));
+ profile_tick(CPU_PROFILING);
I'd like to move update_process_times()'s use of get_irq_regs() into itself,
except that i386, alone of the archs, uses something other than user_mode().
Some notes on the interrupt handling in the drivers:
(*) input_dev() is now gone entirely. The regs pointer is no longer stored in
the input_dev struct.
(*) finish_unlinks() in drivers/usb/host/ohci-q.c needs checking. It does
something different depending on whether it's been supplied with a regs
pointer or not.
(*) Various IRQ handler function pointers have been moved to type
irq_handler_t.
Signed-Off-By: David Howells <dhowells@redhat.com>
(cherry picked from 1b16e7ac850969f38b375e511e3fa2f474a33867 commit)
2006-10-05 20:55:46 +07:00
|
|
|
static void cypress_write_int_callback(struct urb *urb)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-02-24 17:41:47 +07:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-17 05:20:36 +07:00
|
|
|
struct cypress_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int result;
|
2007-06-16 05:44:13 +07:00
|
|
|
int status = urb->status;
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2007-06-16 05:44:13 +07:00
|
|
|
|
|
|
|
switch (status) {
|
2008-07-22 17:10:36 +07:00
|
|
|
case 0:
|
|
|
|
/* success */
|
|
|
|
break;
|
|
|
|
case -ECONNRESET:
|
|
|
|
case -ENOENT:
|
|
|
|
case -ESHUTDOWN:
|
|
|
|
/* this urb is terminated, clean up */
|
|
|
|
dbg("%s - urb shutting down with status: %d",
|
|
|
|
__func__, status);
|
|
|
|
priv->write_urb_in_use = 0;
|
|
|
|
return;
|
|
|
|
case -EPIPE: /* no break needed; clear halt and resubmit */
|
|
|
|
if (!priv->comm_is_ok)
|
2005-04-17 05:20:36 +07:00
|
|
|
break;
|
2008-07-22 17:10:36 +07:00
|
|
|
usb_clear_halt(port->serial->dev, 0x02);
|
|
|
|
/* error in the urb, so we have to resubmit it */
|
|
|
|
dbg("%s - nonzero write bulk status received: %d",
|
|
|
|
__func__, status);
|
|
|
|
port->interrupt_out_urb->transfer_buffer_length = 1;
|
|
|
|
port->interrupt_out_urb->dev = port->serial->dev;
|
|
|
|
result = usb_submit_urb(port->interrupt_out_urb, GFP_ATOMIC);
|
|
|
|
if (!result)
|
2005-04-17 05:20:36 +07:00
|
|
|
return;
|
2008-07-22 17:10:36 +07:00
|
|
|
dev_err(&urb->dev->dev,
|
|
|
|
"%s - failed resubmitting write urb, error %d\n",
|
|
|
|
__func__, result);
|
|
|
|
cypress_set_dead(port);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dev_err(&urb->dev->dev,
|
|
|
|
"%s - unexpected nonzero write status received: %d\n",
|
|
|
|
__func__, status);
|
|
|
|
cypress_set_dead(port);
|
|
|
|
break;
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
priv->write_urb_in_use = 0;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
/* send any buffered data */
|
|
|
|
cypress_send(port);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Write buffer functions - buffering code from pl2303 used
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_alloc
|
|
|
|
*
|
|
|
|
* Allocate a circular buffer and all associated memory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static struct cypress_buf *cypress_buf_alloc(unsigned int size)
|
|
|
|
{
|
|
|
|
|
|
|
|
struct cypress_buf *cb;
|
|
|
|
|
|
|
|
|
|
|
|
if (size == 0)
|
|
|
|
return NULL;
|
|
|
|
|
2006-12-13 15:35:56 +07:00
|
|
|
cb = kmalloc(sizeof(struct cypress_buf), GFP_KERNEL);
|
2005-04-17 05:20:36 +07:00
|
|
|
if (cb == NULL)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
cb->buf_buf = kmalloc(size, GFP_KERNEL);
|
|
|
|
if (cb->buf_buf == NULL) {
|
|
|
|
kfree(cb);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
cb->buf_size = size;
|
|
|
|
cb->buf_get = cb->buf_put = cb->buf_buf;
|
|
|
|
|
|
|
|
return cb;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_free
|
|
|
|
*
|
|
|
|
* Free the buffer and all associated memory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void cypress_buf_free(struct cypress_buf *cb)
|
|
|
|
{
|
2005-04-19 07:39:34 +07:00
|
|
|
if (cb) {
|
|
|
|
kfree(cb->buf_buf);
|
2005-04-17 05:20:36 +07:00
|
|
|
kfree(cb);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_clear
|
|
|
|
*
|
|
|
|
* Clear out all data in the circular buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static void cypress_buf_clear(struct cypress_buf *cb)
|
|
|
|
{
|
|
|
|
if (cb != NULL)
|
|
|
|
cb->buf_get = cb->buf_put;
|
|
|
|
/* equivalent to a get of all data available */
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_data_avail
|
|
|
|
*
|
|
|
|
* Return the number of bytes of data available in the circular
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int cypress_buf_data_avail(struct cypress_buf *cb)
|
|
|
|
{
|
|
|
|
if (cb != NULL)
|
2008-07-22 17:10:36 +07:00
|
|
|
return (cb->buf_size + cb->buf_put - cb->buf_get)
|
|
|
|
% cb->buf_size;
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_space_avail
|
|
|
|
*
|
|
|
|
* Return the number of bytes of space available in the circular
|
|
|
|
* buffer.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int cypress_buf_space_avail(struct cypress_buf *cb)
|
|
|
|
{
|
|
|
|
if (cb != NULL)
|
2008-07-22 17:10:36 +07:00
|
|
|
return (cb->buf_size + cb->buf_get - cb->buf_put - 1)
|
|
|
|
% cb->buf_size;
|
2005-04-17 05:20:36 +07:00
|
|
|
else
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_put
|
|
|
|
*
|
|
|
|
* Copy data data from a user buffer and put it into the circular buffer.
|
|
|
|
* Restrict to the amount of space available.
|
|
|
|
*
|
|
|
|
* Return the number of bytes copied.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int cypress_buf_put(struct cypress_buf *cb, const char *buf,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
|
|
|
|
if (cb == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = cypress_buf_space_avail(cb);
|
|
|
|
if (count > len)
|
|
|
|
count = len;
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = cb->buf_buf + cb->buf_size - cb->buf_put;
|
|
|
|
if (count > len) {
|
|
|
|
memcpy(cb->buf_put, buf, len);
|
|
|
|
memcpy(cb->buf_buf, buf+len, count - len);
|
|
|
|
cb->buf_put = cb->buf_buf + count - len;
|
|
|
|
} else {
|
|
|
|
memcpy(cb->buf_put, buf, count);
|
|
|
|
if (count < len)
|
|
|
|
cb->buf_put += count;
|
|
|
|
else /* count == len */
|
|
|
|
cb->buf_put = cb->buf_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* cypress_buf_get
|
|
|
|
*
|
|
|
|
* Get data from the circular buffer and copy to the given buffer.
|
|
|
|
* Restrict to the amount of data available.
|
|
|
|
*
|
|
|
|
* Return the number of bytes copied.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static unsigned int cypress_buf_get(struct cypress_buf *cb, char *buf,
|
|
|
|
unsigned int count)
|
|
|
|
{
|
|
|
|
|
|
|
|
unsigned int len;
|
|
|
|
|
|
|
|
|
|
|
|
if (cb == NULL)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = cypress_buf_data_avail(cb);
|
|
|
|
if (count > len)
|
|
|
|
count = len;
|
|
|
|
|
|
|
|
if (count == 0)
|
|
|
|
return 0;
|
|
|
|
|
|
|
|
len = cb->buf_buf + cb->buf_size - cb->buf_get;
|
|
|
|
if (count > len) {
|
|
|
|
memcpy(buf, cb->buf_get, len);
|
|
|
|
memcpy(buf+len, cb->buf_buf, count - len);
|
|
|
|
cb->buf_get = cb->buf_buf + count - len;
|
|
|
|
} else {
|
|
|
|
memcpy(buf, cb->buf_get, count);
|
|
|
|
if (count < len)
|
|
|
|
cb->buf_get += count;
|
|
|
|
else /* count == len */
|
|
|
|
cb->buf_get = cb->buf_buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
return count;
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/*****************************************************************************
|
|
|
|
* Module functions
|
|
|
|
*****************************************************************************/
|
|
|
|
|
|
|
|
static int __init cypress_init(void)
|
|
|
|
{
|
|
|
|
int retval;
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s", __func__);
|
2008-07-22 17:10:36 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = usb_serial_register(&cypress_earthmate_device);
|
|
|
|
if (retval)
|
|
|
|
goto failed_em_register;
|
|
|
|
retval = usb_serial_register(&cypress_hidcom_device);
|
|
|
|
if (retval)
|
|
|
|
goto failed_hidcom_register;
|
2006-03-01 23:45:24 +07:00
|
|
|
retval = usb_serial_register(&cypress_ca42v2_device);
|
|
|
|
if (retval)
|
|
|
|
goto failed_ca42v2_register;
|
2005-04-17 05:20:36 +07:00
|
|
|
retval = usb_register(&cypress_driver);
|
|
|
|
if (retval)
|
|
|
|
goto failed_usb_register;
|
|
|
|
|
2008-08-19 03:21:04 +07:00
|
|
|
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
|
|
|
|
DRIVER_DESC "\n");
|
2005-04-17 05:20:36 +07:00
|
|
|
return 0;
|
2006-11-17 23:49:22 +07:00
|
|
|
|
2005-04-17 05:20:36 +07:00
|
|
|
failed_usb_register:
|
2006-03-01 23:45:24 +07:00
|
|
|
usb_serial_deregister(&cypress_ca42v2_device);
|
2006-11-17 23:49:22 +07:00
|
|
|
failed_ca42v2_register:
|
2005-04-17 05:20:36 +07:00
|
|
|
usb_serial_deregister(&cypress_hidcom_device);
|
2006-11-17 23:49:22 +07:00
|
|
|
failed_hidcom_register:
|
2005-04-17 05:20:36 +07:00
|
|
|
usb_serial_deregister(&cypress_earthmate_device);
|
2006-11-17 23:49:22 +07:00
|
|
|
failed_em_register:
|
2005-04-17 05:20:36 +07:00
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
static void __exit cypress_exit(void)
|
2005-04-17 05:20:36 +07:00
|
|
|
{
|
2008-03-04 07:08:34 +07:00
|
|
|
dbg("%s", __func__);
|
2005-04-17 05:20:36 +07:00
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
usb_deregister(&cypress_driver);
|
|
|
|
usb_serial_deregister(&cypress_earthmate_device);
|
|
|
|
usb_serial_deregister(&cypress_hidcom_device);
|
|
|
|
usb_serial_deregister(&cypress_ca42v2_device);
|
2005-04-17 05:20:36 +07:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
module_init(cypress_init);
|
|
|
|
module_exit(cypress_exit);
|
|
|
|
|
2008-07-22 17:10:36 +07:00
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_VERSION(DRIVER_VERSION);
|
2005-04-17 05:20:36 +07:00
|
|
|
MODULE_LICENSE("GPL");
|
|
|
|
|
|
|
|
module_param(debug, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(debug, "Debug enabled or not");
|
|
|
|
module_param(stats, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(stats, "Enable statistics or not");
|
2005-05-04 05:02:20 +07:00
|
|
|
module_param(interval, int, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(interval, "Overrides interrupt interval");
|