[libsigrok.git] / src / hardware / asix-sigma / api.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2010-2012 Håvard Espeland <gus@ping.uio.no>,
 * Copyright (C) 2010 Martin Stensgård <mastensg@ping.uio.no>
 * Copyright (C) 2010 Carl Henrik Lunde <chlunde@ping.uio.no>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <config.h>
#include "protocol.h"

/*
 * Channel numbers seem to go from 1-16, according to this image:
 * http://tools.asix.net/img/sigma_sigmacab_pins_720.jpg
 * (the cable has two additional GND pins, and a TI and TO pin)
 */
static const char *channel_names[] = {
	"1", "2", "3", "4", "5", "6", "7", "8",
	"9", "10", "11", "12", "13", "14", "15", "16",
};

static const uint32_t drvopts[] = {
	SR_CONF_LOGIC_ANALYZER,
};

static const uint32_t devopts[] = {
	SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
	SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
#if ASIX_SIGMA_WITH_TRIGGER
	SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
	SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
#endif
};

#if ASIX_SIGMA_WITH_TRIGGER
static const int32_t trigger_matches[] = {
	SR_TRIGGER_ZERO,
	SR_TRIGGER_ONE,
	SR_TRIGGER_RISING,
	SR_TRIGGER_FALLING,
};
#endif

static void clear_helper(struct dev_context *devc)
{
	ftdi_deinit(&devc->ftdic);
}

static int dev_clear(const struct sr_dev_driver *di)
{
	return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
}

static GSList *scan(struct sr_dev_driver *di, GSList *options)
{
	struct sr_dev_inst *sdi;
	struct dev_context *devc;
	struct ftdi_device_list *devlist;
	char serial_txt[10];
	uint32_t serial;
	int ret;
	unsigned int i;

	(void)options;

	devc = g_malloc0(sizeof(struct dev_context));

	ftdi_init(&devc->ftdic);

	if ((ret = ftdi_usb_find_all(&devc->ftdic, &devlist,
	    USB_VENDOR, USB_PRODUCT)) <= 0) {
		if (ret < 0)
			sr_err("ftdi_usb_find_all(): %d", ret);
		goto free;
	}

	/* Make sure it's a version 1 or 2 SIGMA. */
	ftdi_usb_get_strings(&devc->ftdic, devlist->dev, NULL, 0, NULL, 0,
			     serial_txt, sizeof(serial_txt));
	sscanf(serial_txt, "%x", &serial);

	if (serial < 0xa6010000 || serial > 0xa602ffff) {
		sr_err("Only SIGMA and SIGMA2 are supported "
		       "in this version of libsigrok.");
		goto free;
	}

	sr_info("Found ASIX SIGMA - Serial: %s", serial_txt);

	devc->cur_samplerate = samplerates[0];
	devc->limit_msec = 0;
	devc->limit_samples = 0;
	devc->cur_firmware = -1;
	devc->num_channels = 0;
	devc->samples_per_event = 0;
	devc->capture_ratio = 50;
	devc->use_triggers = 0;

	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	sdi->status = SR_ST_INITIALIZING;
	sdi->vendor = g_strdup("ASIX");
	sdi->model = g_strdup("SIGMA");

	for (i = 0; i < ARRAY_SIZE(channel_names); i++)
		sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_names[i]);

	sdi->priv = devc;

	ftdi_list_free(&devlist);

	return std_scan_complete(di, g_slist_append(NULL, sdi));

free:
	ftdi_deinit(&devc->ftdic);
	g_free(devc);
	return NULL;
}

static int dev_open(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	int ret;

	devc = sdi->priv;

	if ((ret = ftdi_usb_open_desc(&devc->ftdic,
			USB_VENDOR, USB_PRODUCT, USB_DESCRIPTION, NULL)) < 0) {
		sr_err("Failed to open device (%d): %s.",
		       ret, ftdi_get_error_string(&devc->ftdic));
		return SR_ERR;
	}

	return SR_OK;
}

static int dev_close(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;

	devc = sdi->priv;

	return (ftdi_usb_close(&devc->ftdic) == 0) ? SR_OK : SR_ERR;
}

static int config_get(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;

	(void)cg;

	if (!sdi)
		return SR_ERR;
	devc = sdi->priv;

	switch (key) {
	case SR_CONF_SAMPLERATE:
		*data = g_variant_new_uint64(devc->cur_samplerate);
		break;
	case SR_CONF_LIMIT_MSEC:
		*data = g_variant_new_uint64(devc->limit_msec);
		break;
	case SR_CONF_LIMIT_SAMPLES:
		*data = g_variant_new_uint64(devc->limit_samples);
		break;
#if ASIX_SIGMA_WITH_TRIGGER
	case SR_CONF_CAPTURE_RATIO:
		*data = g_variant_new_uint64(devc->capture_ratio);
		break;
#endif
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int config_set(uint32_t key, GVariant *data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	struct dev_context *devc;

	(void)cg;

	devc = sdi->priv;

	switch (key) {
	case SR_CONF_SAMPLERATE:
		return sigma_set_samplerate(sdi, g_variant_get_uint64(data));
	case SR_CONF_LIMIT_MSEC:
		devc->limit_msec = g_variant_get_uint64(data);
		break;
	case SR_CONF_LIMIT_SAMPLES:
		devc->limit_samples = g_variant_get_uint64(data);
		devc->limit_msec = sigma_limit_samples_to_msec(devc,
						devc->limit_samples);
		break;
#if ASIX_SIGMA_WITH_TRIGGER
	case SR_CONF_CAPTURE_RATIO:
		devc->capture_ratio = g_variant_get_uint64(data);
		break;
#endif
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int config_list(uint32_t key, GVariant **data,
	const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
{
	switch (key) {
	case SR_CONF_DEVICE_OPTIONS:
		return STD_CONFIG_LIST(key, data, sdi, cg, NULL, drvopts, devopts);
	case SR_CONF_SAMPLERATE:
		*data = std_gvar_samplerates(samplerates, samplerates_count);
		break;
#if ASIX_SIGMA_WITH_TRIGGER
	case SR_CONF_TRIGGER_MATCH:
		*data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
		break;
#endif
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi)
{
	struct dev_context *devc;
	struct clockselect_50 clockselect;
	int triggerpin, ret;
	uint8_t triggerselect;
	struct triggerinout triggerinout_conf;
	struct triggerlut lut;
	uint8_t regval;
	uint8_t clock_bytes[sizeof(clockselect)];
	size_t clock_idx;

	devc = sdi->priv;

	if (sigma_convert_trigger(sdi) != SR_OK) {
		sr_err("Failed to configure triggers.");
		return SR_ERR;
	}

	/* If the samplerate has not been set, default to 200 kHz. */
	if (devc->cur_firmware == -1) {
		if ((ret = sigma_set_samplerate(sdi, SR_KHZ(200))) != SR_OK)
			return ret;
	}

	/* Enter trigger programming mode. */
	sigma_set_register(WRITE_TRIGGER_SELECT1, 0x20, devc);

	triggerselect = 0;
	if (devc->cur_samplerate >= SR_MHZ(100)) {
		/* 100 and 200 MHz mode. */
		sigma_set_register(WRITE_TRIGGER_SELECT1, 0x81, devc);

		/* Find which pin to trigger on from mask. */
		for (triggerpin = 0; triggerpin < 8; triggerpin++)
			if ((devc->trigger.risingmask | devc->trigger.fallingmask) &
			    (1 << triggerpin))
				break;

		/* Set trigger pin and light LED on trigger. */
		triggerselect = (1 << LEDSEL1) | (triggerpin & 0x7);

		/* Default rising edge. */
		if (devc->trigger.fallingmask)
			triggerselect |= 1 << 3;

	} else if (devc->cur_samplerate <= SR_MHZ(50)) {
		/* All other modes. */
		sigma_build_basic_trigger(&lut, devc);

		sigma_write_trigger_lut(&lut, devc);

		triggerselect = (1 << LEDSEL1) | (1 << LEDSEL0);
	}

	/* Setup trigger in and out pins to default values. */
	memset(&triggerinout_conf, 0, sizeof(struct triggerinout));
	triggerinout_conf.trgout_bytrigger = 1;
	triggerinout_conf.trgout_enable = 1;

	sigma_write_register(WRITE_TRIGGER_OPTION,
			     (uint8_t *) &triggerinout_conf,
			     sizeof(struct triggerinout), devc);

	/* Go back to normal mode. */
	sigma_set_register(WRITE_TRIGGER_SELECT1, triggerselect, devc);

	/* Set clock select register. */
	clockselect.async = 0;
	clockselect.fraction = 1 - 1;		/* Divider 1. */
	clockselect.disabled_channels = 0x0000;	/* All channels enabled. */
	if (devc->cur_samplerate == SR_MHZ(200)) {
		/* Enable 4 channels. */
		clockselect.disabled_channels = 0xf0ff;
	} else if (devc->cur_samplerate == SR_MHZ(100)) {
		/* Enable 8 channels. */
		clockselect.disabled_channels = 0x00ff;
	} else {
		/*
		 * 50 MHz mode, or fraction thereof. The 50MHz reference
		 * can get divided by any integer in the range 1 to 256.
		 * Divider minus 1 gets written to the hardware.
		 * (The driver lists a discrete set of sample rates, but
		 * all of them fit the above description.)
		 */
		clockselect.fraction = SR_MHZ(50) / devc->cur_samplerate - 1;
	}
	clock_idx = 0;
	clock_bytes[clock_idx++] = clockselect.async;
	clock_bytes[clock_idx++] = clockselect.fraction;
	clock_bytes[clock_idx++] = clockselect.disabled_channels & 0xff;
	clock_bytes[clock_idx++] = clockselect.disabled_channels >> 8;
	sigma_write_register(WRITE_CLOCK_SELECT, clock_bytes, clock_idx, devc);

	/* Setup maximum post trigger time. */
	sigma_set_register(WRITE_POST_TRIGGER,
			   (devc->capture_ratio * 255) / 100, devc);

	/* Start acqusition. */
	devc->start_time = g_get_monotonic_time();
	regval =  WMR_TRGRES | WMR_SDRAMWRITEEN;
#if ASIX_SIGMA_WITH_TRIGGER
	regval |= WMR_TRGEN;
#endif
	sigma_set_register(WRITE_MODE, regval, devc);

	std_session_send_df_header(sdi);

	/* Add capture source. */
	sr_session_source_add(sdi->session, -1, 0, 10, sigma_receive_data, (void *)sdi);

	devc->state.state = SIGMA_CAPTURE;

	return SR_OK;
}

static int dev_acquisition_stop(struct sr_dev_inst *sdi)
{
	struct dev_context *devc;

	devc = sdi->priv;
	devc->state.state = SIGMA_IDLE;

	sr_session_source_remove(sdi->session, -1);

	return SR_OK;
}

static struct sr_dev_driver asix_sigma_driver_info = {
	.name = "asix-sigma",
	.longname = "ASIX SIGMA/SIGMA2",
	.api_version = 1,
	.init = std_init,
	.cleanup = std_cleanup,
	.scan = scan,
	.dev_list = std_dev_list,
	.dev_clear = dev_clear,
	.config_get = config_get,
	.config_set = config_set,
	.config_list = config_list,
	.dev_open = dev_open,
	.dev_close = dev_close,
	.dev_acquisition_start = dev_acquisition_start,
	.dev_acquisition_stop = dev_acquisition_stop,
	.context = NULL,
};
SR_REGISTER_DEV_DRIVER(asix_sigma_driver_info);
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2010-2012 Håvard Espeland <gus@ping.uio.no>,
	5	* Copyright (C) 2010 Martin Stensgård <mastensg@ping.uio.no>
	6	* Copyright (C) 2010 Carl Henrik Lunde <chlunde@ping.uio.no>
	7	*
	8	* This program is free software: you can redistribute it and/or modify
	9	* it under the terms of the GNU General Public License as published by
	10	* the Free Software Foundation, either version 3 of the License, or
	11	* (at your option) any later version.
	12	*
	13	* This program is distributed in the hope that it will be useful,
	14	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	15	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	16	* GNU General Public License for more details.
	17	*
	18	* You should have received a copy of the GNU General Public License
	19	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	20	*/
	21
	22	#include <config.h>
	23	#include "protocol.h"
	24
	25	/*
	26	* Channel numbers seem to go from 1-16, according to this image:
	27	* http://tools.asix.net/img/sigma_sigmacab_pins_720.jpg
	28	* (the cable has two additional GND pins, and a TI and TO pin)
	29	*/
	30	static const char *channel_names[] = {
	31	"1", "2", "3", "4", "5", "6", "7", "8",
	32	"9", "10", "11", "12", "13", "14", "15", "16",
	33	};
	34
	35	static const uint32_t drvopts[] = {
	36	SR_CONF_LOGIC_ANALYZER,
	37	};
	38
	39	static const uint32_t devopts[] = {
	40	SR_CONF_LIMIT_MSEC \| SR_CONF_GET \| SR_CONF_SET,
	41	SR_CONF_LIMIT_SAMPLES \| SR_CONF_GET \| SR_CONF_SET,
	42	SR_CONF_SAMPLERATE \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	43	#if ASIX_SIGMA_WITH_TRIGGER
	44	SR_CONF_TRIGGER_MATCH \| SR_CONF_LIST,
	45	SR_CONF_CAPTURE_RATIO \| SR_CONF_GET \| SR_CONF_SET,
	46	#endif
	47	};
	48
	49	#if ASIX_SIGMA_WITH_TRIGGER
	50	static const int32_t trigger_matches[] = {
	51	SR_TRIGGER_ZERO,
	52	SR_TRIGGER_ONE,
	53	SR_TRIGGER_RISING,
	54	SR_TRIGGER_FALLING,
	55	};
	56	#endif
	57
	58	static void clear_helper(struct dev_context *devc)
	59	{
	60	ftdi_deinit(&devc->ftdic);
	61	}
	62
	63	static int dev_clear(const struct sr_dev_driver *di)
	64	{
	65	return std_dev_clear_with_callback(di, (std_dev_clear_callback)clear_helper);
	66	}
	67
	68	static GSList scan(struct sr_dev_driver di, GSList *options)
	69	{
	70	struct sr_dev_inst *sdi;
	71	struct dev_context *devc;
	72	struct ftdi_device_list *devlist;
	73	char serial_txt[10];
	74	uint32_t serial;
	75	int ret;
	76	unsigned int i;
	77
	78	(void)options;
	79
	80	devc = g_malloc0(sizeof(struct dev_context));
	81
	82	ftdi_init(&devc->ftdic);
	83
	84	if ((ret = ftdi_usb_find_all(&devc->ftdic, &devlist,
	85	USB_VENDOR, USB_PRODUCT)) <= 0) {
	86	if (ret < 0)
	87	sr_err("ftdi_usb_find_all(): %d", ret);
	88	goto free;
	89	}
	90
	91	/* Make sure it's a version 1 or 2 SIGMA. */
	92	ftdi_usb_get_strings(&devc->ftdic, devlist->dev, NULL, 0, NULL, 0,
	93	serial_txt, sizeof(serial_txt));
	94	sscanf(serial_txt, "%x", &serial);
	95
	96	if (serial < 0xa6010000 \|\| serial > 0xa602ffff) {
	97	sr_err("Only SIGMA and SIGMA2 are supported "
	98	"in this version of libsigrok.");
	99	goto free;
	100	}
	101
	102	sr_info("Found ASIX SIGMA - Serial: %s", serial_txt);
	103
	104	devc->cur_samplerate = samplerates[0];
	105	devc->limit_msec = 0;
	106	devc->limit_samples = 0;
	107	devc->cur_firmware = -1;
	108	devc->num_channels = 0;
	109	devc->samples_per_event = 0;
	110	devc->capture_ratio = 50;
	111	devc->use_triggers = 0;
	112
	113	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	114	sdi->status = SR_ST_INITIALIZING;
	115	sdi->vendor = g_strdup("ASIX");
	116	sdi->model = g_strdup("SIGMA");
	117
	118	for (i = 0; i < ARRAY_SIZE(channel_names); i++)
	119	sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_names[i]);
	120
	121	sdi->priv = devc;
	122
	123	ftdi_list_free(&devlist);
	124
	125	return std_scan_complete(di, g_slist_append(NULL, sdi));
	126
	127	free:
	128	ftdi_deinit(&devc->ftdic);
	129	g_free(devc);
	130	return NULL;
	131	}
	132
	133	static int dev_open(struct sr_dev_inst *sdi)
	134	{
	135	struct dev_context *devc;
	136	int ret;
	137
	138	devc = sdi->priv;
	139
	140	if ((ret = ftdi_usb_open_desc(&devc->ftdic,
	141	USB_VENDOR, USB_PRODUCT, USB_DESCRIPTION, NULL)) < 0) {
	142	sr_err("Failed to open device (%d): %s.",
	143	ret, ftdi_get_error_string(&devc->ftdic));
	144	return SR_ERR;
	145	}
	146
	147	return SR_OK;
	148	}
	149
	150	static int dev_close(struct sr_dev_inst *sdi)
	151	{
	152	struct dev_context *devc;
	153
	154	devc = sdi->priv;
	155
	156	return (ftdi_usb_close(&devc->ftdic) == 0) ? SR_OK : SR_ERR;
	157	}
	158
	159	static int config_get(uint32_t key, GVariant **data,
	160	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	161	{
	162	struct dev_context *devc;
	163
	164	(void)cg;
	165
	166	if (!sdi)
	167	return SR_ERR;
	168	devc = sdi->priv;
	169
	170	switch (key) {
	171	case SR_CONF_SAMPLERATE:
	172	*data = g_variant_new_uint64(devc->cur_samplerate);
	173	break;
	174	case SR_CONF_LIMIT_MSEC:
	175	*data = g_variant_new_uint64(devc->limit_msec);
	176	break;
	177	case SR_CONF_LIMIT_SAMPLES:
	178	*data = g_variant_new_uint64(devc->limit_samples);
	179	break;
	180	#if ASIX_SIGMA_WITH_TRIGGER
	181	case SR_CONF_CAPTURE_RATIO:
	182	*data = g_variant_new_uint64(devc->capture_ratio);
	183	break;
	184	#endif
	185	default:
	186	return SR_ERR_NA;
	187	}
	188
	189	return SR_OK;
	190	}
	191
	192	static int config_set(uint32_t key, GVariant *data,
	193	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	194	{
	195	struct dev_context *devc;
	196
	197	(void)cg;
	198
	199	devc = sdi->priv;
	200
	201	switch (key) {
	202	case SR_CONF_SAMPLERATE:
	203	return sigma_set_samplerate(sdi, g_variant_get_uint64(data));
	204	case SR_CONF_LIMIT_MSEC:
	205	devc->limit_msec = g_variant_get_uint64(data);
	206	break;
	207	case SR_CONF_LIMIT_SAMPLES:
	208	devc->limit_samples = g_variant_get_uint64(data);
	209	devc->limit_msec = sigma_limit_samples_to_msec(devc,
	210	devc->limit_samples);
	211	break;
	212	#if ASIX_SIGMA_WITH_TRIGGER
	213	case SR_CONF_CAPTURE_RATIO:
	214	devc->capture_ratio = g_variant_get_uint64(data);
	215	break;
	216	#endif
	217	default:
	218	return SR_ERR_NA;
	219	}
	220
	221	return SR_OK;
	222	}
	223
	224	static int config_list(uint32_t key, GVariant **data,
	225	const struct sr_dev_inst sdi, const struct sr_channel_group cg)
	226	{
	227	switch (key) {
	228	case SR_CONF_DEVICE_OPTIONS:
	229	return STD_CONFIG_LIST(key, data, sdi, cg, NULL, drvopts, devopts);
	230	case SR_CONF_SAMPLERATE:
	231	*data = std_gvar_samplerates(samplerates, samplerates_count);
	232	break;
	233	#if ASIX_SIGMA_WITH_TRIGGER
	234	case SR_CONF_TRIGGER_MATCH:
	235	*data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
	236	break;
	237	#endif
	238	default:
	239	return SR_ERR_NA;
	240	}
	241
	242	return SR_OK;
	243	}
	244
	245	static int dev_acquisition_start(const struct sr_dev_inst *sdi)
	246	{
	247	struct dev_context *devc;
	248	struct clockselect_50 clockselect;
	249	int triggerpin, ret;
	250	uint8_t triggerselect;
	251	struct triggerinout triggerinout_conf;
	252	struct triggerlut lut;
	253	uint8_t regval;
	254	uint8_t clock_bytes[sizeof(clockselect)];
	255	size_t clock_idx;
	256
	257	devc = sdi->priv;
	258
	259	if (sigma_convert_trigger(sdi) != SR_OK) {
	260	sr_err("Failed to configure triggers.");
	261	return SR_ERR;
	262	}
	263
	264	/* If the samplerate has not been set, default to 200 kHz. */
	265	if (devc->cur_firmware == -1) {
	266	if ((ret = sigma_set_samplerate(sdi, SR_KHZ(200))) != SR_OK)
	267	return ret;
	268	}
	269
	270	/* Enter trigger programming mode. */
	271	sigma_set_register(WRITE_TRIGGER_SELECT1, 0x20, devc);
	272
	273	triggerselect = 0;
	274	if (devc->cur_samplerate >= SR_MHZ(100)) {
	275	/* 100 and 200 MHz mode. */
	276	sigma_set_register(WRITE_TRIGGER_SELECT1, 0x81, devc);
	277
	278	/* Find which pin to trigger on from mask. */
	279	for (triggerpin = 0; triggerpin < 8; triggerpin++)
	280	if ((devc->trigger.risingmask \| devc->trigger.fallingmask) &
	281	(1 << triggerpin))
	282	break;
	283
	284	/* Set trigger pin and light LED on trigger. */
	285	triggerselect = (1 << LEDSEL1) \| (triggerpin & 0x7);
	286
	287	/* Default rising edge. */
	288	if (devc->trigger.fallingmask)
	289	triggerselect \|= 1 << 3;
	290
	291	} else if (devc->cur_samplerate <= SR_MHZ(50)) {
	292	/* All other modes. */
	293	sigma_build_basic_trigger(&lut, devc);
	294
	295	sigma_write_trigger_lut(&lut, devc);
	296
	297	triggerselect = (1 << LEDSEL1) \| (1 << LEDSEL0);
	298	}
	299
	300	/* Setup trigger in and out pins to default values. */
	301	memset(&triggerinout_conf, 0, sizeof(struct triggerinout));
	302	triggerinout_conf.trgout_bytrigger = 1;
	303	triggerinout_conf.trgout_enable = 1;
	304
	305	sigma_write_register(WRITE_TRIGGER_OPTION,
	306	(uint8_t *) &triggerinout_conf,
	307	sizeof(struct triggerinout), devc);
	308
	309	/* Go back to normal mode. */
	310	sigma_set_register(WRITE_TRIGGER_SELECT1, triggerselect, devc);
	311
	312	/* Set clock select register. */
	313	clockselect.async = 0;
	314	clockselect.fraction = 1 - 1; /* Divider 1. */
	315	clockselect.disabled_channels = 0x0000; /* All channels enabled. */
	316	if (devc->cur_samplerate == SR_MHZ(200)) {
	317	/* Enable 4 channels. */
	318	clockselect.disabled_channels = 0xf0ff;
	319	} else if (devc->cur_samplerate == SR_MHZ(100)) {
	320	/* Enable 8 channels. */
	321	clockselect.disabled_channels = 0x00ff;
	322	} else {
	323	/*
	324	* 50 MHz mode, or fraction thereof. The 50MHz reference
	325	* can get divided by any integer in the range 1 to 256.
	326	* Divider minus 1 gets written to the hardware.
	327	* (The driver lists a discrete set of sample rates, but
	328	* all of them fit the above description.)
	329	*/
	330	clockselect.fraction = SR_MHZ(50) / devc->cur_samplerate - 1;
	331	}
	332	clock_idx = 0;
	333	clock_bytes[clock_idx++] = clockselect.async;
	334	clock_bytes[clock_idx++] = clockselect.fraction;
	335	clock_bytes[clock_idx++] = clockselect.disabled_channels & 0xff;
	336	clock_bytes[clock_idx++] = clockselect.disabled_channels >> 8;
	337	sigma_write_register(WRITE_CLOCK_SELECT, clock_bytes, clock_idx, devc);
	338
	339	/* Setup maximum post trigger time. */
	340	sigma_set_register(WRITE_POST_TRIGGER,
	341	(devc->capture_ratio * 255) / 100, devc);
	342
	343	/* Start acqusition. */
	344	devc->start_time = g_get_monotonic_time();
	345	regval = WMR_TRGRES \| WMR_SDRAMWRITEEN;
	346	#if ASIX_SIGMA_WITH_TRIGGER
	347	regval \|= WMR_TRGEN;
	348	#endif
	349	sigma_set_register(WRITE_MODE, regval, devc);
	350
	351	std_session_send_df_header(sdi);
	352
	353	/* Add capture source. */
	354	sr_session_source_add(sdi->session, -1, 0, 10, sigma_receive_data, (void *)sdi);
	355
	356	devc->state.state = SIGMA_CAPTURE;
	357
	358	return SR_OK;
	359	}
	360
	361	static int dev_acquisition_stop(struct sr_dev_inst *sdi)
	362	{
	363	struct dev_context *devc;
	364
	365	devc = sdi->priv;
	366	devc->state.state = SIGMA_IDLE;
	367
	368	sr_session_source_remove(sdi->session, -1);
	369
	370	return SR_OK;
	371	}
	372
	373	static struct sr_dev_driver asix_sigma_driver_info = {
	374	.name = "asix-sigma",
	375	.longname = "ASIX SIGMA/SIGMA2",
	376	.api_version = 1,
	377	.init = std_init,
	378	.cleanup = std_cleanup,
	379	.scan = scan,
	380	.dev_list = std_dev_list,
	381	.dev_clear = dev_clear,
	382	.config_get = config_get,
	383	.config_set = config_set,
	384	.config_list = config_list,
	385	.dev_open = dev_open,
	386	.dev_close = dev_close,
	387	.dev_acquisition_start = dev_acquisition_start,
	388	.dev_acquisition_stop = dev_acquisition_stop,
	389	.context = NULL,
	390	};
	391	SR_REGISTER_DEV_DRIVER(asix_sigma_driver_info);