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