#include <config.h>
#include <string.h>
-#include "lwla.h"
#include "protocol.h"
+#include "lwla.h"
-/* Status polling interval during acquisition.
- */
-#define POLL_INTERVAL 100 /* ms */
-
-/* Submit an already filled-in USB transfer.
- */
+/* Submit an already filled-in USB transfer. */
static int submit_transfer(struct dev_context *devc,
struct libusb_transfer *xfer)
{
return SR_OK;
}
-/* Set up transfer for the next register in a write sequence.
- */
+/* Set up transfer for the next register in a write sequence. */
static void next_reg_write(struct acquisition_state *acq)
{
struct regval *regval;
acq->xfer_out->length = 4 * sizeof(acq->xfer_buf_out[0]);
}
-/* Set up transfer for the next register in a read sequence.
- */
+/* Set up transfer for the next register in a read sequence. */
static void next_reg_read(struct acquisition_state *acq)
{
unsigned int addr;
acq->xfer_out->length = 2 * sizeof(acq->xfer_buf_out[0]);
}
-/* Decode the response to a register read request.
- */
+/* Decode the response to a register read request. */
static int read_reg_response(struct acquisition_state *acq)
{
uint32_t value;
return SR_OK;
}
-/* Enter a new state and submit the corresponding request to the device.
- */
+/* Enter a new state and submit the corresponding request to the device. */
static int submit_request(const struct sr_dev_inst *sdi,
enum protocol_state state)
{
int ret;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
devc->state = state;
return submit_transfer(devc, acq->xfer_out);
}
-/* Evaluate and act on the response to a capture status request.
- */
+/* Evaluate and act on the response to a capture status request. */
static void handle_status_response(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
unsigned int old_status;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
old_status = acq->status;
if ((*devc->model->handle_response)(sdi) != SR_OK) {
}
devc->state = STATE_STATUS_WAIT;
- sr_spew("Captured %zu words, %" PRIu64 " ms, status 0x%02X.",
+ sr_spew("Captured %u words, %" PRIu64 " ms, status 0x%02X.",
acq->mem_addr_fill, acq->duration_now, acq->status);
if ((~old_status & acq->status & STATUS_TRIGGERED) != 0)
}
}
-/* Evaluate and act on the response to a capture length request.
- */
+/* Evaluate and act on the response to a capture length request. */
static void handle_length_response(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
if ((*devc->model->handle_response)(sdi) != SR_OK) {
devc->transfer_error = TRUE;
submit_request(sdi, STATE_READ_FINISH);
return;
}
- sr_dbg("%zu words in capture buffer.",
+ sr_dbg("%u words in capture buffer.",
acq->mem_addr_stop - acq->mem_addr_next);
submit_request(sdi, STATE_READ_PREPARE);
}
-/* Evaluate and act on the response to a capture length request.
- */
+/* Evaluate and act on the response to a capture memory read request. */
static void handle_read_response(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
- size_t end_addr;
+ unsigned int end_addr;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
/* Prepare session packet. */
- packet.type = SR_DF_LOGIC;
+ packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.unitsize = (devc->model->num_channels + 7) / 8;
- logic.data = acq->out_packet;
+ logic.data = acq->out_packet;
end_addr = MIN(acq->mem_addr_next, acq->mem_addr_stop);
acq->in_index = 0;
+
/*
* Repeatedly call the model-specific read response handler until
* all data received in the transfer has been accounted for.
submit_request(sdi, STATE_READ_FINISH);
}
-/* Destroy and unset the acquisition state record.
- */
+/* Destroy and unset the acquisition state record. */
static void clear_acquisition_state(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
devc->acquisition = NULL;
}
}
-/* USB I/O source callback.
- */
+/* USB I/O source callback. */
static int transfer_event(int fd, int revents, void *cb_data)
{
const struct sr_dev_inst *sdi;
struct dev_context *devc;
struct drv_context *drvc;
struct timeval tv;
- struct sr_datafeed_packet packet;
int ret;
(void)fd;
- sdi = cb_data;
+ sdi = cb_data;
devc = sdi->priv;
drvc = sdi->driver->context;
return G_SOURCE_REMOVE;
/* Handle pending USB events without blocking. */
- tv.tv_sec = 0;
+ tv.tv_sec = 0;
tv.tv_usec = 0;
ret = libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx,
&tv, NULL);
/* We are done, clean up and send end packet to session bus. */
clear_acquisition_state(sdi);
-
- packet.type = SR_DF_END;
- packet.payload = NULL;
- sr_session_send(sdi, &packet);
+ std_session_send_df_end(sdi);
return G_SOURCE_REMOVE;
}
-/* USB output transfer completion callback.
- */
+/* USB output transfer completion callback. */
static void LIBUSB_CALL transfer_out_completed(struct libusb_transfer *transfer)
{
const struct sr_dev_inst *sdi;
struct dev_context *devc;
struct acquisition_state *acq;
- sdi = transfer->user_data;
+ sdi = transfer->user_data;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
- sr_err("Transfer to device failed: %d.", transfer->status);
+ sr_err("Transfer to device failed (state %d): %s.",
+ devc->state, libusb_error_name(transfer->status));
devc->transfer_error = TRUE;
return;
}
}
}
-/* USB input transfer completion callback.
- */
+/* USB input transfer completion callback. */
static void LIBUSB_CALL transfer_in_completed(struct libusb_transfer *transfer)
{
const struct sr_dev_inst *sdi;
struct dev_context *devc;
struct acquisition_state *acq;
- sdi = transfer->user_data;
+ sdi = transfer->user_data;
devc = sdi->priv;
- acq = devc->acquisition;
+ acq = devc->acquisition;
if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
sr_err("Transfer from device failed (state %d): %s.",
}
}
-/* Set up the acquisition state record.
- */
+/* Set up the acquisition state record. */
static int init_acquisition_state(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct acquisition_state *acq;
devc = sdi->priv;
- usb = sdi->conn;
+ usb = sdi->conn;
if (devc->acquisition) {
sr_err("Acquisition still in progress?");
struct drv_context *drvc;
struct dev_context *devc;
int ret;
+ const int poll_interval_ms = 100;
drvc = sdi->driver->context;
devc = sdi->priv;
return ret;
}
/* Register event source for asynchronous USB I/O. */
- ret = usb_source_add(sdi->session, drvc->sr_ctx, POLL_INTERVAL,
+ ret = usb_source_add(sdi->session, drvc->sr_ctx, poll_interval_ms,
&transfer_event, (struct sr_dev_inst *)sdi);
if (ret != SR_OK) {
clear_acquisition_state(sdi);
}
ret = submit_request(sdi, STATE_START_CAPTURE);
- if (ret == SR_OK) {
- /* Send header packet to the session bus. */
- ret = std_session_send_df_header(sdi, LOG_PREFIX);
- }
+ if (ret == SR_OK)
+ ret = std_session_send_df_header(sdi);
+
if (ret != SR_OK) {
usb_source_remove(sdi->session, drvc->sr_ctx);
clear_acquisition_state(sdi);
}
+
return ret;
}