X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=hardware%2Fopenbench-logic-sniffer%2Fols.c;h=35db8402f7b64a99eebb24304c9ede8fe1f3437a;hb=6bb5c5fadfe011ae7797138fb9e9ade32edb0caf;hp=96e961ab9d22835cf79f0318b76b337c60979181;hpb=b53738baf76219237e0a6629905981d7a1f2508e;p=libsigrok.git diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c index 96e961ab..35db8402 100644 --- a/hardware/openbench-logic-sniffer/ols.c +++ b/hardware/openbench-logic-sniffer/ols.c @@ -46,12 +46,12 @@ #define O_NONBLOCK FIONBIO #endif - static int capabilities[] = { SR_HWCAP_LOGIC_ANALYZER, SR_HWCAP_SAMPLERATE, SR_HWCAP_CAPTURE_RATIO, SR_HWCAP_LIMIT_SAMPLES, + SR_HWCAP_RLE, 0, }; @@ -66,8 +66,6 @@ static struct sr_samplerates samplerates = { /* List of struct sr_serial_device_instance */ static GSList *device_instances = NULL; - - static int send_shortcommand(int fd, uint8_t command) { char buf[1]; @@ -174,6 +172,7 @@ static struct ols_device *ols_device_new(void) { struct ols_device *ols; + /* TODO: Is 'ols' ever g_free()'d? */ if (!(ols = g_try_malloc0(sizeof(struct ols_device)))) { sr_err("ols: %s: ols malloc failed", __func__); return NULL; @@ -182,6 +181,7 @@ static struct ols_device *ols_device_new(void) ols->trigger_at = -1; ols->probe_mask = 0xffffffff; ols->cur_samplerate = SR_KHZ(200); + ols->period_ps = 5000000; return ols; } @@ -311,7 +311,6 @@ static struct sr_device_instance *get_metadata(int fd) return sdi; } - static int hw_init(const char *deviceinfo) { struct sr_device_instance *sdi; @@ -321,6 +320,8 @@ static int hw_init(const char *deviceinfo) int devcnt, final_devcnt, num_ports, fd, ret, i; char buf[8], **device_names, **serial_params; + final_devcnt = 0; + if (deviceinfo) ports = g_slist_append(NULL, strdup(deviceinfo)); else @@ -328,9 +329,22 @@ static int hw_init(const char *deviceinfo) ports = list_serial_ports(); num_ports = g_slist_length(ports); - fds = calloc(1, num_ports * sizeof(GPollFD)); - device_names = malloc(num_ports * sizeof(char *)); - serial_params = malloc(num_ports * sizeof(char *)); + + if (!(fds = g_try_malloc0(num_ports * sizeof(GPollFD)))) { + sr_err("ols: %s: fds malloc failed", __func__); + goto hw_init_free_ports; /* TODO: SR_ERR_MALLOC. */ + } + + if (!(device_names = g_try_malloc(num_ports * sizeof(char *)))) { + sr_err("ols: %s: device_names malloc failed", __func__); + goto hw_init_free_fds; /* TODO: SR_ERR_MALLOC. */ + } + + if (!(serial_params = g_try_malloc(num_ports * sizeof(char *)))) { + sr_err("ols: %s: serial_params malloc failed", __func__); + goto hw_init_free_device_names; /* TODO: SR_ERR_MALLOC. */ + } + devcnt = 0; for (l = ports; l; l = l->next) { /* The discovery procedure is like this: first send the Reset @@ -374,7 +388,6 @@ static int hw_init(const char *deviceinfo) /* 2ms isn't enough for reliable transfer with pl2303, let's try 10 */ usleep(10000); - final_devcnt = 0; g_poll(fds, devcnt, 1); for (i = 0; i < devcnt; i++) { @@ -408,7 +421,6 @@ static int hw_init(const char *deviceinfo) final_devcnt++; serial_close(fds[i].fd); fds[i].fd = 0; - } /* clean up after all the probing */ @@ -421,9 +433,12 @@ static int hw_init(const char *deviceinfo) free(device_names[i]); } - free(fds); - free(device_names); - free(serial_params); + g_free(serial_params); +hw_init_free_device_names: + g_free(device_names); +hw_init_free_fds: + g_free(fds); +hw_init_free_ports: g_slist_free(ports); return final_devcnt; @@ -445,18 +460,23 @@ static int hw_opendev(int device_index) return SR_OK; } -static void hw_closedev(int device_index) +static int hw_closedev(int device_index) { struct sr_device_instance *sdi; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) - return; + if (!(sdi = sr_get_device_instance(device_instances, device_index))) { + sr_err("ols: %s: sdi was NULL", __func__); + return SR_ERR; /* TODO: SR_ERR_ARG? */ + } + /* TODO */ if (sdi->serial->fd != -1) { serial_close(sdi->serial->fd); sdi->serial->fd = -1; sdi->status = SR_ST_INACTIVE; } + + return SR_OK; } static void hw_cleanup(void) @@ -464,7 +484,7 @@ static void hw_cleanup(void) GSList *l; struct sr_device_instance *sdi; - /* Properly close all devices. */ + /* Properly close and free all devices. */ for (l = device_instances; l; l = l->next) { sdi = l->data; if (sdi->serial->fd != -1) @@ -534,7 +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; if (samplerate > CLOCK_RATE) { ols->flag_reg |= FLAG_DEMUX; ols->cur_samplerate_divider = (CLOCK_RATE * 2 / samplerate) - 1; @@ -543,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; } @@ -572,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; @@ -585,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; } @@ -592,14 +631,15 @@ static int hw_set_configuration(int device_index, int capability, void *value) return ret; } -static int receive_data(int fd, int revents, void *user_data) +static int receive_data(int fd, int revents, void *session_data) { struct sr_datafeed_packet packet; + struct sr_datafeed_logic logic; 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; @@ -622,8 +662,13 @@ static int receive_data(int fd, int revents, void *user_data) * finished. We'll double that to 30ms to be sure... */ sr_source_remove(fd); - sr_source_add(fd, G_IO_IN, 30, receive_data, user_data); - ols->raw_sample_buf = malloc(ols->limit_samples * 4); + sr_source_add(fd, G_IO_IN, 30, receive_data, session_data); + ols->raw_sample_buf = g_try_malloc(ols->limit_samples * 4); + if (!ols->raw_sample_buf) { + sr_err("ols: %s: ols->raw_sample_buf malloc failed", + __func__); + return FALSE; + } /* fill with 1010... for debugging */ memset(ols->raw_sample_buf, 0x82, ols->limit_samples * 4); } @@ -634,52 +679,42 @@ static int receive_data(int fd, int revents, void *user_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) { @@ -705,23 +740,21 @@ static int receive_data(int fd, int revents, void *user_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 { /* @@ -736,41 +769,58 @@ static int receive_data(int fd, int revents, void *user_data) if (ols->trigger_at > 0) { /* there are pre-trigger samples, send those first */ packet.type = SR_DF_LOGIC; - packet.length = ols->trigger_at * 4; - packet.unitsize = 4; - packet.payload = ols->raw_sample_buf; - sr_session_bus(user_data, &packet); + packet.timeoffset = 0; + packet.duration = ols->trigger_at * ols->period_ps; + packet.payload = &logic; + logic.length = ols->trigger_at * 4; + logic.unitsize = 4; + logic.data = ols->raw_sample_buf + + (ols->limit_samples - ols->num_samples) * 4; + sr_session_bus(session_data, &packet); } + /* send the trigger */ packet.type = SR_DF_TRIGGER; - packet.length = 0; - sr_session_bus(user_data, &packet); + packet.timeoffset = ols->trigger_at * ols->period_ps; + packet.duration = 0; + sr_session_bus(session_data, &packet); + /* send post-trigger samples */ packet.type = SR_DF_LOGIC; - packet.length = (ols->limit_samples * 4) - (ols->trigger_at * 4); - packet.unitsize = 4; - packet.payload = ols->raw_sample_buf + ols->trigger_at * 4; - sr_session_bus(user_data, &packet); + packet.timeoffset = ols->trigger_at * ols->period_ps; + packet.duration = (ols->num_samples - ols->trigger_at) * ols->period_ps; + packet.payload = &logic; + logic.length = (ols->num_samples * 4) - (ols->trigger_at * 4); + logic.unitsize = 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.length = ols->limit_samples * 4; - packet.unitsize = 4; - packet.payload = ols->raw_sample_buf; - sr_session_bus(user_data, &packet); + packet.timeoffset = 0; + packet.duration = ols->num_samples * ols->period_ps; + packet.payload = &logic; + logic.length = ols->num_samples * 4; + logic.unitsize = 4; + logic.data = ols->raw_sample_buf + + (ols->limit_samples - ols->num_samples) * 4; + sr_session_bus(session_data, &packet); } - free(ols->raw_sample_buf); + g_free(ols->raw_sample_buf); serial_flush(fd); serial_close(fd); packet.type = SR_DF_END; - packet.length = 0; - sr_session_bus(user_data, &packet); + packet.timeoffset = ols->num_samples * ols->period_ps; + packet.duration = 0; + sr_session_bus(session_data, &packet); } return TRUE; } -static int hw_start_acquisition(int device_index, gpointer session_device_id) +static int hw_start_acquisition(int device_index, gpointer session_data) { struct sr_datafeed_packet *packet; struct sr_datafeed_header *header; @@ -780,16 +830,36 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) 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))) return SR_ERR; + ols = sdi->priv; 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; @@ -862,20 +932,11 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) 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; @@ -884,7 +945,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) return SR_ERR; sr_source_add(sdi->serial->fd, G_IO_IN, -1, receive_data, - session_device_id); + session_data); if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) { sr_err("ols: %s: packet malloc failed", __func__); @@ -893,20 +954,20 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id) if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) { sr_err("ols: %s: header malloc failed", __func__); + g_free(packet); return SR_ERR_MALLOC; } /* Send header packet to the session bus. */ packet->type = SR_DF_HEADER; - packet->length = sizeof(struct sr_datafeed_header); packet->payload = (unsigned char *)header; header->feed_version = 1; gettimeofday(&header->starttime, NULL); header->samplerate = ols->cur_samplerate; - header->protocol_id = SR_PROTO_RAW; header->num_logic_probes = NUM_PROBES; header->num_analog_probes = 0; - sr_session_bus(session_device_id, packet); + sr_session_bus(session_data, packet); + g_free(header); g_free(packet); @@ -921,22 +982,21 @@ static void hw_stop_acquisition(int device_index, gpointer session_device_id) device_index = device_index; packet.type = SR_DF_END; - packet.length = 0; sr_session_bus(session_device_id, &packet); } struct sr_device_plugin ols_plugin_info = { - "ols", - "Openbench Logic Sniffer", - 1, - hw_init, - hw_cleanup, - hw_opendev, - hw_closedev, - hw_get_device_info, - hw_get_status, - hw_get_capabilities, - hw_set_configuration, - hw_start_acquisition, - hw_stop_acquisition, + .name = "ols", + .longname = "Openbench Logic Sniffer", + .api_version = 1, + .init = hw_init, + .cleanup = hw_cleanup, + .opendev = hw_opendev, + .closedev = hw_closedev, + .get_device_info = hw_get_device_info, + .get_status = hw_get_status, + .get_capabilities = hw_get_capabilities, + .set_configuration = hw_set_configuration, + .start_acquisition = hw_start_acquisition, + .stop_acquisition = hw_stop_acquisition, };