]> sigrok.org Git - libsigrok.git/blame_incremental - src/hardware/rigol-ds/api.c
projects / libsigrok.git / blame_incremental
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (non-incremental) | history | HEAD
rigol-ds: Fix double free.
[libsigrok.git] / src / hardware / rigol-ds / api.c
... / ...
CommitLineData
1/*
2 * This file is part of the libsigrok project.
3 *
4 * Copyright (C) 2012 Martin Ling <martin-git@earth.li>
5 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
6 * Copyright (C) 2013 Mathias Grimmberger <mgri@zaphod.sax.de>
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 <fcntl.h>
23#include <unistd.h>
24#include <stdlib.h>
25#include <string.h>
26#include <math.h>
27#include <glib.h>
28#include "libsigrok.h"
29#include "libsigrok-internal.h"
30#include "protocol.h"
31
32static const uint32_t scanopts[] = {
33 SR_CONF_CONN,
34 SR_CONF_SERIALCOMM
35};
36
37static const uint32_t devopts[] = {
38 SR_CONF_OSCILLOSCOPE,
39 SR_CONF_LIMIT_FRAMES | SR_CONF_SET,
40 SR_CONF_TIMEBASE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
41 SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
42 SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
43 SR_CONF_HORIZ_TRIGGERPOS | SR_CONF_SET,
44 SR_CONF_NUM_HDIV | SR_CONF_GET,
45 SR_CONF_SAMPLERATE | SR_CONF_GET,
46};
47
48static const uint32_t analog_devopts[] = {
49 SR_CONF_NUM_VDIV | SR_CONF_GET,
50 SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
51 SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
52 SR_CONF_DATA_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
53};
54
55static const uint64_t timebases[][2] = {
56 /* nanoseconds */
57 { 1, 1000000000 },
58 { 2, 1000000000 },
59 { 5, 1000000000 },
60 { 10, 1000000000 },
61 { 20, 1000000000 },
62 { 50, 1000000000 },
63 { 100, 1000000000 },
64 { 500, 1000000000 },
65 /* microseconds */
66 { 1, 1000000 },
67 { 2, 1000000 },
68 { 5, 1000000 },
69 { 10, 1000000 },
70 { 20, 1000000 },
71 { 50, 1000000 },
72 { 100, 1000000 },
73 { 200, 1000000 },
74 { 500, 1000000 },
75 /* milliseconds */
76 { 1, 1000 },
77 { 2, 1000 },
78 { 5, 1000 },
79 { 10, 1000 },
80 { 20, 1000 },
81 { 50, 1000 },
82 { 100, 1000 },
83 { 200, 1000 },
84 { 500, 1000 },
85 /* seconds */
86 { 1, 1 },
87 { 2, 1 },
88 { 5, 1 },
89 { 10, 1 },
90 { 20, 1 },
91 { 50, 1 },
92 { 100, 1 },
93 { 200, 1 },
94 { 500, 1 },
95 { 1000, 1 },
96};
97
98static const uint64_t vdivs[][2] = {
99 /* microvolts */
100 { 500, 1000000 },
101 /* millivolts */
102 { 1, 1000 },
103 { 2, 1000 },
104 { 5, 1000 },
105 { 10, 1000 },
106 { 20, 1000 },
107 { 50, 1000 },
108 { 100, 1000 },
109 { 200, 1000 },
110 { 500, 1000 },
111 /* volts */
112 { 1, 1 },
113 { 2, 1 },
114 { 5, 1 },
115 { 10, 1 },
116 { 20, 1 },
117 { 50, 1 },
118 { 100, 1 },
119};
120
121#define NUM_TIMEBASE ARRAY_SIZE(timebases)
122#define NUM_VDIV ARRAY_SIZE(vdivs)
123
124static const char *trigger_sources[] = {
125 "CH1",
126 "CH2",
127 "CH3",
128 "CH4",
129 "EXT",
130 "AC Line",
131 "D0",
132 "D1",
133 "D2",
134 "D3",
135 "D4",
136 "D5",
137 "D6",
138 "D7",
139 "D8",
140 "D9",
141 "D10",
142 "D11",
143 "D12",
144 "D13",
145 "D14",
146 "D15",
147};
148
149static const char *trigger_slopes[] = {
150 "r",
151 "f",
152};
153
154static const char *coupling[] = {
155 "AC",
156 "DC",
157 "GND",
158};
159
160/* Do not change the order of entries */
161static const char *data_sources[] = {
162 "Live",
163 "Memory",
164 "Segmented",
165};
166
167enum vendor {
168 RIGOL,
169 AGILENT,
170};
171
172enum series {
173 VS5000,
174 DS1000,
175 DS2000,
176 DS2000A,
177 DSO1000,
178};
179
180/* short name, full name */
181static const struct rigol_ds_vendor supported_vendors[] = {
182 [RIGOL] = {"Rigol", "Rigol Technologies"},
183 [AGILENT] = {"Agilent", "Agilent Technologies"},
184};
185
186#define VENDOR(x) &supported_vendors[x]
187/* vendor, series, protocol, max timebase, min vdiv, number of horizontal divs,
188 * live waveform samples, memory buffer samples */
189static const struct rigol_ds_series supported_series[] = {
190 [VS5000] = {VENDOR(RIGOL), "VS5000", PROTOCOL_V1, FORMAT_RAW,
191 {50, 1}, {2, 1000}, 14, 2048, 0},
192 [DS1000] = {VENDOR(RIGOL), "DS1000", PROTOCOL_V2, FORMAT_IEEE488_2,
193 {50, 1}, {2, 1000}, 12, 600, 1048576},
194 [DS2000] = {VENDOR(RIGOL), "DS2000", PROTOCOL_V3, FORMAT_IEEE488_2,
195 {500, 1}, {500, 1000000}, 14, 1400, 14000},
196 [DS2000A] = {VENDOR(RIGOL), "DS2000A", PROTOCOL_V3, FORMAT_IEEE488_2,
197 {1000, 1}, {500, 1000000}, 14, 1400, 14000},
198 [DSO1000] = {VENDOR(AGILENT), "DSO1000", PROTOCOL_V3, FORMAT_IEEE488_2,
199 {50, 1}, {2, 1000}, 12, 600, 20480},
200};
201
202#define SERIES(x) &supported_series[x]
203/* series, model, min timebase, analog channels, digital */
204static const struct rigol_ds_model supported_models[] = {
205 {SERIES(VS5000), "VS5022", {20, 1000000000}, 2, false},
206 {SERIES(VS5000), "VS5042", {10, 1000000000}, 2, false},
207 {SERIES(VS5000), "VS5062", {5, 1000000000}, 2, false},
208 {SERIES(VS5000), "VS5102", {2, 1000000000}, 2, false},
209 {SERIES(VS5000), "VS5202", {2, 1000000000}, 2, false},
210 {SERIES(VS5000), "VS5022D", {20, 1000000000}, 2, true},
211 {SERIES(VS5000), "VS5042D", {10, 1000000000}, 2, true},
212 {SERIES(VS5000), "VS5062D", {5, 1000000000}, 2, true},
213 {SERIES(VS5000), "VS5102D", {2, 1000000000}, 2, true},
214 {SERIES(VS5000), "VS5202D", {2, 1000000000}, 2, true},
215 {SERIES(DS1000), "DS1052E", {5, 1000000000}, 2, false},
216 {SERIES(DS1000), "DS1102E", {2, 1000000000}, 2, false},
217 {SERIES(DS1000), "DS1152E", {2, 1000000000}, 2, false},
218 {SERIES(DS1000), "DS1052D", {5, 1000000000}, 2, true},
219 {SERIES(DS1000), "DS1102D", {2, 1000000000}, 2, true},
220 {SERIES(DS1000), "DS1152D", {2, 1000000000}, 2, true},
221 {SERIES(DS2000), "DS2072", {5, 1000000000}, 2, false},
222 {SERIES(DS2000), "DS2102", {5, 1000000000}, 2, false},
223 {SERIES(DS2000), "DS2202", {2, 1000000000}, 2, false},
224 {SERIES(DS2000), "DS2302", {1, 1000000000}, 2, false},
225 {SERIES(DS2000A), "DS2072A", {5, 1000000000}, 2, false},
226 {SERIES(DS2000A), "DS2102A", {5, 1000000000}, 2, false},
227 {SERIES(DS2000A), "DS2202A", {2, 1000000000}, 2, false},
228 {SERIES(DS2000A), "DS2302A", {1, 1000000000}, 2, false},
229 {SERIES(DSO1000), "DSO1002A", {5, 1000000000}, 2, false},
230 {SERIES(DSO1000), "DSO1004A", {5, 1000000000}, 4, false},
231 {SERIES(DSO1000), "DSO1012A", {2, 1000000000}, 2, false},
232 {SERIES(DSO1000), "DSO1014A", {2, 1000000000}, 4, false},
233 {SERIES(DSO1000), "DSO1022A", {2, 1000000000}, 2, false},
234 {SERIES(DSO1000), "DSO1024A", {2, 1000000000}, 4, false},
235};
236
237SR_PRIV struct sr_dev_driver rigol_ds_driver_info;
238static struct sr_dev_driver *di = &rigol_ds_driver_info;
239
240static void clear_helper(void *priv)
241{
242 struct dev_context *devc;
243 unsigned int i;
244
245 devc = priv;
246 g_free(devc->data);
247 g_free(devc->buffer);
248 for (i = 0; i < ARRAY_SIZE(devc->coupling); i++)
249 g_free(devc->coupling[i]);
250 g_free(devc->trigger_source);
251 g_free(devc->trigger_slope);
252 g_free(devc->analog_groups);
253 g_free(devc);
254}
255
256static int dev_clear(void)
257{
258 return std_dev_clear(di, clear_helper);
259}
260
261static int init(struct sr_context *sr_ctx)
262{
263 return std_init(sr_ctx, di, LOG_PREFIX);
264}
265
266static struct sr_dev_inst *probe_device(struct sr_scpi_dev_inst *scpi)
267{
268 struct dev_context *devc;
269 struct sr_dev_inst *sdi;
270 struct sr_scpi_hw_info *hw_info;
271 struct sr_channel *ch;
272 long n[3];
273 unsigned int i;
274 const struct rigol_ds_model *model = NULL;
275 gchar *channel_name, **version;
276
277 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
278 sr_info("Couldn't get IDN response, retrying.");
279 sr_scpi_close(scpi);
280 sr_scpi_open(scpi);
281 if (sr_scpi_get_hw_id(scpi, &hw_info) != SR_OK) {
282 sr_info("Couldn't get IDN response.");
283 return NULL;
284 }
285 }
286
287 for (i = 0; i < ARRAY_SIZE(supported_models); i++) {
288 if (!strcasecmp(hw_info->manufacturer,
289 supported_models[i].series->vendor->full_name) &&
290 !strcmp(hw_info->model, supported_models[i].name)) {
291 model = &supported_models[i];
292 break;
293 }
294 }
295
296 if (!model) {
297 sr_scpi_hw_info_free(hw_info);
298 return NULL;
299 }
300
301 sdi = g_malloc0(sizeof(struct sr_dev_inst));
302 sdi->status = SR_ST_ACTIVE;
303 sdi->vendor = g_strdup(model->series->vendor->name);
304 sdi->model = g_strdup(model->name);
305 sdi->version = g_strdup(hw_info->firmware_version);
306 sdi->conn = scpi;
307 sdi->driver = di;
308 sdi->inst_type = SR_INST_SCPI;
309 sdi->serial_num = g_strdup(hw_info->serial_number);
310 devc = g_malloc0(sizeof(struct dev_context));
311 devc->limit_frames = 0;
312 devc->model = model;
313 devc->format = model->series->format;
314
315 /* DS1000 models with firmware before 0.2.4 used the old data format. */
316 if (model->series == SERIES(DS1000)) {
317 version = g_strsplit(hw_info->firmware_version, ".", 0);
318 do {
319 if (!version[0] || !version[1] || !version[2])
320 break;
321 if (version[0][0] == 0 || version[1][0] == 0 || version[2][0] == 0)
322 break;
323 for (i = 0; i < 3; i++) {
324 if (sr_atol(version[i], &n[i]) != SR_OK)
325 break;
326 }
327 if (i != 3)
328 break;
329 if (n[0] != 0 || n[1] > 2)
330 break;
331 if (n[1] == 2 && n[2] > 3)
332 break;
333 sr_dbg("Found DS1000 firmware < 0.2.4, using raw data format.");
334 devc->format = FORMAT_RAW;
335 } while(0);
336 g_strfreev(version);
337 }
338
339 sr_scpi_hw_info_free(hw_info);
340
341 devc->analog_groups = g_malloc0(sizeof(struct sr_channel_group*) *
342 model->analog_channels);
343
344 for (i = 0; i < model->analog_channels; i++) {
345 if (!(channel_name = g_strdup_printf("CH%d", i + 1)))
346 return NULL;
347 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_name);
348
349 devc->analog_groups[i] = g_malloc0(sizeof(struct sr_channel_group));
350
351 devc->analog_groups[i]->name = channel_name;
352 devc->analog_groups[i]->channels = g_slist_append(NULL, ch);
353 sdi->channel_groups = g_slist_append(sdi->channel_groups,
354 devc->analog_groups[i]);
355 }
356
357 if (devc->model->has_digital) {
358 devc->digital_group = g_malloc0(sizeof(struct sr_channel_group));
359
360 for (i = 0; i < ARRAY_SIZE(devc->digital_channels); i++) {
361 if (!(channel_name = g_strdup_printf("D%d", i)))
362 return NULL;
363 ch = sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_name);
364 g_free(channel_name);
365 devc->digital_group->channels = g_slist_append(
366 devc->digital_group->channels, ch);
367 }
368 devc->digital_group->name = g_strdup("LA");
369 sdi->channel_groups = g_slist_append(sdi->channel_groups,
370 devc->digital_group);
371 }
372
373 for (i = 0; i < NUM_TIMEBASE; i++) {
374 if (!memcmp(&devc->model->min_timebase, &timebases[i], sizeof(uint64_t[2])))
375 devc->timebases = &timebases[i];
376 if (!memcmp(&devc->model->series->max_timebase, &timebases[i], sizeof(uint64_t[2])))
377 devc->num_timebases = &timebases[i] - devc->timebases + 1;
378 }
379
380 for (i = 0; i < NUM_VDIV; i++)
381 if (!memcmp(&devc->model->series->min_vdiv, &vdivs[i], sizeof(uint64_t[2]))) {
382 devc->vdivs = &vdivs[i];
383 devc->num_vdivs = NUM_VDIV - i;
384 }
385
386 if (!(devc->buffer = g_try_malloc(ACQ_BUFFER_SIZE)))
387 return NULL;
388 if (!(devc->data = g_try_malloc(ACQ_BUFFER_SIZE * sizeof(float))))
389 return NULL;
390
391 devc->data_source = DATA_SOURCE_LIVE;
392
393 sdi->priv = devc;
394
395 return sdi;
396}
397
398static GSList *scan(GSList *options)
399{
400 return sr_scpi_scan(di->priv, options, probe_device);
401}
402
403static GSList *dev_list(void)
404{
405 return ((struct drv_context *)(di->priv))->instances;
406}
407
408static int dev_open(struct sr_dev_inst *sdi)
409{
410 int ret;
411 struct sr_scpi_dev_inst *scpi = sdi->conn;
412
413 if ((ret = sr_scpi_open(scpi)) < 0) {
414 sr_err("Failed to open SCPI device: %s.", sr_strerror(ret));
415 return SR_ERR;
416 }
417
418 if ((ret = rigol_ds_get_dev_cfg(sdi)) < 0) {
419 sr_err("Failed to get device config: %s.", sr_strerror(ret));
420 return SR_ERR;
421 }
422
423 sdi->status = SR_ST_ACTIVE;
424
425 return SR_OK;
426}
427
428static int dev_close(struct sr_dev_inst *sdi)
429{
430 struct sr_scpi_dev_inst *scpi;
431 struct dev_context *devc;
432
433 if (sdi->status != SR_ST_ACTIVE)
434 return SR_ERR_DEV_CLOSED;
435
436 scpi = sdi->conn;
437 devc = sdi->priv;
438
439 if (devc->model->series->protocol == PROTOCOL_V2)
440 rigol_ds_config_set(sdi, ":KEY:LOCK DISABLE");
441
442 if (scpi) {
443 if (sr_scpi_close(scpi) < 0)
444 return SR_ERR;
445 sdi->status = SR_ST_INACTIVE;
446 }
447
448 return SR_OK;
449}
450
451static int cleanup(void)
452{
453 return dev_clear();
454}
455
456static int analog_frame_size(const struct sr_dev_inst *sdi)
457{
458 struct dev_context *devc = sdi->priv;
459 struct sr_channel *ch;
460 int analog_channels = 0;
461 GSList *l;
462
463 for (l = sdi->channels; l; l = l->next) {
464 ch = l->data;
465 if (ch->type == SR_CHANNEL_ANALOG && ch->enabled)
466 analog_channels++;
467 }
468
469 if (analog_channels == 0)
470 return 0;
471
472 switch (devc->data_source) {
473 case DATA_SOURCE_LIVE:
474 return devc->model->series->live_samples;
475 case DATA_SOURCE_MEMORY:
476 return devc->model->series->buffer_samples / analog_channels;
477 default:
478 return 0;
479 }
480}
481
482static int digital_frame_size(const struct sr_dev_inst *sdi)
483{
484 struct dev_context *devc = sdi->priv;
485
486 switch (devc->data_source) {
487 case DATA_SOURCE_LIVE:
488 return devc->model->series->live_samples * 2;
489 case DATA_SOURCE_MEMORY:
490 return devc->model->series->buffer_samples * 2;
491 default:
492 return 0;
493 }
494}
495
496static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
497 const struct sr_channel_group *cg)
498{
499 struct dev_context *devc;
500 struct sr_channel *ch;
501 const char *tmp_str;
502 uint64_t samplerate;
503 int analog_channel = -1;
504 float smallest_diff = INFINITY;
505 int idx = -1;
506 unsigned i;
507
508 if (!sdi || !(devc = sdi->priv))
509 return SR_ERR_ARG;
510
511 /* If a channel group is specified, it must be a valid one. */
512 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
513 sr_err("Invalid channel group specified.");
514 return SR_ERR;
515 }
516
517 if (cg) {
518 ch = g_slist_nth_data(cg->channels, 0);
519 if (!ch)
520 return SR_ERR;
521 if (ch->type == SR_CHANNEL_ANALOG) {
522 if (ch->name[2] < '1' || ch->name[2] > '4')
523 return SR_ERR;
524 analog_channel = ch->name[2] - '1';
525 }
526 }
527
528 switch (key) {
529 case SR_CONF_NUM_HDIV:
530 *data = g_variant_new_int32(devc->model->series->num_horizontal_divs);
531 break;
532 case SR_CONF_NUM_VDIV:
533 *data = g_variant_new_int32(devc->num_vdivs);
534 break;
535 case SR_CONF_DATA_SOURCE:
536 if (devc->data_source == DATA_SOURCE_LIVE)
537 *data = g_variant_new_string("Live");
538 else if (devc->data_source == DATA_SOURCE_MEMORY)
539 *data = g_variant_new_string("Memory");
540 else
541 *data = g_variant_new_string("Segmented");
542 break;
543 case SR_CONF_SAMPLERATE:
544 if (devc->data_source == DATA_SOURCE_LIVE) {
545 samplerate = analog_frame_size(sdi) /
546 (devc->timebase * devc->model->series->num_horizontal_divs);
547 *data = g_variant_new_uint64(samplerate);
548 } else {
549 sr_dbg("Unknown data source: %d.", devc->data_source);
550 return SR_ERR_NA;
551 }
552 break;
553 case SR_CONF_TRIGGER_SOURCE:
554 if (!strcmp(devc->trigger_source, "ACL"))
555 tmp_str = "AC Line";
556 else if (!strcmp(devc->trigger_source, "CHAN1"))
557 tmp_str = "CH1";
558 else if (!strcmp(devc->trigger_source, "CHAN2"))
559 tmp_str = "CH2";
560 else if (!strcmp(devc->trigger_source, "CHAN3"))
561 tmp_str = "CH3";
562 else if (!strcmp(devc->trigger_source, "CHAN4"))
563 tmp_str = "CH4";
564 else
565 tmp_str = devc->trigger_source;
566 *data = g_variant_new_string(tmp_str);
567 break;
568 case SR_CONF_TRIGGER_SLOPE:
569 if (!strncmp(devc->trigger_slope, "POS", 3)) {
570 tmp_str = "r";
571 } else if (!strncmp(devc->trigger_slope, "NEG", 3)) {
572 tmp_str = "f";
573 } else {
574 sr_dbg("Unknown trigger slope: '%s'.", devc->trigger_slope);
575 return SR_ERR_NA;
576 }
577 *data = g_variant_new_string(tmp_str);
578 break;
579 case SR_CONF_TIMEBASE:
580 for (i = 0; i < devc->num_timebases; i++) {
581 float tb = (float)devc->timebases[i][0] / devc->timebases[i][1];
582 float diff = fabs(devc->timebase - tb);
583 if (diff < smallest_diff) {
584 smallest_diff = diff;
585 idx = i;
586 }
587 }
588 if (idx < 0) {
589 sr_dbg("Negative timebase index: %d.", idx);
590 return SR_ERR_NA;
591 }
592 *data = g_variant_new("(tt)", devc->timebases[idx][0],
593 devc->timebases[idx][1]);
594 break;
595 case SR_CONF_VDIV:
596 if (analog_channel < 0) {
597 sr_dbg("Negative analog channel: %d.", analog_channel);
598 return SR_ERR_NA;
599 }
600 for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
601 float vdiv = (float)vdivs[i][0] / vdivs[i][1];
602 float diff = fabs(devc->vdiv[analog_channel] - vdiv);
603 if (diff < smallest_diff) {
604 smallest_diff = diff;
605 idx = i;
606 }
607 }
608 if (idx < 0) {
609 sr_dbg("Negative vdiv index: %d.", idx);
610 return SR_ERR_NA;
611 }
612 *data = g_variant_new("(tt)", vdivs[idx][0], vdivs[idx][1]);
613 break;
614 case SR_CONF_COUPLING:
615 if (analog_channel < 0) {
616 sr_dbg("Negative analog channel: %d.", analog_channel);
617 return SR_ERR_NA;
618 }
619 *data = g_variant_new_string(devc->coupling[analog_channel]);
620 break;
621 default:
622 sr_dbg("Tried to get unknown config key: %d.", key);
623 return SR_ERR_NA;
624 }
625
626 return SR_OK;
627}
628
629static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
630 const struct sr_channel_group *cg)
631{
632 struct dev_context *devc;
633 uint64_t p, q;
634 double t_dbl;
635 unsigned int i, j;
636 int ret;
637 const char *tmp_str;
638 char buffer[16];
639
640 if (!(devc = sdi->priv))
641 return SR_ERR_ARG;
642
643 if (sdi->status != SR_ST_ACTIVE)
644 return SR_ERR_DEV_CLOSED;
645
646 /* If a channel group is specified, it must be a valid one. */
647 if (cg && !g_slist_find(sdi->channel_groups, cg)) {
648 sr_err("Invalid channel group specified.");
649 return SR_ERR;
650 }
651
652 ret = SR_OK;
653 switch (key) {
654 case SR_CONF_LIMIT_FRAMES:
655 devc->limit_frames = g_variant_get_uint64(data);
656 break;
657 case SR_CONF_TRIGGER_SLOPE:
658 tmp_str = g_variant_get_string(data, NULL);
659
660 if (!tmp_str || !(tmp_str[0] == 'f' || tmp_str[0] == 'r')) {
661 sr_err("Unknown trigger slope: '%s'.",
662 (tmp_str) ? tmp_str : "NULL");
663 return SR_ERR_ARG;
664 }
665
666 g_free(devc->trigger_slope);
667 devc->trigger_slope = g_strdup((tmp_str[0] == 'r') ? "POS" : "NEG");
668 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SLOP %s", devc->trigger_slope);
669 break;
670 case SR_CONF_HORIZ_TRIGGERPOS:
671 t_dbl = g_variant_get_double(data);
672 if (t_dbl < 0.0 || t_dbl > 1.0) {
673 sr_err("Invalid horiz. trigger position: %g.", t_dbl);
674 return SR_ERR;
675 }
676 devc->horiz_triggerpos = t_dbl;
677 /* We have the trigger offset as a percentage of the frame, but
678 * need to express this in seconds. */
679 t_dbl = -(devc->horiz_triggerpos - 0.5) * devc->timebase * devc->num_timebases;
680 g_ascii_formatd(buffer, sizeof(buffer), "%.6f", t_dbl);
681 ret = rigol_ds_config_set(sdi, ":TIM:OFFS %s", buffer);
682 break;
683 case SR_CONF_TIMEBASE:
684 g_variant_get(data, "(tt)", &p, &q);
685 for (i = 0; i < devc->num_timebases; i++) {
686 if (devc->timebases[i][0] == p && devc->timebases[i][1] == q) {
687 devc->timebase = (float)p / q;
688 g_ascii_formatd(buffer, sizeof(buffer), "%.9f",
689 devc->timebase);
690 ret = rigol_ds_config_set(sdi, ":TIM:SCAL %s", buffer);
691 break;
692 }
693 }
694 if (i == devc->num_timebases) {
695 sr_err("Invalid timebase index: %d.", i);
696 ret = SR_ERR_ARG;
697 }
698 break;
699 case SR_CONF_TRIGGER_SOURCE:
700 tmp_str = g_variant_get_string(data, NULL);
701 for (i = 0; i < ARRAY_SIZE(trigger_sources); i++) {
702 if (!strcmp(trigger_sources[i], tmp_str)) {
703 g_free(devc->trigger_source);
704 devc->trigger_source = g_strdup(trigger_sources[i]);
705 if (!strcmp(devc->trigger_source, "AC Line"))
706 tmp_str = "ACL";
707 else if (!strcmp(devc->trigger_source, "CH1"))
708 tmp_str = "CHAN1";
709 else if (!strcmp(devc->trigger_source, "CH2"))
710 tmp_str = "CHAN2";
711 else if (!strcmp(devc->trigger_source, "CH3"))
712 tmp_str = "CHAN3";
713 else if (!strcmp(devc->trigger_source, "CH4"))
714 tmp_str = "CHAN4";
715 else
716 tmp_str = (char *)devc->trigger_source;
717 ret = rigol_ds_config_set(sdi, ":TRIG:EDGE:SOUR %s", tmp_str);
718 break;
719 }
720 }
721 if (i == ARRAY_SIZE(trigger_sources)) {
722 sr_err("Invalid trigger source index: %d.", i);
723 ret = SR_ERR_ARG;
724 }
725 break;
726 case SR_CONF_VDIV:
727 if (!cg) {
728 sr_err("No channel group specified.");
729 return SR_ERR_CHANNEL_GROUP;
730 }
731 g_variant_get(data, "(tt)", &p, &q);
732 for (i = 0; i < devc->model->analog_channels; i++) {
733 if (cg == devc->analog_groups[i]) {
734 for (j = 0; j < ARRAY_SIZE(vdivs); j++) {
735 if (vdivs[j][0] != p || vdivs[j][1] != q)
736 continue;
737 devc->vdiv[i] = (float)p / q;
738 g_ascii_formatd(buffer, sizeof(buffer), "%.3f",
739 devc->vdiv[i]);
740 return rigol_ds_config_set(sdi, ":CHAN%d:SCAL %s", i + 1,
741 buffer);
742 }
743 sr_err("Invalid vdiv index: %d.", j);
744 return SR_ERR_ARG;
745 }
746 }
747 sr_dbg("Didn't set vdiv, unknown channel(group).");
748 return SR_ERR_NA;
749 case SR_CONF_COUPLING:
750 if (!cg) {
751 sr_err("No channel group specified.");
752 return SR_ERR_CHANNEL_GROUP;
753 }
754 tmp_str = g_variant_get_string(data, NULL);
755 for (i = 0; i < devc->model->analog_channels; i++) {
756 if (cg == devc->analog_groups[i]) {
757 for (j = 0; j < ARRAY_SIZE(coupling); j++) {
758 if (!strcmp(tmp_str, coupling[j])) {
759 g_free(devc->coupling[i]);
760 devc->coupling[i] = g_strdup(coupling[j]);
761 return rigol_ds_config_set(sdi, ":CHAN%d:COUP %s", i + 1,
762 devc->coupling[i]);
763 }
764 }
765 sr_err("Invalid coupling index: %d.", j);
766 return SR_ERR_ARG;
767 }
768 }
769 sr_dbg("Didn't set coupling, unknown channel(group).");
770 return SR_ERR_NA;
771 case SR_CONF_DATA_SOURCE:
772 tmp_str = g_variant_get_string(data, NULL);
773 if (!strcmp(tmp_str, "Live"))
774 devc->data_source = DATA_SOURCE_LIVE;
775 else if (devc->model->series->protocol >= PROTOCOL_V2
776 && !strcmp(tmp_str, "Memory"))
777 devc->data_source = DATA_SOURCE_MEMORY;
778 else if (devc->model->series->protocol >= PROTOCOL_V3
779 && !strcmp(tmp_str, "Segmented"))
780 devc->data_source = DATA_SOURCE_SEGMENTED;
781 else {
782 sr_err("Unknown data source: '%s'.", tmp_str);
783 return SR_ERR;
784 }
785 break;
786 default:
787 sr_dbg("Tried to set unknown config key: %d.", key);
788 ret = SR_ERR_NA;
789 break;
790 }
791
792 return ret;
793}
794
795static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
796 const struct sr_channel_group *cg)
797{
798 GVariant *tuple, *rational[2];
799 GVariantBuilder gvb;
800 unsigned int i;
801 struct dev_context *devc = NULL;
802
803 if (sdi)
804 devc = sdi->priv;
805
806 if (key == SR_CONF_SCAN_OPTIONS) {
807 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
808 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
809 return SR_OK;
810 } else if (key == SR_CONF_DEVICE_OPTIONS && cg == NULL) {
811 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
812 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
813 return SR_OK;
814 }
815
816 /* Every other option requires a valid device instance. */
817 if (!sdi || !(devc = sdi->priv))
818 return SR_ERR_ARG;
819
820 /* If a channel group is specified, it must be a valid one. */
821 if (cg) {
822 for (i = 0; i < devc->model->analog_channels; i++)
823 if (cg == devc->analog_groups[i])
824 break;
825 if (i >= devc->model->analog_channels) {
826 sr_err("Invalid channel group specified.");
827 return SR_ERR;
828 }
829 }
830
831 switch (key) {
832 case SR_CONF_DEVICE_OPTIONS:
833 if (!cg) {
834 sr_err("No channel group specified.");
835 return SR_ERR_CHANNEL_GROUP;
836 }
837 if (cg == devc->digital_group) {
838 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
839 NULL, 0, sizeof(uint32_t));
840 return SR_OK;
841 } else {
842 for (i = 0; i < devc->model->analog_channels; i++) {
843 if (cg == devc->analog_groups[i]) {
844 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
845 analog_devopts, ARRAY_SIZE(analog_devopts), sizeof(uint32_t));
846 return SR_OK;
847 }
848 }
849 return SR_ERR_NA;
850 }
851 break;
852 case SR_CONF_COUPLING:
853 if (!cg) {
854 sr_err("No channel group specified.");
855 return SR_ERR_CHANNEL_GROUP;
856 }
857 *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
858 break;
859 case SR_CONF_VDIV:
860 if (!devc)
861 /* Can't know this until we have the exact model. */
862 return SR_ERR_ARG;
863 if (!cg) {
864 sr_err("No channel group specified.");
865 return SR_ERR_CHANNEL_GROUP;
866 }
867 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
868 for (i = 0; i < devc->num_vdivs; i++) {
869 rational[0] = g_variant_new_uint64(devc->vdivs[i][0]);
870 rational[1] = g_variant_new_uint64(devc->vdivs[i][1]);
871 tuple = g_variant_new_tuple(rational, 2);
872 g_variant_builder_add_value(&gvb, tuple);
873 }
874 *data = g_variant_builder_end(&gvb);
875 break;
876 case SR_CONF_TIMEBASE:
877 if (!devc)
878 /* Can't know this until we have the exact model. */
879 return SR_ERR_ARG;
880 if (devc->num_timebases <= 0)
881 return SR_ERR_NA;
882 g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
883 for (i = 0; i < devc->num_timebases; i++) {
884 rational[0] = g_variant_new_uint64(devc->timebases[i][0]);
885 rational[1] = g_variant_new_uint64(devc->timebases[i][1]);
886 tuple = g_variant_new_tuple(rational, 2);
887 g_variant_builder_add_value(&gvb, tuple);
888 }
889 *data = g_variant_builder_end(&gvb);
890 break;
891 case SR_CONF_TRIGGER_SOURCE:
892 if (!devc)
893 /* Can't know this until we have the exact model. */
894 return SR_ERR_ARG;
895 *data = g_variant_new_strv(trigger_sources,
896 devc->model->has_digital ? ARRAY_SIZE(trigger_sources) : 4);
897 break;
898 case SR_CONF_TRIGGER_SLOPE:
899 *data = g_variant_new_strv(trigger_slopes, ARRAY_SIZE(trigger_slopes));
900 break;
901 case SR_CONF_DATA_SOURCE:
902 if (!devc)
903 /* Can't know this until we have the exact model. */
904 return SR_ERR_ARG;
905 switch (devc->model->series->protocol) {
906 case PROTOCOL_V1:
907 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 2);
908 break;
909 case PROTOCOL_V2:
910 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources) - 1);
911 break;
912 default:
913 *data = g_variant_new_strv(data_sources, ARRAY_SIZE(data_sources));
914 break;
915 }
916 break;
917 default:
918 sr_dbg("Tried to list unknown config key: %d.", key);
919 return SR_ERR_NA;
920 }
921
922 return SR_OK;
923}
924
925static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
926{
927 struct sr_scpi_dev_inst *scpi;
928 struct dev_context *devc;
929 struct sr_channel *ch;
930 struct sr_datafeed_packet packet;
931 GSList *l;
932
933 if (sdi->status != SR_ST_ACTIVE)
934 return SR_ERR_DEV_CLOSED;
935
936 scpi = sdi->conn;
937 devc = sdi->priv;
938
939 devc->num_frames = 0;
940
941 for (l = sdi->channels; l; l = l->next) {
942 ch = l->data;
943 sr_dbg("handling channel %s", ch->name);
944 if (ch->type == SR_CHANNEL_ANALOG) {
945 if (ch->enabled)
946 devc->enabled_analog_channels = g_slist_append(
947 devc->enabled_analog_channels, ch);
948 if (ch->enabled != devc->analog_channels[ch->index]) {
949 /* Enabled channel is currently disabled, or vice versa. */
950 if (rigol_ds_config_set(sdi, ":CHAN%d:DISP %s", ch->index + 1,
951 ch->enabled ? "ON" : "OFF") != SR_OK)
952 return SR_ERR;
953 devc->analog_channels[ch->index] = ch->enabled;
954 }
955 } else if (ch->type == SR_CHANNEL_LOGIC) {
956 if (ch->enabled) {
957 devc->enabled_digital_channels = g_slist_append(
958 devc->enabled_digital_channels, ch);
959 /* Turn on LA module if currently off. */
960 if (!devc->la_enabled) {
961 if (rigol_ds_config_set(sdi, ":LA:DISP ON") != SR_OK)
962 return SR_ERR;
963 devc->la_enabled = TRUE;
964 }
965 }
966 if (ch->enabled != devc->digital_channels[ch->index]) {
967 /* Enabled channel is currently disabled, or vice versa. */
968 if (rigol_ds_config_set(sdi, ":DIG%d:TURN %s", ch->index,
969 ch->enabled ? "ON" : "OFF") != SR_OK)
970 return SR_ERR;
971 devc->digital_channels[ch->index] = ch->enabled;
972 }
973 }
974 }
975
976 if (!devc->enabled_analog_channels && !devc->enabled_digital_channels)
977 return SR_ERR;
978
979 /* Turn off LA module if on and no digital channels selected. */
980 if (devc->la_enabled && !devc->enabled_digital_channels)
981 if (rigol_ds_config_set(sdi, ":LA:DISP OFF") != SR_OK)
982 return SR_ERR;
983
984 /* Set memory mode. */
985 if (devc->data_source == DATA_SOURCE_SEGMENTED) {
986 sr_err("Data source 'Segmented' not yet supported");
987 return SR_ERR;
988 }
989
990 devc->analog_frame_size = analog_frame_size(sdi);
991 devc->digital_frame_size = digital_frame_size(sdi);
992
993 switch (devc->model->series->protocol) {
994 case PROTOCOL_V2:
995 if (rigol_ds_config_set(sdi, ":ACQ:MEMD LONG") != SR_OK)
996 return SR_ERR;
997 break;
998 case PROTOCOL_V3:
999 /* Apparently for the DS2000 the memory
1000 * depth can only be set in Running state -
1001 * this matches the behaviour of the UI. */
1002 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1003 return SR_ERR;
1004 if (rigol_ds_config_set(sdi, ":ACQ:MDEP %d",
1005 devc->analog_frame_size) != SR_OK)
1006 return SR_ERR;
1007 if (rigol_ds_config_set(sdi, ":STOP") != SR_OK)
1008 return SR_ERR;
1009 break;
1010 default:
1011 break;
1012 }
1013
1014 if (devc->data_source == DATA_SOURCE_LIVE)
1015 if (rigol_ds_config_set(sdi, ":RUN") != SR_OK)
1016 return SR_ERR;
1017
1018 sr_scpi_source_add(sdi->session, scpi, G_IO_IN, 50,
1019 rigol_ds_receive, (void *)sdi);
1020
1021 /* Send header packet to the session bus. */
1022 std_session_send_df_header(cb_data, LOG_PREFIX);
1023
1024 if (devc->enabled_analog_channels)
1025 devc->channel_entry = devc->enabled_analog_channels;
1026 else
1027 devc->channel_entry = devc->enabled_digital_channels;
1028
1029 if (rigol_ds_capture_start(sdi) != SR_OK)
1030 return SR_ERR;
1031
1032 /* Start of first frame. */
1033 packet.type = SR_DF_FRAME_BEGIN;
1034 sr_session_send(cb_data, &packet);
1035
1036 return SR_OK;
1037}
1038
1039static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
1040{
1041 struct dev_context *devc;
1042 struct sr_scpi_dev_inst *scpi;
1043 struct sr_datafeed_packet packet;
1044
1045 (void)cb_data;
1046
1047 devc = sdi->priv;
1048
1049 if (sdi->status != SR_ST_ACTIVE) {
1050 sr_err("Device inactive, can't stop acquisition.");
1051 return SR_ERR;
1052 }
1053
1054 /* End of last frame. */
1055 packet.type = SR_DF_END;
1056 sr_session_send(sdi, &packet);
1057
1058 g_slist_free(devc->enabled_analog_channels);
1059 g_slist_free(devc->enabled_digital_channels);
1060 devc->enabled_analog_channels = NULL;
1061 devc->enabled_digital_channels = NULL;
1062 scpi = sdi->conn;
1063 sr_scpi_source_remove(sdi->session, scpi);
1064
1065 return SR_OK;
1066}
1067
1068SR_PRIV struct sr_dev_driver rigol_ds_driver_info = {
1069 .name = "rigol-ds",
1070 .longname = "Rigol DS",
1071 .api_version = 1,
1072 .init = init,
1073 .cleanup = cleanup,
1074 .scan = scan,
1075 .dev_list = dev_list,
1076 .dev_clear = dev_clear,
1077 .config_get = config_get,
1078 .config_set = config_set,
1079 .config_list = config_list,
1080 .dev_open = dev_open,
1081 .dev_close = dev_close,
1082 .dev_acquisition_start = dev_acquisition_start,
1083 .dev_acquisition_stop = dev_acquisition_stop,
1084 .priv = NULL,
1085};
Hardware access and backend lib