2 * This file is part of the libsigrok project.
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>
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.
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.
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/>.
23 * ASIX SIGMA/SIGMA2 logic analyzer driver
29 SR_PRIV struct sr_dev_driver asix_sigma_driver_info;
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)
36 static const char *channel_names[] = {
37 "1", "2", "3", "4", "5", "6", "7", "8",
38 "9", "10", "11", "12", "13", "14", "15", "16",
41 static const uint32_t drvopts[] = {
42 SR_CONF_LOGIC_ANALYZER,
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,
53 static const int32_t trigger_matches[] = {
61 static int dev_clear(const struct sr_dev_driver *di)
63 return std_dev_clear(di, sigma_clear_helper);
66 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
68 return std_init(sr_ctx, di, LOG_PREFIX);
71 static GSList *scan(struct sr_dev_driver *di, GSList *options)
73 struct sr_dev_inst *sdi;
74 struct drv_context *drvc;
75 struct dev_context *devc;
77 struct ftdi_device_list *devlist;
89 devc = g_malloc0(sizeof(struct dev_context));
91 ftdi_init(&devc->ftdic);
93 /* Look for SIGMAs. */
95 if ((ret = ftdi_usb_find_all(&devc->ftdic, &devlist,
96 USB_VENDOR, USB_PRODUCT)) <= 0) {
98 sr_err("ftdi_usb_find_all(): %d", ret);
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);
107 if (serial < 0xa6010000 || serial > 0xa602ffff) {
108 sr_err("Only SIGMA and SIGMA2 are supported "
109 "in this version of libsigrok.");
113 sr_info("Found ASIX SIGMA - Serial: %s", serial_txt);
115 devc->cur_samplerate = samplerates[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;
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);
131 for (i = 0; i < ARRAY_SIZE(channel_names); i++)
132 sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_names[i]);
134 devices = g_slist_append(devices, sdi);
135 drvc->instances = g_slist_append(drvc->instances, sdi);
138 /* We will open the device again when we need it. */
139 ftdi_list_free(&devlist);
144 ftdi_deinit(&devc->ftdic);
149 static GSList *dev_list(const struct sr_dev_driver *di)
151 return ((struct drv_context *)(di->context))->instances;
154 static int dev_open(struct sr_dev_inst *sdi)
156 struct dev_context *devc;
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) {
165 sr_err("ftdi_usb_open failed: %s",
166 ftdi_get_error_string(&devc->ftdic));
171 sdi->status = SR_ST_ACTIVE;
176 static int dev_close(struct sr_dev_inst *sdi)
178 struct dev_context *devc;
183 if (sdi->status == SR_ST_ACTIVE)
184 ftdi_usb_close(&devc->ftdic);
186 sdi->status = SR_ST_INACTIVE;
191 static int cleanup(const struct sr_dev_driver *di)
193 return dev_clear(di);
196 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
197 const struct sr_channel_group *cg)
199 struct dev_context *devc;
208 case SR_CONF_SAMPLERATE:
209 *data = g_variant_new_uint64(devc->cur_samplerate);
211 case SR_CONF_LIMIT_MSEC:
212 *data = g_variant_new_uint64(devc->limit_msec);
214 case SR_CONF_CAPTURE_RATIO:
215 *data = g_variant_new_uint64(devc->capture_ratio);
224 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
225 const struct sr_channel_group *cg)
227 struct dev_context *devc;
233 if (sdi->status != SR_ST_ACTIVE)
234 return SR_ERR_DEV_CLOSED;
240 case SR_CONF_SAMPLERATE:
241 ret = sigma_set_samplerate(sdi, g_variant_get_uint64(data));
243 case SR_CONF_LIMIT_MSEC:
244 tmp = g_variant_get_uint64(data);
246 devc->limit_msec = g_variant_get_uint64(data);
250 case SR_CONF_LIMIT_SAMPLES:
251 tmp = g_variant_get_uint64(data);
252 devc->limit_msec = tmp * 1000 / devc->cur_samplerate;
254 case SR_CONF_CAPTURE_RATIO:
255 tmp = g_variant_get_uint64(data);
257 devc->capture_ratio = tmp;
268 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
269 const struct sr_channel_group *cg)
277 case SR_CONF_DEVICE_OPTIONS:
279 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
280 drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
282 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
283 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
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);
292 case SR_CONF_TRIGGER_MATCH:
293 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
294 trigger_matches, ARRAY_SIZE(trigger_matches),
304 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
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;
313 if (sdi->status != SR_ST_ACTIVE)
314 return SR_ERR_DEV_CLOSED;
318 if (sigma_convert_trigger(sdi) != SR_OK) {
319 sr_err("Failed to configure triggers.");
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)
329 /* Enter trigger programming mode. */
330 sigma_set_register(WRITE_TRIGGER_SELECT1, 0x20, devc);
332 /* 100 and 200 MHz mode. */
333 if (devc->cur_samplerate >= SR_MHZ(100)) {
334 sigma_set_register(WRITE_TRIGGER_SELECT1, 0x81, devc);
336 /* Find which pin to trigger on from mask. */
337 for (triggerpin = 0; triggerpin < 8; triggerpin++)
338 if ((devc->trigger.risingmask | devc->trigger.fallingmask) &
342 /* Set trigger pin and light LED on trigger. */
343 triggerselect = (1 << LEDSEL1) | (triggerpin & 0x7);
345 /* Default rising edge. */
346 if (devc->trigger.fallingmask)
347 triggerselect |= 1 << 3;
349 /* All other modes. */
350 } else if (devc->cur_samplerate <= SR_MHZ(50)) {
351 sigma_build_basic_trigger(&lut, devc);
353 sigma_write_trigger_lut(&lut, devc);
355 triggerselect = (1 << LEDSEL1) | (1 << LEDSEL0);
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;
363 sigma_write_register(WRITE_TRIGGER_OPTION,
364 (uint8_t *) &triggerinout_conf,
365 sizeof(struct triggerinout), devc);
367 /* Go back to normal mode. */
368 sigma_set_register(WRITE_TRIGGER_SELECT1, triggerselect, devc);
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);
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.
382 frac = SR_MHZ(50) / devc->cur_samplerate - 1;
384 clockselect.async = 0;
385 clockselect.fraction = frac;
386 clockselect.disabled_channels = 0;
388 sigma_write_register(WRITE_CLOCK_SELECT,
389 (uint8_t *) &clockselect,
390 sizeof(clockselect), devc);
393 /* Setup maximum post trigger time. */
394 sigma_set_register(WRITE_POST_TRIGGER,
395 (devc->capture_ratio * 255) / 100, devc);
397 /* Start acqusition. */
398 gettimeofday(&devc->start_tv, 0);
399 sigma_set_register(WRITE_MODE, 0x0d, devc);
401 std_session_send_df_header(sdi, LOG_PREFIX);
403 /* Add capture source. */
404 sr_session_source_add(sdi->session, -1, 0, 10, sigma_receive_data, (void *)sdi);
406 devc->state.state = SIGMA_CAPTURE;
411 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
413 struct dev_context *devc;
416 devc->state.state = SIGMA_IDLE;
418 sr_session_source_remove(sdi->session, -1);
423 SR_PRIV struct sr_dev_driver asix_sigma_driver_info = {
424 .name = "asix-sigma",
425 .longname = "ASIX SIGMA/SIGMA2",
430 .dev_list = dev_list,
431 .dev_clear = dev_clear,
432 .config_get = config_get,
433 .config_set = config_set,
434 .config_list = config_list,
435 .dev_open = dev_open,
436 .dev_close = dev_close,
437 .dev_acquisition_start = dev_acquisition_start,
438 .dev_acquisition_stop = dev_acquisition_stop,