X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fasix-sigma%2Fasix-sigma.c;h=5eeb6c1cf1aae5cbe56f425db1412cb6e3af8c15;hb=4147960558ae0d8964e8344faa3515a8ec4d9efb;hp=bffe106c5bcb669e6811f97d9df330176f16991a;hpb=1f9813eb6cf2fa3b6511af46b19270feb9484c1e;p=libsigrok.git diff --git a/hardware/asix-sigma/asix-sigma.c b/hardware/asix-sigma/asix-sigma.c index bffe106c..5eeb6c1c 100644 --- a/hardware/asix-sigma/asix-sigma.c +++ b/hardware/asix-sigma/asix-sigma.c @@ -1,7 +1,7 @@ /* * This file is part of the sigrok project. * - * Copyright (C) 2010 Håvard Espeland , + * Copyright (C) 2010-2012 Håvard Espeland , * Copyright (C) 2010 Martin Stensgård * Copyright (C) 2010 Carl Henrik Lunde * @@ -20,16 +20,15 @@ */ /* - * ASIX SIGMA Logic Analyzer Driver + * ASIX SIGMA/SIGMA2 logic analyzer driver */ #include #include #include #include -#include -#include "sigrok.h" -#include "sigrok-internal.h" +#include "libsigrok.h" +#include "libsigrok-internal.h" #include "asix-sigma.h" #define USB_VENDOR 0xa600 @@ -41,9 +40,10 @@ #define TRIGGER_TYPES "rf10" #define NUM_PROBES 16 -static GSList *dev_insts = NULL; +SR_PRIV struct sr_dev_driver asix_sigma_driver_info; +static struct sr_dev_driver *adi = &asix_sigma_driver_info; -static uint64_t supported_samplerates[] = { +static const uint64_t supported_samplerates[] = { SR_KHZ(200), SR_KHZ(250), SR_KHZ(500), @@ -82,14 +82,14 @@ static const char *probe_names[NUM_PROBES + 1] = { NULL, }; -static struct sr_samplerates samplerates = { - SR_KHZ(200), - SR_MHZ(200), - SR_HZ(0), +static const struct sr_samplerates samplerates = { + 0, + 0, + 0, supported_samplerates, }; -static int hwcaps[] = { +static const int hwcaps[] = { SR_HWCAP_LOGIC_ANALYZER, SR_HWCAP_SAMPLERATE, SR_HWCAP_CAPTURE_RATIO, @@ -123,7 +123,7 @@ static const char *firmware_files[] = { "asix-sigma-phasor.fw", /* Frequency counter */ }; -static int hw_dev_acquisition_stop(int dev_index, void *session_data); +static int hw_dev_acquisition_stop(int dev_index, void *cb_data); static int sigma_read(void *buf, size_t size, struct context *ctx) { @@ -147,7 +147,7 @@ static int sigma_write(void *buf, size_t size, struct context *ctx) sr_err("sigma: ftdi_write_data failed: %s", ftdi_get_error_string(&ctx->ftdic)); } else if ((size_t) ret != size) { - sr_err("sigma: ftdi_write_data did not complete write\n"); + sr_err("sigma: ftdi_write_data did not complete write."); } return ret; @@ -330,14 +330,14 @@ static int bin2bitbang(const char *filename, unsigned char **buf, size_t *buf_size) { FILE *f; - long file_size; + unsigned long file_size; unsigned long offset = 0; unsigned char *p; - uint8_t *compressed_buf, *firmware; - uLongf csize, fwsize; + uint8_t *firmware; + unsigned long fwsize = 0; const int buffer_size = 65536; size_t i; - int c, ret, bit, v; + int c, bit, v; uint32_t imm = 0x3f6df2ab; f = g_fopen(filename, "rb"); @@ -356,44 +356,30 @@ static int bin2bitbang(const char *filename, fseek(f, 0, SEEK_SET); - if (!(compressed_buf = g_try_malloc(file_size))) { - sr_err("sigma: %s: compressed_buf malloc failed", __func__); - fclose(f); - return SR_ERR_MALLOC; - } - if (!(firmware = g_try_malloc(buffer_size))) { sr_err("sigma: %s: firmware malloc failed", __func__); fclose(f); - g_free(compressed_buf); return SR_ERR_MALLOC; } - csize = 0; while ((c = getc(f)) != EOF) { imm = (imm + 0xa853753) % 177 + (imm * 0x8034052); - compressed_buf[csize++] = c ^ imm; + firmware[fwsize++] = c ^ imm; } fclose(f); - fwsize = buffer_size; - ret = uncompress(firmware, &fwsize, compressed_buf, csize); - if (ret < 0) { - g_free(compressed_buf); - g_free(firmware); - sr_err("sigma: Could not unpack Sigma firmware. " - "(Error %d)\n", ret); - return SR_ERR; + if(fwsize != file_size) { + sr_err("sigma: %s: Error reading firmware", filename); + fclose(f); + g_free(firmware); + return SR_ERR; } - g_free(compressed_buf); - *buf_size = fwsize * 2 * 8; *buf = p = (unsigned char *)g_try_malloc(*buf_size); if (!p) { sr_err("sigma: %s: buf/p malloc failed", __func__); - g_free(compressed_buf); g_free(firmware); return SR_ERR_MALLOC; } @@ -411,7 +397,7 @@ static int bin2bitbang(const char *filename, if (offset != *buf_size) { g_free(*buf); sr_err("sigma: Error reading firmware %s " - "offset=%ld, file_size=%ld, buf_size=%zd\n", + "offset=%ld, file_size=%ld, buf_size=%zd.", filename, offset, file_size, *buf_size); return SR_ERR; @@ -420,25 +406,81 @@ static int bin2bitbang(const char *filename, return SR_OK; } -static int hw_init(const char *devinfo) +static void clear_instances(void) { + GSList *l; struct sr_dev_inst *sdi; struct context *ctx; - /* Avoid compiler warnings. */ - (void)devinfo; + /* Properly close all devices. */ + for (l = adi->instances; l; l = l->next) { + if (!(sdi = l->data)) { + /* Log error, but continue cleaning up the rest. */ + sr_err("sigma: %s: sdi was NULL, continuing", __func__); + continue; + } + if (sdi->priv) { + ctx = sdi->priv; + ftdi_free(&ctx->ftdic); + g_free(ctx); + } + sr_dev_inst_free(sdi); + } + g_slist_free(adi->instances); + adi->instances = NULL; + +} + +static int hw_init(void) +{ + + /* Nothing to do. */ + + return SR_OK; +} + +static GSList *hw_scan(GSList *options) +{ + struct sr_dev_inst *sdi; + struct context *ctx; + GSList *devices; + struct ftdi_device_list *devlist; + char serial_txt[10]; + uint32_t serial; + int ret; + + (void)options; + devices = NULL; + clear_instances(); if (!(ctx = g_try_malloc(sizeof(struct context)))) { sr_err("sigma: %s: ctx malloc failed", __func__); - return 0; /* FIXME: Should be SR_ERR_MALLOC. */ + return NULL; } ftdi_init(&ctx->ftdic); /* Look for SIGMAs. */ - if (ftdi_usb_open_desc(&ctx->ftdic, USB_VENDOR, USB_PRODUCT, - USB_DESCRIPTION, NULL) < 0) + + if ((ret = ftdi_usb_find_all(&ctx->ftdic, &devlist, + USB_VENDOR, USB_PRODUCT)) <= 0) { + if (ret < 0) + sr_err("ftdi_usb_find_all(): %d", ret); goto free; + } + + /* Make sure it's a version 1 or 2 SIGMA. */ + ftdi_usb_get_strings(&ctx->ftdic, devlist->dev, NULL, 0, NULL, 0, + serial_txt, sizeof(serial_txt)); + sscanf(serial_txt, "%x", &serial); + + if (serial < 0xa6010000 || serial > 0xa602ffff) { + sr_err("sigma: Only SIGMA and SIGMA2 are supported " + "in this version of sigrok."); + goto free; + } + + sr_info("Found ASIX SIGMA - Serial: %s", serial_txt); ctx->cur_samplerate = 0; ctx->period_ps = 0; @@ -455,19 +497,19 @@ static int hw_init(const char *devinfo) sr_err("sigma: %s: sdi was NULL", __func__); goto free; } - + devices = g_slist_append(devices, sdi); + adi->instances = g_slist_append(adi->instances, sdi); sdi->priv = ctx; - dev_insts = g_slist_append(dev_insts, sdi); - /* We will open the device again when we need it. */ - ftdi_usb_close(&ctx->ftdic); + ftdi_list_free(&devlist); - return 1; + return devices; free: + ftdi_deinit(&ctx->ftdic); g_free(ctx); - return 0; + return NULL; } static int upload_firmware(int firmware_idx, struct context *ctx) @@ -529,6 +571,7 @@ static int upload_firmware(int firmware_idx, struct context *ctx) } /* Upload firmare. */ + sr_info("sigma: Uploading firmware %s", firmware_files[firmware_idx]); sigma_write(buf, buf_size, ctx); g_free(buf); @@ -558,6 +601,8 @@ static int upload_firmware(int firmware_idx, struct context *ctx) ctx->cur_firmware = firmware_idx; + sr_info("sigma: Firmware uploaded"); + return SR_OK; } @@ -567,7 +612,7 @@ static int hw_dev_open(int dev_index) struct context *ctx; int ret; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) + if (!(sdi = sr_dev_inst_get(adi->instances, dev_index))) return SR_ERR; ctx = sdi->priv; @@ -617,8 +662,6 @@ static int set_samplerate(struct sr_dev_inst *sdi, uint64_t samplerate) ctx->samples_per_event = 16 / ctx->num_probes; ctx->state.state = SIGMA_IDLE; - sr_info("sigma: Firmware uploaded"); - return ret; } @@ -630,11 +673,11 @@ static int set_samplerate(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_probes(struct sr_dev_inst *sdi, GSList *probes) +static int configure_probes(struct sr_dev_inst *sdi, const GSList *probes) { struct context *ctx = sdi->priv; - struct sr_probe *probe; - GSList *l; + const struct sr_probe *probe; + const GSList *l; int trigger_set = 0; int probebit; @@ -709,14 +752,14 @@ static int hw_dev_close(int dev_index) struct sr_dev_inst *sdi; struct context *ctx; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) { + if (!(sdi = sr_dev_inst_get(adi->instances, dev_index))) { sr_err("sigma: %s: sdi was NULL", __func__); - return SR_ERR; /* TODO: SR_ERR_ARG? */ + return SR_ERR_BUG; } if (!(ctx = sdi->priv)) { sr_err("sigma: %s: sdi->priv was NULL", __func__); - return SR_ERR; /* TODO: SR_ERR_ARG? */ + return SR_ERR_BUG; } /* TODO */ @@ -730,102 +773,84 @@ static int hw_dev_close(int dev_index) static int hw_cleanup(void) { - GSList *l; - struct sr_dev_inst *sdi; - int ret = SR_OK; - /* Properly close all devices. */ - for (l = dev_insts; l; l = l->next) { - if (!(sdi = l->data)) { - /* Log error, but continue cleaning up the rest. */ - sr_err("sigma: %s: sdi was NULL, continuing", __func__); - ret = SR_ERR_BUG; - continue; - } - sr_dev_inst_free(sdi); - } - g_slist_free(dev_insts); - dev_insts = NULL; + clear_instances(); - return ret; + return SR_OK; } -static void *hw_dev_info_get(int dev_index, int dev_info_id) +static int hw_info_get(int info_id, const void **data, + const struct sr_dev_inst *sdi) { - struct sr_dev_inst *sdi; struct context *ctx; - void *info = NULL; - - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) { - sr_err("sigma: %s: sdi was NULL", __func__); - return NULL; - } - ctx = sdi->priv; - - switch (dev_info_id) { + switch (info_id) { case SR_DI_INST: - info = sdi; + *data = sdi; break; case SR_DI_NUM_PROBES: - info = GINT_TO_POINTER(NUM_PROBES); + *data = GINT_TO_POINTER(NUM_PROBES); break; case SR_DI_PROBE_NAMES: - info = probe_names; + *data = probe_names; break; case SR_DI_SAMPLERATES: - info = &samplerates; + *data = &samplerates; break; case SR_DI_TRIGGER_TYPES: - info = (char *)TRIGGER_TYPES; + *data = (char *)TRIGGER_TYPES; break; case SR_DI_CUR_SAMPLERATE: - info = &ctx->cur_samplerate; + if (sdi) { + ctx = sdi->priv; + *data = &ctx->cur_samplerate; + } else + return SR_ERR; break; } - return info; + return SR_OK; } static int hw_dev_status_get(int dev_index) { struct sr_dev_inst *sdi; - sdi = sr_dev_inst_get(dev_insts, dev_index); + sdi = sr_dev_inst_get(adi->instances, dev_index); if (sdi) return sdi->status; else return SR_ST_NOT_FOUND; } -static int *hw_hwcap_get_all(void) +static const int *hw_hwcap_get_all(void) { return hwcaps; } -static int hw_dev_config_set(int dev_index, int hwcap, void *value) +static int hw_dev_config_set(int dev_index, int hwcap, const void *value) { struct sr_dev_inst *sdi; struct context *ctx; int ret; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) + if (!(sdi = sr_dev_inst_get(adi->instances, dev_index))) return SR_ERR; ctx = sdi->priv; if (hwcap == SR_HWCAP_SAMPLERATE) { - ret = set_samplerate(sdi, *(uint64_t *)value); + ret = set_samplerate(sdi, *(const uint64_t *)value); } else if (hwcap == SR_HWCAP_PROBECONFIG) { ret = configure_probes(sdi, value); } else if (hwcap == SR_HWCAP_LIMIT_MSEC) { - ctx->limit_msec = *(uint64_t *)value; + ctx->limit_msec = *(const uint64_t *)value; if (ctx->limit_msec > 0) ret = SR_OK; else ret = SR_ERR; } else if (hwcap == SR_HWCAP_CAPTURE_RATIO) { - ctx->capture_ratio = *(uint64_t *)value; + ctx->capture_ratio = *(const uint64_t *)value; if (ctx->capture_ratio < 0 || ctx->capture_ratio > 100) ret = SR_ERR; else @@ -879,9 +904,9 @@ static int get_trigger_offset(uint16_t *samples, uint16_t last_sample, */ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts, uint16_t *lastsample, int triggerpos, - uint16_t limit_chunk, void *session_data) + uint16_t limit_chunk, void *cb_data) { - struct sr_dev_inst *sdi = session_data; + struct sr_dev_inst *sdi = cb_data; struct context *ctx = sdi->priv; uint16_t tsdiff, ts; uint16_t samples[65536 * ctx->samples_per_event]; @@ -935,7 +960,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts, logic.length = tosend * sizeof(uint16_t); logic.unitsize = 2; logic.data = samples + sent; - sr_session_send(ctx->session_id, &packet); + sr_session_send(ctx->session_dev_id, &packet); sent += tosend; } @@ -978,7 +1003,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts, logic.length = tosend * sizeof(uint16_t); logic.unitsize = 2; logic.data = samples; - sr_session_send(ctx->session_id, &packet); + sr_session_send(ctx->session_dev_id, &packet); sent += tosend; } @@ -986,7 +1011,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts, /* Only send trigger if explicitly enabled. */ if (ctx->use_triggers) { packet.type = SR_DF_TRIGGER; - sr_session_send(ctx->session_id, &packet); + sr_session_send(ctx->session_dev_id, &packet); } } @@ -999,7 +1024,7 @@ static int decode_chunk_ts(uint8_t *buf, uint16_t *lastts, logic.length = tosend * sizeof(uint16_t); logic.unitsize = 2; logic.data = samples + sent; - sr_session_send(ctx->session_id, &packet); + sr_session_send(ctx->session_dev_id, &packet); } *lastsample = samples[n - 1]; @@ -1023,10 +1048,13 @@ static int receive_data(int fd, int revents, void *cb_data) (void)fd; (void)revents; + /* Get the current position. */ + sigma_read_pos(&ctx->state.stoppos, &ctx->state.triggerpos, ctx); + numchunks = (ctx->state.stoppos + 511) / 512; if (ctx->state.state == SIGMA_IDLE) - return FALSE; + return TRUE; if (ctx->state.state == SIGMA_CAPTURE) { /* Check if the timer has expired, or memory is full. */ @@ -1035,16 +1063,15 @@ static int receive_data(int fd, int revents, void *cb_data) (tv.tv_usec - ctx->start_tv.tv_usec) / 1000; if (running_msec < ctx->limit_msec && numchunks < 32767) - return FALSE; - - hw_dev_acquisition_stop(sdi->index, sdi); + return TRUE; /* While capturing... */ + else + hw_dev_acquisition_stop(sdi->index, sdi); - return FALSE; } else if (ctx->state.state == SIGMA_DOWNLOAD) { if (ctx->state.chunks_downloaded >= numchunks) { /* End of samples. */ packet.type = SR_DF_END; - sr_session_send(ctx->session_id, &packet); + sr_session_send(ctx->session_dev_id, &packet); ctx->state.state = SIGMA_IDLE; @@ -1254,19 +1281,20 @@ static int build_basic_trigger(struct triggerlut *lut, struct context *ctx) return SR_OK; } -static int hw_dev_acquisition_start(int dev_index, void *session_data) +static int hw_dev_acquisition_start(int dev_index, void *cb_data) { struct sr_dev_inst *sdi; struct context *ctx; - struct sr_datafeed_packet packet; - struct sr_datafeed_header header; + struct sr_datafeed_packet *packet; + struct sr_datafeed_header *header; + struct sr_datafeed_meta_logic meta; struct clockselect_50 clockselect; int frac, triggerpin, ret; uint8_t triggerselect; struct triggerinout triggerinout_conf; struct triggerlut lut; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) + if (!(sdi = sr_dev_inst_get(adi->instances, dev_index))) return SR_ERR; ctx = sdi->priv; @@ -1343,41 +1371,59 @@ static int hw_dev_acquisition_start(int dev_index, void *session_data) /* Setup maximum post trigger time. */ sigma_set_register(WRITE_POST_TRIGGER, - (ctx->capture_ratio * 255) / 100, ctx); + (ctx->capture_ratio * 255) / 100, ctx); /* Start acqusition. */ gettimeofday(&ctx->start_tv, 0); sigma_set_register(WRITE_MODE, 0x0d, ctx); - ctx->session_id = session_data; + ctx->session_dev_id = cb_data; + + if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) { + sr_err("sigma: %s: packet malloc failed.", __func__); + return SR_ERR_MALLOC; + } + + if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) { + sr_err("sigma: %s: header malloc failed.", __func__); + return SR_ERR_MALLOC; + } /* Send header packet to the session bus. */ - packet.type = SR_DF_HEADER; - packet.payload = &header; - header.feed_version = 1; - gettimeofday(&header.starttime, NULL); - header.samplerate = ctx->cur_samplerate; - header.num_logic_probes = ctx->num_probes; - sr_session_send(session_data, &packet); + packet->type = SR_DF_HEADER; + packet->payload = header; + header->feed_version = 1; + gettimeofday(&header->starttime, NULL); + sr_session_send(ctx->session_dev_id, packet); + + /* Send metadata about the SR_DF_LOGIC packets to come. */ + packet->type = SR_DF_META_LOGIC; + packet->payload = &meta; + meta.samplerate = ctx->cur_samplerate; + meta.num_probes = ctx->num_probes; + sr_session_send(ctx->session_dev_id, packet); /* Add capture source. */ sr_source_add(0, G_IO_IN, 10, receive_data, sdi); + g_free(header); + g_free(packet); + ctx->state.state = SIGMA_CAPTURE; return SR_OK; } -static int hw_dev_acquisition_stop(int dev_index, void *session_data) +static int hw_dev_acquisition_stop(int dev_index, void *cb_data) { struct sr_dev_inst *sdi; struct context *ctx; uint8_t modestatus; /* Avoid compiler warnings. */ - (void)session_data; + (void)cb_data; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) { + if (!(sdi = sr_dev_inst_get(adi->instances, dev_index))) { sr_err("sigma: %s: sdi was NULL", __func__); return SR_ERR_BUG; } @@ -1412,16 +1458,18 @@ static int hw_dev_acquisition_stop(int dev_index, void *session_data) SR_PRIV struct sr_dev_driver asix_sigma_driver_info = { .name = "asix-sigma", - .longname = "ASIX SIGMA", + .longname = "ASIX SIGMA/SIGMA2", .api_version = 1, .init = hw_init, .cleanup = hw_cleanup, + .scan = hw_scan, .dev_open = hw_dev_open, .dev_close = hw_dev_close, - .dev_info_get = hw_dev_info_get, + .info_get = hw_info_get, .dev_status_get = hw_dev_status_get, - .hwcap_get_all = hw_hwcap_get_all, +// .hwcap_get_all = hw_hwcap_get_all, .dev_config_set = hw_dev_config_set, .dev_acquisition_start = hw_dev_acquisition_start, .dev_acquisition_stop = hw_dev_acquisition_stop, + .instances = NULL, };