[libsigrok.git] / src / serial_hid_cp2110.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2017 Carl-Fredrik Sundström <audio.cf@gmail.com>
 * Copyright (C) 2017-2019 Gerhard Sittig <gerhard.sittig@gmx.net>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 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.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include <glib.h>
#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#include "serial_hid.h"
#include <string.h>

#define LOG_PREFIX "serial-cp2110"

#ifdef HAVE_SERIAL_COMM
#ifdef HAVE_LIBHIDAPI

/**
 * @file
 *
 * Support serial-over-HID, specifically the SiLabs CP2110 chip.
 */

#define CP2110_MAX_BYTES_PER_REQUEST	63

static const struct vid_pid_item vid_pid_items_cp2110[] = {
	{ 0x10c4, 0xea80, },
	ALL_ZERO
};

enum cp2110_report_id {
	CP2110_UART_ENDIS = 0x41,
	CP2110_UART_STATUS = 0x42,
	CP2110_FIFO_PURGE = 0x43,
	CP2110_UART_CONFIG = 0x50,
};

enum cp2110_uart_enable_param {
	CP2110_UART_DISABLE = 0,
	CP2110_UART_ENABLE = 1,
};

enum cp2110_fifo_purge_flag {
	CP2110_FIFO_PURGE_TX = (1 << 0),
	CP2110_FIFO_PURGE_RX = (1 << 1),
};

enum cp2110_uart_config_bitrate {
	CP2110_BAUDRATE_MIN = 300,
	CP2110_BAUDRATE_MAX = 1000000,
};

enum cp2110_uart_config_databits {
	CP2110_DATABITS_MIN = 5,
	CP2110_DATABITS_MAX = 8,
};

enum cp2110_uart_config_parity {
	CP2110_PARITY_NONE = 0,
	CP2110_PARITY_EVEN = 1,
	CP2110_PARITY_ODD = 2,
	CP2110_PARITY_MARK = 3,
	CP2110_PARITY_SPACE = 4,
};

enum cp2110_uart_config_stopbits {
	CP2110_STOPBITS_SHORT = 0,
	CP2110_STOPBITS_LONG = 1,
};

/* Hardware flow control on CP2110 is RTS/CTS only. */
enum cp2110_uart_config_flowctrl {
	CP2110_FLOWCTRL_NONE = 0,
	CP2110_FLOWCTRL_HARD = 1,
};

static int cp2110_set_params(struct sr_serial_dev_inst *serial,
	int baudrate, int bits, int parity, int stopbits,
	int flowcontrol, int rts, int dtr)
{
	uint8_t report[9];
	int replen;
	int rc;

	/* Map serial API specs to CP2110 register values. Check ranges. */
	if (baudrate < CP2110_BAUDRATE_MIN || baudrate > CP2110_BAUDRATE_MAX) {
		sr_err("CP2110: baudrate %d out of range", baudrate);
		return SR_ERR_ARG;
	}
	if (bits < CP2110_DATABITS_MIN || bits > CP2110_DATABITS_MAX) {
		sr_err("CP2110: %d databits out of range", bits);
		return SR_ERR_ARG;
	}
	bits -= CP2110_DATABITS_MIN;
	switch (parity) {
	case SP_PARITY_NONE:
		parity = CP2110_PARITY_NONE;
		break;
	case SP_PARITY_ODD:
		parity = CP2110_PARITY_ODD;
		break;
	case SP_PARITY_EVEN:
		parity = CP2110_PARITY_EVEN;
		break;
	case SP_PARITY_MARK:
		parity = CP2110_PARITY_MARK;
		break;
	case SP_PARITY_SPACE:
		parity = CP2110_PARITY_SPACE;
		break;
	default:
		sr_err("CP2110: unknown parity spec %d", parity);
		return SR_ERR_ARG;
	}
	switch (stopbits) {
	case 1:
		stopbits = CP2110_STOPBITS_SHORT;
		break;
	case 2:
		stopbits = CP2110_STOPBITS_LONG;
		break;
	default:
		sr_err("CP2110: unknown stop bits spec %d", stopbits);
		return SR_ERR_ARG;
	}
	switch (flowcontrol) {
	case SP_FLOWCONTROL_NONE:
		flowcontrol = CP2110_FLOWCTRL_NONE;
		break;
	case SP_FLOWCONTROL_XONXOFF:
		sr_err("CP2110: unsupported XON/XOFF flow control spec");
		return SR_ERR_ARG;
	case SP_FLOWCONTROL_RTSCTS:
		flowcontrol = CP2110_FLOWCTRL_HARD;
		break;
	default:
		sr_err("CP2110: unknown flow control spec %d", flowcontrol);
		return SR_ERR_ARG;
	}

	/*
	 * Enable the UART. Report layout:
	 * @0, length 1, enabled state (0: disable, 1: enable)
	 */
	replen = 0;
	report[replen++] = CP2110_UART_ENDIS;
	report[replen++] = CP2110_UART_ENABLE;
	rc = ser_hid_hidapi_set_report(serial, report, replen);
	if (rc < 0)
		return SR_ERR;
	if (rc != replen)
		return SR_ERR;

	/*
	 * Setup bitrate and frame format. Report layout:
	 * (@-1, length 1, report number)
	 * @0, length 4, bitrate (big endian format)
	 * @4, length 1, parity
	 * @5, length 1, flow control
	 * @6, length 1, data bits (0: 5, 1: 6, 2: 7, 3: 8)
	 * @7, length 1, stop bits
	 */
	replen = 0;
	report[replen++] = CP2110_UART_CONFIG;
	WB32(&report[replen], baudrate);
	replen += sizeof(uint32_t);
	report[replen++] = parity;
	report[replen++] = flowcontrol;
	report[replen++] = bits;
	report[replen++] = stopbits;
	rc = ser_hid_hidapi_set_report(serial, report, replen);
	if (rc < 0)
		return SR_ERR;
	if (rc != replen)
		return SR_ERR;

	/*
	 * Currently not implemented: Control RTS and DTR state.
	 * TODO are these controlled via GPIO requests?
	 * GPIO.1 == RTS, can't find DTR in AN433 table 4.3
	 */
	(void)rts;
	(void)dtr;

	return SR_OK;
}

static int cp2110_read_bytes(struct sr_serial_dev_inst *serial,
	uint8_t *data, int space, unsigned int timeout)
{
	uint8_t buffer[1 + CP2110_MAX_BYTES_PER_REQUEST];
	int rc;
	int count;

	(void)timeout;

	/*
	 * Check for available input data from the serial port.
	 * Packet layout:
	 * @0, length 1, number of bytes, range 0-63
	 * @1, length N, data bytes
	 */
	memset(buffer, 0, sizeof(buffer));
	rc = ser_hid_hidapi_get_data(serial, 0, buffer, sizeof(buffer), timeout);
	if (rc == SR_ERR_TIMEOUT)
		return 0;
	if (rc < 0)
		return SR_ERR;
	if (rc == 0)
		return 0;
	sr_dbg("DBG: %s() got report len %d, 0x%02x.", __func__, rc, buffer[0]);

	/* Check the length spec, get the byte count. */
	count = buffer[0];
	if (!count)
		return 0;
	if (count > CP2110_MAX_BYTES_PER_REQUEST)
		return SR_ERR;
	sr_dbg("DBG: %s(), got %d UART RX bytes.", __func__, count);
	if (count > space)
		return SR_ERR;

	/* Pass received data bytes and their count to the caller. */
	memcpy(data, &buffer[1], count);
	return count;
}

static int cp2110_write_bytes(struct sr_serial_dev_inst *serial,
	const uint8_t *data, int size)
{
	uint8_t buffer[1 + CP2110_MAX_BYTES_PER_REQUEST];
	int rc;

	sr_dbg("DBG: %s() shall send UART TX data, len %d.", __func__, size);

	if (size < 1)
		return 0;
	if (size > CP2110_MAX_BYTES_PER_REQUEST) {
		size = CP2110_MAX_BYTES_PER_REQUEST;
		sr_dbg("DBG: %s() capping size to %d.", __func__, size);
	}

	/*
	 * Packet layout to send serial data to the USB HID chip:
	 * @0, length 1, number of bytes, range 0-63
	 * @1, length N, data bytes
	 */
	buffer[0] = size;
	memcpy(&buffer[1], data, size);
	rc = ser_hid_hidapi_set_data(serial, 0, buffer, sizeof(buffer), 0);
	if (rc < 0)
		return rc;
	if (rc == 0)
		return 0;
	return size;
}

static int cp2110_flush(struct sr_serial_dev_inst *serial)
{
	uint8_t buffer[2];
	int rc;

	sr_dbg("DBG: %s() discarding RX and TX FIFO data.", __func__);

	buffer[0] = CP2110_FIFO_PURGE;
	buffer[1] = CP2110_FIFO_PURGE_TX | CP2110_FIFO_PURGE_RX;
	rc = ser_hid_hidapi_set_data(serial, 0, buffer, sizeof(buffer), 0);
	if (rc != sizeof(buffer))
		return SR_ERR;
	return SR_OK;
}

static int cp2110_drain(struct sr_serial_dev_inst *serial)
{
	uint8_t buffer[7];
	int rc;
	uint16_t tx_fill, rx_fill;

	sr_dbg("DBG: %s() waiting for TX data to drain.", __func__);

	/*
	 * Keep retrieving the UART status until the FIFO is found empty,
	 * or an error occured.
	 * Packet layout:
	 * @0, length 1, report ID
	 * @1, length 2, number of bytes in the TX FIFO (up to 480)
	 * @3, length 2, number of bytes in the RX FIFO (up to 480)
	 * @5, length 1, error status (parity and overrun error flags)
	 * @6, length 1, line break status
	 */
	rx_fill = ~0;
	do {
		memset(buffer, 0, sizeof(buffer));
		buffer[0] = CP2110_UART_STATUS;
		rc = ser_hid_hidapi_get_data(serial, 0, buffer, sizeof(buffer), 0);
		if (rc != sizeof(buffer)) {
			rc = SR_ERR_DATA;
			break;
		}
		if (buffer[0] != CP2110_UART_STATUS) {
			rc = SR_ERR_DATA;
			break;
		}
		rx_fill = RB16(&buffer[1]);
		tx_fill = RB16(&buffer[3]);
		if (!tx_fill) {
			rc = SR_OK;
			break;
		}
		g_usleep(2000);
	} while (1);

	sr_dbg("DBG: %s() TX drained, rc %d, RX fill %u, returning.",
		__func__, rc, (unsigned int)rx_fill);
	return rc;
}

static struct ser_hid_chip_functions chip_cp2110 = {
	.chipname = "cp2110",
	.chipdesc = "SiLabs CP2110",
	.vid_pid_items = vid_pid_items_cp2110,
	.max_bytes_per_request = CP2110_MAX_BYTES_PER_REQUEST,
	.set_params = cp2110_set_params,
	.read_bytes = cp2110_read_bytes,
	.write_bytes = cp2110_write_bytes,
	.flush = cp2110_flush,
	.drain = cp2110_drain,
};
SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_cp2110 = &chip_cp2110;

#else

SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_cp2110 = NULL;

#endif
#endif
Commit	Line	Data
616bc3a1 GS	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2017 Carl-Fredrik Sundström <audio.cf@gmail.com>
	5	* Copyright (C) 2017-2019 Gerhard Sittig <gerhard.sittig@gmx.net>
	6	*
	7	* This program is free software: you can redistribute it and/or modify
	8	* it under the terms of the GNU General Public License as published by
	9	* the Free Software Foundation, either version 3 of the License, or
	10	* (at your option) any later version.
	11	*
	12	* This program is distributed in the hope that it will be useful,
	13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	15	* GNU General Public License for more details.
	16	*
	17	* You should have received a copy of the GNU General Public License
	18	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	19	*/
	20
	21	#include <config.h>
	22	#include <glib.h>
	23	#include <libsigrok/libsigrok.h>
	24	#include "libsigrok-internal.h"
	25	#include "serial_hid.h"
	26	#include <string.h>
	27
616bc3a1	28	#define LOG_PREFIX "serial-cp2110"
616bc3a1 GS	29
	30	#ifdef HAVE_SERIAL_COMM
	31	#ifdef HAVE_LIBHIDAPI
	32
	33	/**
	34	* @file
	35	*
	36	* Support serial-over-HID, specifically the SiLabs CP2110 chip.
	37	*/
	38
	39	#define CP2110_MAX_BYTES_PER_REQUEST 63
	40
	41	static const struct vid_pid_item vid_pid_items_cp2110[] = {
	42	{ 0x10c4, 0xea80, },
9451e01e	43	ALL_ZERO
616bc3a1 GS	44	};
	45
	46	enum cp2110_report_id {
	47	CP2110_UART_ENDIS = 0x41,
	48	CP2110_UART_STATUS = 0x42,
	49	CP2110_FIFO_PURGE = 0x43,
	50	CP2110_UART_CONFIG = 0x50,
	51	};
	52
	53	enum cp2110_uart_enable_param {
	54	CP2110_UART_DISABLE = 0,
	55	CP2110_UART_ENABLE = 1,
	56	};
	57
	58	enum cp2110_fifo_purge_flag {
	59	CP2110_FIFO_PURGE_TX = (1 << 0),
	60	CP2110_FIFO_PURGE_RX = (1 << 1),
	61	};
	62
	63	enum cp2110_uart_config_bitrate {
	64	CP2110_BAUDRATE_MIN = 300,
	65	CP2110_BAUDRATE_MAX = 1000000,
	66	};
	67
	68	enum cp2110_uart_config_databits {
	69	CP2110_DATABITS_MIN = 5,
	70	CP2110_DATABITS_MAX = 8,
	71	};
	72
	73	enum cp2110_uart_config_parity {
	74	CP2110_PARITY_NONE = 0,
	75	CP2110_PARITY_EVEN = 1,
	76	CP2110_PARITY_ODD = 2,
	77	CP2110_PARITY_MARK = 3,
	78	CP2110_PARITY_SPACE = 4,
	79	};
	80
	81	enum cp2110_uart_config_stopbits {
	82	CP2110_STOPBITS_SHORT = 0,
	83	CP2110_STOPBITS_LONG = 1,
	84	};
	85
	86	/* Hardware flow control on CP2110 is RTS/CTS only. */
	87	enum cp2110_uart_config_flowctrl {
	88	CP2110_FLOWCTRL_NONE = 0,
	89	CP2110_FLOWCTRL_HARD = 1,
	90	};
	91
	92	static int cp2110_set_params(struct sr_serial_dev_inst *serial,
	93	int baudrate, int bits, int parity, int stopbits,
	94	int flowcontrol, int rts, int dtr)
	95	{
	96	uint8_t report[9];
	97	int replen;
	98	int rc;
	99
	100	/* Map serial API specs to CP2110 register values. Check ranges. */
	101	if (baudrate < CP2110_BAUDRATE_MIN \|\| baudrate > CP2110_BAUDRATE_MAX) {
	102	sr_err("CP2110: baudrate %d out of range", baudrate);
	103	return SR_ERR_ARG;
	104	}
	105	if (bits < CP2110_DATABITS_MIN \|\| bits > CP2110_DATABITS_MAX) {
	106	sr_err("CP2110: %d databits out of range", bits);
	107	return SR_ERR_ARG;
108	}
109	bits -= CP2110_DATABITS_MIN;
110	switch (parity) {
111	case SP_PARITY_NONE:
112	parity = CP2110_PARITY_NONE;
113	break;
114	case SP_PARITY_ODD:
115	parity = CP2110_PARITY_ODD;
116	break;
117	case SP_PARITY_EVEN:
118	parity = CP2110_PARITY_EVEN;
119	break;
120	case SP_PARITY_MARK:
121	parity = CP2110_PARITY_MARK;
122	break;
123	case SP_PARITY_SPACE:
124	parity = CP2110_PARITY_SPACE;
125	break;
126	default:
127	sr_err("CP2110: unknown parity spec %d", parity);
128	return SR_ERR_ARG;
129	}
130	switch (stopbits) {
131	case 1:
132	stopbits = CP2110_STOPBITS_SHORT;
133	break;
134	case 2:
135	stopbits = CP2110_STOPBITS_LONG;
136	break;
137	default:
138	sr_err("CP2110: unknown stop bits spec %d", stopbits);
139	return SR_ERR_ARG;
140	}
141	switch (flowcontrol) {
142	case SP_FLOWCONTROL_NONE:
143	flowcontrol = CP2110_FLOWCTRL_NONE;
144	break;
145	case SP_FLOWCONTROL_XONXOFF:
146	sr_err("CP2110: unsupported XON/XOFF flow control spec");
147	return SR_ERR_ARG;
148	case SP_FLOWCONTROL_RTSCTS:
149	flowcontrol = CP2110_FLOWCTRL_HARD;
150	break;
151	default:
152	sr_err("CP2110: unknown flow control spec %d", flowcontrol);
153	return SR_ERR_ARG;
154	}
155
156	/*
157	* Enable the UART. Report layout:
158	* @0, length 1, enabled state (0: disable, 1: enable)
159	*/
160	replen = 0;
161	report[replen++] = CP2110_UART_ENDIS;
162	report[replen++] = CP2110_UART_ENABLE;
163	rc = ser_hid_hidapi_set_report(serial, report, replen);
164	if (rc < 0)
165	return SR_ERR;
166	if (rc != replen)
167	return SR_ERR;
168
169	/*
170	* Setup bitrate and frame format. Report layout:
171	* (@-1, length 1, report number)
172	* @0, length 4, bitrate (big endian format)
173	* @4, length 1, parity
174	* @5, length 1, flow control
175	* @6, length 1, data bits (0: 5, 1: 6, 2: 7, 3: 8)
176	* @7, length 1, stop bits
177	*/
178	replen = 0;
179	report[replen++] = CP2110_UART_CONFIG;
180	WB32(&report[replen], baudrate);
181	replen += sizeof(uint32_t);
182	report[replen++] = parity;
183	report[replen++] = flowcontrol;
184	report[replen++] = bits;
185	report[replen++] = stopbits;
186	rc = ser_hid_hidapi_set_report(serial, report, replen);
187	if (rc < 0)
188	return SR_ERR;
189	if (rc != replen)
190	return SR_ERR;
191
192	/*
193	* Currently not implemented: Control RTS and DTR state.
194	* TODO are these controlled via GPIO requests?
195	* GPIO.1 == RTS, can't find DTR in AN433 table 4.3
196	*/
197	(void)rts;
198	(void)dtr;
199
200	return SR_OK;
201	}
202
203	static int cp2110_read_bytes(struct sr_serial_dev_inst *serial,
204	uint8_t *data, int space, unsigned int timeout)
205	{
206	uint8_t buffer[1 + CP2110_MAX_BYTES_PER_REQUEST];
207	int rc;
208	int count;
209
210	(void)timeout;
211
212	/*
213	* Check for available input data from the serial port.
214	* Packet layout:
215	* @0, length 1, number of bytes, range 0-63
216	* @1, length N, data bytes
217	*/
218	memset(buffer, 0, sizeof(buffer));
219	rc = ser_hid_hidapi_get_data(serial, 0, buffer, sizeof(buffer), timeout);
220	if (rc == SR_ERR_TIMEOUT)
221	return 0;
222	if (rc < 0)
223	return SR_ERR;
224	if (rc == 0)
225	return 0;
226	sr_dbg("DBG: %s() got report len %d, 0x%02x.", __func__, rc, buffer[0]);
227
228	/* Check the length spec, get the byte count. */
229	count = buffer[0];
230	if (!count)
231	return 0;
232	if (count > CP2110_MAX_BYTES_PER_REQUEST)
233	return SR_ERR;
234	sr_dbg("DBG: %s(), got %d UART RX bytes.", __func__, count);
235	if (count > space)
236	return SR_ERR;
237
238	/* Pass received data bytes and their count to the caller. */
239	memcpy(data, &buffer[1], count);
240	return count;
241	}
242
243	static int cp2110_write_bytes(struct sr_serial_dev_inst *serial,
244	const uint8_t *data, int size)
245	{
246	uint8_t buffer[1 + CP2110_MAX_BYTES_PER_REQUEST];
247	int rc;
248
249	sr_dbg("DBG: %s() shall send UART TX data, len %d.", __func__, size);
250
251	if (size < 1)
252	return 0;
253	if (size > CP2110_MAX_BYTES_PER_REQUEST) {
254	size = CP2110_MAX_BYTES_PER_REQUEST;
255	sr_dbg("DBG: %s() capping size to %d.", __func__, size);
256	}
257
258	/*
259	* Packet layout to send serial data to the USB HID chip:
260	* @0, length 1, number of bytes, range 0-63
261	* @1, length N, data bytes
262	*/
263	buffer[0] = size;
264	memcpy(&buffer[1], data, size);
265	rc = ser_hid_hidapi_set_data(serial, 0, buffer, sizeof(buffer), 0);
266	if (rc < 0)
267	return rc;
268	if (rc == 0)
269	return 0;
270	return size;
271	}
272
273	static int cp2110_flush(struct sr_serial_dev_inst *serial)
274	{
275	uint8_t buffer[2];
276	int rc;
277
278	sr_dbg("DBG: %s() discarding RX and TX FIFO data.", __func__);
279
280	buffer[0] = CP2110_FIFO_PURGE;
281	buffer[1] = CP2110_FIFO_PURGE_TX \| CP2110_FIFO_PURGE_RX;
282	rc = ser_hid_hidapi_set_data(serial, 0, buffer, sizeof(buffer), 0);
0dc27cd1	283	if (rc != sizeof(buffer))
616bc3a1 GS	284	return SR_ERR;
	285	return SR_OK;
	286	}
	287
	288	static int cp2110_drain(struct sr_serial_dev_inst *serial)
	289	{
	290	uint8_t buffer[7];
	291	int rc;
	292	uint16_t tx_fill, rx_fill;
	293
	294	sr_dbg("DBG: %s() waiting for TX data to drain.", __func__);
	295
	296	/*
	297	* Keep retrieving the UART status until the FIFO is found empty,
	298	* or an error occured.
	299	* Packet layout:
	300	* @0, length 1, report ID
	301	* @1, length 2, number of bytes in the TX FIFO (up to 480)
	302	* @3, length 2, number of bytes in the RX FIFO (up to 480)
	303	* @5, length 1, error status (parity and overrun error flags)
	304	* @6, length 1, line break status
	305	*/
	306	rx_fill = ~0;
	307	do {
	308	memset(buffer, 0, sizeof(buffer));
	309	buffer[0] = CP2110_UART_STATUS;
	310	rc = ser_hid_hidapi_get_data(serial, 0, buffer, sizeof(buffer), 0);
	311	if (rc != sizeof(buffer)) {
	312	rc = SR_ERR_DATA;
	313	break;
	314	}
	315	if (buffer[0] != CP2110_UART_STATUS) {
	316	rc = SR_ERR_DATA;
	317	break;
	318	}
	319	rx_fill = RB16(&buffer[1]);
	320	tx_fill = RB16(&buffer[3]);
	321	if (!tx_fill) {
	322	rc = SR_OK;
	323	break;
	324	}
	325	g_usleep(2000);
	326	} while (1);
	327
	328	sr_dbg("DBG: %s() TX drained, rc %d, RX fill %u, returning.",
	329	__func__, rc, (unsigned int)rx_fill);
	330	return rc;
	331	}
	332
	333	static struct ser_hid_chip_functions chip_cp2110 = {
	334	.chipname = "cp2110",
	335	.chipdesc = "SiLabs CP2110",
	336	.vid_pid_items = vid_pid_items_cp2110,
	337	.max_bytes_per_request = CP2110_MAX_BYTES_PER_REQUEST,
	338	.set_params = cp2110_set_params,
	339	.read_bytes = cp2110_read_bytes,
	340	.write_bytes = cp2110_write_bytes,
	341	.flush = cp2110_flush,
	342	.drain = cp2110_drain,
	343	};
	344	SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_cp2110 = &chip_cp2110;
	345
	346	#else
	347
348	SR_PRIV struct ser_hid_chip_functions *ser_hid_chip_funcs_cp2110 = NULL;
349
350	#endif
351	#endif