#include <ftdi.h>
#include <string.h>
#include <unistd.h>
-#include "libsigrok.h"
+#include <libsigrok/libsigrok.h>
#include "libsigrok-internal.h"
#include "asix-sigma.h"
#define USB_MODEL_NAME "SIGMA"
SR_PRIV struct sr_dev_driver asix_sigma_driver_info;
-static struct sr_dev_driver *di = &asix_sigma_driver_info;
static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
/*
"9", "10", "11", "12", "13", "14", "15", "16",
};
-static const int32_t hwcaps[] = {
+static const uint32_t drvopts[] = {
SR_CONF_LOGIC_ANALYZER,
- SR_CONF_SAMPLERATE,
- SR_CONF_TRIGGER_MATCH,
- SR_CONF_CAPTURE_RATIO,
- SR_CONF_LIMIT_MSEC,
+};
+
+static const uint32_t devopts[] = {
+ SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
+ SR_CONF_LIMIT_SAMPLES | SR_CONF_SET,
+ SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
+ SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
+ SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
};
static const int32_t trigger_matches[] = {
return ret;
}
+/*
+ * NOTE: We chose the buffer size to be large enough to hold any write to the
+ * device. We still print a message just in case.
+ */
static int sigma_write_register(uint8_t reg, uint8_t *data, size_t len,
struct dev_context *devc)
{
size_t i;
- uint8_t buf[len + 2];
+ uint8_t buf[80];
int idx = 0;
+ if ((len + 2) > sizeof(buf)) {
+ sr_err("Attempted to write %zu bytes, but buffer is too small.",
+ len + 2);
+ return SR_ERR_BUG;
+ }
+
buf[idx++] = REG_ADDR_LOW | (reg & 0xf);
buf[idx++] = REG_ADDR_HIGH | (reg >> 4);
/* Not really sure why this must be done, but according to spec. */
if ((--*stoppos & 0x1ff) == 0x1ff)
- stoppos -= 64;
+ *stoppos -= 64;
if ((*--triggerpos & 0x1ff) == 0x1ff)
- triggerpos -= 64;
+ *triggerpos -= 64;
return 1;
}
ftdi_deinit(&devc->ftdic);
}
-static int dev_clear(void)
+static int dev_clear(const struct sr_dev_driver *di)
{
return std_dev_clear(di, clear_helper);
}
-static int init(struct sr_context *sr_ctx)
+static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
{
return std_init(sr_ctx, di, LOG_PREFIX);
}
-static GSList *scan(GSList *options)
+static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
struct sr_dev_inst *sdi;
- struct sr_channel *ch;
struct drv_context *drvc;
struct dev_context *devc;
GSList *devices;
(void)options;
- drvc = di->priv;
+ drvc = di->context;
devices = NULL;
- if (!(devc = g_try_malloc(sizeof(struct dev_context)))) {
- sr_err("%s: devc malloc failed", __func__);
- return NULL;
- }
+ devc = g_malloc0(sizeof(struct dev_context));
ftdi_init(&devc->ftdic);
devc->use_triggers = 0;
/* Register SIGMA device. */
- if (!(sdi = sr_dev_inst_new(0, SR_ST_INITIALIZING, USB_VENDOR_NAME,
- USB_MODEL_NAME, NULL))) {
- sr_err("%s: sdi was NULL", __func__);
- goto free;
- }
+ sdi = g_malloc0(sizeof(struct sr_dev_inst));
+ sdi->status = SR_ST_INITIALIZING;
+ sdi->vendor = g_strdup(USB_VENDOR_NAME);
+ sdi->model = g_strdup(USB_MODEL_NAME);
sdi->driver = di;
- for (i = 0; i < ARRAY_SIZE(channel_names); i++) {
- ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE,
- channel_names[i]);
- if (!ch)
- return NULL;
- sdi->channels = g_slist_append(sdi->channels, ch);
- }
+ for (i = 0; i < ARRAY_SIZE(channel_names); i++)
+ sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_names[i]);
devices = g_slist_append(devices, sdi);
drvc->instances = g_slist_append(drvc->instances, sdi);
return NULL;
}
-static GSList *dev_list(void)
+static GSList *dev_list(const struct sr_dev_driver *di)
{
- return ((struct drv_context *)(di->priv))->instances;
+ return ((struct drv_context *)(di->context))->instances;
}
/*
0x01, 0x03, 0x03, 0x01, 0x01, 0x01, 0x01, 0x01,
0x01, 0x01,
};
- int i, ret, timeout = 10000;
+ int i, ret, timeout = (10 * 1000);
uint8_t data;
/* Section 2. part 1), do the FPGA suicide. */
if (data & (1 << 5))
return 0;
/* The D6 was not asserted yet, wait a bit. */
- usleep(10000);
+ g_usleep(10 * 1000);
}
return SR_ERR_TIMEOUT;
}
/* Four times the speed of sigmalogan - Works well. */
- ret = ftdi_set_baudrate(ftdic, 750000);
+ ret = ftdi_set_baudrate(ftdic, 750 * 1000);
if (ret < 0) {
sr_err("ftdi_set_baudrate failed: %s",
ftdi_get_error_string(ftdic));
/* Prepare firmware. */
ret = sigma_fw_2_bitbang(firmware, &buf, &buf_size);
if (ret != SR_OK) {
- sr_err("An error occured while reading the firmware: %s",
+ sr_err("An error occurred while reading the firmware: %s",
firmware);
return ret;
}
- /* Upload firmare. */
+ /* Upload firmware. */
sr_info("Uploading firmware file '%s'.", firmware);
sigma_write(buf, buf_size, devc);
}
}
-
return SR_OK;
}
return SR_OK;
}
-static int cleanup(void)
+static int cleanup(const struct sr_dev_driver *di)
{
- return dev_clear();
+ return dev_clear(di);
}
-static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi,
+static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
return SR_ERR;
devc = sdi->priv;
- switch (id) {
+ switch (key) {
case SR_CONF_SAMPLERATE:
*data = g_variant_new_uint64(devc->cur_samplerate);
break;
return SR_OK;
}
-static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,
+static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
struct dev_context *devc;
devc = sdi->priv;
ret = SR_OK;
- switch (id) {
+ switch (key) {
case SR_CONF_SAMPLERATE:
ret = set_samplerate(sdi, g_variant_get_uint64(data));
break;
return ret;
}
-static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi,
+static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const struct sr_channel_group *cg)
{
GVariant *gvar;
GVariantBuilder gvb;
- (void)sdi;
(void)cg;
switch (key) {
case SR_CONF_DEVICE_OPTIONS:
- *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
- hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
+ if (!sdi)
+ *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
+ drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
+ else
+ *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
+ devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
return i & 0x7;
}
-
/*
* Return the timestamp of "DRAM cluster".
*/
trigger_event);
}
- /* Find in which cluster the trigger occured. */
+ /* Find in which cluster the trigger occurred. */
trigger_cluster = trigger_event / EVENTS_PER_CLUSTER;
}
aset = (*mask >> i) & 1;
bset = x[b][a];
+ rset = 0;
if (func == FUNC_AND || func == FUNC_NAND)
rset = aset & bset;
else if (func == FUNC_OR || func == FUNC_NOR)
memset(lut, 0, sizeof(struct triggerlut));
- /* Contant for simple triggers. */
+ /* Constant for simple triggers. */
lut->m4 = 0xa000;
/* Value/mask trigger support. */
.dev_close = dev_close,
.dev_acquisition_start = dev_acquisition_start,
.dev_acquisition_stop = dev_acquisition_stop,
- .priv = NULL,
+ .context = NULL,
};
projects / libsigrok.git / blobdiff