SR_PRIV int ikalogic_scanalogic2_receive_data(int fd, int revents, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct drv_context *drvc;
struct timeval tv;
int64_t current_time, time_elapsed;
int ret = 0;
(void)fd;
(void)revents;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
drvc = di->priv;
current_time = g_get_monotonic_time();
if (devc->state == STATE_WAIT_DATA_READY &&
!devc->wait_data_ready_locked) {
time_elapsed = current_time - devc->wait_data_ready_time;
/*
* Check here for stopping in addition to the transfer
* callback functions to avoid waiting until the
* WAIT_DATA_READY_INTERVAL has expired.
*/
if (sdi->status == SR_ST_STOPPING) {
if (!devc->stopping_in_progress) {
devc->next_state = STATE_RESET_AND_IDLE;
devc->stopping_in_progress = TRUE;
ret = libusb_submit_transfer(devc->xfer_in);
}
} else if (time_elapsed >= WAIT_DATA_READY_INTERVAL) {
devc->wait_data_ready_locked = TRUE;
ret = libusb_submit_transfer(devc->xfer_in);
}
}
if (ret != 0) {
sr_err("Submit transfer failed: %s.", libusb_error_name(ret));
abort_acquisition(sdi);
return TRUE;
}
tv.tv_sec = 0;
tv.tv_usec = 0;
libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx, &tv,
NULL);
/* Check if an error occurred on a transfer. */
if (devc->transfer_error)
abort_acquisition(sdi);
return TRUE;
}
static int receive_data(int fd, int revents, void *cb_data)
{
struct timeval tv;
struct dev_context *devc;
struct drv_context *drvc;
const struct sr_dev_inst *sdi;
struct sr_dev_driver *di;
(void)fd;
(void)revents;
sdi = cb_data;
di = sdi->driver;
drvc = di->priv;
devc = sdi->priv;
tv.tv_sec = tv.tv_usec = 0;
libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
if (devc->sent_samples == -2) {
logic16_abort_acquisition(sdi);
abort_acquisition(devc);
}
return TRUE;
}
static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
{
int ret;
(void)cb_data;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
ret = logic16_abort_acquisition(sdi);
abort_acquisition(sdi->priv);
return ret;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct sr_dev_driver *di = sdi->driver;
struct dev_context *devc;
struct drv_context *drvc;
struct sr_usb_dev_inst *usb;
struct sr_trigger *trigger;
struct libusb_transfer *transfer;
unsigned int i, timeout, num_transfers;
int ret;
unsigned char *buf;
size_t size, convsize;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
drvc = di->priv;
devc = sdi->priv;
usb = sdi->conn;
/* Configures devc->cur_channels. */
if (configure_channels(sdi) != SR_OK) {
sr_err("Failed to configure channels.");
return SR_ERR;
}
devc->cb_data = cb_data;
devc->sent_samples = 0;
devc->empty_transfer_count = 0;
devc->cur_channel = 0;
memset(devc->channel_data, 0, sizeof(devc->channel_data));
if ((trigger = sr_session_trigger_get(sdi->session))) {
int pre_trigger_samples = 0;
if (devc->limit_samples > 0)
pre_trigger_samples = devc->capture_ratio * devc->limit_samples/100;
devc->stl = soft_trigger_logic_new(sdi, trigger, pre_trigger_samples);
if (!devc->stl)
return SR_ERR_MALLOC;
devc->trigger_fired = FALSE;
} else
devc->trigger_fired = TRUE;
timeout = get_timeout(devc);
num_transfers = get_number_of_transfers(devc);
size = get_buffer_size(devc);
convsize = (size / devc->num_channels + 2) * 16;
devc->submitted_transfers = 0;
devc->convbuffer_size = convsize;
if (!(devc->convbuffer = g_try_malloc(convsize))) {
sr_err("Conversion buffer malloc failed.");
return SR_ERR_MALLOC;
}
devc->transfers = g_try_malloc0(sizeof(*devc->transfers) * num_transfers);
if (!devc->transfers) {
sr_err("USB transfers malloc failed.");
g_free(devc->convbuffer);
return SR_ERR_MALLOC;
}
if ((ret = logic16_setup_acquisition(sdi, devc->cur_samplerate,
devc->cur_channels)) != SR_OK) {
g_free(devc->transfers);
g_free(devc->convbuffer);
return ret;
}
devc->num_transfers = num_transfers;
for (i = 0; i < num_transfers; i++) {
if (!(buf = g_try_malloc(size))) {
sr_err("USB transfer buffer malloc failed.");
if (devc->submitted_transfers)
abort_acquisition(devc);
else {
g_free(devc->transfers);
g_free(devc->convbuffer);
}
return SR_ERR_MALLOC;
}
transfer = libusb_alloc_transfer(0);
libusb_fill_bulk_transfer(transfer, usb->devhdl,
2 | LIBUSB_ENDPOINT_IN, buf, size,
logic16_receive_transfer, (void *)sdi, timeout);
if ((ret = libusb_submit_transfer(transfer)) != 0) {
sr_err("Failed to submit transfer: %s.",
libusb_error_name(ret));
libusb_free_transfer(transfer);
g_free(buf);
abort_acquisition(devc);
return SR_ERR;
}
devc->transfers[i] = transfer;
devc->submitted_transfers++;
}
devc->ctx = drvc->sr_ctx;
usb_source_add(sdi->session, devc->ctx, timeout, receive_data, (void *)sdi);
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
if ((ret = logic16_start_acquisition(sdi)) != SR_OK) {
abort_acquisition(devc);
return ret;
}
return SR_OK;
}
