Staging: add Support for Quatech ESU2-100 USB 2.0 8-port serial adaptor (c4f3020f) · Commits · e / devices / android_kernel_fairphone_FP5

drivers/staging/Kconfig

+2 −0

Original line number	Diff line number	Diff line
		@@ -121,6 +121,8 @@ source "drivers/staging/octeon/Kconfig"

		source "drivers/staging/serqt_usb2/Kconfig"

		source "drivers/staging/quatech_usb2/Kconfig"

		source "drivers/staging/vt6655/Kconfig"

		source "drivers/staging/vt6656/Kconfig"

drivers/staging/Makefile

+1 −0

Original line number	Diff line number	Diff line
		@@ -41,6 +41,7 @@ obj-$(CONFIG_PLAN9AUTH) += p9auth/
		obj-$(CONFIG_HECI) += heci/
		obj-$(CONFIG_LINE6_USB) += line6/
		obj-$(CONFIG_USB_SERIAL_QUATECH2) += serqt_usb2/
		obj-$(CONFIG_USB_SERIAL_QUATECH_USB2) += quatech_usb2/
		obj-$(CONFIG_OCTEON_ETHERNET) += octeon/
		obj-$(CONFIG_VT6655) += vt6655/
		obj-$(CONFIG_VT6656) += vt6656/

drivers/staging/quatech_usb2/Kconfig

0 → 100644

+15 −0

Original line number	Diff line number	Diff line
		config USB_SERIAL_QUATECH_USB2
		tristate "USB Quatech xSU2-[14]00 USB Serial Driver"
		depends on USB_SERIAL
		help
		Say Y here if you want to use a Quatech USB2.0 to serial adaptor. This
		driver supports the SSU2-100, DSU2-100, DSU2-400, QSU2-100, QSU2-400,
		ESU2-400 and ESU2-100 USB2.0 to RS232 / 485 / 422 serial adaptors.

		Some hardware has an incorrect product string and announces itself as
		ESU-100 (which uses the serqt driver) even though it is an ESU2-100.
		Check the label on the bottom of your device.

		To compile this driver as a module, choose M here: the module will be
		called quatech_usb2 .

drivers/staging/quatech_usb2/Makefile

0 → 100644

+1 −0

Original line number	Diff line number	Diff line
		obj-$(CONFIG_USB_SERIAL_QUATECH_USB2) += quatech_usb2.o

drivers/staging/quatech_usb2/quatech_usb2.c

0 → 100644

+611 −0

Original line number	Diff line number	Diff line
		/*
		* Driver for Quatech Inc USB2.0 to serial adaptors. Largely unrelated to the
		* serqt_usb driver, based on a re-write of the vendor supplied serqt_usb2 code,
		* which is unrelated to the serqt_usb2 in the staging kernel
		*/

		#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/serial.h>
		#include <linux/usb.h>
		#include <linux/usb/serial.h>
		#include <linux/uaccess.h>

		static int debug;

		/* Version Information */
		#define DRIVER_VERSION "v2.00"
		#define DRIVER_AUTHOR "Tim Gobeli, Quatech, Inc"
		#define DRIVER_DESC "Quatech USB 2.0 to Serial Driver"

		/* vendor and device IDs */
		#define USB_VENDOR_ID_QUATECH 0x061d /* Quatech VID */
		#define QUATECH_SSU2_100 0xC120 /* RS232 single port */
		#define QUATECH_DSU2_100 0xC140 /* RS232 dual port */
		#define QUATECH_DSU2_400 0xC150 /* RS232/422/485 dual port */
		#define QUATECH_QSU2_100 0xC160 /* RS232 four port */
		#define QUATECH_QSU2_400 0xC170 /* RS232/422/485 four port */
		#define QUATECH_ESU2_100 0xC1A0 /* RS232 eight port */
		#define QUATECH_ESU2_400 0xC180 /* RS232/422/485 eight port */

		/* magic numbers go here, when we find out which ones are needed */

		#define QU2BOXPWRON 0x8000 /* magic number to turn FPGA power on */
		#define QU2BOX232 0x40 /* RS232 mode on MEI devices */
		#define QU2BOXSPD9600 0x60 /* set speed to 9600 baud */
		/* directions for USB transfers */
		#define USBD_TRANSFER_DIRECTION_IN 0xc0
		#define USBD_TRANSFER_DIRECTION_OUT 0x40
		/* special Quatech command IDs */
		#define QT_SET_GET_DEVICE 0xc2
		#define QT_OPEN_CLOSE_CHANNEL 0xca
		/*#define QT_GET_SET_PREBUF_TRIG_LVL 0xcc
		#define QT_SET_ATF 0xcd
		#define QT_GET_SET_REGISTER 0xc0*/
		#define QT_GET_SET_UART 0xc1
		/*#define QT_HW_FLOW_CONTROL_MASK 0xc5
		#define QT_SW_FLOW_CONTROL_MASK 0xc6
		#define QT_SW_FLOW_CONTROL_DISABLE 0xc7
		#define QT_BREAK_CONTROL 0xc8
		#define QT_STOP_RECEIVE 0xe0
		#define QT_FLUSH_DEVICE 0xc4*/
		#define QT_GET_SET_QMCR 0xe1
		/* port setting constants */
		#define SERIAL_MCR_DTR 0x01
		#define SERIAL_MCR_RTS 0x02
		#define SERIAL_MCR_LOOP 0x10

		#define SERIAL_MSR_CTS 0x10
		#define SERIAL_MSR_CD 0x80
		#define SERIAL_MSR_RI 0x40
		#define SERIAL_MSR_DSR 0x20
		#define SERIAL_MSR_MASK 0xf0

		#define SERIAL_8_DATA 0x03
		#define SERIAL_7_DATA 0x02
		#define SERIAL_6_DATA 0x01
		#define SERIAL_5_DATA 0x00

		#define SERIAL_ODD_PARITY 0X08
		#define SERIAL_EVEN_PARITY 0X18
		#define SERIAL_TWO_STOPB 0x04
		#define SERIAL_ONE_STOPB 0x00

		#define MAX_BAUD_RATE 921600
		#define MAX_BAUD_REMAINDER 4608

		#define SERIAL_LSR_OE 0x02
		#define SERIAL_LSR_PE 0x04
		#define SERIAL_LSR_FE 0x08
		#define SERIAL_LSR_BI 0x10


		static struct usb_device_id quausb2_id_table[] = {
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_SSU2_100)},
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_100)},
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_DSU2_400)},
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_100)},
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_QSU2_400)},
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_100)},
		{USB_DEVICE(USB_VENDOR_ID_QUATECH, QUATECH_ESU2_400)},
		{} /* Terminating entry */
		};

		MODULE_DEVICE_TABLE(usb, quausb2_id_table);

		/* custom structures we need go here */


		static struct usb_driver quausb2_usb_driver = {
		.name = "quatech-usb2-serial",
		.probe = usb_serial_probe,
		.disconnect = usb_serial_disconnect,
		.id_table = quausb2_id_table,
		.no_dynamic_id = 1,
		};

		/* structure in which to keep all the messy stuff that this driver needs
		* alongside the usb_serial_port structure */
		struct quatech2_port {
		int magic;
		char active; /* someone has this device open */
		unsigned char *xfer_to_tty_buffer;
		wait_queue_head_t wait;
		int open_count; /* number of times this port has been opened */
		struct semaphore sem; /* locks this structure */
		__u8 shadowLCR; /* last LCR value received */
		__u8 shadowMCR; /* last MCR value received */
		__u8 shadowMSR; /* last MSR value received */
		__u8 shadowLSR; /* last LSR value received */
		char open_ports; /* ports open on whole device */
		char RxHolding;
		char Rcv_Flush;
		char Xmit_Flush;
		char closePending;
		char fifo_empty_flag;
		int xmit_pending_bytes;
		int xmit_fifo_room_bytes;
		struct semaphore pend_xmit_sem; /* locks this structure */
		spinlock_t lock;
		};

		/* structure which holds line and modem status flags */
		struct qt2_status_data {
		__u8 line_status;
		__u8 modem_status;
		};

		/* Function prototypes */
		static int qt2_boxpoweron(struct usb_serial *serial);
		static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number,
		__u8 QMCR_Value);
		static int port_paranoia_check(struct usb_serial_port *port,
		const char *function);
		static int serial_paranoia_check(struct usb_serial *serial,
		const char *function);
		static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
		*port);
		static inline void qt2_set_port_private(struct usb_serial_port *port,
		struct quatech2_port *data);
		static int qt2_openboxchannel(struct usb_serial *serial, __u16
		Uart_Number, struct qt2_status_data *pDeviceData);
		static int qt2_closeboxchannel(struct usb_serial *serial, __u16
		Uart_Number);
		static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number,
		unsigned short divisor, unsigned char LCR);
		/* implementation functions, roughly in order of use, are here */
		static int qt2_calc_num_ports(struct usb_serial *serial)
		{
		int num_ports;
		int flag_as_400;
		switch (serial->dev->descriptor.idProduct) {
		case QUATECH_SSU2_100:
		num_ports = 1;
		break;

		case QUATECH_DSU2_400:
		flag_as_400 = true;
		case QUATECH_DSU2_100:
		num_ports = 2;
		break;

		case QUATECH_QSU2_400:
		flag_as_400 = true;
		case QUATECH_QSU2_100:
		num_ports = 4;
		break;

		case QUATECH_ESU2_400:
		flag_as_400 = true;
		case QUATECH_ESU2_100:
		num_ports = 8;
		break;
		default:
		num_ports = 1;
		break;
		}
		return num_ports;
		}

		static int qt2_attach(struct usb_serial *serial)
		{
		struct usb_serial_port *port;
		struct quatech2_port *qt2_port;
		int i;
		/* stuff for printing endpoint addresses, not needed for
		* production */
		struct usb_endpoint_descriptor *endpoint;
		struct usb_host_interface *iface_desc;

		/* check how many endpoints there are on the device, for
		* sanity's sake */
		dbg("%s(): Endpoints: %d bulk in, %d bulk out, %d interrupt in",
		__func__, serial->num_bulk_in,
		serial->num_bulk_out, serial->num_interrupt_in);
		if ((serial->num_bulk_in != 1) \|\| (serial->num_bulk_out != 1)) {
		dbg("Device has wrong number of bulk endpoints!");
		return -ENODEV;
		}
		iface_desc = serial->interface->cur_altsetting;
		/* print endpoint addresses so we can check them later
		* by hand */
		for (i = 0; i < iface_desc->desc.bNumEndpoints; ++i)
		{
		endpoint = &iface_desc->endpoint[i].desc;

		if ((endpoint->bEndpointAddress & 0x80) &&
		((endpoint->bmAttributes & 3) == 0x02)) {
		/* we found a bulk in endpoint */
		dbg("found bulk in at 0x%x",
		endpoint->bEndpointAddress);
		}

		if (((endpoint->bEndpointAddress & 0x80) == 0x00) &&
		((endpoint->bmAttributes & 3) == 0x02))
		{
		/* we found a bulk out endpoint */
		dbg("found bulk out at 0x%x",
		endpoint->bEndpointAddress);
		}
		} /* end printing endpoint addresses */

		/* Now setup per port private data, which replaces all the things
		* that quatech added to standard kernel structures in their driver */
		for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		qt2_port = kzalloc(sizeof(*qt2_port), GFP_KERNEL);
		if (!qt2_port) {
		dbg("%s: kmalloc for quatech2_port (%d) failed!.",
		__func__, i);
		return -ENOMEM;
		}
		spin_lock_init(&qt2_port->lock);
		if (i == 0)
		qt2_port->open_ports = 0; /* no ports */
		else
		qt2_port->open_ports = -1; /* unused */

		usb_set_serial_port_data(port, qt2_port);

		}
		/* switch on power to the hardware */
		if (qt2_boxpoweron(serial) < 0) {
		dbg("qt2_boxpoweron() failed");
		goto startup_error;
		}
		/* set all ports to RS232 mode */
		for (i = 0; i < serial->num_ports; ++i) {
		if (qt2_boxsetQMCR(serial, i, QU2BOX232) < 0) {
		dbg("qt2_boxsetQMCR() on port %d failed",
		i);
		goto startup_error;
		}
		}

		return 0;

		startup_error:
		for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		qt2_port = qt2_get_port_private(port);
		kfree(qt2_port);
		usb_set_serial_port_data(port, NULL);
		}

		dbg("Exit fail %s\n", __func__);
		return -EIO;
		}

		static void qt2_release(struct usb_serial *serial)
		{
		struct usb_serial_port *port;
		struct quatech2_port *qt_port;
		int i;

		dbg("enterting %s", __func__);

		for (i = 0; i < serial->num_ports; i++) {
		port = serial->port[i];
		if (!port)
		continue;

		qt_port = usb_get_serial_port_data(port);
		kfree(qt_port);
		usb_set_serial_port_data(port, NULL);
		}
		}
		/* This function is called once per serial port on the device.
		* The tty_struct and the usb_serial_port belong to this port,
		* i.e. there are multiple ones for a multi-port device.
		* However the usb_serial_port structure has a back-pointer
		* to the parent usb_serial structure which belongs to the device,
		* so we can access either the device-wide information or
		* any other port's information (because there are also forward
		* pointers) via that pointer.
		* This is most helpful if the device shares resources (e.g. end
		* points) between different ports
		*/
		int qt2_open(struct tty_struct *tty,
		struct usb_serial_port port, struct file filp)
		{
		struct usb_serial serial; / device structure */
		struct usb_serial_port port0; / first port structure on device */
		struct quatech2_port port_extra; / extra data for this port */
		struct quatech2_port port0_extra; / extra data for first port */
		struct qt2_status_data ChannelData;
		unsigned short default_divisor = QU2BOXSPD9600;
		unsigned char default_LCR = SERIAL_8_DATA;
		int status;

		if (port_paranoia_check(port, __func__))
		return -ENODEV;

		dbg("%s - port %d\n", __func__, port->number);

		serial = port->serial; /* get the parent device structure */
		if (serial_paranoia_check(serial, __func__))
		return -ENODEV;
		port0 = serial->port[0]; /* get the first port's device structure */

		port_extra = qt2_get_port_private(port);
		port0_extra = qt2_get_port_private(port0);

		if (port_extra == NULL \|\| port0_extra == NULL)
		return -ENODEV;

		usb_clear_halt(serial->dev, port->write_urb->pipe);
		usb_clear_halt(serial->dev, port->read_urb->pipe);
		port0_extra->open_ports++;

		/* FIXME: are these needed? Does it even do anything useful? */
		/* get the modem and line status values from the UART */
		status = qt2_openboxchannel(serial, port->number,
		&ChannelData);
		if (status < 0) {
		dbg("qt2_openboxchannel on channel %d failed",
		port->number);
		return status;
		}
		port_extra->shadowLSR = ChannelData.line_status &
		(SERIAL_LSR_OE \| SERIAL_LSR_PE \| SERIAL_LSR_FE \|
		SERIAL_LSR_BI);

		port_extra->shadowMSR = ChannelData.modem_status &
		(SERIAL_MSR_CTS \| SERIAL_MSR_DSR \| SERIAL_MSR_RI \|
		SERIAL_MSR_CD);

		port_extra->fifo_empty_flag = true;
		dbg("qt2_openboxchannel on channel %d completed.",
		port->number);

		/* Set Baud rate to default and turn off flow control here */
		status = qt2_conf_uart(serial, port->number, default_divisor,
		default_LCR);
		if (status < 0) {
		dbg("qt2_conf_uart() failed on channel %d",
		port->number);
		return status;
		}
		dbg("qt2_conf_uart() completed on channel %d",
		port->number);

		dbg("port number is %d", port->number);
		dbg("serial number is %d", port->serial->minor);

		/* We need to set up endpoints here. We only
		* have one pair of endpoints per device, so in fact
		* we only need to set up endpoints on the first time
		* round, not subsequent ones.
		* When we do a write to a port, we will use the same endpoint
		* regardless of the port, with a 5-byte header added on to
		* tell the box which port it should eventually come out of,
		* so the same endpoint information needs to be visible to
		* write calls regardless of which port is being written.
		* To this end we actually keep the relevant endpoints
		* in port 0's structure, because that's always there
		* and avoids providing our own duplicate members in some
		* user data structure for the same purpose.
		* URBs will be allocated and freed dynamically as the are
		* used, so are not touched here.
		*/
		if (port0_extra->open_ports == 1) {
		/* this is first port to be opened */
		}

		dbg("Bulkin endpoint is %d", port->bulk_in_endpointAddress);
		dbg("BulkOut endpoint is %d", port->bulk_out_endpointAddress);
		dbg("Interrupt endpoint is %d", port->interrupt_in_endpointAddress);

		/* initialize our wait queues */
		init_waitqueue_head(&port_extra->wait);

		/* remember to store port_extra and port0 back again at end !*/
		qt2_set_port_private(port, port_extra);
		qt2_set_port_private(serial->port[0], port0_extra);

		return 0;
		}

		/* internal, private helper functions for the driver */

		/* Power up the FPGA in the box to get it working */
		static int qt2_boxpoweron(struct usb_serial *serial)
		{
		int result;
		__u8 Direcion;
		unsigned int pipe;
		Direcion = USBD_TRANSFER_DIRECTION_OUT;
		pipe = usb_rcvctrlpipe(serial->dev, 0);
		result = usb_control_msg(serial->dev, pipe, QT_SET_GET_DEVICE,
		Direcion, QU2BOXPWRON, 0x00, NULL, 0x00,
		5000);
		return result;
		}

		/*
		* qt2_boxsetQMCR Issue a QT_GET_SET_QMCR vendor-spcific request on the
		* default control pipe. If successful return the number of bytes written,
		* otherwise return a negative error number of the problem.
		*/
		static int qt2_boxsetQMCR(struct usb_serial *serial, __u16 Uart_Number,
		__u8 QMCR_Value)
		{
		int result;
		__u16 PortSettings;

		PortSettings = (__u16)(QMCR_Value);

		dbg("%s(): Port = %d, PortSettings = 0x%x", __func__,
		Uart_Number, PortSettings);

		result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
		QT_GET_SET_QMCR, 0x40, PortSettings,
		(__u16)Uart_Number, NULL, 0, 5000);
		return result;
		}

		static int port_paranoia_check(struct usb_serial_port *port,
		const char *function)
		{
		if (!port) {
		dbg("%s - port == NULL", function);
		return -1;
		}
		if (!port->serial) {
		dbg("%s - port->serial == NULL\n", function);
		return -1;
		}
		return 0;
		}

		static int serial_paranoia_check(struct usb_serial *serial,
		const char *function)
		{
		if (!serial) {
		dbg("%s - serial == NULL\n", function);
		return -1;
		}

		if (!serial->type) {
		dbg("%s - serial->type == NULL!", function);
		return -1;
		}

		return 0;
		}

		static inline struct quatech2_port *qt2_get_port_private(struct usb_serial_port
		*port)
		{
		return (struct quatech2_port *)usb_get_serial_port_data(port);
		}

		static inline void qt2_set_port_private(struct usb_serial_port *port,
		struct quatech2_port *data)
		{
		usb_set_serial_port_data(port, (void *)data);
		}

		static int qt2_openboxchannel(struct usb_serial *serial, __u16
		Uart_Number, struct qt2_status_data *status)
		{
		int result;
		__u16 length;
		__u8 Direcion;
		unsigned int pipe;
		length = sizeof(struct qt2_status_data);
		Direcion = USBD_TRANSFER_DIRECTION_IN;
		pipe = usb_rcvctrlpipe(serial->dev, 0);
		result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
		Direcion, 0x00, Uart_Number, status, length, 5000);
		return result;
		}
		static int qt2_closeboxchannel(struct usb_serial *serial, __u16 Uart_Number)
		{
		int result;
		__u8 direcion;
		unsigned int pipe;
		direcion = USBD_TRANSFER_DIRECTION_OUT;
		pipe = usb_sndctrlpipe(serial->dev, 0);
		result = usb_control_msg(serial->dev, pipe, QT_OPEN_CLOSE_CHANNEL,
		direcion, 0, Uart_Number, NULL, 0, 5000);
		return result;
		}

		/* qt2_conf_uart Issue a SET_UART vendor-spcific request on the default
		* control pipe. If successful sets baud rate divisor and LCR value
		*/
		static int qt2_conf_uart(struct usb_serial *serial, unsigned short Uart_Number,
		unsigned short divisor, unsigned char LCR)
		{
		int result;
		unsigned short UartNumandLCR;

		UartNumandLCR = (LCR << 8) + Uart_Number;

		result = usb_control_msg(serial->dev, usb_sndctrlpipe(serial->dev, 0),
		QT_GET_SET_UART, 0x40, divisor, UartNumandLCR,
		NULL, 0, 300);
		return result;
		}

		/*
		* last things in file: stuff to register this driver into the generic
		* USB serial framework.
		*/

		static struct usb_serial_driver quatech2_device = {
		.driver = {
		.owner = THIS_MODULE,
		.name = "quatech_usb2",
		},
		.description = DRIVER_DESC,
		.usb_driver = &quausb2_usb_driver,
		.id_table = quausb2_id_table,
		.num_ports = 8,
		.open = qt2_open,
		/*.close = qt_close,
		.write = qt_write,
		.write_room = qt_write_room,
		.chars_in_buffer = qt_chars_in_buffer,
		.throttle = qt_throttle,
		.unthrottle = qt_unthrottle,*/
		.calc_num_ports = qt2_calc_num_ports,
		/*.ioctl = qt_ioctl,
		.set_termios = qt_set_termios,
		.break_ctl = qt_break,
		.tiocmget = qt_tiocmget,
		.tiocmset = qt_tiocmset,*/
		.attach = qt2_attach,
		.release = qt2_release,
		};

		static int __init quausb2_usb_init(void)
		{
		int retval;

		dbg("%s\n", __func__);

		/* register with usb-serial */
		retval = usb_serial_register(&quatech2_device);

		if (retval)
		goto failed_usb_serial_register;

		printk(KERN_INFO KBUILD_MODNAME ": " DRIVER_VERSION ":"
		DRIVER_DESC "\n");

		/* register with usb */

		retval = usb_register(&quausb2_usb_driver);
		if (retval == 0)
		return 0;

		/* if we're here, usb_register() failed */
		usb_serial_deregister(&quatech2_device);
		failed_usb_serial_register:
		return retval;
		}



		static void __exit quausb2_usb_exit(void)
		{
		usb_deregister(&quausb2_usb_driver);
		usb_serial_deregister(&quatech2_device);
		}

		module_init(quausb2_usb_init);
		module_exit(quausb2_usb_exit);

		MODULE_AUTHOR(DRIVER_AUTHOR);
		MODULE_DESCRIPTION(DRIVER_DESC);
		MODULE_LICENSE("GPL");

		module_param(debug, bool, S_IRUGO \| S_IWUSR);
		MODULE_PARM_DESC(debug, "Debug enabled or not");