+ 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 trigger_offset, i;
+ uint8_t *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. */
+ uint8_t *const cur_buf = transfer->buffer;
+ const int sample_width = ctx->sample_wide ? 2 : 1;
+ const int cur_sample_count = transfer->actual_length / sample_width;
+
+ /* 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 (transfer->actual_length == 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_sample_count; i++) {
+
+ const uint16_t cur_sample = ctx->sample_wide ?
+ *((const uint16_t*)cur_buf + i) :
+ *((const uint8_t*)cur_buf + i);
+
+ if ((cur_sample & ctx->trigger_mask[ctx->trigger_stage]) ==
+ ctx->trigger_value[ctx->trigger_stage]) {
+ /* Match on this trigger stage. */
+ ctx->trigger_buffer[ctx->trigger_stage] = cur_sample;
+ 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. */
+ const trigger_offset_bytes = trigger_offset * sample_width;
+ packet.type = SR_DF_LOGIC;
+ packet.payload = &logic;
+ logic.length = transfer->actual_length - trigger_offset_bytes;
+ logic.unitsize = sample_width;
+ logic.data = cur_buf + trigger_offset_bytes;
+ sr_session_send(ctx->session_dev_id, &packet);
+ g_free(cur_buf);
+
+ ctx->num_samples += cur_sample_count;
+ 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.
+ */
+ }
+}
+
+static int hw_dev_acquisition_start(int dev_index, 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 char *buf;
+
+ if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
+ return SR_ERR;
+ ctx = sdi->priv;
+ ctx->session_dev_id = cb_data;
+ ctx->num_samples = 0;
+
+ if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
+ sr_err("fx2lafw: %s: packet malloc failed.", __func__);
+ return SR_ERR_MALLOC;
+ }
+
+ if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
+ sr_err("fx2lafw: %s: header malloc failed.", __func__);
+ return SR_ERR_MALLOC;
+ }
+
+ /* Start with 2K transfer, subsequently increased to 4K. */
+ size = 2048;
+ for (i = 0; i < NUM_SIMUL_TRANSFERS; i++) {
+ if (!(buf = g_try_malloc(size))) {
+ sr_err("fx2lafw: %s: buf malloc failed.", __func__);
+ return SR_ERR_MALLOC;
+ }
+ transfer = libusb_alloc_transfer(0);
+ libusb_fill_bulk_transfer(transfer, ctx->usb->devhdl,
+ 2 | LIBUSB_ENDPOINT_IN, buf, size,
+ receive_transfer, ctx, 40);
+ if (libusb_submit_transfer(transfer) != 0) {
+ /* TODO: Free them all. */
+ libusb_free_transfer(transfer);
+ g_free(buf);
+ return SR_ERR;
+ }
+
+ 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);
+ free(lupfd); /* NOT g_free()! */
+
+ packet->type = SR_DF_HEADER;
+ packet->payload = header;
+ header->feed_version = 1;
+ gettimeofday(&header->starttime, NULL);
+ sr_session_send(cb_data, 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->sample_wide ? 16 : 8;
+ sr_session_send(cb_data, packet);
+
+ g_free(header);
+ g_free(packet);
+
+ if ((ret = command_start_acquisition (ctx->usb->devhdl,
+ ctx->cur_samplerate, ctx->sample_wide)) != SR_OK) {
+ return ret;
+ }
+