X-Git-Url: https://sigrok.org/gitweb/?a=blobdiff_plain;f=hardware%2Fhameg-hmo%2Fapi.c;h=b5b3bc29f0100dc588c53d3091d6031b3b2d2688;hb=b5bbc3f1b00d5f3096c6800af4069fb07704d3a9;hp=70d91a5a9ca19c45b08f495adf07f6648bd9742e;hpb=13f2b9d789fdc7130c0f31b88319bd0f3445109a;p=libsigrok.git diff --git a/hardware/hameg-hmo/api.c b/hardware/hameg-hmo/api.c index 70d91a5a..b5b3bc29 100644 --- a/hardware/hameg-hmo/api.c +++ b/hardware/hameg-hmo/api.c @@ -18,31 +18,27 @@ */ #include -#include - #include "protocol.h" #define SERIALCOMM "115200/8n1/flow=1" +SR_PRIV struct sr_dev_driver hameg_hmo_driver_info; +static struct sr_dev_driver *di = &hameg_hmo_driver_info; + +static const char *manufacturers[] = { + "HAMEG", +}; + static const int32_t hwopts[] = { SR_CONF_CONN, SR_CONF_SERIALCOMM, }; -struct usb_id_info { - uint16_t vendor_id; - uint16_t product_id; -} usb_id_info; - -static struct usb_id_info ho_models[] = { - { - .vendor_id = 0x0403, - .product_id = 0xed72, /* HO720 */ - }, - { - .vendor_id = 0x0403, - .product_id = 0xed73, /* HO730 */ - }, +enum { + CG_INVALID = -1, + CG_NONE, + CG_ANALOG, + CG_DIGITAL, }; static int init(struct sr_context *sr_ctx) @@ -50,215 +46,74 @@ static int init(struct sr_context *sr_ctx) return std_init(sr_ctx, di, LOG_PREFIX); } -/** - * Find USB serial devices via the USB vendor ID and product ID. - * - * @param vendor_id vendor ID of the USB device. - * @param product_id product ID of the USB device. - * - * @return A GSList of strings containing the path of the serial device or null - * if no serial device is found. The returned list must be freed by the caller. - */ -static GSList *auto_find_usb(unsigned long vendor_id, - unsigned long product_id) +static int check_manufacturer(const char *manufacturer) { -#ifdef __linux__ - const gchar *usb_dev; - const char device_tree[] = "/sys/bus/usb/devices/"; - - GDir *devices_dir; - - GSList *l = NULL; - GSList *tty_devices; - GSList *matched_paths; - - l = NULL; - tty_devices = NULL; - matched_paths = NULL; - - if (!(devices_dir = g_dir_open(device_tree, 0, NULL))) - return NULL; - - /* - * Find potential candidates using the vendor ID and product ID - * and store them in matched_paths - */ - while ((usb_dev = g_dir_read_name(devices_dir))) { - FILE *fd; - char tmp[5]; - - gchar *vendor_path; - gchar *product_path; - - unsigned long read_vendor_id; - unsigned long read_product_id; - - vendor_path = g_strconcat(device_tree, - usb_dev, "/idVendor", NULL); - product_path = g_strconcat(device_tree, - usb_dev, "/idProduct", NULL); - - if (!g_file_test(vendor_path, G_FILE_TEST_EXISTS) || - !g_file_test(product_path, G_FILE_TEST_EXISTS)) - goto skip_device; - - if ((fd = g_fopen(vendor_path, "r")) == NULL) - goto skip_device; - - if (fgets(tmp, sizeof(tmp), fd) == NULL) { - fclose(fd); - goto skip_device; - } - read_vendor_id = strtoul(tmp, NULL, 16); - - fclose(fd); - - if ((fd = g_fopen(product_path, "r")) == NULL) - goto skip_device; + unsigned int i; - if (fgets(tmp, sizeof(tmp), fd) == NULL) { - fclose(fd); - goto skip_device; - } - read_product_id = strtoul(tmp, NULL, 16); + for (i = 0; i < ARRAY_SIZE(manufacturers); ++i) + if (!strcmp(manufacturer, manufacturers[i])) + return SR_OK; - fclose(fd); + return SR_ERR; +} - if (vendor_id == read_vendor_id && - product_id == read_product_id) { - gchar *path_copy; +static struct sr_dev_inst *hmo_probe_serial_device(struct sr_scpi_dev_inst *scpi) +{ + struct sr_dev_inst *sdi; + struct dev_context *devc; + struct sr_scpi_hw_info *hw_info; - path_copy = g_strdup(usb_dev); - matched_paths = g_slist_prepend(matched_paths, - path_copy); - } + sdi = NULL; + devc = NULL; + hw_info = NULL; - skip_device: - g_free(vendor_path); - g_free(product_path); + if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) { + sr_info("Couldn't get IDN response."); + goto fail; } - g_dir_close(devices_dir); - /* For every matched device try to find a ttyUSBX subfolder */ - for (l = matched_paths; l; l = l->next) { - const char *file; + if (check_manufacturer(hw_info->manufacturer) != SR_OK) + goto fail; - GDir *device_dir; + if (!(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, + hw_info->manufacturer, hw_info->model, + hw_info->firmware_version))) { + goto fail; + } + sr_scpi_hw_info_free(hw_info); + hw_info = NULL; - gchar *prefix; - gchar *subdir_path; - gchar *device_path; + if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) + goto fail; - subdir_path = NULL; + sdi->driver = di; + sdi->priv = devc; + sdi->inst_type = SR_INST_SCPI; + sdi->conn = scpi; - device_path = g_strconcat(device_tree, l->data, NULL); + if (hmo_init_device(sdi) != SR_OK) + goto fail; - if (!(device_dir = g_dir_open(device_path, 0, NULL))) { - g_free(device_path); - continue; - } + sr_scpi_close(sdi->conn); - prefix = g_strconcat(l->data, ":", NULL); - - while ((file = g_dir_read_name(device_dir))) { - if (g_str_has_prefix(file, prefix)) { - subdir_path = g_strconcat(device_path, - "/", file, - NULL); - break; - } - } - g_dir_close(device_dir); + sdi->status = SR_ST_INACTIVE; - g_free(prefix); - g_free(device_path); + return sdi; - if (subdir_path) { - if (!(device_dir = g_dir_open(subdir_path, 0, NULL))) { - g_free(subdir_path); - continue; - } - g_free(subdir_path); - - while ((file = g_dir_read_name(device_dir))) { - if (g_str_has_prefix(file, "ttyUSB")) { - gchar *tty_path; - - tty_path = g_strconcat("/dev/", - file, NULL); - sr_dbg("Found USB device %04x:%04x attached to %s", - vendor_id, product_id, tty_path); - tty_devices = g_slist_prepend(tty_devices, - tty_path); - break; - } - } - g_dir_close(device_dir); - } - } - g_slist_free_full(matched_paths, g_free); +fail: + if (hw_info) + sr_scpi_hw_info_free(hw_info); + if (sdi) + sr_dev_inst_free(sdi); + if (devc) + g_free(devc); - return tty_devices; -#else return NULL; -#endif } static GSList *scan(GSList *options) { - GSList *devices; - - struct drv_context *drvc; - struct sr_dev_inst *sdi; - - const char *serial_device; - const char *serial_options; - - serial_device = NULL; - serial_options = SERIALCOMM; - - sdi = NULL; - devices = NULL; - drvc = di->priv; - drvc->instances = NULL; - - if (sr_serial_extract_options(options, &serial_device, - &serial_options) == SR_OK) { - sdi = hameg_probe_serial_device(serial_device, serial_options); - - if (sdi != NULL) { - devices = g_slist_append(devices, sdi); - drvc->instances = g_slist_append(drvc->instances, sdi); - } - - } else { - GSList *l; - GSList *tty_devices; - - unsigned int i; - - tty_devices = NULL; - - for (i = 0; i < ARRAY_SIZE(ho_models); i++) { - if ((l = auto_find_usb(ho_models[i].vendor_id, - ho_models[i].product_id)) == NULL) - continue; - - tty_devices = g_slist_concat(tty_devices, l); - } - - for (l = tty_devices; l; l = l->next) { - sdi = hameg_probe_serial_device(l->data, serial_options); - if (sdi != NULL) { - devices = g_slist_append(devices, sdi); - drvc->instances = g_slist_append(drvc->instances, sdi); - } - } - - g_slist_free_full(tty_devices, g_free); - } - - return devices; + return sr_scpi_scan(di->priv, options, hmo_probe_serial_device); } static GSList *dev_list(void) @@ -269,21 +124,19 @@ static GSList *dev_list(void) static void clear_helper(void *priv) { unsigned int i; - struct dev_context *devc; struct scope_config *model; devc = priv; model = devc->model_config; - scope_state_free(devc->model_state); + hmo_scope_state_free(devc->model_state); - for (i = 0; i < model->analog_channels; ++i) { - g_slist_free(devc->analog_groups[i].probes); - } + for (i = 0; i < model->analog_channels; ++i) + g_slist_free(devc->analog_groups[i].channels); for (i = 0; i < model->digital_pods; ++i) { - g_slist_free(devc->digital_groups[i].probes); + g_slist_free(devc->digital_groups[i].channels); g_free(devc->digital_groups[i].name); } @@ -300,11 +153,10 @@ static int dev_clear(void) static int dev_open(struct sr_dev_inst *sdi) { - if (sdi->status != SR_ST_ACTIVE && - serial_open(sdi->conn, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) + if (sdi->status != SR_ST_ACTIVE && sr_scpi_open(sdi->conn) != SR_OK) return SR_ERR; - if (scope_state_get(sdi) != SR_OK) + if (hmo_scope_state_get(sdi) != SR_OK) return SR_ERR; sdi->status = SR_ST_ACTIVE; @@ -317,7 +169,7 @@ static int dev_close(struct sr_dev_inst *sdi) if (sdi->status == SR_ST_INACTIVE) return SR_OK; - serial_close(sdi->conn); + sr_scpi_close(sdi->conn); sdi->status = SR_ST_INACTIVE; @@ -331,73 +183,128 @@ static int cleanup(void) return SR_OK; } -static int check_probe_group(struct dev_context *devc, - const struct sr_probe_group *probe_group) +static int check_channel_group(struct dev_context *devc, + const struct sr_channel_group *cg) { unsigned int i; struct scope_config *model; model = devc->model_config; - if (!probe_group) - return PG_NONE; + if (!cg) + return CG_NONE; for (i = 0; i < model->analog_channels; ++i) - if (probe_group == &devc->analog_groups[i]) - return PG_ANALOG; + if (cg == &devc->analog_groups[i]) + return CG_ANALOG; for (i = 0; i < model->digital_pods; ++i) - if (probe_group == &devc->digital_groups[i]) - return PG_DIGITAL; + if (cg == &devc->digital_groups[i]) + return CG_DIGITAL; + + sr_err("Invalid channel group specified."); - sr_err("Invalid probe group specified."); - return PG_INVALID; + return CG_INVALID; } static int config_get(int key, GVariant **data, const struct sr_dev_inst *sdi, - const struct sr_probe_group *probe_group) + const struct sr_channel_group *cg) { - int ret; - int pg_type; + int ret, cg_type; unsigned int i; - struct dev_context *devc; struct scope_config *model; + struct scope_state *state; if (!sdi || !(devc = sdi->priv)) return SR_ERR_ARG; - if ((pg_type = check_probe_group(devc, probe_group)) == PG_INVALID) + if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; ret = SR_ERR_NA; model = devc->model_config; + state = devc->model_state; switch (key) { case SR_CONF_NUM_TIMEBASE: *data = g_variant_new_int32(model->num_xdivs); ret = SR_OK; break; - + case SR_CONF_TIMEBASE: + *data = g_variant_new("(tt)", (*model->timebases)[state->timebase][0], + (*model->timebases)[state->timebase][1]); + ret = SR_OK; + break; case SR_CONF_NUM_VDIV: - if (pg_type == PG_NONE) { - sr_err("No probe group specified."); - return SR_ERR_PROBE_GROUP; + if (cg_type == CG_NONE) { + sr_err("No channel group specified."); + return SR_ERR_CHANNEL_GROUP; + } else if (cg_type == CG_ANALOG) { + for (i = 0; i < model->analog_channels; ++i) { + if (cg != &devc->analog_groups[i]) + continue; + *data = g_variant_new_int32(model->num_ydivs); + ret = SR_OK; + break; + } - } else if (pg_type == PG_ANALOG) { + } else { + ret = SR_ERR_NA; + } + break; + case SR_CONF_VDIV: + if (cg_type == CG_NONE) { + sr_err("No channel group specified."); + return SR_ERR_CHANNEL_GROUP; + } else if (cg_type == CG_ANALOG) { for (i = 0; i < model->analog_channels; ++i) { - if (probe_group == &devc->analog_groups[i]) { - *data = g_variant_new_int32(model->num_ydivs); - ret = SR_OK; - break; - } + if (cg != &devc->analog_groups[i]) + continue; + *data = g_variant_new("(tt)", + (*model->vdivs)[state->analog_channels[i].vdiv][0], + (*model->vdivs)[state->analog_channels[i].vdiv][1]); + ret = SR_OK; + break; } } else { ret = SR_ERR_NA; } break; + case SR_CONF_TRIGGER_SOURCE: + *data = g_variant_new_string((*model->trigger_sources)[state->trigger_source]); + ret = SR_OK; + break; + case SR_CONF_TRIGGER_SLOPE: + *data = g_variant_new_string((*model->trigger_slopes)[state->trigger_slope]); + ret = SR_OK; + break; + case SR_CONF_HORIZ_TRIGGERPOS: + *data = g_variant_new_double(state->horiz_triggerpos); + ret = SR_OK; + break; + case SR_CONF_COUPLING: + if (cg_type == CG_NONE) { + sr_err("No channel group specified."); + return SR_ERR_CHANNEL_GROUP; + } else if (cg_type == CG_ANALOG) { + for (i = 0; i < model->analog_channels; ++i) { + if (cg != &devc->analog_groups[i]) + continue; + *data = g_variant_new_string((*model->coupling_options)[state->analog_channels[i].coupling]); + ret = SR_OK; + break; + } + } else { + ret = SR_ERR_NA; + } + break; + case SR_CONF_SAMPLERATE: + *data = g_variant_new_uint64(state->sample_rate); + ret = SR_OK; + break; default: ret = SR_ERR_NA; } @@ -408,7 +315,6 @@ static int config_get(int key, GVariant **data, const struct sr_dev_inst *sdi, static GVariant *build_tuples(const uint64_t (*array)[][2], unsigned int n) { unsigned int i; - GVariant *rational[2]; GVariantBuilder gvb; @@ -418,7 +324,7 @@ static GVariant *build_tuples(const uint64_t (*array)[][2], unsigned int n) rational[0] = g_variant_new_uint64((*array)[i][0]); rational[1] = g_variant_new_uint64((*array)[i][1]); - /* FIXME valgrind reports a memory leak here */ + /* FIXME: Valgrind reports a memory leak here. */ g_variant_builder_add_value(&gvb, g_variant_new_tuple(rational, 2)); } @@ -426,25 +332,28 @@ static GVariant *build_tuples(const uint64_t (*array)[][2], unsigned int n) } static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi, - const struct sr_probe_group *probe_group) + const struct sr_channel_group *cg) { - int ret; - int pg_type; - unsigned int i; - char command[MAX_COMMAND_SIZE]; - + int ret, cg_type; + unsigned int i, j; + char command[MAX_COMMAND_SIZE], float_str[30]; struct dev_context *devc; struct scope_config *model; struct scope_state *state; + const char *tmp; + uint64_t p, q; + double tmp_d; + gboolean update_sample_rate; if (!sdi || !(devc = sdi->priv)) return SR_ERR_ARG; - if ((pg_type = check_probe_group(devc, probe_group)) == PG_INVALID) + if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; model = devc->model_config; state = devc->model_state; + update_sample_rate = FALSE; ret = SR_ERR_NA; @@ -453,159 +362,133 @@ static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi, devc->frame_limit = g_variant_get_uint64(data); ret = SR_OK; break; - case SR_CONF_TRIGGER_SOURCE: - { - const char *tmp; - tmp = g_variant_get_string(data, NULL); - for (i = 0; (*model->trigger_sources)[i]; i++) { - if (!g_strcmp0(tmp, (*model->trigger_sources)[i])) { - state->trigger_source = i; - - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SOURCE], - (*model->trigger_sources)[i]); + if (g_strcmp0(tmp, (*model->trigger_sources)[i]) != 0) + continue; + state->trigger_source = i; + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SOURCE], + (*model->trigger_sources)[i]); - ret = sr_scpi_send(sdi->conn, command); - break; - } + ret = sr_scpi_send(sdi->conn, command); + break; } - } - break; - + break; case SR_CONF_VDIV: - { - unsigned int j; - uint64_t p, q; - - if (pg_type == PG_NONE) { - sr_err("No probe group specified."); - return SR_ERR_PROBE_GROUP; + if (cg_type == CG_NONE) { + sr_err("No channel group specified."); + return SR_ERR_CHANNEL_GROUP; } g_variant_get(data, "(tt)", &p, &q); for (i = 0; i < model->num_vdivs; i++) { - if (p == (*model->vdivs)[i][0] && - q == (*model->vdivs)[i][1]){ - for (j = 1; j <= model->analog_channels; ++j) { - if (probe_group == &devc->analog_groups[j - 1]) { - state->analog_channels[j-1].vdiv = (float) p / q; - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_VERTICAL_DIV], - j, state->analog_channels[j-1].vdiv); - - if (sr_scpi_send(sdi->conn, command) != SR_OK || - sr_scpi_get_opc(sdi->conn) != SR_OK) - return SR_ERR; - - break; - } - } + if (p != (*model->vdivs)[i][0] || + q != (*model->vdivs)[i][1]) + continue; + for (j = 1; j <= model->analog_channels; ++j) { + if (cg != &devc->analog_groups[j - 1]) + continue; + state->analog_channels[j - 1].vdiv = i; + g_ascii_formatd(float_str, sizeof(float_str), "%E", (float) p / q); + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_VERTICAL_DIV], + j, float_str); + + if (sr_scpi_send(sdi->conn, command) != SR_OK || + sr_scpi_get_opc(sdi->conn) != SR_OK) + return SR_ERR; - ret = SR_OK; break; } - } - } - break; + ret = SR_OK; + break; + } + break; case SR_CONF_TIMEBASE: - { - uint64_t p, q; - g_variant_get(data, "(tt)", &p, &q); for (i = 0; i < model->num_timebases; i++) { - if (p == (*model->timebases)[i][0] && - q == (*model->timebases)[i][1]){ - state->timebase = (float) p / q; - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_TIMEBASE], - state->timebase); + if (p != (*model->timebases)[i][0] || + q != (*model->timebases)[i][1]) + continue; + state->timebase = i; + g_ascii_formatd(float_str, sizeof(float_str), "%E", (float) p / q); + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_TIMEBASE], + float_str); - ret = sr_scpi_send(sdi->conn, command); - break; - } + ret = sr_scpi_send(sdi->conn, command); + update_sample_rate = TRUE; + break; } - } - break; - + break; case SR_CONF_HORIZ_TRIGGERPOS: - { - double tmp; - - tmp = g_variant_get_double(data); + tmp_d = g_variant_get_double(data); - if (tmp < 0.0 || tmp > 1.0) + if (tmp_d < 0.0 || tmp_d > 1.0) return SR_ERR; - state->horiz_triggerpos = -(tmp - 0.5) * state->timebase * model->num_xdivs; + state->horiz_triggerpos = tmp_d; + tmp_d = -(tmp_d - 0.5) * + ((double) (*model->timebases)[state->timebase][0] / + (*model->timebases)[state->timebase][1]) + * model->num_xdivs; + + g_ascii_formatd(float_str, sizeof(float_str), "%E", tmp_d); g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_HORIZ_TRIGGERPOS], - state->horiz_triggerpos); + float_str); ret = sr_scpi_send(sdi->conn, command); - } - break; - + break; case SR_CONF_TRIGGER_SLOPE: - { - uint64_t tmp; - - tmp = g_variant_get_uint64(data); + tmp = g_variant_get_string(data, NULL); - if (tmp != 0 && tmp != 1) - return SR_ERR; + if (!tmp || !(tmp[0] == 'f' || tmp[0] == 'r')) + return SR_ERR_ARG; - state->trigger_slope = tmp; + state->trigger_slope = (tmp[0] == 'r') ? 0 : 1; g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_SET_TRIGGER_SLOPE], - tmp ? "POS" : "NEG"); + (state->trigger_slope == 0) ? "POS" : "NEG"); ret = sr_scpi_send(sdi->conn, command); - } - break; - + break; case SR_CONF_COUPLING: - { - unsigned int j; - const char *tmp; - - if (pg_type == PG_NONE) { - sr_err("No probe group specified."); - return SR_ERR_PROBE_GROUP; + if (cg_type == CG_NONE) { + sr_err("No channel group specified."); + return SR_ERR_CHANNEL_GROUP; } tmp = g_variant_get_string(data, NULL); for (i = 0; (*model->coupling_options)[i]; i++) { - if (!strcmp(tmp, (*model->coupling_options)[i])) { - for (j = 1; j <= model->analog_channels; ++j) { - if (probe_group == &devc->analog_groups[j - 1]) { - state->analog_channels[j-1].coupling = i; - - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_COUPLING], - j, tmp); - - if (sr_scpi_send(sdi->conn, command) != SR_OK || - sr_scpi_get_opc(sdi->conn) != SR_OK) - return SR_ERR; - break; - } - } + if (strcmp(tmp, (*model->coupling_options)[i]) != 0) + continue; + for (j = 1; j <= model->analog_channels; ++j) { + if (cg != &devc->analog_groups[j - 1]) + continue; + state->analog_channels[j-1].coupling = i; - ret = SR_OK; + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_COUPLING], + j, tmp); + + if (sr_scpi_send(sdi->conn, command) != SR_OK || + sr_scpi_get_opc(sdi->conn) != SR_OK) + return SR_ERR; break; } - } - } - break; + ret = SR_OK; + break; + } + break; default: ret = SR_ERR_NA; break; @@ -614,67 +497,64 @@ static int config_set(int key, GVariant *data, const struct sr_dev_inst *sdi, if (ret == SR_OK) ret = sr_scpi_get_opc(sdi->conn); + if (ret == SR_OK && update_sample_rate) + ret = hmo_update_sample_rate(sdi); + return ret; } static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, - const struct sr_probe_group *probe_group) + const struct sr_channel_group *cg) { - int pg_type; - + int cg_type; struct dev_context *devc; struct scope_config *model; if (!sdi || !(devc = sdi->priv)) return SR_ERR_ARG; - if ((pg_type = check_probe_group(devc, probe_group)) == PG_INVALID) + if ((cg_type = check_channel_group(devc, cg)) == CG_INVALID) return SR_ERR; model = devc->model_config; switch (key) { case SR_CONF_DEVICE_OPTIONS: - if (pg_type == PG_NONE) { + if (cg_type == CG_NONE) { *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, - model->hw_caps, - model->num_hwcaps, - sizeof(int32_t)); - } else if (pg_type == PG_ANALOG) { + model->hw_caps, model->num_hwcaps, + sizeof(int32_t)); + } else if (cg_type == CG_ANALOG) { *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, - model->analog_hwcaps, - model->num_analog_hwcaps, - sizeof(int32_t)); + model->analog_hwcaps, model->num_analog_hwcaps, + sizeof(int32_t)); } else { *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32, - NULL, 0, sizeof(int32_t)); + NULL, 0, sizeof(int32_t)); } break; - case SR_CONF_COUPLING: - if (pg_type == PG_NONE) - return SR_ERR_PROBE_GROUP; - + if (cg_type == CG_NONE) + return SR_ERR_CHANNEL_GROUP; *data = g_variant_new_strv(*model->coupling_options, - g_strv_length((char **) *model->coupling_options)); + g_strv_length((char **)*model->coupling_options)); break; - case SR_CONF_TRIGGER_SOURCE: *data = g_variant_new_strv(*model->trigger_sources, - g_strv_length((char **) *model->trigger_sources)); + g_strv_length((char **)*model->trigger_sources)); + break; + case SR_CONF_TRIGGER_SLOPE: + *data = g_variant_new_strv(*model->trigger_slopes, + g_strv_length((char **)*model->trigger_slopes)); break; - case SR_CONF_TIMEBASE: *data = build_tuples(model->timebases, model->num_timebases); break; - case SR_CONF_VDIV: - if (pg_type == PG_NONE) - return SR_ERR_PROBE_GROUP; - + if (cg_type == CG_NONE) + return SR_ERR_CHANNEL_GROUP; *data = build_tuples(model->vdivs, model->num_vdivs); break; - default: return SR_ERR_NA; } @@ -685,68 +565,57 @@ static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi, SR_PRIV int hmo_request_data(const struct sr_dev_inst *sdi) { char command[MAX_COMMAND_SIZE]; - - struct sr_probe *probe; + struct sr_channel *ch; struct dev_context *devc; struct scope_config *model; devc = sdi->priv; model = devc->model_config; - probe = devc->current_probe->data; + ch = devc->current_channel->data; - switch (probe->type) { - case SR_PROBE_ANALOG: + switch (ch->type) { + case SR_CHANNEL_ANALOG: g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_GET_ANALOG_DATA], - probe->index + 1); + ch->index + 1); break; - case SR_PROBE_LOGIC: + case SR_CHANNEL_LOGIC: g_snprintf(command, sizeof(command), (*model->scpi_dialect)[SCPI_CMD_GET_DIG_DATA], - probe->index < 8 ? 1 : 2); + ch->index < 8 ? 1 : 2); break; default: - sr_err("Invalid probe type"); + sr_err("Invalid channel type."); break; } return sr_scpi_send(sdi->conn, command); } -static int hmo_check_probes(GSList *probes) +static int hmo_check_channels(GSList *channels) { GSList *l; - gboolean enabled_pod1; - gboolean enabled_pod2; - gboolean enabled_chan3; - gboolean enabled_chan4; - - struct sr_probe *probe; + struct sr_channel *ch; + gboolean enabled_pod1, enabled_pod2, enabled_chan3, enabled_chan4; - enabled_pod1 = FALSE; - enabled_pod2 = FALSE; - enabled_chan3 = FALSE; - enabled_chan4 = FALSE; + enabled_pod1 = enabled_pod2 = enabled_chan3 = enabled_chan4 = FALSE; - for (l = probes; l; l = l->next) { - probe = l->data; - - switch (probe->type) { - case SR_PROBE_ANALOG: - if (probe->index == 2) + for (l = channels; l; l = l->next) { + ch = l->data; + switch (ch->type) { + case SR_CHANNEL_ANALOG: + if (ch->index == 2) enabled_chan3 = TRUE; - else if (probe->index == 3) + else if (ch->index == 3) enabled_chan4 = TRUE; break; - - case SR_PROBE_LOGIC: - if (probe->index < 8) + case SR_CHANNEL_LOGIC: + if (ch->index < 8) enabled_pod1 = TRUE; else enabled_pod2 = TRUE; break; - default: return SR_ERR; } @@ -759,87 +628,83 @@ static int hmo_check_probes(GSList *probes) return SR_OK; } -static int hmo_setup_probes(const struct sr_dev_inst *sdi) +static int hmo_setup_channels(const struct sr_dev_inst *sdi) { GSList *l; unsigned int i; - gboolean *pod_enabled; + gboolean *pod_enabled, setup_changed; char command[MAX_COMMAND_SIZE]; - struct scope_state *state; struct scope_config *model; - - struct sr_probe *probe; + struct sr_channel *ch; struct dev_context *devc; - struct sr_serial_dev_inst *serial; + struct sr_scpi_dev_inst *scpi; devc = sdi->priv; - serial = sdi->conn; + scpi = sdi->conn; state = devc->model_state; model = devc->model_config; + setup_changed = FALSE; pod_enabled = g_try_malloc0(sizeof(gboolean) * model->digital_pods); - for (l = sdi->probes; l; l = l->next) { - probe = l->data; - - switch (probe->type) { - case SR_PROBE_ANALOG: - { - if (probe->enabled != state->analog_channels[probe->index].state) { - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_ANALOG_CHAN_STATE], - probe->index + 1, probe->enabled); - - if (sr_scpi_send(serial, command) != SR_OK) - return SR_ERR; - state->analog_channels[probe->index].state = probe->enabled; - } - } - break; + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + switch (ch->type) { + case SR_CHANNEL_ANALOG: + if (ch->enabled == state->analog_channels[ch->index].state) + break; + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_ANALOG_CHAN_STATE], + ch->index + 1, ch->enabled); - case SR_PROBE_LOGIC: - { + if (sr_scpi_send(scpi, command) != SR_OK) + return SR_ERR; + state->analog_channels[ch->index].state = ch->enabled; + setup_changed = TRUE; + break; + case SR_CHANNEL_LOGIC: /* * A digital POD needs to be enabled for every group of - * 8 probes. + * 8 channels. */ - if (probe->enabled) - pod_enabled[probe->index < 8 ? 0 : 1] = TRUE; - - if (probe->enabled != state->digital_channels[probe->index]) { - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_DIG_CHAN_STATE], - probe->index, probe->enabled); + if (ch->enabled) + pod_enabled[ch->index < 8 ? 0 : 1] = TRUE; - if (sr_scpi_send(serial, command) != SR_OK) - return SR_ERR; + if (ch->enabled == state->digital_channels[ch->index]) + break; + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_DIG_CHAN_STATE], + ch->index, ch->enabled); - state->digital_channels[probe->index] = probe->enabled; - } - } - break; + if (sr_scpi_send(scpi, command) != SR_OK) + return SR_ERR; + state->digital_channels[ch->index] = ch->enabled; + setup_changed = TRUE; + break; default: return SR_ERR; } } for (i = 1; i <= model->digital_pods; ++i) { - if (state->digital_pods[i-1] != pod_enabled[i-1]) { - g_snprintf(command, sizeof(command), - (*model->scpi_dialect)[SCPI_CMD_SET_DIG_POD_STATE], - i, pod_enabled[i-1]); - - if (sr_scpi_send(serial, command) != SR_OK) - return SR_ERR; - - state->digital_pods[i-1] = pod_enabled[i-1]; - } + if (state->digital_pods[i - 1] == pod_enabled[i - 1]) + continue; + g_snprintf(command, sizeof(command), + (*model->scpi_dialect)[SCPI_CMD_SET_DIG_POD_STATE], + i, pod_enabled[i - 1]); + if (sr_scpi_send(scpi, command) != SR_OK) + return SR_ERR; + state->digital_pods[i - 1] = pod_enabled[i - 1]; + setup_changed = TRUE; } g_free(pod_enabled); + if (setup_changed && hmo_update_sample_rate(sdi) != SR_OK) + return SR_ERR; + return SR_OK; } @@ -847,51 +712,49 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) { GSList *l; gboolean digital_added; - - struct sr_probe *probe; + struct sr_channel *ch; struct dev_context *devc; - struct sr_serial_dev_inst *serial; + struct sr_scpi_dev_inst *scpi; if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; - serial = sdi->conn; + scpi = sdi->conn; devc = sdi->priv; digital_added = FALSE; - for (l = sdi->probes; l; l = l->next) { - probe = l->data; - - if (probe->enabled) { - /* Only add a single digital probe */ - if (probe->type != SR_PROBE_LOGIC || !digital_added) { - devc->enabled_probes = g_slist_append(devc->enabled_probes, - probe); - if (probe->type == SR_PROBE_LOGIC) - digital_added = TRUE; - } + for (l = sdi->channels; l; l = l->next) { + ch = l->data; + if (!ch->enabled) + continue; + /* Only add a single digital channel. */ + if (ch->type != SR_CHANNEL_LOGIC || !digital_added) { + devc->enabled_channels = g_slist_append( + devc->enabled_channels, ch); + if (ch->type == SR_CHANNEL_LOGIC) + digital_added = TRUE; } } - if (!devc->enabled_probes) + if (!devc->enabled_channels) return SR_ERR; - if (hmo_check_probes(devc->enabled_probes) != SR_OK) { - sr_err("Invalid probe configuration specified!"); + if (hmo_check_channels(devc->enabled_channels) != SR_OK) { + sr_err("Invalid channel configuration specified!"); return SR_ERR_NA; } - if (hmo_setup_probes(sdi) != SR_OK) { - sr_err("Failed to setup probe configuration!"); + if (hmo_setup_channels(sdi) != SR_OK) { + sr_err("Failed to setup channel configuration!"); return SR_ERR; } - sr_source_add(serial->fd, G_IO_IN, 50, hameg_hmo_receive_data, (void *)sdi); + sr_scpi_source_add(scpi, G_IO_IN, 50, hmo_receive_data, (void *)sdi); /* Send header packet to the session bus. */ std_session_send_df_header(cb_data, LOG_PREFIX); - devc->current_probe = devc->enabled_probes; + devc->current_channel = devc->enabled_channels; return hmo_request_data(sdi); } @@ -899,26 +762,32 @@ static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data) static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data) { struct dev_context *devc; - struct sr_serial_dev_inst *serial; + struct sr_scpi_dev_inst *scpi; + struct sr_datafeed_packet packet; (void)cb_data; + packet.type = SR_DF_END; + packet.payload = NULL; + sr_session_send(sdi, &packet); + if (sdi->status != SR_ST_ACTIVE) return SR_ERR_DEV_CLOSED; devc = sdi->priv; - g_slist_free(devc->enabled_probes); - devc->enabled_probes = NULL; - serial = sdi->conn; - sr_source_remove(serial->fd); + devc->num_frames = 0; + g_slist_free(devc->enabled_channels); + devc->enabled_channels = NULL; + scpi = sdi->conn; + sr_scpi_source_remove(scpi); return SR_OK; } SR_PRIV struct sr_dev_driver hameg_hmo_driver_info = { .name = "hameg-hmo", - .longname = "Hameg HMO scope driver", + .longname = "Hameg HMO", .api_version = 1, .init = init, .cleanup = cleanup,