static int hw_init(const char *devinfo) { struct sr_dev_inst *sdi; struct context *ctx; int devcnt = 0; /* Avoid compiler warnings. */ (void)devinfo; if (libusb_init(&genericdmm_usb_context) != 0) { sr_err("genericdmm: Failed to initialize USB."); return 0; } if (!(ctx = g_try_malloc0(sizeof(struct context)))) { sr_err("genericdmm: ctx malloc failed."); return 0; } devcnt = g_slist_length(genericdmm_dev_insts); if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, "Generic DMM", NULL, NULL))) { sr_err("genericdmm: sr_dev_inst_new returned NULL."); return 0; } sdi->priv = ctx; genericdmm_dev_insts = g_slist_append(genericdmm_dev_insts, sdi); /* Always initialized just one device instance. */ return 0; }
static GSList *scan(GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_channel *ch; GSList *usb_devices, *devices, *l; char *model; (void)options; drvc = di->priv; drvc->instances = NULL; devices = NULL; if ((usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, USB_CONN))) { /* We have a list of sr_usb_dev_inst matching the connection * string. Wrap them in sr_dev_inst and we're done. */ for (l = usb_devices; l; l = l->next) { if (scan_kecheng(l->data, &model) != SR_OK) continue; if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, VENDOR, model, NULL))) return NULL; g_free(model); sdi->driver = di; sdi->inst_type = SR_INST_USB; sdi->conn = l->data; if (!(ch = sr_channel_new(0, SR_CHANNEL_ANALOG, TRUE, "SPL"))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); if (!(devc = g_try_malloc(sizeof(struct dev_context)))) { sr_dbg("Device context malloc failed."); return NULL; } sdi->priv = devc; devc->limit_samples = 0; /* The protocol provides no way to read the current * settings, so we'll enforce these. */ devc->sample_interval = DEFAULT_SAMPLE_INTERVAL; devc->alarm_low = DEFAULT_ALARM_LOW; devc->alarm_high = DEFAULT_ALARM_HIGH; devc->mqflags = DEFAULT_WEIGHT_TIME | DEFAULT_WEIGHT_FREQ; devc->data_source = DEFAULT_DATA_SOURCE; devc->config_dirty = FALSE; /* TODO: Set date/time? */ drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); } g_slist_free(usb_devices); } else g_slist_free_full(usb_devices, g_free); return devices; }
static GSList *mic_scan(const char *conn, const char *serialcomm, int idx) { struct sr_dev_inst *sdi; struct drv_context *drvc; struct dev_context *devc; struct sr_probe *probe; struct sr_serial_dev_inst *serial; GSList *devices; if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) return NULL; drvc = mic_devs[idx].di->priv; devices = NULL; serial_flush(serial); /* TODO: Query device type. */ // ret = mic_cmd_get_device_info(serial); sr_info("Found device on port %s.", conn); /* TODO: Fill in version from protocol response. */ if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, mic_devs[idx].vendor, mic_devs[idx].device, ""))) goto scan_cleanup; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); goto scan_cleanup; } sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; sdi->priv = devc; sdi->driver = mic_devs[idx].di; if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "Temperature"))) goto scan_cleanup; sdi->probes = g_slist_append(sdi->probes, probe); if (mic_devs[idx].has_humidity) { if (!(probe = sr_probe_new(1, SR_PROBE_ANALOG, TRUE, "Humidity"))) goto scan_cleanup; sdi->probes = g_slist_append(sdi->probes, probe); } drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); scan_cleanup: serial_close(serial); return devices; }
static GSList *scan(GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_config *src; struct sr_probe *probe; GSList *devices, *l; const char *conn, *serialcomm; drvc = di->priv; drvc->instances = NULL; devices = NULL; conn = serialcomm = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = SERIALCOMM; if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Colead", "SL-5868P", NULL))) return NULL; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_dbg("Device context malloc failed."); return NULL; } if (!(sdi->conn = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; sdi->inst_type = SR_INST_SERIAL; sdi->priv = devc; sdi->driver = di; if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1"))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); return devices; }
static struct sr_dev_inst *dso_dev_new(int index, const struct dso_profile *prof) { struct sr_dev_inst *sdi; struct sr_probe *probe; struct drv_context *drvc; struct dev_context *devc; int i; sdi = sr_dev_inst_new(index, SR_ST_INITIALIZING, prof->vendor, prof->model, NULL); if (!sdi) return NULL; sdi->driver = di; /* * Add only the real probes -- EXT isn't a source of data, only * a trigger source internal to the device. */ for (i = 0; probe_names[i]; i++) { if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, probe_names[i]))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); } if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } devc->profile = prof; devc->dev_state = IDLE; devc->timebase = DEFAULT_TIMEBASE; devc->ch1_enabled = TRUE; devc->ch2_enabled = TRUE; devc->voltage_ch1 = DEFAULT_VOLTAGE; devc->voltage_ch2 = DEFAULT_VOLTAGE; devc->coupling_ch1 = DEFAULT_COUPLING; devc->coupling_ch2 = DEFAULT_COUPLING; devc->voffset_ch1 = DEFAULT_VERT_OFFSET; devc->voffset_ch2 = DEFAULT_VERT_OFFSET; devc->voffset_trigger = DEFAULT_VERT_TRIGGERPOS; devc->framesize = DEFAULT_FRAMESIZE; devc->triggerslope = SLOPE_POSITIVE; devc->triggersource = g_strdup(DEFAULT_TRIGGER_SOURCE); devc->triggerposition = DEFAULT_HORIZ_TRIGGERPOS; sdi->priv = devc; drvc = di->priv; drvc->instances = g_slist_append(drvc->instances, sdi); return sdi; }
static int init(struct sr_input *in, const char *filename) { struct sr_probe *probe; int num_probes, i; char name[SR_MAX_PROBENAME_LEN + 1]; char *param; struct context *ctx; (void)filename; if (!(ctx = g_try_malloc0(sizeof(*ctx)))) { sr_err("Input format context malloc failed."); return SR_ERR_MALLOC; } num_probes = DEFAULT_NUM_PROBES; ctx->samplerate = 0; if (in->param) { param = g_hash_table_lookup(in->param, "numprobes"); if (param) { num_probes = strtoul(param, NULL, 10); if (num_probes < 1) return SR_ERR; } param = g_hash_table_lookup(in->param, "samplerate"); if (param) { if (sr_parse_sizestring(param, &ctx->samplerate) != SR_OK) return SR_ERR; } } /* Create a virtual device. */ in->sdi = sr_dev_inst_new(LOGIC, 0, SR_ST_ACTIVE, NULL, NULL, NULL); in->internal = ctx; for (i = 0; i < num_probes; i++) { snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i); /* TODO: Check return value. */ if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name))) return SR_ERR; in->sdi->probes = g_slist_append(in->sdi->probes, probe); } return SR_OK; }
static GSList *scan(GSList *options) { struct sr_dev_inst *sdi; struct sr_probe *probe; struct drv_context *drvc; struct dev_context *devc; GSList *devices; int i; (void)options; drvc = di->priv; devices = NULL; sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, DEMONAME, NULL, NULL); if (!sdi) { sr_err("Device instance creation failed."); return NULL; } sdi->driver = di; for (i = 0; probe_names[i]; i++) { if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_names[i]))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); } devices = g_slist_append(devices, sdi); drvc->instances = g_slist_append(drvc->instances, sdi); if (!(devc = g_try_malloc(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } devc->sdi = sdi; devc->cur_samplerate = SR_KHZ(200); devc->limit_samples = 0; devc->limit_msec = 0; devc->sample_generator = PATTERN_SIGROK; sdi->priv = devc; return devices; }
static int init(struct sr_input *in, const char *filename) { struct sr_probe *probe; struct context *ctx; char buf[40], probename[8]; int i; if (get_wav_header(filename, buf) != SR_OK) return SR_ERR; if (!(ctx = g_try_malloc0(sizeof(struct context)))) return SR_ERR_MALLOC; /* Create a virtual device. */ in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL); in->sdi->priv = ctx; ctx->samplerate = GUINT32_FROM_LE(*(uint32_t *)(buf + 24)); ctx->samplesize = GUINT16_FROM_LE(*(uint16_t *)(buf + 34)) / 8; if (ctx->samplesize != 1 && ctx->samplesize != 2 && ctx->samplesize != 4) { sr_err("only 8, 16 or 32 bits per sample supported."); return SR_ERR; } if ((ctx->num_channels = GUINT16_FROM_LE(*(uint16_t *)(buf + 22))) > 20) { sr_err("%d channels seems crazy.", ctx->num_channels); return SR_ERR; } for (i = 0; i < ctx->num_channels; i++) { snprintf(probename, 8, "CH%d", i + 1); if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, probename))) return SR_ERR; in->sdi->probes = g_slist_append(in->sdi->probes, probe); } return SR_OK; }
static GSList *scan(GSList *options) { GSList *usb_devices, *devices, *l; struct drv_context *drvc; struct sr_dev_inst *sdi; struct sr_probe *probe; struct dev_context *devc; struct sr_usb_dev_inst *usb; struct device_info dev_info; int ret, device_index, i; char *fw_ver_str; (void)options; devices = NULL; drvc = di->priv; drvc->instances = NULL; device_index = 0; usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, USB_VID_PID); if (usb_devices == NULL) return NULL; for (l = usb_devices; l; l = l->next) { usb = l->data; if ((ret = sl2_get_device_info(*usb, &dev_info)) < 0) { sr_warn("Failed to get device information: %d.", ret); sr_usb_dev_inst_free(usb); continue; } if (!(devc = g_try_malloc(sizeof(struct dev_context)))) { sr_err("Device instance malloc failed."); sr_usb_dev_inst_free(usb); continue; } if (!(devc->xfer_in = libusb_alloc_transfer(0))) { sr_err("Transfer malloc failed."); sr_usb_dev_inst_free(usb); g_free(devc); continue; } if (!(devc->xfer_out = libusb_alloc_transfer(0))) { sr_err("Transfer malloc failed."); sr_usb_dev_inst_free(usb); libusb_free_transfer(devc->xfer_in); g_free(devc); continue; } fw_ver_str = g_strdup_printf("%u.%u", dev_info.fw_ver_major, dev_info.fw_ver_minor); if (!fw_ver_str) { sr_err("Firmware string malloc failed."); sr_usb_dev_inst_free(usb); libusb_free_transfer(devc->xfer_in); libusb_free_transfer(devc->xfer_out); g_free(devc); continue; } sdi = sr_dev_inst_new(device_index, SR_ST_INACTIVE, VENDOR_NAME, MODEL_NAME, fw_ver_str); g_free(fw_ver_str); if (!sdi) { sr_err("sr_dev_inst_new failed."); sr_usb_dev_inst_free(usb); libusb_free_transfer(devc->xfer_in); libusb_free_transfer(devc->xfer_out); g_free(devc); continue; } sdi->priv = devc; sdi->driver = di; sdi->inst_type = SR_INST_USB; sdi->conn = usb; for (i = 0; probe_names[i]; i++) { probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_names[i]); sdi->probes = g_slist_append(sdi->probes, probe); devc->probes[i] = probe; } devc->state = STATE_IDLE; devc->next_state = STATE_IDLE; /* Set default samplerate. */ sl2_set_samplerate(sdi, DEFAULT_SAMPLERATE); /* Set default capture ratio. */ devc->capture_ratio = 0; /* Set default after trigger delay. */ devc->after_trigger_delay = 0; memset(devc->xfer_buf_in, 0, LIBUSB_CONTROL_SETUP_SIZE + PACKET_LENGTH); memset(devc->xfer_buf_out, 0, LIBUSB_CONTROL_SETUP_SIZE + PACKET_LENGTH); libusb_fill_control_setup(devc->xfer_buf_in, USB_REQUEST_TYPE_IN, USB_HID_GET_REPORT, USB_HID_REPORT_TYPE_FEATURE, USB_INTERFACE, PACKET_LENGTH); libusb_fill_control_setup(devc->xfer_buf_out, USB_REQUEST_TYPE_OUT, USB_HID_SET_REPORT, USB_HID_REPORT_TYPE_FEATURE, USB_INTERFACE, PACKET_LENGTH); devc->xfer_data_in = devc->xfer_buf_in + LIBUSB_CONTROL_SETUP_SIZE; devc->xfer_data_out = devc->xfer_buf_out + LIBUSB_CONTROL_SETUP_SIZE; drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); device_index++; } g_slist_free(usb_devices); return devices; }
static GSList *scan(GSList *options) { struct sr_dev_inst *sdi; struct sr_probe *probe; struct drv_context *drvc; struct dev_context *devc; GSList *devices; unsigned int i; int ret; (void)options; drvc = di->priv; devices = NULL; /* Allocate memory for our private device context. */ if (!(devc = g_try_malloc(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); goto err_free_nothing; } /* Set some sane defaults. */ devc->ftdic = NULL; devc->cur_samplerate = SR_MHZ(100); /* 100MHz == max. samplerate */ devc->limit_msec = 0; devc->limit_samples = 0; devc->cb_data = NULL; memset(devc->mangled_buf, 0, BS); devc->final_buf = NULL; devc->trigger_pattern = 0x00; /* Value irrelevant, see trigger_mask. */ devc->trigger_mask = 0x00; /* All probes are "don't care". */ devc->trigger_timeout = 10; /* Default to 10s trigger timeout. */ devc->trigger_found = 0; devc->done = 0; devc->block_counter = 0; devc->divcount = 0; /* 10ns sample period == 100MHz samplerate */ devc->usb_pid = 0; /* Allocate memory where we'll store the de-mangled data. */ if (!(devc->final_buf = g_try_malloc(SDRAM_SIZE))) { sr_err("final_buf malloc failed."); goto err_free_devc; } /* Allocate memory for the FTDI context (ftdic) and initialize it. */ if (!(devc->ftdic = ftdi_new())) { sr_err("%s: ftdi_new failed.", __func__); goto err_free_final_buf; } /* Check for the device and temporarily open it. */ for (i = 0; i < ARRAY_SIZE(usb_pids); i++) { sr_dbg("Probing for VID/PID %04x:%04x.", USB_VENDOR_ID, usb_pids[i]); ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID, usb_pids[i], USB_DESCRIPTION, NULL); if (ret == 0) { sr_dbg("Found LA8 device (%04x:%04x).", USB_VENDOR_ID, usb_pids[i]); devc->usb_pid = usb_pids[i]; } } if (devc->usb_pid == 0) goto err_free_ftdic; /* Register the device with libsigrok. */ sdi = sr_dev_inst_new(0, SR_ST_INITIALIZING, USB_VENDOR_NAME, USB_MODEL_NAME, USB_MODEL_VERSION); if (!sdi) { sr_err("%s: sr_dev_inst_new failed.", __func__); goto err_close_ftdic; } sdi->driver = di; sdi->priv = devc; for (i = 0; chronovu_la8_probe_names[i]; i++) { if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, chronovu_la8_probe_names[i]))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); } devices = g_slist_append(devices, sdi); drvc->instances = g_slist_append(drvc->instances, sdi); /* Close device. We'll reopen it again when we need it. */ (void) la8_close(devc); /* Log, but ignore errors. */ return devices; err_close_ftdic: (void) la8_close(devc); /* Log, but ignore errors. */ err_free_ftdic: ftdi_free(devc->ftdic); /* NOT free() or g_free()! */ err_free_final_buf: g_free(devc->final_buf); err_free_devc: g_free(devc); err_free_nothing: return NULL; }
static GSList *scan(GSList *options, int dmm) { GSList *usb_devices, *devices, *l; struct sr_dev_inst *sdi; struct dev_context *devc; struct drv_context *drvc; struct sr_usb_dev_inst *usb; struct sr_config *src; struct sr_channel *ch; const char *conn; drvc = udmms[dmm].di->priv; conn = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; devices = NULL; if (!(usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn))) { g_slist_free_full(usb_devices, g_free); return NULL; } for (l = usb_devices; l; l = l->next) { usb = l->data; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } devc->first_run = TRUE; if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, udmms[dmm].vendor, udmms[dmm].device, NULL))) { sr_err("sr_dev_inst_new returned NULL."); return NULL; } sdi->priv = devc; sdi->driver = udmms[dmm].di; if (!(ch = sr_channel_new(0, SR_CHANNEL_ANALOG, TRUE, "P1"))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); sdi->inst_type = SR_INST_USB; sdi->conn = usb; drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); } return devices; }
static int probe_port(const char *port, GSList **devices) { struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_serial_dev_inst *serial; struct sr_probe *probe; unsigned int i; int len, num_tokens; gboolean matched, has_digital; const char *manufacturer, *model, *version; char buf[256]; gchar **tokens, *channel_name; *devices = NULL; if (!(serial = sr_serial_dev_inst_new(port, NULL))) return SR_ERR_MALLOC; if (serial_open(serial, SERIAL_RDWR) != SR_OK) return SR_ERR; len = serial_write(serial, "*IDN?", 5); len = serial_read(serial, buf, sizeof(buf)); if (serial_close(serial) != SR_OK) return SR_ERR; sr_serial_dev_inst_free(serial); if (len == 0) return SR_ERR_NA; buf[len] = 0; tokens = g_strsplit(buf, ",", 0); sr_dbg("response: %s [%s]", port, buf); for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++); if (num_tokens < 4) { g_strfreev(tokens); return SR_ERR_NA; } manufacturer = tokens[0]; model = tokens[1]; version = tokens[3]; if (strcmp(manufacturer, "Rigol Technologies")) { g_strfreev(tokens); return SR_ERR_NA; } matched = has_digital = FALSE; for (i = 0; i < ARRAY_SIZE(supported_models); i++) { if (!strcmp(model, supported_models[i])) { matched = TRUE; has_digital = g_str_has_suffix(model, "D"); break; } } if (!matched || !(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, manufacturer, model, version))) { g_strfreev(tokens); return SR_ERR_NA; } g_strfreev(tokens); if (!(sdi->conn = sr_serial_dev_inst_new(port, NULL))) return SR_ERR_MALLOC; sdi->driver = di; sdi->inst_type = SR_INST_SERIAL; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) return SR_ERR_MALLOC; devc->limit_frames = 0; devc->has_digital = has_digital; for (i = 0; i < 2; i++) { if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, i == 0 ? "CH1" : "CH2"))) return SR_ERR_MALLOC; sdi->probes = g_slist_append(sdi->probes, probe); } if (devc->has_digital) { for (i = 0; i < 16; i++) { if (!(channel_name = g_strdup_printf("D%d", i))) return SR_ERR_MALLOC; probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, channel_name); g_free(channel_name); if (!probe) return SR_ERR_MALLOC; sdi->probes = g_slist_append(sdi->probes, probe); } } sdi->priv = devc; *devices = g_slist_append(NULL, sdi); return SR_OK; }
static GSList *hw_scan(GSList *options) { GSList *usb_devices, *devices, *l; struct sr_dev_inst *sdi; struct dev_context *devc; struct drv_context *drvc; struct sr_usb_dev_inst *usb; struct sr_config *src; struct sr_probe *probe; const char *conn; (void)options; drvc = di->priv; /* USB scan is always authoritative. */ clear_instances(); conn = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = src->value; break; } } if (!conn) conn = UNI_T_UT_D04_NEW; devices = NULL; if (!(usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn))) { g_slist_free_full(usb_devices, g_free); return NULL; } for (l = usb_devices; l; l = l->next) { usb = l->data; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, di->longname, NULL, NULL))) { sr_err("sr_dev_inst_new returned NULL."); return NULL; } sdi->priv = devc; sdi->driver = di; if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1"))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); devc->usb = usb; drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); } return devices; }
static GSList *scan(GSList *options, int modelid) { struct sr_dev_inst *sdi; struct drv_context *drvc; struct dev_context *devc; struct sr_config *src; struct sr_channel *ch; struct sr_channel_group *cg; struct sr_serial_dev_inst *serial; GSList *l, *devices; struct pps_model *model; uint8_t packet[PACKET_SIZE]; unsigned int i; int ret; const char *conn, *serialcomm; char channel[10]; devices = NULL; drvc = di->priv; drvc->instances = NULL; conn = serialcomm = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = SERIALCOMM; if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) return NULL; serial_flush(serial); /* This is how the vendor software channels for hardware. */ memset(packet, 0, PACKET_SIZE); packet[0] = 0xaa; packet[1] = 0xaa; if (serial_write(serial, packet, PACKET_SIZE) == -1) { sr_err("Unable to write while probing for hardware: %s", strerror(errno)); return NULL; } /* The device responds with a 24-byte packet when it receives a packet. * At 9600 baud, 300ms is long enough for it to have arrived. */ g_usleep(300 * 1000); memset(packet, 0, PACKET_SIZE); if ((ret = serial_read_nonblocking(serial, packet, PACKET_SIZE)) < 0) { sr_err("Unable to read while probing for hardware: %s", strerror(errno)); return NULL; } if (ret != PACKET_SIZE || packet[0] != 0xaa || packet[1] != 0xaa) { /* Doesn't look like an Atten PPS. */ return NULL; } model = NULL; for (i = 0; i < ARRAY_SIZE(models); i++) { if (models[i].modelid == modelid) { model = &models[i]; break; } } if (!model) { sr_err("Unknown modelid %d", modelid); return NULL; } sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Atten", model->name, NULL); sdi->driver = di; sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; for (i = 0; i < MAX_CHANNELS; i++) { snprintf(channel, 10, "CH%d", i + 1); ch = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE, channel); sdi->channels = g_slist_append(sdi->channels, ch); cg = g_malloc(sizeof(struct sr_channel_group)); cg->name = g_strdup(channel); cg->channels = g_slist_append(NULL, ch); cg->priv = NULL; sdi->channel_groups = g_slist_append(sdi->channel_groups, cg); } devc = g_malloc0(sizeof(struct dev_context)); devc->model = model; devc->config = g_malloc0(sizeof(struct per_channel_config) * model->num_channels); sdi->priv = devc; drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); serial_close(serial); if (!devices) sr_serial_dev_inst_free(serial); return devices; }
static GSList *hw_scan(GSList *options) { struct sr_dev_inst *sdi; struct sr_channel *probe; struct drv_context *drvc; struct dev_context *devc; GSList *devices; uint16_t i; (void)options; drvc = di->priv; devices = NULL; sdi = sr_dev_inst_new(LOGIC, 0, SR_ST_INITIALIZING, DEMONAME, NULL, NULL); if (!sdi) { sr_err("Device instance creation failed."); return NULL; } sdi->driver = di; devices = g_slist_append(devices, sdi); drvc->instances = g_slist_append(drvc->instances, sdi); if (!(devc = g_try_malloc(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } devc->sdi = sdi; devc->cur_samplerate = SR_MHZ(1); devc->limit_samples = SR_MB(1); devc->limit_samples_show = devc->limit_samples; devc->limit_msec = 0; devc->sample_generator = PATTERN_SINE; devc->timebase = 500; devc->data_lock = FALSE; devc->max_height = 0; devc->dso_bits = 8; sdi->priv = devc; if (sdi->mode == LOGIC) { for (i = 0; probe_names[i]; i++) { if (!(probe = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, probe_names[i]))) return NULL; sdi->channels = g_slist_append(sdi->channels, probe); } } else if (sdi->mode == DSO) { for (i = 0; i < DS_MAX_DSO_PROBES_NUM; i++) { if (!(probe = sr_channel_new(i, SR_CHANNEL_DSO, TRUE, probe_names[i]))) return NULL; sdi->channels = g_slist_append(sdi->channels, probe); } } else if (sdi->mode == ANALOG) { for (i = 0; i < DS_MAX_ANALOG_PROBES_NUM; i++) { if (!(probe = sr_channel_new(i, SR_CHANNEL_ANALOG, TRUE, probe_names[i]))) return NULL; sdi->channels = g_slist_append(sdi->channels, probe); } } return devices; }
static GSList *sdmm_scan(const char *conn, const char *serialcomm, int dmm) { struct sr_dev_inst *sdi; struct drv_context *drvc; struct dev_context *devc; struct sr_channel *ch; struct sr_serial_dev_inst *serial; GSList *devices; int dropped, ret; size_t len; uint8_t buf[128]; if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) return NULL; sr_info("Probing serial port %s.", conn); drvc = dmms[dmm].di->priv; devices = NULL; serial_flush(serial); /* Request a packet if the DMM requires this. */ if (dmms[dmm].packet_request) { if ((ret = dmms[dmm].packet_request(serial)) < 0) { sr_err("Failed to request packet: %d.", ret); return FALSE; } } /* * There's no way to get an ID from the multimeter. It just sends data * periodically (or upon request), so the best we can do is check if * the packets match the expected format. */ /* Let's get a bit of data and see if we can find a packet. */ len = sizeof(buf); ret = serial_stream_detect(serial, buf, &len, dmms[dmm].packet_size, dmms[dmm].packet_valid, 3000, dmms[dmm].baudrate); if (ret != SR_OK) goto scan_cleanup; /* * If we dropped more than two packets worth of data, something is * wrong. We shouldn't quit however, since the dropped bytes might be * just zeroes at the beginning of the stream. Those can occur as a * combination of the nonstandard cable that ships with some devices * and the serial port or USB to serial adapter. */ dropped = len - dmms[dmm].packet_size; if (dropped > 2 * dmms[dmm].packet_size) sr_warn("Had to drop too much data."); sr_info("Found device on port %s.", conn); if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, dmms[dmm].vendor, dmms[dmm].device, NULL))) goto scan_cleanup; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); goto scan_cleanup; } sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; sdi->priv = devc; sdi->driver = dmms[dmm].di; if (!(ch = sr_channel_new(0, SR_CHANNEL_ANALOG, TRUE, "P1"))) goto scan_cleanup; sdi->channels = g_slist_append(sdi->channels, ch); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); scan_cleanup: serial_close(serial); return devices; }
static int hw_init(const char *devinfo) { struct sr_dev_inst *sdi; struct libusb_device_descriptor des; libusb_device **devlist; int ret, devcnt, i; struct context *ctx; /* Avoid compiler warnings. */ (void)devinfo; /* Allocate memory for our private driver context. */ if (!(ctx = g_try_malloc(sizeof(struct context)))) { sr_err("zp: %s: ctx malloc failed", __func__); return 0; } /* Set some sane defaults. */ ctx->cur_samplerate = 0; ctx->limit_samples = 0; ctx->num_channels = 32; /* TODO: This isn't initialized before it's needed :( */ ctx->memory_size = 0; ctx->probe_mask = 0; memset(ctx->trigger_mask, 0, NUM_TRIGGER_STAGES); memset(ctx->trigger_value, 0, NUM_TRIGGER_STAGES); // memset(ctx->trigger_buffer, 0, NUM_TRIGGER_STAGES); if (libusb_init(&usb_context) != 0) { sr_err("zp: Failed to initialize USB."); return 0; } /* Find all ZeroPlus analyzers and add them to device list. */ devcnt = 0; libusb_get_device_list(usb_context, &devlist); /* TODO: Errors. */ for (i = 0; devlist[i]; i++) { ret = libusb_get_device_descriptor(devlist[i], &des); if (ret != 0) { sr_err("zp: failed to get device descriptor: %d", ret); continue; } if (des.idVendor == USB_VENDOR) { /* * Definitely a Zeroplus. * TODO: Any way to detect specific model/version in * the zeroplus range? */ /* Register the device with libsigrok. */ if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_INACTIVE, USB_VENDOR_NAME, USB_MODEL_NAME, USB_MODEL_VERSION))) { sr_err("zp: %s: sr_dev_inst_new failed", __func__); return 0; } sdi->priv = ctx; dev_insts = g_slist_append(dev_insts, sdi); ctx->usb = sr_usb_dev_inst_new( libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), NULL); devcnt++; } } libusb_free_device_list(devlist, 1); return devcnt; }
/** * Load the session from the specified filename. * * @param filename The name of the session file to load. Must not be NULL. * * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, * SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon * other errors. */ SR_API int sr_session_load(const char *filename) { GKeyFile *kf; GPtrArray *capturefiles; struct zip *archive; struct zip_file *zf; struct zip_stat zs; struct sr_dev_inst *sdi; struct sr_channel *ch; int devcnt, ret, i, j; uint64_t tmp_u64, total_channels, enabled_channels, p; char **sections, **keys, *metafile, *val; char channelname[SR_MAX_CHANNELNAME_LEN + 1]; if ((ret = sr_sessionfile_check(filename)) != SR_OK) return ret; if (!(archive = zip_open(filename, 0, &ret))) return SR_ERR; if (zip_stat(archive, "metadata", 0, &zs) == -1) return SR_ERR; if (!(metafile = g_try_malloc(zs.size))) { sr_err("%s: metafile malloc failed", __func__); return SR_ERR_MALLOC; } zf = zip_fopen_index(archive, zs.index, 0); zip_fread(zf, metafile, zs.size); zip_fclose(zf); kf = g_key_file_new(); if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) { sr_dbg("Failed to parse metadata."); return SR_ERR; } sr_session_new(); devcnt = 0; capturefiles = g_ptr_array_new_with_free_func(g_free); sections = g_key_file_get_groups(kf, NULL); for (i = 0; sections[i]; i++) { if (!strcmp(sections[i], "global")) /* nothing really interesting in here yet */ continue; if (!strncmp(sections[i], "device ", 7)) { /* device section */ sdi = NULL; enabled_channels = total_channels = 0; keys = g_key_file_get_keys(kf, sections[i], NULL, NULL); for (j = 0; keys[j]; j++) { val = g_key_file_get_string(kf, sections[i], keys[j], NULL); if (!strcmp(keys[j], "capturefile")) { sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, NULL, NULL, NULL); sdi->driver = &session_driver; if (devcnt == 0) /* first device, init the driver */ sdi->driver->init(NULL); sr_dev_open(sdi); sr_session_dev_add(sdi); sdi->driver->config_set(SR_CONF_SESSIONFILE, g_variant_new_string(filename), sdi, NULL); sdi->driver->config_set(SR_CONF_CAPTUREFILE, g_variant_new_string(val), sdi, NULL); g_ptr_array_add(capturefiles, val); } else if (!strcmp(keys[j], "samplerate")) { sr_parse_sizestring(val, &tmp_u64); sdi->driver->config_set(SR_CONF_SAMPLERATE, g_variant_new_uint64(tmp_u64), sdi, NULL); } else if (!strcmp(keys[j], "unitsize")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE, g_variant_new_uint64(tmp_u64), sdi, NULL); } else if (!strcmp(keys[j], "total probes")) { total_channels = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_NUM_LOGIC_CHANNELS, g_variant_new_uint64(total_channels), sdi, NULL); for (p = 0; p < total_channels; p++) { snprintf(channelname, SR_MAX_CHANNELNAME_LEN, "%" PRIu64, p); if (!(ch = sr_channel_new(p, SR_CHANNEL_LOGIC, TRUE, channelname))) return SR_ERR; sdi->channels = g_slist_append(sdi->channels, ch); } } else if (!strncmp(keys[j], "probe", 5)) { if (!sdi) continue; enabled_channels++; tmp_u64 = strtoul(keys[j]+5, NULL, 10); /* sr_session_save() */ sr_dev_channel_name_set(sdi, tmp_u64 - 1, val); } } g_strfreev(keys); /* Disable channels not specifically listed. */ if (total_channels) for (p = enabled_channels; p < total_channels; p++) sr_dev_channel_enable(sdi, p, FALSE); } devcnt++; } g_strfreev(sections); g_key_file_free(kf); return SR_OK; }
static GSList *scan(GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_serial_dev_inst *serial; struct sr_dev_inst *sdi; struct sr_probe *probe; struct sr_config *src; GSList *devices, *l; const char *conn, *serialcomm; uint8_t buf[50]; size_t len; len = sizeof(buf); devices = NULL; conn = serialcomm = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = "9600/8n1"; if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDONLY | SERIAL_NONBLOCK) != SR_OK) return NULL; sr_info("Probing serial port %s.", conn); drvc = di->priv; drvc->instances = NULL; serial_flush(serial); /* Let's get a bit of data and see if we can find a packet. */ if (serial_stream_detect(serial, buf, &len, 25, appa_55ii_packet_valid, 500, 9600) != SR_OK) goto scan_cleanup; sr_info("Found device on port %s.", conn); if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "APPA", "55II", ""))) goto scan_cleanup; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); goto scan_cleanup; } devc->data_source = DEFAULT_DATA_SOURCE; sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; sdi->priv = devc; sdi->driver = di; if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "T1"))) goto scan_cleanup; sdi->probes = g_slist_append(sdi->probes, probe); if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "T2"))) goto scan_cleanup; sdi->probes = g_slist_append(sdi->probes, probe); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); scan_cleanup: serial_close(serial); return devices; }
static int init(struct sr_input *in, const char *filename) { struct sr_probe *probe; int num_probes, i; char name[SR_MAX_PROBENAME_LEN + 1]; char *param; struct context *ctx; (void)filename; if (!(ctx = g_try_malloc0(sizeof(*ctx)))) { sr_err("Input format context malloc failed."); return SR_ERR_MALLOC; } num_probes = DEFAULT_NUM_PROBES; ctx->samplerate = 0; ctx->downsample = 1; ctx->skip = -1; if (in->param) { param = g_hash_table_lookup(in->param, "numprobes"); if (param) { num_probes = strtoul(param, NULL, 10); if (num_probes < 1) { release_context(ctx); return SR_ERR; } } param = g_hash_table_lookup(in->param, "downsample"); if (param) { ctx->downsample = strtoul(param, NULL, 10); if (ctx->downsample < 1) { ctx->downsample = 1; } } param = g_hash_table_lookup(in->param, "compress"); if (param) { ctx->compress = strtoul(param, NULL, 10); } param = g_hash_table_lookup(in->param, "skip"); if (param) { ctx->skip = strtoul(param, NULL, 10) / ctx->downsample; } } /* Maximum number of probes to parse from the VCD */ ctx->maxprobes = num_probes; /* Create a virtual device. */ in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL); in->internal = ctx; for (i = 0; i < num_probes; i++) { snprintf(name, SR_MAX_PROBENAME_LEN, "%d", i); if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, name))) { release_context(ctx); return SR_ERR; } in->sdi->probes = g_slist_append(in->sdi->probes, probe); } return SR_OK; }
static int init(struct sr_input *in, const char *filename) { int res; struct context *ctx; const char *param; GIOStatus status; gsize i, term_pos; char probe_name[SR_MAX_PROBENAME_LEN + 1]; struct sr_probe *probe; char **columns; gsize num_columns; char *ptr; if (!(ctx = g_try_malloc0(sizeof(struct context)))) { sr_err("Context malloc failed."); return SR_ERR_MALLOC; } /* Create a virtual device. */ in->sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, NULL, NULL, NULL); in->internal = ctx; /* Set default samplerate. */ ctx->samplerate = 0; /* * Enable auto-detection of the number of probes in multi column mode * and enforce the specification of the number of probes in single * column mode. */ ctx->num_probes = 0; /* Set default delimiter. */ if (!(ctx->delimiter = g_string_new(","))) { sr_err("Delimiter malloc failed."); free_context(ctx); return SR_ERR_MALLOC; } /* * Set default comment prefix. Note that an empty comment prefix * disables removing of comments. */ if (!(ctx->comment = g_string_new(""))) { sr_err("Comment malloc failed."); free_context(ctx); return SR_ERR_MALLOC; } /* Enable multi column mode by default. */ ctx->multi_column_mode = TRUE; /* Use first column as default single column number. */ ctx->single_column = 0; /* * In multi column mode start parsing sample data at the first column * and in single column mode at the first bit. */ ctx->first_probe = 0; /* Start at the beginning of the file. */ ctx->start_line = 1; /* Disable the usage of the first line as header by default. */ ctx->header = FALSE; /* Set default format for single column mode. */ ctx->format = FORMAT_BIN; if (!(ctx->buffer = g_string_new(""))) { sr_err("Line buffer malloc failed."); free_context(ctx); return SR_ERR_MALLOC; } if (in->param) { if ((param = g_hash_table_lookup(in->param, "samplerate"))) { res = sr_parse_sizestring(param, &ctx->samplerate); if (res != SR_OK) { sr_err("Invalid samplerate: %s.", param); free_context(ctx); return SR_ERR_ARG; } } if ((param = g_hash_table_lookup(in->param, "numprobes"))) ctx->num_probes = g_ascii_strtoull(param, NULL, 10); if ((param = g_hash_table_lookup(in->param, "delimiter"))) { if (!strlen(param)) { sr_err("Delimiter must be at least one character."); free_context(ctx); return SR_ERR_ARG; } if (!g_ascii_strcasecmp(param, "\\t")) g_string_assign(ctx->delimiter, "\t"); else g_string_assign(ctx->delimiter, param); } if ((param = g_hash_table_lookup(in->param, "comment"))) g_string_assign(ctx->comment, param); if ((param = g_hash_table_lookup(in->param, "single-column"))) { ctx->single_column = g_ascii_strtoull(param, &ptr, 10); ctx->multi_column_mode = FALSE; if (param == ptr) { sr_err("Invalid single-colum number: %s.", param); free_context(ctx); return SR_ERR_ARG; } } if ((param = g_hash_table_lookup(in->param, "first-probe"))) ctx->first_probe = g_ascii_strtoull(param, NULL, 10); if ((param = g_hash_table_lookup(in->param, "startline"))) { ctx->start_line = g_ascii_strtoull(param, NULL, 10); if (ctx->start_line < 1) { sr_err("Invalid start line: %s.", param); free_context(ctx); return SR_ERR_ARG; } } if ((param = g_hash_table_lookup(in->param, "header"))) ctx->header = sr_parse_boolstring(param); if ((param = g_hash_table_lookup(in->param, "format"))) { if (!g_ascii_strncasecmp(param, "bin", 3)) { ctx->format = FORMAT_BIN; } else if (!g_ascii_strncasecmp(param, "hex", 3)) { ctx->format = FORMAT_HEX; } else if (!g_ascii_strncasecmp(param, "oct", 3)) { ctx->format = FORMAT_OCT; } else { sr_err("Invalid format: %s.", param); free_context(ctx); return SR_ERR; } } } if (ctx->multi_column_mode) ctx->first_column = ctx->first_probe; else ctx->first_column = ctx->single_column; if (!ctx->multi_column_mode && !ctx->num_probes) { sr_err("Number of probes needs to be specified in single column mode."); free_context(ctx); return SR_ERR; } if (!(ctx->channel = g_io_channel_new_file(filename, "r", NULL))) { sr_err("Input file '%s' could not be opened.", filename); free_context(ctx); return SR_ERR; } while (TRUE) { ctx->line_number++; status = g_io_channel_read_line_string(ctx->channel, ctx->buffer, &term_pos, NULL); if (status == G_IO_STATUS_EOF) { sr_err("Input file is empty."); free_context(ctx); return SR_ERR; } if (status != G_IO_STATUS_NORMAL) { sr_err("Error while reading line %zu.", ctx->line_number); free_context(ctx); return SR_ERR; } if (ctx->start_line > ctx->line_number) { sr_spew("Line %zu skipped.", ctx->line_number); continue; } /* Remove line termination character(s). */ g_string_truncate(ctx->buffer, term_pos); if (!ctx->buffer->len) { sr_spew("Blank line %zu skipped.", ctx->line_number); continue; } /* Remove trailing comment. */ strip_comment(ctx->buffer, ctx->comment); if (ctx->buffer->len) break; sr_spew("Comment-only line %zu skipped.", ctx->line_number); } /* * In order to determine the number of columns parse the current line * without limiting the number of columns. */ if (!(columns = parse_line(ctx, -1))) { sr_err("Error while parsing line %zu.", ctx->line_number); free_context(ctx); return SR_ERR; } num_columns = g_strv_length(columns); /* Ensure that the first column is not out of bounds. */ if (!num_columns) { sr_err("Column %zu in line %zu is out of bounds.", ctx->first_column, ctx->line_number); g_strfreev(columns); free_context(ctx); return SR_ERR; } if (ctx->multi_column_mode) { /* * Detect the number of probes in multi column mode * automatically if not specified. */ if (!ctx->num_probes) { ctx->num_probes = num_columns; sr_info("Number of auto-detected probes: %zu.", ctx->num_probes); } /* * Ensure that the number of probes does not exceed the number * of columns in multi column mode. */ if (num_columns < ctx->num_probes) { sr_err("Not enough columns for desired number of probes in line %zu.", ctx->line_number); g_strfreev(columns); free_context(ctx); return SR_ERR; } } for (i = 0; i < ctx->num_probes; i++) { if (ctx->header && ctx->multi_column_mode && strlen(columns[i])) snprintf(probe_name, sizeof(probe_name), "%s", columns[i]); else snprintf(probe_name, sizeof(probe_name), "%zu", i); probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, probe_name); if (!probe) { sr_err("Probe creation failed."); free_context(ctx); g_strfreev(columns); return SR_ERR; } in->sdi->probes = g_slist_append(in->sdi->probes, probe); } g_strfreev(columns); /* * Calculate the minimum buffer size to store the sample data of the * probes. */ ctx->sample_buffer_size = (ctx->num_probes + 7) >> 3; if (!(ctx->sample_buffer = g_try_malloc(ctx->sample_buffer_size))) { sr_err("Sample buffer malloc failed."); free_context(ctx); return SR_ERR_MALLOC; } return SR_OK; }
static GSList *scan(GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_channel *ch; struct sr_channel_group *cg; struct sr_config *src; struct analog_gen *ag; GSList *devices, *l; int num_logic_channels, num_analog_channels, pattern, i; char channel_name[16]; drvc = di->priv; num_logic_channels = DEFAULT_NUM_LOGIC_CHANNELS; num_analog_channels = DEFAULT_NUM_ANALOG_CHANNELS; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_NUM_LOGIC_CHANNELS: num_logic_channels = g_variant_get_int32(src->data); break; case SR_CONF_NUM_ANALOG_CHANNELS: num_analog_channels = g_variant_get_int32(src->data); break; } } devices = NULL; sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Demo device", NULL, NULL); if (!sdi) { sr_err("Device instance creation failed."); return NULL; } sdi->driver = di; if (!(devc = g_try_malloc(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } devc->cur_samplerate = SR_KHZ(200); devc->limit_samples = 0; devc->limit_msec = 0; devc->step = 0; devc->num_logic_channels = num_logic_channels; devc->logic_unitsize = (devc->num_logic_channels + 7) / 8; devc->logic_pattern = PATTERN_SIGROK; devc->num_analog_channels = num_analog_channels; devc->analog_channel_groups = NULL; /* Logic channels, all in one channel group. */ if (!(cg = g_try_malloc(sizeof(struct sr_channel_group)))) return NULL; cg->name = g_strdup("Logic"); cg->channels = NULL; cg->priv = NULL; for (i = 0; i < num_logic_channels; i++) { sprintf(channel_name, "D%d", i); if (!(ch = sr_channel_new(i, SR_CHANNEL_LOGIC, TRUE, channel_name))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); cg->channels = g_slist_append(cg->channels, ch); } sdi->channel_groups = g_slist_append(NULL, cg); /* Analog channels, channel groups and pattern generators. */ pattern = 0; for (i = 0; i < num_analog_channels; i++) { sprintf(channel_name, "A%d", i); if (!(ch = sr_channel_new(i + num_logic_channels, SR_CHANNEL_ANALOG, TRUE, channel_name))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); /* Every analog channel gets its own channel group. */ if (!(cg = g_try_malloc(sizeof(struct sr_channel_group)))) return NULL; cg->name = g_strdup(channel_name); cg->channels = g_slist_append(NULL, ch); /* Every channel group gets a generator struct. */ if (!(ag = g_try_malloc(sizeof(struct analog_gen)))) return NULL; ag->packet.channels = cg->channels; ag->packet.mq = 0; ag->packet.mqflags = 0; ag->packet.unit = SR_UNIT_VOLT; ag->packet.data = ag->pattern_data; ag->pattern = pattern; cg->priv = ag; sdi->channel_groups = g_slist_append(sdi->channel_groups, cg); devc->analog_channel_groups = g_slist_append(devc->analog_channel_groups, cg); if (++pattern == ARRAY_SIZE(analog_pattern_str)) pattern = 0; } sdi->priv = devc; devices = g_slist_append(devices, sdi); drvc->instances = g_slist_append(drvc->instances, sdi); return devices; }
static GSList *hw_scan(GSList *options) { int i; GSList *devices = NULL; const char *conn = NULL; const char *serialcomm = NULL; GSList *l; struct sr_config *src; struct udev *udev; (void)options; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = src->value; break; case SR_CONF_SERIALCOMM: serialcomm = src->value; break; } } if (!conn) conn = SERIALCONN; if (serialcomm == NULL) serialcomm = SERIALCOMM; udev = udev_new(); if (!udev) { sr_err("Failed to initialize udev."); } struct udev_enumerate *enumerate = udev_enumerate_new(udev); udev_enumerate_add_match_subsystem(enumerate, "usb-serial"); udev_enumerate_scan_devices(enumerate); struct udev_list_entry *devs = udev_enumerate_get_list_entry(enumerate); struct udev_list_entry *dev_list_entry; for (dev_list_entry = devs; dev_list_entry != NULL; dev_list_entry = udev_list_entry_get_next(dev_list_entry)) { const char *syspath = udev_list_entry_get_name(dev_list_entry); struct udev_device *dev = udev_device_new_from_syspath(udev, syspath); const char *sysname = udev_device_get_sysname(dev); struct udev_device *parent = udev_device_get_parent_with_subsystem_devtype(dev, "usb", "usb_device"); if (!parent) { sr_err("Unable to find parent usb device for %s", sysname); continue; } const char *idVendor = udev_device_get_sysattr_value(parent, "idVendor"); const char *idProduct = udev_device_get_sysattr_value(parent, "idProduct"); if (strcmp(USB_VENDOR, idVendor) || strcmp(USB_PRODUCT, idProduct)) continue; const char *iSerial = udev_device_get_sysattr_value(parent, "serial"); const char *iProduct = udev_device_get_sysattr_value(parent, "product"); char path[32]; snprintf(path, sizeof(path), "/dev/%s", sysname); conn = path; size_t s = strcspn(iProduct, " "); char product[32]; char manufacturer[32]; if (s > sizeof(product) || strlen(iProduct) - s > sizeof(manufacturer)) { sr_err("Could not parse iProduct: %s.", iProduct); continue; } strncpy(product, iProduct, s); product[s] = 0; strcpy(manufacturer, iProduct + s + 1); //Create the device context and set its params struct dev_context *devc; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return devices; } if (mso_parse_serial(iSerial, iProduct, devc) != SR_OK) { sr_err("Invalid iSerial: %s.", iSerial); g_free(devc); return devices; } char hwrev[32]; sprintf(hwrev, "r%d", devc->hwrev); devc->ctlbase1 = 0; devc->protocol_trigger.spimode = 0; for (i = 0; i < 4; i++) { devc->protocol_trigger.word[i] = 0; devc->protocol_trigger.mask[i] = 0xff; } if (!(devc->serial = sr_serial_dev_inst_new(conn, serialcomm))) { g_free(devc); return devices; } struct sr_dev_inst *sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, manufacturer, product, hwrev); if (!sdi) { sr_err("Unable to create device instance for %s", sysname); sr_dev_inst_free(sdi); g_free(devc); return devices; } sdi->driver = di; sdi->priv = devc; for (i = 0; i < NUM_PROBES; i++) { struct sr_probe *probe; if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE, mso19_probe_names[i]))) return 0; sdi->probes = g_slist_append(sdi->probes, probe); } //Add the driver struct drv_context *drvc = di->priv; drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); } return devices; }
static GSList *scan(GSList *options) { struct sr_dev_inst *sdi; struct drv_context *drvc; struct sr_config *src; struct sr_channel *ch; struct sr_serial_dev_inst *serial; GSList *l, *devices; const char *conn, *serialcomm; devices = NULL; drvc = di->priv; drvc->instances = NULL; conn = serialcomm = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = SERIALCOMM; /* * We cannot scan for this device because it is write-only. * So just check that the port parameters are valid and assume that * the device is there. */ if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) return NULL; serial_flush(serial); serial_close(serial); sr_spew("Conrad DIGI 35 CPU assumed at %s.", conn); if (!(sdi = sr_dev_inst_new(0, SR_ST_ACTIVE, "Conrad", "DIGI 35 CPU", NULL))) return NULL; sdi->conn = serial; sdi->priv = NULL; sdi->driver = di; if (!(ch = sr_channel_new(0, SR_CHANNEL_ANALOG, TRUE, "CH1"))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); return devices; }
/** * Load the session from the specified filename. * * @param filename The name of the session file to load. Must not be NULL. * * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, * SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon * other errors. */ SR_API int sr_session_load(const char *filename) { GKeyFile *kf; GPtrArray *capturefiles; struct zip *archive; struct zip_file *zf; struct zip_stat zs; struct sr_dev_inst *sdi; struct sr_channel *probe; int ret, devcnt, i, j, k; uint16_t probenum; uint64_t tmp_u64, total_probes, enabled_probes; uint16_t p; char **sections, **keys, *metafile, *val, s[11]; char probename[SR_MAX_PROBENAME_LEN + 1]; int mode = LOGIC; int channel_type = SR_CHANNEL_LOGIC; double tmp_double; if (!filename) { sr_err("%s: filename was NULL", __func__); return SR_ERR_ARG; } if (!(archive = zip_open(filename, 0, &ret))) { sr_dbg("Failed to open session file: zip error %d", ret); return SR_ERR; } /* read "metadata" */ if (zip_stat(archive, "header", 0, &zs) == -1) { sr_dbg("Not a valid DSView data file."); return SR_ERR; } if (!(metafile = g_try_malloc(zs.size))) { sr_err("%s: metafile malloc failed", __func__); return SR_ERR_MALLOC; } zf = zip_fopen_index(archive, zs.index, 0); zip_fread(zf, metafile, zs.size); zip_fclose(zf); kf = g_key_file_new(); if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) { sr_dbg("Failed to parse metadata."); return SR_ERR; } sr_session_new(); devcnt = 0; capturefiles = g_ptr_array_new_with_free_func(g_free); sections = g_key_file_get_groups(kf, NULL); for (i = 0; sections[i]; i++) { if (!strcmp(sections[i], "version")) /* nothing really interesting in here yet */ continue; if (!strncmp(sections[i], "header", 6)) { /* device section */ sdi = NULL; enabled_probes = total_probes = 0; keys = g_key_file_get_keys(kf, sections[i], NULL, NULL); for (j = 0; keys[j]; j++) { val = g_key_file_get_string(kf, sections[i], keys[j], NULL); if (!strcmp(keys[j], "device mode")) { mode = strtoull(val, NULL, 10); } else if (!strcmp(keys[j], "capturefile")) { sdi = sr_dev_inst_new(mode, devcnt, SR_ST_ACTIVE, NULL, NULL, NULL); sdi->driver = &session_driver; if (devcnt == 0) /* first device, init the driver */ sdi->driver->init(NULL); sr_dev_open(sdi); sr_session_dev_add(sdi); sdi->driver->config_set(SR_CONF_SESSIONFILE, g_variant_new_bytestring(filename), sdi, NULL, NULL); sdi->driver->config_set(SR_CONF_CAPTUREFILE, g_variant_new_bytestring(val), sdi, NULL, NULL); g_ptr_array_add(capturefiles, val); } else if (!strcmp(keys[j], "samplerate")) { sr_parse_sizestring(val, &tmp_u64); sdi->driver->config_set(SR_CONF_SAMPLERATE, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "unitsize")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "total samples")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_LIMIT_SAMPLES, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "hDiv")) { tmp_u64 = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_TIMEBASE, g_variant_new_uint64(tmp_u64), sdi, NULL, NULL); } else if (!strcmp(keys[j], "total probes")) { total_probes = strtoull(val, NULL, 10); sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES, g_variant_new_uint64(total_probes), sdi, NULL, NULL); channel_type = (mode == DSO) ? SR_CHANNEL_DSO : (mode == ANALOG) ? SR_CHANNEL_ANALOG : SR_CHANNEL_LOGIC; for (p = 0; p < total_probes; p++) { snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p); if (!(probe = sr_channel_new(p, channel_type, FALSE, probename))) return SR_ERR; sdi->channels = g_slist_append(sdi->channels, probe); } } else if (!strncmp(keys[j], "probe", 5)) { if (!sdi) continue; enabled_probes++; tmp_u64 = strtoul(keys[j]+5, NULL, 10); /* sr_session_save() */ sr_dev_probe_name_set(sdi, tmp_u64, val); sr_dev_probe_enable(sdi, tmp_u64, TRUE); } else if (!strncmp(keys[j], "trigger", 7)) { probenum = strtoul(keys[j]+7, NULL, 10); sr_dev_trigger_set(sdi, probenum, val); } else if (!strncmp(keys[j], "enable", 6)) { probenum = strtoul(keys[j]+6, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_EN_CH, g_variant_new_boolean(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "coupling", 8)) { probenum = strtoul(keys[j]+8, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_COUPLING, g_variant_new_byte(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "vDiv", 4)) { probenum = strtoul(keys[j]+4, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_VDIV, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "vFactor", 7)) { probenum = strtoul(keys[j]+7, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_FACTOR, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "vPos", 4)) { probenum = strtoul(keys[j]+4, NULL, 10); tmp_double = strtod(val, NULL); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_VPOS, g_variant_new_double(tmp_double), sdi, probe, NULL); } } else if (!strncmp(keys[j], "period", 6)) { probenum = strtoul(keys[j]+6, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_PERIOD, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "pcnt", 4)) { probenum = strtoul(keys[j]+4, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_PCNT, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "max", 3)) { probenum = strtoul(keys[j]+3, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_MAX, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } else if (!strncmp(keys[j], "min", 3)) { probenum = strtoul(keys[j]+3, NULL, 10); tmp_u64 = strtoull(val, NULL, 10); if (probenum < g_slist_length(sdi->channels)) { probe = g_slist_nth(sdi->channels, probenum)->data; sdi->driver->config_set(SR_CONF_STATUS_MIN, g_variant_new_uint64(tmp_u64), sdi, probe, NULL); } } } g_strfreev(keys); } devcnt++; } g_strfreev(sections); g_key_file_free(kf); return SR_OK; }
static GSList *hw_scan(GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_dev_inst *sdi; struct sr_usb_dev_inst *usb; struct sr_config *src; struct sr_probe *probe; libusb_device *dev; GSList *usb_devices, *devices, *l; int i; const char *conn; (void)options; drvc = di->priv; /* USB scan is always authoritative. */ clear_instances(); conn = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = src->value; break; } } if (!conn) conn = OSCI_VIDPID; devices = NULL; if ((usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn))) { for (l = usb_devices; l; l = l->next) { usb = l->data; if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, OSCI_VENDOR, OSCI_MODEL, OSCI_VERSION))) return NULL; sdi->driver = di; for (i = 0; probe_names[i]; i++) { if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE, probe_names[i]))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); } if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) return NULL; sdi->priv = devc; devc->usb = usb; if (strcmp(conn, OSCI_VIDPID)) { if (sr_usb_open(drvc->sr_ctx->libusb_ctx, usb) != SR_OK) break; dev = libusb_get_device(usb->devhdl); if (ezusb_upload_firmware(dev, 0, OSCI_FIRMWARE) == SR_OK) /* Remember when the firmware on this device was updated */ devc->fw_updated = g_get_monotonic_time(); else sr_err("Firmware upload failed for device " "at bus %d address %d.", usb->bus, usb->address); } drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); } g_slist_free(usb_devices); } else g_slist_free_full(usb_devices, g_free); return devices; }
static GSList *scan(GSList *options) { struct drv_context *drvc; struct dev_context *devc; struct sr_config *src; struct sr_serial_dev_inst *serial; struct sr_dev_inst *sdi; struct sr_channel *ch; GSList *l, *devices; gint64 start; const char *conn; unsigned char c; conn = NULL; for (l = options; l; l = l->next) { src = l->data; if (src->key == SR_CONF_CONN) conn = g_variant_get_string(src->data, NULL); } if (!conn) return NULL; if (!(serial = sr_serial_dev_inst_new(conn, SERIALCOMM))) return NULL; if (serial_open(serial, SERIAL_RDONLY | SERIAL_NONBLOCK) != SR_OK) return NULL; devices = NULL; drvc = di->priv; start = g_get_monotonic_time(); while (g_get_monotonic_time() - start < MAX_SCAN_TIME) { if (serial_read(serial, &c, 1) == 1 && c == 0xa5) { /* Found one. */ if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "CEM", "DT-885x", NULL))) return NULL; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_dbg("Device context malloc failed."); return NULL; } devc->cur_mqflags = 0; devc->recording = -1; devc->cur_meas_range = 0; devc->cur_data_source = DATA_SOURCE_LIVE; devc->enable_data_source_memory = FALSE; if (!(sdi->conn = sr_serial_dev_inst_new(conn, SERIALCOMM))) return NULL; sdi->inst_type = SR_INST_SERIAL; sdi->priv = devc; sdi->driver = di; if (!(ch = sr_channel_new(0, SR_CHANNEL_ANALOG, TRUE, "SPL"))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); break; } /* It takes about 1ms for a byte to come in. */ g_usleep(1000); } serial_close(serial); return devices; }
static GSList *brymen_scan(const char *conn, const char *serialcomm) { struct sr_dev_inst *sdi; struct dev_context *devc; struct drv_context *drvc; struct sr_probe *probe; struct sr_serial_dev_inst *serial; GSList *devices; int ret; uint8_t buf[128]; size_t len; if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) return NULL; sr_info("Probing port %s.", conn); devices = NULL; /* Request reading */ if ((ret = brymen_packet_request(serial)) < 0) { sr_err("Unable to send command: %d.", ret); goto scan_cleanup; } len = 128; ret = brymen_stream_detect(serial, buf, &len, brymen_packet_length, brymen_packet_is_valid, 1000, 9600); if (ret != SR_OK) goto scan_cleanup; sr_info("Found device on port %s.", conn); if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, "Brymen", "BM85x", ""))) goto scan_cleanup; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); goto scan_cleanup; } sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; drvc = di->priv; sdi->priv = devc; sdi->driver = di; if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1"))) goto scan_cleanup; sdi->probes = g_slist_append(sdi->probes, probe); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); scan_cleanup: serial_close(serial); return devices; }
static GSList *scan(GSList *options) { struct sr_dev_inst *sdi; struct sr_channel *ch; struct drv_context *drvc; struct dev_context *devc; const struct zp_model *prof; struct libusb_device_descriptor des; libusb_device **devlist; GSList *devices; int ret, devcnt, i, j; (void)options; drvc = di->priv; devices = NULL; /* Find all ZEROPLUS analyzers and add them to device list. */ devcnt = 0; libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); /* TODO: Errors. */ for (i = 0; devlist[i]; i++) { ret = libusb_get_device_descriptor(devlist[i], &des); if (ret != 0) { sr_err("Failed to get device descriptor: %s.", libusb_error_name(ret)); continue; } prof = NULL; for (j = 0; j < zeroplus_models[j].vid; j++) { if (des.idVendor == zeroplus_models[j].vid && des.idProduct == zeroplus_models[j].pid) { prof = &zeroplus_models[j]; } } /* Skip if the device was not found. */ if (!prof) continue; sr_info("Found ZEROPLUS %s.", prof->model_name); /* Register the device with libsigrok. */ if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_INACTIVE, VENDOR_NAME, prof->model_name, NULL))) { sr_err("%s: sr_dev_inst_new failed", __func__); return NULL; } sdi->driver = di; /* Allocate memory for our private driver context. */ if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } sdi->priv = devc; devc->prof = prof; devc->num_channels = prof->channels; #ifdef ZP_EXPERIMENTAL devc->max_sample_depth = 128 * 1024; devc->max_samplerate = 200; #else devc->max_sample_depth = prof->sample_depth * 1024; devc->max_samplerate = prof->max_sampling_freq; #endif devc->max_samplerate *= SR_MHZ(1); devc->memory_size = MEMORY_SIZE_8K; // memset(devc->trigger_buffer, 0, NUM_TRIGGER_STAGES); /* Fill in channellist according to this device's profile. */ for (j = 0; j < devc->num_channels; j++) { if (!(ch = sr_channel_new(j, SR_CHANNEL_LOGIC, TRUE, channel_names[j]))) return NULL; sdi->channels = g_slist_append(sdi->channels, ch); } devices = g_slist_append(devices, sdi); drvc->instances = g_slist_append(drvc->instances, sdi); sdi->inst_type = SR_INST_USB; sdi->conn = sr_usb_dev_inst_new( libusb_get_bus_number(devlist[i]), libusb_get_device_address(devlist[i]), NULL); devcnt++; } libusb_free_device_list(devlist, 1); return devices; }
static GSList *scan(GSList *options) { struct sr_dev_inst *sdi; struct drv_context *drvc; struct dev_context *devc; struct sr_config *src; struct sr_probe *probe; struct sr_serial_dev_inst *serial; GSList *l, *devices; int len, i; const char *conn, *serialcomm; char *buf, **tokens; drvc = di->priv; drvc->instances = NULL; devices = NULL; conn = serialcomm = NULL; for (l = options; l; l = l->next) { src = l->data; switch (src->key) { case SR_CONF_CONN: conn = g_variant_get_string(src->data, NULL); break; case SR_CONF_SERIALCOMM: serialcomm = g_variant_get_string(src->data, NULL); break; } } if (!conn) return NULL; if (!serialcomm) serialcomm = SERIALCOMM; if (!(serial = sr_serial_dev_inst_new(conn, serialcomm))) return NULL; if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK) return NULL; serial_flush(serial); if (serial_write(serial, "*IDN?\r\n", 7) == -1) { sr_err("Unable to send identification string: %s.", strerror(errno)); return NULL; } len = 128; if (!(buf = g_try_malloc(len))) { sr_err("Serial buffer malloc failed."); return NULL; } serial_readline(serial, &buf, &len, 150); if (!len) return NULL; tokens = g_strsplit(buf, ",", 4); if (!strcmp("Agilent Technologies", tokens[0]) && tokens[1] && tokens[2] && tokens[3]) { for (i = 0; supported_agdmm[i].model; i++) { if (strcmp(supported_agdmm[i].modelname, tokens[1])) continue; if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, tokens[0], tokens[1], tokens[3]))) return NULL; if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) { sr_err("Device context malloc failed."); return NULL; } devc->profile = &supported_agdmm[i]; devc->cur_mq = -1; sdi->inst_type = SR_INST_SERIAL; sdi->conn = serial; sdi->priv = devc; sdi->driver = di; if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1"))) return NULL; sdi->probes = g_slist_append(sdi->probes, probe); drvc->instances = g_slist_append(drvc->instances, sdi); devices = g_slist_append(devices, sdi); break; } } g_strfreev(tokens); g_free(buf); serial_close(serial); if (!devices) sr_serial_dev_inst_free(serial); return devices; }