rdtech-tc: dump response payload at higher log levels

[libsigrok.git] / src / hardware / rdtech-tc / protocol.c

diff --git a/src/hardware/rdtech-tc/protocol.c b/src/hardware/rdtech-tc/protocol.c
index fd392884735885c4fc1ffa90d1cd250d2071c3c8..649489feeb0da6e0fa106e9035f23ab9f6150661 100644 (file)
--- a/src/hardware/rdtech-tc/protocol.c
+++ b/src/hardware/rdtech-tc/protocol.c
@@ -33,8 +33,6 @@
 #define WRITE_TO_MS    1
 #define POLL_PERIOD_MS 100
 
-static const char *poll_cmd = "getva";
-
 /*
  * Response data (raw sample data) consists of three adjacent chunks
  * of 64 bytes each. These chunks start with their magic string, and
@@ -55,6 +53,9 @@ static const char *poll_cmd = "getva";
 #define OFF_PAC2 (1 * PAC_LEN)
 #define OFF_PAC3 (2 * PAC_LEN)
 #define TC_POLL_LEN (3 * PAC_LEN)
+#if TC_POLL_LEN > RDTECH_TC_RSPBUFSIZE
+#  error "response length exceeds receive buffer space"
+#endif
 
 #define OFF_MODEL 4
 #define LEN_MODEL 4
@@ -121,21 +122,57 @@ static int process_poll_pkt(struct dev_context *devc, uint8_t *dst)
                return SR_ERR_DATA;
        }
 
+       if (sr_log_loglevel_get() >= SR_LOG_SPEW) {
+               static const size_t chunk_max = 32;
+
+               const uint8_t *rdptr;
+               size_t rdlen, chunk_addr, chunk_len;
+               GString *txt;
+
+               sr_spew("check passed on decrypted receive data");
+               rdptr = dst;
+               rdlen = TC_POLL_LEN;
+               chunk_addr = 0;
+               while (rdlen) {
+                       chunk_len = rdlen;
+                       if (chunk_len > chunk_max)
+                               chunk_len = chunk_max;
+                       txt = sr_hexdump_new(rdptr, chunk_len);
+                       sr_spew("%04zx  %s", chunk_addr, txt->str);
+                       sr_hexdump_free(txt);
+                       chunk_addr += chunk_len;
+                       rdptr += chunk_len;
+                       rdlen -= chunk_len;
+               }
+       }
+
        return SR_OK;
 }
 
 SR_PRIV int rdtech_tc_probe(struct sr_serial_dev_inst *serial, struct dev_context *devc)
 {
+       static const char *poll_cmd_cdc = "getva";
+       static const char *poll_cmd_ble = "bgetva\r\n";
+
        int len;
        uint8_t poll_pkt[TC_POLL_LEN];
 
+       /* Construct the request text. Which differs across transports. */
+       devc->is_bluetooth = ser_name_is_bt(serial);
+       snprintf(devc->req_text, sizeof(devc->req_text), "%s",
+               devc->is_bluetooth ? poll_cmd_ble : poll_cmd_cdc);
+       sr_dbg("is bluetooth %d -> poll request '%s'.",
+               devc->is_bluetooth, devc->req_text);
+
+       /* Transmit the request. */
        len = serial_write_blocking(serial,
-               poll_cmd, strlen(poll_cmd), WRITE_TO_MS);
+               devc->req_text, strlen(devc->req_text), WRITE_TO_MS);
        if (len < 0) {
                sr_err("Failed to send probe request.");
                return SR_ERR;
        }
 
+       /* Receive a response. */
        len = serial_read_blocking(serial, devc->buf, TC_POLL_LEN, PROBE_TO_MS);
        if (len != TC_POLL_LEN) {
                sr_err("Failed to read probe response.");
@@ -167,7 +204,7 @@ SR_PRIV int rdtech_tc_poll(const struct sr_dev_inst *sdi, gboolean force)
         * Don't send the request while receive data is being accumulated.
         */
        devc = sdi->priv;
-       if (!force && devc->buflen)
+       if (!force && devc->rdlen)
                return SR_OK;
 
        /*
@@ -185,7 +222,7 @@ SR_PRIV int rdtech_tc_poll(const struct sr_dev_inst *sdi, gboolean force)
         */
        serial = sdi->conn;
        len = serial_write_blocking(serial,
-               poll_cmd, strlen(poll_cmd), WRITE_TO_MS);
+               devc->req_text, strlen(devc->req_text), WRITE_TO_MS);
        if (len < 0) {
                sr_err("Unable to send poll request.");
                return SR_ERR;
@@ -205,9 +242,9 @@ static int handle_poll_data(struct sr_dev_inst *sdi)
        float v;
 
        devc = sdi->priv;
-       sr_spew("Received poll packet (len: %zu).", devc->buflen);
-       if (devc->buflen < TC_POLL_LEN) {
-               sr_err("Insufficient poll packet length: %zu", devc->buflen);
+       sr_spew("Received poll packet (len: %zu).", devc->rdlen);
+       if (devc->rdlen < TC_POLL_LEN) {
+               sr_err("Insufficient poll packet length: %zu", devc->rdlen);
                return SR_ERR_DATA;
        }
 
@@ -245,15 +282,15 @@ static int recv_poll_data(struct sr_dev_inst *sdi, struct sr_serial_dev_inst *se
 
        /* Receive data became available. Drain the transport layer. */
        devc = sdi->priv;
-       while (devc->buflen < TC_POLL_LEN) {
-               space = sizeof(devc->buf) - devc->buflen;
+       while (devc->rdlen < TC_POLL_LEN) {
+               space = sizeof(devc->buf) - devc->rdlen;
                len = serial_read_nonblocking(serial,
-                       &devc->buf[devc->buflen], space);
+                       &devc->buf[devc->rdlen], space);
                if (len < 0)
                        return SR_ERR_IO;
                if (len == 0)
                        return SR_OK;
-               devc->buflen += len;
+               devc->rdlen += len;
        }
 
        /*
@@ -262,13 +299,13 @@ static int recv_poll_data(struct sr_dev_inst *sdi, struct sr_serial_dev_inst *se
         */
 
        /* Process packets when their reception has completed. */
-       while (devc->buflen >= TC_POLL_LEN) {
+       while (devc->rdlen >= TC_POLL_LEN) {
                ret = handle_poll_data(sdi);
                if (ret != SR_OK)
                        return ret;
-               devc->buflen -= TC_POLL_LEN;
-               if (devc->buflen)
-                       memmove(&devc->buf[0], &devc->buf[TC_POLL_LEN], devc->buflen);
+               devc->rdlen -= TC_POLL_LEN;
+               if (devc->rdlen)
+                       memmove(devc->buf, &devc->buf[TC_POLL_LEN], devc->rdlen);
        }
 
        return SR_OK;