/*
- * This file is part of the sigrok project.
+ * This file is part of the libsigrok project.
*
- * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
+ * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
*/
#include "protocol.h"
+#include <libserialport.h>
extern SR_PRIV struct sr_dev_driver ols_driver_info;
static struct sr_dev_driver *di = &ols_driver_info;
sr_dbg("Sending cmd 0x%.2x.", command);
buf[0] = command;
- if (serial_write(serial, buf, 1) != 1)
+ if (serial_write_blocking(serial, buf, 1) != 1)
return SR_ERR;
return SR_OK;
}
SR_PRIV int send_longcommand(struct sr_serial_dev_inst *serial,
- uint8_t command, uint32_t data)
+ uint8_t command, uint8_t *data)
{
char buf[5];
- sr_dbg("Sending cmd 0x%.2x data 0x%.8x.", command, data);
+ sr_dbg("Sending cmd 0x%.2x data 0x%.2x%.2x%.2x%.2x.", command,
+ data[0], data[1], data[2], data[3]);
buf[0] = command;
- buf[1] = (data & 0xff000000) >> 24;
- buf[2] = (data & 0xff0000) >> 16;
- buf[3] = (data & 0xff00) >> 8;
- buf[4] = data & 0xff;
- if (serial_write(serial, buf, 5) != 5)
+ buf[1] = data[0];
+ buf[2] = data[1];
+ buf[3] = data[2];
+ buf[4] = data[3];
+ if (serial_write_blocking(serial, buf, 5) != 5)
return SR_ERR;
return SR_OK;
}
-SR_PRIV int ols_configure_probes(const struct sr_dev_inst *sdi)
+SR_PRIV int ols_configure_channels(const struct sr_dev_inst *sdi)
{
struct dev_context *devc;
- const struct sr_probe *probe;
+ const struct sr_channel *ch;
const GSList *l;
- int probe_bit, stage, i;
+ int channel_bit, stage, i;
char *tc;
devc = sdi->priv;
- devc->probe_mask = 0;
+ devc->channel_mask = 0;
for (i = 0; i < NUM_TRIGGER_STAGES; i++) {
devc->trigger_mask[i] = 0;
devc->trigger_value[i] = 0;
}
devc->num_stages = 0;
- for (l = sdi->probes; l; l = l->next) {
- probe = (const struct sr_probe *)l->data;
- if (!probe->enabled)
+ for (l = sdi->channels; l; l = l->next) {
+ ch = (const struct sr_channel *)l->data;
+ if (!ch->enabled)
continue;
+ if (ch->index >= devc->max_channels) {
+ sr_err("Channels over the limit of %d\n", devc->max_channels);
+ return SR_ERR;
+ }
+
/*
- * Set up the probe mask for later configuration into the
+ * Set up the channel mask for later configuration into the
* flag register.
*/
- probe_bit = 1 << (probe->index);
- devc->probe_mask |= probe_bit;
+ channel_bit = 1 << (ch->index);
+ devc->channel_mask |= channel_bit;
- if (!probe->trigger)
+ if (!ch->trigger)
continue;
/* Configure trigger mask and value. */
stage = 0;
- for (tc = probe->trigger; tc && *tc; tc++) {
- devc->trigger_mask[stage] |= probe_bit;
+ for (tc = ch->trigger; tc && *tc; tc++) {
+ devc->trigger_mask[stage] |= channel_bit;
if (*tc == '1')
- devc->trigger_value[stage] |= probe_bit;
+ devc->trigger_value[stage] |= channel_bit;
stage++;
- if (stage > 3)
- /*
- * TODO: Only supporting parallel mode, with
- * up to 4 stages.
- */
+ /* Only supporting parallel mode, with up to 4 stages. */
+ if (stage > 4)
return SR_ERR;
}
if (stage > devc->num_stages)
- devc->num_stages = stage;
+ devc->num_stages = stage - 1;
}
return SR_OK;
}
-SR_PRIV uint32_t reverse16(uint32_t in)
-{
- uint32_t out;
-
- out = (in & 0xff) << 8;
- out |= (in & 0xff00) >> 8;
- out |= (in & 0xff0000) << 8;
- out |= (in & 0xff000000) >> 8;
-
- return out;
-}
-
-SR_PRIV uint32_t reverse32(uint32_t in)
-{
- uint32_t out;
-
- out = (in & 0xff) << 24;
- out |= (in & 0xff00) << 8;
- out |= (in & 0xff0000) >> 8;
- out |= (in & 0xff000000) >> 24;
-
- return out;
-}
-
SR_PRIV struct dev_context *ols_dev_new(void)
{
struct dev_context *devc;
- if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
+ if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
sr_err("Device context malloc failed.");
return NULL;
}
+ /* Device-specific settings */
+ devc->max_samples = devc->max_samplerate = devc->protocol_version = 0;
+
+ /* Acquisition settings */
+ devc->limit_samples = devc->capture_ratio = 0;
devc->trigger_at = -1;
- devc->probe_mask = 0xffffffff;
- devc->cur_samplerate = SR_KHZ(200);
- devc->serial = NULL;
+ devc->channel_mask = 0xffffffff;
+ devc->flag_reg = 0;
return devc;
}
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
- struct sr_probe *probe;
+ struct sr_channel *ch;
uint32_t tmp_int, ui;
uint8_t key, type, token;
GString *tmp_str, *devname, *version;
key = 0xff;
while (key) {
- if (serial_read(serial, &key, 1) != 1 || key == 0x00)
+ if (serial_read_blocking(serial, &key, 1) != 1)
+ break;
+ if (key == 0x00) {
+ sr_dbg("Got metadata key 0x00, metadata ends.");
break;
+ }
type = key >> 5;
token = key & 0x1f;
switch (type) {
case 0:
/* NULL-terminated string */
tmp_str = g_string_new("");
- while (serial_read(serial, &tmp_c, 1) == 1 && tmp_c != '\0')
+ while (serial_read_blocking(serial, &tmp_c, 1) == 1 && tmp_c != '\0')
g_string_append_c(tmp_str, tmp_c);
sr_dbg("Got metadata key 0x%.2x value '%s'.",
key, tmp_str->str);
break;
case 1:
/* 32-bit unsigned integer */
- if (serial_read(serial, &tmp_int, 4) != 4)
+ if (serial_read_blocking(serial, &tmp_int, 4) != 4)
break;
- tmp_int = reverse32(tmp_int);
+ tmp_int = RB32(&tmp_int);
sr_dbg("Got metadata key 0x%.2x value 0x%.8x.",
key, tmp_int);
switch (token) {
case 0x00:
- /* Number of usable probes */
+ /* Number of usable channels */
for (ui = 0; ui < tmp_int; ui++) {
- if (!(probe = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
- ols_probe_names[ui])))
+ if (!(ch = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
+ ols_channel_names[ui])))
return 0;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
break;
case 0x01:
break;
case 2:
/* 8-bit unsigned integer */
- if (serial_read(serial, &tmp_c, 1) != 1)
+ if (serial_read_blocking(serial, &tmp_c, 1) != 1)
break;
sr_dbg("Got metadata key 0x%.2x value 0x%.2x.",
key, tmp_c);
switch (token) {
case 0x00:
- /* Number of usable probes */
+ /* Number of usable channels */
for (ui = 0; ui < tmp_c; ui++) {
- if (!(probe = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
- ols_probe_names[ui])))
+ if (!(ch = sr_probe_new(ui, SR_PROBE_LOGIC, TRUE,
+ ols_channel_names[ui])))
return 0;
- sdi->probes = g_slist_append(sdi->probes, probe);
+ sdi->channels = g_slist_append(sdi->channels, ch);
}
break;
case 0x01:
}
SR_PRIV int ols_set_samplerate(const struct sr_dev_inst *sdi,
- uint64_t samplerate,
- const struct sr_samplerates *samplerates)
+ const uint64_t samplerate)
{
struct dev_context *devc;
devc = sdi->priv;
- if (devc->max_samplerate) {
- if (samplerate > devc->max_samplerate)
- return SR_ERR_SAMPLERATE;
- } else if (samplerate < samplerates->low || samplerate > samplerates->high)
+ if (devc->max_samplerate && samplerate > devc->max_samplerate)
return SR_ERR_SAMPLERATE;
if (samplerate > CLOCK_RATE) {
+ sr_info("Enabling demux mode.");
devc->flag_reg |= FLAG_DEMUX;
+ devc->flag_reg &= ~FLAG_FILTER;
+ devc->max_channels = NUM_PROBES / 2;
devc->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1;
} else {
+ sr_info("Disabling demux mode.");
devc->flag_reg &= ~FLAG_DEMUX;
+ devc->flag_reg |= FLAG_FILTER;
+ devc->max_channels = NUM_PROBES;
devc->cur_samplerate_divider = (CLOCK_RATE / samplerate) - 1;
}
if (devc->flag_reg & FLAG_DEMUX)
devc->cur_samplerate *= 2;
if (devc->cur_samplerate != samplerate)
- sr_err("Can't match samplerate %" PRIu64 ", using %"
+ sr_info("Can't match samplerate %" PRIu64 ", using %"
PRIu64 ".", samplerate, devc->cur_samplerate);
return SR_OK;
SR_PRIV void abort_acquisition(const struct sr_dev_inst *sdi)
{
struct sr_datafeed_packet packet;
- struct dev_context *devc;
+ struct sr_serial_dev_inst *serial;
- devc = sdi->priv;
- sr_source_remove(devc->serial->fd);
+ serial = sdi->conn;
+ serial_source_remove(serial);
/* Terminate session */
packet.type = SR_DF_END;
SR_PRIV int ols_receive_data(int fd, int revents, void *cb_data)
{
+ struct dev_context *devc;
+ struct sr_dev_inst *sdi;
+ struct sr_serial_dev_inst *serial;
struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic;
- struct sr_dev_inst *sdi;
- struct drv_context *drvc;
- struct dev_context *devc;
- GSList *l;
- int num_channels, offset, i, j;
+ uint32_t sample;
+ int num_channels, offset, j;
+ unsigned int i;
unsigned char byte;
- drvc = di->priv;
+ (void)fd;
- /* Find this device's devc struct by its fd. */
- devc = NULL;
- for (l = drvc->instances; l; l = l->next) {
- sdi = l->data;
- devc = sdi->priv;
- if (devc->serial->fd == fd)
- break;
- devc = NULL;
- }
- if (!devc)
- /* Shouldn't happen. */
- return TRUE;
+ sdi = cb_data;
+ serial = sdi->conn;
+ devc = sdi->priv;
if (devc->num_transfers++ == 0) {
/*
* longer than it takes to send a byte, that means it's
* finished. We'll double that to 30ms to be sure...
*/
- sr_source_remove(fd);
- sr_source_add(fd, G_IO_IN, 30, ols_receive_data, cb_data);
+ serial_source_remove(serial);
+ serial_source_add(serial, G_IO_IN, 30, ols_receive_data, cb_data);
devc->raw_sample_buf = g_try_malloc(devc->limit_samples * 4);
if (!devc->raw_sample_buf) {
sr_err("Sample buffer malloc failed.");
}
num_channels = 0;
- for (i = 0x20; i > 0x02; i /= 2) {
- if ((devc->flag_reg & i) == 0)
+ for (i = NUM_PROBES; i > 0x02; i /= 2) {
+ if ((devc->flag_reg & i) == 0) {
num_channels++;
+ }
}
- if (revents == G_IO_IN) {
- if (serial_read(devc->serial, &byte, 1) != 1)
+ if (revents == G_IO_IN && devc->num_samples < devc->limit_samples) {
+ if (serial_read_nonblocking(serial, &byte, 1) != 1)
return FALSE;
+ devc->cnt_bytes++;
/* Ignore it if we've read enough. */
if (devc->num_samples >= devc->limit_samples)
return TRUE;
devc->sample[devc->num_bytes++] = byte;
- sr_dbg("Received byte 0x%.2x.", byte);
+ sr_spew("Received byte 0x%.2x.", byte);
if (devc->num_bytes == num_channels) {
- /* Got a full sample. */
- sr_dbg("Received sample 0x%.*x.",
- devc->num_bytes * 2, *(int *)devc->sample);
+ devc->cnt_samples++;
+ devc->cnt_samples_rle++;
+ /*
+ * Got a full sample. Convert from the OLS's little-endian
+ * sample to the local format.
+ */
+ sample = devc->sample[0] | (devc->sample[1] << 8) \
+ | (devc->sample[2] << 16) | (devc->sample[3] << 24);
+ sr_dbg("Received sample 0x%.*x.", devc->num_bytes * 2, sample);
if (devc->flag_reg & FLAG_RLE) {
/*
- * In RLE mode -1 should never come in as a
- * sample, because bit 31 is the "count" flag.
+ * In RLE mode the high bit of the sample is the
+ * "count" flag, meaning this sample is the number
+ * of times the previous sample occurred.
*/
if (devc->sample[devc->num_bytes - 1] & 0x80) {
- devc->sample[devc->num_bytes - 1] &= 0x7f;
- /*
- * FIXME: This will only work on
- * little-endian systems.
- */
- devc->rle_count = *(int *)(devc->sample);
- sr_dbg("RLE count: %d.", devc->rle_count);
+ /* Clear the high bit. */
+ sample &= ~(0x80 << (devc->num_bytes - 1) * 8);
+ devc->rle_count = sample;
+ devc->cnt_samples_rle += devc->rle_count;
+ sr_dbg("RLE count: %u.", devc->rle_count);
devc->num_bytes = 0;
return TRUE;
}
* submitting it over the session bus --
* whatever is listening on the bus will be
* expecting a full 32-bit sample, based on
- * the number of probes.
+ * the number of channels.
*/
j = 0;
memset(devc->tmp_sample, 0, 4);
* sample.
*/
devc->tmp_sample[i] = devc->sample[j++];
+ } else if (devc->flag_reg & FLAG_DEMUX && (i > 2)) {
+ /* group 2 & 3 get added to 0 & 1 */
+ devc->tmp_sample[i - 2] = devc->sample[j++];
}
}
memcpy(devc->sample, devc->tmp_sample, 4);
- sr_dbg("Full sample: 0x%.8x.", *(int *)devc->sample);
+ sr_spew("Expanded sample: 0x%.8x.", sample);
}
- /* the OLS sends its sample buffer backwards.
+ /*
+ * the OLS sends its sample buffer backwards.
* store it in reverse order here, so we can dump
* this on the session bus later.
*/
* we've acquired all the samples we asked for -- we're done.
* Send the (properly-ordered) buffer to the frontend.
*/
+ sr_dbg("Received %d bytes, %d samples, %d decompressed samples.",
+ devc->cnt_bytes, devc->cnt_samples,
+ devc->cnt_samples_rle);
if (devc->trigger_at != -1) {
- /* a trigger was set up, so we need to tell the frontend
+ /*
+ * A trigger was set up, so we need to tell the frontend
* about it.
*/
if (devc->trigger_at > 0) {
- /* there are pre-trigger samples, send those first */
+ /* There are pre-trigger samples, send those first. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = devc->trigger_at * 4;
sr_session_send(cb_data, &packet);
}
- /* send the trigger */
+ /* Send the trigger. */
packet.type = SR_DF_TRIGGER;
sr_session_send(cb_data, &packet);
- /* send post-trigger samples */
+ /* Send post-trigger samples. */
packet.type = SR_DF_LOGIC;
packet.payload = &logic;
logic.length = (devc->num_samples * 4) - (devc->trigger_at * 4);
}
g_free(devc->raw_sample_buf);
- serial_flush(devc->serial);
+ serial_flush(serial);
abort_acquisition(sdi);
- serial_close(devc->serial);
}
return TRUE;
projects / libsigrok.git / blobdiff