asix-sigma: Fixup the download of the last data acquisition chunk

[libsigrok.git] / src / hardware / asix-sigma / protocol.c

diff --git a/src/hardware/asix-sigma/protocol.c b/src/hardware/asix-sigma/protocol.c
index ab3342a0af0812b5b3ead235b3842e0cd2f3d5ba..a80e4d10c45be1f9e3af90745672206909b92666 100644 (file)
--- a/src/hardware/asix-sigma/protocol.c
+++ b/src/hardware/asix-sigma/protocol.c
@@ -590,7 +590,6 @@ SR_PRIV int sigma_set_samplerate(const struct sr_dev_inst *sdi, uint64_t sampler
         */
        if (ret == SR_OK) {
                devc->cur_samplerate = samplerate;
-               devc->period_ps = 1000000000000ULL / samplerate;
                devc->samples_per_event = 16 / devc->num_channels;
                devc->state.state = SIGMA_IDLE;
        }
@@ -797,6 +796,34 @@ static void store_sr_sample(uint8_t *samples, int idx, uint16_t data)
        samples[2 * idx + 1] = (data >> 8) & 0xff;
 }
 
+/*
+ * Local wrapper around sr_session_send() calls. Make sure to not send
+ * more samples to the session's datafeed than what was requested by a
+ * previously configured (optional) sample count.
+ */
+static void sigma_session_send(struct sr_dev_inst *sdi,
+                               struct sr_datafeed_packet *packet)
+{
+       struct dev_context *devc;
+       struct sr_datafeed_logic *logic;
+       uint64_t send_now;
+
+       devc = sdi->priv;
+       if (devc->limit_samples) {
+               logic = (void *)packet->payload;
+               send_now = logic->length / logic->unitsize;
+               if (devc->sent_samples + send_now > devc->limit_samples) {
+                       send_now = devc->limit_samples - devc->sent_samples;
+                       logic->length = send_now * logic->unitsize;
+               }
+               if (!send_now)
+                       return;
+               devc->sent_samples += send_now;
+       }
+
+       sr_session_send(sdi, packet);
+}
+
 /*
  * This size translates to: event count (1K events per cluster), times
  * the sample width (unitsize, 16bits per event), times the maximum
@@ -830,15 +857,9 @@ static void sigma_decode_dram_cluster(struct sigma_dram_cluster *dram_cluster,
        logic.data = samples;
 
        /*
-        * First of all, send Sigrok a copy of the last sample from
-        * previous cluster as many times as needed to make up for
-        * the differential characteristics of data we get from the
-        * Sigma. Sigrok needs one sample of data per period.
-        *
-        * One DRAM cluster contains a timestamp and seven samples,
-        * the units of timestamp are "devc->period_ps" , the first
-        * sample in the cluster happens at the time of the timestamp
-        * and the remaining samples happen at timestamp +1...+6 .
+        * If this cluster is not adjacent to the previously received
+        * cluster, then send the appropriate number of samples with the
+        * previous values to the sigrok session. This "decodes RLE".
         */
        for (ts = 0; ts < tsdiff; ts++) {
                i = ts % 1024;
@@ -854,7 +875,7 @@ static void sigma_decode_dram_cluster(struct sigma_dram_cluster *dram_cluster,
                if ((i == 1023) || (ts == tsdiff - 1)) {
                        logic.length = (i + 1) * logic.unitsize;
                        for (j = 0; j < devc->samples_per_event; j++)
-                               sr_session_send(sdi, &packet);
+                               sigma_session_send(sdi, &packet);
                }
        }
 
@@ -908,7 +929,7 @@ static void sigma_decode_dram_cluster(struct sigma_dram_cluster *dram_cluster,
                        trig_count = trigger_offset * devc->samples_per_event;
                        packet.type = SR_DF_LOGIC;
                        logic.length = trig_count * logic.unitsize;
-                       sr_session_send(sdi, &packet);
+                       sigma_session_send(sdi, &packet);
                        send_ptr += trig_count * logic.unitsize;
                        send_count -= trig_count;
                }
@@ -928,7 +949,7 @@ static void sigma_decode_dram_cluster(struct sigma_dram_cluster *dram_cluster,
                packet.type = SR_DF_LOGIC;
                logic.length = send_count * logic.unitsize;
                logic.data = send_ptr;
-               sr_session_send(sdi, &packet);
+               sigma_session_send(sdi, &packet);
        }
 
        ss->lastsample = sample;
@@ -1042,6 +1063,8 @@ static int download_capture(struct sr_dev_inst *sdi)
                trg_event = triggerpos & 0x1ff;
        }
 
+       devc->sent_samples = 0;
+
        /*
         * Determine how many 1024b "DRAM lines" do we need to read from the
         * Sigma so we have a complete set of samples. Note that the last
@@ -1053,7 +1076,7 @@ static int download_capture(struct sr_dev_inst *sdi)
 
        while (dl_lines_total > dl_lines_done) {
                /* We can download only up-to 32 DRAM lines in one go! */
-               dl_lines_curr = MIN(chunks_per_read, dl_lines_total);
+               dl_lines_curr = MIN(chunks_per_read, dl_lines_total - dl_lines_done);
 
                bufsz = sigma_read_dram(dl_lines_done, dl_lines_curr,
                                        (uint8_t *)dram_line, devc);