[PATCH] USB: serial: add nt124 usb to serial driver
From: George McCollister
Date: Mon Dec 08 2014 - 18:25:54 EST
This driver is for the NovaTech 124 4x serial expansion board for the
NovaTech OrionLXm.
Firmware source code can be found here:
https://github.com/novatechweb/nt124
Signed-off-by: George McCollister <george.mccollister@xxxxxxxxx>
---
drivers/usb/serial/Kconfig | 9 +
drivers/usb/serial/Makefile | 1 +
drivers/usb/serial/nt124.c | 429 ++++++++++++++++++++++++++++++++++++++++++++
3 files changed, 439 insertions(+)
create mode 100644 drivers/usb/serial/nt124.c
diff --git a/drivers/usb/serial/Kconfig b/drivers/usb/serial/Kconfig
index a69f7cd..6dfc340 100644
--- a/drivers/usb/serial/Kconfig
+++ b/drivers/usb/serial/Kconfig
@@ -509,6 +509,15 @@ config USB_SERIAL_NAVMAN
To compile this driver as a module, choose M here: the
module will be called navman.
+config USB_SERIAL_NT124
+ tristate "USB nt124 serial device"
+ help
+ Say Y here if you want to use the NovaTech 124 4x USB to serial
+ board.
+
+ To compile this driver as a module, choose M here: the
+ module will be called nt124.
+
config USB_SERIAL_PL2303
tristate "USB Prolific 2303 Single Port Serial Driver"
help
diff --git a/drivers/usb/serial/Makefile b/drivers/usb/serial/Makefile
index 349d9df..f88eaab 100644
--- a/drivers/usb/serial/Makefile
+++ b/drivers/usb/serial/Makefile
@@ -39,6 +39,7 @@ obj-$(CONFIG_USB_SERIAL_MOS7720) += mos7720.o
obj-$(CONFIG_USB_SERIAL_MOS7840) += mos7840.o
obj-$(CONFIG_USB_SERIAL_MXUPORT) += mxuport.o
obj-$(CONFIG_USB_SERIAL_NAVMAN) += navman.o
+obj-$(CONFIG_USB_SERIAL_NT124) += nt124.o
obj-$(CONFIG_USB_SERIAL_OMNINET) += omninet.o
obj-$(CONFIG_USB_SERIAL_OPTICON) += opticon.o
obj-$(CONFIG_USB_SERIAL_OPTION) += option.o
diff --git a/drivers/usb/serial/nt124.c b/drivers/usb/serial/nt124.c
new file mode 100644
index 0000000..d7557ff
--- /dev/null
+++ b/drivers/usb/serial/nt124.c
@@ -0,0 +1,429 @@
+/*
+ * nt124.c
+ *
+ * Copyright (c) 2014 NovaTech LLC
+ *
+ * Driver for nt124 4x serial board based on STM32F103
+ *
+ * Portions derived from the cdc-acm driver
+ *
+ * The original intention was to implement a cdc-acm compliant
+ * 4x USB to serial converter in the STM32F103 however several problems arose.
+ * The STM32F103 didn't have enough end points to implement 4 ports.
+ * CTS control was required by the application.
+ * Accurate notification of transmission completion was required.
+ * RTSCTS flow control support was required.
+ *
+ * The interrupt endpoint was eliminated and the control line information
+ * was moved to the first two bytes of the in endpoint message. CTS control
+ * and mechanisms to enable RTSCTS flow control and deliver TXEMPTY
+ * information were added.
+ *
+ * Firmware source code can be found here:
+ * https://github.com/novatechweb/nt124
+ *
+ * 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.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ */
+
+#include <linux/kernel.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/usb.h>
+#include <linux/usb/serial.h>
+#include <asm/unaligned.h>
+
+#define NT124_VID 0x2aeb
+#define NT124_USB_PID 124
+
+#define DRIVER_AUTHOR "George McCollister <george.mccollister@xxxxxxxxx>"
+#define DRIVER_DESC "nt124 USB serial driver"
+
+static const struct usb_device_id id_table[] = {
+ { USB_DEVICE(NT124_VID, NT124_USB_PID) },
+ { },
+};
+
+MODULE_DEVICE_TABLE(usb, id_table);
+
+/*
+ * Output control lines.
+ */
+
+#define NT124_CTRL_DTR 0x01
+#define NT124_CTRL_RTS 0x02
+
+/*
+ * Input control lines and line errors.
+ */
+
+#define NT124_CTRL_DCD 0x01
+#define NT124_CTRL_DSR 0x02
+#define NT124_CTRL_BRK 0x04
+#define NT124_CTRL_RI 0x08
+#define NT124_CTRL_FRAMING 0x10
+#define NT124_CTRL_PARITY 0x20
+#define NT124_CTRL_OVERRUN 0x40
+#define NT124_CTRL_TXEMPTY 0x80
+#define NT124_CTRL_CTS 0x100
+
+#define USB_NT124_REQ_SET_LINE_CODING 0x20
+#define USB_NT124_REQ_SET_CONTROL_LINE_STATE 0x22
+#define USB_NT124_REQ_SEND_BREAK 0x23
+#define USB_NT124_SET_FLOW_CONTROL 0x90
+
+struct nt124_line_coding {
+ __le32 dwDTERate;
+ u8 bCharFormat;
+ u8 bParityType;
+ u8 bDataBits;
+} __packed;
+
+struct nt124_private {
+ /* USB interface */
+ u16 bInterfaceNumber;
+ /* input control lines (DCD, DSR, RI, break, overruns) */
+ unsigned int ctrlin;
+ /* output control lines (DTR, RTS) */
+ unsigned int ctrlout;
+ /* termios CLOCAL */
+ unsigned char clocal;
+ /* bits, stop, parity */
+ struct nt124_line_coding line;
+ int serial_transmit;
+ unsigned int flowctrl;
+};
+
+static int nt124_ctrl_msg(struct usb_serial_port *port, int request, int value,
+ void *buf, int len)
+{
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ int retval;
+
+ retval = usb_control_msg(port->serial->dev,
+ usb_sndctrlpipe(port->serial->dev, 0),
+ request, USB_TYPE_CLASS | USB_RECIP_INTERFACE, value,
+ priv->bInterfaceNumber,
+ buf, len, 5000);
+
+ dev_dbg(&port->dev,
+ "%s - rq 0x%02x, val %#x, len %#x, result %d\n",
+ __func__, request, value, len, retval);
+
+ return retval < 0 ? retval : 0;
+}
+
+#define nt124_set_control(port, control) \
+ nt124_ctrl_msg(port, USB_NT124_REQ_SET_CONTROL_LINE_STATE, control, \
+ NULL, 0)
+#define nt124_set_line(port, line) \
+ nt124_ctrl_msg(port, USB_NT124_REQ_SET_LINE_CODING, 0, line, \
+ sizeof *(line))
+#define nt124_send_break(port, ms) \
+ nt124_ctrl_msg(port, USB_NT124_REQ_SEND_BREAK, ms, NULL, 0)
+#define nt124_set_flowctrl(port, flowctrl) \
+ nt124_ctrl_msg(port, USB_NT124_SET_FLOW_CONTROL, flowctrl, NULL, 0)
+
+static void nt124_process_notify(struct usb_serial_port *port,
+ struct nt124_private *priv,
+ unsigned char *data)
+{
+ int newctrl;
+ unsigned long flags;
+
+ newctrl = get_unaligned_le16(data);
+ if (newctrl & NT124_CTRL_TXEMPTY) {
+ spin_lock_irqsave(&port->lock, flags);
+ priv->serial_transmit = 0;
+ spin_unlock_irqrestore(&port->lock, flags);
+ tty_port_tty_wakeup(&port->port);
+ }
+
+ if (!priv->clocal && (priv->ctrlin & ~newctrl & NT124_CTRL_DCD)) {
+ dev_dbg(&port->dev, "%s - calling hangup\n",
+ __func__);
+ tty_port_tty_hangup(&port->port, false);
+ }
+
+ priv->ctrlin = newctrl;
+}
+
+static void nt124_process_read_urb(struct urb *urb)
+{
+ struct usb_serial_port *port = urb->context;
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ unsigned char *data = (unsigned char *)urb->transfer_buffer;
+
+ if (urb->actual_length < 2)
+ return;
+
+ nt124_process_notify(port, priv, data);
+
+ if (urb->actual_length == 2)
+ return;
+
+ tty_insert_flip_string(&port->port, &data[2],
+ urb->actual_length - 2);
+ tty_flip_buffer_push(&port->port);
+}
+
+static int nt124_tiocmget(struct tty_struct *tty)
+{
+ struct usb_serial_port *port = tty->driver_data;
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+
+ return (priv->ctrlout & NT124_CTRL_DTR ? TIOCM_DTR : 0) |
+ (priv->ctrlout & NT124_CTRL_RTS ? TIOCM_RTS : 0) |
+ (priv->ctrlin & NT124_CTRL_DSR ? TIOCM_DSR : 0) |
+ (priv->ctrlin & NT124_CTRL_RI ? TIOCM_RI : 0) |
+ (priv->ctrlin & NT124_CTRL_DCD ? TIOCM_CD : 0) |
+ (priv->ctrlin & NT124_CTRL_CTS ? TIOCM_CTS : 0);
+}
+
+static int nt124_port_tiocmset(struct usb_serial_port *port,
+ unsigned int set, unsigned int clear)
+{
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ unsigned int newctrl;
+
+ newctrl = priv->ctrlout;
+ set = (set & TIOCM_DTR ? NT124_CTRL_DTR : 0) |
+ (set & TIOCM_RTS ? NT124_CTRL_RTS : 0);
+ clear = (clear & TIOCM_DTR ? NT124_CTRL_DTR : 0) |
+ (clear & TIOCM_RTS ? NT124_CTRL_RTS : 0);
+
+ newctrl = (newctrl & ~clear) | set;
+
+ if (priv->ctrlout == newctrl)
+ return 0;
+ return nt124_set_control(port, priv->ctrlout = newctrl);
+}
+
+static int nt124_tiocmset(struct tty_struct *tty,
+ unsigned int set, unsigned int clear)
+{
+ struct usb_serial_port *port = tty->driver_data;
+
+ return nt124_port_tiocmset(port, set, clear);
+}
+
+static void nt124_dtr_rts(struct usb_serial_port *port, int on)
+{
+ if (on)
+ nt124_port_tiocmset(port, TIOCM_DTR|TIOCM_RTS, 0);
+ else
+ nt124_port_tiocmset(port, 0, TIOCM_DTR|TIOCM_RTS);
+}
+
+static void nt124_set_termios(struct tty_struct *tty,
+ struct usb_serial_port *port,
+ struct ktermios *termios_old)
+{
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ struct ktermios *termios = &tty->termios;
+ struct nt124_line_coding newline;
+ int newctrl = priv->ctrlout;
+
+ newline.dwDTERate = cpu_to_le32(tty_get_baud_rate(tty));
+ newline.bCharFormat = termios->c_cflag & CSTOPB ? 2 : 0;
+ newline.bParityType = termios->c_cflag & PARENB ?
+ (termios->c_cflag & PARODD ? 1 : 2) +
+ (termios->c_cflag & CMSPAR ? 2 : 0) : 0;
+ switch (termios->c_cflag & CSIZE) {
+ case CS5:
+ newline.bDataBits = 5;
+ break;
+ case CS6:
+ newline.bDataBits = 6;
+ break;
+ case CS7:
+ newline.bDataBits = 7;
+ break;
+ case CS8:
+ default:
+ newline.bDataBits = 8;
+ break;
+ }
+ priv->clocal = ((termios->c_cflag & CLOCAL) != 0);
+
+ if (C_BAUD(tty) == B0) {
+ newline.dwDTERate = priv->line.dwDTERate;
+ newctrl &= ~NT124_CTRL_DTR;
+ } else if (termios_old && (termios_old->c_cflag & CBAUD) == B0) {
+ newctrl |= NT124_CTRL_DTR;
+ }
+
+ if (newctrl != priv->ctrlout)
+ nt124_set_control(port, priv->ctrlout = newctrl);
+
+ if (memcmp(&priv->line, &newline, sizeof(newline))) {
+ memcpy(&priv->line, &newline, sizeof(newline));
+ dev_dbg(&port->dev, "%s - set line: %d %d %d %d\n",
+ __func__,
+ le32_to_cpu(newline.dwDTERate),
+ newline.bCharFormat, newline.bParityType,
+ newline.bDataBits);
+ nt124_set_line(port, &priv->line);
+ }
+
+ if (termios->c_cflag & CRTSCTS && !priv->flowctrl) {
+ priv->flowctrl = 1;
+ nt124_set_flowctrl(port, priv->flowctrl);
+ } else if (!(termios->c_cflag & CRTSCTS) && priv->flowctrl) {
+ priv->flowctrl = 0;
+ nt124_set_flowctrl(port, priv->flowctrl);
+ }
+}
+
+static void nt124_write_bulk_callback(struct urb *urb)
+{
+ unsigned long flags;
+ struct usb_serial_port *port = urb->context;
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ int i;
+
+ for (i = 0; i < ARRAY_SIZE(port->write_urbs); ++i) {
+ if (port->write_urbs[i] == urb)
+ break;
+ }
+ spin_lock_irqsave(&port->lock, flags);
+ port->tx_bytes -= urb->transfer_buffer_length;
+ if (!urb->status)
+ priv->serial_transmit = 1;
+ set_bit(i, &port->write_urbs_free);
+ spin_unlock_irqrestore(&port->lock, flags);
+
+ switch (urb->status) {
+ case 0:
+ break;
+ case -ENOENT:
+ case -ECONNRESET:
+ case -ESHUTDOWN:
+ dev_dbg(&port->dev, "%s - urb stopped: %d\n",
+ __func__, urb->status);
+ return;
+ case -EPIPE:
+ dev_err_console(port, "%s - urb stopped: %d\n",
+ __func__, urb->status);
+ return;
+ default:
+ dev_err_console(port, "%s - nonzero urb status: %d\n",
+ __func__, urb->status);
+ goto resubmit;
+ }
+
+resubmit:
+ usb_serial_generic_write_start(port, GFP_ATOMIC);
+ usb_serial_port_softint(port);
+}
+
+static int nt124_chars_in_buffer(struct tty_struct *tty)
+{
+ struct usb_serial_port *port = tty->driver_data;
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ unsigned long flags;
+ int chars;
+
+ if (!port->bulk_out_size)
+ return 0;
+
+ spin_lock_irqsave(&port->lock, flags);
+ chars = kfifo_len(&port->write_fifo) + port->tx_bytes +
+ priv->serial_transmit;
+ spin_unlock_irqrestore(&port->lock, flags);
+
+ dev_dbg(&port->dev, "%s - returns %d\n", __func__, chars);
+ return chars;
+}
+
+static void nt124_break_ctl(struct tty_struct *tty, int state)
+{
+ struct usb_serial_port *port = tty->driver_data;
+ int retval;
+
+ retval = nt124_send_break(port, state ? 0xffff : 0);
+ if (retval < 0)
+ dev_dbg(&port->dev, "%s - send break failed\n", __func__);
+}
+
+static int nt124_open(struct tty_struct *tty,
+ struct usb_serial_port *port)
+{
+ struct nt124_private *priv = usb_get_serial_port_data(port);
+ int result = 0;
+ unsigned long flags;
+
+ spin_lock_irqsave(&port->lock, flags);
+ port->throttled = 0;
+ port->throttle_req = 0;
+ spin_unlock_irqrestore(&port->lock, flags);
+
+ priv->flowctrl = 0;
+ nt124_set_termios(tty, port, NULL);
+ nt124_set_flowctrl(port, priv->flowctrl);
+
+ if (port->bulk_in_size)
+ result = usb_serial_generic_submit_read_urbs(port, GFP_KERNEL);
+
+ return result;
+}
+
+static int nt124_port_probe(struct usb_serial_port *port)
+{
+ struct usb_interface *interface = port->serial->interface;
+ struct usb_host_interface *cur_altsetting = interface->cur_altsetting;
+ struct nt124_private *priv;
+
+ priv = devm_kzalloc(&port->dev, sizeof(*priv), GFP_KERNEL);
+ if (!priv)
+ return -ENOMEM;
+
+ priv->bInterfaceNumber = cur_altsetting->desc.bInterfaceNumber;
+
+ usb_set_serial_port_data(port, priv);
+
+ return 0;
+}
+
+static struct usb_serial_driver nt124_device = {
+ .driver = {
+ .owner = THIS_MODULE,
+ .name = "nt124",
+ },
+ .id_table = id_table,
+ .num_ports = 1,
+ .bulk_in_size = 32,
+ .bulk_out_size = 32,
+ .open = nt124_open,
+ .process_read_urb = nt124_process_read_urb,
+ .write_bulk_callback = nt124_write_bulk_callback,
+ .chars_in_buffer = nt124_chars_in_buffer,
+ .throttle = usb_serial_generic_throttle,
+ .unthrottle = usb_serial_generic_unthrottle,
+ .set_termios = nt124_set_termios,
+ .tiocmget = nt124_tiocmget,
+ .tiocmset = nt124_tiocmset,
+ .dtr_rts = nt124_dtr_rts,
+ .break_ctl = nt124_break_ctl,
+ .port_probe = nt124_port_probe,
+};
+
+static struct usb_serial_driver * const serial_drivers[] = {
+ &nt124_device, NULL
+};
+
+module_usb_serial_driver(serial_drivers, id_table);
+
+MODULE_AUTHOR(DRIVER_AUTHOR);
+MODULE_DESCRIPTION(DRIVER_DESC);
+MODULE_LICENSE("GPL");
--
2.1.0
--
To unsubscribe from this list: send the line "unsubscribe linux-kernel" in
the body of a message to majordomo@xxxxxxxxxxxxxxx
More majordomo info at http://vger.kernel.org/majordomo-info.html
Please read the FAQ at http://www.tux.org/lkml/