X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fasix-sigma%2Fasix-sigma.c;h=747d5f0cdee09122e15c7405b7c3980f65609a55;hb=b5bbc3f1b00d5f3096c6800af4069fb07704d3a9;hp=e3a56d35b9b3fc49a8fece85f2b2825a96bc2cb5;hpb=fb2e6de774816b4298dcc9eed66d2d9282d53cab;p=libsigrok.git diff --git a/hardware/asix-sigma/asix-sigma.c b/hardware/asix-sigma/asix-sigma.c index e3a56d35..747d5f0c 100644 --- a/hardware/asix-sigma/asix-sigma.c +++ b/hardware/asix-sigma/asix-sigma.c @@ -27,6 +27,7 @@ #include #include #include +#include #include "libsigrok.h" #include "libsigrok-internal.h" #include "asix-sigma.h" @@ -36,7 +37,6 @@ #define USB_DESCRIPTION "ASIX SIGMA" #define USB_VENDOR_NAME "ASIX" #define USB_MODEL_NAME "SIGMA" -#define TRIGGER_TYPE "rf10" SR_PRIV struct sr_dev_driver asix_sigma_driver_info; static struct sr_dev_driver *di = &asix_sigma_driver_info; @@ -74,10 +74,16 @@ static const char *channel_names[] = { static const int32_t hwcaps[] = { SR_CONF_LOGIC_ANALYZER, SR_CONF_SAMPLERATE, - SR_CONF_TRIGGER_TYPE, + SR_CONF_TRIGGER_MATCH, SR_CONF_CAPTURE_RATIO, SR_CONF_LIMIT_MSEC, - SR_CONF_LIMIT_SAMPLES, +}; + +static const int32_t trigger_matches[] = { + SR_TRIGGER_ZERO, + SR_TRIGGER_ONE, + SR_TRIGGER_RISING, + SR_TRIGGER_FALLING, }; static const char *sigma_firmware_files[] = { @@ -683,20 +689,20 @@ static int set_samplerate(const struct sr_dev_inst *sdi, uint64_t samplerate) if (samplerate <= SR_MHZ(50)) { ret = upload_firmware(0, devc); devc->num_channels = 16; - } - if (samplerate == SR_MHZ(100)) { + } else if (samplerate == SR_MHZ(100)) { ret = upload_firmware(1, devc); devc->num_channels = 8; - } - else if (samplerate == SR_MHZ(200)) { + } else if (samplerate == SR_MHZ(200)) { ret = upload_firmware(2, devc); devc->num_channels = 4; } - devc->cur_samplerate = samplerate; - devc->period_ps = 1000000000000ULL / samplerate; - devc->samples_per_event = 16 / devc->num_channels; - devc->state.state = SIGMA_IDLE; + 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; + } return ret; } @@ -709,76 +715,81 @@ static int set_samplerate(const struct sr_dev_inst *sdi, uint64_t samplerate) * The Sigma supports complex triggers using boolean expressions, but this * has not been implemented yet. */ -static int configure_channels(const struct sr_dev_inst *sdi) +static int convert_trigger(const struct sr_dev_inst *sdi) { - struct dev_context *devc = sdi->priv; - const struct sr_channel *ch; - const GSList *l; - int trigger_set = 0; - int channelbit; + struct dev_context *devc; + struct sr_trigger *trigger; + struct sr_trigger_stage *stage; + struct sr_trigger_match *match; + const GSList *l, *m; + int channelbit, trigger_set; + devc = sdi->priv; memset(&devc->trigger, 0, sizeof(struct sigma_trigger)); + if (!(trigger = sr_session_trigger_get())) + return SR_OK; + + trigger_set = 0; + for (l = trigger->stages; l; l = l->next) { + stage = l->data; + for (m = stage->matches; m; m = m->next) { + match = m->data; + if (!match->channel->enabled) + /* Ignore disabled channels with a trigger. */ + continue; + channelbit = 1 << (match->channel->index); + if (devc->cur_samplerate >= SR_MHZ(100)) { + /* Fast trigger support. */ + if (trigger_set) { + sr_err("Only a single pin trigger is " + "supported in 100 and 200MHz mode."); + return SR_ERR; + } + if (match->match == SR_TRIGGER_FALLING) + devc->trigger.fallingmask |= channelbit; + else if (match->match == SR_TRIGGER_RISING) + devc->trigger.risingmask |= channelbit; + else { + sr_err("Only rising/falling trigger is " + "supported in 100 and 200MHz mode."); + return SR_ERR; + } - for (l = sdi->channels; l; l = l->next) { - ch = (struct sr_channel *)l->data; - channelbit = 1 << (ch->index); - - if (!ch->enabled || !ch->trigger) - continue; - - if (devc->cur_samplerate >= SR_MHZ(100)) { - /* Fast trigger support. */ - if (trigger_set) { - sr_err("Only a single pin trigger in 100 and " - "200MHz mode is supported."); - return SR_ERR; - } - if (ch->trigger[0] == 'f') - devc->trigger.fallingmask |= channelbit; - else if (ch->trigger[0] == 'r') - devc->trigger.risingmask |= channelbit; - else { - sr_err("Only rising/falling trigger in 100 " - "and 200MHz mode is supported."); - return SR_ERR; - } - - ++trigger_set; - } else { - /* Simple trigger support (event). */ - if (ch->trigger[0] == '1') { - devc->trigger.simplevalue |= channelbit; - devc->trigger.simplemask |= channelbit; - } - else if (ch->trigger[0] == '0') { - devc->trigger.simplevalue &= ~channelbit; - devc->trigger.simplemask |= channelbit; - } - else if (ch->trigger[0] == 'f') { - devc->trigger.fallingmask |= channelbit; ++trigger_set; - } - else if (ch->trigger[0] == 'r') { - devc->trigger.risingmask |= channelbit; - ++trigger_set; - } - - /* - * Actually, Sigma supports 2 rising/falling triggers, - * but they are ORed and the current trigger syntax - * does not permit ORed triggers. - */ - if (trigger_set > 1) { - sr_err("Only 1 rising/falling trigger " - "is supported."); - return SR_ERR; + } else { + /* Simple trigger support (event). */ + if (match->match == SR_TRIGGER_ONE) { + devc->trigger.simplevalue |= channelbit; + devc->trigger.simplemask |= channelbit; + } + else if (match->match == SR_TRIGGER_ZERO) { + devc->trigger.simplevalue &= ~channelbit; + devc->trigger.simplemask |= channelbit; + } + else if (match->match == SR_TRIGGER_FALLING) { + devc->trigger.fallingmask |= channelbit; + ++trigger_set; + } + else if (match->match == SR_TRIGGER_RISING) { + devc->trigger.risingmask |= channelbit; + ++trigger_set; + } + + /* + * Actually, Sigma supports 2 rising/falling triggers, + * but they are ORed and the current trigger syntax + * does not permit ORed triggers. + */ + if (trigger_set > 1) { + sr_err("Only 1 rising/falling trigger " + "is supported."); + return SR_ERR; + } } } - - if (trigger_set) - devc->use_triggers = 1; } + return SR_OK; } @@ -834,8 +845,8 @@ static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, const struct sr_channel_group *cg) { struct dev_context *devc; - uint64_t num_samples; - int ret = 0; + uint64_t tmp; + int ret; (void)cg; @@ -844,27 +855,28 @@ static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi, devc = sdi->priv; + ret = SR_OK; switch (id) { case SR_CONF_SAMPLERATE: ret = set_samplerate(sdi, g_variant_get_uint64(data)); break; case SR_CONF_LIMIT_MSEC: - devc->limit_msec = g_variant_get_uint64(data); - if (devc->limit_msec > 0) - ret = SR_OK; + tmp = g_variant_get_uint64(data); + if (tmp > 0) + devc->limit_msec = g_variant_get_uint64(data); else ret = SR_ERR; break; case SR_CONF_LIMIT_SAMPLES: - num_samples = g_variant_get_uint64(data); - devc->limit_msec = num_samples * 1000 / devc->cur_samplerate; + tmp = g_variant_get_uint64(data); + devc->limit_msec = tmp * 1000 / devc->cur_samplerate; break; case SR_CONF_CAPTURE_RATIO: - devc->capture_ratio = g_variant_get_uint64(data); - if (devc->capture_ratio < 0 || devc->capture_ratio > 100) - ret = SR_ERR; + tmp = g_variant_get_uint64(data); + if (tmp <= 100) + devc->capture_ratio = tmp; else - ret = SR_OK; + ret = SR_ERR; break; default: ret = SR_ERR_NA; @@ -894,8 +906,10 @@ static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar); *data = g_variant_builder_end(&gvb); break; - case SR_CONF_TRIGGER_TYPE: - *data = g_variant_new_string(TRIGGER_TYPE); + case SR_CONF_TRIGGER_MATCH: + *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, + trigger_matches, ARRAY_SIZE(trigger_matches), + sizeof(int32_t)); break; default: return SR_ERR_NA; @@ -1100,7 +1114,7 @@ static int decode_chunk_ts(struct sigma_dram_line *dram_line, static int download_capture(struct sr_dev_inst *sdi) { struct dev_context *devc = sdi->priv; - const int chunks_per_read = 32; + const uint32_t chunks_per_read = 32; struct sigma_dram_line *dram_line; int bufsz; uint32_t stoppos, triggerpos; @@ -1410,8 +1424,8 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) devc = sdi->priv; - if (configure_channels(sdi) != SR_OK) { - sr_err("Failed to configure channels."); + if (convert_trigger(sdi) != SR_OK) { + sr_err("Failed to configure triggers."); return SR_ERR; }