BLAHAJ
/
libsigrok
10
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

sr/cli/gtk/qt: s/device/dev/ in many places. 

Also, a few s/instance/inst/ occurences.
This commit is contained in:
Uwe Hermann 2012-02-17 22:25:01 +01:00
parent d68e2d1a21
commit bb7ef79377
29 changed files with 570 additions and 576 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

117
device.c
View File

@ -22,7 +22,7 @@
#include "sigrok.h" #include "sigrok.h"
#include "sigrok-internal.h" #include "sigrok-internal.h"
static GSList *devices = NULL; static GSList *devs = NULL;
/** /**
* Scan the system for attached logic analyzers / devices. * Scan the system for attached logic analyzers / devices.
@ -60,7 +60,7 @@ static GSList *devices = NULL;
SR_API int sr_dev_scan(void) SR_API int sr_dev_scan(void)
{ {
GSList *plugins, *l; GSList *plugins, *l;
struct sr_device_plugin *plugin; struct sr_dev_plugin *plugin;
if (!(plugins = sr_hw_list())) { if (!(plugins = sr_hw_list())) {
sr_err("dev: %s: no supported devices/hwplugins", __func__); sr_err("dev: %s: no supported devices/hwplugins", __func__);
@ -93,10 +93,10 @@ SR_API int sr_dev_scan(void)
*/ */
SR_API GSList *sr_dev_list(void) SR_API GSList *sr_dev_list(void)
{ {
if (!devices) if (!devs)
sr_dev_scan(); sr_dev_scan();
return devices; return devs;
} }
/** /**
@ -119,23 +119,23 @@ SR_API GSList *sr_dev_list(void)
* *
* @return Pointer to the newly allocated device, or NULL upon errors. * @return Pointer to the newly allocated device, or NULL upon errors.
*/ */
SR_API struct sr_device *sr_dev_new(const struct sr_device_plugin *plugin, SR_API struct sr_dev *sr_dev_new(const struct sr_dev_plugin *plugin,
int plugin_index) int plugin_index)
{ {
struct sr_device *device; struct sr_dev *dev;
/* TODO: Check if plugin_index valid? */ /* TODO: Check if plugin_index valid? */
if (!(device = g_try_malloc0(sizeof(struct sr_device)))) { if (!(dev = g_try_malloc0(sizeof(struct sr_dev)))) {
sr_err("dev: %s: device malloc failed", __func__); sr_err("dev: %s: dev malloc failed", __func__);
return NULL; return NULL;
} }
device->plugin = (struct sr_device_plugin *)plugin; dev->plugin = (struct sr_dev_plugin *)plugin;
device->plugin_index = plugin_index; dev->plugin_index = plugin_index;
devices = g_slist_append(devices, device); devs = g_slist_append(devs, dev);
return device; return dev;
} }
/** /**
@ -151,22 +151,22 @@ SR_API struct sr_device *sr_dev_new(const struct sr_device_plugin *plugin,
* TODO: Error if the max. probe number for the specific LA is reached, e.g. * TODO: Error if the max. probe number for the specific LA is reached, e.g.
* if the caller tries to add more probes than the device actually has. * if the caller tries to add more probes than the device actually has.
* *
* @param device The device to which to add a probe with the specified name. * @param dev The device to which to add a probe with the specified name.
* Must not be NULL. * Must not be NULL.
* @param name The name of the probe to add to this device. Must not be NULL. * @param name The name of the probe to add to this device. Must not be NULL.
* TODO: Maximum length, allowed characters, etc. * TODO: Maximum length, allowed characters, etc.
* *
* @return SR_OK upon success, SR_ERR_MALLOC upon memory allocation errors, * @return SR_OK upon success, SR_ERR_MALLOC upon memory allocation errors,
* or SR_ERR_ARG upon invalid arguments. * or SR_ERR_ARG upon invalid arguments.
* If something other than SR_OK is returned, 'device' is unchanged. * If something other than SR_OK is returned, 'dev' is unchanged.
*/ */
SR_API int sr_dev_probe_add(struct sr_device *device, const char *name) SR_API int sr_dev_probe_add(struct sr_dev *dev, const char *name)
{ {
struct sr_probe *p; struct sr_probe *p;
int probenum; int probenum;
if (!device) { if (!dev) {
sr_err("dev: %s: device was NULL", __func__); sr_err("dev: %s: dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -177,7 +177,7 @@ SR_API int sr_dev_probe_add(struct sr_device *device, const char *name)
/* TODO: Further checks to ensure name is valid. */ /* TODO: Further checks to ensure name is valid. */
probenum = g_slist_length(device->probes) + 1; probenum = g_slist_length(dev->probes) + 1;
if (!(p = g_try_malloc0(sizeof(struct sr_probe)))) { if (!(p = g_try_malloc0(sizeof(struct sr_probe)))) {
sr_err("dev: %s: p malloc failed", __func__); sr_err("dev: %s: p malloc failed", __func__);
@ -188,7 +188,7 @@ SR_API int sr_dev_probe_add(struct sr_device *device, const char *name)
p->enabled = TRUE; p->enabled = TRUE;
p->name = g_strdup(name); p->name = g_strdup(name);
p->trigger = NULL; p->trigger = NULL;
device->probes = g_slist_append(device->probes, p); dev->probes = g_slist_append(dev->probes, p);
return SR_OK; return SR_OK;
} }
@ -198,7 +198,7 @@ SR_API int sr_dev_probe_add(struct sr_device *device, const char *name)
* *
* TODO * TODO
* *
* @param device TODO. Must not be NULL. * @param dev TODO. Must not be NULL.
* @param probenum The number of the probe whose 'struct sr_probe' we want. * @param probenum The number of the probe whose 'struct sr_probe' we want.
* Note that the probe numbers start at 1 (not 0!). * Note that the probe numbers start at 1 (not 0!).
* *
@ -208,21 +208,21 @@ SR_API int sr_dev_probe_add(struct sr_device *device, const char *name)
* @return A pointer to the requested probe's 'struct sr_probe', or NULL * @return A pointer to the requested probe's 'struct sr_probe', or NULL
* if the probe could not be found. * if the probe could not be found.
*/ */
SR_API struct sr_probe *sr_dev_probe_find(const struct sr_device *device, SR_API struct sr_probe *sr_dev_probe_find(const struct sr_dev *dev,
int probenum) int probenum)
{ {
GSList *l; GSList *l;
struct sr_probe *p, *found_probe; struct sr_probe *p, *found_probe;
if (!device) { if (!dev) {
sr_err("dev: %s: device was NULL", __func__); sr_err("dev: %s: dev was NULL", __func__);
return NULL; /* TODO: SR_ERR_ARG */ return NULL; /* TODO: SR_ERR_ARG */
} }
/* TODO: Sanity check on probenum. */ /* TODO: Sanity check on probenum. */
found_probe = NULL; found_probe = NULL;
for (l = device->probes; l; l = l->next) { for (l = dev->probes; l; l = l->next) {
p = l->data; p = l->data;
/* TODO: Check for p != NULL. */ /* TODO: Check for p != NULL. */
if (p->index == probenum) { if (p->index == probenum) {
@ -240,28 +240,28 @@ SR_API struct sr_probe *sr_dev_probe_find(const struct sr_device *device,
* If the probe already has a different name assigned to it, it will be * If the probe already has a different name assigned to it, it will be
* removed, and the new name will be saved instead. * removed, and the new name will be saved instead.
* *
* TODO: Rename to sr_device_set_probe_name(). * TODO: Rename to sr_dev_probe_name_set().
* *
* @param device TODO * @param dev TODO
* @param probenum The number of the probe whose name to set. * @param probenum The number of the probe whose name to set.
* Note that the probe numbers start at 1 (not 0!). * Note that the probe numbers start at 1 (not 0!).
* @param name The new name that the specified probe should get. * @param name The new name that the specified probe should get.
* *
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
* upon other errors. * upon other errors.
* If something other than SR_OK is returned, 'device' is unchanged. * If something other than SR_OK is returned, 'dev' is unchanged.
*/ */
SR_API int sr_dev_probe_name(struct sr_device *device, int probenum, SR_API int sr_dev_probe_name(struct sr_dev *dev, int probenum,
const char *name) const char *name)
{ {
struct sr_probe *p; struct sr_probe *p;
if (!device) { if (!dev) {
sr_err("dev: %s: device was NULL", __func__); sr_err("dev: %s: dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
p = sr_dev_probe_find(device, probenum); p = sr_dev_probe_find(dev, probenum);
if (!p) { if (!p) {
sr_err("dev: %s: probe %d not found", __func__, probenum); sr_err("dev: %s: probe %d not found", __func__, probenum);
return SR_ERR; /* TODO: More specific error? */ return SR_ERR; /* TODO: More specific error? */
@ -282,28 +282,28 @@ SR_API int sr_dev_probe_name(struct sr_device *device, int probenum,
* *
* TODO: Better description. * TODO: Better description.
* *
* @param device TODO * @param dev TODO
* *
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments. * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
* If something other than SR_OK is returned, 'device' is unchanged. * If something other than SR_OK is returned, 'dev' is unchanged.
*/ */
SR_API int sr_dev_trigger_clear(struct sr_device *device) SR_API int sr_dev_trigger_clear(struct sr_dev *dev)
{ {
struct sr_probe *p; struct sr_probe *p;
unsigned int pnum; /* TODO: uint16_t? */ unsigned int pnum; /* TODO: uint16_t? */
if (!device) { if (!dev) {
sr_err("dev: %s: device was NULL", __func__); sr_err("dev: %s: dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!device->probes) { if (!dev->probes) {
sr_err("dev: %s: device->probes was NULL", __func__); sr_err("dev: %s: dev->probes was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
for (pnum = 1; pnum <= g_slist_length(device->probes); pnum++) { for (pnum = 1; pnum <= g_slist_length(dev->probes); pnum++) {
p = sr_dev_probe_find(device, pnum); p = sr_dev_probe_find(dev, pnum);
/* TODO: Silently ignore probes which cannot be found? */ /* TODO: Silently ignore probes which cannot be found? */
if (p) { if (p) {
g_free(p->trigger); g_free(p->trigger);
@ -320,7 +320,7 @@ SR_API int sr_dev_trigger_clear(struct sr_device *device)
* TODO: Better description. * TODO: Better description.
* TODO: Describe valid format of the 'trigger' string. * TODO: Describe valid format of the 'trigger' string.
* *
* @param device TODO. Must not be NULL. * @param dev TODO. Must not be NULL.
* @param probenum The number of the probe. TODO. * @param probenum The number of the probe. TODO.
* Note that the probe numbers start at 1 (not 0!). * Note that the probe numbers start at 1 (not 0!).
* @param trigger TODO. * @param trigger TODO.
@ -328,15 +328,15 @@ SR_API int sr_dev_trigger_clear(struct sr_device *device)
* *
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
* upon other errors. * upon other errors.
* If something other than SR_OK is returned, 'device' is unchanged. * If something other than SR_OK is returned, 'dev' is unchanged.
*/ */
SR_API int sr_dev_trigger_set(struct sr_device *device, int probenum, SR_API int sr_dev_trigger_set(struct sr_dev *dev, int probenum,
const char *trigger) const char *trigger)
{ {
struct sr_probe *p; struct sr_probe *p;
if (!device) { if (!dev) {
sr_err("dev: %s: device was NULL", __func__); sr_err("dev: %s: dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -344,7 +344,7 @@ SR_API int sr_dev_trigger_set(struct sr_device *device, int probenum,
/* TODO: Sanity check on 'trigger'. */ /* TODO: Sanity check on 'trigger'. */
p = sr_dev_probe_find(device, probenum); p = sr_dev_probe_find(dev, probenum);
if (!p) { if (!p) {
sr_err("dev: %s: probe %d not found", __func__, probenum); sr_err("dev: %s: probe %d not found", __func__, probenum);
return SR_ERR; /* TODO: More specific error? */ return SR_ERR; /* TODO: More specific error? */
@ -363,7 +363,7 @@ SR_API int sr_dev_trigger_set(struct sr_device *device, int probenum,
* *
* TODO: Should return int? * TODO: Should return int?
* *
* @param device Pointer to the device to be checked. Must not be NULL. * @param dev Pointer to the device to be checked. Must not be NULL.
* The device's 'plugin' field must not be NULL either. * The device's 'plugin' field must not be NULL either.
* @param hwcap The capability that should be checked (whether it's supported * @param hwcap The capability that should be checked (whether it's supported
* by the specified device). * by the specified device).
@ -372,24 +372,24 @@ SR_API int sr_dev_trigger_set(struct sr_device *device, int probenum,
* FALSE is also returned upon invalid input parameters or other * FALSE is also returned upon invalid input parameters or other
* error conditions. * error conditions.
*/ */
SR_API gboolean sr_dev_has_hwcap(const struct sr_device *device, int hwcap) SR_API gboolean sr_dev_has_hwcap(const struct sr_dev *dev, int hwcap)
{ {
int *capabilities, i; int *capabilities, i;
if (!device) { if (!dev) {
sr_err("dev: %s: device was NULL", __func__); sr_err("dev: %s: dev was NULL", __func__);
return FALSE; /* TODO: SR_ERR_ARG. */ return FALSE; /* TODO: SR_ERR_ARG. */
} }
if (!device->plugin) { if (!dev->plugin) {
sr_err("dev: %s: device->plugin was NULL", __func__); sr_err("dev: %s: dev->plugin was NULL", __func__);
return FALSE; /* TODO: SR_ERR_ARG. */ return FALSE; /* TODO: SR_ERR_ARG. */
} }
/* TODO: Sanity check on 'hwcap'. */ /* TODO: Sanity check on 'hwcap'. */
if (!(capabilities = device->plugin->get_capabilities())) { if (!(capabilities = dev->plugin->get_capabilities())) {
sr_err("dev: %s: device has no capabilities", __func__); sr_err("dev: %s: dev has no capabilities", __func__);
return FALSE; /* TODO: SR_ERR*. */ return FALSE; /* TODO: SR_ERR*. */
} }
@ -408,7 +408,7 @@ SR_API gboolean sr_dev_has_hwcap(const struct sr_device *device, int hwcap)
/** /**
* Returns information about the given device. * Returns information about the given device.
* *
* @param device Pointer to the device to be checked. Must not be NULL. * @param dev Pointer to the device to be checked. Must not be NULL.
* The device's 'plugin' field must not be NULL either. * The device's 'plugin' field must not be NULL either.
* @param id The type of information. * @param id The type of information.
* @param data The return value. Must not be NULL. * @param data The return value. Must not be NULL.
@ -416,16 +416,15 @@ SR_API gboolean sr_dev_has_hwcap(const struct sr_device *device, int hwcap)
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or SR_ERR
* upon other errors. * upon other errors.
*/ */
SR_API int sr_dev_info_get(const struct sr_device *device, int id, SR_API int sr_dev_info_get(const struct sr_dev *dev, int id, const void **data)
const void **data)
{ {
if ((device == NULL) || (device->plugin == NULL)) if ((dev == NULL) || (dev->plugin == NULL))
return SR_ERR_ARG; return SR_ERR_ARG;
if (data == NULL) if (data == NULL)
return SR_ERR_ARG; return SR_ERR_ARG;
*data = device->plugin->get_device_info(device->plugin_index, id); *data = dev->plugin->get_dev_info(dev->plugin_index, id);
if (*data == NULL) if (*data == NULL)
return SR_ERR; return SR_ERR;

44
hardware/alsa/alsa.c
View File

@ -64,13 +64,13 @@ struct alsa {
gpointer session_id; gpointer session_id;
}; };
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct alsa *alsa; struct alsa *alsa;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
deviceinfo = deviceinfo; devinfo = devinfo;
if (!(alsa = g_try_malloc0(sizeof(struct alsa)))) { if (!(alsa = g_try_malloc0(sizeof(struct alsa)))) {
sr_err("alsa: %s: alsa malloc failed", __func__); sr_err("alsa: %s: alsa malloc failed", __func__);
@ -91,13 +91,13 @@ free_alsa:
return 0; return 0;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct alsa *alsa; struct alsa *alsa;
int err; int err;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
alsa = sdi->priv; alsa = sdi->priv;
@ -126,12 +126,12 @@ static int hw_opendev(int device_index)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct alsa *alsa; struct alsa *alsa;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("alsa: %s: sdi was NULL", __func__); sr_err("alsa: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -164,17 +164,17 @@ static int hw_cleanup(void)
return SR_OK; return SR_OK;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct alsa *alsa; struct alsa *alsa;
void *info = NULL; void *info = NULL;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return NULL; return NULL;
alsa = sdi->priv; alsa = sdi->priv;
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -195,10 +195,10 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
device_index = device_index; dev_index = dev_index;
return SR_ST_ACTIVE; return SR_ST_ACTIVE;
} }
@ -208,12 +208,12 @@ static int *hw_get_capabilities(void)
return capabilities; return capabilities;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct alsa *alsa; struct alsa *alsa;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
alsa = sdi->priv; alsa = sdi->priv;
@ -289,7 +289,7 @@ static int receive_data(int fd, int revents, void *user_data)
return TRUE; return TRUE;
} }
static int hw_start_acquisition(int device_index, gpointer session_device_id) static int hw_start_acquisition(int dev_index, gpointer session_dev_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct alsa *alsa; struct alsa *alsa;
@ -299,7 +299,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
int count; int count;
int err; int err;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
alsa = sdi->priv; alsa = sdi->priv;
@ -364,7 +364,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
return SR_ERR; return SR_ERR;
} }
alsa->session_id = session_device_id; alsa->session_id = session_dev_id;
sr_source_add(ufds[0].fd, ufds[0].events, 10, receive_data, sdi); sr_source_add(ufds[0].fd, ufds[0].events, 10, receive_data, sdi);
packet.type = SR_DF_HEADER; packet.type = SR_DF_HEADER;
@ -376,22 +376,22 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
header.num_analog_probes = NUM_PROBES; header.num_analog_probes = NUM_PROBES;
header.num_logic_probes = 0; header.num_logic_probes = 0;
header.protocol_id = SR_PROTO_RAW; header.protocol_id = SR_PROTO_RAW;
sr_session_bus(session_device_id, &packet); sr_session_bus(session_dev_id, &packet);
g_free(ufds); g_free(ufds);
return SR_OK; return SR_OK;
} }
static int hw_stop_acquisition(int device_index, gpointer session_device_id) static int hw_stop_acquisition(int dev_index, gpointer session_dev_id)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
device_index = device_index; dev_index = dev_index;
session_device_id = session_device_id; session_dev_id = session_dev_id;
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin alsa_plugin_info = { SR_PRIV struct sr_dev_plugin alsa_plugin_info = {
.name = "alsa", .name = "alsa",
.longname = "ALSA driver", .longname = "ALSA driver",
.api_version = 1, .api_version = 1,
@ -399,7 +399,7 @@ SR_PRIV struct sr_device_plugin alsa_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

40
hardware/asix-sigma/asix-sigma.c
View File

@ -118,7 +118,7 @@ static const char *firmware_files[] = {
"asix-sigma-phasor.fw", /* Frequency counter */ "asix-sigma-phasor.fw", /* Frequency counter */
}; };
static int hw_stop_acquisition(int device_index, gpointer session_data); static int hw_stop_acquisition(int dev_index, gpointer session_data);
static int sigma_read(void *buf, size_t size, struct sigma *sigma) static int sigma_read(void *buf, size_t size, struct sigma *sigma)
{ {
@ -415,13 +415,13 @@ static int bin2bitbang(const char *filename,
return SR_OK; return SR_OK;
} }
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)deviceinfo; (void)devinfo;
if (!(sigma = g_try_malloc(sizeof(struct sigma)))) { if (!(sigma = g_try_malloc(sizeof(struct sigma)))) {
sr_err("sigma: %s: sigma malloc failed", __func__); sr_err("sigma: %s: sigma malloc failed", __func__);
@ -555,13 +555,13 @@ static int upload_firmware(int firmware_idx, struct sigma *sigma)
return SR_OK; return SR_OK;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
int ret; int ret;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
sigma = sdi->priv; sigma = sdi->priv;
@ -698,12 +698,12 @@ static int configure_probes(struct sr_dev_inst *sdi, GSList *probes)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("sigma: %s: sdi was NULL", __func__); sr_err("sigma: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -744,20 +744,20 @@ static int hw_cleanup(void)
return ret; return ret;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
void *info = NULL; void *info = NULL;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("sigma: %s: sdi was NULL", __func__); sr_err("sigma: %s: sdi was NULL", __func__);
return NULL; return NULL;
} }
sigma = sdi->priv; sigma = sdi->priv;
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -781,11 +781,11 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
sdi = sr_dev_inst_get(dev_insts, device_index); sdi = sr_dev_inst_get(dev_insts, dev_index);
if (sdi) if (sdi)
return sdi->status; return sdi->status;
else else
@ -797,13 +797,13 @@ static int *hw_get_capabilities(void)
return capabilities; return capabilities;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
int ret; int ret;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
sigma = sdi->priv; sigma = sdi->priv;
@ -1252,7 +1252,7 @@ static int build_basic_trigger(struct triggerlut *lut, struct sigma *sigma)
return SR_OK; return SR_OK;
} }
static int hw_start_acquisition(int device_index, gpointer session_data) static int hw_start_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
@ -1267,7 +1267,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)session_data; (void)session_data;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
sigma = sdi->priv; sigma = sdi->priv;
@ -1369,7 +1369,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
static int hw_stop_acquisition(int device_index, gpointer session_data) static int hw_stop_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sigma *sigma; struct sigma *sigma;
@ -1378,7 +1378,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)session_data; (void)session_data;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("sigma: %s: sdi was NULL", __func__); sr_err("sigma: %s: sdi was NULL", __func__);
return SR_ERR_BUG; return SR_ERR_BUG;
} }
@ -1411,7 +1411,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin asix_sigma_plugin_info = { SR_PRIV struct sr_dev_plugin asix_sigma_plugin_info = {
.name = "asix-sigma", .name = "asix-sigma",
.longname = "ASIX SIGMA", .longname = "ASIX SIGMA",
.api_version = 1, .api_version = 1,
@ -1419,7 +1419,7 @@ SR_PRIV struct sr_device_plugin asix_sigma_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

42
hardware/chronovu-la8/chronovu-la8.c
View File

@ -111,7 +111,7 @@ struct la8 {
uint8_t divcount; uint8_t divcount;
}; };
/* This will be initialized via hw_get_device_info()/SR_DI_SAMPLERATES. */ /* This will be initialized via hw_get_dev_info()/SR_DI_SAMPLERATES. */
static uint64_t supported_samplerates[255 + 1] = { 0 }; static uint64_t supported_samplerates[255 + 1] = { 0 };
/* /*
@ -136,7 +136,7 @@ static int capabilities[] = {
/* Function prototypes. */ /* Function prototypes. */
static int la8_close_usb_reset_sequencer(struct la8 *la8); static int la8_close_usb_reset_sequencer(struct la8 *la8);
static int hw_stop_acquisition(int device_index, gpointer session_data); static int hw_stop_acquisition(int dev_index, gpointer session_data);
static int la8_reset(struct la8 *la8); static int la8_reset(struct la8 *la8);
static void fill_supported_samplerates_if_needed(void) static void fill_supported_samplerates_if_needed(void)
@ -467,14 +467,14 @@ static int configure_probes(struct la8 *la8, GSList *probes)
return SR_OK; return SR_OK;
} }
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
int ret; int ret;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
/* Avoid compiler errors. */ /* Avoid compiler errors. */
(void)deviceinfo; (void)devinfo;
/* Allocate memory for our private driver context. */ /* Allocate memory for our private driver context. */
if (!(la8 = g_try_malloc(sizeof(struct la8)))) { if (!(la8 = g_try_malloc(sizeof(struct la8)))) {
@ -550,13 +550,13 @@ err_free_nothing:
return 0; return 0;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
int ret; int ret;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL", __func__); sr_err("la8: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -638,12 +638,12 @@ static int set_samplerate(struct sr_dev_inst *sdi, uint64_t samplerate)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL", __func__); sr_err("la8: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -693,7 +693,7 @@ static int hw_cleanup(void)
return ret; return ret;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
@ -701,7 +701,7 @@ static void *hw_get_device_info(int device_index, int device_info_id)
sr_spew("la8: entering %s", __func__); sr_spew("la8: entering %s", __func__);
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL", __func__); sr_err("la8: %s: sdi was NULL", __func__);
return NULL; return NULL;
} }
@ -711,7 +711,7 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return NULL; return NULL;
} }
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -741,11 +741,11 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL, device not found", __func__); sr_err("la8: %s: sdi was NULL, device not found", __func__);
return SR_ST_NOT_FOUND; return SR_ST_NOT_FOUND;
} }
@ -762,14 +762,14 @@ static int *hw_get_capabilities(void)
return capabilities; return capabilities;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
sr_spew("la8: entering %s", __func__); sr_spew("la8: entering %s", __func__);
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL", __func__); sr_err("la8: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -1012,7 +1012,7 @@ static int receive_data(int fd, int revents, void *session_data)
return TRUE; return TRUE;
} }
static int hw_start_acquisition(int device_index, gpointer session_data) static int hw_start_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
@ -1023,7 +1023,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
sr_spew("la8: entering %s", __func__); sr_spew("la8: entering %s", __func__);
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL", __func__); sr_err("la8: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -1087,7 +1087,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
static int hw_stop_acquisition(int device_index, gpointer session_data) static int hw_stop_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct la8 *la8; struct la8 *la8;
@ -1095,7 +1095,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
sr_dbg("la8: stopping acquisition"); sr_dbg("la8: stopping acquisition");
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("la8: %s: sdi was NULL", __func__); sr_err("la8: %s: sdi was NULL", __func__);
return SR_ERR_BUG; return SR_ERR_BUG;
} }
@ -1113,7 +1113,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin chronovu_la8_plugin_info = { SR_PRIV struct sr_dev_plugin chronovu_la8_plugin_info = {
.name = "chronovu-la8", .name = "chronovu-la8",
.longname = "ChronoVu LA8", .longname = "ChronoVu LA8",
.api_version = 1, .api_version = 1,
@ -1121,7 +1121,7 @@ SR_PRIV struct sr_device_plugin chronovu_la8_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

44
hardware/demo/demo.c
View File

@ -71,14 +71,14 @@ struct databag {
uint8_t sample_generator; uint8_t sample_generator;
uint8_t thread_running; uint8_t thread_running;
uint64_t samples_counter; uint64_t samples_counter;
int device_index; int dev_index;
gpointer session_data; gpointer session_data;
GTimer *timer; GTimer *timer;
}; };
static int capabilities[] = { static int capabilities[] = {
SR_HWCAP_LOGIC_ANALYZER, SR_HWCAP_LOGIC_ANALYZER,
SR_HWCAP_DEMO_DEVICE, SR_HWCAP_DEMO_DEV,
SR_HWCAP_SAMPLERATE, SR_HWCAP_SAMPLERATE,
SR_HWCAP_PATTERN_MODE, SR_HWCAP_PATTERN_MODE,
SR_HWCAP_LIMIT_SAMPLES, SR_HWCAP_LIMIT_SAMPLES,
@ -134,14 +134,14 @@ static int default_pattern = PATTERN_SIGROK;
static GThread *my_thread; static GThread *my_thread;
static int thread_running; static int thread_running;
static int hw_stop_acquisition(int device_index, gpointer session_data); static int hw_stop_acquisition(int dev_index, gpointer session_data);
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)deviceinfo; (void)devinfo;
sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL); sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL);
if (!sdi) { if (!sdi) {
@ -154,20 +154,20 @@ static int hw_init(const char *deviceinfo)
return 1; return 1;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
/* Nothing needed so far. */ /* Nothing needed so far. */
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
/* Nothing needed so far. */ /* Nothing needed so far. */
@ -180,17 +180,17 @@ static int hw_cleanup(void)
return SR_OK; return SR_OK;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
void *info = NULL; void *info = NULL;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("demo: %s: sdi was NULL", __func__); sr_err("demo: %s: sdi was NULL", __func__);
return NULL; return NULL;
} }
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -214,10 +214,10 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
return SR_ST_ACTIVE; return SR_ST_ACTIVE;
} }
@ -227,13 +227,13 @@ static int *hw_get_capabilities(void)
return capabilities; return capabilities;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
int ret; int ret;
char *stropt; char *stropt;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
if (capability == SR_HWCAP_PROBECONFIG) { if (capability == SR_HWCAP_PROBECONFIG) {
/* Nothing to do, but must be supported */ /* Nothing to do, but must be supported */
@ -405,7 +405,7 @@ static int receive_data(int fd, int revents, void *session_data)
return TRUE; return TRUE;
} }
static int hw_start_acquisition(int device_index, gpointer session_data) static int hw_start_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_datafeed_packet *packet; struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header; struct sr_datafeed_header *header;
@ -419,7 +419,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
mydata->sample_generator = default_pattern; mydata->sample_generator = default_pattern;
mydata->session_data = session_data; mydata->session_data = session_data;
mydata->device_index = device_index; mydata->dev_index = dev_index;
mydata->samples_counter = 0; mydata->samples_counter = 0;
if (pipe(mydata->pipe_fds)) { if (pipe(mydata->pipe_fds)) {
@ -477,10 +477,10 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
static int hw_stop_acquisition(int device_index, gpointer session_data) static int hw_stop_acquisition(int dev_index, gpointer session_data)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
(void)session_data; (void)session_data;
/* Stop generate thread. */ /* Stop generate thread. */
@ -489,7 +489,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin demo_plugin_info = { SR_PRIV struct sr_dev_plugin demo_plugin_info = {
.name = "demo", .name = "demo",
.longname = "Demo driver and pattern generator", .longname = "Demo driver and pattern generator",
.api_version = 1, .api_version = 1,
@ -497,7 +497,7 @@ SR_PRIV struct sr_device_plugin demo_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

50
hardware/link-mso19/link-mso19.c
View File

@ -396,16 +396,16 @@ static int mso_parse_serial(const char *iSerial, const char *iProduct,
return SR_OK; return SR_OK;
} }
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
int devcnt = 0; int devcnt = 0;
struct udev *udev; struct udev *udev;
struct udev_enumerate *enumerate; struct udev_enumerate *enumerate;
struct udev_list_entry *devices, *dev_list_entry; struct udev_list_entry *devs, *dev_list_entry;
struct mso *mso; struct mso *mso;
deviceinfo = deviceinfo; devinfo = devinfo;
/* It's easier to map usb<->serial using udev */ /* It's easier to map usb<->serial using udev */
/* /*
@ -420,8 +420,8 @@ static int hw_init(const char *deviceinfo)
enumerate = udev_enumerate_new(udev); enumerate = udev_enumerate_new(udev);
udev_enumerate_add_match_subsystem(enumerate, "usb-serial"); udev_enumerate_add_match_subsystem(enumerate, "usb-serial");
udev_enumerate_scan_devices(enumerate); udev_enumerate_scan_devices(enumerate);
devices = udev_enumerate_get_list_entry(enumerate); devs = udev_enumerate_get_list_entry(enumerate);
udev_list_entry_foreach(dev_list_entry, devices) { udev_list_entry_foreach(dev_list_entry, devs) {
const char *syspath, *sysname, *idVendor, *idProduct, const char *syspath, *sysname, *idVendor, *idProduct,
*iSerial, *iProduct; *iSerial, *iProduct;
char path[32], manufacturer[32], product[32], hwrev[32]; char path[32], manufacturer[32], product[32], hwrev[32];
@ -540,13 +540,13 @@ static int hw_cleanup(void)
return ret; return ret;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct mso *mso; struct mso *mso;
int ret = SR_ERR; int ret = SR_ERR;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return ret; return ret;
mso = sdi->priv; mso = sdi->priv;
@ -582,11 +582,11 @@ static int hw_opendev(int device_index)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("mso19: %s: sdi was NULL", __func__); sr_err("mso19: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -602,17 +602,17 @@ static int hw_closedev(int device_index)
return SR_OK; return SR_OK;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct mso *mso; struct mso *mso;
void *info = NULL; void *info = NULL;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return NULL; return NULL;
mso = sdi->priv; mso = sdi->priv;
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -635,11 +635,11 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ST_NOT_FOUND; return SR_ST_NOT_FOUND;
return sdi->status; return sdi->status;
@ -650,11 +650,11 @@ static int *hw_get_capabilities(void)
return capabilities; return capabilities;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
switch (capability) { switch (capability) {
@ -743,7 +743,7 @@ static int receive_data(int fd, int revents, void *user_data)
return TRUE; return TRUE;
} }
static int hw_start_acquisition(int device_index, gpointer session_device_id) static int hw_start_acquisition(int dev_index, gpointer session_dev_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct mso *mso; struct mso *mso;
@ -751,7 +751,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
struct sr_datafeed_header header; struct sr_datafeed_header header;
int ret = SR_ERR; int ret = SR_ERR;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return ret; return ret;
mso = sdi->priv; mso = sdi->priv;
@ -801,7 +801,7 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
if (ret != SR_OK) if (ret != SR_OK)
return ret; return ret;
mso->session_id = session_device_id; mso->session_id = session_dev_id;
sr_source_add(sdi->serial->fd, G_IO_IN, -1, receive_data, sdi); sr_source_add(sdi->serial->fd, G_IO_IN, -1, receive_data, sdi);
packet.type = SR_DF_HEADER; packet.type = SR_DF_HEADER;
@ -811,25 +811,25 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
header.samplerate = mso->cur_rate; header.samplerate = mso->cur_rate;
// header.num_analog_probes = 1; // header.num_analog_probes = 1;
header.num_logic_probes = 8; header.num_logic_probes = 8;
sr_session_bus(session_device_id, &packet); sr_session_bus(session_dev_id, &packet);
return ret; return ret;
} }
/* FIXME */ /* FIXME */
static int hw_stop_acquisition(int device_index, gpointer session_device_id) static int hw_stop_acquisition(int dev_index, gpointer session_dev_id)
{ {
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
device_index = device_index; dev_index = dev_index;
packet.type = SR_DF_END; packet.type = SR_DF_END;
sr_session_bus(session_device_id, &packet); sr_session_bus(session_dev_id, &packet);
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin link_mso19_plugin_info = { SR_PRIV struct sr_dev_plugin link_mso19_plugin_info = {
.name = "link-mso19", .name = "link-mso19",
.longname = "Link Instruments MSO-19", .longname = "Link Instruments MSO-19",
.api_version = 1, .api_version = 1,
@ -837,7 +837,7 @@ SR_PRIV struct sr_device_plugin link_mso19_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

104
hardware/openbench-logic-sniffer/ols.c
View File

@ -130,7 +130,7 @@ static int send_longcommand(int fd, uint8_t command, uint32_t data)
return SR_OK; return SR_OK;
} }
static int configure_probes(struct ols_device *ols, GSList *probes) static int configure_probes(struct ols_dev *ols, GSList *probes)
{ {
struct sr_probe *probe; struct sr_probe *probe;
GSList *l; GSList *l;
@ -204,12 +204,12 @@ static uint32_t reverse32(uint32_t in)
return out; return out;
} }
static struct ols_device *ols_device_new(void) static struct ols_dev *ols_dev_new(void)
{ {
struct ols_device *ols; struct ols_dev *ols;
/* TODO: Is 'ols' ever g_free()'d? */ /* TODO: Is 'ols' ever g_free()'d? */
if (!(ols = g_try_malloc0(sizeof(struct ols_device)))) { if (!(ols = g_try_malloc0(sizeof(struct ols_dev)))) {
sr_err("ols: %s: ols malloc failed", __func__); sr_err("ols: %s: ols malloc failed", __func__);
return NULL; return NULL;
} }
@ -225,17 +225,17 @@ static struct ols_device *ols_device_new(void)
static struct sr_dev_inst *get_metadata(int fd) static struct sr_dev_inst *get_metadata(int fd)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
uint32_t tmp_int; uint32_t tmp_int;
uint8_t key, type, token; uint8_t key, type, token;
GString *tmp_str, *devicename, *version; GString *tmp_str, *devname, *version;
gchar tmp_c; gchar tmp_c;
sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, NULL, NULL, NULL); sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, NULL, NULL, NULL);
ols = ols_device_new(); ols = ols_dev_new();
sdi->priv = ols; sdi->priv = ols;
devicename = g_string_new(""); devname = g_string_new("");
version = g_string_new(""); version = g_string_new("");
key = 0xff; key = 0xff;
@ -255,7 +255,7 @@ static struct sr_dev_inst *get_metadata(int fd)
switch (token) { switch (token) {
case 0x01: case 0x01:
/* Device name */ /* Device name */
devicename = g_string_append(devicename, tmp_str->str); devname = g_string_append(devname, tmp_str->str);
break; break;
case 0x02: case 0x02:
/* FPGA firmware version */ /* FPGA firmware version */
@ -339,27 +339,27 @@ static struct sr_dev_inst *get_metadata(int fd)
} }
} }
sdi->model = devicename->str; sdi->model = devname->str;
sdi->version = version->str; sdi->version = version->str;
g_string_free(devicename, FALSE); g_string_free(devname, FALSE);
g_string_free(version, FALSE); g_string_free(version, FALSE);
return sdi; return sdi;
} }
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
GSList *ports, *l; GSList *ports, *l;
GPollFD *fds, probefd; GPollFD *fds, probefd;
int devcnt, final_devcnt, num_ports, fd, ret, i; int devcnt, final_devcnt, num_ports, fd, ret, i;
char buf[8], **device_names, **serial_params; char buf[8], **dev_names, **serial_params;
final_devcnt = 0; final_devcnt = 0;
if (deviceinfo) if (devinfo)
ports = g_slist_append(NULL, g_strdup(deviceinfo)); ports = g_slist_append(NULL, g_strdup(devinfo));
else else
/* No specific device given, so scan all serial ports. */ /* No specific device given, so scan all serial ports. */
ports = list_serial_ports(); ports = list_serial_ports();
@ -371,14 +371,14 @@ static int hw_init(const char *deviceinfo)
goto hw_init_free_ports; /* TODO: SR_ERR_MALLOC. */ goto hw_init_free_ports; /* TODO: SR_ERR_MALLOC. */
} }
if (!(device_names = g_try_malloc(num_ports * sizeof(char *)))) { if (!(dev_names = g_try_malloc(num_ports * sizeof(char *)))) {
sr_err("ols: %s: device_names malloc failed", __func__); sr_err("ols: %s: dev_names malloc failed", __func__);
goto hw_init_free_fds; /* TODO: SR_ERR_MALLOC. */ goto hw_init_free_fds; /* TODO: SR_ERR_MALLOC. */
} }
if (!(serial_params = g_try_malloc(num_ports * sizeof(char *)))) { if (!(serial_params = g_try_malloc(num_ports * sizeof(char *)))) {
sr_err("ols: %s: serial_params malloc failed", __func__); sr_err("ols: %s: serial_params malloc failed", __func__);
goto hw_init_free_device_names; /* TODO: SR_ERR_MALLOC. */ goto hw_init_free_dev_names; /* TODO: SR_ERR_MALLOC. */
} }
devcnt = 0; devcnt = 0;
@ -415,7 +415,7 @@ static int hw_init(const char *deviceinfo)
send_shortcommand(fd, CMD_ID); send_shortcommand(fd, CMD_ID);
fds[devcnt].fd = fd; fds[devcnt].fd = fd;
fds[devcnt].events = G_IO_IN; fds[devcnt].events = G_IO_IN;
device_names[devcnt] = g_strdup(l->data); dev_names[devcnt] = g_strdup(l->data);
devcnt++; devcnt++;
} }
g_free(l->data); g_free(l->data);
@ -448,11 +448,11 @@ static int hw_init(const char *deviceinfo)
/* not an OLS -- some other board that uses the sump protocol */ /* not an OLS -- some other board that uses the sump protocol */
sdi = sr_dev_inst_new(final_devcnt, SR_ST_INACTIVE, sdi = sr_dev_inst_new(final_devcnt, SR_ST_INACTIVE,
"Sump", "Logic Analyzer", "v1.0"); "Sump", "Logic Analyzer", "v1.0");
ols = ols_device_new(); ols = ols_dev_new();
ols->num_probes = 32; ols->num_probes = 32;
sdi->priv = ols; sdi->priv = ols;
} }
ols->serial = sr_serial_dev_inst_new(device_names[i], -1); ols->serial = sr_serial_dev_inst_new(dev_names[i], -1);
dev_insts = g_slist_append(dev_insts, sdi); dev_insts = g_slist_append(dev_insts, sdi);
final_devcnt++; final_devcnt++;
serial_close(fds[i].fd); serial_close(fds[i].fd);
@ -466,12 +466,12 @@ static int hw_init(const char *deviceinfo)
serial_close(fds[i].fd); serial_close(fds[i].fd);
} }
g_free(serial_params[i]); g_free(serial_params[i]);
g_free(device_names[i]); g_free(dev_names[i]);
} }
g_free(serial_params); g_free(serial_params);
hw_init_free_device_names: hw_init_free_dev_names:
g_free(device_names); g_free(dev_names);
hw_init_free_fds: hw_init_free_fds:
g_free(fds); g_free(fds);
hw_init_free_ports: hw_init_free_ports:
@ -480,12 +480,12 @@ hw_init_free_ports:
return final_devcnt; return final_devcnt;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
ols = sdi->priv; ols = sdi->priv;
@ -499,12 +499,12 @@ static int hw_opendev(int device_index)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("ols: %s: sdi was NULL", __func__); sr_err("ols: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
@ -525,7 +525,7 @@ static int hw_cleanup(void)
{ {
GSList *l; GSList *l;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
int ret = SR_OK; int ret = SR_OK;
/* Properly close and free all devices. */ /* Properly close and free all devices. */
@ -555,18 +555,18 @@ static int hw_cleanup(void)
return ret; return ret;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
void *info; void *info;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return NULL; return NULL;
ols = sdi->priv; ols = sdi->priv;
info = NULL; info = NULL;
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -590,11 +590,11 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ST_NOT_FOUND; return SR_ST_NOT_FOUND;
return sdi->status; return sdi->status;
@ -608,7 +608,7 @@ static int *hw_get_capabilities(void)
static int set_configuration_samplerate(struct sr_dev_inst *sdi, static int set_configuration_samplerate(struct sr_dev_inst *sdi,
uint64_t samplerate) uint64_t samplerate)
{ {
struct ols_device *ols; struct ols_dev *ols;
ols = sdi->priv; ols = sdi->priv;
if (ols->max_samplerate) { if (ols->max_samplerate) {
@ -638,14 +638,14 @@ static int set_configuration_samplerate(struct sr_dev_inst *sdi,
return SR_OK; return SR_OK;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
int ret; int ret;
uint64_t *tmp_u64; uint64_t *tmp_u64;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
ols = sdi->priv; ols = sdi->priv;
@ -698,12 +698,12 @@ static int receive_data(int fd, int revents, void *session_data)
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic; struct sr_datafeed_logic logic;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
GSList *l; GSList *l;
int num_channels, offset, i, j; int num_channels, offset, i, j;
unsigned char byte; unsigned char byte;
/* find this device's ols_device struct by its fd */ /* find this device's ols_dev struct by its fd */
ols = NULL; ols = NULL;
for (l = dev_insts; l; l = l->next) { for (l = dev_insts; l; l = l->next) {
sdi = l->data; sdi = l->data;
@ -872,12 +872,12 @@ static int receive_data(int fd, int revents, void *session_data)
return TRUE; return TRUE;
} }
static int hw_start_acquisition(int device_index, gpointer session_data) static int hw_start_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_datafeed_packet *packet; struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header; struct sr_datafeed_header *header;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct ols_device *ols; struct ols_dev *ols;
uint32_t trigger_config[4]; uint32_t trigger_config[4];
uint32_t data; uint32_t data;
uint16_t readcount, delaycount; uint16_t readcount, delaycount;
@ -885,7 +885,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
int num_channels; int num_channels;
int i; int i;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
ols = sdi->priv; ols = sdi->priv;
@ -1025,20 +1025,20 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
static int hw_stop_acquisition(int device_index, gpointer session_device_id) static int hw_stop_acquisition(int dev_index, gpointer session_dev_id)
{ {
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
packet.type = SR_DF_END; packet.type = SR_DF_END;
sr_session_bus(session_device_id, &packet); sr_session_bus(session_dev_id, &packet);
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin ols_plugin_info = { SR_PRIV struct sr_dev_plugin ols_plugin_info = {
.name = "ols", .name = "ols",
.longname = "Openbench Logic Sniffer", .longname = "Openbench Logic Sniffer",
.api_version = 1, .api_version = 1,
@ -1046,7 +1046,7 @@ SR_PRIV struct sr_device_plugin ols_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

2
hardware/openbench-logic-sniffer/ols.h
View File

@ -59,7 +59,7 @@
#define FLAG_CLOCK_INVERTED 0x80 #define FLAG_CLOCK_INVERTED 0x80
#define FLAG_RLE 0x0100 #define FLAG_RLE 0x0100
struct ols_device { struct ols_dev {
uint32_t max_samplerate; uint32_t max_samplerate;
uint32_t max_samples; uint32_t max_samples;
uint32_t protocol_version; uint32_t protocol_version;

94
hardware/saleae-logic/saleae-logic.c
View File

@ -93,8 +93,8 @@ static libusb_context *usb_context = NULL;
static int new_saleae_logic_firmware = 0; static int new_saleae_logic_firmware = 0;
static int hw_set_configuration(int device_index, int capability, void *value); static int hw_set_configuration(int dev_index, int capability, void *value);
static int hw_stop_acquisition(int device_index, gpointer session_device_id); static int hw_stop_acquisition(int dev_index, gpointer session_dev_id);
/** /**
* Check the USB configuration to determine if this is a Saleae Logic. * Check the USB configuration to determine if this is a Saleae Logic.
@ -165,15 +165,15 @@ static int check_conf_profile(libusb_device *dev)
return ret; return ret;
} }
static int sl_open_device(int device_index) static int sl_open_dev(int dev_index)
{ {
libusb_device **devlist; libusb_device **devlist;
struct libusb_device_descriptor des; struct libusb_device_descriptor des;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct fx2_device *fx2; struct fx2_dev *fx2;
int err, skip, i; int err, skip, i;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
fx2 = sdi->priv; fx2 = sdi->priv;
@ -194,7 +194,7 @@ static int sl_open_device(int device_index)
continue; continue;
if (sdi->status == SR_ST_INITIALIZING) { if (sdi->status == SR_ST_INITIALIZING) {
if (skip != device_index) { if (skip != dev_index) {
/* Skip devices of this type that aren't the one we want. */ /* Skip devices of this type that aren't the one we want. */
skip += 1; skip += 1;
continue; continue;
@ -237,9 +237,9 @@ static int sl_open_device(int device_index)
return SR_OK; return SR_OK;
} }
static void close_device(struct sr_dev_inst *sdi) static void close_dev(struct sr_dev_inst *sdi)
{ {
struct fx2_device *fx2; struct fx2_dev *fx2;
fx2 = sdi->priv; fx2 = sdi->priv;
@ -254,7 +254,7 @@ static void close_device(struct sr_dev_inst *sdi)
sdi->status = SR_ST_INACTIVE; sdi->status = SR_ST_INACTIVE;
} }
static int configure_probes(struct fx2_device *fx2, GSList *probes) static int configure_probes(struct fx2_dev *fx2, GSList *probes)
{ {
struct sr_probe *probe; struct sr_probe *probe;
GSList *l; GSList *l;
@ -300,11 +300,11 @@ static int configure_probes(struct fx2_device *fx2, GSList *probes)
return SR_OK; return SR_OK;
} }
static struct fx2_device *fx2_device_new(void) static struct fx2_dev *fx2_dev_new(void)
{ {
struct fx2_device *fx2; struct fx2_dev *fx2;
if (!(fx2 = g_try_malloc0(sizeof(struct fx2_device)))) { if (!(fx2 = g_try_malloc0(sizeof(struct fx2_dev)))) {
sr_err("logic: %s: fx2 malloc failed", __func__); sr_err("logic: %s: fx2 malloc failed", __func__);
return NULL; return NULL;
} }
@ -319,17 +319,17 @@ static struct fx2_device *fx2_device_new(void)
* API callbacks * API callbacks
*/ */
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct libusb_device_descriptor des; struct libusb_device_descriptor des;
struct fx2_profile *fx2_prof; struct fx2_profile *fx2_prof;
struct fx2_device *fx2; struct fx2_dev *fx2;
libusb_device **devlist; libusb_device **devlist;
int err, devcnt, i, j; int err, devcnt, i, j;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)deviceinfo; (void)devinfo;
if (libusb_init(&usb_context) != 0) { if (libusb_init(&usb_context) != 0) {
sr_err("logic: Failed to initialize USB."); sr_err("logic: Failed to initialize USB.");
@ -363,7 +363,7 @@ static int hw_init(const char *deviceinfo)
fx2_prof->vendor, fx2_prof->model, fx2_prof->model_version); fx2_prof->vendor, fx2_prof->model, fx2_prof->model_version);
if (!sdi) if (!sdi)
return 0; return 0;
fx2 = fx2_device_new(); fx2 = fx2_dev_new();
fx2->profile = fx2_prof; fx2->profile = fx2_prof;
sdi->priv = fx2; sdi->priv = fx2;
dev_insts = g_slist_append(dev_insts, sdi); dev_insts = g_slist_append(dev_insts, sdi);
@ -393,14 +393,14 @@ static int hw_init(const char *deviceinfo)
return devcnt; return devcnt;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
GTimeVal cur_time; GTimeVal cur_time;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct fx2_device *fx2; struct fx2_dev *fx2;
int timediff, err; int timediff, err;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
fx2 = sdi->priv; fx2 = sdi->priv;
@ -415,7 +415,7 @@ static int hw_opendev(int device_index)
g_usleep(300 * 1000); g_usleep(300 * 1000);
timediff = 0; timediff = 0;
while (timediff < MAX_RENUM_DELAY) { while (timediff < MAX_RENUM_DELAY) {
if ((err = sl_open_device(device_index)) == SR_OK) if ((err = sl_open_dev(dev_index)) == SR_OK)
break; break;
g_usleep(100 * 1000); g_usleep(100 * 1000);
g_get_current_time(&cur_time); g_get_current_time(&cur_time);
@ -423,7 +423,7 @@ static int hw_opendev(int device_index)
} }
sr_info("logic: device came back after %d ms", timediff); sr_info("logic: device came back after %d ms", timediff);
} else { } else {
err = sl_open_device(device_index); err = sl_open_dev(dev_index);
} }
if (err != SR_OK) { if (err != SR_OK) {
@ -440,7 +440,7 @@ static int hw_opendev(int device_index)
if (fx2->cur_samplerate == 0) { if (fx2->cur_samplerate == 0) {
/* Samplerate hasn't been set; default to the slowest one. */ /* Samplerate hasn't been set; default to the slowest one. */
if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE, if (hw_set_configuration(dev_index, SR_HWCAP_SAMPLERATE,
&supported_samplerates[0]) == SR_ERR) &supported_samplerates[0]) == SR_ERR)
return SR_ERR; return SR_ERR;
} }
@ -448,17 +448,17 @@ static int hw_opendev(int device_index)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("logic: %s: sdi was NULL", __func__); sr_err("logic: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
/* TODO */ /* TODO */
close_device(sdi); close_dev(sdi);
return SR_OK; return SR_OK;
} }
@ -467,7 +467,7 @@ static int hw_cleanup(void)
{ {
GSList *l; GSList *l;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct fx2_device *fx2; struct fx2_dev *fx2;
int ret = SR_OK; int ret = SR_OK;
/* Properly close and free all devices. */ /* Properly close and free all devices. */
@ -485,7 +485,7 @@ static int hw_cleanup(void)
ret = SR_ERR_BUG; ret = SR_ERR_BUG;
continue; continue;
} }
close_device(sdi); close_dev(sdi);
sr_usb_dev_inst_free(fx2->usb); sr_usb_dev_inst_free(fx2->usb);
sr_dev_inst_free(sdi); sr_dev_inst_free(sdi);
} }
@ -500,17 +500,17 @@ static int hw_cleanup(void)
return ret; return ret;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct fx2_device *fx2; struct fx2_dev *fx2;
void *info = NULL; void *info = NULL;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return NULL; return NULL;
fx2 = sdi->priv; fx2 = sdi->priv;
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -534,11 +534,11 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
sdi = sr_dev_inst_get(dev_insts, device_index); sdi = sr_dev_inst_get(dev_insts, dev_index);
if (sdi) if (sdi)
return sdi->status; return sdi->status;
else else
@ -594,7 +594,7 @@ static uint8_t new_firmware_divider_value(uint64_t samplerate)
static int set_configuration_samplerate(struct sr_dev_inst *sdi, static int set_configuration_samplerate(struct sr_dev_inst *sdi,
uint64_t samplerate) uint64_t samplerate)
{ {
struct fx2_device *fx2; struct fx2_dev *fx2;
uint8_t divider; uint8_t divider;
int ret, result, i; int ret, result, i;
unsigned char buf[2]; unsigned char buf[2];
@ -628,14 +628,14 @@ static int set_configuration_samplerate(struct sr_dev_inst *sdi,
return SR_OK; return SR_OK;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct fx2_device *fx2; struct fx2_dev *fx2;
int ret; int ret;
uint64_t *tmp_u64; uint64_t *tmp_u64;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
fx2 = sdi->priv; fx2 = sdi->priv;
@ -672,12 +672,12 @@ static int receive_data(int fd, int revents, void *user_data)
static void receive_transfer(struct libusb_transfer *transfer) static void receive_transfer(struct libusb_transfer *transfer)
{ {
/* TODO: these statics have to move to fx2_device struct */ /* TODO: these statics have to move to fx2_dev struct */
static int num_samples = 0; static int num_samples = 0;
static int empty_transfer_count = 0; static int empty_transfer_count = 0;
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic; struct sr_datafeed_logic logic;
struct fx2_device *fx2; struct fx2_dev *fx2;
int cur_buflen, trigger_offset, i; int cur_buflen, trigger_offset, i;
unsigned char *cur_buf, *new_buf; unsigned char *cur_buf, *new_buf;
@ -808,18 +808,18 @@ static void receive_transfer(struct libusb_transfer *transfer)
} }
} }
static int hw_start_acquisition(int device_index, gpointer session_data) static int hw_start_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sr_datafeed_packet *packet; struct sr_datafeed_packet *packet;
struct sr_datafeed_header *header; struct sr_datafeed_header *header;
struct fx2_device *fx2; struct fx2_dev *fx2;
struct libusb_transfer *transfer; struct libusb_transfer *transfer;
const struct libusb_pollfd **lupfd; const struct libusb_pollfd **lupfd;
int size, i; int size, i;
unsigned char *buf; unsigned char *buf;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return SR_ERR; return SR_ERR;
fx2 = sdi->priv; fx2 = sdi->priv;
fx2->session_data = session_data; fx2->session_data = session_data;
@ -873,13 +873,13 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
/* This stops acquisition on ALL devices, ignoring device_index. */ /* This stops acquisition on ALL devices, ignoring dev_index. */
static int hw_stop_acquisition(int device_index, gpointer session_data) static int hw_stop_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
packet.type = SR_DF_END; packet.type = SR_DF_END;
sr_session_bus(session_data, &packet); sr_session_bus(session_data, &packet);
@ -891,7 +891,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin saleae_logic_plugin_info = { SR_PRIV struct sr_dev_plugin saleae_logic_plugin_info = {
.name = "saleae-logic", .name = "saleae-logic",
.longname = "Saleae Logic", .longname = "Saleae Logic",
.api_version = 1, .api_version = 1,
@ -899,7 +899,7 @@ SR_PRIV struct sr_device_plugin saleae_logic_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

10
hardware/saleae-logic/saleae-logic.h
View File

@ -48,13 +48,13 @@ struct fx2_profile {
int num_probes; int num_probes;
}; };
struct fx2_device { struct fx2_dev {
struct fx2_profile *profile; struct fx2_profile *profile;
/* /*
* Since we can't keep track of a Saleae Logic device after upgrading the * Since we can't keep track of a Saleae Logic device after upgrading
* firmware (it re-enumerates into a different device address after the * the firmware (it re-enumerates into a different device address
* upgrade) this is like a global lock. No device will open until a proper * after the upgrade) this is like a global lock. No device will open
* delay after the last device was upgraded. * until a proper delay after the last device was upgraded.
*/ */
GTimeVal fw_updated; GTimeVal fw_updated;
/* device/capture settings */ /* device/capture settings */

11
hardware/zeroplus-logic-cube/analyzer.c
View File

@ -37,11 +37,11 @@ enum {
HARD_DATA_CHECK_SUM = 0x00, HARD_DATA_CHECK_SUM = 0x00,
PASS_WORD, PASS_WORD,
DEVICE_ID0 = 0x10, DEV_ID0 = 0x10,
DEVICE_ID1, DEV_ID1,
START_STATUS = 0x20, START_STATUS = 0x20,
DEVICE_STATUS = 0x21, DEV_STATUS = 0x21,
FREQUENCY_REG0 = 0x30, FREQUENCY_REG0 = 0x30,
FREQUENCY_REG1, FREQUENCY_REG1,
FREQUENCY_REG2, FREQUENCY_REG2,
@ -319,7 +319,7 @@ SR_PRIV void analyzer_wait(libusb_device_handle *devh, int set, int unset)
{ {
int status; int status;
while (1) { while (1) {
status = gl_reg_read(devh, DEVICE_STATUS); status = gl_reg_read(devh, DEV_STATUS);
if ((status & set) && ((status & unset) == 0)) if ((status & set) && ((status & unset) == 0))
return; return;
} }
@ -507,8 +507,7 @@ SR_PRIV void analyzer_set_triggerbar_address(unsigned int address)
SR_PRIV unsigned int analyzer_read_id(libusb_device_handle *devh) SR_PRIV unsigned int analyzer_read_id(libusb_device_handle *devh)
{ {
return gl_reg_read(devh, DEVICE_ID1) << 8 | gl_reg_read(devh, return gl_reg_read(devh, DEV_ID1) << 8 | gl_reg_read(devh, DEV_ID0);
DEVICE_ID0);
} }
SR_PRIV unsigned int analyzer_get_stop_address(libusb_device_handle *devh) SR_PRIV unsigned int analyzer_get_stop_address(libusb_device_handle *devh)

58
hardware/zeroplus-logic-cube/zeroplus.c
View File

@ -166,7 +166,7 @@ struct zp {
struct sr_usb_dev_inst *usb; struct sr_usb_dev_inst *usb;
}; };
static int hw_set_configuration(int device_index, int capability, void *value); static int hw_set_configuration(int dev_index, int capability, void *value);
static unsigned int get_memory_size(int type) static unsigned int get_memory_size(int type)
{ {
@ -239,14 +239,14 @@ static int opendev4(struct sr_dev_inst **sdi, libusb_device *dev,
return 0; return 0;
} }
static struct sr_dev_inst *zp_open_device(int device_index) static struct sr_dev_inst *zp_open_dev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
libusb_device **devlist; libusb_device **devlist;
struct libusb_device_descriptor des; struct libusb_device_descriptor des;
int err, i; int err, i;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) if (!(sdi = sr_dev_inst_get(dev_insts, dev_index)))
return NULL; return NULL;
libusb_get_device_list(usb_context, &devlist); libusb_get_device_list(usb_context, &devlist);
@ -269,7 +269,7 @@ static struct sr_dev_inst *zp_open_device(int device_index)
return sdi; return sdi;
} }
static void close_device(struct sr_dev_inst *sdi) static void close_dev(struct sr_dev_inst *sdi)
{ {
struct zp *zp; struct zp *zp;
@ -336,7 +336,7 @@ static int configure_probes(struct sr_dev_inst *sdi, GSList *probes)
* API callbacks * API callbacks
*/ */
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct libusb_device_descriptor des; struct libusb_device_descriptor des;
@ -345,7 +345,7 @@ static int hw_init(const char *deviceinfo)
struct zp *zp; struct zp *zp;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)deviceinfo; (void)devinfo;
/* Allocate memory for our private driver context. */ /* Allocate memory for our private driver context. */
if (!(zp = g_try_malloc(sizeof(struct zp)))) { if (!(zp = g_try_malloc(sizeof(struct zp)))) {
@ -409,18 +409,18 @@ static int hw_init(const char *deviceinfo)
return devcnt; return devcnt;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct zp *zp; struct zp *zp;
int err; int err;
if (!(sdi = zp_open_device(device_index))) { if (!(sdi = zp_open_dev(dev_index))) {
sr_err("zp: unable to open device"); sr_err("zp: unable to open device");
return SR_ERR; return SR_ERR;
} }
/* TODO: Note: sdi is retrieved in zp_open_device(). */ /* TODO: Note: sdi is retrieved in zp_open_dev(). */
if (!(zp = sdi->priv)) { if (!(zp = sdi->priv)) {
sr_err("zp: %s: sdi->priv was NULL", __func__); sr_err("zp: %s: sdi->priv was NULL", __func__);
@ -462,7 +462,7 @@ static int hw_opendev(int device_index)
if (zp->cur_samplerate == 0) { if (zp->cur_samplerate == 0) {
/* Samplerate hasn't been set. Default to the slowest one. */ /* Samplerate hasn't been set. Default to the slowest one. */
if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE, if (hw_set_configuration(dev_index, SR_HWCAP_SAMPLERATE,
&samplerates.list[0]) == SR_ERR) &samplerates.list[0]) == SR_ERR)
return SR_ERR; return SR_ERR;
} }
@ -470,17 +470,17 @@ static int hw_opendev(int device_index)
return SR_OK; return SR_OK;
} }
static int hw_closedev(int device_index) static int hw_closedev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("zp: %s: sdi was NULL", __func__); sr_err("zp: %s: sdi was NULL", __func__);
return SR_ERR; /* TODO: SR_ERR_ARG? */ return SR_ERR; /* TODO: SR_ERR_ARG? */
} }
/* TODO */ /* TODO */
close_device(sdi); close_dev(sdi);
return SR_OK; return SR_OK;
} }
@ -493,7 +493,7 @@ static int hw_cleanup(void)
for (l = dev_insts; l; l = l->next) { for (l = dev_insts; l; l = l->next) {
sdi = l->data; sdi = l->data;
/* Properly close all devices... */ /* Properly close all devices... */
close_device(sdi); close_dev(sdi);
/* ...and free all their memory. */ /* ...and free all their memory. */
sr_dev_inst_free(sdi); sr_dev_inst_free(sdi);
} }
@ -507,13 +507,13 @@ static int hw_cleanup(void)
return SR_OK; return SR_OK;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct zp *zp; struct zp *zp;
void *info; void *info;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("zp: %s: sdi was NULL", __func__); sr_err("zp: %s: sdi was NULL", __func__);
return NULL; return NULL;
} }
@ -523,7 +523,7 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return NULL; return NULL;
} }
switch (device_info_id) { switch (dev_info_id) {
case SR_DI_INSTANCE: case SR_DI_INSTANCE:
info = sdi; info = sdi;
break; break;
@ -552,11 +552,11 @@ static void *hw_get_device_info(int device_index, int device_info_id)
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
sdi = sr_dev_inst_get(dev_insts, device_index); sdi = sr_dev_inst_get(dev_insts, dev_index);
if (sdi) if (sdi)
return sdi->status; return sdi->status;
else else
@ -597,13 +597,13 @@ static int set_configuration_samplerate(struct sr_dev_inst *sdi,
return SR_OK; return SR_OK;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
uint64_t *tmp_u64; uint64_t *tmp_u64;
struct zp *zp; struct zp *zp;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("zp: %s: sdi was NULL", __func__); sr_err("zp: %s: sdi was NULL", __func__);
return SR_ERR; return SR_ERR;
} }
@ -628,7 +628,7 @@ static int hw_set_configuration(int device_index, int capability, void *value)
} }
} }
static int hw_start_acquisition(int device_index, gpointer session_data) static int hw_start_acquisition(int dev_index, gpointer session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
@ -640,7 +640,7 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
unsigned char *buf; unsigned char *buf;
struct zp *zp; struct zp *zp;
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("zp: %s: sdi was NULL", __func__); sr_err("zp: %s: sdi was NULL", __func__);
return SR_ERR; return SR_ERR;
} }
@ -703,17 +703,17 @@ static int hw_start_acquisition(int device_index, gpointer session_data)
return SR_OK; return SR_OK;
} }
/* This stops acquisition on ALL devices, ignoring device_index. */ /* This stops acquisition on ALL devices, ignoring dev_index. */
static int hw_stop_acquisition(int device_index, gpointer session_device_id) static int hw_stop_acquisition(int dev_index, gpointer session_dev_id)
{ {
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct zp *zp; struct zp *zp;
packet.type = SR_DF_END; packet.type = SR_DF_END;
sr_session_bus(session_device_id, &packet); sr_session_bus(session_dev_id, &packet);
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("zp: %s: sdi was NULL", __func__); sr_err("zp: %s: sdi was NULL", __func__);
return SR_ERR_BUG; return SR_ERR_BUG;
} }
@ -729,7 +729,7 @@ static int hw_stop_acquisition(int device_index, gpointer session_device_id)
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin zeroplus_logic_cube_plugin_info = { SR_PRIV struct sr_dev_plugin zeroplus_logic_cube_plugin_info = {
.name = "zeroplus-logic-cube", .name = "zeroplus-logic-cube",
.longname = "Zeroplus Logic Cube LAP-C series", .longname = "Zeroplus Logic Cube LAP-C series",
.api_version = 1, .api_version = 1,
@ -737,7 +737,7 @@ SR_PRIV struct sr_device_plugin zeroplus_logic_cube_plugin_info = {
.cleanup = hw_cleanup, .cleanup = hw_cleanup,
.opendev = hw_opendev, .opendev = hw_opendev,
.closedev = hw_closedev, .closedev = hw_closedev,
.get_device_info = hw_get_device_info, .get_dev_info = hw_get_dev_info,
.get_status = hw_get_status, .get_status = hw_get_status,
.get_capabilities = hw_get_capabilities, .get_capabilities = hw_get_capabilities,
.set_configuration = hw_set_configuration, .set_configuration = hw_set_configuration,

50
hwplugin.c
View File

@ -43,28 +43,28 @@ SR_API struct sr_hwcap_option sr_hwcap_options[] = {
}; };
#ifdef HAVE_LA_DEMO #ifdef HAVE_LA_DEMO
extern struct sr_device_plugin demo_plugin_info; extern struct sr_dev_plugin demo_plugin_info;
#endif #endif
#ifdef HAVE_LA_SALEAE_LOGIC #ifdef HAVE_LA_SALEAE_LOGIC
extern struct sr_device_plugin saleae_logic_plugin_info; extern struct sr_dev_plugin saleae_logic_plugin_info;
#endif #endif
#ifdef HAVE_LA_OLS #ifdef HAVE_LA_OLS
extern struct sr_device_plugin ols_plugin_info; extern struct sr_dev_plugin ols_plugin_info;
#endif #endif
#ifdef HAVE_LA_ZEROPLUS_LOGIC_CUBE #ifdef HAVE_LA_ZEROPLUS_LOGIC_CUBE
extern struct sr_device_plugin zeroplus_logic_cube_plugin_info; extern struct sr_dev_plugin zeroplus_logic_cube_plugin_info;
#endif #endif
#ifdef HAVE_LA_ASIX_SIGMA #ifdef HAVE_LA_ASIX_SIGMA
extern struct sr_device_plugin asix_sigma_plugin_info; extern struct sr_dev_plugin asix_sigma_plugin_info;
#endif #endif
#ifdef HAVE_LA_CHRONOVU_LA8 #ifdef HAVE_LA_CHRONOVU_LA8
extern SR_PRIV struct device_plugin chronovu_la8_plugin_info; extern SR_PRIV struct dev_plugin chronovu_la8_plugin_info;
#endif #endif
#ifdef HAVE_LA_LINK_MSO19 #ifdef HAVE_LA_LINK_MSO19
extern struct sr_device_plugin link_mso19_plugin_info; extern struct sr_dev_plugin link_mso19_plugin_info;
#endif #endif
#ifdef HAVE_LA_ALSA #ifdef HAVE_LA_ALSA
extern struct sr_device_plugin alsa_plugin_info; extern struct sr_dev_plugin alsa_plugin_info;
#endif #endif
/* TODO: No linked list needed, this can be a simple array. */ /* TODO: No linked list needed, this can be a simple array. */
@ -123,19 +123,19 @@ SR_API GSList *sr_hw_list(void)
* *
* @return The number of devices found and instantiated by the plugin. * @return The number of devices found and instantiated by the plugin.
*/ */
SR_API int sr_hw_init(struct sr_device_plugin *plugin) SR_API int sr_hw_init(struct sr_dev_plugin *plugin)
{ {
int num_devices, num_probes, i, j; int num_devs, num_probes, i, j;
int num_initialized_devices = 0; int num_initialized_devs = 0;
struct sr_device *device; struct sr_dev *dev;
char **probe_names; char **probe_names;
sr_dbg("initializing %s plugin", plugin->name); sr_dbg("initializing %s plugin", plugin->name);
num_devices = plugin->init(NULL); num_devs = plugin->init(NULL);
for (i = 0; i < num_devices; i++) { for (i = 0; i < num_devs; i++) {
num_probes = GPOINTER_TO_INT( num_probes = GPOINTER_TO_INT(
plugin->get_device_info(i, SR_DI_NUM_PROBES)); plugin->get_dev_info(i, SR_DI_NUM_PROBES));
probe_names = (char **)plugin->get_device_info(i, probe_names = (char **)plugin->get_dev_info(i,
SR_DI_PROBE_NAMES); SR_DI_PROBE_NAMES);
if (!probe_names) { if (!probe_names) {
@ -144,18 +144,18 @@ SR_API int sr_hw_init(struct sr_device_plugin *plugin)
continue; continue;
} }
device = sr_dev_new(plugin, i); dev = sr_dev_new(plugin, i);
for (j = 0; j < num_probes; j++) for (j = 0; j < num_probes; j++)
sr_dev_probe_add(device, probe_names[j]); sr_dev_probe_add(dev, probe_names[j]);
num_initialized_devices++; num_initialized_devs++;
} }
return num_initialized_devices; return num_initialized_devs;
} }
SR_PRIV void sr_hw_cleanup_all(void) SR_PRIV void sr_hw_cleanup_all(void)
{ {
struct sr_device_plugin *plugin; struct sr_dev_plugin *plugin;
GSList *l; GSList *l;
for (l = plugins; l; l = l->next) { for (l = plugins; l; l = l->next) {
@ -186,17 +186,17 @@ SR_PRIV struct sr_dev_inst *sr_dev_inst_new(int index, int status,
return sdi; return sdi;
} }
SR_PRIV struct sr_dev_inst *sr_dev_inst_get(GSList *dev_insts, int device_index) SR_PRIV struct sr_dev_inst *sr_dev_inst_get(GSList *dev_insts, int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
GSList *l; GSList *l;
for (l = dev_insts; l; l = l->next) { for (l = dev_insts; l; l = l->next) {
sdi = (struct sr_dev_inst *)(l->data); sdi = (struct sr_dev_inst *)(l->data);
if (sdi->index == device_index) if (sdi->index == dev_index)
return sdi; return sdi;
} }
sr_warn("could not find device index %d instance", device_index); sr_warn("could not find device index %d instance", dev_index);
return NULL; return NULL;
} }
@ -268,7 +268,7 @@ SR_PRIV void sr_serial_dev_inst_free(struct sr_serial_dev_inst *serial)
* *
* @return TRUE if found, FALSE otherwise. * @return TRUE if found, FALSE otherwise.
*/ */
SR_API gboolean sr_hw_has_hwcap(struct sr_device_plugin *plugin, int hwcap) SR_API gboolean sr_hw_has_hwcap(struct sr_dev_plugin *plugin, int hwcap)
{ {
int *capabilities, i; int *capabilities, i;

12
input/binary.c
View File

@ -52,12 +52,12 @@ static int init(struct sr_input *in)
} }
/* Create a virtual device. */ /* Create a virtual device. */
in->vdevice = sr_dev_new(NULL, 0); in->vdev = sr_dev_new(NULL, 0);
for (i = 0; i < num_probes; i++) { for (i = 0; i < num_probes; i++) {
snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i); snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i);
/* TODO: Check return value. */ /* TODO: Check return value. */
sr_dev_probe_add(in->vdevice, name); sr_dev_probe_add(in->vdev, name);
} }
return SR_OK; return SR_OK;
@ -74,7 +74,7 @@ static int loadfile(struct sr_input *in, const char *filename)
if ((fd = open(filename, O_RDONLY)) == -1) if ((fd = open(filename, O_RDONLY)) == -1)
return SR_ERR; return SR_ERR;
num_probes = g_slist_length(in->vdevice->probes); num_probes = g_slist_length(in->vdev->probes);
/* send header */ /* send header */
header.feed_version = 1; header.feed_version = 1;
@ -83,7 +83,7 @@ static int loadfile(struct sr_input *in, const char *filename)
gettimeofday(&header.starttime, NULL); gettimeofday(&header.starttime, NULL);
packet.type = SR_DF_HEADER; packet.type = SR_DF_HEADER;
packet.payload = &header; packet.payload = &header;
sr_session_bus(in->vdevice, &packet); sr_session_bus(in->vdev, &packet);
/* chop up the input file into chunks and feed it into the session bus */ /* chop up the input file into chunks and feed it into the session bus */
packet.type = SR_DF_LOGIC; packet.type = SR_DF_LOGIC;
@ -92,13 +92,13 @@ static int loadfile(struct sr_input *in, const char *filename)
logic.data = buffer; logic.data = buffer;
while ((size = read(fd, buffer, CHUNKSIZE)) > 0) { while ((size = read(fd, buffer, CHUNKSIZE)) > 0) {
logic.length = size; logic.length = size;
sr_session_bus(in->vdevice, &packet); sr_session_bus(in->vdev, &packet);
} }
close(fd); close(fd);
/* end of stream */ /* end of stream */
packet.type = SR_DF_END; packet.type = SR_DF_END;
sr_session_bus(in->vdevice, &packet); sr_session_bus(in->vdev, &packet);
return SR_OK; return SR_OK;
} }

12
input/chronovu_la8.c
View File

@ -92,12 +92,12 @@ static int init(struct sr_input *in)
} }
/* Create a virtual device. */ /* Create a virtual device. */
in->vdevice = sr_dev_new(NULL, 0); in->vdev = sr_dev_new(NULL, 0);
for (i = 0; i < num_probes; i++) { for (i = 0; i < num_probes; i++) {
snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i); snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i);
/* TODO: Check return value. */ /* TODO: Check return value. */
sr_dev_probe_add(in->vdevice, name); sr_dev_probe_add(in->vdev, name);
} }
return SR_OK; return SR_OK;
@ -118,7 +118,7 @@ static int loadfile(struct sr_input *in, const char *filename)
return SR_ERR; return SR_ERR;
} }
num_probes = g_slist_length(in->vdevice->probes); num_probes = g_slist_length(in->vdev->probes);
/* Seek to the end of the file, and read the divcount byte. */ /* Seek to the end of the file, and read the divcount byte. */
divcount = 0x00; /* TODO: Don't hardcode! */ divcount = 0x00; /* TODO: Don't hardcode! */
@ -139,7 +139,7 @@ static int loadfile(struct sr_input *in, const char *filename)
gettimeofday(&header.starttime, NULL); gettimeofday(&header.starttime, NULL);
header.num_logic_probes = num_probes; header.num_logic_probes = num_probes;
header.samplerate = samplerate; header.samplerate = samplerate;
sr_session_bus(in->vdevice, &packet); sr_session_bus(in->vdev, &packet);
/* TODO: Handle trigger point. */ /* TODO: Handle trigger point. */
@ -155,7 +155,7 @@ static int loadfile(struct sr_input *in, const char *filename)
/* TODO: Handle errors, handle incomplete reads. */ /* TODO: Handle errors, handle incomplete reads. */
size = read(fd, buf, PACKET_SIZE); size = read(fd, buf, PACKET_SIZE);
logic.length = PACKET_SIZE; logic.length = PACKET_SIZE;
sr_session_bus(in->vdevice, &packet); sr_session_bus(in->vdev, &packet);
} }
close(fd); /* FIXME */ close(fd); /* FIXME */
@ -163,7 +163,7 @@ static int loadfile(struct sr_input *in, const char *filename)
sr_dbg("la8 in: %s: sending SR_DF_END", __func__); sr_dbg("la8 in: %s: sending SR_DF_END", __func__);
packet.type = SR_DF_END; packet.type = SR_DF_END;
packet.payload = NULL; packet.payload = NULL;
sr_session_bus(in->vdevice, &packet); sr_session_bus(in->vdev, &packet);
return SR_OK; return SR_OK;
} }

10
output/analog.c
View File

@ -105,7 +105,7 @@ static int init(struct sr_output *o, int default_spl, enum outputmode mode)
o->internal = ctx; o->internal = ctx;
ctx->num_enabled_probes = 0; ctx->num_enabled_probes = 0;
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -134,10 +134,10 @@ static int init(struct sr_output *o, int default_spl, enum outputmode mode)
} }
snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING); snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING);
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
if (o->device->plugin && sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (o->dev->plugin && sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
if (!(samplerate_s = sr_samplerate_string(samplerate))) { if (!(samplerate_s = sr_samplerate_string(samplerate))) {
g_free(ctx->header); g_free(ctx->header);
g_free(ctx); g_free(ctx);

18
output/chronovu_la8.c
View File

@ -94,13 +94,13 @@ static int init(struct sr_output *o)
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!o->device) { if (!o->dev) {
sr_warn("la8 out: %s: o->device was NULL", __func__); sr_warn("la8 out: %s: o->dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!o->device->plugin) { if (!o->dev->plugin) {
sr_warn("la8 out: %s: o->device->plugin was NULL", __func__); sr_warn("la8 out: %s: o->dev->plugin was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -113,7 +113,7 @@ static int init(struct sr_output *o)
/* Get the number of probes, their names, and the unitsize. */ /* Get the number of probes, their names, and the unitsize. */
/* TODO: Error handling. */ /* TODO: Error handling. */
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -122,11 +122,11 @@ static int init(struct sr_output *o)
ctx->probelist[ctx->num_enabled_probes] = 0; ctx->probelist[ctx->num_enabled_probes] = 0;
ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
if (sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
/* TODO: Error checks. */ /* TODO: Error checks. */
} else { } else {
samplerate = 0; /* TODO: Error or set some value? */ samplerate = 0; /* TODO: Error or set some value? */

18
output/csv.c
View File

@ -61,13 +61,13 @@ static int init(struct sr_output *o)
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!o->device) { if (!o->dev) {
sr_err("csv out: %s: o->device was NULL", __func__); sr_err("csv out: %s: o->dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!o->device->plugin) { if (!o->dev->plugin) {
sr_err("csv out: %s: o->device->plugin was NULL", __func__); sr_err("csv out: %s: o->dev->plugin was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -80,7 +80,7 @@ static int init(struct sr_output *o)
/* Get the number of probes, their names, and the unitsize. */ /* Get the number of probes, their names, and the unitsize. */
/* TODO: Error handling. */ /* TODO: Error handling. */
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -89,11 +89,11 @@ static int init(struct sr_output *o)
ctx->probelist[ctx->num_enabled_probes] = 0; ctx->probelist[ctx->num_enabled_probes] = 0;
ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
if (sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
/* TODO: Error checks. */ /* TODO: Error checks. */
} else { } else {
samplerate = 0; /* TODO: Error or set some value? */ samplerate = 0; /* TODO: Error or set some value? */

28
output/gnuplot.c
View File

@ -66,13 +66,13 @@ static int init(struct sr_output *o)
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!o->device) { if (!o->dev) {
sr_err("gnuplot out: %s: o->device was NULL", __func__); sr_err("gnuplot out: %s: o->dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!o->device->plugin) { if (!o->dev->plugin) {
sr_err("gnuplot out: %s: o->device->plugin was NULL", __func__); sr_err("gnuplot out: %s: o->dev->plugin was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -89,7 +89,7 @@ static int init(struct sr_output *o)
o->internal = ctx; o->internal = ctx;
ctx->num_enabled_probes = 0; ctx->num_enabled_probes = 0;
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; /* TODO: Error checks. */ probe = l->data; /* TODO: Error checks. */
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -98,11 +98,11 @@ static int init(struct sr_output *o)
ctx->probelist[ctx->num_enabled_probes] = 0; ctx->probelist[ctx->num_enabled_probes] = 0;
ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
comment[0] = '\0'; comment[0] = '\0';
if (sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
if (!(frequency_s = sr_samplerate_string(samplerate))) { if (!(frequency_s = sr_samplerate_string(samplerate))) {
sr_err("gnuplot out: %s: sr_samplerate_string failed", sr_err("gnuplot out: %s: sr_samplerate_string failed",
__func__); __func__);
@ -311,7 +311,7 @@ static int analog_init(struct sr_output *o)
o->internal = ctx; o->internal = ctx;
ctx->num_enabled_probes = 0; ctx->num_enabled_probes = 0;
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -322,11 +322,11 @@ static int analog_init(struct sr_output *o)
ctx->unitsize = sizeof(struct sr_analog_sample) + ctx->unitsize = sizeof(struct sr_analog_sample) +
(ctx->num_enabled_probes * sizeof(struct sr_analog_probe)); (ctx->num_enabled_probes * sizeof(struct sr_analog_probe));
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
comment[0] = '\0'; comment[0] = '\0';
if (o->device->plugin && sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (o->dev->plugin && sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
if (!(frequency_s = sr_samplerate_string(samplerate))) { if (!(frequency_s = sr_samplerate_string(samplerate))) {
g_free(ctx->header); g_free(ctx->header);
g_free(ctx); g_free(ctx);

8
output/ols.c
View File

@ -53,16 +53,16 @@ static int init(struct sr_output *o)
ctx->num_samples = 0; ctx->num_samples = 0;
num_enabled_probes = 0; num_enabled_probes = 0;
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (probe->enabled) if (probe->enabled)
num_enabled_probes++; num_enabled_probes++;
} }
ctx->unitsize = (num_enabled_probes + 7) / 8; ctx->unitsize = (num_enabled_probes + 7) / 8;
if (o->device->plugin && sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) if (o->dev->plugin && sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE))
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
else else
samplerate = 0; samplerate = 0;

10
output/text/text.c
View File

@ -81,7 +81,7 @@ SR_PRIV int init(struct sr_output *o, int default_spl, enum outputmode mode)
o->internal = ctx; o->internal = ctx;
ctx->num_enabled_probes = 0; ctx->num_enabled_probes = 0;
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -109,10 +109,10 @@ SR_PRIV int init(struct sr_output *o, int default_spl, enum outputmode mode)
} }
snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING); snprintf(ctx->header, 511, "%s\n", PACKAGE_STRING);
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
if (o->device->plugin || sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (o->dev->plugin || sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) o->device->plugin->get_device_info( samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
if (!(samplerate_s = sr_samplerate_string(samplerate))) { if (!(samplerate_s = sr_samplerate_string(samplerate))) {
g_free(ctx->header); g_free(ctx->header);
g_free(ctx); g_free(ctx);

10
output/vcd.c
View File

@ -57,7 +57,7 @@ static int init(struct sr_output *o)
o->internal = ctx; o->internal = ctx;
ctx->num_enabled_probes = 0; ctx->num_enabled_probes = 0;
for (l = o->device->probes; l; l = l->next) { for (l = o->dev->probes; l; l = l->next) {
probe = l->data; probe = l->data;
if (!probe->enabled) if (!probe->enabled)
continue; continue;
@ -71,7 +71,7 @@ static int init(struct sr_output *o)
ctx->probelist[ctx->num_enabled_probes] = 0; ctx->probelist[ctx->num_enabled_probes] = 0;
ctx->unitsize = (ctx->num_enabled_probes + 7) / 8; ctx->unitsize = (ctx->num_enabled_probes + 7) / 8;
ctx->header = g_string_sized_new(512); ctx->header = g_string_sized_new(512);
num_probes = g_slist_length(o->device->probes); num_probes = g_slist_length(o->dev->probes);
/* timestamp */ /* timestamp */
t = time(NULL); t = time(NULL);
@ -84,9 +84,9 @@ static int init(struct sr_output *o)
g_string_append_printf(ctx->header, "$version %s %s $end\n", g_string_append_printf(ctx->header, "$version %s %s $end\n",
PACKAGE, PACKAGE_VERSION); PACKAGE, PACKAGE_VERSION);
if (o->device->plugin && sr_dev_has_hwcap(o->device, SR_HWCAP_SAMPLERATE)) { if (o->dev->plugin && sr_dev_has_hwcap(o->dev, SR_HWCAP_SAMPLERATE)) {
ctx->samplerate = *((uint64_t *) o->device->plugin->get_device_info( ctx->samplerate = *((uint64_t *) o->dev->plugin->get_dev_info(
o->device->plugin_index, SR_DI_CUR_SAMPLERATE)); o->dev->plugin_index, SR_DI_CUR_SAMPLERATE));
if (!((samplerate_s = sr_samplerate_string(ctx->samplerate)))) { if (!((samplerate_s = sr_samplerate_string(ctx->samplerate)))) {
g_string_free(ctx->header, TRUE); g_string_free(ctx->header, TRUE);
g_free(ctx); g_free(ctx);

85
session.c
View File

@ -76,8 +76,8 @@ SR_API int sr_session_destroy(void)
return SR_ERR_BUG; return SR_ERR_BUG;
} }
g_slist_free(session->devices); g_slist_free(session->devs);
session->devices = NULL; session->devs = NULL;
/* TODO: Error checks needed? */ /* TODO: Error checks needed? */
@ -97,15 +97,15 @@ SR_API int sr_session_destroy(void)
* *
* @return SR_OK upon success, SR_ERR_BUG if no session exists. * @return SR_OK upon success, SR_ERR_BUG if no session exists.
*/ */
SR_API int sr_session_device_clear(void) SR_API int sr_session_dev_clear(void)
{ {
if (!session) { if (!session) {
sr_err("session: %s: session was NULL", __func__); sr_err("session: %s: session was NULL", __func__);
return SR_ERR_BUG; return SR_ERR_BUG;
} }
g_slist_free(session->devices); g_slist_free(session->devs);
session->devices = NULL; session->devs = NULL;
return SR_OK; return SR_OK;
} }
@ -113,28 +113,27 @@ SR_API int sr_session_device_clear(void)
/** /**
* Add a device to the current session. * Add a device to the current session.
* *
* @param device The device to add to the current session. Must not be NULL. * @param dev The device to add to the current session. Must not be NULL.
* Also, device->plugin and device->plugin->opendev must not * Also, dev->plugin and dev->plugin->opendev must not be NULL.
* be NULL.
* *
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments. * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
*/ */
SR_API int sr_session_device_add(struct sr_device *device) SR_API int sr_session_dev_add(struct sr_dev *dev)
{ {
int ret; int ret;
if (!device) { if (!dev) {
sr_err("session: %s: device was NULL", __func__); sr_err("session: %s: dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!device->plugin) { if (!dev->plugin) {
sr_err("session: %s: device->plugin was NULL", __func__); sr_err("session: %s: dev->plugin was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!device->plugin->opendev) { if (!dev->plugin->opendev) {
sr_err("session: %s: device->plugin->opendev was NULL", sr_err("session: %s: dev->plugin->opendev was NULL",
__func__); __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -144,12 +143,12 @@ SR_API int sr_session_device_add(struct sr_device *device)
return SR_ERR; /* TODO: SR_ERR_BUG? */ return SR_ERR; /* TODO: SR_ERR_BUG? */
} }
if ((ret = device->plugin->opendev(device->plugin_index)) != SR_OK) { if ((ret = dev->plugin->opendev(dev->plugin_index)) != SR_OK) {
sr_err("session: %s: opendev failed (%d)", __func__, ret); sr_err("session: %s: opendev failed (%d)", __func__, ret);
return ret; return ret;
} }
session->devices = g_slist_append(session->devices, device); session->devs = g_slist_append(session->devs, dev);
return SR_OK; return SR_OK;
} }
@ -253,7 +252,7 @@ static int sr_session_run_poll(void)
*/ */
SR_API int sr_session_start(void) SR_API int sr_session_start(void)
{ {
struct sr_device *device; struct sr_dev *dev;
GSList *l; GSList *l;
int ret; int ret;
@ -263,9 +262,9 @@ SR_API int sr_session_start(void)
return SR_ERR; /* TODO: SR_ERR_BUG? */ return SR_ERR; /* TODO: SR_ERR_BUG? */
} }
if (!session->devices) { if (!session->devs) {
/* TODO: Actually the case? */ /* TODO: Actually the case? */
sr_err("session: %s: session->devices was NULL; a session " sr_err("session: %s: session->devs was NULL; a session "
"cannot be started without devices.", __func__); "cannot be started without devices.", __func__);
return SR_ERR; /* TODO: SR_ERR_BUG? */ return SR_ERR; /* TODO: SR_ERR_BUG? */
} }
@ -274,11 +273,11 @@ SR_API int sr_session_start(void)
sr_info("session: starting"); sr_info("session: starting");
for (l = session->devices; l; l = l->next) { for (l = session->devs; l; l = l->next) {
device = l->data; dev = l->data;
/* TODO: Check for device != NULL. */ /* TODO: Check for dev != NULL. */
if ((ret = device->plugin->start_acquisition( if ((ret = dev->plugin->start_acquisition(
device->plugin_index, device)) != SR_OK) { dev->plugin_index, dev)) != SR_OK) {
sr_err("session: %s: could not start an acquisition " sr_err("session: %s: could not start an acquisition "
"(%d)", __func__, ret); "(%d)", __func__, ret);
break; break;
@ -305,9 +304,9 @@ SR_API int sr_session_run(void)
return SR_ERR_BUG; return SR_ERR_BUG;
} }
if (!session->devices) { if (!session->devs) {
/* TODO: Actually the case? */ /* TODO: Actually the case? */
sr_err("session: %s: session->devices was NULL; a session " sr_err("session: %s: session->devs was NULL; a session "
"cannot be run without devices.", __func__); "cannot be run without devices.", __func__);
return SR_ERR_BUG; return SR_ERR_BUG;
} }
@ -359,7 +358,7 @@ SR_API int sr_session_halt(void)
*/ */
SR_API int sr_session_stop(void) SR_API int sr_session_stop(void)
{ {
struct sr_device *device; struct sr_dev *dev;
GSList *l; GSList *l;
if (!session) { if (!session) {
@ -370,14 +369,14 @@ SR_API int sr_session_stop(void)
sr_info("session: stopping"); sr_info("session: stopping");
session->running = FALSE; session->running = FALSE;
for (l = session->devices; l; l = l->next) { for (l = session->devs; l; l = l->next) {
device = l->data; dev = l->data;
/* Check for device != NULL. */ /* Check for dev != NULL. */
if (device->plugin) { if (dev->plugin) {
if (device->plugin->stop_acquisition) if (dev->plugin->stop_acquisition)
device->plugin->stop_acquisition(device->plugin_index, device); dev->plugin->stop_acquisition(dev->plugin_index, dev);
if (device->plugin->cleanup) if (dev->plugin->cleanup)
device->plugin->cleanup(); dev->plugin->cleanup();
} }
} }
@ -419,24 +418,24 @@ static void datafeed_dump(struct sr_datafeed_packet *packet)
* *
* Hardware drivers use this to send a data packet to the frontend. * Hardware drivers use this to send a data packet to the frontend.
* *
* @param device TODO. * @param dev TODO.
* @param packet TODO. * @param packet TODO.
* *
* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments. * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
*/ */
SR_PRIV int sr_session_bus(struct sr_device *device, SR_PRIV int sr_session_bus(struct sr_dev *dev,
struct sr_datafeed_packet *packet) struct sr_datafeed_packet *packet)
{ {
GSList *l; GSList *l;
sr_datafeed_callback cb; sr_datafeed_callback cb;
if (!device) { if (!dev) {
sr_err("session: %s: device was NULL", __func__); sr_err("session: %s: dev was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
if (!device->plugin) { if (!dev->plugin) {
sr_err("session: %s: device->plugin was NULL", __func__); sr_err("session: %s: dev->plugin was NULL", __func__);
return SR_ERR_ARG; return SR_ERR_ARG;
} }
@ -450,7 +449,7 @@ SR_PRIV int sr_session_bus(struct sr_device *device,
datafeed_dump(packet); datafeed_dump(packet);
cb = l->data; cb = l->data;
/* TODO: Check for cb != NULL. */ /* TODO: Check for cb != NULL. */
cb(device, packet); cb(dev, packet);
} }
return SR_OK; return SR_OK;

113
session_driver.c
View File

@ -29,7 +29,7 @@
/* size of payloads sent across the session bus */ /* size of payloads sent across the session bus */
#define CHUNKSIZE (512 * 1024) #define CHUNKSIZE (512 * 1024)
struct session_vdevice { struct session_vdev {
char *capturefile; char *capturefile;
struct zip *archive; struct zip *archive;
struct zip_file *capfile; struct zip_file *capfile;
@ -50,26 +50,26 @@ static int capabilities[] = {
/** /**
* TODO. * TODO.
* *
* @param device_index TODO. * @param dev_index TODO.
*/ */
static struct session_vdevice *get_vdevice_by_index(int device_index) static struct session_vdev *get_vdev_by_index(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct session_vdevice *vdevice; struct session_vdev *vdev;
/* TODO: Sanity checks on device_index. */ /* TODO: Sanity checks on dev_index. */
if (!(sdi = sr_dev_inst_get(dev_insts, device_index))) { if (!(sdi = sr_dev_inst_get(dev_insts, dev_index))) {
sr_err("session driver: %s: device instance with device " sr_err("session driver: %s: device instance with device "
"index %d was not found", __func__, device_index); "index %d was not found", __func__, dev_index);
return NULL; return NULL;
} }
/* TODO: Is sdi->priv == NULL valid? */ /* TODO: Is sdi->priv == NULL valid? */
vdevice = sdi->priv; vdev = sdi->priv;
return vdevice; return vdev;
} }
/** /**
@ -84,7 +84,7 @@ static struct session_vdevice *get_vdevice_by_index(int device_index)
static int feed_chunk(int fd, int revents, void *session_data) static int feed_chunk(int fd, int revents, void *session_data)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
struct session_vdevice *vdevice; struct session_vdev *vdev;
struct sr_datafeed_packet packet; struct sr_datafeed_packet packet;
struct sr_datafeed_logic logic; struct sr_datafeed_logic logic;
GSList *l; GSList *l;
@ -100,8 +100,8 @@ static int feed_chunk(int fd, int revents, void *session_data)
got_data = FALSE; got_data = FALSE;
for (l = dev_insts; l; l = l->next) { for (l = dev_insts; l; l = l->next) {
sdi = l->data; sdi = l->data;
vdevice = sdi->priv; vdev = sdi->priv;
if (!vdevice) if (!vdev)
/* already done with this instance */ /* already done with this instance */
continue; continue;
@ -111,21 +111,21 @@ static int feed_chunk(int fd, int revents, void *session_data)
return FALSE; /* TODO: SR_ERR_MALLOC */ return FALSE; /* TODO: SR_ERR_MALLOC */
} }
ret = zip_fread(vdevice->capfile, buf, CHUNKSIZE); ret = zip_fread(vdev->capfile, buf, CHUNKSIZE);
if (ret > 0) { if (ret > 0) {
got_data = TRUE; got_data = TRUE;
packet.type = SR_DF_LOGIC; packet.type = SR_DF_LOGIC;
packet.payload = &logic; packet.payload = &logic;
logic.length = ret; logic.length = ret;
logic.unitsize = vdevice->unitsize; logic.unitsize = vdev->unitsize;
logic.data = buf; logic.data = buf;
vdevice->bytes_read += ret; vdev->bytes_read += ret;
sr_session_bus(session_data, &packet); sr_session_bus(session_data, &packet);
} else { } else {
/* done with this capture file */ /* done with this capture file */
zip_fclose(vdevice->capfile); zip_fclose(vdev->capfile);
g_free(vdevice->capturefile); g_free(vdev->capturefile);
g_free(vdevice); g_free(vdev);
sdi->priv = NULL; sdi->priv = NULL;
} }
} }
@ -144,13 +144,13 @@ static int hw_cleanup(void);
/** /**
* TODO. * TODO.
* *
* @param deviceinfo TODO. * @param devinfo TODO.
* *
* @return TODO. * @return TODO.
*/ */
static int hw_init(const char *deviceinfo) static int hw_init(const char *devinfo)
{ {
sessionfile = g_strdup(deviceinfo); sessionfile = g_strdup(devinfo);
return 0; return 0;
} }
@ -175,16 +175,16 @@ static int hw_cleanup(void)
return SR_OK; return SR_OK;
} }
static int hw_opendev(int device_index) static int hw_opendev(int dev_index)
{ {
struct sr_dev_inst *sdi; struct sr_dev_inst *sdi;
sdi = sr_dev_inst_new(device_index, SR_ST_INITIALIZING, sdi = sr_dev_inst_new(dev_index, SR_ST_INITIALIZING,
NULL, NULL, NULL); NULL, NULL, NULL);
if (!sdi) if (!sdi)
return SR_ERR; return SR_ERR;
if (!(sdi->priv = g_try_malloc0(sizeof(struct session_vdevice)))) { if (!(sdi->priv = g_try_malloc0(sizeof(struct session_vdev)))) {
sr_err("session driver: %s: sdi->priv malloc failed", __func__); sr_err("session driver: %s: sdi->priv malloc failed", __func__);
return SR_ERR_MALLOC; return SR_ERR_MALLOC;
} }
@ -194,26 +194,26 @@ static int hw_opendev(int device_index)
return SR_OK; return SR_OK;
} }
static void *hw_get_device_info(int device_index, int device_info_id) static void *hw_get_dev_info(int dev_index, int dev_info_id)
{ {
struct session_vdevice *vdevice; struct session_vdev *vdev;
void *info; void *info;
if (device_info_id != SR_DI_CUR_SAMPLERATE) if (dev_info_id != SR_DI_CUR_SAMPLERATE)
return NULL; return NULL;
if (!(vdevice = get_vdevice_by_index(device_index))) if (!(vdev = get_vdev_by_index(dev_index)))
return NULL; return NULL;
info = &vdevice->samplerate; info = &vdev->samplerate;
return info; return info;
} }
static int hw_get_status(int device_index) static int hw_get_status(int dev_index)
{ {
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)device_index; (void)dev_index;
if (sr_dev_list() != NULL) if (sr_dev_list() != NULL)
return SR_OK; return SR_OK;
@ -232,33 +232,33 @@ static int *hw_get_capabilities(void)
return capabilities; return capabilities;
} }
static int hw_set_configuration(int device_index, int capability, void *value) static int hw_set_configuration(int dev_index, int capability, void *value)
{ {
struct session_vdevice *vdevice; struct session_vdev *vdev;
uint64_t *tmp_u64; uint64_t *tmp_u64;
if (!(vdevice = get_vdevice_by_index(device_index))) if (!(vdev = get_vdev_by_index(dev_index)))
return SR_ERR; return SR_ERR;
switch (capability) { switch (capability) {
case SR_HWCAP_SAMPLERATE: case SR_HWCAP_SAMPLERATE:
tmp_u64 = value; tmp_u64 = value;
vdevice->samplerate = *tmp_u64; vdev->samplerate = *tmp_u64;
sr_info("session driver: setting samplerate to %" PRIu64, sr_info("session driver: setting samplerate to %" PRIu64,
vdevice->samplerate); vdev->samplerate);
break; break;
case SR_HWCAP_CAPTUREFILE: case SR_HWCAP_CAPTUREFILE:
vdevice->capturefile = g_strdup(value); vdev->capturefile = g_strdup(value);
sr_info("session driver: setting capturefile to %s", sr_info("session driver: setting capturefile to %s",
vdevice->capturefile); vdev->capturefile);
break; break;
case SR_HWCAP_CAPTURE_UNITSIZE: case SR_HWCAP_CAPTURE_UNITSIZE:
tmp_u64 = value; tmp_u64 = value;
vdevice->unitsize = *tmp_u64; vdev->unitsize = *tmp_u64;
break; break;
case SR_HWCAP_CAPTURE_NUM_PROBES: case SR_HWCAP_CAPTURE_NUM_PROBES:
tmp_u64 = value; tmp_u64 = value;
vdevice->num_probes = *tmp_u64; vdev->num_probes = *tmp_u64;
break; break;
default: default:
sr_err("session driver: %s: unknown capability %d requested", sr_err("session driver: %s: unknown capability %d requested",
@ -269,44 +269,43 @@ static int hw_set_configuration(int device_index, int capability, void *value)
return SR_OK; return SR_OK;
} }
static int hw_start_acquisition(int device_index, gpointer session_device_id) static int hw_start_acquisition(int dev_index, gpointer session_dev_id)
{ {
struct zip_stat zs; struct zip_stat zs;
struct session_vdevice *vdevice; struct session_vdev *vdev;
struct sr_datafeed_header *header; struct sr_datafeed_header *header;
struct sr_datafeed_packet *packet; struct sr_datafeed_packet *packet;
int err; int err;
/* Avoid compiler warnings. */ /* Avoid compiler warnings. */
(void)session_device_id; (void)session_dev_id;
if (!(vdevice = get_vdevice_by_index(device_index))) if (!(vdev = get_vdev_by_index(dev_index)))
return SR_ERR; return SR_ERR;
sr_info("session_driver: opening archive %s file %s", sessionfile, sr_info("session_driver: opening archive %s file %s", sessionfile,
vdevice->capturefile); vdev->capturefile);
if (!(vdevice->archive = zip_open(sessionfile, 0, &err))) { if (!(vdev->archive = zip_open(sessionfile, 0, &err))) {
sr_err("session driver: Failed to open session file '%s': " sr_err("session driver: Failed to open session file '%s': "
"zip error %d\n", sessionfile, err); "zip error %d\n", sessionfile, err);
return SR_ERR; return SR_ERR;
} }
if (zip_stat(vdevice->archive, vdevice->capturefile, 0, &zs) == -1) { if (zip_stat(vdev->archive, vdev->capturefile, 0, &zs) == -1) {
sr_err("session driver: Failed to check capture file '%s' in " sr_err("session driver: Failed to check capture file '%s' in "
"session file '%s'.", vdevice->capturefile, sessionfile); "session file '%s'.", vdev->capturefile, sessionfile);
return SR_ERR; return SR_ERR;
} }
if (!(vdevice->capfile = zip_fopen(vdevice->archive, if (!(vdev->capfile = zip_fopen(vdev->archive, vdev->capturefile, 0))) {
vdevice->capturefile, 0))) {
sr_err("session driver: Failed to open capture file '%s' in " sr_err("session driver: Failed to open capture file '%s' in "
"session file '%s'.", vdevice->capturefile, sessionfile); "session file '%s'.", vdev->capturefile, sessionfile);
return SR_ERR; return SR_ERR;
} }
/* freewheeling source */ /* freewheeling source */
sr_session_source_add(-1, 0, 0, feed_chunk, session_device_id); sr_session_source_add(-1, 0, 0, feed_chunk, session_dev_id);
if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) { if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
sr_err("session driver: %s: packet malloc failed", __func__); sr_err("session driver: %s: packet malloc failed", __func__);
@ -323,16 +322,16 @@ static int hw_start_acquisition(int device_index, gpointer session_device_id)
packet->payload = (unsigned char *)header; packet->payload = (unsigned char *)header;
header->feed_version = 1; header->feed_version = 1;
gettimeofday(&header->starttime, NULL); gettimeofday(&header->starttime, NULL);
header->samplerate = vdevice->samplerate; header->samplerate = vdev->samplerate;
header->num_logic_probes = vdevice->num_probes; header->num_logic_probes = vdev->num_probes;
sr_session_bus(session_device_id, packet); sr_session_bus(session_dev_id, packet);
g_free(header); g_free(header);
g_free(packet); g_free(packet);
return SR_OK; return SR_OK;
} }
SR_PRIV struct sr_device_plugin session_driver = { SR_PRIV struct sr_dev_plugin session_driver = {
"session", "session",
"Session-emulating driver", "Session-emulating driver",
1, 1,
@ -340,7 +339,7 @@ SR_PRIV struct sr_device_plugin session_driver = {
hw_cleanup, hw_cleanup,
hw_opendev, hw_opendev,
NULL, NULL,
hw_get_device_info, hw_get_dev_info,
hw_get_status, hw_get_status,
hw_get_capabilities, hw_get_capabilities,
hw_set_configuration, hw_set_configuration,

52
session_file.c
View File

@ -28,7 +28,7 @@
#include "sigrok-internal.h" #include "sigrok-internal.h"
extern struct sr_session *session; extern struct sr_session *session;
extern SR_PRIV struct sr_device_plugin session_driver; extern SR_PRIV struct sr_dev_plugin session_driver;
/** /**
* Load the session from the specified filename. * Load the session from the specified filename.
@ -47,7 +47,7 @@ SR_API int sr_session_load(const char *filename)
struct zip_file *zf; struct zip_file *zf;
struct zip_stat zs; struct zip_stat zs;
struct sr_session *session; struct sr_session *session;
struct sr_device *device; struct sr_dev *dev;
struct sr_probe *probe; struct sr_probe *probe;
int ret, err, probenum, devcnt, i, j; int ret, err, probenum, devcnt, i, j;
uint64_t tmp_u64, total_probes, enabled_probes, p; uint64_t tmp_u64, total_probes, enabled_probes, p;
@ -109,46 +109,46 @@ SR_API int sr_session_load(const char *filename)
continue; continue;
if (!strncmp(sections[i], "device ", 7)) { if (!strncmp(sections[i], "device ", 7)) {
/* device section */ /* device section */
device = NULL; dev = NULL;
enabled_probes = 0; enabled_probes = 0;
keys = g_key_file_get_keys(kf, sections[i], NULL, NULL); keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
for (j = 0; keys[j]; j++) { for (j = 0; keys[j]; j++) {
val = g_key_file_get_string(kf, sections[i], keys[j], NULL); val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
if (!strcmp(keys[j], "capturefile")) { if (!strcmp(keys[j], "capturefile")) {
device = sr_dev_new(&session_driver, devcnt); dev = sr_dev_new(&session_driver, devcnt);
if (devcnt == 0) if (devcnt == 0)
/* first device, init the plugin */ /* first device, init the plugin */
device->plugin->init((char *)filename); dev->plugin->init((char *)filename);
sr_session_device_add(device); sr_session_dev_add(dev);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTUREFILE, val); dev->plugin->set_configuration(devcnt, SR_HWCAP_CAPTUREFILE, val);
g_ptr_array_add(capturefiles, val); g_ptr_array_add(capturefiles, val);
} else if (!strcmp(keys[j], "samplerate")) { } else if (!strcmp(keys[j], "samplerate")) {
sr_parse_sizestring(val, &tmp_u64); sr_parse_sizestring(val, &tmp_u64);
device->plugin->set_configuration(devcnt, SR_HWCAP_SAMPLERATE, &tmp_u64); dev->plugin->set_configuration(devcnt, SR_HWCAP_SAMPLERATE, &tmp_u64);
} else if (!strcmp(keys[j], "unitsize")) { } else if (!strcmp(keys[j], "unitsize")) {
tmp_u64 = strtoull(val, NULL, 10); tmp_u64 = strtoull(val, NULL, 10);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_UNITSIZE, &tmp_u64); dev->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_UNITSIZE, &tmp_u64);
} else if (!strcmp(keys[j], "total probes")) { } else if (!strcmp(keys[j], "total probes")) {
total_probes = strtoull(val, NULL, 10); total_probes = strtoull(val, NULL, 10);
device->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_NUM_PROBES, &total_probes); dev->plugin->set_configuration(devcnt, SR_HWCAP_CAPTURE_NUM_PROBES, &total_probes);
for (p = 0; p < total_probes; p++) { for (p = 0; p < total_probes; p++) {
snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p); snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
sr_dev_probe_add(device, probename); sr_dev_probe_add(dev, probename);
} }
} else if (!strncmp(keys[j], "probe", 5)) { } else if (!strncmp(keys[j], "probe", 5)) {
if (!device) if (!dev)
continue; continue;
enabled_probes++; enabled_probes++;
tmp_u64 = strtoul(keys[j]+5, NULL, 10); tmp_u64 = strtoul(keys[j]+5, NULL, 10);
sr_dev_probe_name(device, tmp_u64, val); sr_dev_probe_name(dev, tmp_u64, val);
} else if (!strncmp(keys[j], "trigger", 7)) { } else if (!strncmp(keys[j], "trigger", 7)) {
probenum = strtoul(keys[j]+7, NULL, 10); probenum = strtoul(keys[j]+7, NULL, 10);
sr_dev_trigger_set(device, probenum, val); sr_dev_trigger_set(dev, probenum, val);
} }
} }
g_strfreev(keys); g_strfreev(keys);
for (p = enabled_probes; p < total_probes; p++) { for (p = enabled_probes; p < total_probes; p++) {
probe = g_slist_nth_data(device->probes, p); probe = g_slist_nth_data(dev->probes, p);
probe->enabled = FALSE; probe->enabled = FALSE;
} }
} }
@ -172,7 +172,7 @@ int sr_session_save(const char *filename)
{ {
GSList *l, *p, *d; GSList *l, *p, *d;
FILE *meta; FILE *meta;
struct sr_device *device; struct sr_dev *dev;
struct sr_probe *probe; struct sr_probe *probe;
struct sr_datastore *ds; struct sr_datastore *ds;
struct zip *zipfile; struct zip *zipfile;
@ -213,28 +213,28 @@ int sr_session_save(const char *filename)
/* all datastores in all devices */ /* all datastores in all devices */
devcnt = 1; devcnt = 1;
for (l = session->devices; l; l = l->next) { for (l = session->devs; l; l = l->next) {
device = l->data; dev = l->data;
/* metadata */ /* metadata */
fprintf(meta, "[device %d]\n", devcnt); fprintf(meta, "[device %d]\n", devcnt);
if (device->plugin) if (dev->plugin)
fprintf(meta, "driver = %s\n", device->plugin->name); fprintf(meta, "driver = %s\n", dev->plugin->name);
ds = device->datastore; ds = dev->datastore;
if (ds) { if (ds) {
/* metadata */ /* metadata */
fprintf(meta, "capturefile = logic-%d\n", devcnt); fprintf(meta, "capturefile = logic-%d\n", devcnt);
fprintf(meta, "unitsize = %d\n", ds->ds_unitsize); fprintf(meta, "unitsize = %d\n", ds->ds_unitsize);
fprintf(meta, "total probes = %d\n", g_slist_length(device->probes)); fprintf(meta, "total probes = %d\n", g_slist_length(dev->probes));
if (sr_dev_has_hwcap(device, SR_HWCAP_SAMPLERATE)) { if (sr_dev_has_hwcap(dev, SR_HWCAP_SAMPLERATE)) {
samplerate = *((uint64_t *) device->plugin->get_device_info( samplerate = *((uint64_t *) dev->plugin->get_dev_info(
device->plugin_index, SR_DI_CUR_SAMPLERATE)); dev->plugin_index, SR_DI_CUR_SAMPLERATE));
s = sr_samplerate_string(samplerate); s = sr_samplerate_string(samplerate);
fprintf(meta, "samplerate = %s\n", s); fprintf(meta, "samplerate = %s\n", s);
g_free(s); g_free(s);
} }
probecnt = 1; probecnt = 1;
for (p = device->probes; p; p = p->next) { for (p = dev->probes; p; p = p->next) {
probe = p->data; probe = p->data;
if (probe->enabled) { if (probe->enabled) {
if (probe->name) if (probe->name)

7
sigrok-internal.h
View File

@ -81,14 +81,13 @@ SR_PRIV void sr_hw_cleanup_all(void);
/*--- session.c -------------------------------------------------------------*/ /*--- session.c -------------------------------------------------------------*/
SR_PRIV int sr_session_bus(struct sr_device *device, SR_PRIV int sr_session_bus(struct sr_dev *dev,
struct sr_datafeed_packet *packet); struct sr_datafeed_packet *packet);
/* Generic device instances */ /* Generic device instances */
SR_PRIV struct sr_dev_inst *sr_dev_inst_new(int index, int status, SR_PRIV struct sr_dev_inst *sr_dev_inst_new(int index, int status,
const char *vendor, const char *model, const char *version); const char *vendor, const char *model, const char *version);
SR_PRIV struct sr_dev_inst *sr_dev_inst_get(GSList *dev_insts, SR_PRIV struct sr_dev_inst *sr_dev_inst_get(GSList *dev_insts, int dev_index);
int device_index);
SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi); SR_PRIV void sr_dev_inst_free(struct sr_dev_inst *sdi);
SR_PRIV void sr_source_remove(int fd); SR_PRIV void sr_source_remove(int fd);
@ -121,7 +120,7 @@ SR_PRIV int ezusb_upload_firmware(libusb_device *dev, int configuration,
/*--- hardware/common/misc.c ------------------------------------------------*/ /*--- hardware/common/misc.c ------------------------------------------------*/
#ifdef HAVE_LIBUSB_1_0 #ifdef HAVE_LIBUSB_1_0
SR_PRIV int opendev2(int device_index, struct sr_dev_inst **sdi, SR_PRIV int opendev2(int dev_index, struct sr_dev_inst **sdi,
libusb_device *dev, struct libusb_device_descriptor *des, libusb_device *dev, struct libusb_device_descriptor *des,
int *skip, uint16_t vid, uint16_t pid, int interface); int *skip, uint16_t vid, uint16_t pid, int interface);
SR_PRIV int opendev3(struct sr_dev_inst **sdi, libusb_device *dev, SR_PRIV int opendev3(struct sr_dev_inst **sdi, libusb_device *dev,

31
sigrok-proto.h
View File

@ -49,19 +49,18 @@ SR_API int sr_datastore_put(struct sr_datastore *ds, void *data,
SR_API int sr_dev_scan(void); SR_API int sr_dev_scan(void);
SR_API GSList *sr_dev_list(void); SR_API GSList *sr_dev_list(void);
SR_API struct sr_device *sr_dev_new(const struct sr_device_plugin *plugin, SR_API struct sr_dev *sr_dev_new(const struct sr_dev_plugin *plugin,
int plugin_index); int plugin_index);
SR_API int sr_dev_probe_add(struct sr_device *device, const char *name); SR_API int sr_dev_probe_add(struct sr_dev *dev, const char *name);
SR_API struct sr_probe *sr_dev_probe_find(const struct sr_device *device, SR_API struct sr_probe *sr_dev_probe_find(const struct sr_dev *dev,
int probenum); int probenum);
SR_API int sr_dev_probe_name(struct sr_device *device, int probenum, SR_API int sr_dev_probe_name(struct sr_dev *dev, int probenum,
const char *name); const char *name);
SR_API int sr_dev_trigger_clear(struct sr_device *device); SR_API int sr_dev_trigger_clear(struct sr_dev *dev);
SR_API int sr_dev_trigger_set(struct sr_device *device, int probenum, SR_API int sr_dev_trigger_set(struct sr_dev *dev, int probenum,
const char *trigger); const char *trigger);
SR_API gboolean sr_dev_has_hwcap(const struct sr_device *device, int hwcap); SR_API gboolean sr_dev_has_hwcap(const struct sr_dev *dev, int hwcap);
SR_API int sr_dev_info_get(const struct sr_device *device, int id, SR_API int sr_dev_info_get(const struct sr_dev *dev, int id, const void **data);
const void **data);
/*--- filter.c --------------------------------------------------------------*/ /*--- filter.c --------------------------------------------------------------*/
@ -73,21 +72,21 @@ SR_API int sr_filter_probes(int in_unitsize, int out_unitsize,
/*--- hwplugin.c ------------------------------------------------------------*/ /*--- hwplugin.c ------------------------------------------------------------*/
SR_API GSList *sr_hw_list(void); SR_API GSList *sr_hw_list(void);
SR_API int sr_hw_init(struct sr_device_plugin *plugin); SR_API int sr_hw_init(struct sr_dev_plugin *plugin);
SR_API gboolean sr_hw_has_hwcap(struct sr_device_plugin *plugin, int hwcap); SR_API gboolean sr_hw_has_hwcap(struct sr_dev_plugin *plugin, int hwcap);
SR_API struct sr_hwcap_option *sr_hw_hwcap_get(int hwcap); SR_API struct sr_hwcap_option *sr_hw_hwcap_get(int hwcap);
/*--- session.c -------------------------------------------------------------*/ /*--- session.c -------------------------------------------------------------*/
typedef void (*sr_datafeed_callback) (struct sr_device *device, typedef void (*sr_datafeed_callback) (struct sr_dev *dev,
struct sr_datafeed_packet *packet); struct sr_datafeed_packet *packet);
/* Session setup */ /* Session setup */
SR_API int sr_session_load(const char *filename); SR_API int sr_session_load(const char *filename);
SR_API struct sr_session *sr_session_new(void); SR_API struct sr_session *sr_session_new(void);
SR_API int sr_session_destroy(void); SR_API int sr_session_destroy(void);
SR_API int sr_session_device_clear(void); SR_API int sr_session_dev_clear(void);
SR_API int sr_session_device_add(struct sr_device *device); SR_API int sr_session_dev_add(struct sr_dev *dev);
/* Datafeed setup */ /* Datafeed setup */
SR_API int sr_session_datafeed_callback_clear(void); SR_API int sr_session_datafeed_callback_clear(void);
@ -111,11 +110,11 @@ SR_API struct sr_input_format **sr_input_list(void);
SR_API struct sr_output_format **sr_output_list(void); SR_API struct sr_output_format **sr_output_list(void);
/*--- strutil.c -------------------------------------------------------*/ /*--- strutil.c -------------------------------------------------------------*/
SR_API char *sr_samplerate_string(uint64_t samplerate); SR_API char *sr_samplerate_string(uint64_t samplerate);
SR_API char *sr_period_string(uint64_t frequency); SR_API char *sr_period_string(uint64_t frequency);
SR_API char **sr_parse_triggerstring(struct sr_device *device, SR_API char **sr_parse_triggerstring(struct sr_dev *dev,
const char *triggerstring); const char *triggerstring);
SR_API int sr_parse_sizestring(const char *sizestring, uint64_t *size); SR_API int sr_parse_sizestring(const char *sizestring, uint64_t *size);
SR_API uint64_t sr_parse_timestring(const char *timestring); SR_API uint64_t sr_parse_timestring(const char *timestring);

34
sigrok.h
View File

@ -131,7 +131,7 @@ struct sr_datafeed_logic {
struct sr_input { struct sr_input {
struct sr_input_format *format; struct sr_input_format *format;
char *param; char *param;
struct sr_device *vdevice; struct sr_dev *vdev;
}; };
struct sr_input_format { struct sr_input_format {
@ -144,7 +144,7 @@ struct sr_input_format {
struct sr_output { struct sr_output {
struct sr_output_format *format; struct sr_output_format *format;
struct sr_device *device; struct sr_dev *dev;
char *param; char *param;
void *internal; void *internal;
}; };
@ -171,11 +171,11 @@ struct sr_datastore {
* This represents a generic device connected to the system. * This represents a generic device connected to the system.
* For device-specific information, ask the plugin. The plugin_index refers * For device-specific information, ask the plugin. The plugin_index refers
* to the device index within that plugin; it may be handling more than one * to the device index within that plugin; it may be handling more than one
* device. All relevant plugin calls take a device_index parameter for this. * device. All relevant plugin calls take a dev_index parameter for this.
*/ */
struct sr_device { struct sr_dev {
/* Which plugin handles this device */ /* Which plugin handles this device */
struct sr_device_plugin *plugin; struct sr_dev_plugin *plugin;
/* A plugin may handle multiple devices of the same type */ /* A plugin may handle multiple devices of the same type */
int plugin_index; int plugin_index;
/* List of struct sr_probe* */ /* List of struct sr_probe* */
@ -210,7 +210,7 @@ enum {
/*--- Device types --------------------------------------------------*/ /*--- Device types --------------------------------------------------*/
/** The device is demo device. */ /** The device is demo device. */
SR_HWCAP_DEMO_DEVICE, SR_HWCAP_DEMO_DEV,
/*--- Device options ------------------------------------------------*/ /*--- Device options ------------------------------------------------*/
@ -338,28 +338,28 @@ struct sr_samplerates {
uint64_t *list; uint64_t *list;
}; };
struct sr_device_plugin { struct sr_dev_plugin {
/* Plugin-specific */ /* Plugin-specific */
char *name; char *name;
char *longname; char *longname;
int api_version; int api_version;
int (*init) (const char *deviceinfo); int (*init) (const char *devinfo);
int (*cleanup) (void); int (*cleanup) (void);
/* Device-specific */ /* Device-specific */
int (*opendev) (int device_index); int (*opendev) (int dev_index);
int (*closedev) (int device_index); int (*closedev) (int dev_index);
void *(*get_device_info) (int device_index, int device_info_id); void *(*get_dev_info) (int dev_index, int dev_info_id);
int (*get_status) (int device_index); int (*get_status) (int dev_index);
int *(*get_capabilities) (void); int *(*get_capabilities) (void);
int (*set_configuration) (int device_index, int capability, void *value); int (*set_configuration) (int dev_index, int capability, void *value);
int (*start_acquisition) (int device_index, gpointer session_device_id); int (*start_acquisition) (int dev_index, gpointer session_dev_id);
int (*stop_acquisition) (int device_index, gpointer session_device_id); int (*stop_acquisition) (int dev_index, gpointer session_dev_id);
}; };
struct sr_session { struct sr_session {
/* List of struct sr_device* */ /* List of struct sr_dev* */
GSList *devices; GSList *devs;
/* list of sr_receive_data_callback */ /* list of sr_receive_data_callback */
GSList *datafeed_callbacks; GSList *datafeed_callbacks;
GTimeVal starttime; GTimeVal starttime;

10
strutil.c
View File

@ -108,12 +108,12 @@ SR_API char *sr_period_string(uint64_t frequency)
/** /**
* TODO * TODO
* *
* @param device TODO * @param dev TODO
* @param triggerstring TODO * @param triggerstring TODO
* *
* @return TODO * @return TODO
*/ */
SR_API char **sr_parse_triggerstring(struct sr_device *device, SR_API char **sr_parse_triggerstring(struct sr_dev *dev,
const char *triggerstring) const char *triggerstring)
{ {
GSList *l; GSList *l;
@ -122,7 +122,7 @@ SR_API char **sr_parse_triggerstring(struct sr_device *device,
char **tokens, **triggerlist, *trigger, *tc, *trigger_types; char **tokens, **triggerlist, *trigger, *tc, *trigger_types;
gboolean error; gboolean error;
max_probes = g_slist_length(device->probes); max_probes = g_slist_length(dev->probes);
error = FALSE; error = FALSE;
if (!(triggerlist = g_try_malloc0(max_probes * sizeof(char *)))) { if (!(triggerlist = g_try_malloc0(max_probes * sizeof(char *)))) {
@ -131,7 +131,7 @@ SR_API char **sr_parse_triggerstring(struct sr_device *device,
} }
tokens = g_strsplit(triggerstring, ",", max_probes); tokens = g_strsplit(triggerstring, ",", max_probes);
trigger_types = device->plugin->get_device_info(0, SR_DI_TRIGGER_TYPES); trigger_types = dev->plugin->get_dev_info(0, SR_DI_TRIGGER_TYPES);
if (trigger_types == NULL) if (trigger_types == NULL)
return NULL; return NULL;
@ -139,7 +139,7 @@ SR_API char **sr_parse_triggerstring(struct sr_device *device,
if (tokens[i][0] < '0' || tokens[i][0] > '9') { if (tokens[i][0] < '0' || tokens[i][0] > '9') {
/* Named probe */ /* Named probe */
probenum = 0; probenum = 0;
for (l = device->probes; l; l = l->next) { for (l = dev->probes; l; l = l->next) {
probe = (struct sr_probe *)l->data; probe = (struct sr_probe *)l->data;
if (probe->enabled if (probe->enabled
&& !strncmp(probe->name, tokens[i], && !strncmp(probe->name, tokens[i],