X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2Fhardware%2Fsysclk-lwla%2Fapi.c;h=20e30d1ecc9c2ba126b9da346987ecf2f8023e50;hb=a078d3ec527c0a8180f59086e62a8905ae79aa65;hp=7dfd7582f67c539219f199c2f2bebf9733977e34;hpb=567674b4f8a71ff369fad9a31f7d9db00abbd6bc;p=libsigrok.git diff --git a/src/hardware/sysclk-lwla/api.c b/src/hardware/sysclk-lwla/api.c index 7dfd7582..20e30d1e 100644 --- a/src/hardware/sysclk-lwla/api.c +++ b/src/hardware/sysclk-lwla/api.c @@ -23,7 +23,7 @@ #include #include #include -#include "libsigrok-internal.h" +#include #include "protocol.h" /* Supported device scan options. @@ -248,6 +248,40 @@ static int dev_clear(const struct sr_dev_driver *di) return std_dev_clear(di, &clear_dev_context); } +/* Drain any pending data from the USB transfer buffers on the device. + * This may be necessary e.g. after a crash or generally to clean up after + * an abnormal condition. + */ +static int drain_usb(struct sr_usb_dev_inst *usb, unsigned int endpoint) +{ + int drained, xfer_len; + int ret; + unsigned char buf[512]; + + const unsigned int drain_timeout_ms = 10; + + drained = 0; + do { + xfer_len = 0; + ret = libusb_bulk_transfer(usb->devhdl, endpoint, + buf, sizeof(buf), &xfer_len, + drain_timeout_ms); + drained += xfer_len; + } while (ret == LIBUSB_SUCCESS && xfer_len != 0); + + if (ret != LIBUSB_SUCCESS && ret != LIBUSB_ERROR_TIMEOUT) { + sr_err("Failed to drain USB endpoint %u: %s.", + endpoint & (LIBUSB_ENDPOINT_IN - 1), + libusb_error_name(ret)); + return SR_ERR; + } + if (drained > 0) { + sr_warn("Drained %d bytes from USB endpoint %u.", + drained, endpoint & (LIBUSB_ENDPOINT_IN - 1)); + } + return SR_OK; +} + /* Open and initialize device. */ static int dev_open(struct sr_dev_inst *sdi) @@ -255,6 +289,7 @@ static int dev_open(struct sr_dev_inst *sdi) struct drv_context *drvc; struct dev_context *devc; struct sr_usb_dev_inst *usb; + int i; int ret; drvc = sdi->driver->context; @@ -270,40 +305,57 @@ static int dev_open(struct sr_dev_inst *sdi) return SR_ERR; } - ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb); - if (ret != SR_OK) - return ret; + /* Try the whole shebang three times, fingers crossed. */ + for (i = 0; i < 3; i++) { + ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb); + if (ret != SR_OK) + return ret; - ret = libusb_set_configuration(usb->devhdl, USB_CONFIG); - if (ret != 0) { - sr_err("Failed to set USB configuration: %s.", - libusb_error_name(ret)); - sr_usb_close(usb); - return SR_ERR; - } + ret = libusb_set_configuration(usb->devhdl, USB_CONFIG); + if (ret != LIBUSB_SUCCESS) { + sr_err("Failed to set USB configuration: %s.", + libusb_error_name(ret)); + sr_usb_close(usb); + return SR_ERR; + } - ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE); - if (ret < 0) { - sr_err("Failed to claim interface: %s.", - libusb_error_name(ret)); - sr_usb_close(usb); - return SR_ERR; - } + ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE); + if (ret != LIBUSB_SUCCESS) { + sr_err("Failed to claim interface: %s.", + libusb_error_name(ret)); + sr_usb_close(usb); + return SR_ERR; + } - sdi->status = SR_ST_ACTIVE; + ret = drain_usb(usb, EP_REPLY); + if (ret != SR_OK) { + sr_usb_close(usb); + return ret; + } + /* This delay appears to be necessary for reliable operation. */ + g_usleep(30 * 1000); - devc->active_fpga_config = FPGA_NOCONF; - devc->state = STATE_IDLE; + sdi->status = SR_ST_ACTIVE; - ret = (*devc->model->apply_fpga_config)(sdi); + devc->active_fpga_config = FPGA_NOCONF; + devc->short_transfer_quirk = FALSE; + devc->state = STATE_IDLE; - if (ret == SR_OK) - ret = (*devc->model->device_init_check)(sdi); + ret = (*devc->model->apply_fpga_config)(sdi); - if (ret != SR_OK) { + if (ret == SR_OK) + ret = (*devc->model->device_init_check)(sdi); + if (ret == SR_OK) + break; + + /* Rinse and repeat. */ sdi->status = SR_ST_INACTIVE; sr_usb_close(usb); } + + if (ret == SR_OK && devc->short_transfer_quirk) + sr_warn("Short transfer quirk detected! " + "Memory reads will be slow."); return ret; } @@ -556,13 +608,14 @@ static int prepare_trigger_masks(const struct sr_dev_inst *sdi) uint64_t trigger_mask; uint64_t trigger_values; uint64_t trigger_edge_mask; - uint64_t channel_bit; + uint64_t level_bit, type_bit; struct dev_context *devc; struct sr_trigger *trigger; struct sr_trigger_stage *stage; struct sr_trigger_match *match; const GSList *node; int idx; + enum sr_trigger_matches trg; devc = sdi->priv; @@ -587,30 +640,27 @@ static int prepare_trigger_masks(const struct sr_dev_inst *sdi) continue; /* ignore disabled channel */ idx = match->channel->index; + trg = match->match; if (idx < 0 || idx >= devc->model->num_channels) { sr_err("Channel index %d out of range.", idx); return SR_ERR_BUG; /* should not happen */ } - channel_bit = UINT64_C(1) << idx; - trigger_mask |= channel_bit; - - switch (match->match) { - case SR_TRIGGER_ZERO: - break; - case SR_TRIGGER_ONE: - trigger_values |= channel_bit; - break; - case SR_TRIGGER_RISING: - trigger_values |= channel_bit; - /* Fall through for edge mask. */ - case SR_TRIGGER_FALLING: - trigger_edge_mask |= channel_bit; - break; - default: + if (trg != SR_TRIGGER_ZERO + && trg != SR_TRIGGER_ONE + && trg != SR_TRIGGER_RISING + && trg != SR_TRIGGER_FALLING) { sr_err("Unsupported trigger match for CH%d.", idx + 1); return SR_ERR_ARG; } + level_bit = (trg == SR_TRIGGER_ONE + || trg == SR_TRIGGER_RISING) ? 1 : 0; + type_bit = (trg == SR_TRIGGER_RISING + || trg == SR_TRIGGER_FALLING) ? 1 : 0; + + trigger_mask |= UINT64_C(1) << idx; + trigger_values |= level_bit << idx; + trigger_edge_mask |= type_bit << idx; } devc->trigger_mask = trigger_mask; devc->trigger_values = trigger_values;