forked from Qortal/Brooklyn
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
776 lines
22 KiB
776 lines
22 KiB
// SPDX-License-Identifier: GPL-2.0+ |
|
/* |
|
* MCT (Magic Control Technology Corp.) USB RS232 Converter Driver |
|
* |
|
* Copyright (C) 2000 Wolfgang Grandegger ([email protected]) |
|
* |
|
* This program is largely derived from the Belkin USB Serial Adapter Driver |
|
* (see belkin_sa.[ch]). All of the information about the device was acquired |
|
* by using SniffUSB on Windows98. For technical details see mct_u232.h. |
|
* |
|
* William G. Greathouse and Greg Kroah-Hartman provided great help on how to |
|
* do the reverse engineering and how to write a USB serial device driver. |
|
* |
|
* TO BE DONE, TO BE CHECKED: |
|
* DTR/RTS signal handling may be incomplete or incorrect. I have mainly |
|
* implemented what I have seen with SniffUSB or found in belkin_sa.c. |
|
* For further TODOs check also belkin_sa.c. |
|
*/ |
|
|
|
#include <linux/kernel.h> |
|
#include <linux/errno.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/spinlock.h> |
|
#include <linux/uaccess.h> |
|
#include <asm/unaligned.h> |
|
#include <linux/usb.h> |
|
#include <linux/usb/serial.h> |
|
#include <linux/serial.h> |
|
#include "mct_u232.h" |
|
|
|
#define DRIVER_AUTHOR "Wolfgang Grandegger <[email protected]>" |
|
#define DRIVER_DESC "Magic Control Technology USB-RS232 converter driver" |
|
|
|
/* |
|
* Function prototypes |
|
*/ |
|
static int mct_u232_port_probe(struct usb_serial_port *port); |
|
static void mct_u232_port_remove(struct usb_serial_port *remove); |
|
static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port); |
|
static void mct_u232_close(struct usb_serial_port *port); |
|
static void mct_u232_dtr_rts(struct usb_serial_port *port, int on); |
|
static void mct_u232_read_int_callback(struct urb *urb); |
|
static void mct_u232_set_termios(struct tty_struct *tty, |
|
struct usb_serial_port *port, struct ktermios *old); |
|
static void mct_u232_break_ctl(struct tty_struct *tty, int break_state); |
|
static int mct_u232_tiocmget(struct tty_struct *tty); |
|
static int mct_u232_tiocmset(struct tty_struct *tty, |
|
unsigned int set, unsigned int clear); |
|
static void mct_u232_throttle(struct tty_struct *tty); |
|
static void mct_u232_unthrottle(struct tty_struct *tty); |
|
|
|
|
|
/* |
|
* All of the device info needed for the MCT USB-RS232 converter. |
|
*/ |
|
static const struct usb_device_id id_table[] = { |
|
{ USB_DEVICE(MCT_U232_VID, MCT_U232_PID) }, |
|
{ USB_DEVICE(MCT_U232_VID, MCT_U232_SITECOM_PID) }, |
|
{ USB_DEVICE(MCT_U232_VID, MCT_U232_DU_H3SP_PID) }, |
|
{ USB_DEVICE(MCT_U232_BELKIN_F5U109_VID, MCT_U232_BELKIN_F5U109_PID) }, |
|
{ } /* Terminating entry */ |
|
}; |
|
MODULE_DEVICE_TABLE(usb, id_table); |
|
|
|
static struct usb_serial_driver mct_u232_device = { |
|
.driver = { |
|
.owner = THIS_MODULE, |
|
.name = "mct_u232", |
|
}, |
|
.description = "MCT U232", |
|
.id_table = id_table, |
|
.num_ports = 1, |
|
.open = mct_u232_open, |
|
.close = mct_u232_close, |
|
.dtr_rts = mct_u232_dtr_rts, |
|
.throttle = mct_u232_throttle, |
|
.unthrottle = mct_u232_unthrottle, |
|
.read_int_callback = mct_u232_read_int_callback, |
|
.set_termios = mct_u232_set_termios, |
|
.break_ctl = mct_u232_break_ctl, |
|
.tiocmget = mct_u232_tiocmget, |
|
.tiocmset = mct_u232_tiocmset, |
|
.tiocmiwait = usb_serial_generic_tiocmiwait, |
|
.port_probe = mct_u232_port_probe, |
|
.port_remove = mct_u232_port_remove, |
|
.get_icount = usb_serial_generic_get_icount, |
|
}; |
|
|
|
static struct usb_serial_driver * const serial_drivers[] = { |
|
&mct_u232_device, NULL |
|
}; |
|
|
|
struct mct_u232_private { |
|
struct urb *read_urb; |
|
spinlock_t lock; |
|
unsigned int control_state; /* Modem Line Setting (TIOCM) */ |
|
unsigned char last_lcr; /* Line Control Register */ |
|
unsigned char last_lsr; /* Line Status Register */ |
|
unsigned char last_msr; /* Modem Status Register */ |
|
unsigned int rx_flags; /* Throttling flags */ |
|
}; |
|
|
|
#define THROTTLED 0x01 |
|
|
|
/* |
|
* Handle vendor specific USB requests |
|
*/ |
|
|
|
#define WDR_TIMEOUT 5000 /* default urb timeout */ |
|
|
|
/* |
|
* Later day 2.6.0-test kernels have new baud rates like B230400 which |
|
* we do not know how to support. We ignore them for the moment. |
|
*/ |
|
static int mct_u232_calculate_baud_rate(struct usb_serial *serial, |
|
speed_t value, speed_t *result) |
|
{ |
|
*result = value; |
|
|
|
if (le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_SITECOM_PID |
|
|| le16_to_cpu(serial->dev->descriptor.idProduct) == MCT_U232_BELKIN_F5U109_PID) { |
|
switch (value) { |
|
case 300: |
|
return 0x01; |
|
case 600: |
|
return 0x02; /* this one not tested */ |
|
case 1200: |
|
return 0x03; |
|
case 2400: |
|
return 0x04; |
|
case 4800: |
|
return 0x06; |
|
case 9600: |
|
return 0x08; |
|
case 19200: |
|
return 0x09; |
|
case 38400: |
|
return 0x0a; |
|
case 57600: |
|
return 0x0b; |
|
case 115200: |
|
return 0x0c; |
|
default: |
|
*result = 9600; |
|
return 0x08; |
|
} |
|
} else { |
|
/* FIXME: Can we use any divider - should we do |
|
divider = 115200/value; |
|
real baud = 115200/divider */ |
|
switch (value) { |
|
case 300: break; |
|
case 600: break; |
|
case 1200: break; |
|
case 2400: break; |
|
case 4800: break; |
|
case 9600: break; |
|
case 19200: break; |
|
case 38400: break; |
|
case 57600: break; |
|
case 115200: break; |
|
default: |
|
value = 9600; |
|
*result = 9600; |
|
} |
|
return 115200/value; |
|
} |
|
} |
|
|
|
static int mct_u232_set_baud_rate(struct tty_struct *tty, |
|
struct usb_serial *serial, struct usb_serial_port *port, speed_t value) |
|
{ |
|
unsigned int divisor; |
|
int rc; |
|
unsigned char *buf; |
|
unsigned char cts_enable_byte = 0; |
|
speed_t speed; |
|
|
|
buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
|
if (buf == NULL) |
|
return -ENOMEM; |
|
|
|
divisor = mct_u232_calculate_baud_rate(serial, value, &speed); |
|
put_unaligned_le32(divisor, buf); |
|
rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
|
MCT_U232_SET_BAUD_RATE_REQUEST, |
|
MCT_U232_SET_REQUEST_TYPE, |
|
0, 0, buf, MCT_U232_SET_BAUD_RATE_SIZE, |
|
WDR_TIMEOUT); |
|
if (rc < 0) /*FIXME: What value speed results */ |
|
dev_err(&port->dev, "Set BAUD RATE %d failed (error = %d)\n", |
|
value, rc); |
|
else |
|
tty_encode_baud_rate(tty, speed, speed); |
|
dev_dbg(&port->dev, "set_baud_rate: value: 0x%x, divisor: 0x%x\n", value, divisor); |
|
|
|
/* Mimic the MCT-supplied Windows driver (version 1.21P.0104), which |
|
always sends two extra USB 'device request' messages after the |
|
'baud rate change' message. The actual functionality of the |
|
request codes in these messages is not fully understood but these |
|
particular codes are never seen in any operation besides a baud |
|
rate change. Both of these messages send a single byte of data. |
|
In the first message, the value of this byte is always zero. |
|
|
|
The second message has been determined experimentally to control |
|
whether data will be transmitted to a device which is not asserting |
|
the 'CTS' signal. If the second message's data byte is zero, data |
|
will be transmitted even if 'CTS' is not asserted (i.e. no hardware |
|
flow control). if the second message's data byte is nonzero (a |
|
value of 1 is used by this driver), data will not be transmitted to |
|
a device which is not asserting 'CTS'. |
|
*/ |
|
|
|
buf[0] = 0; |
|
rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
|
MCT_U232_SET_UNKNOWN1_REQUEST, |
|
MCT_U232_SET_REQUEST_TYPE, |
|
0, 0, buf, MCT_U232_SET_UNKNOWN1_SIZE, |
|
WDR_TIMEOUT); |
|
if (rc < 0) |
|
dev_err(&port->dev, "Sending USB device request code %d " |
|
"failed (error = %d)\n", MCT_U232_SET_UNKNOWN1_REQUEST, |
|
rc); |
|
|
|
if (port && C_CRTSCTS(tty)) |
|
cts_enable_byte = 1; |
|
|
|
dev_dbg(&port->dev, "set_baud_rate: send second control message, data = %02X\n", |
|
cts_enable_byte); |
|
buf[0] = cts_enable_byte; |
|
rc = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0), |
|
MCT_U232_SET_CTS_REQUEST, |
|
MCT_U232_SET_REQUEST_TYPE, |
|
0, 0, buf, MCT_U232_SET_CTS_SIZE, |
|
WDR_TIMEOUT); |
|
if (rc < 0) |
|
dev_err(&port->dev, "Sending USB device request code %d " |
|
"failed (error = %d)\n", MCT_U232_SET_CTS_REQUEST, rc); |
|
|
|
kfree(buf); |
|
return rc; |
|
} /* mct_u232_set_baud_rate */ |
|
|
|
static int mct_u232_set_line_ctrl(struct usb_serial_port *port, |
|
unsigned char lcr) |
|
{ |
|
int rc; |
|
unsigned char *buf; |
|
|
|
buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
|
if (buf == NULL) |
|
return -ENOMEM; |
|
|
|
buf[0] = lcr; |
|
rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0), |
|
MCT_U232_SET_LINE_CTRL_REQUEST, |
|
MCT_U232_SET_REQUEST_TYPE, |
|
0, 0, buf, MCT_U232_SET_LINE_CTRL_SIZE, |
|
WDR_TIMEOUT); |
|
if (rc < 0) |
|
dev_err(&port->dev, "Set LINE CTRL 0x%x failed (error = %d)\n", lcr, rc); |
|
dev_dbg(&port->dev, "set_line_ctrl: 0x%x\n", lcr); |
|
kfree(buf); |
|
return rc; |
|
} /* mct_u232_set_line_ctrl */ |
|
|
|
static int mct_u232_set_modem_ctrl(struct usb_serial_port *port, |
|
unsigned int control_state) |
|
{ |
|
int rc; |
|
unsigned char mcr; |
|
unsigned char *buf; |
|
|
|
buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
|
if (buf == NULL) |
|
return -ENOMEM; |
|
|
|
mcr = MCT_U232_MCR_NONE; |
|
if (control_state & TIOCM_DTR) |
|
mcr |= MCT_U232_MCR_DTR; |
|
if (control_state & TIOCM_RTS) |
|
mcr |= MCT_U232_MCR_RTS; |
|
|
|
buf[0] = mcr; |
|
rc = usb_control_msg(port->serial->dev, usb_sndctrlpipe(port->serial->dev, 0), |
|
MCT_U232_SET_MODEM_CTRL_REQUEST, |
|
MCT_U232_SET_REQUEST_TYPE, |
|
0, 0, buf, MCT_U232_SET_MODEM_CTRL_SIZE, |
|
WDR_TIMEOUT); |
|
kfree(buf); |
|
|
|
dev_dbg(&port->dev, "set_modem_ctrl: state=0x%x ==> mcr=0x%x\n", control_state, mcr); |
|
|
|
if (rc < 0) { |
|
dev_err(&port->dev, "Set MODEM CTRL 0x%x failed (error = %d)\n", mcr, rc); |
|
return rc; |
|
} |
|
return 0; |
|
} /* mct_u232_set_modem_ctrl */ |
|
|
|
static int mct_u232_get_modem_stat(struct usb_serial_port *port, |
|
unsigned char *msr) |
|
{ |
|
int rc; |
|
unsigned char *buf; |
|
|
|
buf = kmalloc(MCT_U232_MAX_SIZE, GFP_KERNEL); |
|
if (buf == NULL) { |
|
*msr = 0; |
|
return -ENOMEM; |
|
} |
|
rc = usb_control_msg(port->serial->dev, usb_rcvctrlpipe(port->serial->dev, 0), |
|
MCT_U232_GET_MODEM_STAT_REQUEST, |
|
MCT_U232_GET_REQUEST_TYPE, |
|
0, 0, buf, MCT_U232_GET_MODEM_STAT_SIZE, |
|
WDR_TIMEOUT); |
|
if (rc < MCT_U232_GET_MODEM_STAT_SIZE) { |
|
dev_err(&port->dev, "Get MODEM STATus failed (error = %d)\n", rc); |
|
|
|
if (rc >= 0) |
|
rc = -EIO; |
|
|
|
*msr = 0; |
|
} else { |
|
*msr = buf[0]; |
|
} |
|
dev_dbg(&port->dev, "get_modem_stat: 0x%x\n", *msr); |
|
kfree(buf); |
|
return rc; |
|
} /* mct_u232_get_modem_stat */ |
|
|
|
static void mct_u232_msr_to_icount(struct async_icount *icount, |
|
unsigned char msr) |
|
{ |
|
/* Translate Control Line states */ |
|
if (msr & MCT_U232_MSR_DDSR) |
|
icount->dsr++; |
|
if (msr & MCT_U232_MSR_DCTS) |
|
icount->cts++; |
|
if (msr & MCT_U232_MSR_DRI) |
|
icount->rng++; |
|
if (msr & MCT_U232_MSR_DCD) |
|
icount->dcd++; |
|
} /* mct_u232_msr_to_icount */ |
|
|
|
static void mct_u232_msr_to_state(struct usb_serial_port *port, |
|
unsigned int *control_state, unsigned char msr) |
|
{ |
|
/* Translate Control Line states */ |
|
if (msr & MCT_U232_MSR_DSR) |
|
*control_state |= TIOCM_DSR; |
|
else |
|
*control_state &= ~TIOCM_DSR; |
|
if (msr & MCT_U232_MSR_CTS) |
|
*control_state |= TIOCM_CTS; |
|
else |
|
*control_state &= ~TIOCM_CTS; |
|
if (msr & MCT_U232_MSR_RI) |
|
*control_state |= TIOCM_RI; |
|
else |
|
*control_state &= ~TIOCM_RI; |
|
if (msr & MCT_U232_MSR_CD) |
|
*control_state |= TIOCM_CD; |
|
else |
|
*control_state &= ~TIOCM_CD; |
|
dev_dbg(&port->dev, "msr_to_state: msr=0x%x ==> state=0x%x\n", msr, *control_state); |
|
} /* mct_u232_msr_to_state */ |
|
|
|
/* |
|
* Driver's tty interface functions |
|
*/ |
|
|
|
static int mct_u232_port_probe(struct usb_serial_port *port) |
|
{ |
|
struct usb_serial *serial = port->serial; |
|
struct mct_u232_private *priv; |
|
|
|
/* check first to simplify error handling */ |
|
if (!serial->port[1] || !serial->port[1]->interrupt_in_urb) { |
|
dev_err(&port->dev, "expected endpoint missing\n"); |
|
return -ENODEV; |
|
} |
|
|
|
priv = kzalloc(sizeof(*priv), GFP_KERNEL); |
|
if (!priv) |
|
return -ENOMEM; |
|
|
|
/* Use second interrupt-in endpoint for reading. */ |
|
priv->read_urb = serial->port[1]->interrupt_in_urb; |
|
priv->read_urb->context = port; |
|
|
|
spin_lock_init(&priv->lock); |
|
|
|
usb_set_serial_port_data(port, priv); |
|
|
|
return 0; |
|
} |
|
|
|
static void mct_u232_port_remove(struct usb_serial_port *port) |
|
{ |
|
struct mct_u232_private *priv; |
|
|
|
priv = usb_get_serial_port_data(port); |
|
kfree(priv); |
|
} |
|
|
|
static int mct_u232_open(struct tty_struct *tty, struct usb_serial_port *port) |
|
{ |
|
struct usb_serial *serial = port->serial; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
int retval = 0; |
|
unsigned int control_state; |
|
unsigned long flags; |
|
unsigned char last_lcr; |
|
unsigned char last_msr; |
|
|
|
/* Compensate for a hardware bug: although the Sitecom U232-P25 |
|
* device reports a maximum output packet size of 32 bytes, |
|
* it seems to be able to accept only 16 bytes (and that's what |
|
* SniffUSB says too...) |
|
*/ |
|
if (le16_to_cpu(serial->dev->descriptor.idProduct) |
|
== MCT_U232_SITECOM_PID) |
|
port->bulk_out_size = 16; |
|
|
|
/* Do a defined restart: the normal serial device seems to |
|
* always turn on DTR and RTS here, so do the same. I'm not |
|
* sure if this is really necessary. But it should not harm |
|
* either. |
|
*/ |
|
spin_lock_irqsave(&priv->lock, flags); |
|
if (tty && C_BAUD(tty)) |
|
priv->control_state = TIOCM_DTR | TIOCM_RTS; |
|
else |
|
priv->control_state = 0; |
|
|
|
priv->last_lcr = (MCT_U232_DATA_BITS_8 | |
|
MCT_U232_PARITY_NONE | |
|
MCT_U232_STOP_BITS_1); |
|
control_state = priv->control_state; |
|
last_lcr = priv->last_lcr; |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
mct_u232_set_modem_ctrl(port, control_state); |
|
mct_u232_set_line_ctrl(port, last_lcr); |
|
|
|
/* Read modem status and update control state */ |
|
mct_u232_get_modem_stat(port, &last_msr); |
|
spin_lock_irqsave(&priv->lock, flags); |
|
priv->last_msr = last_msr; |
|
mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr); |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
|
|
retval = usb_submit_urb(priv->read_urb, GFP_KERNEL); |
|
if (retval) { |
|
dev_err(&port->dev, |
|
"usb_submit_urb(read) failed pipe 0x%x err %d\n", |
|
port->read_urb->pipe, retval); |
|
goto error; |
|
} |
|
|
|
retval = usb_submit_urb(port->interrupt_in_urb, GFP_KERNEL); |
|
if (retval) { |
|
usb_kill_urb(priv->read_urb); |
|
dev_err(&port->dev, |
|
"usb_submit_urb(read int) failed pipe 0x%x err %d", |
|
port->interrupt_in_urb->pipe, retval); |
|
goto error; |
|
} |
|
return 0; |
|
|
|
error: |
|
return retval; |
|
} /* mct_u232_open */ |
|
|
|
static void mct_u232_dtr_rts(struct usb_serial_port *port, int on) |
|
{ |
|
unsigned int control_state; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
|
|
spin_lock_irq(&priv->lock); |
|
if (on) |
|
priv->control_state |= TIOCM_DTR | TIOCM_RTS; |
|
else |
|
priv->control_state &= ~(TIOCM_DTR | TIOCM_RTS); |
|
control_state = priv->control_state; |
|
spin_unlock_irq(&priv->lock); |
|
|
|
mct_u232_set_modem_ctrl(port, control_state); |
|
} |
|
|
|
static void mct_u232_close(struct usb_serial_port *port) |
|
{ |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
|
|
usb_kill_urb(priv->read_urb); |
|
usb_kill_urb(port->interrupt_in_urb); |
|
|
|
usb_serial_generic_close(port); |
|
} /* mct_u232_close */ |
|
|
|
|
|
static void mct_u232_read_int_callback(struct urb *urb) |
|
{ |
|
struct usb_serial_port *port = urb->context; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
unsigned char *data = urb->transfer_buffer; |
|
int retval; |
|
int status = urb->status; |
|
unsigned long flags; |
|
|
|
switch (status) { |
|
case 0: |
|
/* success */ |
|
break; |
|
case -ECONNRESET: |
|
case -ENOENT: |
|
case -ESHUTDOWN: |
|
/* this urb is terminated, clean up */ |
|
dev_dbg(&port->dev, "%s - urb shutting down with status: %d\n", |
|
__func__, status); |
|
return; |
|
default: |
|
dev_dbg(&port->dev, "%s - nonzero urb status received: %d\n", |
|
__func__, status); |
|
goto exit; |
|
} |
|
|
|
usb_serial_debug_data(&port->dev, __func__, urb->actual_length, data); |
|
|
|
/* |
|
* Work-a-round: handle the 'usual' bulk-in pipe here |
|
*/ |
|
if (urb->transfer_buffer_length > 2) { |
|
if (urb->actual_length) { |
|
tty_insert_flip_string(&port->port, data, |
|
urb->actual_length); |
|
tty_flip_buffer_push(&port->port); |
|
} |
|
goto exit; |
|
} |
|
|
|
/* |
|
* The interrupt-in pipe signals exceptional conditions (modem line |
|
* signal changes and errors). data[0] holds MSR, data[1] holds LSR. |
|
*/ |
|
spin_lock_irqsave(&priv->lock, flags); |
|
priv->last_msr = data[MCT_U232_MSR_INDEX]; |
|
|
|
/* Record Control Line states */ |
|
mct_u232_msr_to_state(port, &priv->control_state, priv->last_msr); |
|
|
|
mct_u232_msr_to_icount(&port->icount, priv->last_msr); |
|
|
|
#if 0 |
|
/* Not yet handled. See belkin_sa.c for further information */ |
|
/* Now to report any errors */ |
|
priv->last_lsr = data[MCT_U232_LSR_INDEX]; |
|
/* |
|
* fill in the flip buffer here, but I do not know the relation |
|
* to the current/next receive buffer or characters. I need |
|
* to look in to this before committing any code. |
|
*/ |
|
if (priv->last_lsr & MCT_U232_LSR_ERR) { |
|
tty = tty_port_tty_get(&port->port); |
|
/* Overrun Error */ |
|
if (priv->last_lsr & MCT_U232_LSR_OE) { |
|
} |
|
/* Parity Error */ |
|
if (priv->last_lsr & MCT_U232_LSR_PE) { |
|
} |
|
/* Framing Error */ |
|
if (priv->last_lsr & MCT_U232_LSR_FE) { |
|
} |
|
/* Break Indicator */ |
|
if (priv->last_lsr & MCT_U232_LSR_BI) { |
|
} |
|
tty_kref_put(tty); |
|
} |
|
#endif |
|
wake_up_interruptible(&port->port.delta_msr_wait); |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
exit: |
|
retval = usb_submit_urb(urb, GFP_ATOMIC); |
|
if (retval) |
|
dev_err(&port->dev, |
|
"%s - usb_submit_urb failed with result %d\n", |
|
__func__, retval); |
|
} /* mct_u232_read_int_callback */ |
|
|
|
static void mct_u232_set_termios(struct tty_struct *tty, |
|
struct usb_serial_port *port, |
|
struct ktermios *old_termios) |
|
{ |
|
struct usb_serial *serial = port->serial; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
struct ktermios *termios = &tty->termios; |
|
unsigned int cflag = termios->c_cflag; |
|
unsigned int old_cflag = old_termios->c_cflag; |
|
unsigned long flags; |
|
unsigned int control_state; |
|
unsigned char last_lcr; |
|
|
|
/* get a local copy of the current port settings */ |
|
spin_lock_irqsave(&priv->lock, flags); |
|
control_state = priv->control_state; |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
last_lcr = 0; |
|
|
|
/* |
|
* Update baud rate. |
|
* Do not attempt to cache old rates and skip settings, |
|
* disconnects screw such tricks up completely. |
|
* Premature optimization is the root of all evil. |
|
*/ |
|
|
|
/* reassert DTR and RTS on transition from B0 */ |
|
if ((old_cflag & CBAUD) == B0) { |
|
dev_dbg(&port->dev, "%s: baud was B0\n", __func__); |
|
control_state |= TIOCM_DTR | TIOCM_RTS; |
|
mct_u232_set_modem_ctrl(port, control_state); |
|
} |
|
|
|
mct_u232_set_baud_rate(tty, serial, port, tty_get_baud_rate(tty)); |
|
|
|
if ((cflag & CBAUD) == B0) { |
|
dev_dbg(&port->dev, "%s: baud is B0\n", __func__); |
|
/* Drop RTS and DTR */ |
|
control_state &= ~(TIOCM_DTR | TIOCM_RTS); |
|
mct_u232_set_modem_ctrl(port, control_state); |
|
} |
|
|
|
/* |
|
* Update line control register (LCR) |
|
*/ |
|
|
|
/* set the parity */ |
|
if (cflag & PARENB) |
|
last_lcr |= (cflag & PARODD) ? |
|
MCT_U232_PARITY_ODD : MCT_U232_PARITY_EVEN; |
|
else |
|
last_lcr |= MCT_U232_PARITY_NONE; |
|
|
|
/* set the number of data bits */ |
|
switch (cflag & CSIZE) { |
|
case CS5: |
|
last_lcr |= MCT_U232_DATA_BITS_5; break; |
|
case CS6: |
|
last_lcr |= MCT_U232_DATA_BITS_6; break; |
|
case CS7: |
|
last_lcr |= MCT_U232_DATA_BITS_7; break; |
|
case CS8: |
|
last_lcr |= MCT_U232_DATA_BITS_8; break; |
|
default: |
|
dev_err(&port->dev, |
|
"CSIZE was not CS5-CS8, using default of 8\n"); |
|
last_lcr |= MCT_U232_DATA_BITS_8; |
|
break; |
|
} |
|
|
|
termios->c_cflag &= ~CMSPAR; |
|
|
|
/* set the number of stop bits */ |
|
last_lcr |= (cflag & CSTOPB) ? |
|
MCT_U232_STOP_BITS_2 : MCT_U232_STOP_BITS_1; |
|
|
|
mct_u232_set_line_ctrl(port, last_lcr); |
|
|
|
/* save off the modified port settings */ |
|
spin_lock_irqsave(&priv->lock, flags); |
|
priv->control_state = control_state; |
|
priv->last_lcr = last_lcr; |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
} /* mct_u232_set_termios */ |
|
|
|
static void mct_u232_break_ctl(struct tty_struct *tty, int break_state) |
|
{ |
|
struct usb_serial_port *port = tty->driver_data; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
unsigned char lcr; |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&priv->lock, flags); |
|
lcr = priv->last_lcr; |
|
|
|
if (break_state) |
|
lcr |= MCT_U232_SET_BREAK; |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
|
|
mct_u232_set_line_ctrl(port, lcr); |
|
} /* mct_u232_break_ctl */ |
|
|
|
|
|
static int mct_u232_tiocmget(struct tty_struct *tty) |
|
{ |
|
struct usb_serial_port *port = tty->driver_data; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
unsigned int control_state; |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&priv->lock, flags); |
|
control_state = priv->control_state; |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
|
|
return control_state; |
|
} |
|
|
|
static int mct_u232_tiocmset(struct tty_struct *tty, |
|
unsigned int set, unsigned int clear) |
|
{ |
|
struct usb_serial_port *port = tty->driver_data; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
unsigned int control_state; |
|
unsigned long flags; |
|
|
|
spin_lock_irqsave(&priv->lock, flags); |
|
control_state = priv->control_state; |
|
|
|
if (set & TIOCM_RTS) |
|
control_state |= TIOCM_RTS; |
|
if (set & TIOCM_DTR) |
|
control_state |= TIOCM_DTR; |
|
if (clear & TIOCM_RTS) |
|
control_state &= ~TIOCM_RTS; |
|
if (clear & TIOCM_DTR) |
|
control_state &= ~TIOCM_DTR; |
|
|
|
priv->control_state = control_state; |
|
spin_unlock_irqrestore(&priv->lock, flags); |
|
return mct_u232_set_modem_ctrl(port, control_state); |
|
} |
|
|
|
static void mct_u232_throttle(struct tty_struct *tty) |
|
{ |
|
struct usb_serial_port *port = tty->driver_data; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
unsigned int control_state; |
|
|
|
spin_lock_irq(&priv->lock); |
|
priv->rx_flags |= THROTTLED; |
|
if (C_CRTSCTS(tty)) { |
|
priv->control_state &= ~TIOCM_RTS; |
|
control_state = priv->control_state; |
|
spin_unlock_irq(&priv->lock); |
|
mct_u232_set_modem_ctrl(port, control_state); |
|
} else { |
|
spin_unlock_irq(&priv->lock); |
|
} |
|
} |
|
|
|
static void mct_u232_unthrottle(struct tty_struct *tty) |
|
{ |
|
struct usb_serial_port *port = tty->driver_data; |
|
struct mct_u232_private *priv = usb_get_serial_port_data(port); |
|
unsigned int control_state; |
|
|
|
spin_lock_irq(&priv->lock); |
|
if ((priv->rx_flags & THROTTLED) && C_CRTSCTS(tty)) { |
|
priv->rx_flags &= ~THROTTLED; |
|
priv->control_state |= TIOCM_RTS; |
|
control_state = priv->control_state; |
|
spin_unlock_irq(&priv->lock); |
|
mct_u232_set_modem_ctrl(port, control_state); |
|
} else { |
|
spin_unlock_irq(&priv->lock); |
|
} |
|
} |
|
|
|
module_usb_serial_driver(serial_drivers, id_table); |
|
|
|
MODULE_AUTHOR(DRIVER_AUTHOR); |
|
MODULE_DESCRIPTION(DRIVER_DESC); |
|
MODULE_LICENSE("GPL");
|
|
|