X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fasix-sigma%2Fasix-sigma.c;h=59faa6e2adea2284ad88e561025c4ea5740ae3d2;hb=1b79df2f57012926927983a8e2829004f0eee4fa;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..59faa6e2 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,14 +20,13 @@ */ /* - * ASIX SIGMA Logic Analyzer Driver + * ASIX SIGMA/SIGMA2 logic analyzer driver */ #include #include #include #include -#include #include "sigrok.h" #include "sigrok-internal.h" #include "asix-sigma.h" @@ -83,13 +82,13 @@ static const char *probe_names[NUM_PROBES + 1] = { }; static struct sr_samplerates samplerates = { - SR_KHZ(200), - SR_MHZ(200), - SR_HZ(0), + 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 +122,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 +146,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 +329,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 +355,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 +396,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; @@ -424,21 +409,38 @@ static int hw_init(const char *devinfo) { struct sr_dev_inst *sdi; struct context *ctx; + struct ftdi_device_list *devlist; + char serial_txt[10]; + uint32_t serial; /* Avoid compiler warnings. */ (void)devinfo; 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 SR_ERR_MALLOC; } ftdi_init(&ctx->ftdic); /* Look for SIGMAs. */ - if (ftdi_usb_open_desc(&ctx->ftdic, USB_VENDOR, USB_PRODUCT, - USB_DESCRIPTION, NULL) < 0) + + if (ftdi_usb_find_all(&ctx->ftdic, &devlist, + USB_VENDOR, USB_PRODUCT) <= 0) + 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; @@ -461,7 +463,7 @@ static int hw_init(const char *devinfo) 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; @@ -529,6 +531,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 +561,8 @@ static int upload_firmware(int firmware_idx, struct context *ctx) ctx->cur_firmware = firmware_idx; + sr_info("sigma: Firmware uploaded"); + return SR_OK; } @@ -617,8 +622,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 +633,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; @@ -711,12 +714,12 @@ static int hw_dev_close(int dev_index) if (!(sdi = sr_dev_inst_get(dev_insts, 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 */ @@ -750,11 +753,11 @@ static int hw_cleanup(void) return ret; } -static void *hw_dev_info_get(int dev_index, int dev_info_id) +static const void *hw_dev_info_get(int dev_index, int dev_info_id) { struct sr_dev_inst *sdi; struct context *ctx; - void *info = NULL; + const void *info = NULL; if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) { sr_err("sigma: %s: sdi was NULL", __func__); @@ -798,12 +801,12 @@ static int hw_dev_status_get(int dev_index) 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; @@ -815,17 +818,17 @@ static int hw_dev_config_set(int dev_index, int hwcap, void *value) 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 +882,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 +938,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 +981,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 +989,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 +1002,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 +1026,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 +1041,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,12 +1259,13 @@ 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; @@ -1343,39 +1349,57 @@ 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))) { sr_err("sigma: %s: sdi was NULL", __func__); @@ -1412,7 +1436,7 @@ 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,