* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
-#include "protocol.h"
-#include "libsigrok.h"
-#include "libsigrok-internal.h"
#include <glib.h>
#include <libusb.h>
#include <stdlib.h>
#include <string.h>
+#include <libsigrok/libsigrok.h>
+#include "libsigrok-internal.h"
+#include "protocol.h"
static const uint32_t scanopts[] = {
SR_CONF_CONN,
SR_PRIV struct sr_dev_driver sysclk_lwla_driver_info;
static struct sr_dev_driver *const di = &sysclk_lwla_driver_info;
-static int init(struct sr_context *sr_ctx)
+static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
{
return std_init(sr_ctx, di, LOG_PREFIX);
}
-static GSList *gen_channel_list(int num_channels)
-{
- GSList *list;
- struct sr_channel *ch;
- int i;
- char name[8];
-
- list = NULL;
-
- for (i = num_channels; i > 0; --i) {
- /* The LWLA series simply number channels from CH1 to CHxx. */
- g_snprintf(name, sizeof(name), "CH%d", i);
-
- ch = sr_channel_new(i - 1, SR_CHANNEL_LOGIC, TRUE, name);
- list = g_slist_prepend(list, ch);
- }
-
- return list;
-}
-
static struct sr_dev_inst *dev_inst_new(void)
{
struct sr_dev_inst *sdi;
struct dev_context *devc;
+ int i;
+ char name[8];
/* Allocate memory for our private driver context. */
- devc = g_try_new0(struct dev_context, 1);
- if (!devc) {
- sr_err("Device context malloc failed.");
- return NULL;
- }
+ devc = g_malloc0(sizeof(struct dev_context));
/* Register the device with libsigrok. */
sdi = g_malloc0(sizeof(struct sr_dev_inst));
devc->samplerate = DEFAULT_SAMPLERATE;
sdi->priv = devc;
- sdi->channels = gen_channel_list(NUM_CHANNELS);
+ for (i = 0; i < NUM_CHANNELS; ++i) {
+ /* The LWLA series simply number channels from CH1 to CHxx. */
+ g_snprintf(name, sizeof(name), "CH%d", i + 1);
+ sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, name);
+ }
return sdi;
}
-static GSList *scan(GSList *options)
+static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
GSList *usb_devices, *devices, *node;
struct drv_context *drvc;
struct sr_config *src;
const char *conn;
- drvc = di->priv;
+ drvc = di->context;
conn = USB_VID_PID;
for (node = options; node != NULL; node = node->next) {
return devices;
}
-static GSList *dev_list(void)
+static GSList *dev_list(const struct sr_dev_driver *di)
{
struct drv_context *drvc;
- drvc = di->priv;
+ drvc = di->context;
return drvc->instances;
}
g_free(devc);
}
-static int dev_clear(void)
+static int dev_clear(const struct sr_dev_driver *di)
{
return std_dev_clear(di, &clear_dev_context);
}
struct sr_usb_dev_inst *usb;
int ret;
- drvc = di->priv;
+ drvc = di->context;
if (!drvc) {
sr_err("Driver was not initialized.");
{
struct sr_usb_dev_inst *usb;
- if (!di->priv) {
+ if (!di->context) {
sr_err("Driver was not initialized.");
return SR_ERR;
}
return SR_OK;
}
-static int cleanup(void)
+static int cleanup(const struct sr_dev_driver *di)
{
- return dev_clear();
+ return dev_clear(di);
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
break;
case SR_CONF_CLOCK_EDGE:
idx = devc->cfg_clock_edge;
- if (idx >= G_N_ELEMENTS(signal_edge_names))
+ if (idx >= ARRAY_SIZE(signal_edge_names))
return SR_ERR_BUG;
*data = g_variant_new_string(signal_edge_names[idx]);
break;
case SR_CONF_TRIGGER_SOURCE:
idx = devc->cfg_trigger_source;
- if (idx >= G_N_ELEMENTS(trigger_source_names))
+ if (idx >= ARRAY_SIZE(trigger_source_names))
return SR_ERR_BUG;
*data = g_variant_new_string(trigger_source_names[idx]);
break;
case SR_CONF_TRIGGER_SLOPE:
idx = devc->cfg_trigger_slope;
- if (idx >= G_N_ELEMENTS(signal_edge_names))
+ if (idx >= ARRAY_SIZE(signal_edge_names))
return SR_ERR_BUG;
*data = g_variant_new_string(signal_edge_names[idx]);
break;
switch (key) {
case SR_CONF_SAMPLERATE:
value = g_variant_get_uint64(data);
- if (value < samplerates[G_N_ELEMENTS(samplerates) - 1]
+ if (value < samplerates[ARRAY_SIZE(samplerates) - 1]
|| value > samplerates[0])
return SR_ERR_SAMPLERATE;
devc->samplerate = value;
break;
case SR_CONF_CLOCK_EDGE:
idx = lookup_index(data, signal_edge_names,
- G_N_ELEMENTS(signal_edge_names));
+ ARRAY_SIZE(signal_edge_names));
if (idx < 0)
return SR_ERR_ARG;
devc->cfg_clock_edge = idx;
break;
case SR_CONF_TRIGGER_SOURCE:
idx = lookup_index(data, trigger_source_names,
- G_N_ELEMENTS(trigger_source_names));
+ ARRAY_SIZE(trigger_source_names));
if (idx < 0)
return SR_ERR_ARG;
devc->cfg_trigger_source = idx;
break;
case SR_CONF_TRIGGER_SLOPE:
idx = lookup_index(data, signal_edge_names,
- G_N_ELEMENTS(signal_edge_names));
+ ARRAY_SIZE(signal_edge_names));
if (idx < 0)
return SR_ERR_ARG;
devc->cfg_trigger_slope = idx;
break;
case SR_CONF_DEVICE_OPTIONS:
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
- devopts, G_N_ELEMENTS(devopts), sizeof(uint32_t));
+ devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
break;
case SR_CONF_SAMPLERATE:
g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
- samplerates, G_N_ELEMENTS(samplerates),
+ samplerates, ARRAY_SIZE(samplerates),
sizeof(uint64_t));
g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
*data = g_variant_builder_end(&gvb);
break;
case SR_CONF_TRIGGER_SOURCE:
*data = g_variant_new_strv(trigger_source_names,
- G_N_ELEMENTS(trigger_source_names));
+ ARRAY_SIZE(trigger_source_names));
break;
case SR_CONF_TRIGGER_SLOPE:
case SR_CONF_CLOCK_EDGE:
*data = g_variant_new_strv(signal_edge_names,
- G_N_ELEMENTS(signal_edge_names));
+ ARRAY_SIZE(signal_edge_names));
break;
default:
return SR_ERR_NA;
return SR_ERR_DEV_CLOSED;
devc = sdi->priv;
- drvc = di->priv;
+ drvc = di->context;
if (devc->acquisition) {
sr_err("Acquisition still in progress?");
.dev_close = dev_close,
.dev_acquisition_start = dev_acquisition_start,
.dev_acquisition_stop = dev_acquisition_stop,
- .priv = NULL,
+ .context = NULL,
};
projects / libsigrok.git / blobdiff