2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* KLSI KL5KUSB105 chip RS232 converter driver
|
|
|
|
*
|
|
|
|
* Copyright (C) 2001 Utz-Uwe Haus <haus@uuhaus.de>
|
|
|
|
*
|
|
|
|
* 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.
|
|
|
|
*
|
|
|
|
* All information about the device was acquired using SniffUSB ans snoopUSB
|
|
|
|
* on Windows98.
|
|
|
|
* It was written out of frustration with the PalmConnect USB Serial adapter
|
|
|
|
* sold by Palm Inc.
|
|
|
|
* Neither Palm, nor their contractor (MCCI) or their supplier (KLSI) provided
|
|
|
|
* information that was not already available.
|
|
|
|
*
|
2008-07-22 04:14:00 -06:00
|
|
|
* It seems that KLSI bought some silicon-design information from ScanLogic,
|
2005-04-16 16:20:36 -06:00
|
|
|
* whose SL11R processor is at the core of the KL5KUSB chipset from KLSI.
|
|
|
|
* KLSI has firmware available for their devices; it is probable that the
|
|
|
|
* firmware differs from that used by KLSI in their products. If you have an
|
2008-07-22 04:14:00 -06:00
|
|
|
* original KLSI device and can provide some information on it, I would be
|
|
|
|
* most interested in adding support for it here. If you have any information
|
2005-04-16 16:20:36 -06:00
|
|
|
* on the protocol used (or find errors in my reverse-engineered stuff), please
|
|
|
|
* let me know.
|
|
|
|
*
|
|
|
|
* The code was only tested with a PalmConnect USB adapter; if you
|
|
|
|
* are adventurous, try it with any KLSI-based device and let me know how it
|
|
|
|
* breaks so that I can fix it!
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* TODO:
|
|
|
|
* check modem line signals
|
|
|
|
* implement handshaking or decide that we do not support it
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* History:
|
|
|
|
* 0.3a - implemented pools of write URBs
|
|
|
|
* 0.3 - alpha version for public testing
|
|
|
|
* 0.2 - TIOCMGET works, so autopilot(1) can be used!
|
2009-07-16 09:13:03 -06:00
|
|
|
* 0.1 - can be used to do pilot-xfer -p /dev/ttyUSB0 -l
|
2005-04-16 16:20:36 -06:00
|
|
|
*
|
2008-07-22 04:14:00 -06:00
|
|
|
* The driver skeleton is mainly based on mct_u232.c and various other
|
2005-04-16 16:20:36 -06:00
|
|
|
* pieces of code shamelessly copied from the drivers/usb/serial/ directory.
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#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>
|
2008-07-22 04:14:00 -06:00
|
|
|
#include <linux/uaccess.h>
|
2008-04-28 00:00:16 -06:00
|
|
|
#include <asm/unaligned.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include <linux/usb.h>
|
2006-07-11 22:22:58 -06:00
|
|
|
#include <linux/usb/serial.h>
|
2005-04-16 16:20:36 -06:00
|
|
|
#include "kl5kusb105.h"
|
|
|
|
|
|
|
|
static int debug;
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Version Information
|
|
|
|
*/
|
|
|
|
#define DRIVER_VERSION "v0.3a"
|
|
|
|
#define DRIVER_AUTHOR "Utz-Uwe Haus <haus@uuhaus.de>"
|
|
|
|
#define DRIVER_DESC "KLSI KL5KUSB105 chipset USB->Serial Converter driver"
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Function prototypes
|
|
|
|
*/
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_startup(struct usb_serial *serial);
|
2009-06-02 09:53:55 -06:00
|
|
|
static void klsi_105_disconnect(struct usb_serial *serial);
|
|
|
|
static void klsi_105_release(struct usb_serial *serial);
|
2009-09-19 14:13:26 -06:00
|
|
|
static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port);
|
2009-06-11 05:26:29 -06:00
|
|
|
static void klsi_105_close(struct usb_serial_port *port);
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_write(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, const unsigned char *buf, int count);
|
|
|
|
static void klsi_105_write_bulk_callback(struct urb *urb);
|
|
|
|
static int klsi_105_chars_in_buffer(struct tty_struct *tty);
|
|
|
|
static int klsi_105_write_room(struct tty_struct *tty);
|
|
|
|
static void klsi_105_read_bulk_callback(struct urb *urb);
|
|
|
|
static void klsi_105_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, struct ktermios *old);
|
|
|
|
static void klsi_105_throttle(struct tty_struct *tty);
|
|
|
|
static void klsi_105_unthrottle(struct tty_struct *tty);
|
|
|
|
static int klsi_105_tiocmget(struct tty_struct *tty, struct file *file);
|
|
|
|
static int klsi_105_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int set, unsigned int clear);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/*
|
|
|
|
* All of the device info needed for the KLSI converters.
|
|
|
|
*/
|
2010-01-10 07:34:24 -07:00
|
|
|
static const struct usb_device_id id_table[] = {
|
2005-04-16 16:20:36 -06:00
|
|
|
{ USB_DEVICE(PALMCONNECT_VID, PALMCONNECT_PID) },
|
|
|
|
{ USB_DEVICE(KLSI_VID, KLSI_KL5KUSB105D_PID) },
|
|
|
|
{ } /* Terminating entry */
|
|
|
|
};
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
MODULE_DEVICE_TABLE(usb, id_table);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
static struct usb_driver kl5kusb105d_driver = {
|
|
|
|
.name = "kl5kusb105d",
|
|
|
|
.probe = usb_serial_probe,
|
|
|
|
.disconnect = usb_serial_disconnect,
|
|
|
|
.id_table = id_table,
|
2005-11-16 14:41:28 -07:00
|
|
|
.no_dynamic_id = 1,
|
2005-04-16 16:20:36 -06:00
|
|
|
};
|
|
|
|
|
2005-06-20 22:15:16 -06:00
|
|
|
static struct usb_serial_driver kl5kusb105d_device = {
|
2005-06-20 22:15:16 -06:00
|
|
|
.driver = {
|
|
|
|
.owner = THIS_MODULE,
|
2005-06-20 22:15:16 -06:00
|
|
|
.name = "kl5kusb105d",
|
2005-06-20 22:15:16 -06:00
|
|
|
},
|
2005-06-20 22:15:16 -06:00
|
|
|
.description = "KL5KUSB105D / PalmConnect",
|
2006-12-17 13:50:24 -07:00
|
|
|
.usb_driver = &kl5kusb105d_driver,
|
2005-04-16 16:20:36 -06:00
|
|
|
.id_table = id_table,
|
|
|
|
.num_ports = 1,
|
|
|
|
.open = klsi_105_open,
|
|
|
|
.close = klsi_105_close,
|
|
|
|
.write = klsi_105_write,
|
|
|
|
.write_bulk_callback = klsi_105_write_bulk_callback,
|
|
|
|
.chars_in_buffer = klsi_105_chars_in_buffer,
|
|
|
|
.write_room = klsi_105_write_room,
|
2008-07-22 04:14:00 -06:00
|
|
|
.read_bulk_callback = klsi_105_read_bulk_callback,
|
2005-04-16 16:20:36 -06:00
|
|
|
.set_termios = klsi_105_set_termios,
|
|
|
|
/*.break_ctl = klsi_105_break_ctl,*/
|
|
|
|
.tiocmget = klsi_105_tiocmget,
|
|
|
|
.tiocmset = klsi_105_tiocmset,
|
|
|
|
.attach = klsi_105_startup,
|
2009-06-02 09:53:55 -06:00
|
|
|
.disconnect = klsi_105_disconnect,
|
|
|
|
.release = klsi_105_release,
|
2005-04-16 16:20:36 -06:00
|
|
|
.throttle = klsi_105_throttle,
|
|
|
|
.unthrottle = klsi_105_unthrottle,
|
|
|
|
};
|
|
|
|
|
|
|
|
struct klsi_105_port_settings {
|
|
|
|
__u8 pktlen; /* always 5, it seems */
|
|
|
|
__u8 baudrate;
|
|
|
|
__u8 databits;
|
|
|
|
__u8 unknown1;
|
|
|
|
__u8 unknown2;
|
|
|
|
} __attribute__ ((packed));
|
|
|
|
|
|
|
|
/* we implement a pool of NUM_URBS urbs per usb_serial */
|
|
|
|
#define NUM_URBS 1
|
|
|
|
#define URB_TRANSFER_BUFFER_SIZE 64
|
|
|
|
struct klsi_105_private {
|
|
|
|
struct klsi_105_port_settings cfg;
|
2006-12-08 03:38:45 -07:00
|
|
|
struct ktermios termios;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long line_state; /* modem line settings */
|
|
|
|
/* write pool */
|
2008-07-22 04:14:00 -06:00
|
|
|
struct urb *write_urb_pool[NUM_URBS];
|
2005-04-16 16:20:36 -06:00
|
|
|
spinlock_t lock;
|
|
|
|
unsigned long bytes_in;
|
|
|
|
unsigned long bytes_out;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Handle vendor specific USB requests
|
|
|
|
*/
|
|
|
|
|
|
|
|
|
|
|
|
#define KLSI_TIMEOUT 5000 /* default urb timeout */
|
|
|
|
|
|
|
|
static int klsi_105_chg_port_settings(struct usb_serial_port *port,
|
|
|
|
struct klsi_105_port_settings *settings)
|
|
|
|
{
|
|
|
|
int rc;
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
rc = usb_control_msg(port->serial->dev,
|
|
|
|
usb_sndctrlpipe(port->serial->dev, 0),
|
|
|
|
KL5KUSB105A_SIO_SET_DATA,
|
|
|
|
USB_TYPE_VENDOR | USB_DIR_OUT | USB_RECIP_INTERFACE,
|
|
|
|
0, /* value */
|
|
|
|
0, /* index */
|
|
|
|
settings,
|
|
|
|
sizeof(struct klsi_105_port_settings),
|
|
|
|
KLSI_TIMEOUT);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (rc < 0)
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"Change port settings failed (error = %d)\n", rc);
|
2008-08-18 14:21:04 -06:00
|
|
|
dev_info(&port->serial->dev->dev,
|
|
|
|
"%d byte block, baudrate %x, databits %d, u1 %d, u2 %d\n",
|
|
|
|
settings->pktlen, settings->baudrate, settings->databits,
|
|
|
|
settings->unknown1, settings->unknown2);
|
2008-07-22 04:14:00 -06:00
|
|
|
return rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* klsi_105_chg_port_settings */
|
|
|
|
|
|
|
|
/* translate a 16-bit status value from the device to linux's TIO bits */
|
|
|
|
static unsigned long klsi_105_status2linestate(const __u16 status)
|
|
|
|
{
|
|
|
|
unsigned long res = 0;
|
|
|
|
|
|
|
|
res = ((status & KL5KUSB105A_DSR) ? TIOCM_DSR : 0)
|
|
|
|
| ((status & KL5KUSB105A_CTS) ? TIOCM_CTS : 0)
|
|
|
|
;
|
|
|
|
|
|
|
|
return res;
|
|
|
|
}
|
2008-07-22 04:14:00 -06:00
|
|
|
/*
|
2005-04-16 16:20:36 -06:00
|
|
|
* Read line control via vendor command and return result through
|
2008-07-22 04:14:00 -06:00
|
|
|
* *line_state_p
|
2005-04-16 16:20:36 -06:00
|
|
|
*/
|
|
|
|
/* It seems that the status buffer has always only 2 bytes length */
|
|
|
|
#define KLSI_STATUSBUF_LEN 2
|
|
|
|
static int klsi_105_get_line_state(struct usb_serial_port *port,
|
|
|
|
unsigned long *line_state_p)
|
|
|
|
{
|
|
|
|
int rc;
|
2009-12-28 15:01:52 -07:00
|
|
|
u8 *status_buf;
|
2005-04-16 16:20:36 -06:00
|
|
|
__u16 status;
|
|
|
|
|
2008-08-18 14:21:04 -06:00
|
|
|
dev_info(&port->serial->dev->dev, "sending SIO Poll request\n");
|
2009-12-28 15:01:52 -07:00
|
|
|
|
|
|
|
status_buf = kmalloc(KLSI_STATUSBUF_LEN, GFP_KERNEL);
|
|
|
|
if (!status_buf) {
|
|
|
|
dev_err(&port->dev, "%s - out of memory for status buffer.\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
status_buf[0] = 0xff;
|
|
|
|
status_buf[1] = 0xff;
|
2008-07-22 04:14:00 -06:00
|
|
|
rc = usb_control_msg(port->serial->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
usb_rcvctrlpipe(port->serial->dev, 0),
|
|
|
|
KL5KUSB105A_SIO_POLL,
|
2008-07-22 04:14:00 -06:00
|
|
|
USB_TYPE_VENDOR | USB_DIR_IN,
|
2005-04-16 16:20:36 -06:00
|
|
|
0, /* value */
|
|
|
|
0, /* index */
|
|
|
|
status_buf, KLSI_STATUSBUF_LEN,
|
|
|
|
10000
|
|
|
|
);
|
|
|
|
if (rc < 0)
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev, "Reading line status failed (error = %d)\n",
|
|
|
|
rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
else {
|
2008-05-01 21:52:57 -06:00
|
|
|
status = get_unaligned_le16(status_buf);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-08-18 14:21:04 -06:00
|
|
|
dev_info(&port->serial->dev->dev, "read status %x %x",
|
|
|
|
status_buf[0], status_buf[1]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
*line_state_p = klsi_105_status2linestate(status);
|
|
|
|
}
|
2009-12-28 15:01:52 -07:00
|
|
|
|
|
|
|
kfree(status_buf);
|
2008-07-22 04:14:00 -06:00
|
|
|
return rc;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Driver's tty interface functions
|
|
|
|
*/
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_startup(struct usb_serial *serial)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct klsi_105_private *priv;
|
2007-03-29 03:23:54 -06:00
|
|
|
int i, j;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* check if we support the product id (see keyspan.c)
|
|
|
|
* FIXME
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* allocate the private data structure */
|
2008-07-22 04:14:00 -06:00
|
|
|
for (i = 0; i < serial->num_ports; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
priv = kmalloc(sizeof(struct klsi_105_private),
|
|
|
|
GFP_KERNEL);
|
|
|
|
if (!priv) {
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%skmalloc for klsi_105_private failed.", __func__);
|
2007-03-29 03:23:54 -06:00
|
|
|
i--;
|
|
|
|
goto err_cleanup;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
/* set initial values for control structures */
|
|
|
|
priv->cfg.pktlen = 5;
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b9600;
|
|
|
|
priv->cfg.databits = kl5kusb105a_dtb_8;
|
|
|
|
priv->cfg.unknown1 = 0;
|
|
|
|
priv->cfg.unknown2 = 1;
|
|
|
|
|
|
|
|
priv->line_state = 0;
|
|
|
|
|
|
|
|
priv->bytes_in = 0;
|
|
|
|
priv->bytes_out = 0;
|
|
|
|
usb_set_serial_port_data(serial->port[i], priv);
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_init(&priv->lock);
|
|
|
|
for (j = 0; j < NUM_URBS; j++) {
|
|
|
|
struct urb *urb = usb_alloc_urb(0, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
priv->write_urb_pool[j] = urb;
|
|
|
|
if (urb == NULL) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&serial->dev->dev, "No more urbs???\n");
|
2007-03-29 03:23:54 -06:00
|
|
|
goto err_cleanup;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
urb->transfer_buffer =
|
|
|
|
kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (!urb->transfer_buffer) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&serial->dev->dev,
|
|
|
|
"%s - out of memory for urb buffers.\n",
|
|
|
|
__func__);
|
2007-03-29 03:23:54 -06:00
|
|
|
goto err_cleanup;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* priv->termios is left uninitalized until port opening */
|
|
|
|
init_waitqueue_head(&serial->port[i]->write_wait);
|
|
|
|
}
|
2008-07-22 04:14:00 -06:00
|
|
|
|
2007-03-29 03:23:54 -06:00
|
|
|
return 0;
|
|
|
|
|
|
|
|
err_cleanup:
|
|
|
|
for (; i >= 0; i--) {
|
|
|
|
priv = usb_get_serial_port_data(serial->port[i]);
|
2008-07-22 04:14:00 -06:00
|
|
|
for (j = 0; j < NUM_URBS; j++) {
|
2007-03-29 03:23:54 -06:00
|
|
|
if (priv->write_urb_pool[j]) {
|
|
|
|
kfree(priv->write_urb_pool[j]->transfer_buffer);
|
|
|
|
usb_free_urb(priv->write_urb_pool[j]);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
usb_set_serial_port_data(serial->port[i], NULL);
|
|
|
|
}
|
|
|
|
return -ENOMEM;
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* klsi_105_startup */
|
|
|
|
|
|
|
|
|
2009-06-02 09:53:55 -06:00
|
|
|
static void klsi_105_disconnect(struct usb_serial *serial)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int i;
|
2008-07-22 04:14:00 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* stop reads and writes on all ports */
|
2008-07-22 04:14:00 -06:00
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
|
|
|
struct klsi_105_private *priv =
|
|
|
|
usb_get_serial_port_data(serial->port[i]);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if (priv) {
|
|
|
|
/* kill our write urb pool */
|
|
|
|
int j;
|
|
|
|
struct urb **write_urbs = priv->write_urb_pool;
|
|
|
|
|
|
|
|
for (j = 0; j < NUM_URBS; j++) {
|
|
|
|
if (write_urbs[j]) {
|
2009-06-02 09:53:55 -06:00
|
|
|
usb_kill_urb(write_urbs[j]);
|
2008-07-22 04:14:00 -06:00
|
|
|
usb_free_urb(write_urbs[j]);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2009-06-02 09:53:55 -06:00
|
|
|
} /* klsi_105_disconnect */
|
|
|
|
|
|
|
|
|
|
|
|
static void klsi_105_release(struct usb_serial *serial)
|
|
|
|
{
|
|
|
|
int i;
|
|
|
|
|
|
|
|
dbg("%s", __func__);
|
|
|
|
|
|
|
|
for (i = 0; i < serial->num_ports; ++i) {
|
|
|
|
struct klsi_105_private *priv =
|
|
|
|
usb_get_serial_port_data(serial->port[i]);
|
|
|
|
|
|
|
|
kfree(priv);
|
|
|
|
}
|
|
|
|
} /* klsi_105_release */
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-09-19 14:13:26 -06:00
|
|
|
static int klsi_105_open(struct tty_struct *tty, struct usb_serial_port *port)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int retval = 0;
|
|
|
|
int rc;
|
|
|
|
int i;
|
|
|
|
unsigned long line_state;
|
2009-12-28 15:01:52 -07:00
|
|
|
struct klsi_105_port_settings *cfg;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags;
|
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s port %d", __func__, port->number);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* Do a defined restart:
|
|
|
|
* Set up sane default baud rate and send the 'READ_ON'
|
2008-07-22 04:14:00 -06:00
|
|
|
* vendor command.
|
2005-04-16 16:20:36 -06:00
|
|
|
* FIXME: set modem line control (how?)
|
|
|
|
* Then read the modem line control and store values in
|
|
|
|
* priv->line_state.
|
|
|
|
*/
|
2009-12-28 15:01:52 -07:00
|
|
|
cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
|
|
|
|
if (!cfg) {
|
|
|
|
dev_err(&port->dev, "%s - out of memory for config buffer.\n",
|
|
|
|
__func__);
|
|
|
|
return -ENOMEM;
|
|
|
|
}
|
|
|
|
cfg->pktlen = 5;
|
|
|
|
cfg->baudrate = kl5kusb105a_sio_b9600;
|
|
|
|
cfg->databits = kl5kusb105a_dtb_8;
|
|
|
|
cfg->unknown1 = 0;
|
|
|
|
cfg->unknown2 = 1;
|
|
|
|
klsi_105_chg_port_settings(port, cfg);
|
2008-07-22 04:14:00 -06:00
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* set up termios structure */
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2008-07-22 04:09:07 -06:00
|
|
|
priv->termios.c_iflag = tty->termios->c_iflag;
|
|
|
|
priv->termios.c_oflag = tty->termios->c_oflag;
|
|
|
|
priv->termios.c_cflag = tty->termios->c_cflag;
|
|
|
|
priv->termios.c_lflag = tty->termios->c_lflag;
|
2008-07-22 04:14:00 -06:00
|
|
|
for (i = 0; i < NCCS; i++)
|
2008-07-22 04:09:07 -06:00
|
|
|
priv->termios.c_cc[i] = tty->termios->c_cc[i];
|
2009-12-28 15:01:52 -07:00
|
|
|
priv->cfg.pktlen = cfg->pktlen;
|
|
|
|
priv->cfg.baudrate = cfg->baudrate;
|
|
|
|
priv->cfg.databits = cfg->databits;
|
|
|
|
priv->cfg.unknown1 = cfg->unknown1;
|
|
|
|
priv->cfg.unknown2 = cfg->unknown2;
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* READ_ON and urb submission */
|
2008-07-22 04:14:00 -06:00
|
|
|
usb_fill_bulk_urb(port->read_urb, port->serial->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
usb_rcvbulkpipe(port->serial->dev,
|
|
|
|
port->bulk_in_endpointAddress),
|
|
|
|
port->read_urb->transfer_buffer,
|
|
|
|
port->read_urb->transfer_buffer_length,
|
|
|
|
klsi_105_read_bulk_callback,
|
|
|
|
port);
|
|
|
|
|
|
|
|
rc = usb_submit_urb(port->read_urb, GFP_KERNEL);
|
|
|
|
if (rc) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev, "%s - failed submitting read urb, "
|
|
|
|
"error %d\n", __func__, rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = rc;
|
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
rc = usb_control_msg(port->serial->dev,
|
2008-07-22 04:14:00 -06:00
|
|
|
usb_sndctrlpipe(port->serial->dev, 0),
|
2005-04-16 16:20:36 -06:00
|
|
|
KL5KUSB105A_SIO_CONFIGURE,
|
|
|
|
USB_TYPE_VENDOR|USB_DIR_OUT|USB_RECIP_INTERFACE,
|
|
|
|
KL5KUSB105A_SIO_CONFIGURE_READ_ON,
|
|
|
|
0, /* index */
|
|
|
|
NULL,
|
|
|
|
0,
|
|
|
|
KLSI_TIMEOUT);
|
|
|
|
if (rc < 0) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev, "Enabling read failed (error = %d)\n", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = rc;
|
2008-07-22 04:14:00 -06:00
|
|
|
} else
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - enabled reading", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rc = klsi_105_get_line_state(port, &line_state);
|
|
|
|
if (rc >= 0) {
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
priv->line_state = line_state;
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - read line state 0x%lx", __func__, line_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
retval = 0;
|
|
|
|
} else
|
|
|
|
retval = rc;
|
|
|
|
|
|
|
|
exit:
|
2009-12-28 15:01:52 -07:00
|
|
|
kfree(cfg);
|
2005-04-16 16:20:36 -06:00
|
|
|
return retval;
|
|
|
|
} /* klsi_105_open */
|
|
|
|
|
|
|
|
|
2009-06-11 05:26:29 -06:00
|
|
|
static void klsi_105_close(struct usb_serial_port *port)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int rc;
|
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s port %d", __func__, port->number);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-01-22 04:47:15 -07:00
|
|
|
mutex_lock(&port->serial->disc_mutex);
|
|
|
|
if (!port->serial->disconnected) {
|
|
|
|
/* send READ_OFF */
|
2008-07-22 04:14:00 -06:00
|
|
|
rc = usb_control_msg(port->serial->dev,
|
|
|
|
usb_sndctrlpipe(port->serial->dev, 0),
|
|
|
|
KL5KUSB105A_SIO_CONFIGURE,
|
|
|
|
USB_TYPE_VENDOR | USB_DIR_OUT,
|
|
|
|
KL5KUSB105A_SIO_CONFIGURE_READ_OFF,
|
|
|
|
0, /* index */
|
|
|
|
NULL, 0,
|
|
|
|
KLSI_TIMEOUT);
|
2008-01-22 04:47:15 -07:00
|
|
|
if (rc < 0)
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"Disabling read failed (error = %d)\n", rc);
|
2008-01-22 04:47:15 -07:00
|
|
|
}
|
|
|
|
mutex_unlock(&port->serial->disc_mutex);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* shutdown our bulk reads and writes */
|
|
|
|
usb_kill_urb(port->write_urb);
|
|
|
|
usb_kill_urb(port->read_urb);
|
|
|
|
/* unlink our write pool */
|
|
|
|
/* FIXME */
|
|
|
|
/* wgg - do I need this? I think so. */
|
|
|
|
usb_kill_urb(port->interrupt_in_urb);
|
2008-08-18 14:21:04 -06:00
|
|
|
dev_info(&port->serial->dev->dev,
|
|
|
|
"port stats: %ld bytes in, %ld bytes out\n",
|
|
|
|
priv->bytes_in, priv->bytes_out);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* klsi_105_close */
|
|
|
|
|
|
|
|
|
|
|
|
/* We need to write a complete 64-byte data block and encode the
|
2008-07-22 04:14:00 -06:00
|
|
|
* number actually sent in the first double-byte, LSB-order. That
|
2005-04-16 16:20:36 -06:00
|
|
|
* leaves at most 62 bytes of payload.
|
|
|
|
*/
|
|
|
|
#define KLSI_105_DATA_OFFSET 2 /* in the bulk urb data block */
|
|
|
|
|
|
|
|
|
2008-07-22 04:09:07 -06:00
|
|
|
static int klsi_105_write(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port, const unsigned char *buf, int count)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
int result, size;
|
2008-07-22 04:14:00 -06:00
|
|
|
int bytes_sent = 0;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
while (count > 0) {
|
|
|
|
/* try to find a free urb (write 0 bytes if none) */
|
|
|
|
struct urb *urb = NULL;
|
|
|
|
unsigned long flags;
|
|
|
|
int i;
|
2008-07-22 04:14:00 -06:00
|
|
|
/* since the pool is per-port we might not need
|
|
|
|
the spin lock !? */
|
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
for (i = 0; i < NUM_URBS; i++) {
|
2005-04-16 16:20:36 -06:00
|
|
|
if (priv->write_urb_pool[i]->status != -EINPROGRESS) {
|
|
|
|
urb = priv->write_urb_pool[i];
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - using pool URB %d", __func__, i);
|
2005-04-16 16:20:36 -06:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
if (urb == NULL) {
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - no more free urbs", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (urb->transfer_buffer == NULL) {
|
2008-07-22 04:14:00 -06:00
|
|
|
urb->transfer_buffer =
|
|
|
|
kmalloc(URB_TRANSFER_BUFFER_SIZE, GFP_ATOMIC);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (urb->transfer_buffer == NULL) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s - no more kernel memory...\n",
|
|
|
|
__func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
size = min(count, port->bulk_out_size - KLSI_105_DATA_OFFSET);
|
|
|
|
size = min(size, URB_TRANSFER_BUFFER_SIZE -
|
|
|
|
KLSI_105_DATA_OFFSET);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
memcpy(urb->transfer_buffer + KLSI_105_DATA_OFFSET, buf, size);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* write payload size into transfer buffer */
|
|
|
|
((__u8 *)urb->transfer_buffer)[0] = (__u8) (size & 0xFF);
|
|
|
|
((__u8 *)urb->transfer_buffer)[1] = (__u8) ((size & 0xFF00)>>8);
|
|
|
|
|
|
|
|
/* set up our urb */
|
|
|
|
usb_fill_bulk_urb(urb, port->serial->dev,
|
|
|
|
usb_sndbulkpipe(port->serial->dev,
|
|
|
|
port->bulk_out_endpointAddress),
|
|
|
|
urb->transfer_buffer,
|
|
|
|
URB_TRANSFER_BUFFER_SIZE,
|
|
|
|
klsi_105_write_bulk_callback,
|
|
|
|
port);
|
|
|
|
|
|
|
|
/* send the data out the bulk port */
|
|
|
|
result = usb_submit_urb(urb, GFP_ATOMIC);
|
|
|
|
if (result) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s - failed submitting write urb, error %d\n",
|
|
|
|
__func__, result);
|
2005-04-16 16:20:36 -06:00
|
|
|
goto exit;
|
|
|
|
}
|
|
|
|
buf += size;
|
|
|
|
bytes_sent += size;
|
|
|
|
count -= size;
|
|
|
|
}
|
|
|
|
exit:
|
|
|
|
/* lockless, but it's for debug info only... */
|
2008-07-22 04:14:00 -06:00
|
|
|
priv->bytes_out += bytes_sent;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
return bytes_sent; /* that's how much we wrote */
|
|
|
|
} /* klsi_105_write */
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static void klsi_105_write_bulk_callback(struct urb *urb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-24 03:41:47 -07:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2007-06-15 16:44:13 -06:00
|
|
|
int status = urb->status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2007-06-15 16:44:13 -06:00
|
|
|
|
|
|
|
if (status) {
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - nonzero write bulk status received: %d", __func__,
|
2007-06-15 16:44:13 -06:00
|
|
|
status);
|
2005-04-16 16:20:36 -06:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2006-05-22 22:58:49 -06:00
|
|
|
usb_serial_port_softint(port);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* klsi_105_write_bulk_completion_callback */
|
|
|
|
|
|
|
|
|
|
|
|
/* return number of characters currently in the writing process */
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_chars_in_buffer(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:09:07 -06:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
int chars = 0;
|
|
|
|
int i;
|
|
|
|
unsigned long flags;
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
for (i = 0; i < NUM_URBS; ++i) {
|
2008-07-22 04:14:00 -06:00
|
|
|
if (priv->write_urb_pool[i]->status == -EINPROGRESS)
|
2005-04-16 16:20:36 -06:00
|
|
|
chars += URB_TRANSFER_BUFFER_SIZE;
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - returns %d", __func__, chars);
|
2008-07-22 04:14:00 -06:00
|
|
|
return chars;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_write_room(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:09:07 -06:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags;
|
|
|
|
int i;
|
|
|
|
int room = 0;
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
for (i = 0; i < NUM_URBS; ++i) {
|
2008-07-22 04:14:00 -06:00
|
|
|
if (priv->write_urb_pool[i]->status != -EINPROGRESS)
|
2005-04-16 16:20:36 -06:00
|
|
|
room += URB_TRANSFER_BUFFER_SIZE;
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - returns %d", __func__, room);
|
2008-07-22 04:14:00 -06:00
|
|
|
return room;
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static void klsi_105_read_bulk_callback(struct urb *urb)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-02-24 03:41:47 -07:00
|
|
|
struct usb_serial_port *port = urb->context;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
struct tty_struct *tty;
|
|
|
|
unsigned char *data = urb->transfer_buffer;
|
|
|
|
int rc;
|
2007-06-15 16:44:13 -06:00
|
|
|
int status = urb->status;
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* The urb might have been killed. */
|
2007-06-15 16:44:13 -06:00
|
|
|
if (status) {
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - nonzero read bulk status received: %d", __func__,
|
2007-06-15 16:44:13 -06:00
|
|
|
status);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* The data received is again preceded by a length double-byte in LSB-
|
|
|
|
* first order (see klsi_105_write() )
|
|
|
|
*/
|
|
|
|
if (urb->actual_length == 0) {
|
|
|
|
/* empty urbs seem to happen, we ignore them */
|
2008-03-03 17:08:34 -07:00
|
|
|
/* dbg("%s - emtpy URB", __func__); */
|
2005-04-16 16:20:36 -06:00
|
|
|
;
|
|
|
|
} else if (urb->actual_length <= 2) {
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - size %d URB not understood", __func__,
|
2005-04-16 16:20:36 -06:00
|
|
|
urb->actual_length);
|
2008-03-03 17:08:34 -07:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
2005-04-16 16:20:36 -06:00
|
|
|
urb->actual_length, data);
|
|
|
|
} else {
|
|
|
|
int bytes_sent = ((__u8 *) data)[0] +
|
|
|
|
((unsigned int) ((__u8 *) data)[1] << 8);
|
2008-10-13 03:39:46 -06:00
|
|
|
tty = tty_port_tty_get(&port->port);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* we should immediately resubmit the URB, before attempting
|
|
|
|
* to pass the data on to the tty layer. But that needs locking
|
|
|
|
* against re-entry an then mixed-up data because of
|
|
|
|
* intermixed tty_flip_buffer_push()s
|
|
|
|
* FIXME
|
2008-07-22 04:14:00 -06:00
|
|
|
*/
|
2008-03-03 17:08:34 -07:00
|
|
|
usb_serial_debug_data(debug, &port->dev, __func__,
|
2005-04-16 16:20:36 -06:00
|
|
|
urb->actual_length, data);
|
|
|
|
|
|
|
|
if (bytes_sent + 2 > urb->actual_length) {
|
|
|
|
dbg("%s - trying to read more data than available"
|
2008-03-03 17:08:34 -07:00
|
|
|
" (%d vs. %d)", __func__,
|
2005-04-16 16:20:36 -06:00
|
|
|
bytes_sent+2, urb->actual_length);
|
|
|
|
/* cap at implied limit */
|
|
|
|
bytes_sent = urb->actual_length - 2;
|
|
|
|
}
|
|
|
|
|
[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-09 21:54:13 -07:00
|
|
|
tty_insert_flip_string(tty, data + 2, bytes_sent);
|
2005-04-16 16:20:36 -06:00
|
|
|
tty_flip_buffer_push(tty);
|
2008-10-13 03:39:46 -06:00
|
|
|
tty_kref_put(tty);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* again lockless, but debug info only */
|
|
|
|
priv->bytes_in += bytes_sent;
|
|
|
|
}
|
|
|
|
/* Continue trying to always read */
|
2008-07-22 04:14:00 -06:00
|
|
|
usb_fill_bulk_urb(port->read_urb, port->serial->dev,
|
2005-04-16 16:20:36 -06:00
|
|
|
usb_rcvbulkpipe(port->serial->dev,
|
|
|
|
port->bulk_in_endpointAddress),
|
|
|
|
port->read_urb->transfer_buffer,
|
|
|
|
port->read_urb->transfer_buffer_length,
|
|
|
|
klsi_105_read_bulk_callback,
|
|
|
|
port);
|
|
|
|
rc = usb_submit_urb(port->read_urb, GFP_ATOMIC);
|
|
|
|
if (rc)
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s - failed resubmitting read urb, error %d\n",
|
|
|
|
__func__, rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* klsi_105_read_bulk_callback */
|
|
|
|
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static void klsi_105_set_termios(struct tty_struct *tty,
|
|
|
|
struct usb_serial_port *port,
|
|
|
|
struct ktermios *old_termios)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
2008-04-08 10:16:06 -06:00
|
|
|
unsigned int iflag = tty->termios->c_iflag;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int old_iflag = old_termios->c_iflag;
|
2008-04-08 10:16:06 -06:00
|
|
|
unsigned int cflag = tty->termios->c_cflag;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned int old_cflag = old_termios->c_cflag;
|
2009-12-28 15:01:52 -07:00
|
|
|
struct klsi_105_port_settings *cfg;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned long flags;
|
2008-04-08 10:16:06 -06:00
|
|
|
speed_t baud;
|
2008-07-22 04:14:00 -06:00
|
|
|
|
2009-12-28 15:01:52 -07:00
|
|
|
cfg = kmalloc(sizeof(*cfg), GFP_KERNEL);
|
|
|
|
if (!cfg) {
|
|
|
|
dev_err(&port->dev, "%s - out of memory for config buffer.\n",
|
|
|
|
__func__);
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* lock while we are modifying the settings */
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/*
|
|
|
|
* Update baud rate
|
|
|
|
*/
|
2008-04-08 10:16:06 -06:00
|
|
|
baud = tty_get_baud_rate(tty);
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
if ((cflag & CBAUD) != (old_cflag & CBAUD)) {
|
|
|
|
/* reassert DTR and (maybe) RTS on transition from B0 */
|
|
|
|
if ((old_cflag & CBAUD) == B0) {
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s: baud was B0", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
#if 0
|
|
|
|
priv->control_state |= TIOCM_DTR;
|
|
|
|
/* don't set RTS if using hardware flow control */
|
2008-07-22 04:14:00 -06:00
|
|
|
if (!(old_cflag & CRTSCTS))
|
2005-04-16 16:20:36 -06:00
|
|
|
priv->control_state |= TIOCM_RTS;
|
|
|
|
mct_u232_set_modem_ctrl(serial, priv->control_state);
|
|
|
|
#endif
|
|
|
|
}
|
2008-04-08 10:16:06 -06:00
|
|
|
}
|
2008-07-22 04:14:00 -06:00
|
|
|
switch (baud) {
|
|
|
|
case 0: /* handled below */
|
|
|
|
break;
|
|
|
|
case 1200:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b1200;
|
|
|
|
break;
|
|
|
|
case 2400:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b2400;
|
|
|
|
break;
|
|
|
|
case 4800:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b4800;
|
|
|
|
break;
|
|
|
|
case 9600:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b9600;
|
|
|
|
break;
|
|
|
|
case 19200:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b19200;
|
|
|
|
break;
|
|
|
|
case 38400:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b38400;
|
|
|
|
break;
|
|
|
|
case 57600:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b57600;
|
|
|
|
break;
|
|
|
|
case 115200:
|
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b115200;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
dbg("KLSI USB->Serial converter:"
|
|
|
|
" unsupported baudrate request, using default of 9600");
|
2007-08-10 15:53:34 -06:00
|
|
|
priv->cfg.baudrate = kl5kusb105a_sio_b9600;
|
2008-07-22 04:14:00 -06:00
|
|
|
baud = 9600;
|
|
|
|
break;
|
2008-04-08 10:16:06 -06:00
|
|
|
}
|
2008-07-22 04:14:00 -06:00
|
|
|
if ((cflag & CBAUD) == B0) {
|
2008-04-08 10:16:06 -06:00
|
|
|
dbg("%s: baud is B0", __func__);
|
|
|
|
/* Drop RTS and DTR */
|
|
|
|
/* maybe this should be simulated by sending read
|
|
|
|
* disable and read enable messages?
|
|
|
|
*/
|
|
|
|
;
|
2005-04-16 16:20:36 -06:00
|
|
|
#if 0
|
2008-04-08 10:16:06 -06:00
|
|
|
priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
|
2008-07-22 04:14:00 -06:00
|
|
|
mct_u232_set_modem_ctrl(serial, priv->control_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
#endif
|
|
|
|
}
|
2008-04-08 10:16:06 -06:00
|
|
|
tty_encode_baud_rate(tty, baud, baud);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
if ((cflag & CSIZE) != (old_cflag & CSIZE)) {
|
|
|
|
/* set the number of data bits */
|
|
|
|
switch (cflag & CSIZE) {
|
|
|
|
case CS5:
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - 5 bits/byte not supported", __func__);
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2009-12-28 15:01:52 -07:00
|
|
|
goto err;
|
2005-04-16 16:20:36 -06:00
|
|
|
case CS6:
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - 6 bits/byte not supported", __func__);
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2009-12-28 15:01:52 -07:00
|
|
|
goto err;
|
2005-04-16 16:20:36 -06:00
|
|
|
case CS7:
|
|
|
|
priv->cfg.databits = kl5kusb105a_dtb_7;
|
|
|
|
break;
|
|
|
|
case CS8:
|
|
|
|
priv->cfg.databits = kl5kusb105a_dtb_8;
|
|
|
|
break;
|
|
|
|
default:
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"CSIZE was not CS5-CS8, using default of 8\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
priv->cfg.databits = kl5kusb105a_dtb_8;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Update line control register (LCR)
|
|
|
|
*/
|
|
|
|
if ((cflag & (PARENB|PARODD)) != (old_cflag & (PARENB|PARODD))
|
2008-07-22 04:14:00 -06:00
|
|
|
|| (cflag & CSTOPB) != (old_cflag & CSTOPB)) {
|
2008-04-08 10:16:06 -06:00
|
|
|
/* Not currently supported */
|
|
|
|
tty->termios->c_cflag &= ~(PARENB|PARODD|CSTOPB);
|
2005-04-16 16:20:36 -06:00
|
|
|
#if 0
|
|
|
|
priv->last_lcr = 0;
|
|
|
|
|
|
|
|
/* set the parity */
|
|
|
|
if (cflag & PARENB)
|
|
|
|
priv->last_lcr |= (cflag & PARODD) ?
|
|
|
|
MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN;
|
|
|
|
else
|
|
|
|
priv->last_lcr |= MCT_U232_PARITY_NONE;
|
|
|
|
|
|
|
|
/* set the number of stop bits */
|
|
|
|
priv->last_lcr |= (cflag & CSTOPB) ?
|
|
|
|
MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1;
|
|
|
|
|
|
|
|
mct_u232_set_line_ctrl(serial, priv->last_lcr);
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
}
|
|
|
|
/*
|
|
|
|
* Set flow control: well, I do not really now how to handle DTR/RTS.
|
|
|
|
* Just do what we have seen with SniffUSB on Win98.
|
|
|
|
*/
|
2008-07-22 04:14:00 -06:00
|
|
|
if ((iflag & IXOFF) != (old_iflag & IXOFF)
|
2005-04-16 16:20:36 -06:00
|
|
|
|| (iflag & IXON) != (old_iflag & IXON)
|
2008-07-22 04:14:00 -06:00
|
|
|
|| (cflag & CRTSCTS) != (old_cflag & CRTSCTS)) {
|
2008-04-08 10:16:06 -06:00
|
|
|
/* Not currently supported */
|
|
|
|
tty->termios->c_cflag &= ~CRTSCTS;
|
2005-04-16 16:20:36 -06:00
|
|
|
/* Drop DTR/RTS if no flow control otherwise assert */
|
|
|
|
#if 0
|
2008-07-22 04:14:00 -06:00
|
|
|
if ((iflag & IXOFF) || (iflag & IXON) || (cflag & CRTSCTS))
|
2005-04-16 16:20:36 -06:00
|
|
|
priv->control_state |= TIOCM_DTR | TIOCM_RTS;
|
|
|
|
else
|
|
|
|
priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS);
|
|
|
|
mct_u232_set_modem_ctrl(serial, priv->control_state);
|
|
|
|
#endif
|
|
|
|
;
|
|
|
|
}
|
2009-12-28 15:01:52 -07:00
|
|
|
memcpy(cfg, &priv->cfg, sizeof(*cfg));
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
|
|
|
|
2005-04-16 16:20:36 -06:00
|
|
|
/* now commit changes to device */
|
2009-12-28 15:01:52 -07:00
|
|
|
klsi_105_chg_port_settings(port, cfg);
|
|
|
|
err:
|
|
|
|
kfree(cfg);
|
2005-04-16 16:20:36 -06:00
|
|
|
} /* klsi_105_set_termios */
|
|
|
|
|
|
|
|
|
|
|
|
#if 0
|
2008-07-22 04:14:00 -06:00
|
|
|
static void mct_u232_break_ctl(struct tty_struct *tty, int break_state)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:09:07 -06:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct usb_serial *serial = port->serial;
|
2008-07-22 04:14:00 -06:00
|
|
|
struct mct_u232_private *priv =
|
|
|
|
(struct mct_u232_private *)port->private;
|
2005-04-16 16:20:36 -06:00
|
|
|
unsigned char lcr = priv->last_lcr;
|
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%sstate=%d", __func__, break_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2009-01-02 06:48:56 -07:00
|
|
|
/* LOCKING */
|
2005-04-16 16:20:36 -06:00
|
|
|
if (break_state)
|
|
|
|
lcr |= MCT_U232_SET_BREAK;
|
|
|
|
|
|
|
|
mct_u232_set_line_ctrl(serial, lcr);
|
|
|
|
} /* mct_u232_break_ctl */
|
|
|
|
#endif
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_tiocmget(struct tty_struct *tty, struct file *file)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:09:07 -06:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
int rc;
|
|
|
|
unsigned long line_state;
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - request, just guessing", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
rc = klsi_105_get_line_state(port, &line_state);
|
|
|
|
if (rc < 0) {
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"Reading line control failed (error = %d)\n", rc);
|
2005-04-16 16:20:36 -06:00
|
|
|
/* better return value? EAGAIN? */
|
|
|
|
return rc;
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_lock_irqsave(&priv->lock, flags);
|
2005-04-16 16:20:36 -06:00
|
|
|
priv->line_state = line_state;
|
2008-07-22 04:14:00 -06:00
|
|
|
spin_unlock_irqrestore(&priv->lock, flags);
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - read line state 0x%lx", __func__, line_state);
|
2005-04-16 16:20:36 -06:00
|
|
|
return (int)line_state;
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static int klsi_105_tiocmset(struct tty_struct *tty, struct file *file,
|
|
|
|
unsigned int set, unsigned int clear)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int retval = -EINVAL;
|
2008-07-22 04:14:00 -06:00
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s", __func__);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
/* if this ever gets implemented, it should be done something like this:
|
|
|
|
struct usb_serial *serial = port->serial;
|
|
|
|
struct klsi_105_private *priv = usb_get_serial_port_data(port);
|
|
|
|
unsigned long flags;
|
|
|
|
int control;
|
|
|
|
|
|
|
|
spin_lock_irqsave (&priv->lock, flags);
|
|
|
|
if (set & TIOCM_RTS)
|
|
|
|
priv->control_state |= TIOCM_RTS;
|
|
|
|
if (set & TIOCM_DTR)
|
|
|
|
priv->control_state |= TIOCM_DTR;
|
|
|
|
if (clear & TIOCM_RTS)
|
|
|
|
priv->control_state &= ~TIOCM_RTS;
|
|
|
|
if (clear & TIOCM_DTR)
|
|
|
|
priv->control_state &= ~TIOCM_DTR;
|
|
|
|
control = priv->control_state;
|
|
|
|
spin_unlock_irqrestore (&priv->lock, flags);
|
|
|
|
retval = mct_u232_set_modem_ctrl(serial, control);
|
|
|
|
*/
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static void klsi_105_throttle(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:09:07 -06:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-16 16:20:36 -06:00
|
|
|
usb_kill_urb(port->read_urb);
|
|
|
|
}
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static void klsi_105_unthrottle(struct tty_struct *tty)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:09:07 -06:00
|
|
|
struct usb_serial_port *port = tty->driver_data;
|
2005-04-16 16:20:36 -06:00
|
|
|
int result;
|
|
|
|
|
2008-03-03 17:08:34 -07:00
|
|
|
dbg("%s - port %d", __func__, port->number);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
port->read_urb->dev = port->serial->dev;
|
2009-10-07 02:50:23 -06:00
|
|
|
result = usb_submit_urb(port->read_urb, GFP_KERNEL);
|
2005-04-16 16:20:36 -06:00
|
|
|
if (result)
|
2008-08-20 17:56:34 -06:00
|
|
|
dev_err(&port->dev,
|
|
|
|
"%s - failed submitting read urb, error %d\n",
|
|
|
|
__func__, result);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static int __init klsi_105_init(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
|
|
|
int retval;
|
|
|
|
retval = usb_serial_register(&kl5kusb105d_device);
|
|
|
|
if (retval)
|
|
|
|
goto failed_usb_serial_register;
|
|
|
|
retval = usb_register(&kl5kusb105d_driver);
|
|
|
|
if (retval)
|
|
|
|
goto failed_usb_register;
|
|
|
|
|
2008-08-18 14:21:04 -06:00
|
|
|
printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
|
|
|
|
DRIVER_DESC "\n");
|
2005-04-16 16:20:36 -06:00
|
|
|
return 0;
|
|
|
|
failed_usb_register:
|
|
|
|
usb_serial_deregister(&kl5kusb105d_device);
|
|
|
|
failed_usb_serial_register:
|
|
|
|
return retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
static void __exit klsi_105_exit(void)
|
2005-04-16 16:20:36 -06:00
|
|
|
{
|
2008-07-22 04:14:00 -06:00
|
|
|
usb_deregister(&kl5kusb105d_driver);
|
|
|
|
usb_serial_deregister(&kl5kusb105d_device);
|
2005-04-16 16:20:36 -06:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
module_init(klsi_105_init);
|
|
|
|
module_exit(klsi_105_exit);
|
2005-04-16 16:20:36 -06:00
|
|
|
|
2008-07-22 04:14:00 -06:00
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR);
|
|
|
|
MODULE_DESCRIPTION(DRIVER_DESC);
|
|
|
|
MODULE_LICENSE("GPL");
|
2005-04-16 16:20:36 -06:00
|
|
|
|
|
|
|
|
|
|
|
module_param(debug, bool, S_IRUGO | S_IWUSR);
|
|
|
|
MODULE_PARM_DESC(debug, "enable extensive debugging messages");
|
|
|
|
|
|
|
|
/* vim: set sts=8 ts=8 sw=8: */
|