}
/* Device-specific settings */
- devc->max_samples = devc->max_samplerate = devc->protocol_version = 0;
+ devc->max_samplebytes = devc->max_samplerate = devc->protocol_version = 0;
/* Acquisition settings */
devc->limit_samples = devc->capture_ratio = 0;
devc = sdi->priv;
if (devc->flag_reg & FLAG_RLE)
return SR_ERR_NA;
- if (devc->max_samples == 0)
+ if (devc->max_samplebytes == 0)
/* Device didn't specify sample memory size in metadata. */
return SR_ERR_NA;
/*
* divide by zero. */
break;
}
+ /* 3 channel groups takes as many bytes as 4 channel groups */
+ if (num_channels == 3)
+ num_channels = 4;
grange[0] = g_variant_new_uint64(MIN_NUM_SAMPLES);
- grange[1] = g_variant_new_uint64(devc->max_samples / num_channels);
+ grange[1] = g_variant_new_uint64(devc->max_samplebytes / num_channels);
*data = g_variant_new_tuple(grange, 2);
break;
default:
struct dev_context *devc;
uint32_t samplecount, readcount, delaycount;
uint8_t changrp_mask, arg[4];
- int num_channels;
+ uint16_t flag_tmp;
+ int num_channels, samplespercount;
int ret, i;
if (sdi->status != SR_ST_ACTIVE)
num_channels++;
}
}
+ /* 3 channel groups takes as many bytes as 4 channel groups */
+ if (num_channels == 3)
+ num_channels = 4;
+ /* maximum number of samples (or RLE counts) the buffer memory can hold */
+ devc->max_samples = devc->max_samplebytes / num_channels;
/*
* Limit readcount to prevent reading past the end of the hardware
*/
sr_dbg("max_samples = %d", devc->max_samples);
sr_dbg("limit_samples = %d", devc->limit_samples);
- samplecount = MIN(devc->max_samples / num_channels, devc->limit_samples);
- readcount = samplecount / 4;
+ samplecount = MIN(devc->max_samples, devc->limit_samples);
sr_dbg("Samplecount = %d", samplecount);
+ /* In demux mode the OLS is processing two samples per clock */
+ if (devc->flag_reg & FLAG_DEMUX) {
+ samplespercount = 8;
+ }
+ else {
+ samplespercount = 4;
+ }
+
+ readcount = samplecount / samplespercount;
+
/* Rather read too many samples than too few. */
- if (samplecount % 4 != 0)
+ if (samplecount % samplespercount != 0)
readcount++;
/* Basic triggers. */
if (devc->trigger_mask[0] != 0x00000000) {
/* At least one channel has a trigger on it. */
delaycount = readcount * (1 - devc->capture_ratio / 100.0);
- devc->trigger_at = (readcount - delaycount) * 4 - devc->num_stages;
+ devc->trigger_at = (readcount - delaycount) * samplespercount - devc->num_stages;
for (i = 0; i <= devc->num_stages; i++) {
sr_dbg("Setting stage %d trigger.", i);
if ((ret = set_trigger(sdi, i)) != SR_OK)
devc->flag_reg & FLAG_FILTER ? "on": "off",
devc->flag_reg & FLAG_DEMUX ? "on" : "off");
- /* 1 means "disable channel". */
+ /*
+ * Enable/disable OLS channel groups in the flag register according
+ * to the channel mask. 1 means "disable channel".
+ */
+ devc->flag_reg &= ~0x3c;
devc->flag_reg |= ~(changrp_mask << 2) & 0x3c;
- arg[0] = devc->flag_reg & 0xff;
- arg[1] = devc->flag_reg >> 8;
+ sr_dbg("flag_reg = %x", devc->flag_reg);
+
+ /*
+ * In demux mode the OLS is processing two 8-bit or 16-bit samples
+ * in parallel and for this to work the lower two bits of the four
+ * "channel_disable" bits must be replicated to the upper two bits.
+ */
+ flag_tmp = devc->flag_reg;
+ if (devc->flag_reg & FLAG_DEMUX) {
+ flag_tmp &= ~0x30;
+ flag_tmp |= ~(changrp_mask << 4) & 0x30;
+ }
+ arg[0] = flag_tmp & 0xff;
+ arg[1] = flag_tmp >> 8;
arg[2] = arg[3] = 0x00;
if (write_longcommand(devc, CMD_SET_FLAGS, arg) != SR_OK)
return SR_ERR;
break;
case 0x01:
/* Amount of sample memory available (bytes) */
- devc->max_samples = tmp_int;
+ devc->max_samplebytes = tmp_int;
break;
case 0x02:
/* Amount of dynamic memory available (bytes) */
memset(devc->raw_sample_buf, 0x82, devc->limit_samples * 4);
}
- if (devc->num_samples < devc->limit_samples) {
+ if ((devc->num_samples < devc->limit_samples) && (devc->cnt_samples < devc->max_samples)) {
num_channels = 0;
for (i = NUM_CHANNELS; i > 0x02; i /= 2) {
num_channels++;
}
}
+ sr_dbg("num_channels = %d", num_channels);
/* Get a block of data. */
bytes_read = ftdi_read_data(devc->ftdic, devc->ftdi_buf, FTDI_BUF_SIZE);
devc->sample[devc->num_bytes++] = byte;
sr_spew("Received byte 0x%.2x.", byte);
- if (devc->num_bytes == num_channels) {
- 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_spew("Received sample 0x%.*x.", devc->num_bytes * 2, sample);
- if (devc->flag_reg & FLAG_RLE) {
+
+ if ((devc->flag_reg & FLAG_DEMUX) && (devc->flag_reg & FLAG_RLE)) {
+ /* RLE in demux mode must be processed differently
+ * since in this case the RLE encoder is operating on pairs of samples.
+ */
+ if (devc->num_bytes == num_channels * 2) {
+ devc->cnt_samples += 2;
+ devc->cnt_samples_rle += 2;
/*
- * 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.
+ * Got a sample pair. 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_spew("Received sample pair 0x%.*x.", devc->num_bytes * 2, sample);
+
+ /*
+ * In RLE mode the high bit of the sample pair is the
+ * "count" flag, meaning this sample pair is the number
+ * of times the previous sample pair occurred.
*/
if (devc->sample[devc->num_bytes - 1] & 0x80) {
/* 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->cnt_samples_rle += devc->rle_count * 2;
+ sr_dbg("RLE count: %u.", devc->rle_count * 2);
devc->num_bytes = 0;
continue;
}
- }
- devc->num_samples += devc->rle_count + 1;
- if (devc->num_samples > devc->limit_samples) {
- /* Save us from overrunning the buffer. */
- devc->rle_count -= devc->num_samples - devc->limit_samples;
- devc->num_samples = devc->limit_samples;
- }
+ devc->num_samples += (devc->rle_count + 1) * 2;
+ if (devc->num_samples > devc->limit_samples) {
+ /* Save us from overrunning the buffer. */
+ devc->rle_count -= (devc->num_samples - devc->limit_samples) / 2;
+ devc->num_samples = devc->limit_samples;
+ index = bytes_read;
+ }
- if (num_channels < 4) {
/*
* Some channel groups may have been turned
* off, to speed up transfer between the
* the number of channels.
*/
j = 0;
+ /* expand first sample */
memset(devc->tmp_sample, 0, 4);
- for (i = 0; i < 4; i++) {
+ for (i = 0; i < 2; i++) {
if (((devc->flag_reg >> 2) & (1 << i)) == 0) {
/*
* This channel group was
* 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_spew("Expanded sample: 0x%.8x.", sample);
+ /* Clear out the most significant bit of the sample */
+ devc->tmp_sample[devc->num_bytes - 1] &= 0x7f;
+ sr_spew("Expanded sample 1: 0x%.8x.", devc->tmp_sample);
+
+ /* expand second sample */
+ memset(devc->tmp_sample2, 0, 4);
+ for (i = 0; i < 2; i++) {
+ if (((devc->flag_reg >> 2) & (1 << i)) == 0) {
+ /*
+ * This channel group was
+ * enabled, copy from received
+ * sample.
+ */
+ devc->tmp_sample2[i] = devc->sample[j++];
+ }
+ }
+ /* Clear out the most significant bit of the sample */
+ devc->tmp_sample2[devc->num_bytes - 1] &= 0x7f;
+ sr_spew("Expanded sample 2: 0x%.8x.", devc->tmp_sample2);
+
+ /*
+ * OLS sends its sample buffer backwards.
+ * store it in reverse order here, so we can dump
+ * this on the session bus later.
+ */
+ offset = (devc->limit_samples - devc->num_samples) * 4;
+ for (i = 0; i <= devc->rle_count; i++) {
+ memcpy(devc->raw_sample_buf + offset + (i * 8),
+ devc->tmp_sample2, 4);
+ memcpy(devc->raw_sample_buf + offset + (4 + (i * 8)),
+ devc->tmp_sample, 4);
+ }
+ memset(devc->sample, 0, 4);
+ devc->num_bytes = 0;
+ devc->rle_count = 0;
}
+ }
+ else {
+ if (devc->num_bytes == num_channels) {
+ 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_spew("Received sample 0x%.*x.", devc->num_bytes * 2, sample);
+ if (devc->flag_reg & FLAG_RLE) {
+ /*
+ * 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) {
+ /* 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;
+ continue;
+ }
+ }
+ devc->num_samples += devc->rle_count + 1;
+ if (devc->num_samples > devc->limit_samples) {
+ /* Save us from overrunning the buffer. */
+ devc->rle_count -= devc->num_samples - devc->limit_samples;
+ devc->num_samples = devc->limit_samples;
+ index = bytes_read;
+ }
+
+ if (num_channels < 4) {
+ /*
+ * Some channel groups may have been turned
+ * off, to speed up transfer between the
+ * hardware and the PC. Expand that here before
+ * 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 channels.
+ */
+ j = 0;
+ memset(devc->tmp_sample, 0, 4);
+ for (i = 0; i < 4; i++) {
+ if (((devc->flag_reg >> 2) & (1 << i)) == 0) {
+ /*
+ * This channel group was
+ * enabled, copy from received
+ * sample.
+ */
+ devc->tmp_sample[i] = devc->sample[j++];
+ }
+ }
+ memcpy(devc->sample, devc->tmp_sample, 4);
+ sr_spew("Expanded sample: 0x%.8x.", sample);
+ }
- /*
- * Pipistrello OLS sends its sample buffer backwards.
- * store it in reverse order here, so we can dump
- * this on the session bus later.
- */
- offset = (devc->limit_samples - devc->num_samples) * 4;
- for (i = 0; i <= devc->rle_count; i++) {
- memcpy(devc->raw_sample_buf + offset + (i * 4),
- devc->sample, 4);
+ /*
+ * Pipistrello OLS sends its sample buffer backwards.
+ * store it in reverse order here, so we can dump
+ * this on the session bus later.
+ */
+ offset = (devc->limit_samples - devc->num_samples) * 4;
+ for (i = 0; i <= devc->rle_count; i++) {
+ memcpy(devc->raw_sample_buf + offset + (i * 4),
+ devc->sample, 4);
+ }
+ memset(devc->sample, 0, 4);
+ devc->num_bytes = 0;
+ devc->rle_count = 0;
}
- memset(devc->sample, 0, 4);
- devc->num_bytes = 0;
- devc->rle_count = 0;
}
}
return TRUE;
} else {
+ do bytes_read = ftdi_read_data(devc->ftdic, devc->ftdi_buf, FTDI_BUF_SIZE);
+ while (bytes_read > 0);
+
/*
* We've acquired all the samples we asked for -- we're done.
* Send the (properly-ordered) buffer to the frontend.
projects / libsigrok.git / commitdiff