[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/>.
 */

/*
 * ASIX SIGMA/SIGMA2 logic analyzer driver
 */

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

SR_PRIV struct sr_dev_driver asix_sigma_driver_info;

/*
 * 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_SET,
	SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
	SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
	SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
};

static const int32_t trigger_matches[] = {
	SR_TRIGGER_ZERO,
	SR_TRIGGER_ONE,
	SR_TRIGGER_RISING,
	SR_TRIGGER_FALLING,
};


static int dev_clear(const struct sr_dev_driver *di)
{
	return std_dev_clear(di, sigma_clear_helper);
}

static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
{
	return std_init(sr_ctx, di, LOG_PREFIX);
}

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

	(void)options;

	drvc = di->context;

	devices = NULL;

	devc = g_malloc0(sizeof(struct dev_context));

	ftdi_init(&devc->ftdic);

	/* Look for SIGMAs. */

	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->period_ps = 0;
	devc->limit_msec = 0;
	devc->cur_firmware = -1;
	devc->num_channels = 0;
	devc->samples_per_event = 0;
	devc->capture_ratio = 50;
	devc->use_triggers = 0;

	/* Register SIGMA device. */
	sdi = g_malloc0(sizeof(struct sr_dev_inst));
	sdi->status = SR_ST_INITIALIZING;
	sdi->vendor = g_strdup(USB_VENDOR_NAME);
	sdi->model = g_strdup(USB_MODEL_NAME);
	sdi->driver = di;

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

	devices = g_slist_append(devices, sdi);
	drvc->instances = g_slist_append(drvc->instances, sdi);
	sdi->priv = devc;

	/* We will open the device again when we need it. */
	ftdi_list_free(&devlist);

	return devices;

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

static GSList *dev_list(const struct sr_dev_driver *di)
{
	return ((struct drv_context *)(di->context))->instances;
}

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

	devc = sdi->priv;

	/* Make sure it's an ASIX SIGMA. */
	if ((ret = ftdi_usb_open_desc(&devc->ftdic,
		USB_VENDOR, USB_PRODUCT, USB_DESCRIPTION, NULL)) < 0) {

		sr_err("ftdi_usb_open failed: %s",
		       ftdi_get_error_string(&devc->ftdic));

		return 0;
	}

	sdi->status = SR_ST_ACTIVE;

	return SR_OK;
}

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

	devc = sdi->priv;

	/* TODO */
	if (sdi->status == SR_ST_ACTIVE)
		ftdi_usb_close(&devc->ftdic);

	sdi->status = SR_ST_INACTIVE;

	return SR_OK;
}

static int cleanup(const struct sr_dev_driver *di)
{
	return dev_clear(di);
}

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_CAPTURE_RATIO:
		*data = g_variant_new_uint64(devc->capture_ratio);
		break;
	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;
	uint64_t tmp;
	int ret;

	(void)cg;

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

	devc = sdi->priv;

	ret = SR_OK;
	switch (key) {
	case SR_CONF_SAMPLERATE:
		ret = sigma_set_samplerate(sdi, g_variant_get_uint64(data));
		break;
	case SR_CONF_LIMIT_MSEC:
		tmp = g_variant_get_uint64(data);
		if (tmp > 0)
			devc->limit_msec = g_variant_get_uint64(data);
		else
			ret = SR_ERR;
		break;
	case SR_CONF_LIMIT_SAMPLES:
		tmp = g_variant_get_uint64(data);
		devc->limit_msec = tmp * 1000 / devc->cur_samplerate;
		break;
	case SR_CONF_CAPTURE_RATIO:
		tmp = g_variant_get_uint64(data);
		if (tmp <= 100)
			devc->capture_ratio = tmp;
		else
			ret = SR_ERR;
		break;
	default:
		ret = SR_ERR_NA;
	}

	return ret;
}

static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
		const struct sr_channel_group *cg)
{
	GVariant *gvar;
	GVariantBuilder gvb;

	(void)cg;

	switch (key) {
	case SR_CONF_DEVICE_OPTIONS:
		if (!sdi)
			*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
					drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
		else
			*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
					devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
		break;
	case SR_CONF_SAMPLERATE:
		g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
		gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
				SAMPLERATES_COUNT, sizeof(uint64_t));
		g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
		*data = g_variant_builder_end(&gvb);
		break;
	case SR_CONF_TRIGGER_MATCH:
		*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
				trigger_matches, ARRAY_SIZE(trigger_matches),
				sizeof(int32_t));
		break;
	default:
		return SR_ERR_NA;
	}

	return SR_OK;
}

static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
{
	struct dev_context *devc;
	struct clockselect_50 clockselect;
	int frac, triggerpin, ret;
	uint8_t triggerselect = 0;
	struct triggerinout triggerinout_conf;
	struct triggerlut lut;

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

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

	/* 100 and 200 MHz mode. */
	if (devc->cur_samplerate >= SR_MHZ(100)) {
		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;

	/* All other modes. */
	} else if (devc->cur_samplerate <= SR_MHZ(50)) {
		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. */
	if (devc->cur_samplerate == SR_MHZ(200))
		/* Enable 4 channels. */
		sigma_set_register(WRITE_CLOCK_SELECT, 0xf0, devc);
	else if (devc->cur_samplerate == SR_MHZ(100))
		/* Enable 8 channels. */
		sigma_set_register(WRITE_CLOCK_SELECT, 0x00, devc);
	else {
		/*
		 * 50 MHz mode (or fraction thereof). Any fraction down to
		 * 50 MHz / 256 can be used, but is not supported by sigrok API.
		 */
		frac = SR_MHZ(50) / devc->cur_samplerate - 1;

		clockselect.async = 0;
		clockselect.fraction = frac;
		clockselect.disabled_channels = 0;

		sigma_write_register(WRITE_CLOCK_SELECT,
				     (uint8_t *) &clockselect,
				     sizeof(clockselect), devc);
	}

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

	/* Start acqusition. */
	gettimeofday(&devc->start_tv, 0);
	sigma_set_register(WRITE_MODE, 0x0d, devc);

	devc->cb_data = cb_data;

	std_session_send_df_header(sdi, LOG_PREFIX);

	/* 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, void *cb_data)
{
	struct dev_context *devc;

	(void)cb_data;

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

	sr_session_source_remove(sdi->session, -1);

	return SR_OK;
}

SR_PRIV struct sr_dev_driver asix_sigma_driver_info = {
	.name = "asix-sigma",
	.longname = "ASIX SIGMA/SIGMA2",
	.api_version = 1,
	.init = init,
	.cleanup = cleanup,
	.scan = scan,
	.dev_list = 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,
};
Commit	Line	Data
3ba56876	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	/*
	23	* ASIX SIGMA/SIGMA2 logic analyzer driver
	24	*/
	25
	26	#include <config.h>
	27	#include "protocol.h"
	28
	29	SR_PRIV struct sr_dev_driver asix_sigma_driver_info;
	30
	31	/*
	32	* Channel numbers seem to go from 1-16, according to this image:
	33	* http://tools.asix.net/img/sigma_sigmacab_pins_720.jpg
	34	* (the cable has two additional GND pins, and a TI and TO pin)
	35	*/
	36	static const char *channel_names[] = {
	37	"1", "2", "3", "4", "5", "6", "7", "8",
	38	"9", "10", "11", "12", "13", "14", "15", "16",
	39	};
	40
	41	static const uint32_t drvopts[] = {
	42	SR_CONF_LOGIC_ANALYZER,
	43	};
	44
	45	static const uint32_t devopts[] = {
	46	SR_CONF_LIMIT_MSEC \| SR_CONF_GET \| SR_CONF_SET,
	47	SR_CONF_LIMIT_SAMPLES \| SR_CONF_SET,
	48	SR_CONF_SAMPLERATE \| SR_CONF_GET \| SR_CONF_SET \| SR_CONF_LIST,
	49	SR_CONF_TRIGGER_MATCH \| SR_CONF_LIST,
	50	SR_CONF_CAPTURE_RATIO \| SR_CONF_GET \| SR_CONF_SET,
	51	};
	52
	53	static const int32_t trigger_matches[] = {
	54	SR_TRIGGER_ZERO,
	55	SR_TRIGGER_ONE,
	56	SR_TRIGGER_RISING,
	57	SR_TRIGGER_FALLING,
	58	};
	59
	60
	61	static int dev_clear(const struct sr_dev_driver *di)
	62	{
	63	return std_dev_clear(di, sigma_clear_helper);
	64	}
65
66	static int init(struct sr_dev_driver di, struct sr_context sr_ctx)
67	{
68	return std_init(sr_ctx, di, LOG_PREFIX);
69	}
70
71	static GSList scan(struct sr_dev_driver di, GSList *options)
72	{
73	struct sr_dev_inst *sdi;
74	struct drv_context *drvc;
75	struct dev_context *devc;
76	GSList *devices;
77	struct ftdi_device_list *devlist;
78	char serial_txt[10];
79	uint32_t serial;
80	int ret;
81	unsigned int i;
82
83	(void)options;
84
85	drvc = di->context;
86
87	devices = NULL;
88
89	devc = g_malloc0(sizeof(struct dev_context));
90
91	ftdi_init(&devc->ftdic);
92
93	/* Look for SIGMAs. */
94
95	if ((ret = ftdi_usb_find_all(&devc->ftdic, &devlist,
96	USB_VENDOR, USB_PRODUCT)) <= 0) {
97	if (ret < 0)
98	sr_err("ftdi_usb_find_all(): %d", ret);
99	goto free;
100	}
101
102	/* Make sure it's a version 1 or 2 SIGMA. */
103	ftdi_usb_get_strings(&devc->ftdic, devlist->dev, NULL, 0, NULL, 0,
104	serial_txt, sizeof(serial_txt));
105	sscanf(serial_txt, "%x", &serial);
106
107	if (serial < 0xa6010000 \|\| serial > 0xa602ffff) {
108	sr_err("Only SIGMA and SIGMA2 are supported "
109	"in this version of libsigrok.");
110	goto free;
111	}
112
113	sr_info("Found ASIX SIGMA - Serial: %s", serial_txt);
114
115	devc->cur_samplerate = samplerates[0];
116	devc->period_ps = 0;
117	devc->limit_msec = 0;
118	devc->cur_firmware = -1;
119	devc->num_channels = 0;
120	devc->samples_per_event = 0;
121	devc->capture_ratio = 50;
122	devc->use_triggers = 0;
123
124	/* Register SIGMA device. */
125	sdi = g_malloc0(sizeof(struct sr_dev_inst));
126	sdi->status = SR_ST_INITIALIZING;
127	sdi->vendor = g_strdup(USB_VENDOR_NAME);
128	sdi->model = g_strdup(USB_MODEL_NAME);
129	sdi->driver = di;
130
131	for (i = 0; i < ARRAY_SIZE(channel_names); i++)
132	sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_names[i]);
133
134	devices = g_slist_append(devices, sdi);
135	drvc->instances = g_slist_append(drvc->instances, sdi);
136	sdi->priv = devc;
137
138	/* We will open the device again when we need it. */
139	ftdi_list_free(&devlist);
140
141	return devices;
142
143	free:
144	ftdi_deinit(&devc->ftdic);
145	g_free(devc);
146	return NULL;
147	}
148
149	static GSList dev_list(const struct sr_dev_driver di)
150	{
151	return ((struct drv_context *)(di->context))->instances;
152	}
153
154	static int dev_open(struct sr_dev_inst *sdi)
155	{
156	struct dev_context *devc;
157	int ret;
158
159	devc = sdi->priv;
160
161	/* Make sure it's an ASIX SIGMA. */
162	if ((ret = ftdi_usb_open_desc(&devc->ftdic,
163	USB_VENDOR, USB_PRODUCT, USB_DESCRIPTION, NULL)) < 0) {
164
165	sr_err("ftdi_usb_open failed: %s",
166	ftdi_get_error_string(&devc->ftdic));
167
168	return 0;
169	}
170
171	sdi->status = SR_ST_ACTIVE;
172
173	return SR_OK;
174	}
175
176	static int dev_close(struct sr_dev_inst *sdi)
177	{
178	struct dev_context *devc;
179
180	devc = sdi->priv;
181
182	/* TODO */
183	if (sdi->status == SR_ST_ACTIVE)
184	ftdi_usb_close(&devc->ftdic);
185
186	sdi->status = SR_ST_INACTIVE;
187
188	return SR_OK;
189	}
190
191	static int cleanup(const struct sr_dev_driver *di)
192	{
193	return dev_clear(di);
194	}
195
196	static int config_get(uint32_t key, GVariant *data, const struct sr_dev_inst sdi,
197	const struct sr_channel_group *cg)
198	{
199	struct dev_context *devc;
200
201	(void)cg;
202
203	if (!sdi)
204	return SR_ERR;
205	devc = sdi->priv;
206
207	switch (key) {
208	case SR_CONF_SAMPLERATE:
209	*data = g_variant_new_uint64(devc->cur_samplerate);
210	break;
211	case SR_CONF_LIMIT_MSEC:
212	*data = g_variant_new_uint64(devc->limit_msec);
213	break;
214	case SR_CONF_CAPTURE_RATIO:
215	*data = g_variant_new_uint64(devc->capture_ratio);
216	break;
217	default:
218	return SR_ERR_NA;
219	}
220
221	return SR_OK;
222	}
223
224	static int config_set(uint32_t key, GVariant data, const struct sr_dev_inst sdi,
225	const struct sr_channel_group *cg)
226	{
227	struct dev_context *devc;
228	uint64_t tmp;
229	int ret;
230
231	(void)cg;
232
233	if (sdi->status != SR_ST_ACTIVE)
234	return SR_ERR_DEV_CLOSED;
235
236	devc = sdi->priv;
237
238	ret = SR_OK;
239	switch (key) {
240	case SR_CONF_SAMPLERATE:
241	ret = sigma_set_samplerate(sdi, g_variant_get_uint64(data));
242	break;
243	case SR_CONF_LIMIT_MSEC:
244	tmp = g_variant_get_uint64(data);
245	if (tmp > 0)
246	devc->limit_msec = g_variant_get_uint64(data);
247	else
248	ret = SR_ERR;
249	break;
250	case SR_CONF_LIMIT_SAMPLES:
251	tmp = g_variant_get_uint64(data);
252	devc->limit_msec = tmp * 1000 / devc->cur_samplerate;
253	break;
254	case SR_CONF_CAPTURE_RATIO:
255	tmp = g_variant_get_uint64(data);
256	if (tmp <= 100)
257	devc->capture_ratio = tmp;
258	else
259	ret = SR_ERR;
260	break;
261	default:
262	ret = SR_ERR_NA;
263	}
264
265	return ret;
266	}
267
268	static int config_list(uint32_t key, GVariant *data, const struct sr_dev_inst sdi,
269	const struct sr_channel_group *cg)
270	{
271	GVariant *gvar;
272	GVariantBuilder gvb;
273
274	(void)cg;
275
276	switch (key) {
277	case SR_CONF_DEVICE_OPTIONS:
278	if (!sdi)
279	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
280	drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
281	else
282	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
283	devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
284	break;
285	case SR_CONF_SAMPLERATE:
286	g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
287	gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"), samplerates,
288	SAMPLERATES_COUNT, sizeof(uint64_t));
289	g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
290	*data = g_variant_builder_end(&gvb);
291	break;
292	case SR_CONF_TRIGGER_MATCH:
293	*data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
294	trigger_matches, ARRAY_SIZE(trigger_matches),
295	sizeof(int32_t));
296	break;
297	default:
298	return SR_ERR_NA;
299	}
300
301	return SR_OK;
302	}
303
304	static int dev_acquisition_start(const struct sr_dev_inst sdi, void cb_data)
305	{
306	struct dev_context *devc;
307	struct clockselect_50 clockselect;
308	int frac, triggerpin, ret;
309	uint8_t triggerselect = 0;
310	struct triggerinout triggerinout_conf;
311	struct triggerlut lut;
312
313	if (sdi->status != SR_ST_ACTIVE)
314	return SR_ERR_DEV_CLOSED;
315
316	devc = sdi->priv;
317
318	if (sigma_convert_trigger(sdi) != SR_OK) {
319	sr_err("Failed to configure triggers.");
320	return SR_ERR;
321	}
322
323	/* If the samplerate has not been set, default to 200 kHz. */
324	if (devc->cur_firmware == -1) {
325	if ((ret = sigma_set_samplerate(sdi, SR_KHZ(200))) != SR_OK)
326	return ret;
327	}
328
329	/* Enter trigger programming mode. */
330	sigma_set_register(WRITE_TRIGGER_SELECT1, 0x20, devc);
331
332	/* 100 and 200 MHz mode. */
333	if (devc->cur_samplerate >= SR_MHZ(100)) {
334	sigma_set_register(WRITE_TRIGGER_SELECT1, 0x81, devc);
335
336	/* Find which pin to trigger on from mask. */
0a1f7b09	337	for (triggerpin = 0; triggerpin < 8; triggerpin++)
3ba56876	338	if ((devc->trigger.risingmask \| devc->trigger.fallingmask) &
	339	(1 << triggerpin))
	340	break;
	341
	342	/* Set trigger pin and light LED on trigger. */
	343	triggerselect = (1 << LEDSEL1) \| (triggerpin & 0x7);
	344
	345	/* Default rising edge. */
	346	if (devc->trigger.fallingmask)
	347	triggerselect \|= 1 << 3;
	348
	349	/* All other modes. */
	350	} else if (devc->cur_samplerate <= SR_MHZ(50)) {
	351	sigma_build_basic_trigger(&lut, devc);
	352
	353	sigma_write_trigger_lut(&lut, devc);
	354
	355	triggerselect = (1 << LEDSEL1) \| (1 << LEDSEL0);
	356	}
	357
	358	/* Setup trigger in and out pins to default values. */
	359	memset(&triggerinout_conf, 0, sizeof(struct triggerinout));
	360	triggerinout_conf.trgout_bytrigger = 1;
	361	triggerinout_conf.trgout_enable = 1;
	362
	363	sigma_write_register(WRITE_TRIGGER_OPTION,
	364	(uint8_t *) &triggerinout_conf,
	365	sizeof(struct triggerinout), devc);
	366
	367	/* Go back to normal mode. */
	368	sigma_set_register(WRITE_TRIGGER_SELECT1, triggerselect, devc);
	369
	370	/* Set clock select register. */
	371	if (devc->cur_samplerate == SR_MHZ(200))
	372	/* Enable 4 channels. */
	373	sigma_set_register(WRITE_CLOCK_SELECT, 0xf0, devc);
	374	else if (devc->cur_samplerate == SR_MHZ(100))
	375	/* Enable 8 channels. */
	376	sigma_set_register(WRITE_CLOCK_SELECT, 0x00, devc);
	377	else {
	378	/*
	379	* 50 MHz mode (or fraction thereof). Any fraction down to
	380	* 50 MHz / 256 can be used, but is not supported by sigrok API.
	381	*/
	382	frac = SR_MHZ(50) / devc->cur_samplerate - 1;
	383
	384	clockselect.async = 0;
	385	clockselect.fraction = frac;
	386	clockselect.disabled_channels = 0;
	387
	388	sigma_write_register(WRITE_CLOCK_SELECT,
	389	(uint8_t *) &clockselect,
	390	sizeof(clockselect), devc);
	391	}
	392
	393	/* Setup maximum post trigger time. */
	394	sigma_set_register(WRITE_POST_TRIGGER,
	395	(devc->capture_ratio * 255) / 100, devc);
	396
	397	/* Start acqusition. */
	398	gettimeofday(&devc->start_tv, 0);
	399	sigma_set_register(WRITE_MODE, 0x0d, devc);
	400
	401	devc->cb_data = cb_data;
402
3ba56876	403	std_session_send_df_header(sdi, LOG_PREFIX);
	404
	405	/* Add capture source. */
	406	sr_session_source_add(sdi->session, -1, 0, 10, sigma_receive_data, (void *)sdi);
	407
	408	devc->state.state = SIGMA_CAPTURE;
	409
	410	return SR_OK;
	411	}
	412
	413	static int dev_acquisition_stop(struct sr_dev_inst sdi, void cb_data)
	414	{
	415	struct dev_context *devc;
	416
	417	(void)cb_data;
	418
	419	devc = sdi->priv;
	420	devc->state.state = SIGMA_IDLE;
	421
	422	sr_session_source_remove(sdi->session, -1);
	423
	424	return SR_OK;
	425	}
	426
	427	SR_PRIV struct sr_dev_driver asix_sigma_driver_info = {
	428	.name = "asix-sigma",
	429	.longname = "ASIX SIGMA/SIGMA2",
	430	.api_version = 1,
	431	.init = init,
	432	.cleanup = cleanup,
	433	.scan = scan,
	434	.dev_list = dev_list,
	435	.dev_clear = dev_clear,
	436	.config_get = config_get,
	437	.config_set = config_set,
	438	.config_list = config_list,
	439	.dev_open = dev_open,
	440	.dev_close = dev_close,
	441	.dev_acquisition_start = dev_acquisition_start,
	442	.dev_acquisition_stop = dev_acquisition_stop,
	443	.context = NULL,
	444	};