int ezusb_install_firmware(libusb_device_handle *hdl, const char *filename)
{
FILE *fw;
int offset, chunksize, err, result;
unsigned char buf[4096];
sr_info("Uploading firmware at %s", filename);
if ((fw = g_fopen(filename, "rb")) == NULL) {
sr_warn("Unable to open firmware file %s for reading: %s",
filename, strerror(errno));
return SR_ERR;
}
result = SR_OK;
offset = 0;
while (1) {
chunksize = fread(buf, 1, 4096, fw);
if (chunksize == 0)
break;
err = libusb_control_transfer(hdl, LIBUSB_REQUEST_TYPE_VENDOR |
LIBUSB_ENDPOINT_OUT, 0xa0, offset,
0x0000, buf, chunksize, 100);
if (err < 0) {
sr_warn("Unable to send firmware to device: %d", err);
result = SR_ERR;
break;
}
sr_info("Uploaded %d bytes", chunksize);
offset += chunksize;
}
fclose(fw);
sr_info("Firmware upload done");
return result;
}
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
const struct sr_probe_group *probe_group)
{
struct session_vdev *vdev;
(void)probe_group;
vdev = sdi->priv;
switch (id) {
case SR_CONF_SAMPLERATE:
vdev->samplerate = g_variant_get_uint64(data);
sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate);
break;
case SR_CONF_SESSIONFILE:
vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL));
sr_info("Setting sessionfile to '%s'.", vdev->sessionfile);
break;
case SR_CONF_CAPTUREFILE:
vdev->capturefile = g_strdup(g_variant_get_string(data, NULL));
sr_info("Setting capturefile to '%s'.", vdev->capturefile);
break;
case SR_CONF_CAPTURE_UNITSIZE:
vdev->unitsize = g_variant_get_uint64(data);
break;
case SR_CONF_CAPTURE_NUM_PROBES:
vdev->num_probes = g_variant_get_uint64(data);
break;
default:
return SR_ERR_NA;
}
return SR_OK;
}
static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
{
struct session_vdev *vdev;
vdev = sdi->priv;
switch (id) {
case SR_CONF_SAMPLERATE:
vdev->samplerate = g_variant_get_uint64(data);
sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate);
break;
case SR_CONF_SESSIONFILE:
vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL));
sr_info("Setting sessionfile to '%s'.", vdev->sessionfile);
break;
case SR_CONF_CAPTUREFILE:
vdev->capturefile = g_strdup(g_variant_get_string(data, NULL));
sr_info("Setting capturefile to '%s'.", vdev->capturefile);
break;
case SR_CONF_CAPTURE_UNITSIZE:
vdev->unitsize = g_variant_get_uint64(data);
break;
case SR_CONF_LIMIT_SAMPLES:
vdev->total_samples = g_variant_get_uint64(data);
break;
case SR_CONF_CAPTURE_NUM_PROBES:
vdev->num_probes = g_variant_get_uint64(data);
break;
default:
sr_err("Unknown capability: %d.", id);
return SR_ERR;
}
return SR_OK;
}
SR_PRIV int appa_55ii_receive_data(int fd, int revents, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
int64_t time;
const uint8_t *ptr, *next_ptr, *end_ptr;
int len;
(void)fd;
if (!(sdi = cb_data) || !(devc = sdi->priv) || revents != G_IO_IN)
return TRUE;
serial = sdi->conn;
/* Try to get as much data as the buffer can hold. */
len = sizeof(devc->buf) - devc->buf_len;
len = serial_read_nonblocking(serial, devc->buf + devc->buf_len, len);
if (len < 1) {
sr_err("Serial port read error: %d.", len);
return FALSE;
}
devc->buf_len += len;
/* Now look for packets in that data. */
ptr = devc->buf;
end_ptr = ptr + devc->buf_len;
while ((next_ptr = appa_55ii_parse_data(sdi, ptr, end_ptr - ptr)))
ptr = next_ptr;
/* If we have any data left, move it to the beginning of our buffer. */
memmove(devc->buf, ptr, end_ptr - ptr);
devc->buf_len -= ptr - devc->buf;
/* If buffer is full and no valid packet was found, wipe buffer. */
if (devc->buf_len >= sizeof(devc->buf)) {
devc->buf_len = 0;
return FALSE;
}
if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {
sr_info("Requested number of samples reached.");
sdi->driver->dev_acquisition_stop(sdi, devc->session_cb_data);
return TRUE;
}
if (devc->limit_msec) {
time = (g_get_monotonic_time() - devc->start_time) / 1000;
if (time > (int64_t)devc->limit_msec) {
sr_info("Requested time limit reached.");
sdi->driver->dev_acquisition_stop(sdi,
devc->session_cb_data);
return TRUE;
}
}
return TRUE;
}
static int opendev4(struct sr_dev_inst **sdi, libusb_device *dev,
struct libusb_device_descriptor *des)
{
struct context *ctx;
unsigned int i;
int ret;
/* Note: sdi is non-NULL, the caller already checked this. */
if (!(ctx = (*sdi)->priv)) {
sr_err("zp: %s: (*sdi)->priv was NULL", __func__);
return -1;
}
if ((ret = libusb_get_device_descriptor(dev, des))) {
sr_err("zp: failed to get device descriptor: %d", ret);
return -1;
}
if (des->idVendor != USB_VENDOR)
return 0;
if (libusb_get_bus_number(dev) == ctx->usb->bus
&& libusb_get_device_address(dev) == ctx->usb->address) {
for (i = 0; i < ARRAY_SIZE(zeroplus_models); i++) {
if (!(des->idProduct == zeroplus_models[i].pid))
continue;
sr_info("zp: Found ZeroPlus device 0x%04x (%s)",
des->idProduct, zeroplus_models[i].model_name);
ctx->num_channels = zeroplus_models[i].channels;
ctx->memory_size = zeroplus_models[i].sample_depth * 1024;
break;
}
if (ctx->num_channels == 0) {
sr_err("zp: Unknown ZeroPlus device 0x%04x",
des->idProduct);
return -2;
}
/* Found it. */
if (!(ret = libusb_open(dev, &(ctx->usb->devhdl)))) {
(*sdi)->status = SR_ST_ACTIVE;
sr_info("zp: opened device %d on %d.%d interface %d",
(*sdi)->index, ctx->usb->bus,
ctx->usb->address, USB_INTERFACE);
} else {
sr_err("zp: failed to open device: %d", ret);
*sdi = NULL;
}
}
return 0;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct drv_context *drvc;
struct dev_context *devc;
struct acquisition_state *acq;
int ret;
(void)cb_data;
if (sdi->status != SR_ST_ACTIVE)
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
drvc = di->priv;
if (devc->acquisition) {
sr_err("Acquisition still in progress?");
return SR_ERR;
}
acq = lwla_alloc_acquisition_state();
if (!acq)
return SR_ERR_MALLOC;
devc->stopping_in_progress = FALSE;
devc->transfer_error = FALSE;
sr_info("Starting acquisition.");
devc->acquisition = acq;
lwla_convert_trigger(sdi);
ret = lwla_setup_acquisition(sdi);
if (ret != SR_OK) {
sr_err("Failed to set up acquisition.");
devc->acquisition = NULL;
lwla_free_acquisition_state(acq);
return ret;
}
ret = lwla_start_acquisition(sdi);
if (ret != SR_OK) {
sr_err("Failed to start acquisition.");
devc->acquisition = NULL;
lwla_free_acquisition_state(acq);
return ret;
}
usb_source_add(sdi->session, drvc->sr_ctx, 100, &lwla_receive_data,
(struct sr_dev_inst *)sdi);
sr_info("Waiting for data.");
/* Send header packet to the session bus. */
std_session_send_df_header(sdi, LOG_PREFIX);
return SR_OK;
}
static int hw_opendev(int device_index)
{
GTimeVal cur_time;
struct sr_device_instance *sdi;
struct fx2_device *fx2;
int timediff, err;
if (!(sdi = sr_get_device_instance(device_instances, device_index)))
return SR_ERR;
fx2 = sdi->priv;
/*
* if the firmware was recently uploaded, wait up to MAX_RENUM_DELAY ms
* for the FX2 to renumerate
*/
err = 0;
if (GTV_TO_MSEC(fx2->fw_updated) > 0) {
sr_info("saleae: waiting for device to reset");
/* takes at least 300ms for the FX2 to be gone from the USB bus */
g_usleep(300*1000);
timediff = 0;
while (timediff < MAX_RENUM_DELAY) {
if ((err = sl_open_device(device_index)) == SR_OK)
break;
g_usleep(100*1000);
g_get_current_time(&cur_time);
timediff = GTV_TO_MSEC(cur_time) - GTV_TO_MSEC(fx2->fw_updated);
}
sr_info("saleae: device came back after %d ms", timediff);
} else {
err = sl_open_device(device_index);
}
if (err != SR_OK) {
sr_warn("unable to open device");
return SR_ERR;
}
fx2 = sdi->priv;
err = libusb_claim_interface(sdi->usb->devhdl, USB_INTERFACE);
if (err != 0) {
sr_warn("Unable to claim interface: %d", err);
return SR_ERR;
}
if (fx2->cur_samplerate == 0) {
/* Samplerate hasn't been set; default to the slowest one. */
if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE,
&supported_samplerates[0]) == SR_ERR)
return SR_ERR;
}
return SR_OK;
}
SR_PRIV void sl2_calculate_trigger_samples(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
uint64_t pre_trigger_samples, post_trigger_samples;
uint16_t pre_trigger_bytes, post_trigger_bytes;
uint8_t cr;
devc = sdi->priv;
cr = devc->capture_ratio;
/* Ignore the capture ratio if no trigger is enabled. */
if (devc->trigger_type == TRIGGER_TYPE_NONE)
cr = 0;
pre_trigger_samples = (devc->limit_samples * cr) / 100;
post_trigger_samples = (devc->limit_samples * (100 - cr)) / 100;
/*
* Increase the number of post trigger samples by one to compensate the
* possible loss of a sample through integer rounding.
*/
if (pre_trigger_samples + post_trigger_samples != devc->limit_samples)
post_trigger_samples++;
/*
* The device requires the number of samples in multiples of 8 which
* will also be called sample bytes in the following.
*/
pre_trigger_bytes = pre_trigger_samples / 8;
post_trigger_bytes = post_trigger_samples / 8;
/*
* Round up the number of sample bytes to ensure that at least the
* requested number of samples will be acquired. Note that due to this
* rounding the buffer to store these sample bytes needs to be at least
* one sample byte larger than the minimal number of sample bytes
* needed to store the requested samples.
*/
if (pre_trigger_samples % 8 != 0)
pre_trigger_bytes++;
if (post_trigger_samples % 8 != 0)
post_trigger_bytes++;
sr_info("Pre trigger samples: %" PRIu64 ".", pre_trigger_samples);
sr_info("Post trigger samples: %" PRIu64 ".", post_trigger_samples);
sr_dbg("Pre trigger sample bytes: %" PRIu16 ".", pre_trigger_bytes);
sr_dbg("Post trigger sample bytes: %" PRIu16 ".", post_trigger_bytes);
devc->pre_trigger_samples = pre_trigger_samples;
devc->pre_trigger_bytes = pre_trigger_bytes;
devc->post_trigger_bytes = post_trigger_bytes;
}
static int receive_data(int fd, int revents, int idx, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
int64_t t;
static gboolean request_new_packet = TRUE;
struct sr_serial_dev_inst *serial;
(void)fd;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
serial = sdi->conn;
if (revents == G_IO_IN) {
/* New data arrived. */
request_new_packet = handle_new_data(sdi, idx);
} else {
/*
* Timeout. Send "A" to request a packet, but then don't send
* further "A" commands until we received a full packet first.
*/
if (request_new_packet) {
center_send(serial, "A");
request_new_packet = FALSE;
}
}
if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {
sr_info("Requested number of samples reached.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
if (devc->limit_msec) {
t = (g_get_monotonic_time() - devc->starttime) / 1000;
if (t > (int64_t)devc->limit_msec) {
sr_info("Requested time limit reached.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
}
return TRUE;
}
static int receive_data(int fd, int revents, int dmm, void *info, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
int64_t time;
int ret;
(void)fd;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
serial = sdi->conn;
if (revents == G_IO_IN) {
/* Serial data arrived. */
handle_new_data(sdi, dmm, info);
} else {
/* Timeout, send another packet request (if DMM needs it). */
if (dmms[dmm].packet_request) {
ret = dmms[dmm].packet_request(serial);
if (ret < 0) {
sr_err("Failed to request packet: %d.", ret);
return FALSE;
}
}
}
if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {
sr_info("Requested number of samples reached.");
sdi->driver->dev_acquisition_stop(sdi, cb_data);
return TRUE;
}
if (devc->limit_msec) {
time = (g_get_monotonic_time() - devc->starttime) / 1000;
if (time > (int64_t)devc->limit_msec) {
sr_info("Requested time limit reached.");
sdi->driver->dev_acquisition_stop(sdi, cb_data);
return TRUE;
}
}
return TRUE;
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
int ret;
int64_t timediff_us, timediff_ms;
devc = sdi->priv;
/*
* If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
* milliseconds for the FX2 to renumerate.
*/
ret = SR_ERR;
if (devc->fw_updated > 0) {
sr_info("Waiting for device to reset.");
/* Takes >= 300ms for the FX2 to be gone from the USB bus. */
g_usleep(300 * 1000);
timediff_ms = 0;
while (timediff_ms < MAX_RENUM_DELAY_MS) {
if ((ret = logic16_dev_open(sdi)) == SR_OK)
break;
g_usleep(100 * 1000);
timediff_us = g_get_monotonic_time() - devc->fw_updated;
timediff_ms = timediff_us / 1000;
sr_spew("Waited %" PRIi64 "ms.", timediff_ms);
}
if (ret != SR_OK) {
sr_err("Device failed to renumerate.");
return SR_ERR;
}
sr_info("Device came back after %" PRIi64 "ms.", timediff_ms);
} else {
sr_info("Firmware upload was not needed.");
ret = logic16_dev_open(sdi);
}
if (ret != SR_OK) {
sr_err("Unable to open device.");
return SR_ERR;
}
if (devc->cur_samplerate == 0) {
/* Samplerate hasn't been set; default to the slowest one. */
devc->cur_samplerate = samplerates[0];
}
return SR_OK;
}
static int dev_open(struct sr_dev_inst *sdi)
{
struct dev_context *devc;
struct sr_usb_dev_inst *usb;
int64_t timediff_us, timediff_ms;
int err;
devc = sdi->priv;
usb = sdi->conn;
/*
* If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
* for the FX2 to renumerate.
*/
err = SR_ERR;
if (devc->fw_updated > 0) {
sr_info("Waiting for device to reset.");
/* Takes >= 300ms for the FX2 to be gone from the USB bus. */
g_usleep(300 * 1000);
timediff_ms = 0;
while (timediff_ms < MAX_RENUM_DELAY_MS) {
if ((err = hantek_6xxx_open(sdi)) == SR_OK)
break;
g_usleep(100 * 1000);
timediff_us = g_get_monotonic_time() - devc->fw_updated;
timediff_ms = timediff_us / 1000;
sr_spew("Waited %" PRIi64 " ms.", timediff_ms);
}
if (timediff_ms < MAX_RENUM_DELAY_MS)
sr_info("Device came back after %"PRIu64" ms.", timediff_ms);
} else {
err = hantek_6xxx_open(sdi);
}
if (err != SR_OK) {
sr_err("Unable to open device.");
return SR_ERR;
}
err = libusb_claim_interface(usb->devhdl, USB_INTERFACE);
if (err != 0) {
sr_err("Unable to claim interface: %s.",
libusb_error_name(err));
return SR_ERR;
}
return SR_OK;
}
/**
* Start a session.
*
* There can only be one session at a time.
*
* @return SR_OK upon success, SR_ERR upon errors.
*/
SR_API int sr_session_start(void)
{
struct sr_dev_inst *sdi;
GSList *l;
int ret;
if (!session) {
sr_err("%s: session was NULL; a session must be "
"created before starting it.", __func__);
return SR_ERR_BUG;
}
if (!session->devs) {
sr_err("%s: session->devs was NULL; a session "
"cannot be started without devices.", __func__);
return SR_ERR_BUG;
}
sr_info("Starting.");
ret = SR_OK;
for (l = session->devs; l; l = l->next) {
sdi = l->data;
if ((ret = sdi->driver->dev_acquisition_start(sdi, sdi)) != SR_OK) {
sr_err("%s: could not start an acquisition "
"(%d)", __func__, ret);
break;
}
}
/* TODO: What if there are multiple devices? Which return code? */
return ret;
}
static int set_samplerate(struct sr_dev_inst *sdi, uint64_t samplerate)
{
struct context *ctx;
if (!sdi) {
sr_err("zp: %s: sdi was NULL", __func__);
return SR_ERR_ARG;
}
if (!(ctx = sdi->priv)) {
sr_err("zp: %s: sdi->priv was NULL", __func__);
return SR_ERR_ARG;
}
sr_info("zp: Setting samplerate to %" PRIu64 "Hz.", samplerate);
if (samplerate > SR_MHZ(1))
analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);
else if (samplerate > SR_KHZ(1))
analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);
else
analyzer_set_freq(samplerate, FREQ_SCALE_HZ);
ctx->cur_samplerate = samplerate;
return SR_OK;
}
/**
* Stop the current session.
*
* The current session is stopped immediately, with all acquisition sessions
* being stopped and hardware drivers cleaned up.
*
* @return SR_OK upon success, SR_ERR_BUG if no session exists.
*/
SR_API int sr_session_stop(void)
{
struct sr_dev_inst *sdi;
GSList *l;
if (!session) {
sr_err("%s: session was NULL", __func__);
return SR_ERR_BUG;
}
sr_info("Stopping.");
for (l = session->devs; l; l = l->next) {
sdi = l->data;
if (sdi->driver) {
if (sdi->driver->dev_acquisition_stop)
sdi->driver->dev_acquisition_stop(sdi, sdi);
}
}
/*
* Some sources may not be necessarily associated with a device.
* Those sources may still be present even after stopping all devices.
* We need to make sure all sources are removed, or we risk running the
* session in an infinite loop.
*/
while (session->num_sources)
sr_session_source_remove(session->sources[0].poll_object);
return SR_OK;
}
static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
struct session_vdev *vdev;
int ret;
vdev = sdi->priv;
vdev->bytes_read = 0;
vdev->cur_chunk = 0;
vdev->finished = FALSE;
sr_info("Opening archive %s file %s", vdev->sessionfile,
vdev->capturefile);
if (!(vdev->archive = zip_open(vdev->sessionfile, 0, &ret))) {
sr_err("Failed to open session file '%s': "
"zip error %d.", vdev->sessionfile, ret);
return SR_ERR;
}
/* Send header packet to the session bus. */
std_session_send_df_header(cb_data, LOG_PREFIX);
/* freewheeling source */
sr_session_source_add(-1, 0, 0, receive_data, cb_data);
return SR_OK;
}
static struct sr_dev_inst *sr_scpi_scan_resource(struct drv_context *drvc,
const char *resource, const char *serialcomm,
struct sr_dev_inst *(*probe_device)(struct sr_scpi_dev_inst *scpi))
{
struct sr_scpi_dev_inst *scpi;
struct sr_dev_inst *sdi;
if (!(scpi = scpi_dev_inst_new(drvc, resource, serialcomm)))
return NULL;
if (sr_scpi_open(scpi) != SR_OK) {
sr_info("Couldn't open SCPI device.");
sr_scpi_free(scpi);
return NULL;
};
sdi = probe_device(scpi);
sr_scpi_close(scpi);
if (sdi)
sdi->status = SR_ST_INACTIVE;
else
sr_scpi_free(scpi);
return sdi;
}
static GSList *center_scan(const char *conn, const char *serialcomm, int idx)
{
int i;
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_serial_dev_inst *serial;
serial = sr_serial_dev_inst_new(conn, serialcomm);
if (serial_open(serial, SERIAL_RDWR) != SR_OK)
return NULL;
serial_flush(serial);
sr_info("Found device on port %s.", conn);
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_INACTIVE;
sdi->vendor = g_strdup(center_devs[idx].vendor);
sdi->model = g_strdup(center_devs[idx].device);
devc = g_malloc0(sizeof(struct dev_context));
sdi->inst_type = SR_INST_SERIAL;
sdi->conn = serial;
sdi->priv = devc;
for (i = 0; i < center_devs[idx].num_channels; i++)
sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_names[i]);
serial_close(serial);
return g_slist_append(NULL, sdi);
}
static int set_configuration_samplerate(struct sr_device_instance *sdi,
uint64_t samplerate)
{
struct fx2_device *fx2;
uint8_t divider;
int ret, result, i;
unsigned char buf[2];
fx2 = sdi->priv;
for (i = 0; supported_samplerates[i]; i++) {
if (supported_samplerates[i] == samplerate)
break;
}
if (supported_samplerates[i] == 0)
return SR_ERR_SAMPLERATE;
divider = (uint8_t) (48 / (samplerate / 1000000.0)) - 1;
sr_info("saleae: setting samplerate to %" PRIu64 " Hz (divider %d)",
samplerate, divider);
buf[0] = 0x01;
buf[1] = divider;
ret = libusb_bulk_transfer(sdi->usb->devhdl, 1 | LIBUSB_ENDPOINT_OUT,
buf, 2, &result, 500);
if (ret != 0) {
sr_warn("failed to set samplerate: %d", ret);
return SR_ERR;
}
fx2->cur_samplerate = samplerate;
fx2->period_ps = 1000000000000 / samplerate;
return SR_OK;
}
/**
* Run the session.
*
* TODO: Various error checks etc.
*
* @return SR_OK upon success, SR_ERR_BUG upon errors.
*/
SR_API int sr_session_run(void)
{
if (!session) {
sr_err("session: %s: session was NULL; a session must be "
"created first, before running it.", __func__);
return SR_ERR_BUG;
}
if (!session->devs) {
/* TODO: Actually the case? */
sr_err("session: %s: session->devs was NULL; a session "
"cannot be run without devices.", __func__);
return SR_ERR_BUG;
}
sr_info("session: running");
session->running = TRUE;
/* Do we have real sources? */
if (session->num_sources == 1 && session->pollfds[0].fd == -1) {
/* Dummy source, freewheel over it. */
while (session->running)
session->sources[0].cb(-1, 0, session->sources[0].cb_data);
} else {
/* Real sources, use g_poll() main loop. */
sr_session_run_poll();
}
return SR_OK;
}
SR_PRIV int zp_set_samplerate(struct dev_context *devc, uint64_t samplerate)
{
int i;
for (i = 0; ARRAY_SIZE(samplerates_200); i++)
if (samplerate == samplerates_200[i])
break;
if (i == ARRAY_SIZE(samplerates_200) || samplerate > devc->max_samplerate) {
sr_err("Unsupported samplerate: %" PRIu64 "Hz.", samplerate);
return SR_ERR_ARG;
}
sr_info("Setting samplerate to %" PRIu64 "Hz.", samplerate);
if (samplerate >= SR_MHZ(1))
analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);
else if (samplerate >= SR_KHZ(1))
analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);
else
analyzer_set_freq(samplerate, FREQ_SCALE_HZ);
devc->cur_samplerate = samplerate;
return SR_OK;
}
/* 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;
struct acquisition_state *acq;
unsigned int old_status;
devc = sdi->priv;
acq = devc->acquisition;
old_status = acq->status;
if ((*devc->model->handle_response)(sdi) != SR_OK) {
devc->transfer_error = TRUE;
return;
}
devc->state = STATE_STATUS_WAIT;
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)
sr_info("Capture triggered.");
if (acq->duration_now >= acq->duration_max) {
sr_dbg("Time limit reached, stopping capture.");
submit_request(sdi, STATE_STOP_CAPTURE);
} else if ((acq->status & STATUS_TRIGGERED) == 0) {
sr_spew("Waiting for trigger.");
} else if ((acq->status & STATUS_MEM_AVAIL) == 0) {
sr_dbg("Capture memory filled.");
submit_request(sdi, STATE_LENGTH_REQUEST);
} else if ((acq->status & STATUS_CAPTURING) != 0) {
sr_spew("Sampling in progress.");
}
}
/* Idle handler; invoked when the number of registered event sources
* for a running session drops to zero.
*/
static gboolean delayed_stop_check(void *data)
{
struct sr_session *session;
session = data;
session->stop_check_id = 0;
/* Session already ended? */
if (!session->running)
return G_SOURCE_REMOVE;
/* New event sources may have been installed in the meantime. */
if (g_hash_table_size(session->event_sources) != 0)
return G_SOURCE_REMOVE;
session->running = FALSE;
unset_main_context(session);
sr_info("Stopped.");
/* This indicates a bug in user code, since it is not valid to
* restart or destroy a session while it may still be running.
*/
if (!session->main_loop && !session->stopped_callback) {
sr_err("BUG: Session stop left unhandled.");
return G_SOURCE_REMOVE;
}
if (session->main_loop)
g_main_loop_quit(session->main_loop);
if (session->stopped_callback)
(*session->stopped_callback)(session->stopped_cb_data);
return G_SOURCE_REMOVE;
}
static int receive_data(int fd, int revents, int idx, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
int64_t t;
static gboolean first_time = TRUE;
struct sr_serial_dev_inst *serial;
(void)fd;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
serial = sdi->conn;
if (revents == G_IO_IN) {
/* New data arrived. */
handle_new_data(sdi, idx);
} else {
/* Timeout. */
if (first_time) {
mic_cmd_set_realtime_mode(serial);
first_time = FALSE;
}
}
if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {
sr_info("Requested number of samples reached.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
if (devc->limit_msec) {
t = (g_get_monotonic_time() - devc->starttime) / 1000;
if (t > (int64_t)devc->limit_msec) {
sr_info("Requested time limit reached.");
sdi->driver->dev_acquisition_stop(sdi);
return TRUE;
}
}
return TRUE;
}
static struct sr_dev_inst *probe_usbtmc_device(struct sr_scpi_dev_inst *scpi)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct sr_scpi_hw_info *hw_info;
char *model_name;
int model_index;
sdi = NULL;
devc = NULL;
hw_info = NULL;
if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
sr_info("Couldn't get IDN response.");
goto fail;
}
if (strcmp(hw_info->manufacturer, MANUFACTURER_ID) != 0)
goto fail;
if (dlm_model_get(hw_info->model, &model_name, &model_index) != SR_OK)
goto fail;
sdi = g_malloc0(sizeof(struct sr_dev_inst));
sdi->status = SR_ST_ACTIVE;
sdi->vendor = g_strdup(MANUFACTURER_NAME);
sdi->model = g_strdup(model_name);
sdi->version = g_strdup(hw_info->firmware_version);
sdi->serial_num = g_strdup(hw_info->serial_number);
sr_scpi_hw_info_free(hw_info);
hw_info = NULL;
devc = g_malloc0(sizeof(struct dev_context));
sdi->driver = &yokogawa_dlm_driver_info;
sdi->priv = devc;
sdi->inst_type = SR_INST_SCPI;
sdi->conn = scpi;
if (dlm_device_init(sdi, model_index) != SR_OK)
goto fail;
sr_scpi_close(sdi->conn);
sdi->status = SR_ST_INACTIVE;
return sdi;
fail:
if (hw_info)
sr_scpi_hw_info_free(hw_info);
if (sdi)
sr_dev_inst_free(sdi);
g_free(devc);
return NULL;
}
static GSList *mic_scan(const char *conn, const char *serialcomm, int idx)
{
struct sr_dev_inst *sdi;
struct drv_context *drvc;
struct dev_context *devc;
struct sr_probe *probe;
struct sr_serial_dev_inst *serial;
GSList *devices;
if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
return NULL;
if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
return NULL;
drvc = mic_devs[idx].di->priv;
devices = NULL;
serial_flush(serial);
/* TODO: Query device type. */
// ret = mic_cmd_get_device_info(serial);
sr_info("Found device on port %s.", conn);
/* TODO: Fill in version from protocol response. */
if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, mic_devs[idx].vendor,
mic_devs[idx].device, "")))
goto scan_cleanup;
if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
sr_err("Device context malloc failed.");
goto scan_cleanup;
}
sdi->inst_type = SR_INST_SERIAL;
sdi->conn = serial;
sdi->priv = devc;
sdi->driver = mic_devs[idx].di;
if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Temperature")))
goto scan_cleanup;
sdi->probes = g_slist_append(sdi->probes, probe);
if (mic_devs[idx].has_humidity) {
if (!(probe = sr_probe_new(1, SR_PROBE_ANALOG, TRUE, "Humidity")))
goto scan_cleanup;
sdi->probes = g_slist_append(sdi->probes, probe);
}
drvc->instances = g_slist_append(drvc->instances, sdi);
devices = g_slist_append(devices, sdi);
scan_cleanup:
serial_close(serial);
return devices;
}
/**
* Send the *IDN? SCPI command, receive the reply, parse it and store the
* reply as a sr_scpi_hw_info structure in the supplied scpi_response pointer.
*
* The hw_info structure must be freed by the caller via sr_scpi_hw_info_free().
*
* @param scpi Previously initialised SCPI device structure.
* @param scpi_response Pointer where to store the hw_info structure.
*
* @return SR_OK upon success, SR_ERR on failure.
*/
SR_PRIV int sr_scpi_get_hw_id(struct sr_scpi_dev_inst *scpi,
struct sr_scpi_hw_info **scpi_response)
{
int num_tokens;
char *response;
char *newline;
gchar **tokens;
struct sr_scpi_hw_info *hw_info;
response = NULL;
tokens = NULL;
if (sr_scpi_get_string(scpi, SCPI_CMD_IDN, &response) != SR_OK)
if (!response)
return SR_ERR;
sr_info("Got IDN string: '%s'", response);
/* Remove trailing newline if present. */
if ((newline = g_strrstr(response, "\n")))
newline[0] = '\0';
/*
* The response to a '*IDN?' is specified by the SCPI spec. It contains
* a comma-separated list containing the manufacturer name, instrument
* model, serial number of the instrument and the firmware version.
*/
tokens = g_strsplit(response, ",", 0);
for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);
if (num_tokens != 4) {
sr_dbg("IDN response not according to spec: %80.s.", response);
g_strfreev(tokens);
g_free(response);
return SR_ERR;
}
g_free(response);
hw_info = g_try_malloc(sizeof(struct sr_scpi_hw_info));
if (!hw_info) {
g_strfreev(tokens);
return SR_ERR_MALLOC;
}
hw_info->manufacturer = g_strdup(tokens[0]);
hw_info->model = g_strdup(tokens[1]);
hw_info->serial_number = g_strdup(tokens[2]);
hw_info->firmware_version = g_strdup(tokens[3]);
g_strfreev(tokens);
*scpi_response = hw_info;
return SR_OK;
}
SR_PRIV int brymen_dmm_receive_data(int fd, int revents, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
int ret;
int64_t time;
(void)fd;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
if (revents == G_IO_IN) {
/* Serial data arrived. */
handle_new_data(sdi);
} else {
/* Timeout, send another packet request. */
if ((ret = brymen_packet_request(devc->serial)) < 0) {
sr_err("Failed to request packet: %d.", ret);
return FALSE;
}
}
if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {
sr_info("Requested number of samples reached, stopping.");
sdi->driver->dev_acquisition_stop(sdi, cb_data);
return TRUE;
}
if (devc->limit_msec) {
time = (g_get_monotonic_time() - devc->starttime) / 1000;
if (time > (int64_t)devc->limit_msec) {
sr_info("Requested time limit reached, stopping.");
sdi->driver->dev_acquisition_stop(sdi, cb_data);
return TRUE;
}
}
return TRUE;
}
SR_PRIV int kern_scale_receive_data(int fd, int revents, void *cb_data)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
struct scale_info *scale;
int64_t time;
void *info;
(void)fd;
if (!(sdi = cb_data))
return TRUE;
if (!(devc = sdi->priv))
return TRUE;
scale = (struct scale_info *)sdi->driver;
if (revents == G_IO_IN) {
/* Serial data arrived. */
info = g_malloc(scale->info_size);
handle_new_data(sdi, info);
g_free(info);
}
if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {
sr_info("Requested number of samples reached.");
sdi->driver->dev_acquisition_stop(sdi, cb_data);
return TRUE;
}
if (devc->limit_msec) {
time = (g_get_monotonic_time() - devc->starttime) / 1000;
if (time > (int64_t)devc->limit_msec) {
sr_info("Requested time limit reached.");
sdi->driver->dev_acquisition_stop(sdi, cb_data);
return TRUE;
}
}
return TRUE;
}
SR_PRIV int ezusb_install_firmware(struct sr_context *ctx,
libusb_device_handle *hdl,
const char *name)
{
unsigned char *firmware;
size_t length, offset, chunksize;
int ret, result;
/* Max size is 64 kiB since the value field of the setup packet,
* which holds the firmware offset, is only 16 bit wide.
*/
firmware = sr_resource_load(ctx, SR_RESOURCE_FIRMWARE,
name, &length, 1 << 16);
if (!firmware)
return SR_ERR;
sr_info("Uploading firmware '%s'.", name);
result = SR_OK;
offset = 0;
while (offset < length) {
chunksize = MIN(length - offset, FW_CHUNKSIZE);
ret = libusb_control_transfer(hdl, LIBUSB_REQUEST_TYPE_VENDOR |
LIBUSB_ENDPOINT_OUT, 0xa0, offset,
0x0000, firmware + offset,
chunksize, 100);
if (ret < 0) {
sr_err("Unable to send firmware to device: %s.",
libusb_error_name(ret));
g_free(firmware);
return SR_ERR;
}
sr_info("Uploaded %zu bytes.", chunksize);
offset += chunksize;
}
g_free(firmware);
sr_info("Firmware upload done.");
return result;
}