#include "protocol.h"
SR_PRIV struct sr_dev_driver scpi_pps_driver_info;
-static struct sr_dev_driver *di = &scpi_pps_driver_info;
extern unsigned int num_pps_profiles;
extern const struct scpi_pps pps_profiles[];
SR_CONF_SERIALCOMM,
};
-static struct pps_channel_instance pci[] = {
+static const uint32_t drvopts[] = {
+ SR_CONF_POWER_SUPPLY,
+};
+
+static const struct pps_channel_instance pci[] = {
{ SR_MQ_VOLTAGE, SCPI_CMD_GET_MEAS_VOLTAGE, "V" },
{ SR_MQ_CURRENT, SCPI_CMD_GET_MEAS_CURRENT, "I" },
{ SR_MQ_POWER, SCPI_CMD_GET_MEAS_POWER, "P" },
};
-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);
}
struct sr_channel *ch;
const struct scpi_pps *device;
struct pps_channel *pch;
- const struct channel_group_spec *cgs;
+ struct channel_spec *channels;
+ struct channel_group_spec *channel_groups, *cgs;
struct pps_channel_group *pcg;
GRegex *model_re;
GMatchInfo *model_mi;
GSList *l;
uint64_t mask;
- unsigned int ch_num, ch_idx, i, j;
+ unsigned int num_channels, num_channel_groups, ch_num, ch_idx, i, j;
+ int ret;
const char *vendor;
char ch_name[16];
return NULL;
}
- sdi = sr_dev_inst_new(SR_ST_ACTIVE, vendor, hw_info->model,
- hw_info->firmware_version);
+ sdi = g_malloc0(sizeof(struct sr_dev_inst));
+ sdi->status = SR_ST_INACTIVE;
+ sdi->vendor = g_strdup(vendor);
+ sdi->model = g_strdup(hw_info->model);
+ sdi->version = g_strdup(hw_info->firmware_version);
sdi->conn = scpi;
- sdi->driver = di;
+ sdi->driver = &scpi_pps_driver_info;
sdi->inst_type = SR_INST_SCPI;
+ sdi->serial_num = g_strdup(hw_info->serial_number);
+
devc = g_malloc0(sizeof(struct dev_context));
devc->device = device;
sdi->priv = devc;
+ if (device->num_channels) {
+ /* Static channels and groups. */
+ channels = (struct channel_spec *)device->channels;
+ num_channels = device->num_channels;
+ channel_groups = (struct channel_group_spec *)device->channel_groups;
+ num_channel_groups = device->num_channel_groups;
+ } else {
+ /* Channels and groups need to be probed. */
+ ret = device->probe_channels(sdi, hw_info, &channels, &num_channels,
+ &channel_groups, &num_channel_groups);
+ if (ret != SR_OK) {
+ sr_err("Failed to probe for channels.");
+ return NULL;
+ }
+ /*
+ * Since these were dynamically allocated, we'll need to free them
+ * later.
+ */
+ devc->channels = channels;
+ devc->channel_groups = channel_groups;
+ }
+
ch_idx = 0;
- for (ch_num = 0; ch_num < device->num_channels; ch_num++) {
+ for (ch_num = 0; ch_num < num_channels; ch_num++) {
/* Create one channel per measurable output unit. */
for (i = 0; i < ARRAY_SIZE(pci); i++) {
if (!scpi_cmd_get(sdi, pci[i].command))
continue;
g_snprintf(ch_name, 16, "%s%s", pci[i].prefix,
- device->channels[ch_num].name);
- ch = sr_channel_new(ch_idx++, SR_CHANNEL_ANALOG, TRUE, ch_name);
+ channels[ch_num].name);
+ ch = sr_channel_new(sdi, ch_idx++, SR_CHANNEL_ANALOG, TRUE,
+ ch_name);
pch = g_malloc0(sizeof(struct pps_channel));
pch->hw_output_idx = ch_num;
- pch->hwname = device->channels[ch_num].name;
+ pch->hwname = channels[ch_num].name;
pch->mq = pci[i].mq;
ch->priv = pch;
- sdi->channels = g_slist_append(sdi->channels, ch);
}
}
- for (i = 0; i < device->num_channel_groups; i++) {
- cgs = &device->channel_groups[i];
+ for (i = 0; i < num_channel_groups; i++) {
+ cgs = &channel_groups[i];
cg = g_malloc0(sizeof(struct sr_channel_group));
cg->name = g_strdup(cgs->name);
for (j = 0, mask = 1; j < 64; j++, mask <<= 1) {
sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
}
+ sr_scpi_hw_info_free(hw_info);
+ hw_info = NULL;
+
scpi_cmd(sdi, SCPI_CMD_LOCAL);
sr_scpi_close(scpi);
return sdi;
}
-static GSList *scan(GSList *options)
+static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
return sr_scpi_scan(di->priv, options, probe_device);
}
-static GSList *dev_list(void)
+static GSList *dev_list(const struct sr_dev_driver *di)
{
return ((struct drv_context *)(di->priv))->instances;
}
-static int dev_clear(void)
+static int dev_clear(const struct sr_dev_driver *di)
{
return std_dev_clear(di, NULL);
}
struct sr_scpi_dev_inst *scpi;
GVariant *beeper;
- if (sdi->status != SR_ST_ACTIVE)
+ if (sdi->status != SR_ST_INACTIVE)
return SR_ERR;
scpi = sdi->conn;
return SR_OK;
}
-static int cleanup(void)
+static void clear_helper(void *priv)
{
- return std_dev_clear(di, NULL);
+ struct dev_context *devc;
+
+ devc = priv;
+ g_free(devc->channels);
+ g_free(devc->channel_groups);
+ g_free(devc);
+}
+
+static int cleanup(const struct sr_dev_driver *di)
+{
+ return std_dev_clear(di, clear_helper);
}
static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
const GVariantType *gvtype;
unsigned int i;
int cmd, ret;
- const char *s;
if (!sdi)
return SR_ERR_ARG;
if (cg)
select_channel(sdi, cg->channels->data);
ret = scpi_cmd_resp(sdi, data, gvtype, cmd);
-
- if (gvtype == G_VARIANT_TYPE_STRING && ret == SR_OK) {
- /* Non-standard data type responses. */
- switch (key) {
- case SCPI_CMD_GET_OUTPUT_REGULATION:
- /*
- * This is specific to the Rigol DP800 series.
- * We return the same string for now until more
- * models with this key are supported. Do a check
- * just for the hell of it.
- */
- s = g_variant_get_string(*data, NULL);
- if (strcmp(s, "CC") && strcmp(s, "CV") && strcmp(s, "UR")) {
- sr_dbg("Unknown response to SCPI_CMD_GET_OUTPUT_REGULATION: %s", s);
- ret = SR_ERR_DATA;
- }
- break;
- }
- }
} else
ret = SR_ERR_NA;
{
struct dev_context *devc;
struct sr_channel *ch;
- struct channel_spec *ch_spec;
+ const struct channel_spec *ch_spec;
GVariant *gvar;
GVariantBuilder gvb;
int ret, i;
*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
return SR_OK;
+ } else if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
+ *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
+ drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
+ return SR_OK;
}
if (!sdi)
projects / libsigrok.git / blobdiff