X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Ffx2lafw%2Ffx2lafw.c;h=7a83b58ba53e1b89b846c7dc68f7bd5de4f99895;hb=aee878fa2efb8483bf93fa3bb03508357fc713a8;hp=c03c6b87391726d59d024743d11fe5803da91d9e;hpb=17dff8a1e6faaec02ed99715f2914b15b4cab82e;p=libsigrok.git diff --git a/hardware/fx2lafw/fx2lafw.c b/hardware/fx2lafw/fx2lafw.c index c03c6b87..7a83b58b 100644 --- a/hardware/fx2lafw/fx2lafw.c +++ b/hardware/fx2lafw/fx2lafw.c @@ -24,8 +24,8 @@ #include #include #include "config.h" -#include "sigrok.h" -#include "sigrok-internal.h" +#include "libsigrok.h" +#include "libsigrok-internal.h" #include "fx2lafw.h" #include "command.h" @@ -38,6 +38,13 @@ static const struct fx2lafw_profile supported_fx2[] = { { 0x08a9, 0x0014, "CWAV", "USBee AX", NULL, FIRMWARE_DIR "/fx2lafw-cwav-usbeeax.fw", 0 }, + /* + * CWAV USBee DX + * XZL-Studio DX + */ + { 0x08a9, 0x0015, "CWAV", "USBee DX", NULL, + FIRMWARE_DIR "/fx2lafw-cwav-usbeedx.fw", + DEV_CAPS_16BIT }, /* * CWAV USBee SX @@ -85,9 +92,6 @@ static const int hwcaps[] = { 0, }; -/* - * TODO: Different probe_names[] for each supported device. - */ static const char *probe_names[] = { "0", "1", @@ -135,11 +139,15 @@ static const struct sr_samplerates samplerates = { supported_samplerates, }; -static GSList *dev_insts = NULL; static libusb_context *usb_context = NULL; -static int hw_dev_config_set(int dev_index, int hwcap, const void *value); -static int hw_dev_acquisition_stop(int dev_index, void *cb_data); +SR_PRIV struct sr_dev_driver fx2lafw_driver_info; +static struct sr_dev_driver *fdi = &fx2lafw_driver_info; +static int hw_dev_close(struct sr_dev_inst *sdi); +static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap, + const void *value); +static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi, + void *cb_data); /** * Check the USB configuration to determine if this is an fx2lafw device. @@ -185,18 +193,15 @@ static gboolean check_conf_profile(libusb_device *dev) return ret; } -static int fx2lafw_dev_open(int dev_index) +static int fx2lafw_dev_open(struct sr_dev_inst *sdi) { libusb_device **devlist; struct libusb_device_descriptor des; - struct sr_dev_inst *sdi; struct context *ctx; struct version_info vi; int ret, skip, i; uint8_t revid; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) - return SR_ERR; ctx = sdi->priv; if (sdi->status == SR_ST_ACTIVE) @@ -223,7 +228,7 @@ static int fx2lafw_dev_open(int dev_index) continue; if (sdi->status == SR_ST_INITIALIZING) { - if (skip != dev_index) { + if (skip != sdi->index) { /* Skip devices of this type that aren't the one we want. */ skip += 1; continue; @@ -292,23 +297,6 @@ static int fx2lafw_dev_open(int dev_index) return SR_OK; } -static void close_dev(struct sr_dev_inst *sdi) -{ - struct context *ctx; - - ctx = sdi->priv; - - if (ctx->usb->devhdl == NULL) - return; - - sr_info("fx2lafw: Closing device %d on %d.%d interface %d.", - sdi->index, ctx->usb->bus, ctx->usb->address, USB_INTERFACE); - libusb_release_interface(ctx->usb->devhdl, USB_INTERFACE); - libusb_close(ctx->usb->devhdl); - ctx->usb->devhdl = NULL; - sdi->status = SR_ST_INACTIVE; -} - static int configure_probes(struct context *ctx, GSList *probes) { struct sr_probe *probe; @@ -327,10 +315,10 @@ static int configure_probes(struct context *ctx, GSList *probes) if (probe->enabled == FALSE) continue; - if (probe->index > 8) + if (probe->index > 7) ctx->sample_wide = TRUE; - probe_bit = 1 << (probe->index - 1); + probe_bit = 1 << (probe->index); if (!(probe->trigger)) continue; @@ -371,30 +359,75 @@ static struct context *fx2lafw_dev_new(void) return ctx; } +static int clear_instances(void) +{ + GSList *l; + struct sr_dev_inst *sdi; + struct context *ctx; + int ret; + + ret = SR_OK; + for (l = fdi->instances; l; l = l->next) { + if (!(sdi = l->data)) { + /* Log error, but continue cleaning up the rest. */ + sr_err("fx2lafw: %s: sdi was NULL, continuing.", + __func__); + ret = SR_ERR_BUG; + continue; + } + if (!(ctx = sdi->priv)) { + /* Log error, but continue cleaning up the rest. */ + sr_err("fx2lafw: %s: sdi->priv was NULL, continuing", + __func__); + ret = SR_ERR_BUG; + continue; + } + hw_dev_close(sdi); + sdi = l->data; + sr_dev_inst_free(sdi); + } + + g_slist_free(fdi->instances); + fdi->instances = NULL; + + return ret; +} + + /* * API callbacks */ -static int hw_init(const char *devinfo) +static int hw_init(void) { - struct sr_dev_inst *sdi; + + if (libusb_init(&usb_context) != 0) { + sr_warn("fx2lafw: Failed to initialize libusb."); + return SR_ERR; + } + + return SR_OK; +} + +static GSList *hw_scan(GSList *options) +{ + GSList *devices; struct libusb_device_descriptor des; + struct sr_dev_inst *sdi; const struct fx2lafw_profile *prof; struct context *ctx; + struct sr_probe *probe; libusb_device **devlist; - int ret; - int devcnt = 0; - int i, j; + int devcnt, num_logic_probes, ret, i, j; /* Avoid compiler warnings. */ - (void)devinfo; + (void)options; - if (libusb_init(&usb_context) != 0) { - sr_warn("fx2lafw: Failed to initialize libusb."); - return 0; - } + /* This scan always invalidates any previous scans. */ + clear_instances(); /* Find all fx2lafw compatible devices and upload firmware to them. */ + devices = NULL; libusb_get_device_list(usb_context, &devlist); for (i = 0; devlist[i]; i++) { @@ -416,15 +449,27 @@ static int hw_init(const char *devinfo) if (!prof) continue; + devcnt = g_slist_length(fdi->instances); sdi = sr_dev_inst_new(devcnt, SR_ST_INITIALIZING, prof->vendor, prof->model, prof->model_version); if (!sdi) - return 0; + return NULL; + sdi->driver = fdi; + + /* Fill in probelist according to this device's profile. */ + num_logic_probes = prof->dev_caps & DEV_CAPS_16BIT ? 16 : 8; + for (j = 0; j < num_logic_probes; j++) { + if (!(probe = sr_probe_new(j, SR_PROBE_LOGIC, TRUE, + probe_names[j]))) + return NULL; + sdi->probes = g_slist_append(sdi->probes, probe); + } ctx = fx2lafw_dev_new(); ctx->profile = prof; sdi->priv = ctx; - dev_insts = g_slist_append(dev_insts, sdi); + fdi->instances = g_slist_append(fdi->instances, sdi); + devices = g_slist_append(devices, sdi); if (check_conf_profile(devlist[i])) { /* Already has the firmware, so fix the new address. */ @@ -444,23 +489,18 @@ static int hw_init(const char *devinfo) ctx->usb = sr_usb_dev_inst_new (libusb_get_bus_number(devlist[i]), 0xff, NULL); } - - devcnt++; } libusb_free_device_list(devlist, 1); - return devcnt; + return devices; } -static int hw_dev_open(int dev_index) +static int hw_dev_open(struct sr_dev_inst *sdi) { - struct sr_dev_inst *sdi; struct context *ctx; int ret; int64_t timediff_us, timediff_ms; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) - return SR_ERR; ctx = sdi->priv; /* @@ -474,7 +514,7 @@ static int hw_dev_open(int dev_index) g_usleep(300 * 1000); timediff_ms = 0; while (timediff_ms < MAX_RENUM_DELAY_MS) { - if ((ret = fx2lafw_dev_open(dev_index)) == SR_OK) + if ((ret = fx2lafw_dev_open(sdi)) == SR_OK) break; g_usleep(100 * 1000); @@ -484,7 +524,7 @@ static int hw_dev_open(int dev_index) } sr_info("fx2lafw: Device came back after %d ms.", timediff_ms); } else { - ret = fx2lafw_dev_open(dev_index); + ret = fx2lafw_dev_open(sdi); } if (ret != SR_OK) { @@ -515,7 +555,7 @@ static int hw_dev_open(int dev_index) if (ctx->cur_samplerate == 0) { /* Samplerate hasn't been set; default to the slowest one. */ - if (hw_dev_config_set(dev_index, SR_HWCAP_SAMPLERATE, + if (hw_dev_config_set(sdi, SR_HWCAP_SAMPLERATE, &supported_samplerates[0]) == SR_ERR) return SR_ERR; } @@ -523,50 +563,29 @@ static int hw_dev_open(int dev_index) return SR_OK; } -static int hw_dev_close(int dev_index) +static int hw_dev_close(struct sr_dev_inst *sdi) { - struct sr_dev_inst *sdi; + struct context *ctx; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) { - sr_err("fx2lafw: %s: sdi was NULL.", __func__); - return SR_ERR_BUG; - } + ctx = sdi->priv; + if (ctx->usb->devhdl == NULL) + return SR_ERR; - /* TODO */ - close_dev(sdi); + sr_info("fx2lafw: Closing device %d on %d.%d interface %d.", + sdi->index, ctx->usb->bus, ctx->usb->address, USB_INTERFACE); + libusb_release_interface(ctx->usb->devhdl, USB_INTERFACE); + libusb_close(ctx->usb->devhdl); + ctx->usb->devhdl = NULL; + sdi->status = SR_ST_INACTIVE; return SR_OK; } static int hw_cleanup(void) { - GSList *l; - struct sr_dev_inst *sdi; - struct context *ctx; - int ret = SR_OK; - - for (l = dev_insts; l; l = l->next) { - if (!(sdi = l->data)) { - /* Log error, but continue cleaning up the rest. */ - sr_err("fx2lafw: %s: sdi was NULL, continuing.", - __func__); - ret = SR_ERR_BUG; - continue; - } - if (!(ctx = sdi->priv)) { - /* Log error, but continue cleaning up the rest. */ - sr_err("fx2lafw: %s: sdi->priv was NULL, continuing", - __func__); - ret = SR_ERR_BUG; - continue; - } - close_dev(sdi); - sdi = l->data; - sr_dev_inst_free(sdi); - } + int ret; - g_slist_free(dev_insts); - dev_insts = NULL; + ret = clear_instances(); if (usb_context) libusb_exit(usb_context); @@ -575,59 +594,53 @@ static int hw_cleanup(void) return ret; } -static const 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; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) - return NULL; - ctx = sdi->priv; - - switch (dev_info_id) { - case SR_DI_INST: - return sdi; + switch (info_id) { + case SR_DI_HWCAPS: + *data = hwcaps; + break; case SR_DI_NUM_PROBES: - return GINT_TO_POINTER( - (ctx->profile->dev_caps & DEV_CAPS_16BIT) ? - 16 : 8); + if (sdi) { + ctx = sdi->priv; + *data = GINT_TO_POINTER( + (ctx->profile->dev_caps & DEV_CAPS_16BIT) ? + 16 : 8); + } else + return SR_ERR; + break; case SR_DI_PROBE_NAMES: - return probe_names; + *data = probe_names; + break; case SR_DI_SAMPLERATES: - return &samplerates; + *data = &samplerates; + break; case SR_DI_TRIGGER_TYPES: - return TRIGGER_TYPES; + *data = TRIGGER_TYPES; + break; case SR_DI_CUR_SAMPLERATE: - return &ctx->cur_samplerate; + if (sdi) { + ctx = sdi->priv; + *data = &ctx->cur_samplerate; + } else + return SR_ERR; + break; + default: + return SR_ERR_ARG; } - return NULL; -} - -static int hw_dev_status_get(int dev_index) -{ - const struct sr_dev_inst *const sdi = - sr_dev_inst_get(dev_insts, dev_index); - - if (!sdi) - return SR_ST_NOT_FOUND; - - return sdi->status; -} - -static const int *hw_hwcap_get_all(void) -{ - return hwcaps; + return SR_OK; } -static int hw_dev_config_set(int dev_index, int hwcap, const void *value) +static int hw_dev_config_set(const struct sr_dev_inst *sdi, 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))) - return SR_ERR; ctx = sdi->priv; if (hwcap == SR_HWCAP_SAMPLERATE) { @@ -662,7 +675,14 @@ static int receive_data(int fd, int revents, void *cb_data) static void abort_acquisition(struct context *ctx) { + int i; + ctx->num_samples = -1; + + for (i = ctx->num_transfers - 1; i >= 0; i--) { + if (ctx->transfers[i]) + libusb_cancel_transfer(ctx->transfers[i]); + } } static void finish_acquisition(struct context *ctx) @@ -680,16 +700,27 @@ static void finish_acquisition(struct context *ctx) for (i = 0; lupfd[i]; i++) sr_source_remove(lupfd[i]->fd); free(lupfd); /* NOT g_free()! */ + + ctx->num_transfers = 0; + g_free(ctx->transfers); } static void free_transfer(struct libusb_transfer *transfer) { struct context *ctx = transfer->user_data; + unsigned int i; g_free(transfer->buffer); transfer->buffer = NULL; libusb_free_transfer(transfer); + for (i = 0; i < ctx->num_transfers; i++) { + if (ctx->transfers[i] == transfer) { + ctx->transfers[i] = NULL; + break; + } + } + ctx->submitted_transfers--; if (ctx->submitted_transfers == 0) finish_acquisition(ctx); @@ -698,20 +729,6 @@ static void free_transfer(struct libusb_transfer *transfer) static void resubmit_transfer(struct libusb_transfer *transfer) { - uint8_t *new_buf; - - /* Increase buffer size to 4096 */ - if (transfer->length != 4096) { - new_buf = g_try_malloc(4096); - /* If allocation of the new buffer fails, just vdo not bother and - * continue to use the old one. */ - if (new_buf) { - g_free(transfer->buffer); - transfer->buffer = new_buf; - transfer->length = 4096; - } - } - if (libusb_submit_transfer(transfer) != 0) { free_transfer(transfer); /* TODO: Stop session? */ @@ -722,8 +739,7 @@ static void resubmit_transfer(struct libusb_transfer *transfer) static void receive_transfer(struct libusb_transfer *transfer) { - /* TODO: These statics have to move to the ctx struct. */ - static int empty_transfer_count = 0; + gboolean packet_has_error = FALSE; struct sr_datafeed_packet packet; struct sr_datafeed_logic logic; struct context *ctx = transfer->user_data; @@ -746,9 +762,22 @@ static void receive_transfer(struct libusb_transfer *transfer) const int sample_width = ctx->sample_wide ? 2 : 1; const int cur_sample_count = transfer->actual_length / sample_width; - if (transfer->actual_length == 0) { - empty_transfer_count++; - if (empty_transfer_count > MAX_EMPTY_TRANSFERS) { + switch (transfer->status) { + case LIBUSB_TRANSFER_NO_DEVICE: + abort_acquisition(ctx); + free_transfer(transfer); + return; + case LIBUSB_TRANSFER_COMPLETED: + case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though */ + break; + default: + packet_has_error = TRUE; + break; + } + + if (transfer->actual_length == 0 || packet_has_error) { + ctx->empty_transfer_count++; + if (ctx->empty_transfer_count > MAX_EMPTY_TRANSFERS) { /* * The FX2 gave up. End the acquisition, the frontend * will work out that the samplecount is short. @@ -760,7 +789,7 @@ static void receive_transfer(struct libusb_transfer *transfer) } return; } else { - empty_transfer_count = 0; + ctx->empty_transfer_count = 0; } trigger_offset = 0; @@ -835,6 +864,8 @@ static void receive_transfer(struct libusb_transfer *transfer) if (ctx->limit_samples && (unsigned int)ctx->num_samples > ctx->limit_samples) { abort_acquisition(ctx); + free_transfer(transfer); + return; } } else { /* @@ -846,27 +877,76 @@ static void receive_transfer(struct libusb_transfer *transfer) resubmit_transfer(transfer); } -static int hw_dev_acquisition_start(int dev_index, void *cb_data) +static unsigned int to_bytes_per_ms(unsigned int samplerate) +{ + return samplerate / 1000; +} + +static size_t get_buffer_size(struct context *ctx) +{ + size_t s; + + /* The buffer should be large enough to hold 10ms of data and a multiple + * of 512. */ + s = 10 * to_bytes_per_ms(ctx->cur_samplerate); + return (s + 511) & ~511; +} + +static unsigned int get_number_of_transfers(struct context *ctx) +{ + unsigned int n; + + /* Total buffer size should be able to hold about 500ms of data */ + n = 500 * to_bytes_per_ms(ctx->cur_samplerate) / get_buffer_size(ctx); + + if (n > NUM_SIMUL_TRANSFERS) + return NUM_SIMUL_TRANSFERS; + + return n; +} + +static unsigned int get_timeout(struct context *ctx) +{ + size_t total_size; + unsigned int timeout; + + total_size = get_buffer_size(ctx) * get_number_of_transfers(ctx); + timeout = total_size / to_bytes_per_ms(ctx->cur_samplerate); + return timeout + timeout / 4; /* Leave a headroom of 25% percent */ +} + +static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi, + void *cb_data) { - struct sr_dev_inst *sdi; struct sr_datafeed_packet packet; struct sr_datafeed_header header; struct sr_datafeed_meta_logic meta; struct context *ctx; struct libusb_transfer *transfer; const struct libusb_pollfd **lupfd; - int ret, size, i; + unsigned int i; + int ret; unsigned char *buf; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) - return SR_ERR; ctx = sdi->priv; + if (ctx->submitted_transfers != 0) + return SR_ERR; + ctx->session_dev_id = cb_data; ctx->num_samples = 0; + ctx->empty_transfer_count = 0; + + const unsigned int timeout = get_timeout(ctx); + const unsigned int num_transfers = get_number_of_transfers(ctx); + const size_t size = get_buffer_size(ctx); + + ctx->transfers = g_try_malloc0(sizeof(*ctx->transfers) * num_transfers); + if (!ctx->transfers) + return SR_ERR; - /* Start with 2K transfer, subsequently increased to 4K. */ - size = 2048; - for (i = 0; i < NUM_SIMUL_TRANSFERS; i++) { + ctx->num_transfers = num_transfers; + + for (i = 0; i < num_transfers; i++) { if (!(buf = g_try_malloc(size))) { sr_err("fx2lafw: %s: buf malloc failed.", __func__); return SR_ERR_MALLOC; @@ -874,22 +954,21 @@ static int hw_dev_acquisition_start(int dev_index, void *cb_data) transfer = libusb_alloc_transfer(0); libusb_fill_bulk_transfer(transfer, ctx->usb->devhdl, 2 | LIBUSB_ENDPOINT_IN, buf, size, - receive_transfer, ctx, 40); + receive_transfer, ctx, timeout); if (libusb_submit_transfer(transfer) != 0) { - /* TODO: Free them all. */ libusb_free_transfer(transfer); g_free(buf); + abort_acquisition(ctx); return SR_ERR; } - + ctx->transfers[i] = transfer; ctx->submitted_transfers++; - size = 4096; } lupfd = libusb_get_pollfds(usb_context); for (i = 0; lupfd[i]; i++) sr_source_add(lupfd[i]->fd, lupfd[i]->events, - 40, receive_data, NULL); + timeout, receive_data, NULL); free(lupfd); /* NOT g_free()! */ packet.type = SR_DF_HEADER; @@ -907,6 +986,7 @@ static int hw_dev_acquisition_start(int dev_index, void *cb_data) if ((ret = command_start_acquisition (ctx->usb->devhdl, ctx->cur_samplerate, ctx->sample_wide)) != SR_OK) { + abort_acquisition(ctx); return ret; } @@ -914,16 +994,13 @@ static int hw_dev_acquisition_start(int dev_index, void *cb_data) } /* TODO: This stops acquisition on ALL devices, ignoring dev_index. */ -static int hw_dev_acquisition_stop(int dev_index, void *cb_data) +static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi, + void *cb_data) { - struct sr_dev_inst *sdi; /* Avoid compiler warnings. */ (void)cb_data; - if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) - return SR_ERR; - abort_acquisition(sdi->priv); return SR_OK; @@ -935,12 +1012,12 @@ SR_PRIV struct sr_dev_driver fx2lafw_driver_info = { .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, - .dev_status_get = hw_dev_status_get, - .hwcap_get_all = hw_hwcap_get_all, + .info_get = hw_info_get, .dev_config_set = hw_dev_config_set, .dev_acquisition_start = hw_dev_acquisition_start, .dev_acquisition_stop = hw_dev_acquisition_stop, + .instances = NULL, };