自学教程：C++ sr_info函数代码示例

int ezusb_install_firmware(libusb_device_handle *hdl, const char *filename){	FILE *fw;	int offset, chunksize, err, result;	unsigned char buf[4096];	sr_info("Uploading firmware at %s", filename);	if ((fw = g_fopen(filename, "rb")) == NULL) {		sr_warn("Unable to open firmware file %s for reading: %s",			filename, strerror(errno));		return SR_ERR;	}	result = SR_OK;	offset = 0;	while (1) {		chunksize = fread(buf, 1, 4096, fw);		if (chunksize == 0)			break;		err = libusb_control_transfer(hdl, LIBUSB_REQUEST_TYPE_VENDOR |					      LIBUSB_ENDPOINT_OUT, 0xa0, offset,					      0x0000, buf, chunksize, 100);		if (err < 0) {			sr_warn("Unable to send firmware to device: %d", err);			result = SR_ERR;			break;		}		sr_info("Uploaded %d bytes", chunksize);		offset += chunksize;	}	fclose(fw);	sr_info("Firmware upload done");	return result;}

static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi,		const struct sr_probe_group *probe_group){	struct session_vdev *vdev;	(void)probe_group;	vdev = sdi->priv;	switch (id) {	case SR_CONF_SAMPLERATE:		vdev->samplerate = g_variant_get_uint64(data);		sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate);		break;	case SR_CONF_SESSIONFILE:		vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL));		sr_info("Setting sessionfile to '%s'.", vdev->sessionfile);		break;	case SR_CONF_CAPTUREFILE:		vdev->capturefile = g_strdup(g_variant_get_string(data, NULL));		sr_info("Setting capturefile to '%s'.", vdev->capturefile);		break;	case SR_CONF_CAPTURE_UNITSIZE:		vdev->unitsize = g_variant_get_uint64(data);		break;	case SR_CONF_CAPTURE_NUM_PROBES:		vdev->num_probes = g_variant_get_uint64(data);		break;	default:		return SR_ERR_NA;	}	return SR_OK;}

static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi){	struct session_vdev *vdev;	vdev = sdi->priv;	switch (id) {	case SR_CONF_SAMPLERATE:		vdev->samplerate = g_variant_get_uint64(data);		sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate);		break;	case SR_CONF_SESSIONFILE:		vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL));		sr_info("Setting sessionfile to '%s'.", vdev->sessionfile);		break;	case SR_CONF_CAPTUREFILE:		vdev->capturefile = g_strdup(g_variant_get_string(data, NULL));		sr_info("Setting capturefile to '%s'.", vdev->capturefile);		break;	case SR_CONF_CAPTURE_UNITSIZE:		vdev->unitsize = g_variant_get_uint64(data);		break;    case SR_CONF_LIMIT_SAMPLES:        vdev->total_samples = g_variant_get_uint64(data);        break;	case SR_CONF_CAPTURE_NUM_PROBES:		vdev->num_probes = g_variant_get_uint64(data);		break;	default:		sr_err("Unknown capability: %d.", id);		return SR_ERR;	}	return SR_OK;}

SR_PRIV int appa_55ii_receive_data(int fd, int revents, void *cb_data){	struct sr_dev_inst *sdi;	struct dev_context *devc;	struct sr_serial_dev_inst *serial;	int64_t time;	const uint8_t *ptr, *next_ptr, *end_ptr;	int len;	(void)fd;	if (!(sdi = cb_data) || !(devc = sdi->priv) || revents != G_IO_IN)		return TRUE;	serial = sdi->conn;	/* Try to get as much data as the buffer can hold. */	len = sizeof(devc->buf) - devc->buf_len;	len = serial_read_nonblocking(serial, devc->buf + devc->buf_len, len);	if (len < 1) {		sr_err("Serial port read error: %d.", len);		return FALSE;	}	devc->buf_len += len;	/* Now look for packets in that data. */	ptr = devc->buf;	end_ptr = ptr + devc->buf_len;	while ((next_ptr = appa_55ii_parse_data(sdi, ptr, end_ptr - ptr)))		ptr = next_ptr;	/* If we have any data left, move it to the beginning of our buffer. */	memmove(devc->buf, ptr, end_ptr - ptr);	devc->buf_len -= ptr - devc->buf;	/* If buffer is full and no valid packet was found, wipe buffer. */	if (devc->buf_len >= sizeof(devc->buf)) {		devc->buf_len = 0;		return FALSE;	}	if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {		sr_info("Requested number of samples reached.");		sdi->driver->dev_acquisition_stop(sdi, devc->session_cb_data);		return TRUE;	}	if (devc->limit_msec) {		time = (g_get_monotonic_time() - devc->start_time) / 1000;		if (time > (int64_t)devc->limit_msec) {			sr_info("Requested time limit reached.");			sdi->driver->dev_acquisition_stop(sdi,					devc->session_cb_data);			return TRUE;		}	}	return TRUE;}

static int opendev4(struct sr_dev_inst **sdi, libusb_device *dev,		    struct libusb_device_descriptor *des){	struct context *ctx;	unsigned int i;	int ret;	/* Note: sdi is non-NULL, the caller already checked this. */	if (!(ctx = (*sdi)->priv)) {		sr_err("zp: %s: (*sdi)->priv was NULL", __func__);		return -1;	}	if ((ret = libusb_get_device_descriptor(dev, des))) {		sr_err("zp: failed to get device descriptor: %d", ret);		return -1;	}	if (des->idVendor != USB_VENDOR)		return 0;	if (libusb_get_bus_number(dev) == ctx->usb->bus	    && libusb_get_device_address(dev) == ctx->usb->address) {		for (i = 0; i < ARRAY_SIZE(zeroplus_models); i++) {			if (!(des->idProduct == zeroplus_models[i].pid))				continue;			sr_info("zp: Found ZeroPlus device 0x%04x (%s)",				des->idProduct, zeroplus_models[i].model_name);			ctx->num_channels = zeroplus_models[i].channels;			ctx->memory_size = zeroplus_models[i].sample_depth * 1024;			break;		}		if (ctx->num_channels == 0) {			sr_err("zp: Unknown ZeroPlus device 0x%04x",			       des->idProduct);			return -2;		}		/* Found it. */		if (!(ret = libusb_open(dev, &(ctx->usb->devhdl)))) {			(*sdi)->status = SR_ST_ACTIVE;			sr_info("zp: opened device %d on %d.%d interface %d",				(*sdi)->index, ctx->usb->bus,				ctx->usb->address, USB_INTERFACE);		} else {			sr_err("zp: failed to open device: %d", ret);			*sdi = NULL;		}	}	return 0;}

static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data){	struct drv_context *drvc;	struct dev_context *devc;	struct acquisition_state *acq;	int ret;	(void)cb_data;	if (sdi->status != SR_ST_ACTIVE)		return SR_ERR_DEV_CLOSED;	devc = sdi->priv;	drvc = di->priv;	if (devc->acquisition) {		sr_err("Acquisition still in progress?");		return SR_ERR;	}	acq = lwla_alloc_acquisition_state();	if (!acq)		return SR_ERR_MALLOC;	devc->stopping_in_progress = FALSE;	devc->transfer_error = FALSE;	sr_info("Starting acquisition.");	devc->acquisition = acq;	lwla_convert_trigger(sdi);	ret = lwla_setup_acquisition(sdi);	if (ret != SR_OK) {		sr_err("Failed to set up acquisition.");		devc->acquisition = NULL;		lwla_free_acquisition_state(acq);		return ret;	}	ret = lwla_start_acquisition(sdi);	if (ret != SR_OK) {		sr_err("Failed to start acquisition.");		devc->acquisition = NULL;		lwla_free_acquisition_state(acq);		return ret;	}	usb_source_add(sdi->session, drvc->sr_ctx, 100, &lwla_receive_data,		       (struct sr_dev_inst *)sdi);	sr_info("Waiting for data.");	/* Send header packet to the session bus. */	std_session_send_df_header(sdi, LOG_PREFIX);	return SR_OK;}

static int hw_opendev(int device_index){	GTimeVal cur_time;	struct sr_device_instance *sdi;	struct fx2_device *fx2;	int timediff, err;	if (!(sdi = sr_get_device_instance(device_instances, device_index)))		return SR_ERR;	fx2 = sdi->priv;	/*	 * if the firmware was recently uploaded, wait up to MAX_RENUM_DELAY ms	 * for the FX2 to renumerate	 */	err = 0;	if (GTV_TO_MSEC(fx2->fw_updated) > 0) {		sr_info("saleae: waiting for device to reset");		/* takes at least 300ms for the FX2 to be gone from the USB bus */		g_usleep(300*1000);		timediff = 0;		while (timediff < MAX_RENUM_DELAY) {			if ((err = sl_open_device(device_index)) == SR_OK)				break;			g_usleep(100*1000);			g_get_current_time(&cur_time);			timediff = GTV_TO_MSEC(cur_time) - GTV_TO_MSEC(fx2->fw_updated);		}		sr_info("saleae: device came back after %d ms", timediff);	} else {		err = sl_open_device(device_index);	}	if (err != SR_OK) {		sr_warn("unable to open device");		return SR_ERR;	}	fx2 = sdi->priv;	err = libusb_claim_interface(sdi->usb->devhdl, USB_INTERFACE);	if (err != 0) {		sr_warn("Unable to claim interface: %d", err);		return SR_ERR;	}	if (fx2->cur_samplerate == 0) {		/* Samplerate hasn't been set; default to the slowest one. */		if (hw_set_configuration(device_index, SR_HWCAP_SAMPLERATE,		    &supported_samplerates[0]) == SR_ERR)			return SR_ERR;	}	return SR_OK;}

SR_PRIV void sl2_calculate_trigger_samples(const struct sr_dev_inst *sdi){	struct dev_context *devc;	uint64_t pre_trigger_samples, post_trigger_samples;	uint16_t pre_trigger_bytes, post_trigger_bytes;	uint8_t cr;	devc = sdi->priv;	cr = devc->capture_ratio;	/* Ignore the capture ratio if no trigger is enabled. */	if (devc->trigger_type == TRIGGER_TYPE_NONE)		cr = 0;	pre_trigger_samples = (devc->limit_samples * cr) / 100;	post_trigger_samples = (devc->limit_samples * (100 - cr)) / 100;	/*	 * Increase the number of post trigger samples by one to compensate the	 * possible loss of a sample through integer rounding.	 */	if (pre_trigger_samples + post_trigger_samples != devc->limit_samples)		post_trigger_samples++;	/*	 * The device requires the number of samples in multiples of 8 which	 * will also be called sample bytes in the following.	 */	pre_trigger_bytes = pre_trigger_samples / 8;	post_trigger_bytes = post_trigger_samples / 8;	/*	 * Round up the number of sample bytes to ensure that at least the	 * requested number of samples will be acquired. Note that due to this	 * rounding the buffer to store these sample bytes needs to be at least	 * one sample byte larger than the minimal number of sample bytes	 * needed to store the requested samples.	 */	if (pre_trigger_samples % 8 != 0)		pre_trigger_bytes++;	if (post_trigger_samples % 8 != 0)		post_trigger_bytes++;	sr_info("Pre trigger samples: %" PRIu64 ".", pre_trigger_samples);	sr_info("Post trigger samples: %" PRIu64 ".", post_trigger_samples);	sr_dbg("Pre trigger sample bytes: %" PRIu16 ".", pre_trigger_bytes);	sr_dbg("Post trigger sample bytes: %" PRIu16 ".", post_trigger_bytes);	devc->pre_trigger_samples = pre_trigger_samples;	devc->pre_trigger_bytes = pre_trigger_bytes;	devc->post_trigger_bytes = post_trigger_bytes;}

static int receive_data(int fd, int revents, int idx, void *cb_data){	struct sr_dev_inst *sdi;	struct dev_context *devc;	int64_t t;	static gboolean request_new_packet = TRUE;	struct sr_serial_dev_inst *serial;	(void)fd;	if (!(sdi = cb_data))		return TRUE;	if (!(devc = sdi->priv))		return TRUE;	serial = sdi->conn;	if (revents == G_IO_IN) {		/* New data arrived. */		request_new_packet = handle_new_data(sdi, idx);	} else {		/*		 * Timeout. Send "A" to request a packet, but then don't send		 * further "A" commands until we received a full packet first.		 */		if (request_new_packet) {			center_send(serial, "A");			request_new_packet = FALSE;		}	}	if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {		sr_info("Requested number of samples reached.");		sdi->driver->dev_acquisition_stop(sdi);		return TRUE;	}	if (devc->limit_msec) {		t = (g_get_monotonic_time() - devc->starttime) / 1000;		if (t > (int64_t)devc->limit_msec) {			sr_info("Requested time limit reached.");			sdi->driver->dev_acquisition_stop(sdi);			return TRUE;		}	}	return TRUE;}

static int receive_data(int fd, int revents, int dmm, void *info, void *cb_data){	struct sr_dev_inst *sdi;	struct dev_context *devc;	struct sr_serial_dev_inst *serial;	int64_t time;	int ret;	(void)fd;	if (!(sdi = cb_data))		return TRUE;	if (!(devc = sdi->priv))		return TRUE;	serial = sdi->conn;	if (revents == G_IO_IN) {		/* Serial data arrived. */		handle_new_data(sdi, dmm, info);	} else {		/* Timeout, send another packet request (if DMM needs it). */		if (dmms[dmm].packet_request) {			ret = dmms[dmm].packet_request(serial);			if (ret < 0) {				sr_err("Failed to request packet: %d.", ret);				return FALSE;			}		}	}	if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {		sr_info("Requested number of samples reached.");		sdi->driver->dev_acquisition_stop(sdi, cb_data);		return TRUE;	}	if (devc->limit_msec) {		time = (g_get_monotonic_time() - devc->starttime) / 1000;		if (time > (int64_t)devc->limit_msec) {			sr_info("Requested time limit reached.");			sdi->driver->dev_acquisition_stop(sdi, cb_data);			return TRUE;		}	}	return TRUE;}

static int dev_open(struct sr_dev_inst *sdi){	struct dev_context *devc;	int ret;	int64_t timediff_us, timediff_ms;	devc = sdi->priv;	/*	 * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS	 * milliseconds for the FX2 to renumerate.	 */	ret = SR_ERR;	if (devc->fw_updated > 0) {		sr_info("Waiting for device to reset.");		/* Takes >= 300ms for the FX2 to be gone from the USB bus. */		g_usleep(300 * 1000);		timediff_ms = 0;		while (timediff_ms < MAX_RENUM_DELAY_MS) {			if ((ret = logic16_dev_open(sdi)) == SR_OK)				break;			g_usleep(100 * 1000);			timediff_us = g_get_monotonic_time() - devc->fw_updated;			timediff_ms = timediff_us / 1000;			sr_spew("Waited %" PRIi64 "ms.", timediff_ms);		}		if (ret != SR_OK) {			sr_err("Device failed to renumerate.");			return SR_ERR;		}		sr_info("Device came back after %" PRIi64 "ms.", timediff_ms);	} else {		sr_info("Firmware upload was not needed.");		ret = logic16_dev_open(sdi);	}	if (ret != SR_OK) {		sr_err("Unable to open device.");		return SR_ERR;	}	if (devc->cur_samplerate == 0) {		/* Samplerate hasn't been set; default to the slowest one. */		devc->cur_samplerate = samplerates[0];	}	return SR_OK;}

static int dev_open(struct sr_dev_inst *sdi){	struct dev_context *devc;	struct sr_usb_dev_inst *usb;	int64_t timediff_us, timediff_ms;	int err;	devc = sdi->priv;	usb = sdi->conn;	/*	 * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS	 * for the FX2 to renumerate.	 */	err = SR_ERR;	if (devc->fw_updated > 0) {		sr_info("Waiting for device to reset.");		/* Takes >= 300ms for the FX2 to be gone from the USB bus. */		g_usleep(300 * 1000);		timediff_ms = 0;		while (timediff_ms < MAX_RENUM_DELAY_MS) {			if ((err = hantek_6xxx_open(sdi)) == SR_OK)				break;			g_usleep(100 * 1000);			timediff_us = g_get_monotonic_time() - devc->fw_updated;			timediff_ms = timediff_us / 1000;			sr_spew("Waited %" PRIi64 " ms.", timediff_ms);		}		if (timediff_ms < MAX_RENUM_DELAY_MS)			sr_info("Device came back after %"PRIu64" ms.", timediff_ms);	} else {		err = hantek_6xxx_open(sdi);	}	if (err != SR_OK) {		sr_err("Unable to open device.");		return SR_ERR;	}	err = libusb_claim_interface(usb->devhdl, USB_INTERFACE);	if (err != 0) {		sr_err("Unable to claim interface: %s.",			   libusb_error_name(err));		return SR_ERR;	}	return SR_OK;}

/** * Start a session. * * There can only be one session at a time. * * @return SR_OK upon success, SR_ERR upon errors. */SR_API int sr_session_start(void){	struct sr_dev_inst *sdi;	GSList *l;	int ret;	if (!session) {		sr_err("%s: session was NULL; a session must be "		       "created before starting it.", __func__);		return SR_ERR_BUG;	}	if (!session->devs) {		sr_err("%s: session->devs was NULL; a session "		       "cannot be started without devices.", __func__);		return SR_ERR_BUG;	}	sr_info("Starting.");	ret = SR_OK;	for (l = session->devs; l; l = l->next) {		sdi = l->data;		if ((ret = sdi->driver->dev_acquisition_start(sdi, sdi)) != SR_OK) {			sr_err("%s: could not start an acquisition "			       "(%d)", __func__, ret);			break;		}	}	/* TODO: What if there are multiple devices? Which return code? */	return ret;}

static int set_samplerate(struct sr_dev_inst *sdi, uint64_t samplerate){	struct context *ctx;	if (!sdi) {		sr_err("zp: %s: sdi was NULL", __func__);		return SR_ERR_ARG;	}	if (!(ctx = sdi->priv)) {		sr_err("zp: %s: sdi->priv was NULL", __func__);		return SR_ERR_ARG;	}	sr_info("zp: Setting samplerate to %" PRIu64 "Hz.", samplerate);	if (samplerate > SR_MHZ(1))		analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);	else if (samplerate > SR_KHZ(1))		analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);	else		analyzer_set_freq(samplerate, FREQ_SCALE_HZ);	ctx->cur_samplerate = samplerate;	return SR_OK;}

/** * Stop the current session. * * The current session is stopped immediately, with all acquisition sessions * being stopped and hardware drivers cleaned up. * * @return SR_OK upon success, SR_ERR_BUG if no session exists. */SR_API int sr_session_stop(void){	struct sr_dev_inst *sdi;	GSList *l;	if (!session) {		sr_err("%s: session was NULL", __func__);		return SR_ERR_BUG;	}	sr_info("Stopping.");	for (l = session->devs; l; l = l->next) {		sdi = l->data;		if (sdi->driver) {			if (sdi->driver->dev_acquisition_stop)				sdi->driver->dev_acquisition_stop(sdi, sdi);		}	}	/*	 * Some sources may not be necessarily associated with a device.	 * Those sources may still be present even after stopping all devices.	 * We need to make sure all sources are removed, or we risk running the	 * session in an infinite loop.	 */	while (session->num_sources)		sr_session_source_remove(session->sources[0].poll_object);	return SR_OK;}

static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data){	struct session_vdev *vdev;	int ret;	vdev = sdi->priv;	vdev->bytes_read = 0;	vdev->cur_chunk = 0;	vdev->finished = FALSE;	sr_info("Opening archive %s file %s", vdev->sessionfile,		vdev->capturefile);	if (!(vdev->archive = zip_open(vdev->sessionfile, 0, &ret))) {		sr_err("Failed to open session file '%s': "		       "zip error %d.", vdev->sessionfile, ret);		return SR_ERR;	}	/* Send header packet to the session bus. */	std_session_send_df_header(cb_data, LOG_PREFIX);	/* freewheeling source */	sr_session_source_add(-1, 0, 0, receive_data, cb_data);	return SR_OK;}

static struct sr_dev_inst *sr_scpi_scan_resource(struct drv_context *drvc,		const char *resource, const char *serialcomm,		struct sr_dev_inst *(*probe_device)(struct sr_scpi_dev_inst *scpi)){	struct sr_scpi_dev_inst *scpi;	struct sr_dev_inst *sdi;	if (!(scpi = scpi_dev_inst_new(drvc, resource, serialcomm)))		return NULL;	if (sr_scpi_open(scpi) != SR_OK) {		sr_info("Couldn't open SCPI device.");		sr_scpi_free(scpi);		return NULL;	};	sdi = probe_device(scpi);	sr_scpi_close(scpi);	if (sdi)		sdi->status = SR_ST_INACTIVE;	else		sr_scpi_free(scpi);	return sdi;}

static GSList *center_scan(const char *conn, const char *serialcomm, int idx){	int i;	struct sr_dev_inst *sdi;	struct dev_context *devc;	struct sr_serial_dev_inst *serial;	serial = sr_serial_dev_inst_new(conn, serialcomm);	if (serial_open(serial, SERIAL_RDWR) != SR_OK)		return NULL;	serial_flush(serial);	sr_info("Found device on port %s.", conn);	sdi = g_malloc0(sizeof(struct sr_dev_inst));	sdi->status = SR_ST_INACTIVE;	sdi->vendor = g_strdup(center_devs[idx].vendor);	sdi->model = g_strdup(center_devs[idx].device);	devc = g_malloc0(sizeof(struct dev_context));	sdi->inst_type = SR_INST_SERIAL;	sdi->conn = serial;	sdi->priv = devc;	for (i = 0; i < center_devs[idx].num_channels; i++)		sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_names[i]);	serial_close(serial);	return g_slist_append(NULL, sdi);}

static int set_configuration_samplerate(struct sr_device_instance *sdi,					uint64_t samplerate){	struct fx2_device *fx2;	uint8_t divider;	int ret, result, i;	unsigned char buf[2];	fx2 = sdi->priv;	for (i = 0; supported_samplerates[i]; i++) {		if (supported_samplerates[i] == samplerate)			break;	}	if (supported_samplerates[i] == 0)		return SR_ERR_SAMPLERATE;	divider = (uint8_t) (48 / (samplerate / 1000000.0)) - 1;	sr_info("saleae: setting samplerate to %" PRIu64 " Hz (divider %d)",		samplerate, divider);	buf[0] = 0x01;	buf[1] = divider;	ret = libusb_bulk_transfer(sdi->usb->devhdl, 1 | LIBUSB_ENDPOINT_OUT,				   buf, 2, &result, 500);	if (ret != 0) {		sr_warn("failed to set samplerate: %d", ret);		return SR_ERR;	}	fx2->cur_samplerate = samplerate;	fx2->period_ps = 1000000000000 / samplerate;	return SR_OK;}

/** * Run the session. * * TODO: Various error checks etc. * * @return SR_OK upon success, SR_ERR_BUG upon errors. */SR_API int sr_session_run(void){	if (!session) {		sr_err("session: %s: session was NULL; a session must be "		       "created first, before running it.", __func__);		return SR_ERR_BUG;	}	if (!session->devs) {		/* TODO: Actually the case? */		sr_err("session: %s: session->devs was NULL; a session "		       "cannot be run without devices.", __func__);		return SR_ERR_BUG;	}	sr_info("session: running");	session->running = TRUE;	/* Do we have real sources? */	if (session->num_sources == 1 && session->pollfds[0].fd == -1) {		/* Dummy source, freewheel over it. */		while (session->running)			session->sources[0].cb(-1, 0, session->sources[0].cb_data);	} else {		/* Real sources, use g_poll() main loop. */		sr_session_run_poll();	}	return SR_OK;}

SR_PRIV int zp_set_samplerate(struct dev_context *devc, uint64_t samplerate){	int i;	for (i = 0; ARRAY_SIZE(samplerates_200); i++)		if (samplerate == samplerates_200[i])			break;	if (i == ARRAY_SIZE(samplerates_200) || samplerate > devc->max_samplerate) {		sr_err("Unsupported samplerate: %" PRIu64 "Hz.", samplerate);		return SR_ERR_ARG;	}	sr_info("Setting samplerate to %" PRIu64 "Hz.", samplerate);	if (samplerate >= SR_MHZ(1))		analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);	else if (samplerate >= SR_KHZ(1))		analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);	else		analyzer_set_freq(samplerate, FREQ_SCALE_HZ);	devc->cur_samplerate = samplerate;	return SR_OK;}

/* Evaluate and act on the response to a capture status request. */static void handle_status_response(const struct sr_dev_inst *sdi){	struct dev_context *devc;	struct acquisition_state *acq;	unsigned int old_status;	devc = sdi->priv;	acq  = devc->acquisition;	old_status = acq->status;	if ((*devc->model->handle_response)(sdi) != SR_OK) {		devc->transfer_error = TRUE;		return;	}	devc->state = STATE_STATUS_WAIT;	sr_spew("Captured %u words, %" PRIu64 " ms, status 0x%02X.",		acq->mem_addr_fill, acq->duration_now, acq->status);	if ((~old_status & acq->status & STATUS_TRIGGERED) != 0)		sr_info("Capture triggered.");	if (acq->duration_now >= acq->duration_max) {		sr_dbg("Time limit reached, stopping capture.");		submit_request(sdi, STATE_STOP_CAPTURE);	} else if ((acq->status & STATUS_TRIGGERED) == 0) {		sr_spew("Waiting for trigger.");	} else if ((acq->status & STATUS_MEM_AVAIL) == 0) {		sr_dbg("Capture memory filled.");		submit_request(sdi, STATE_LENGTH_REQUEST);	} else if ((acq->status & STATUS_CAPTURING) != 0) {		sr_spew("Sampling in progress.");	}}

/* Idle handler; invoked when the number of registered event sources * for a running session drops to zero. */static gboolean delayed_stop_check(void *data){	struct sr_session *session;	session = data;	session->stop_check_id = 0;	/* Session already ended? */	if (!session->running)		return G_SOURCE_REMOVE;	/* New event sources may have been installed in the meantime. */	if (g_hash_table_size(session->event_sources) != 0)		return G_SOURCE_REMOVE;	session->running = FALSE;	unset_main_context(session);	sr_info("Stopped.");	/* This indicates a bug in user code, since it is not valid to	 * restart or destroy a session while it may still be running.	 */	if (!session->main_loop && !session->stopped_callback) {		sr_err("BUG: Session stop left unhandled.");		return G_SOURCE_REMOVE;	}	if (session->main_loop)		g_main_loop_quit(session->main_loop);	if (session->stopped_callback)		(*session->stopped_callback)(session->stopped_cb_data);	return G_SOURCE_REMOVE;}

static struct sr_dev_inst *probe_usbtmc_device(struct sr_scpi_dev_inst *scpi){	struct sr_dev_inst *sdi;	struct dev_context *devc;	struct sr_scpi_hw_info *hw_info;	char *model_name;	int model_index;	sdi = NULL;	devc = NULL;	hw_info = NULL;	if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {		sr_info("Couldn't get IDN response.");		goto fail;	}	if (strcmp(hw_info->manufacturer, MANUFACTURER_ID) != 0)		goto fail;	if (dlm_model_get(hw_info->model, &model_name, &model_index) != SR_OK)		goto fail;	sdi = g_malloc0(sizeof(struct sr_dev_inst));	sdi->status = SR_ST_ACTIVE;	sdi->vendor = g_strdup(MANUFACTURER_NAME);	sdi->model = g_strdup(model_name);	sdi->version = g_strdup(hw_info->firmware_version);	sdi->serial_num = g_strdup(hw_info->serial_number);	sr_scpi_hw_info_free(hw_info);	hw_info = NULL;	devc = g_malloc0(sizeof(struct dev_context));	sdi->driver = &yokogawa_dlm_driver_info;	sdi->priv = devc;	sdi->inst_type = SR_INST_SCPI;	sdi->conn = scpi;	if (dlm_device_init(sdi, model_index) != SR_OK)		goto fail;	sr_scpi_close(sdi->conn);	sdi->status = SR_ST_INACTIVE;	return sdi;fail:	if (hw_info)		sr_scpi_hw_info_free(hw_info);	if (sdi)		sr_dev_inst_free(sdi);	g_free(devc);	return NULL;}

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;}

/** * Send the *IDN? SCPI command, receive the reply, parse it and store the * reply as a sr_scpi_hw_info structure in the supplied scpi_response pointer. * * The hw_info structure must be freed by the caller via sr_scpi_hw_info_free(). * * @param scpi Previously initialised SCPI device structure. * @param scpi_response Pointer where to store the hw_info structure. * * @return SR_OK upon success, SR_ERR on failure. */SR_PRIV int sr_scpi_get_hw_id(struct sr_scpi_dev_inst *scpi,			      struct sr_scpi_hw_info **scpi_response){	int num_tokens;	char *response;	char *newline;	gchar **tokens;	struct sr_scpi_hw_info *hw_info;	response = NULL;	tokens = NULL;	if (sr_scpi_get_string(scpi, SCPI_CMD_IDN, &response) != SR_OK)		if (!response)			return SR_ERR;	sr_info("Got IDN string: '%s'", response);	/* Remove trailing newline if present. */	if ((newline = g_strrstr(response, "/n")))		newline[0] = '/0';	/*	 * The response to a '*IDN?' is specified by the SCPI spec. It contains	 * a comma-separated list containing the manufacturer name, instrument	 * model, serial number of the instrument and the firmware version.	 */	tokens = g_strsplit(response, ",", 0);	for (num_tokens = 0; tokens[num_tokens] != NULL; num_tokens++);	if (num_tokens != 4) {		sr_dbg("IDN response not according to spec: %80.s.", response);		g_strfreev(tokens);		g_free(response);		return SR_ERR;	}	g_free(response);	hw_info = g_try_malloc(sizeof(struct sr_scpi_hw_info));	if (!hw_info) {		g_strfreev(tokens);		return SR_ERR_MALLOC;	}	hw_info->manufacturer = g_strdup(tokens[0]);	hw_info->model = g_strdup(tokens[1]);	hw_info->serial_number = g_strdup(tokens[2]);	hw_info->firmware_version = g_strdup(tokens[3]);	g_strfreev(tokens);	*scpi_response = hw_info;	return SR_OK;}

SR_PRIV int brymen_dmm_receive_data(int fd, int revents, void *cb_data){	struct sr_dev_inst *sdi;	struct dev_context *devc;	int ret;	int64_t time;	(void)fd;	if (!(sdi = cb_data))		return TRUE;	if (!(devc = sdi->priv))		return TRUE;	if (revents == G_IO_IN) {		/* Serial data arrived. */		handle_new_data(sdi);	} else {		/* Timeout, send another packet request. */		if ((ret = brymen_packet_request(devc->serial)) < 0) {			sr_err("Failed to request packet: %d.", ret);			return FALSE;		}	}	if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {		sr_info("Requested number of samples reached, stopping.");		sdi->driver->dev_acquisition_stop(sdi, cb_data);		return TRUE;	}	if (devc->limit_msec) {		time = (g_get_monotonic_time() - devc->starttime) / 1000;		if (time > (int64_t)devc->limit_msec) {			sr_info("Requested time limit reached, stopping.");			sdi->driver->dev_acquisition_stop(sdi, cb_data);			return TRUE;		}	}	return TRUE;}

SR_PRIV int kern_scale_receive_data(int fd, int revents, void *cb_data){	struct sr_dev_inst *sdi;	struct dev_context *devc;	struct scale_info *scale;	int64_t time;	void *info;	(void)fd;	if (!(sdi = cb_data))		return TRUE;	if (!(devc = sdi->priv))		return TRUE;	scale = (struct scale_info *)sdi->driver;	if (revents == G_IO_IN) {		/* Serial data arrived. */		info = g_malloc(scale->info_size);		handle_new_data(sdi, info);		g_free(info);	}	if (devc->limit_samples && devc->num_samples >= devc->limit_samples) {		sr_info("Requested number of samples reached.");		sdi->driver->dev_acquisition_stop(sdi, cb_data);		return TRUE;	}	if (devc->limit_msec) {		time = (g_get_monotonic_time() - devc->starttime) / 1000;		if (time > (int64_t)devc->limit_msec) {			sr_info("Requested time limit reached.");			sdi->driver->dev_acquisition_stop(sdi, cb_data);			return TRUE;		}	}	return TRUE;}

SR_PRIV int ezusb_install_firmware(struct sr_context *ctx,				   libusb_device_handle *hdl,				   const char *name){	unsigned char *firmware;	size_t length, offset, chunksize;	int ret, result;	/* Max size is 64 kiB since the value field of the setup packet,	 * which holds the firmware offset, is only 16 bit wide.	 */	firmware = sr_resource_load(ctx, SR_RESOURCE_FIRMWARE,			name, &length, 1 << 16);	if (!firmware)		return SR_ERR;	sr_info("Uploading firmware '%s'.", name);	result = SR_OK;	offset = 0;	while (offset < length) {		chunksize = MIN(length - offset, FW_CHUNKSIZE);		ret = libusb_control_transfer(hdl, LIBUSB_REQUEST_TYPE_VENDOR |					      LIBUSB_ENDPOINT_OUT, 0xa0, offset,					      0x0000, firmware + offset,					      chunksize, 100);		if (ret < 0) {			sr_err("Unable to send firmware to device: %s.",					libusb_error_name(ret));			g_free(firmware);			return SR_ERR;		}		sr_info("Uploaded %zu bytes.", chunksize);		offset += chunksize;	}	g_free(firmware);	sr_info("Firmware upload done.");	return result;}