+ 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) {
+ ctx->cur_samplerate = *(uint64_t *)value;
+ ret = SR_OK;
+ } else if (hwcap == SR_HWCAP_PROBECONFIG) {
+ ret = configure_probes(ctx, (GSList *) value);
+ } else if (hwcap == SR_HWCAP_LIMIT_SAMPLES) {
+ ctx->limit_samples = *(uint64_t *)value;
+ ret = SR_OK;
+ } else {
+ ret = SR_ERR;
+ }
+
+ return ret;
+}
+
+static int receive_data(int fd, int revents, void *cb_data)
+{
+ struct timeval tv;
+
+ /* Avoid compiler warnings. */
+ (void)fd;
+ (void)revents;
+ (void)cb_data;
+
+ tv.tv_sec = tv.tv_usec = 0;
+ libusb_handle_events_timeout(usb_context, &tv);
+
+ return TRUE;
+}
+
+static void abort_acquisition(struct context *ctx)
+{
+ ctx->num_samples = -1;
+}
+
+static void finish_acquisition(struct context *ctx)
+{
+ struct sr_datafeed_packet packet;
+ int i;
+
+ /* Terminate session */
+ packet.type = SR_DF_END;
+ sr_session_send(ctx->session_dev_id, &packet);
+
+ /* Remove fds from polling */
+ const struct libusb_pollfd **const lupfd =
+ libusb_get_pollfds(usb_context);
+ for (i = 0; lupfd[i]; i++)
+ sr_source_remove(lupfd[i]->fd);
+ free(lupfd); /* NOT g_free()! */
+}
+
+static void receive_transfer(struct libusb_transfer *transfer)
+{
+ /* TODO: These statics have to move to the ctx struct. */
+ static int empty_transfer_count = 0;
+ struct sr_datafeed_packet packet;
+ struct sr_datafeed_logic logic;
+ struct context *ctx = transfer->user_data;
+ int cur_buflen, trigger_offset, i;
+ unsigned char *cur_buf, *new_buf;
+
+ /*
+ * If acquisition has already ended, just free any queued up
+ * transfer that come in.
+ */
+ if (ctx->num_samples == -1) {
+ if (transfer)
+ libusb_free_transfer(transfer);
+
+ ctx->submitted_transfers--;
+ if (ctx->submitted_transfers == 0)
+ finish_acquisition(ctx);
+
+ return;
+ }
+
+ sr_info("fx2lafw: receive_transfer(): status %d received %d bytes.",
+ transfer->status, transfer->actual_length);
+
+ /* Save incoming transfer before reusing the transfer struct. */
+ cur_buf = transfer->buffer;
+ cur_buflen = transfer->actual_length;
+
+ /* Fire off a new request. */
+ if (!(new_buf = g_try_malloc(4096))) {
+ sr_err("fx2lafw: %s: new_buf malloc failed.", __func__);
+ return; /* TODO: SR_ERR_MALLOC */
+ }
+
+ transfer->buffer = new_buf;
+ transfer->length = 4096;
+ if (libusb_submit_transfer(transfer) != 0) {
+ /* TODO: Stop session? */
+ /* TODO: Better error message. */
+ sr_err("fx2lafw: %s: libusb_submit_transfer error.", __func__);
+ }
+
+ if (cur_buflen == 0) {
+ empty_transfer_count++;
+ if (empty_transfer_count > MAX_EMPTY_TRANSFERS) {
+ /*
+ * The FX2 gave up. End the acquisition, the frontend
+ * will work out that the samplecount is short.
+ */
+ abort_acquisition(ctx);
+ }
+ return;
+ } else {
+ empty_transfer_count = 0;
+ }
+
+ trigger_offset = 0;
+ if (ctx->trigger_stage >= 0) {
+ for (i = 0; i < cur_buflen; i++) {
+
+ if ((cur_buf[i] & ctx->trigger_mask[ctx->trigger_stage]) == ctx->trigger_value[ctx->trigger_stage]) {
+ /* Match on this trigger stage. */
+ ctx->trigger_buffer[ctx->trigger_stage] = cur_buf[i];
+ ctx->trigger_stage++;
+
+ if (ctx->trigger_stage == NUM_TRIGGER_STAGES || ctx->trigger_mask[ctx->trigger_stage] == 0) {
+ /* Match on all trigger stages, we're done. */
+ trigger_offset = i + 1;
+
+ /*
+ * TODO: Send pre-trigger buffer to session bus.
+ * Tell the frontend we hit the trigger here.
+ */
+ packet.type = SR_DF_TRIGGER;
+ packet.payload = NULL;
+ sr_session_send(ctx->session_dev_id, &packet);
+
+ /*
+ * Send the samples that triggered it, since we're
+ * skipping past them.
+ */
+ packet.type = SR_DF_LOGIC;
+ packet.payload = &logic;
+ logic.length = ctx->trigger_stage;
+ logic.unitsize = 1;
+ logic.data = ctx->trigger_buffer;
+ sr_session_send(ctx->session_dev_id, &packet);
+
+ ctx->trigger_stage = TRIGGER_FIRED;
+ break;
+ }
+ return;
+ }
+
+ /*
+ * We had a match before, but not in the next sample. However, we may
+ * have a match on this stage in the next bit -- trigger on 0001 will
+ * fail on seeing 00001, so we need to go back to stage 0 -- but at
+ * the next sample from the one that matched originally, which the
+ * counter increment at the end of the loop takes care of.
+ */
+ if (ctx->trigger_stage > 0) {
+ i -= ctx->trigger_stage;
+ if (i < -1)
+ i = -1; /* Oops, went back past this buffer. */
+ /* Reset trigger stage. */
+ ctx->trigger_stage = 0;
+ }
+ }
+ }
+
+ if (ctx->trigger_stage == TRIGGER_FIRED) {
+ /* Send the incoming transfer to the session bus. */
+ packet.type = SR_DF_LOGIC;
+ packet.payload = &logic;
+ logic.length = cur_buflen - trigger_offset;
+ logic.unitsize = 1;
+ logic.data = cur_buf + trigger_offset;
+ sr_session_send(ctx->session_dev_id, &packet);
+ g_free(cur_buf);
+
+ ctx->num_samples += cur_buflen;
+ if (ctx->limit_samples &&
+ (unsigned int)ctx->num_samples > ctx->limit_samples) {
+ abort_acquisition(ctx);
+ }
+ } else {
+ /*
+ * TODO: Buffer pre-trigger data in capture
+ * ratio-sized buffer.
+ */
+ }