X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fopenbench-logic-sniffer%2Fols.c;h=35db8402f7b64a99eebb24304c9ede8fe1f3437a;hb=a562c3a2e5e54dbb7e0553422ac0e0c845b180ad;hp=e7daa016a9e6eef9ce9eba35c2e158c8b83a6d7e;hpb=9c939c5132d82575cc1ce8f8fef5b6c4289aec5b;p=libsigrok.git diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c index e7daa016..35db8402 100644 --- a/hardware/openbench-logic-sniffer/ols.c +++ b/hardware/openbench-logic-sniffer/ols.c @@ -51,6 +51,7 @@ static int capabilities[] = { SR_HWCAP_SAMPLERATE, SR_HWCAP_CAPTURE_RATIO, SR_HWCAP_LIMIT_SAMPLES, + SR_HWCAP_RLE, 0, }; @@ -553,8 +554,6 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi, } else if (samplerate < samplerates.low || samplerate > samplerates.high) return SR_ERR_SAMPLERATE; - ols->cur_samplerate = samplerate; - ols->period_ps = 1000000000000 / samplerate; if (samplerate > CLOCK_RATE) { ols->flag_reg |= FLAG_DEMUX; ols->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1; @@ -563,6 +562,17 @@ static int set_configuration_samplerate(struct sr_device_instance *sdi, ols->cur_samplerate_divider = (CLOCK_RATE / samplerate) - 1; } + /* Calculate actual samplerate used and complain if it is different + * from the requested. + */ + ols->cur_samplerate = CLOCK_RATE / (ols->cur_samplerate_divider + 1); + if(ols->flag_reg & FLAG_DEMUX) + ols->cur_samplerate *= 2; + ols->period_ps = 1000000000000 / ols->cur_samplerate; + if(ols->cur_samplerate != samplerate) + sr_warn("ols: can't match samplerate %" PRIu64 ", using %" PRIu64, + samplerate, ols->cur_samplerate); + return SR_OK; } @@ -592,6 +602,8 @@ static int hw_set_configuration(int device_index, int capability, void *value) tmp_u64 = value; if (*tmp_u64 < MIN_NUM_SAMPLES) return SR_ERR; + if (*tmp_u64 > ols->max_samples) + sr_warn("ols: sample limit exceeds hw max"); ols->limit_samples = *tmp_u64; sr_info("ols: sample limit %" PRIu64, ols->limit_samples); ret = SR_OK; @@ -605,6 +617,13 @@ static int hw_set_configuration(int device_index, int capability, void *value) } else ret = SR_OK; break; + case SR_HWCAP_RLE: + if (!strcmp(value, "on")) { + sr_info("ols: enabling RLE"); + ols->flag_reg |= FLAG_RLE; + } + ret = SR_OK; + break; default: ret = SR_ERR; } @@ -619,8 +638,8 @@ static int receive_data(int fd, int revents, void *session_data) struct sr_device_instance *sdi; struct ols_device *ols; GSList *l; - int count, buflen, num_channels, offset, i, j; - unsigned char byte, *buffer; + int num_channels, offset, i, j; + unsigned char byte; /* find this device's ols_device struct by its fd */ ols = NULL; @@ -660,52 +679,42 @@ static int receive_data(int fd, int revents, void *session_data) num_channels++; } - if (revents == G_IO_IN - && ols->num_transfers / num_channels <= ols->limit_samples) { + if (revents == G_IO_IN) { if (serial_read(fd, &byte, 1) != 1) return FALSE; + /* Ignore it if we've read enough. */ + if (ols->num_samples >= ols->limit_samples) + return TRUE; + ols->sample[ols->num_bytes++] = byte; sr_dbg("ols: received byte 0x%.2x", byte); if (ols->num_bytes == num_channels) { /* Got a full sample. */ sr_dbg("ols: received sample 0x%.*x", - ols->num_bytes * 2, (int) *ols->sample); + ols->num_bytes * 2, *(int *)ols->sample); if (ols->flag_reg & FLAG_RLE) { /* * In RLE mode -1 should never come in as a * sample, because bit 31 is the "count" flag. - * TODO: Endianness may be wrong here, could be - * sample[3]. */ - if (ols->sample[0] & 0x80 - && !(ols->last_sample[0] & 0x80)) { - count = (int)(*ols->sample) & 0x7fffffff; - if (!(buffer = g_try_malloc(count))) { - sr_err("ols: %s: buffer malloc " - "failed", __func__); - return FALSE; - } - - buflen = 0; - for (i = 0; i < count; i++) { - memcpy(buffer + buflen, ols->last_sample, 4); - buflen += 4; - } - } else { + if (ols->sample[ols->num_bytes - 1] & 0x80) { + ols->sample[ols->num_bytes - 1] &= 0x7f; /* - * Just a single sample, next sample - * will probably be a count referring - * to this -- but this one is still a - * part of the stream. + * FIXME: This will only work on + * little-endian systems. */ - buffer = ols->sample; - buflen = 4; + ols->rle_count = *(int *)(ols->sample); + sr_dbg("ols: RLE count = %d", ols->rle_count); + ols->num_bytes = 0; + return TRUE; } - } else { - /* No compression. */ - buffer = ols->sample; - buflen = 4; + } + ols->num_samples += ols->rle_count + 1; + if (ols->num_samples > ols->limit_samples) { + /* Save us from overrunning the buffer. */ + ols->rle_count -= ols->num_samples - ols->limit_samples; + ols->num_samples = ols->limit_samples; } if (num_channels < 4) { @@ -731,23 +740,21 @@ static int receive_data(int fd, int revents, void *session_data) } } memcpy(ols->sample, ols->tmp_sample, 4); - sr_dbg("ols: full sample 0x%.8x", (int) *ols->sample); + sr_dbg("ols: full sample 0x%.8x", *(int *)ols->sample); } /* the OLS sends its sample buffer backwards. * store it in reverse order here, so we can dump * this on the session bus later. */ - offset = (ols->limit_samples - ols->num_transfers / num_channels) * 4; - memcpy(ols->raw_sample_buf + offset, ols->sample, 4); - - if (buffer == ols->sample) - memcpy(ols->last_sample, buffer, num_channels); - else - g_free(buffer); - + offset = (ols->limit_samples - ols->num_samples) * 4; + for (i = 0; i <= ols->rle_count; i++) { + memcpy(ols->raw_sample_buf + offset + (i * 4), + ols->sample, 4); + } memset(ols->sample, 0, 4); ols->num_bytes = 0; + ols->rle_count = 0; } } else { /* @@ -767,7 +774,8 @@ static int receive_data(int fd, int revents, void *session_data) packet.payload = &logic; logic.length = ols->trigger_at * 4; logic.unitsize = 4; - logic.data = ols->raw_sample_buf; + logic.data = ols->raw_sample_buf + + (ols->limit_samples - ols->num_samples) * 4; sr_session_bus(session_data, &packet); } @@ -780,21 +788,23 @@ static int receive_data(int fd, int revents, void *session_data) /* send post-trigger samples */ packet.type = SR_DF_LOGIC; packet.timeoffset = ols->trigger_at * ols->period_ps; - packet.duration = (ols->limit_samples - ols->trigger_at) * ols->period_ps; + packet.duration = (ols->num_samples - ols->trigger_at) * ols->period_ps; packet.payload = &logic; - logic.length = (ols->limit_samples * 4) - (ols->trigger_at * 4); + logic.length = (ols->num_samples * 4) - (ols->trigger_at * 4); logic.unitsize = 4; - logic.data = ols->raw_sample_buf + ols->trigger_at * 4; + logic.data = ols->raw_sample_buf + ols->trigger_at * 4 + + (ols->limit_samples - ols->num_samples) * 4; sr_session_bus(session_data, &packet); } else { /* no trigger was used */ packet.type = SR_DF_LOGIC; packet.timeoffset = 0; - packet.duration = ols->limit_samples * ols->period_ps; + packet.duration = ols->num_samples * ols->period_ps; packet.payload = &logic; - logic.length = ols->limit_samples * 4; + logic.length = ols->num_samples * 4; logic.unitsize = 4; - logic.data = ols->raw_sample_buf; + logic.data = ols->raw_sample_buf + + (ols->limit_samples - ols->num_samples) * 4; sr_session_bus(session_data, &packet); } g_free(ols->raw_sample_buf); @@ -802,7 +812,7 @@ static int receive_data(int fd, int revents, void *session_data) serial_flush(fd); serial_close(fd); packet.type = SR_DF_END; - packet.timeoffset = ols->limit_samples * ols->period_ps; + packet.timeoffset = ols->num_samples * ols->period_ps; packet.duration = 0; sr_session_bus(session_data, &packet); } @@ -820,6 +830,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data) uint32_t data; uint16_t readcount, delaycount; uint8_t changrp_mask; + int num_channels; int i; if (!(sdi = sr_get_device_instance(device_instances, device_index))) @@ -830,7 +841,25 @@ static int hw_start_acquisition(int device_index, gpointer session_data) if (sdi->status != SR_ST_ACTIVE) return SR_ERR; - readcount = ols->limit_samples / 4; + /* + * Enable/disable channel groups in the flag register according to the + * probe mask. Calculate this here, because num_channels is needed + * to limit readcount. + */ + changrp_mask = 0; + num_channels = 0; + for (i = 0; i < 4; i++) { + if (ols->probe_mask & (0xff << (i * 8))) { + changrp_mask |= (1 << i); + num_channels++; + } + } + + /* + * Limit readcount to prevent reading past the end of the hardware + * buffer. + */ + readcount = MIN(ols->max_samples / num_channels, ols->limit_samples) / 4; memset(trigger_config, 0, 16); trigger_config[ols->num_stages - 1] |= 0x08; @@ -903,20 +932,11 @@ static int hw_start_acquisition(int device_index, gpointer session_data) if (send_longcommand(sdi->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK) return SR_ERR; - /* - * Enable/disable channel groups in the flag register according to the - * probe mask. - */ - changrp_mask = 0; - for (i = 0; i < 4; i++) { - if (ols->probe_mask & (0xff << (i * 8))) - changrp_mask |= (1 << i); - } - /* The flag register wants them here, and 1 means "disable channel". */ ols->flag_reg |= ~(changrp_mask << 2) & 0x3c; ols->flag_reg |= FLAG_FILTER; - data = ols->flag_reg << 24; + ols->rle_count = 0; + data = (ols->flag_reg << 24) | ((ols->flag_reg << 8) & 0xff0000); if (send_longcommand(sdi->serial->fd, CMD_SET_FLAGS, data) != SR_OK) return SR_ERR;