X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=output%2Fchronovu_la8.c;h=8029da1b9d2916bdcab58ec11a9296c1f3ee6662;hb=7b5daad45c6526f6eed368e30d262dcbe610b7f5;hp=6ef99dafbfc6621cb58d9f7c67385af8c840de16;hpb=7c1d391c8b33bf76f7c6617fe9d5174e16a04f95;p=libsigrok.git diff --git a/output/chronovu_la8.c b/output/chronovu_la8.c index 6ef99daf..8029da1b 100644 --- a/output/chronovu_la8.c +++ b/output/chronovu_la8.c @@ -1,5 +1,5 @@ /* - * This file is part of the sigrok project. + * This file is part of the libsigrok project. * * Copyright (C) 2011 Uwe Hermann * @@ -21,13 +21,21 @@ #include #include #include -#include "sigrok.h" -#include "sigrok-internal.h" +#include "libsigrok.h" +#include "libsigrok-internal.h" + +/* Message logging helpers with subsystem-specific prefix string. */ +#define LOG_PREFIX "output/chronovu-la8: " +#define sr_log(l, s, args...) sr_log(l, LOG_PREFIX s, ## args) +#define sr_spew(s, args...) sr_spew(LOG_PREFIX s, ## args) +#define sr_dbg(s, args...) sr_dbg(LOG_PREFIX s, ## args) +#define sr_info(s, args...) sr_info(LOG_PREFIX s, ## args) +#define sr_warn(s, args...) sr_warn(LOG_PREFIX s, ## args) +#define sr_err(s, args...) sr_err(LOG_PREFIX s, ## args) struct context { unsigned int num_enabled_probes; unsigned int unitsize; - char *probelist[SR_MAX_NUM_PROBES + 1]; uint64_t trigger_point; uint64_t samplerate; }; @@ -36,6 +44,7 @@ struct context { * Check if the given samplerate is supported by the LA8 hardware. * * @param samplerate The samplerate (in Hz) to check. + * * @return 1 if the samplerate is supported/valid, 0 otherwise. */ static int is_valid_samplerate(uint64_t samplerate) @@ -47,7 +56,7 @@ static int is_valid_samplerate(uint64_t samplerate) return 1; } - sr_warn("la8 out: %s: invalid samplerate (%" PRIu64 "Hz)", + sr_warn("%s: invalid samplerate (%" PRIu64 "Hz)", __func__, samplerate); return 0; @@ -61,18 +70,18 @@ static int is_valid_samplerate(uint64_t samplerate) * Max. value for divcount: 0xfe (2550ns sample period, 392.15kHz samplerate). * * @param samplerate The samplerate in Hz. + * * @return The divcount value as needed by the hardware, or 0xff upon errors. */ static uint8_t samplerate_to_divcount(uint64_t samplerate) { if (samplerate == 0) { - sr_warn("la8 out: %s: samplerate was 0", __func__); + sr_warn("%s: samplerate was 0", __func__); return 0xff; } if (!is_valid_samplerate(samplerate)) { - sr_warn("la8 out: %s: can't get divcount, samplerate invalid", - __func__); + sr_warn("%s: can't get divcount, samplerate invalid", __func__); return 0xff; } @@ -84,86 +93,74 @@ static int init(struct sr_output *o) struct context *ctx; struct sr_probe *probe; GSList *l; - int num_probes; - uint64_t samplerate; + GVariant *gvar; if (!o) { - sr_warn("la8 out: %s: o was NULL", __func__); + sr_warn("%s: o was NULL", __func__); return SR_ERR_ARG; } - if (!o->device) { - sr_warn("la8 out: %s: o->device was NULL", __func__); + if (!o->sdi) { + sr_warn("%s: o->sdi was NULL", __func__); return SR_ERR_ARG; } - if (!o->device->plugin) { - sr_warn("la8 out: %s: o->device->plugin was NULL", __func__); - return SR_ERR_ARG; - } - - if (!(ctx = calloc(1, sizeof(struct context)))) { - sr_warn("la8 out: %s: ctx calloc failed", __func__); + if (!(ctx = g_try_malloc0(sizeof(struct context)))) { + sr_warn("%s: ctx malloc failed", __func__); return SR_ERR_MALLOC; } o->internal = ctx; - /* Get the number of probes, their names, and the unitsize. */ - /* TODO: Error handling. */ - for (l = o->device->probes; l; l = l->next) { + /* Get the unitsize. */ + for (l = o->sdi->probes; l; l = l->next) { probe = l->data; if (!probe->enabled) continue; - ctx->probelist[ctx->num_enabled_probes++] = probe->name; + ctx->num_enabled_probes++; } - ctx->probelist[ctx->num_enabled_probes] = 0; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; - num_probes = g_slist_length(o->device->probes); - - if (sr_device_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { - samplerate = *((uint64_t *) o->device->plugin->get_device_info( - o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); - /* TODO: Error checks. */ - } else { - samplerate = 0; /* TODO: Error or set some value? */ - } - ctx->samplerate = samplerate; + if (sr_config_get(o->sdi->driver, SR_CONF_SAMPLERATE, &gvar, + o->sdi) == SR_OK) { + ctx->samplerate = g_variant_get_uint64(gvar); + g_variant_unref(gvar); + } else + ctx->samplerate = 0; - return 0; /* TODO: SR_OK? */ + return SR_OK; } -static int event(struct sr_output *o, int event_type, char **data_out, +static int event(struct sr_output *o, int event_type, uint8_t **data_out, uint64_t *length_out) { struct context *ctx; - char *outbuf; + uint8_t *outbuf; if (!o) { - sr_warn("la8 out: %s: o was NULL", __func__); + sr_warn("%s: o was NULL", __func__); return SR_ERR_ARG; } if (!(ctx = o->internal)) { - sr_warn("la8 out: %s: o->internal was NULL", __func__); + sr_warn("%s: o->internal was NULL", __func__); return SR_ERR_ARG; } if (!data_out) { - sr_warn("la8 out: %s: data_out was NULL", __func__); + sr_warn("%s: data_out was NULL", __func__); return SR_ERR_ARG; } switch (event_type) { case SR_DF_TRIGGER: - sr_dbg("la8 out: %s: SR_DF_TRIGGER event", __func__); + sr_dbg("%s: SR_DF_TRIGGER event", __func__); /* Save the trigger point for later (SR_DF_END). */ ctx->trigger_point = 0; /* TODO: Store _actual_ value. */ break; case SR_DF_END: - sr_dbg("la8 out: %s: SR_DF_END event", __func__); - if (!(outbuf = malloc(4 + 1))) { + sr_dbg("%s: SR_DF_END event", __func__); + if (!(outbuf = g_try_malloc(4 + 1))) { sr_warn("la8 out: %s: outbuf malloc failed", __func__); return SR_ERR_MALLOC; } @@ -171,7 +168,7 @@ static int event(struct sr_output *o, int event_type, char **data_out, /* One byte for the 'divcount' value. */ outbuf[0] = samplerate_to_divcount(ctx->samplerate); // if (outbuf[0] == 0xff) { - // sr_warn("la8 out: %s: invalid divcount", __func__); + // sr_warn("%s: invalid divcount", __func__); // return SR_ERR; // } @@ -183,11 +180,11 @@ static int event(struct sr_output *o, int event_type, char **data_out, *data_out = outbuf; *length_out = 4 + 1; - free(o->internal); + g_free(o->internal); o->internal = NULL; break; default: - sr_warn("la8 out: %s: unsupported event type: %d", __func__, + sr_warn("%s: unsupported event type: %d", __func__, event_type); *data_out = NULL; *length_out = 0; @@ -197,29 +194,29 @@ static int event(struct sr_output *o, int event_type, char **data_out, return SR_OK; } -static int data(struct sr_output *o, const char *data_in, uint64_t length_in, - char **data_out, uint64_t *length_out) +static int data(struct sr_output *o, const uint8_t *data_in, + uint64_t length_in, uint8_t **data_out, uint64_t *length_out) { struct context *ctx; - char *outbuf; + uint8_t *outbuf; if (!o) { - sr_warn("la8 out: %s: o was NULL", __func__); + sr_warn("%s: o was NULL", __func__); return SR_ERR_ARG; } if (!(ctx = o->internal)) { - sr_warn("la8 out: %s: o->internal was NULL", __func__); + sr_warn("%s: o->internal was NULL", __func__); return SR_ERR_ARG; } if (!data_in) { - sr_warn("la8 out: %s: data_in was NULL", __func__); + sr_warn("%s: data_in was NULL", __func__); return SR_ERR_ARG; } - if (!(outbuf = calloc(1, length_in))) { - sr_warn("la8 out: %s: outbuf calloc failed", __func__); + if (!(outbuf = g_try_malloc0(length_in))) { + sr_warn("%s: outbuf malloc failed", __func__); return SR_ERR_MALLOC; }