hantek-6xxx: Fix the device scan to not scan the NULL entry.

[libsigrok.git] / src / lcr / es51919.c

diff --git a/src/lcr/es51919.c b/src/lcr/es51919.c
index 91aedbcab690e81d832d71c5a46bb22ce2c57f9b..0244851a2b6c9594ab093dc4d7429523fcc9e791 100644 (file)
--- a/src/lcr/es51919.c
+++ b/src/lcr/es51919.c
@@ -415,9 +415,6 @@ static const char *const models[] = {
 
 /** Private, per-device-instance driver context. */
 struct dev_context {
-       /** Opaque pointer passed in by the frontend. */
-       void *cb_data;
-
        /** The number of frames. */
        struct dev_limit_counter frame_count;
 
@@ -470,7 +467,7 @@ static int parse_mq(const uint8_t *pkt, int is_secondary, int is_parallel)
 
        sr_err("Unknown quantity 0x%03x.", is_secondary << 8 | buf[0]);
 
-       return -1;
+       return 0;
 }
 
 static float parse_value(const uint8_t *buf)
@@ -513,8 +510,8 @@ static void parse_measurement(const uint8_t *pkt, float *floatval,
 
        buf = pkt_to_buf(pkt, is_secondary);
 
-       analog->mq = -1;
-       analog->mqflags = 0;
+       analog->meaning->mq = 0;
+       analog->meaning->mqflags = 0;
 
        state = buf[4] & 0xf;
 
@@ -528,24 +525,24 @@ static void parse_measurement(const uint8_t *pkt, float *floatval,
 
        if (!is_secondary) {
                if (pkt[2] & 0x01)
-                       analog->mqflags |= SR_MQFLAG_HOLD;
+                       analog->meaning->mqflags |= SR_MQFLAG_HOLD;
                if (pkt[2] & 0x02)
-                       analog->mqflags |= SR_MQFLAG_REFERENCE;
+                       analog->meaning->mqflags |= SR_MQFLAG_REFERENCE;
        } else {
                if (pkt[2] & 0x04)
-                       analog->mqflags |= SR_MQFLAG_RELATIVE;
+                       analog->meaning->mqflags |= SR_MQFLAG_RELATIVE;
        }
 
-       if ((analog->mq = parse_mq(pkt, is_secondary, pkt[2] & 0x80)) < 0)
+       if ((analog->meaning->mq = parse_mq(pkt, is_secondary, pkt[2] & 0x80)) < 0)
                return;
 
        if ((buf[3] >> 3) >= ARRAY_SIZE(units)) {
                sr_err("Unknown unit %u.", buf[3] >> 3);
-               analog->mq = -1;
+               analog->meaning->mq = 0;
                return;
        }
 
-       analog->unit = units[buf[3] >> 3].unit;
+       analog->meaning->unit = units[buf[3] >> 3].unit;
 
        *floatval = parse_value(buf);
        *floatval *= (state == 0) ? units[buf[3] >> 3].mult : INFINITY;
@@ -595,11 +592,7 @@ static gboolean packet_valid(const uint8_t *pkt)
 static int do_config_update(struct sr_dev_inst *sdi, uint32_t key,
                            GVariant *var)
 {
-       struct dev_context *devc;
-
-       devc = sdi->priv;
-
-       return send_config_update_key(devc->cb_data, key, var);
+       return send_config_update_key(sdi, key, var);
 }
 
 static int send_freq_update(struct sr_dev_inst *sdi, unsigned int freq)
@@ -618,6 +611,9 @@ static void handle_packet(struct sr_dev_inst *sdi, const uint8_t *pkt)
 {
        struct sr_datafeed_packet packet;
        struct sr_datafeed_analog analog;
+       struct sr_analog_encoding encoding;
+       struct sr_analog_meaning meaning;
+       struct sr_analog_spec spec;
        struct dev_context *devc;
        unsigned int val;
        float floatval;
@@ -643,49 +639,49 @@ static void handle_packet(struct sr_dev_inst *sdi, const uint8_t *pkt)
 
        frame = FALSE;
 
-       memset(&analog, 0, sizeof(analog));
+       sr_analog_init(&analog, &encoding, &meaning, &spec, 0);
 
        analog.num_samples = 1;
        analog.data = &floatval;
 
-       analog.channels = g_slist_append(NULL, sdi->channels->data);
+       analog.meaning->channels = g_slist_append(NULL, sdi->channels->data);
 
        parse_measurement(pkt, &floatval, &analog, 0);
-       if (analog.mq >= 0) {
+       if (analog.meaning->mq != 0) {
                if (!frame) {
                        packet.type = SR_DF_FRAME_BEGIN;
-                       sr_session_send(devc->cb_data, &packet);
+                       sr_session_send(sdi, &packet);
                        frame = TRUE;
                }
 
                packet.type = SR_DF_ANALOG;
                packet.payload = &analog;
 
-               sr_session_send(devc->cb_data, &packet);
+               sr_session_send(sdi, &packet);
        }
 
-       g_slist_free(analog.channels);
-       analog.channels = g_slist_append(NULL, sdi->channels->next->data);
+       g_slist_free(analog.meaning->channels);
+       analog.meaning->channels = g_slist_append(NULL, sdi->channels->next->data);
 
        parse_measurement(pkt, &floatval, &analog, 1);
-       if (analog.mq >= 0) {
+       if (analog.meaning->mq != 0) {
                if (!frame) {
                        packet.type = SR_DF_FRAME_BEGIN;
-                       sr_session_send(devc->cb_data, &packet);
+                       sr_session_send(sdi, &packet);
                        frame = TRUE;
                }
 
                packet.type = SR_DF_ANALOG;
                packet.payload = &analog;
 
-               sr_session_send(devc->cb_data, &packet);
+               sr_session_send(sdi, &packet);
        }
 
-       g_slist_free(analog.channels);
+       g_slist_free(analog.meaning->channels);
 
        if (frame) {
                packet.type = SR_DF_FRAME_END;
-               sr_session_send(devc->cb_data, &packet);
+               sr_session_send(sdi, &packet);
                dev_limit_counter_inc(&devc->frame_count);
        }
 }
@@ -729,7 +725,7 @@ static int receive_data(int fd, int revents, void *cb_data)
 
        if (dev_limit_counter_limit_reached(&devc->frame_count) ||
            dev_time_limit_reached(&devc->time_count))
-               sdi->driver->dev_acquisition_stop(sdi, cb_data);
+               sdi->driver->dev_acquisition_stop(sdi);
 
        return TRUE;
 }
@@ -816,8 +812,7 @@ SR_PRIV int es51919_serial_config_get(uint32_t key, GVariant **data,
 
        (void)cg;
 
-       if (!(devc = sdi->priv))
-               return SR_ERR_BUG;
+       devc = sdi->priv;
 
        switch (key) {
        case SR_CONF_OUTPUT_FREQUENCY:
@@ -827,7 +822,6 @@ SR_PRIV int es51919_serial_config_get(uint32_t key, GVariant **data,
                *data = g_variant_new_string(models[devc->model]);
                break;
        default:
-               sr_spew("%s: Unsupported key %u", __func__, key);
                return SR_ERR_NA;
        }
 
@@ -903,15 +897,13 @@ SR_PRIV int es51919_serial_config_list(uint32_t key, GVariant **data,
                *data = g_variant_new_strv(models, ARRAY_SIZE(models));
                break;
        default:
-               sr_spew("%s: Unsupported key %u", __func__, key);
                return SR_ERR_NA;
        }
 
        return SR_OK;
 }
 
-SR_PRIV int es51919_serial_acquisition_start(const struct sr_dev_inst *sdi,
-                                            void *cb_data)
+SR_PRIV int es51919_serial_acquisition_start(const struct sr_dev_inst *sdi)
 {
        struct dev_context *devc;
        struct sr_serial_dev_inst *serial;
@@ -922,13 +914,10 @@ SR_PRIV int es51919_serial_acquisition_start(const struct sr_dev_inst *sdi,
        if (!(devc = sdi->priv))
                return SR_ERR_BUG;
 
-       devc->cb_data = cb_data;
-
        dev_limit_counter_start(&devc->frame_count);
        dev_time_counter_start(&devc->time_count);
 
-       /* Send header packet to the session bus. */
-       std_session_send_df_header(cb_data, LOG_PREFIX);
+       std_session_send_df_header(sdi);
 
        /* Poll every 50ms, or whenever some data comes in. */
        serial = sdi->conn;
@@ -937,10 +926,3 @@ SR_PRIV int es51919_serial_acquisition_start(const struct sr_dev_inst *sdi,
 
        return SR_OK;
 }
-
-SR_PRIV int es51919_serial_acquisition_stop(struct sr_dev_inst *sdi,
-                                           void *cb_data)
-{
-       return std_serial_dev_acquisition_stop(sdi, cb_data,
-                       std_serial_dev_close, sdi->conn, LOG_PREFIX);
-}