X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fopenbench-logic-sniffer%2Fols.c;h=c322f789fd64f3e831fda864be0c05752782e984;hb=da1466d677afadcb17b12ebc1223ab0bdafe21db;hp=88e585f0d3c1f53a1cc88d3bf7e8a864b924306f;hpb=3a4d09c0de68c3ae9f287d243967431b8e3de0b7;p=libsigrok.git diff --git a/hardware/openbench-logic-sniffer/ols.c b/hardware/openbench-logic-sniffer/ols.c index 88e585f0..c322f789 100644 --- a/hardware/openbench-logic-sniffer/ols.c +++ b/hardware/openbench-logic-sniffer/ols.c @@ -1,7 +1,7 @@ /* * This file is part of the sigrok project. * - * Copyright (C) 2010 Bert Vermeulen + * Copyright (C) 2010-2012 Bert Vermeulen * * 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 @@ -38,8 +38,8 @@ #include #endif #include -#include -#include +#include "sigrok.h" +#include "sigrok-internal.h" #include "ols.h" #ifdef _WIN32 @@ -55,6 +55,42 @@ static int capabilities[] = { 0, }; +static const char *probe_names[NUM_PROBES + 1] = { + "0", + "1", + "2", + "3", + "4", + "5", + "6", + "7", + "8", + "9", + "10", + "11", + "12", + "13", + "14", + "15", + "16", + "17", + "18", + "19", + "20", + "21", + "22", + "23", + "24", + "25", + "26", + "27", + "28", + "29", + "30", + "31", + NULL, +}; + /* default supported samplerates, can be overridden by device metadata */ static struct sr_samplerates samplerates = { SR_HZ(10), @@ -181,7 +217,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; + ols->serial = NULL; return ols; } @@ -195,7 +231,7 @@ static struct sr_device_instance *get_metadata(int fd) GString *tmp_str, *devicename, *version; gchar tmp_c; - sdi = sr_device_instance_new(0, SR_ST_INACTIVE, NULL, NULL, NULL); + sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, NULL, NULL, NULL); ols = ols_device_new(); sdi->priv = ols; @@ -323,7 +359,7 @@ static int hw_init(const char *deviceinfo) final_devcnt = 0; if (deviceinfo) - ports = g_slist_append(NULL, strdup(deviceinfo)); + ports = g_slist_append(NULL, g_strdup(deviceinfo)); else /* No specific device given, so scan all serial ports. */ ports = list_serial_ports(); @@ -379,10 +415,10 @@ static int hw_init(const char *deviceinfo) send_shortcommand(fd, CMD_ID); fds[devcnt].fd = fd; fds[devcnt].events = G_IO_IN; - device_names[devcnt] = strdup(l->data); + device_names[devcnt] = g_strdup(l->data); devcnt++; } - free(l->data); + g_free(l->data); } /* 2ms isn't enough for reliable transfer with pl2303, let's try 10 */ @@ -410,13 +446,13 @@ static int hw_init(const char *deviceinfo) sdi->index = final_devcnt; } else { /* not an OLS -- some other board that uses the sump protocol */ - sdi = sr_device_instance_new(final_devcnt, SR_ST_INACTIVE, + sdi = sr_dev_inst_new(final_devcnt, SR_ST_INACTIVE, "Sump", "Logic Analyzer", "v1.0"); ols = ols_device_new(); ols->num_probes = 32; sdi->priv = ols; } - sdi->serial = sr_serial_device_instance_new(device_names[i], -1); + ols->serial = sr_serial_dev_inst_new(device_names[i], -1); device_instances = g_slist_append(device_instances, sdi); final_devcnt++; serial_close(fds[i].fd); @@ -429,8 +465,8 @@ static int hw_init(const char *deviceinfo) serial_restore_params(fds[i].fd, serial_params[i]); serial_close(fds[i].fd); } - free(serial_params[i]); - free(device_names[i]); + g_free(serial_params[i]); + g_free(device_names[i]); } g_free(serial_params); @@ -447,12 +483,15 @@ hw_init_free_ports: static int hw_opendev(int device_index) { struct sr_device_instance *sdi; + struct ols_device *ols; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) + if (!(sdi = sr_dev_inst_get(device_instances, device_index))) return SR_ERR; - sdi->serial->fd = serial_open(sdi->serial->port, O_RDWR); - if (sdi->serial->fd == -1) + ols = sdi->priv; + + ols->serial->fd = serial_open(ols->serial->port, O_RDWR); + if (ols->serial->fd == -1) return SR_ERR; sdi->status = SR_ST_ACTIVE; @@ -463,36 +502,57 @@ static int hw_opendev(int device_index) static int hw_closedev(int device_index) { struct sr_device_instance *sdi; + struct ols_device *ols; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) { + if (!(sdi = sr_dev_inst_get(device_instances, device_index))) { sr_err("ols: %s: sdi was NULL", __func__); return SR_ERR; /* TODO: SR_ERR_ARG? */ } + ols = sdi->priv; + /* TODO */ - if (sdi->serial->fd != -1) { - serial_close(sdi->serial->fd); - sdi->serial->fd = -1; + if (ols->serial->fd != -1) { + serial_close(ols->serial->fd); + ols->serial->fd = -1; sdi->status = SR_ST_INACTIVE; } return SR_OK; } -static void hw_cleanup(void) +static int hw_cleanup(void) { GSList *l; struct sr_device_instance *sdi; + struct ols_device *ols; + int ret = SR_OK; /* Properly close and free all devices. */ for (l = device_instances; l; l = l->next) { - sdi = l->data; - if (sdi->serial->fd != -1) - serial_close(sdi->serial->fd); - sr_device_instance_free(sdi); + if (!(sdi = l->data)) { + /* Log error, but continue cleaning up the rest. */ + sr_err("ols: %s: sdi was NULL, continuing", __func__); + ret = SR_ERR_BUG; + continue; + } + if (!(ols = sdi->priv)) { + /* Log error, but continue cleaning up the rest. */ + sr_err("ols: %s: sdi->priv was NULL, continuing", + __func__); + ret = SR_ERR_BUG; + continue; + } + /* TODO: Check for serial != NULL. */ + if (ols->serial->fd != -1) + serial_close(ols->serial->fd); + sr_serial_dev_inst_free(ols->serial); + sr_dev_inst_free(sdi); } g_slist_free(device_instances); device_instances = NULL; + + return ret; } static void *hw_get_device_info(int device_index, int device_info_id) @@ -501,7 +561,7 @@ static void *hw_get_device_info(int device_index, int device_info_id) struct ols_device *ols; void *info; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) + if (!(sdi = sr_dev_inst_get(device_instances, device_index))) return NULL; ols = sdi->priv; @@ -513,6 +573,9 @@ static void *hw_get_device_info(int device_index, int device_info_id) case SR_DI_NUM_PROBES: info = GINT_TO_POINTER(NUM_PROBES); break; + case SR_DI_PROBE_NAMES: + info = probe_names; + break; case SR_DI_SAMPLERATES: info = &samplerates; break; @@ -531,7 +594,7 @@ static int hw_get_status(int device_index) { struct sr_device_instance *sdi; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) + if (!(sdi = sr_dev_inst_get(device_instances, device_index))) return SR_ST_NOT_FOUND; return sdi->status; @@ -554,8 +617,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; @@ -564,6 +625,16 @@ 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; + if (ols->cur_samplerate != samplerate) + sr_err("ols: can't match samplerate %" PRIu64 ", using %" + PRIu64, samplerate, ols->cur_samplerate); + return SR_OK; } @@ -574,7 +645,7 @@ static int hw_set_configuration(int device_index, int capability, void *value) int ret; uint64_t *tmp_u64; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) + if (!(sdi = sr_dev_inst_get(device_instances, device_index))) return SR_ERR; ols = sdi->priv; @@ -593,9 +664,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"); - + if (*tmp_u64 > ols->max_samples) + sr_err("ols: sample limit exceeds hw max"); ols->limit_samples = *tmp_u64; sr_info("ols: sample limit %" PRIu64, ols->limit_samples); ret = SR_OK; @@ -610,7 +680,7 @@ static int hw_set_configuration(int device_index, int capability, void *value) ret = SR_OK; break; case SR_HWCAP_RLE: - if(strcmp(value, "on") == 0) { + if (GPOINTER_TO_INT(value)) { sr_info("ols: enabling RLE"); ols->flag_reg |= FLAG_RLE; } @@ -637,7 +707,7 @@ static int receive_data(int fd, int revents, void *session_data) ols = NULL; for (l = device_instances; l; l = l->next) { sdi = l->data; - if (sdi->serial->fd == fd) { + if (ols->serial->fd == fd) { ols = sdi->priv; break; } @@ -675,35 +745,36 @@ static int receive_data(int fd, int revents, void *session_data) 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; + /* 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. */ if (ols->sample[ols->num_bytes - 1] & 0x80) { - ols->sample[ols->num_bytes - 1] &= 0x7F; - /* FIXME: This will only work on - * little-endian systems + ols->sample[ols->num_bytes - 1] &= 0x7f; + /* + * FIXME: This will only work on + * little-endian systems. */ - ols->rle_count = *(int*)(ols->sample); + ols->rle_count = *(int *)(ols->sample); sr_dbg("ols: RLE count = %d", ols->rle_count); ols->num_bytes = 0; return TRUE; - } + } } ols->num_samples += ols->rle_count + 1; - if(ols->num_samples > ols->limit_samples) { - /* Save us from overrunning the buffer */ + 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; } @@ -731,7 +802,7 @@ 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. @@ -739,9 +810,10 @@ static int receive_data(int fd, int revents, void *session_data) * this on the session bus later. */ 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); - + 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; @@ -759,26 +831,20 @@ static int receive_data(int fd, int revents, void *session_data) if (ols->trigger_at > 0) { /* there are pre-trigger samples, send those first */ packet.type = SR_DF_LOGIC; - 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 + + 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.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.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; @@ -788,8 +854,6 @@ static int receive_data(int fd, int revents, void *session_data) } else { /* no trigger was used */ packet.type = SR_DF_LOGIC; - packet.timeoffset = 0; - packet.duration = ols->num_samples * ols->period_ps; packet.payload = &logic; logic.length = ols->num_samples * 4; logic.unitsize = 4; @@ -802,8 +866,6 @@ 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->num_samples * ols->period_ps; - packet.duration = 0; sr_session_bus(session_data, &packet); } @@ -823,7 +885,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data) int num_channels; int i; - if (!(sdi = sr_get_device_instance(device_instances, device_index))) + if (!(sdi = sr_dev_inst_get(device_instances, device_index))) return SR_ERR; ols = sdi->priv; @@ -833,7 +895,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data) /* * Enable/disable channel groups in the flag register according to the - * probe mask. Calculate this here, because num_channels is needed + * probe mask. Calculate this here, because num_channels is needed * to limit readcount. */ changrp_mask = 0; @@ -845,7 +907,8 @@ static int hw_start_acquisition(int device_index, gpointer session_data) } } - /* Limit readcount to prevent reading past the end of the hardware + /* + * Limit readcount to prevent reading past the end of the hardware * buffer. */ readcount = MIN(ols->max_samples / num_channels, ols->limit_samples) / 4; @@ -856,53 +919,53 @@ static int hw_start_acquisition(int device_index, gpointer session_data) delaycount = readcount * (1 - ols->capture_ratio / 100.0); ols->trigger_at = (readcount - delaycount) * 4 - ols->num_stages; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_0, reverse32(ols->trigger_mask[0])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_0, reverse32(ols->trigger_value[0])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_0, trigger_config[0]) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_1, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_1, reverse32(ols->trigger_mask[1])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_1, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_1, reverse32(ols->trigger_value[1])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_1, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_1, trigger_config[1]) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_2, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_2, reverse32(ols->trigger_mask[2])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_2, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_2, reverse32(ols->trigger_value[2])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_2, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_2, trigger_config[2]) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_3, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_3, reverse32(ols->trigger_mask[3])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_3, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_3, reverse32(ols->trigger_value[3])) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_3, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_3, trigger_config[3]) != SR_OK) return SR_ERR; } else { - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_MASK_0, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_MASK_0, ols->trigger_mask[0]) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_VALUE_0, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_VALUE_0, ols->trigger_value[0]) != SR_OK) return SR_ERR; - if (send_longcommand(sdi->serial->fd, CMD_SET_TRIGGER_CONFIG_0, + if (send_longcommand(ols->serial->fd, CMD_SET_TRIGGER_CONFIG_0, 0x00000008) != SR_OK) return SR_ERR; delaycount = readcount; @@ -911,14 +974,14 @@ static int hw_start_acquisition(int device_index, gpointer session_data) sr_info("ols: setting samplerate to %" PRIu64 " Hz (divider %u, " "demux %s)", ols->cur_samplerate, ols->cur_samplerate_divider, ols->flag_reg & FLAG_DEMUX ? "on" : "off"); - if (send_longcommand(sdi->serial->fd, CMD_SET_DIVIDER, + if (send_longcommand(ols->serial->fd, CMD_SET_DIVIDER, reverse32(ols->cur_samplerate_divider)) != SR_OK) return SR_ERR; /* Send sample limit and pre/post-trigger capture ratio. */ data = ((readcount - 1) & 0xffff) << 16; data |= (delaycount - 1) & 0xffff; - if (send_longcommand(sdi->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK) + if (send_longcommand(ols->serial->fd, CMD_CAPTURE_SIZE, reverse16(data)) != SR_OK) return SR_ERR; /* The flag register wants them here, and 1 means "disable channel". */ @@ -926,14 +989,14 @@ static int hw_start_acquisition(int device_index, gpointer session_data) ols->flag_reg |= FLAG_FILTER; 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) + if (send_longcommand(ols->serial->fd, CMD_SET_FLAGS, data) != SR_OK) return SR_ERR; /* Start acquisition on the device. */ - if (send_shortcommand(sdi->serial->fd, CMD_RUN) != SR_OK) + if (send_shortcommand(ols->serial->fd, CMD_RUN) != SR_OK) return SR_ERR; - sr_source_add(sdi->serial->fd, G_IO_IN, -1, receive_data, + sr_source_add(ols->serial->fd, G_IO_IN, -1, receive_data, session_data); if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) { @@ -954,7 +1017,6 @@ static int hw_start_acquisition(int device_index, gpointer session_data) gettimeofday(&header->starttime, NULL); header->samplerate = ols->cur_samplerate; header->num_logic_probes = NUM_PROBES; - header->num_analog_probes = 0; sr_session_bus(session_data, packet); g_free(header); @@ -963,18 +1025,20 @@ static int hw_start_acquisition(int device_index, gpointer session_data) return SR_OK; } -static void hw_stop_acquisition(int device_index, gpointer session_device_id) +static int hw_stop_acquisition(int device_index, gpointer session_device_id) { struct sr_datafeed_packet packet; /* Avoid compiler warnings. */ - device_index = device_index; + (void)device_index; packet.type = SR_DF_END; sr_session_bus(session_device_id, &packet); + + return SR_OK; } -struct sr_device_plugin ols_plugin_info = { +SR_PRIV struct sr_device_plugin ols_plugin_info = { .name = "ols", .longname = "Openbench Logic Sniffer", .api_version = 1,