예제 #1
0
static void *hw_get_device_info(int device_index, int device_info_id)
{
	struct sr_device_instance *sdi;
	struct fx2_device *fx2;
	void *info = NULL;

	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
		return NULL;
	fx2 = sdi->priv;

	switch (device_info_id) {
	case SR_DI_INSTANCE:
		info = sdi;
		break;
	case SR_DI_NUM_PROBES:
		info = GINT_TO_POINTER(fx2->profile->num_probes);
		break;
	case SR_DI_SAMPLERATES:
		info = &samplerates;
		break;
	case SR_DI_TRIGGER_TYPES:
		info = TRIGGER_TYPES;
		break;
	case SR_DI_CUR_SAMPLERATE:
		info = &fx2->cur_samplerate;
		break;
	}

	return info;
}
예제 #2
0
static int hw_set_configuration(int device_index, int capability, void *value)
{
	struct sr_device_instance *sdi;
	struct fx2_device *fx2;
	int ret;
	uint64_t *tmp_u64;

	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
		return SR_ERR;
	fx2 = sdi->priv;

	if (capability == SR_HWCAP_SAMPLERATE) {
		tmp_u64 = value;
		ret = set_configuration_samplerate(sdi, *tmp_u64);
	} else if (capability == SR_HWCAP_PROBECONFIG) {
		ret = configure_probes(fx2, (GSList *) value);
	} else if (capability == SR_HWCAP_LIMIT_SAMPLES) {
		tmp_u64 = value;
		fx2->limit_samples = *tmp_u64;
		ret = SR_OK;
	} else {
		ret = SR_ERR;
	}

	return ret;
}
예제 #3
0
파일: demo.c 프로젝트: gsmcmullin/sigrok
static void *hw_get_device_info(int device_index, int device_info_id)
{
	struct sr_device_instance *sdi;
	void *info = NULL;

	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
		sr_err("demo: %s: sdi was NULL", __func__);
		return NULL;
	}

	switch (device_info_id) {
	case SR_DI_INSTANCE:
		info = sdi;
		break;
	case SR_DI_NUM_PROBES:
		info = GINT_TO_POINTER(NUM_PROBES);
		break;
	case SR_DI_SAMPLERATES:
		info = &samplerates;
		break;
	case SR_DI_CUR_SAMPLERATE:
		info = &cur_samplerate;
		break;
	case SR_DI_PATTERNMODES:
		info = &pattern_strings;
		break;
	}

	return info;
}
예제 #4
0
static int hw_get_status(int device_index)
{
	struct sr_device_instance *sdi;

	sdi = sr_get_device_instance(device_instances, device_index);
	if (sdi)
		return sdi->status;
	else
		return SR_ST_NOT_FOUND;
}
예제 #5
0
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;
}
예제 #6
0
static struct session_vdevice *get_vdevice_by_index(int device_index)
{
	struct sr_device_instance *sdi;
	struct session_vdevice *vdevice;

	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
		return NULL;

	vdevice = sdi->priv;

	return vdevice;
}
예제 #7
0
static int hw_closedev(int device_index)
{
	struct sr_device_instance *sdi;

	if (!(sdi = sr_get_device_instance(device_instances, device_index))) {
		sr_err("logic: %s: sdi was NULL", __func__);
		return SR_ERR; /* TODO: SR_ERR_ARG? */
	}

	/* TODO */
	close_device(sdi);

	return SR_OK;
}
예제 #8
0
static int hw_start_acquisition(int device_index, gpointer session_data)
{
	struct sr_device_instance *sdi;
	struct sr_datafeed_packet *packet;
	struct sr_datafeed_header *header;
	struct fx2_device *fx2;
	struct libusb_transfer *transfer;
	const struct libusb_pollfd **lupfd;
	int size, i;
	unsigned char *buf;

	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
		return SR_ERR;
	fx2 = sdi->priv;
	fx2->session_data = session_data;

	if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
		sr_err("saleae: %s: packet malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
		sr_err("saleae: %s: header malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	/* Start with 2K transfer, subsequently increased to 4K. */
	size = 2048;
	for (i = 0; i < NUM_SIMUL_TRANSFERS; i++) {
		if (!(buf = g_try_malloc(size))) {
			sr_err("saleae: %s: buf malloc failed", __func__);
			return SR_ERR_MALLOC;
		}
		transfer = libusb_alloc_transfer(0);
		libusb_fill_bulk_transfer(transfer, sdi->usb->devhdl,
				2 | LIBUSB_ENDPOINT_IN, buf, size,
				receive_transfer, fx2, 40);
		if (libusb_submit_transfer(transfer) != 0) {
			/* TODO: Free them all. */
			libusb_free_transfer(transfer);
			g_free(buf);
			return SR_ERR;
		}
		size = 4096;
	}

	lupfd = libusb_get_pollfds(usb_context);
	for (i = 0; lupfd[i]; i++)
		sr_source_add(lupfd[i]->fd, lupfd[i]->events, 40, receive_data,
			      NULL);
	free(lupfd);

	packet->type = SR_DF_HEADER;
	packet->payload = header;
	header->feed_version = 1;
	gettimeofday(&header->starttime, NULL);
	header->samplerate = fx2->cur_samplerate;
	header->num_logic_probes = fx2->profile->num_probes;
	header->num_analog_probes = 0;
	sr_session_bus(session_data, packet);
	g_free(header);
	g_free(packet);

	return SR_OK;
}
예제 #9
0
static int sl_open_device(int device_index)
{
	libusb_device **devlist;
	struct libusb_device_descriptor des;
	struct sr_device_instance *sdi;
	struct fx2_device *fx2;
	int err, skip, i;

	if (!(sdi = sr_get_device_instance(device_instances, device_index)))
		return SR_ERR;
	fx2 = sdi->priv;

	if (sdi->status == SR_ST_ACTIVE)
		/* already in use */
		return SR_ERR;

	skip = 0;
	libusb_get_device_list(usb_context, &devlist);
	for (i = 0; devlist[i]; i++) {
		if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
			sr_warn("failed to get device descriptor: %d", err);
			continue;
		}

		if (des.idVendor != fx2->profile->fw_vid || des.idProduct != fx2->profile->fw_pid)
			continue;

		if (sdi->status == SR_ST_INITIALIZING) {
			if (skip != device_index) {
				/* Skip devices of this type that aren't the one we want. */
				skip += 1;
				continue;
			}
		} else if (sdi->status == SR_ST_INACTIVE) {
			/*
			 * This device is fully enumerated, so we need to find this
			 * device by vendor, product, bus and address.
			 */
			if (libusb_get_bus_number(devlist[i]) != sdi->usb->bus
				|| libusb_get_device_address(devlist[i]) != sdi->usb->address)
				/* this is not the one */
				continue;
		}

		if (!(err = libusb_open(devlist[i], &sdi->usb->devhdl))) {
			if (sdi->usb->address == 0xff)
				/*
				 * first time we touch this device after firmware upload,
				 * so we don't know the address yet.
				 */
				sdi->usb->address = libusb_get_device_address(devlist[i]);

			sdi->status = SR_ST_ACTIVE;
			sr_info("saleae: opened device %d on %d.%d interface %d",
				  sdi->index, sdi->usb->bus,
				  sdi->usb->address, USB_INTERFACE);
		} else {
			sr_warn("failed to open device: %d", err);
		}

		/* if we made it here, we handled the device one way or another */
		break;
	}
	libusb_free_device_list(devlist, 1);

	if (sdi->status != SR_ST_ACTIVE)
		return SR_ERR;

	return SR_OK;
}