]> sigrok.org Git - libsigrok.git/blobdiff - src/hardware/asix-sigma/protocol.c
asix-sigma: concentrate parameters for sample memory interpretation
[libsigrok.git] / src / hardware / asix-sigma / protocol.c
index b1af2e5a2f0efda93f4d412fb17504e72d6ac706..351e15c5d169d343c6695e37c0480a0dabfacf95 100644 (file)
@@ -382,7 +382,7 @@ static int sigma_read_pos(struct dev_context *devc,
 }
 
 static int sigma_read_dram(struct dev_context *devc,
-       uint16_t startchunk, size_t numchunks, uint8_t *data)
+       size_t startchunk, size_t numchunks, uint8_t *data)
 {
        uint8_t buf[128], *wrptr, regval;
        size_t chunk;
@@ -432,10 +432,10 @@ static int sigma_read_dram(struct dev_context *devc,
 SR_PRIV int sigma_write_trigger_lut(struct dev_context *devc,
        struct triggerlut *lut)
 {
-       int lut_addr;
+       size_t lut_addr;
        uint16_t bit;
        uint8_t m3d, m2d, m1d, m0d;
-       uint8_t buf[6], *wrptr;
+       uint8_t buf[6], *wrptr, v8;
        uint16_t selreg;
        int ret;
 
@@ -446,49 +446,49 @@ SR_PRIV int sigma_write_trigger_lut(struct dev_context *devc,
         * which combines pin levels or edges.
         */
        for (lut_addr = 0; lut_addr < 16; lut_addr++) {
-               bit = 1 << lut_addr;
+               bit = BIT(lut_addr);
 
                /* - M4 M3S M3Q */
                m3d = 0;
                if (lut->m4 & bit)
-                       m3d |= 1 << 2;
+                       m3d |= BIT(2);
                if (lut->m3s & bit)
-                       m3d |= 1 << 1;
+                       m3d |= BIT(1);
                if (lut->m3q & bit)
-                       m3d |= 1 << 0;
+                       m3d |= BIT(0);
 
                /* M2D3 M2D2 M2D1 M2D0 */
                m2d = 0;
                if (lut->m2d[3] & bit)
-                       m2d |= 1 << 3;
+                       m2d |= BIT(3);
                if (lut->m2d[2] & bit)
-                       m2d |= 1 << 2;
+                       m2d |= BIT(2);
                if (lut->m2d[1] & bit)
-                       m2d |= 1 << 1;
+                       m2d |= BIT(1);
                if (lut->m2d[0] & bit)
-                       m2d |= 1 << 0;
+                       m2d |= BIT(0);
 
                /* M1D3 M1D2 M1D1 M1D0 */
                m1d = 0;
                if (lut->m1d[3] & bit)
-                       m1d |= 1 << 3;
+                       m1d |= BIT(3);
                if (lut->m1d[2] & bit)
-                       m1d |= 1 << 2;
+                       m1d |= BIT(2);
                if (lut->m1d[1] & bit)
-                       m1d |= 1 << 1;
+                       m1d |= BIT(1);
                if (lut->m1d[0] & bit)
-                       m1d |= 1 << 0;
+                       m1d |= BIT(0);
 
                /* M0D3 M0D2 M0D1 M0D0 */
                m0d = 0;
                if (lut->m0d[3] & bit)
-                       m0d |= 1 << 3;
+                       m0d |= BIT(3);
                if (lut->m0d[2] & bit)
-                       m0d |= 1 << 2;
+                       m0d |= BIT(2);
                if (lut->m0d[1] & bit)
-                       m0d |= 1 << 1;
+                       m0d |= BIT(1);
                if (lut->m0d[0] & bit)
-                       m0d |= 1 << 0;
+                       m0d |= BIT(0);
 
                /*
                 * Send 16bits with M3D/M2D and M1D/M0D bit masks to the
@@ -503,9 +503,9 @@ SR_PRIV int sigma_write_trigger_lut(struct dev_context *devc,
                        buf, wrptr - buf);
                if (ret != SR_OK)
                        return ret;
-               ret = sigma_set_register(devc, WRITE_TRIGGER_SELECT2,
-                       TRGSEL2_RESET | TRGSEL2_LUT_WRITE |
-                       (lut_addr & TRGSEL2_LUT_ADDR_MASK));
+               v8 = TRGSEL2_RESET | TRGSEL2_LUT_WRITE |
+                       (lut_addr & TRGSEL2_LUT_ADDR_MASK);
+               ret = sigma_set_register(devc, WRITE_TRIGGER_SELECT2, v8);
                if (ret != SR_OK)
                        return ret;
        }
@@ -553,14 +553,14 @@ SR_PRIV int sigma_write_trigger_lut(struct dev_context *devc,
  * mode and sending configuration data. Set D7 and toggle D2, D3, D4
  * a few times.
  */
-#define BB_PIN_CCLK (1 << 0) /* D0, CCLK */
-#define BB_PIN_PROG (1 << 1) /* D1, PROG */
-#define BB_PIN_D2   (1 << 2) /* D2, (part of) SUICIDE */
-#define BB_PIN_D3   (1 << 3) /* D3, (part of) SUICIDE */
-#define BB_PIN_D4   (1 << 4) /* D4, (part of) SUICIDE (unused?) */
-#define BB_PIN_INIT (1 << 5) /* D5, INIT, input pin */
-#define BB_PIN_DIN  (1 << 6) /* D6, DIN */
-#define BB_PIN_D7   (1 << 7) /* D7, (part of) SUICIDE */
+#define BB_PIN_CCLK BIT(0) /* D0, CCLK */
+#define BB_PIN_PROG BIT(1) /* D1, PROG */
+#define BB_PIN_D2   BIT(2) /* D2, (part of) SUICIDE */
+#define BB_PIN_D3   BIT(3) /* D3, (part of) SUICIDE */
+#define BB_PIN_D4   BIT(4) /* D4, (part of) SUICIDE (unused?) */
+#define BB_PIN_INIT BIT(5) /* D5, INIT, input pin */
+#define BB_PIN_DIN  BIT(6) /* D6, DIN */
+#define BB_PIN_D7   BIT(7) /* D7, (part of) SUICIDE */
 
 #define BB_BITRATE (750 * 1000)
 #define BB_PINMASK (0xff & ~BB_PIN_INIT)
@@ -601,7 +601,8 @@ static int sigma_fpga_init_bitbang_once(struct dev_context *devc)
                BB_PIN_CCLK,
                BB_PIN_CCLK,
        };
-       int retries, ret;
+       size_t retries;
+       int ret;
        uint8_t data;
 
        /* Section 2. part 1), do the FPGA suicide. */
@@ -746,7 +747,7 @@ static int sigma_fpga_init_la(struct dev_context *devc)
  * by the caller of this function.
  */
 static int sigma_fw_2_bitbang(struct sr_context *ctx, const char *name,
-       uint8_t **bb_cmd, gsize *bb_cmd_size)
+       uint8_t **bb_cmd, size_t *bb_cmd_size)
 {
        uint8_t *firmware;
        size_t file_size;
@@ -837,7 +838,7 @@ static int upload_firmware(struct sr_context *ctx, struct dev_context *devc,
                return SR_OK;
        }
 
-       devc->state.state = SIGMA_CONFIG;
+       devc->state = SIGMA_CONFIG;
 
        /* Set the cable to bitbang mode. */
        ret = ftdi_set_bitmode(&devc->ftdi.ctx, BB_PINMASK, BITMODE_BITBANG);
@@ -895,7 +896,7 @@ static int upload_firmware(struct sr_context *ctx, struct dev_context *devc,
        }
 
        /* Keep track of successful firmware download completion. */
-       devc->state.state = SIGMA_IDLE;
+       devc->state = SIGMA_IDLE;
        devc->firmware_idx = firmware_idx;
        sr_info("Firmware uploaded.");
 
@@ -932,10 +933,10 @@ SR_PRIV int sigma_set_acquire_timeout(struct dev_context *devc)
        uint64_t worst_cluster_time_ms;
        uint64_t count_msecs, acquire_msecs;
 
-       sr_sw_limits_init(&devc->acq_limits);
+       sr_sw_limits_init(&devc->limit.acquire);
 
        /* Get sample count limit, convert to msecs. */
-       ret = sr_sw_limits_config_get(&devc->cfg_limits,
+       ret = sr_sw_limits_config_get(&devc->limit.config,
                SR_CONF_LIMIT_SAMPLES, &data);
        if (ret != SR_OK)
                return ret;
@@ -946,7 +947,7 @@ SR_PRIV int sigma_set_acquire_timeout(struct dev_context *devc)
                count_msecs = 1000 * user_count / devc->clock.samplerate + 1;
 
        /* Get time limit, which is in msecs. */
-       ret = sr_sw_limits_config_get(&devc->cfg_limits,
+       ret = sr_sw_limits_config_get(&devc->limit.config,
                SR_CONF_LIMIT_MSEC, &data);
        if (ret != SR_OK)
                return ret;
@@ -966,13 +967,13 @@ SR_PRIV int sigma_set_acquire_timeout(struct dev_context *devc)
        worst_cluster_time_ms = 1000 * 65536 / devc->clock.samplerate;
        acquire_msecs += 2 * worst_cluster_time_ms;
        data = g_variant_new_uint64(acquire_msecs);
-       ret = sr_sw_limits_config_set(&devc->acq_limits,
+       ret = sr_sw_limits_config_set(&devc->limit.acquire,
                SR_CONF_LIMIT_MSEC, data);
        g_variant_unref(data);
        if (ret != SR_OK)
                return ret;
 
-       sr_sw_limits_acquisition_start(&devc->acq_limits);
+       sr_sw_limits_acquisition_start(&devc->limit.acquire);
        return SR_OK;
 }
 
@@ -1067,7 +1068,7 @@ SR_PRIV int sigma_set_samplerate(const struct sr_dev_inst *sdi)
        struct drv_context *drvc;
        uint64_t samplerate;
        int ret;
-       int num_channels;
+       size_t num_channels;
 
        devc = sdi->priv;
        drvc = sdi->driver->context;
@@ -1082,7 +1083,7 @@ SR_PRIV int sigma_set_samplerate(const struct sr_dev_inst *sdi)
         * firmware is required and higher rates might limit the set
         * of available channels.
         */
-       num_channels = devc->num_channels;
+       num_channels = devc->interp.num_channels;
        if (samplerate <= SR_MHZ(50)) {
                ret = upload_firmware(drvc->sr_ctx, devc, SIGMA_FW_50MHZ);
                num_channels = 16;
@@ -1100,8 +1101,8 @@ SR_PRIV int sigma_set_samplerate(const struct sr_dev_inst *sdi)
         * which the device will communicate within an "event").
         */
        if (ret == SR_OK) {
-               devc->num_channels = num_channels;
-               devc->samples_per_event = 16 / devc->num_channels;
+               devc->interp.num_channels = num_channels;
+               devc->interp.samples_per_event = 16 / devc->interp.num_channels;
        }
 
        /*
@@ -1156,7 +1157,7 @@ static int alloc_submit_buffer(struct sr_dev_inst *sdi)
        if (!buffer->sample_data)
                return SR_ERR_MALLOC;
        buffer->write_pointer = buffer->sample_data;
-       sr_sw_limits_init(&devc->feed_limits);
+       sr_sw_limits_init(&devc->limit.submit);
 
        buffer->sdi = sdi;
        memset(&buffer->logic, 0, sizeof(buffer->logic));
@@ -1176,9 +1177,9 @@ static int setup_submit_limit(struct dev_context *devc)
        GVariant *data;
        uint64_t total;
 
-       limits = &devc->feed_limits;
+       limits = &devc->limit.submit;
 
-       ret = sr_sw_limits_config_get(&devc->cfg_limits,
+       ret = sr_sw_limits_config_get(&devc->limit.config,
                SR_CONF_LIMIT_SAMPLES, &data);
        if (ret != SR_OK)
                return ret;
@@ -1248,7 +1249,7 @@ static int addto_submit_buffer(struct dev_context *devc,
        int ret;
 
        buffer = devc->buffer;
-       limits = &devc->feed_limits;
+       limits = &devc->limit.submit;
        if (sr_sw_limits_check(limits))
                count = 0;
 
@@ -1288,14 +1289,21 @@ SR_PRIV int sigma_convert_trigger(const struct sr_dev_inst *sdi)
        struct sr_trigger_stage *stage;
        struct sr_trigger_match *match;
        const GSList *l, *m;
-       int channelbit, trigger_set;
+       uint16_t channelbit;
+       size_t trigger_set;
 
        devc = sdi->priv;
        memset(&devc->trigger, 0, sizeof(devc->trigger));
+       devc->use_triggers = FALSE;
        trigger = sr_session_trigger_get(sdi->session);
        if (!trigger)
                return SR_OK;
 
+       if (!ASIX_SIGMA_WITH_TRIGGER) {
+               sr_warn("Trigger support is not implemented. Ignoring the spec.");
+               return SR_OK;
+       }
+
        trigger_set = 0;
        for (l = trigger->stages; l; l = l->next) {
                stage = l->data;
@@ -1304,7 +1312,7 @@ SR_PRIV int sigma_convert_trigger(const struct sr_dev_inst *sdi)
                        /* Ignore disabled channels with a trigger. */
                        if (!match->channel->enabled)
                                continue;
-                       channelbit = 1 << match->channel->index;
+                       channelbit = BIT(match->channel->index);
                        if (devc->clock.samplerate >= SR_MHZ(100)) {
                                /* Fast trigger support. */
                                if (trigger_set) {
@@ -1350,6 +1358,9 @@ SR_PRIV int sigma_convert_trigger(const struct sr_dev_inst *sdi)
                }
        }
 
+       /* Keep track whether triggers are involved during acquisition. */
+       devc->use_triggers = TRUE;
+
        return SR_OK;
 }
 
@@ -1358,7 +1369,7 @@ static int get_trigger_offset(uint8_t *samples, uint16_t last_sample,
        struct sigma_trigger *t)
 {
        const uint8_t *rdptr;
-       int i;
+       size_t i;
        uint16_t sample;
 
        rdptr = samples;
@@ -1401,7 +1412,9 @@ static gboolean sample_matches_trigger(struct dev_context *devc, uint16_t sample
         * See the previous get_trigger_offset() implementation. This
         * code needs to get re-used here.
         */
-       (void)devc;
+       if (!devc->use_triggers)
+               return FALSE;
+
        (void)sample;
        (void)get_trigger_offset;
 
@@ -1452,7 +1465,7 @@ static uint16_t sigma_dram_cluster_data(struct sigma_dram_cluster *cl, int idx)
  * One 16bit item contains two samples of 8bits each. The bits of
  * multiple samples are interleaved.
  */
-static uint16_t sigma_deinterlace_100mhz_data(uint16_t indata, int idx)
+static uint16_t sigma_deinterlace_data_2x8(uint16_t indata, int idx)
 {
        uint16_t outdata;
 
@@ -1474,7 +1487,7 @@ static uint16_t sigma_deinterlace_100mhz_data(uint16_t indata, int idx)
  * One 16bit item contains four samples of 4bits each. The bits of
  * multiple samples are interleaved.
  */
-static uint16_t sigma_deinterlace_200mhz_data(uint16_t indata, int idx)
+static uint16_t sigma_deinterlace_data_4x4(uint16_t indata, int idx)
 {
        uint16_t outdata;
 
@@ -1491,9 +1504,9 @@ static void sigma_decode_dram_cluster(struct dev_context *devc,
        struct sigma_dram_cluster *dram_cluster,
        size_t events_in_cluster, gboolean triggered)
 {
-       struct sigma_state *ss;
        uint16_t tsdiff, ts, sample, item16;
-       unsigned int i;
+       size_t count;
+       size_t evt;
 
        if (!devc->use_triggers || !ASIX_SIGMA_WITH_TRIGGER)
                triggered = FALSE;
@@ -1508,16 +1521,14 @@ static void sigma_decode_dram_cluster(struct dev_context *devc,
         * for simple level and edge triggers. It would not for timed or
         * counted conditions, which currently are not supported.)
         */
-       ss = &devc->state;
        ts = sigma_dram_cluster_ts(dram_cluster);
-       tsdiff = ts - ss->lastts;
+       tsdiff = ts - devc->interp.lastts;
        if (tsdiff > 0) {
-               size_t count;
-               sample = ss->lastsample;
-               count = tsdiff * devc->samples_per_event;
+               sample = devc->interp.lastsample;
+               count = tsdiff * devc->interp.samples_per_event;
                (void)check_and_submit_sample(devc, sample, count, FALSE);
        }
-       ss->lastts = ts + EVENTS_PER_CLUSTER;
+       devc->interp.lastts = ts + EVENTS_PER_CLUSTER;
 
        /*
         * Grab sample data from the current cluster and prepare their
@@ -1527,28 +1538,28 @@ static void sigma_decode_dram_cluster(struct dev_context *devc,
         * buffer depth is neither assumed nor required here.
         */
        sample = 0;
-       for (i = 0; i < events_in_cluster; i++) {
-               item16 = sigma_dram_cluster_data(dram_cluster, i);
-               if (devc->clock.samplerate == SR_MHZ(200)) {
-                       sample = sigma_deinterlace_200mhz_data(item16, 0);
+       for (evt = 0; evt < events_in_cluster; evt++) {
+               item16 = sigma_dram_cluster_data(dram_cluster, evt);
+               if (devc->interp.samples_per_event == 4) {
+                       sample = sigma_deinterlace_data_4x4(item16, 0);
                        check_and_submit_sample(devc, sample, 1, triggered);
-                       sample = sigma_deinterlace_200mhz_data(item16, 1);
+                       sample = sigma_deinterlace_data_4x4(item16, 1);
                        check_and_submit_sample(devc, sample, 1, triggered);
-                       sample = sigma_deinterlace_200mhz_data(item16, 2);
+                       sample = sigma_deinterlace_data_4x4(item16, 2);
                        check_and_submit_sample(devc, sample, 1, triggered);
-                       sample = sigma_deinterlace_200mhz_data(item16, 3);
+                       sample = sigma_deinterlace_data_4x4(item16, 3);
                        check_and_submit_sample(devc, sample, 1, triggered);
-               } else if (devc->clock.samplerate == SR_MHZ(100)) {
-                       sample = sigma_deinterlace_100mhz_data(item16, 0);
+               } else if (devc->interp.samples_per_event == 2) {
+                       sample = sigma_deinterlace_data_2x8(item16, 0);
                        check_and_submit_sample(devc, sample, 1, triggered);
-                       sample = sigma_deinterlace_100mhz_data(item16, 1);
+                       sample = sigma_deinterlace_data_2x8(item16, 1);
                        check_and_submit_sample(devc, sample, 1, triggered);
                } else {
                        sample = item16;
                        check_and_submit_sample(devc, sample, 1, triggered);
                }
        }
-       ss->lastsample = sample;
+       devc->interp.lastsample = sample;
 }
 
 /*
@@ -1565,17 +1576,17 @@ static int decode_chunk_ts(struct dev_context *devc,
        size_t events_in_line, size_t trigger_event)
 {
        struct sigma_dram_cluster *dram_cluster;
-       unsigned int clusters_in_line;
-       unsigned int events_in_cluster;
-       unsigned int i;
-       uint32_t trigger_cluster;
+       size_t clusters_in_line;
+       size_t events_in_cluster;
+       size_t cluster;
+       size_t trigger_cluster;
 
        clusters_in_line = events_in_line;
        clusters_in_line += EVENTS_PER_CLUSTER - 1;
        clusters_in_line /= EVENTS_PER_CLUSTER;
-       trigger_cluster = ~0;
 
        /* Check if trigger is in this chunk. */
+       trigger_cluster = ~0UL;
        if (trigger_event < EVENTS_PER_ROW) {
                if (devc->clock.samplerate <= SR_MHZ(50)) {
                        trigger_event -= MIN(EVENTS_PER_CLUSTER - 1,
@@ -1587,11 +1598,11 @@ static int decode_chunk_ts(struct dev_context *devc,
        }
 
        /* For each full DRAM cluster. */
-       for (i = 0; i < clusters_in_line; i++) {
-               dram_cluster = &dram_line->cluster[i];
+       for (cluster = 0; cluster < clusters_in_line; cluster++) {
+               dram_cluster = &dram_line->cluster[cluster];
 
                /* The last cluster might not be full. */
-               if ((i == clusters_in_line - 1) &&
+               if ((cluster == clusters_in_line - 1) &&
                    (events_in_line % EVENTS_PER_CLUSTER)) {
                        events_in_cluster = events_in_line % EVENTS_PER_CLUSTER;
                } else {
@@ -1599,7 +1610,7 @@ static int decode_chunk_ts(struct dev_context *devc,
                }
 
                sigma_decode_dram_cluster(devc, dram_cluster,
-                       events_in_cluster, i == trigger_cluster);
+                       events_in_cluster, cluster == trigger_cluster);
        }
 
        return SR_OK;
@@ -1613,17 +1624,17 @@ static int download_capture(struct sr_dev_inst *sdi)
        struct sigma_dram_line *dram_line;
        uint32_t stoppos, triggerpos;
        uint8_t modestatus;
-       uint32_t i;
-       uint32_t dl_lines_total, dl_lines_curr, dl_lines_done;
-       uint32_t dl_first_line, dl_line;
-       uint32_t dl_events_in_line, trigger_event;
-       uint32_t trg_line, trg_event;
+       size_t line_idx;
+       size_t dl_lines_total, dl_lines_curr, dl_lines_done;
+       size_t dl_first_line, dl_line;
+       size_t dl_events_in_line, trigger_event;
+       size_t trg_line, trg_event;
        int ret;
 
        devc = sdi->priv;
 
        sr_info("Downloading sample data.");
-       devc->state.state = SIGMA_DOWNLOAD;
+       devc->state = SIGMA_DOWNLOAD;
 
        /*
         * Ask the hardware to stop data acquisition. Reception of the
@@ -1654,8 +1665,10 @@ static int download_capture(struct sr_dev_inst *sdi)
                sr_err("Could not query capture positions/state.");
                return FALSE;
        }
-       trg_line = ~0;
-       trg_event = ~0;
+       if (!devc->use_triggers)
+               triggerpos = ~0;
+       trg_line = ~0UL;
+       trg_event = ~0UL;
        if (modestatus & RMR_TRIGGERED) {
                trg_line = triggerpos >> ROW_SHIFT;
                trg_event = triggerpos & ROW_MASK;
@@ -1700,23 +1713,23 @@ static int download_capture(struct sr_dev_inst *sdi)
 
                /* This is the first DRAM line, so find the initial timestamp. */
                if (dl_lines_done == 0) {
-                       devc->state.lastts =
+                       devc->interp.lastts =
                                sigma_dram_cluster_ts(&dram_line[0].cluster[0]);
-                       devc->state.lastsample = 0;
+                       devc->interp.lastsample = 0;
                }
 
-               for (i = 0; i < dl_lines_curr; i++) {
+               for (line_idx = 0; line_idx < dl_lines_curr; line_idx++) {
                        /* The last "DRAM line" need not span its full length. */
                        dl_events_in_line = EVENTS_PER_ROW;
-                       if (dl_lines_done + i == dl_lines_total - 1)
+                       if (dl_lines_done + line_idx == dl_lines_total - 1)
                                dl_events_in_line = stoppos & ROW_MASK;
 
                        /* Test if the trigger happened on this line. */
-                       trigger_event = ~0;
-                       if (dl_lines_done + i == trg_line)
+                       trigger_event = ~0UL;
+                       if (dl_lines_done + line_idx == trg_line)
                                trigger_event = trg_event;
 
-                       decode_chunk_ts(devc, dram_line + i,
+                       decode_chunk_ts(devc, dram_line + line_idx,
                                dl_events_in_line, trigger_event);
                }
 
@@ -1728,7 +1741,7 @@ static int download_capture(struct sr_dev_inst *sdi)
 
        std_session_send_df_end(sdi);
 
-       devc->state.state = SIGMA_IDLE;
+       devc->state = SIGMA_IDLE;
        sr_dev_acquisition_stop(sdi);
 
        return TRUE;
@@ -1744,7 +1757,7 @@ static int sigma_capture_mode(struct sr_dev_inst *sdi)
        struct dev_context *devc;
 
        devc = sdi->priv;
-       if (sr_sw_limits_check(&devc->acq_limits))
+       if (sr_sw_limits_check(&devc->limit.acquire))
                return download_capture(sdi);
 
        return TRUE;
@@ -1761,7 +1774,7 @@ SR_PRIV int sigma_receive_data(int fd, int revents, void *cb_data)
        sdi = cb_data;
        devc = sdi->priv;
 
-       if (devc->state.state == SIGMA_IDLE)
+       if (devc->state == SIGMA_IDLE)
                return TRUE;
 
        /*
@@ -1770,9 +1783,9 @@ SR_PRIV int sigma_receive_data(int fd, int revents, void *cb_data)
         * keep checking configured limits which will terminate the
         * acquisition and initiate download.
         */
-       if (devc->state.state == SIGMA_STOPPING)
+       if (devc->state == SIGMA_STOPPING)
                return download_capture(sdi);
-       if (devc->state.state == SIGMA_CAPTURE)
+       if (devc->state == SIGMA_CAPTURE)
                return sigma_capture_mode(sdi);
 
        return TRUE;
@@ -1798,7 +1811,7 @@ static void build_lut_entry(uint16_t *lut_entry,
                lut_entry[quad] = ~0;
                for (bitidx = 0; bitidx < 16; bitidx++) {
                        for (ch = 0; ch < 4; ch++) {
-                               quadmask = 1 << ch;
+                               quadmask = BIT(ch);
                                bitmask = quadmask << (quad * 4);
                                if (!(spec_mask & bitmask))
                                        continue;
@@ -1814,7 +1827,7 @@ static void build_lut_entry(uint16_t *lut_entry,
                                bit_idx_low = !(bitidx & quadmask);
                                if (spec_value_low == bit_idx_low)
                                        continue;
-                               lut_entry[quad] &= ~(1 << bitidx);
+                               lut_entry[quad] &= ~BIT(bitidx);
                        }
                }
        }
@@ -1822,14 +1835,19 @@ static void build_lut_entry(uint16_t *lut_entry,
 
 /* Add a logical function to LUT mask. */
 static void add_trigger_function(enum triggerop oper, enum triggerfunc func,
-       int index, int neg, uint16_t *mask)
+       size_t index, gboolean neg, uint16_t *mask)
 {
-       int i, j;
-       int x[2][2], tmp, a, b, aset, bset, rset;
+       int x[2][2], a, b, aset, bset, rset;
+       size_t bitidx;
 
-       memset(x, 0, sizeof(x));
+       /*
+        * Beware! The x, a, b, aset, bset, rset variables strictly
+        * require the limited 0..1 range. They are not interpreted
+        * as logically true, instead bit arith is done on them.
+        */
 
-       /* Trigger detect condition. */
+       /* Construct a pattern which detects the condition. */
+       memset(x, 0, sizeof(x));
        switch (oper) {
        case OP_LEVEL:
                x[0][1] = 1;
@@ -1865,8 +1883,11 @@ static void add_trigger_function(enum triggerop oper, enum triggerfunc func,
                break;
        }
 
-       /* Transpose if neg is set. */
+       /* Transpose the pattern if the condition is negated. */
        if (neg) {
+               size_t i, j;
+               int tmp;
+
                for (i = 0; i < 2; i++) {
                        for (j = 0; j < 2; j++) {
                                tmp = x[i][j];
@@ -1876,29 +1897,30 @@ static void add_trigger_function(enum triggerop oper, enum triggerfunc func,
                }
        }
 
-       /* Update mask with function. */
-       for (i = 0; i < 16; i++) {
-               a = (i >> (2 * index + 0)) & 1;
-               b = (i >> (2 * index + 1)) & 1;
+       /* Update the LUT mask with the function's condition. */
+       for (bitidx = 0; bitidx < 16; bitidx++) {
+               a = (bitidx & BIT(2 * index + 0)) ? 1 : 0;
+               b = (bitidx & BIT(2 * index + 1)) ? 1 : 0;
 
-               aset = (*mask >> i) & 1;
+               aset = (*mask & BIT(bitidx)) ? 1 : 0;
                bset = x[b][a];
 
-               rset = 0;
                if (func == FUNC_AND || func == FUNC_NAND)
                        rset = aset & bset;
                else if (func == FUNC_OR || func == FUNC_NOR)
                        rset = aset | bset;
                else if (func == FUNC_XOR || func == FUNC_NXOR)
                        rset = aset ^ bset;
+               else
+                       rset = 0;
 
                if (func == FUNC_NAND || func == FUNC_NOR || func == FUNC_NXOR)
-                       rset = !rset;
-
-               *mask &= ~(1 << i);
+                       rset = 1 - rset;
 
                if (rset)
-                       *mask |= 1 << i;
+                       *mask |= BIT(bitidx);
+               else
+                       *mask &= ~BIT(bitidx);
        }
 }
 
@@ -1911,11 +1933,15 @@ SR_PRIV int sigma_build_basic_trigger(struct dev_context *devc,
        struct triggerlut *lut)
 {
        uint16_t masks[2];
-       int bitidx, condidx;
+       size_t bitidx, condidx;
        uint16_t value, mask;
 
-       /* Start assuming simple triggers. */
+       /* Setup something that "won't match" in the absence of a spec. */
        memset(lut, 0, sizeof(*lut));
+       if (!devc->use_triggers)
+               return SR_OK;
+
+       /* Start assuming simple triggers. Edges are handled below. */
        lut->m4 = 0xa000;
        lut->m3q = 0xffff;
 
@@ -1928,7 +1954,7 @@ SR_PRIV int sigma_build_basic_trigger(struct dev_context *devc,
        memset(&masks, 0, sizeof(masks));
        condidx = 0;
        for (bitidx = 0; bitidx < 16; bitidx++) {
-               mask = 1 << bitidx;
+               mask = BIT(bitidx);
                value = devc->trigger.risingmask | devc->trigger.fallingmask;
                if (!(value & mask))
                        continue;