]> sigrok.org Git - libsigrok.git/blame - src/hardware/zeroplus-logic-cube/api.c
rigol-ds: Fix crash when fetching logic channels
[libsigrok.git] / src / hardware / zeroplus-logic-cube / api.c
CommitLineData
a1bb33af 1/*
50985c20 2 * This file is part of the libsigrok project.
a1bb33af 3 *
c73d2ea4 4 * Copyright (C) 2010-2012 Bert Vermeulen <bert@biot.com>
a1bb33af
UH
5 *
6 * This program is free software: you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation, either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program. If not, see <http://www.gnu.org/licenses/>.
18 */
19
6ec6c43b 20#include <config.h>
6d116114 21#include "protocol.h"
a1bb33af 22
a1bb33af
UH
23#define USB_INTERFACE 0
24#define USB_CONFIGURATION 1
25#define NUM_TRIGGER_STAGES 4
fed16f06 26#define PACKET_SIZE 2048 /* ?? */
a1bb33af 27
0ab0cb94
TY
28//#define ZP_EXPERIMENTAL
29
e495a676
UH
30struct zp_model {
31 uint16_t vid;
32 uint16_t pid;
2c240774 33 const char *model_name;
a1bb33af 34 unsigned int channels;
fed16f06 35 unsigned int sample_depth; /* In Ksamples/channel */
a1bb33af 36 unsigned int max_sampling_freq;
e495a676 37};
a1bb33af 38
fed16f06
UH
39/*
40 * Note -- 16032, 16064 and 16128 *usually* -- but not always -- have the
41 * same 128K sample depth.
42 */
e495a676 43static const struct zp_model zeroplus_models[] = {
9e5670d0 44 {0x0c12, 0x7002, "LAP-16128U", 16, 128, 200},
428edbe1 45 {0x0c12, 0x7009, "LAP-C(16064)", 16, 64, 100},
e495a676 46 {0x0c12, 0x700a, "LAP-C(16128)", 16, 128, 200},
5db0c668
RD
47 {0x0c12, 0x700b, "LAP-C(32128)", 32, 128, 200},
48 {0x0c12, 0x700c, "LAP-C(321000)", 32, 1024, 200},
49 {0x0c12, 0x700d, "LAP-C(322000)", 32, 2048, 200},
e495a676 50 {0x0c12, 0x700e, "LAP-C(16032)", 16, 32, 100},
428edbe1 51 {0x0c12, 0x7016, "LAP-C(162000)", 16, 2048, 200},
6605f1b9 52 {0x0c12, 0x7025, "LAP-C(16128+)", 16, 128, 200},
8e45ba3f 53 {0x0c12, 0x7064, "Logian-16L", 16, 128, 200},
fb1d341d 54 {0x0c12, 0x7100, "AKIP-9101", 16, 256, 200},
9e9dba7b 55 ALL_ZERO
a1bb33af
UH
56};
57
716d6dfc 58static const uint32_t drvopts[] = {
1953564a 59 SR_CONF_LOGIC_ANALYZER,
716d6dfc
YS
60};
61
62static const uint32_t devopts[] = {
5827f61b
BV
63 SR_CONF_LIMIT_SAMPLES | SR_CONF_SET | SR_CONF_LIST,
64 SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
65 SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
66 SR_CONF_CAPTURE_RATIO | SR_CONF_GET | SR_CONF_SET,
67 SR_CONF_VOLTAGE_THRESHOLD | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
a1bb33af
UH
68};
69
28731bab
BV
70static const int32_t trigger_matches[] = {
71 SR_TRIGGER_ZERO,
72 SR_TRIGGER_ONE,
73};
74
d261dbbf 75/*
ba7dd8bb 76 * ZEROPLUS LAP-C (16032) numbers the 16 channels A0-A7 and B0-B7.
d261dbbf
UH
77 * We currently ignore other untested/unsupported devices here.
78 */
ba7dd8bb 79static const char *channel_names[] = {
78693401
UH
80 "A0", "A1", "A2", "A3", "A4", "A5", "A6", "A7",
81 "B0", "B1", "B2", "B3", "B4", "B5", "B6", "B7",
5db0c668
RD
82 "C0", "C1", "C2", "C3", "C4", "C5", "C6", "C7",
83 "D0", "D1", "D2", "D3", "D4", "D5", "D6", "D7",
464d12c7
KS
84};
85
fed16f06
UH
86/*
87 * The hardware supports more samplerates than these, but these are the
88 * options hardcoded into the vendor's Windows GUI.
89 */
a1bb33af 90
8386096f 91static const uint64_t samplerates_100[] = {
17548571
UH
92 SR_HZ(100),
93 SR_HZ(500),
94 SR_KHZ(1),
95 SR_KHZ(5),
96 SR_KHZ(25),
97 SR_KHZ(50),
98 SR_KHZ(100),
99 SR_KHZ(200),
100 SR_KHZ(400),
101 SR_KHZ(800),
102 SR_MHZ(1),
103 SR_MHZ(10),
104 SR_MHZ(25),
105 SR_MHZ(50),
106 SR_MHZ(80),
107 SR_MHZ(100),
17548571
UH
108};
109
8386096f 110const uint64_t samplerates_200[] = {
c9140419
UH
111 SR_HZ(100),
112 SR_HZ(500),
59df0c77
UH
113 SR_KHZ(1),
114 SR_KHZ(5),
115 SR_KHZ(25),
116 SR_KHZ(50),
117 SR_KHZ(100),
118 SR_KHZ(200),
119 SR_KHZ(400),
120 SR_KHZ(800),
121 SR_MHZ(1),
122 SR_MHZ(10),
123 SR_MHZ(25),
124 SR_MHZ(50),
125 SR_MHZ(80),
126 SR_MHZ(100),
127 SR_MHZ(150),
128 SR_MHZ(200),
bf43ea23 129};
a1bb33af 130
3316e149
BV
131SR_PRIV int zp_set_samplerate(struct dev_context *devc, uint64_t samplerate)
132{
133 int i;
134
135 for (i = 0; ARRAY_SIZE(samplerates_200); i++)
136 if (samplerate == samplerates_200[i])
137 break;
138
139 if (i == ARRAY_SIZE(samplerates_200) || samplerate > devc->max_samplerate) {
140 sr_err("Unsupported samplerate: %" PRIu64 "Hz.", samplerate);
141 return SR_ERR_ARG;
142 }
143
144 sr_info("Setting samplerate to %" PRIu64 "Hz.", samplerate);
145
146 if (samplerate >= SR_MHZ(1))
147 analyzer_set_freq(samplerate / SR_MHZ(1), FREQ_SCALE_MHZ);
148 else if (samplerate >= SR_KHZ(1))
149 analyzer_set_freq(samplerate / SR_KHZ(1), FREQ_SCALE_KHZ);
150 else
151 analyzer_set_freq(samplerate, FREQ_SCALE_HZ);
152
153 devc->cur_samplerate = samplerate;
154
155 return SR_OK;
156}
157
4f840ce9 158static GSList *scan(struct sr_dev_driver *di, GSList *options)
a1bb33af 159{
d68e2d1a 160 struct sr_dev_inst *sdi;
310e9e9b
BV
161 struct drv_context *drvc;
162 struct dev_context *devc;
e495a676 163 const struct zp_model *prof;
a1bb33af 164 struct libusb_device_descriptor des;
ee4f9bb1 165 struct libusb_device_handle *hdl;
a1bb33af 166 libusb_device **devlist;
428edbe1 167 GSList *devices;
ee4f9bb1
SA
168 int ret, i, j;
169 char serial_num[64], connection_id[64];
a1bb33af 170
4ca38984 171 (void)options;
64d33dc2 172
41812aca 173 drvc = di->context;
4b97c74e 174
4ca38984
BV
175 devices = NULL;
176
8fdecced 177 /* Find all ZEROPLUS analyzers and add them to device list. */
d4abb463 178 libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist); /* TODO: Errors. */
fed16f06
UH
179
180 for (i = 0; devlist[i]; i++) {
2a8f2d41 181 libusb_get_device_descriptor(devlist[i], &des);
a1bb33af 182
ee4f9bb1
SA
183 if ((ret = libusb_open(devlist[i], &hdl)) < 0)
184 continue;
185
186 if (des.iSerialNumber == 0) {
187 serial_num[0] = '\0';
188 } else if ((ret = libusb_get_string_descriptor_ascii(hdl,
189 des.iSerialNumber, (unsigned char *) serial_num,
190 sizeof(serial_num))) < 0) {
191 sr_warn("Failed to get serial number string descriptor: %s.",
192 libusb_error_name(ret));
193 continue;
194 }
195
196 libusb_close(hdl);
197
198 usb_get_port_path(devlist[i], connection_id, sizeof(connection_id));
199
428edbe1
BV
200 prof = NULL;
201 for (j = 0; j < zeroplus_models[j].vid; j++) {
202 if (des.idVendor == zeroplus_models[j].vid &&
203 des.idProduct == zeroplus_models[j].pid) {
204 prof = &zeroplus_models[j];
bf43ea23 205 }
a1bb33af 206 }
ca314e06 207
428edbe1
BV
208 if (!prof)
209 continue;
e495a676 210 sr_info("Found ZEROPLUS %s.", prof->model_name);
428edbe1 211
aac29cc1 212 sdi = g_malloc0(sizeof(struct sr_dev_inst));
0af636be 213 sdi->status = SR_ST_INACTIVE;
b15ff1c9 214 sdi->vendor = g_strdup("ZEROPLUS");
0af636be 215 sdi->model = g_strdup(prof->model_name);
ee4f9bb1
SA
216 sdi->serial_num = g_strdup(serial_num);
217 sdi->connection_id = g_strdup(connection_id);
428edbe1 218
f57d8ffe 219 devc = g_malloc0(sizeof(struct dev_context));
310e9e9b 220 sdi->priv = devc;
17548571 221 devc->prof = prof;
310e9e9b 222 devc->num_channels = prof->channels;
0ab0cb94 223#ifdef ZP_EXPERIMENTAL
e93fb98b 224 devc->max_sample_depth = 128 * 1024;
0ab0cb94
TY
225 devc->max_samplerate = 200;
226#else
e93fb98b 227 devc->max_sample_depth = prof->sample_depth * 1024;
0ab0cb94
TY
228 devc->max_samplerate = prof->max_sampling_freq;
229#endif
230 devc->max_samplerate *= SR_MHZ(1);
231 devc->memory_size = MEMORY_SIZE_8K;
310e9e9b 232 // memset(devc->trigger_buffer, 0, NUM_TRIGGER_STAGES);
428edbe1 233
5e23fcab
ML
234 for (j = 0; j < devc->num_channels; j++)
235 sr_channel_new(sdi, j, SR_CHANNEL_LOGIC, TRUE,
c368e6f3 236 channel_names[j]);
428edbe1
BV
237
238 devices = g_slist_append(devices, sdi);
8111446a 239 sdi->inst_type = SR_INST_USB;
609bfd75 240 sdi->conn = sr_usb_dev_inst_new(
428edbe1
BV
241 libusb_get_bus_number(devlist[i]),
242 libusb_get_device_address(devlist[i]), NULL);
a1bb33af
UH
243 }
244 libusb_free_device_list(devlist, 1);
245
15a5bfe4 246 return std_scan_complete(di, devices);
a1bb33af
UH
247}
248
6078d2c9 249static int dev_open(struct sr_dev_inst *sdi)
a1bb33af 250{
4f840ce9 251 struct sr_dev_driver *di = sdi->driver;
310e9e9b 252 struct dev_context *devc;
e495a676 253 struct drv_context *drvc;
609bfd75 254 struct sr_usb_dev_inst *usb;
87629577 255 int ret;
a1bb33af 256
41812aca 257 drvc = di->context;
609bfd75 258 usb = sdi->conn;
61c90858 259 devc = sdi->priv;
bf43ea23 260
87629577
LPC
261 ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb);
262 if (ret != SR_OK)
263 return ret;
428edbe1 264
609bfd75 265 ret = libusb_set_configuration(usb->devhdl, USB_CONFIGURATION);
ebc34738 266 if (ret < 0) {
6d116114 267 sr_err("Unable to set USB configuration %d: %s.",
d4928d71 268 USB_CONFIGURATION, libusb_error_name(ret));
185ae2c5
UH
269 return SR_ERR;
270 }
271
609bfd75 272 ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE);
ebc34738 273 if (ret != 0) {
6d116114 274 sr_err("Unable to claim interface: %s.",
d4928d71 275 libusb_error_name(ret));
e46b8fb1 276 return SR_ERR;
a1bb33af 277 }
185ae2c5 278
e495a676 279 /* Set default configuration after power on. */
609bfd75
BV
280 if (analyzer_read_status(usb->devhdl) == 0)
281 analyzer_configure(usb->devhdl);
0ab0cb94 282
609bfd75
BV
283 analyzer_reset(usb->devhdl);
284 analyzer_initialize(usb->devhdl);
a1bb33af 285
0ab0cb94 286 //analyzer_set_memory_size(MEMORY_SIZE_512K);
fed16f06 287 // analyzer_set_freq(g_freq, g_freq_scale);
a1bb33af 288 analyzer_set_trigger_count(1);
408e7199
UH
289 // analyzer_set_ramsize_trigger_address((((100 - g_pre_trigger)
290 // * get_memory_size(g_memory_size)) / 100) >> 2);
a1bb33af 291
fed16f06
UH
292#if 0
293 if (g_double_mode == 1)
a1bb33af
UH
294 analyzer_set_compression(COMPRESSION_DOUBLE);
295 else if (g_compression == 1)
296 analyzer_set_compression(COMPRESSION_ENABLE);
fed16f06
UH
297 else
298#endif
299 analyzer_set_compression(COMPRESSION_NONE);
a1bb33af 300
310e9e9b 301 if (devc->cur_samplerate == 0) {
0ab0cb94
TY
302 /* Samplerate hasn't been set. Default to 1MHz. */
303 analyzer_set_freq(1, FREQ_SCALE_MHZ);
304 devc->cur_samplerate = SR_MHZ(1);
a1bb33af
UH
305 }
306
7142d6b9
RD
307 if (devc->cur_threshold == 0)
308 set_voltage_threshold(devc, 1.5);
309
e46b8fb1 310 return SR_OK;
a1bb33af
UH
311}
312
6078d2c9 313static int dev_close(struct sr_dev_inst *sdi)
a1bb33af 314{
609bfd75 315 struct sr_usb_dev_inst *usb;
a1bb33af 316
609bfd75 317 usb = sdi->conn;
697785d1 318
609bfd75 319 if (!usb->devhdl)
f1ba6b4b 320 return SR_ERR_BUG;
25a0f108 321
ee4f9bb1
SA
322 sr_info("Closing device on %d.%d (logical) / %s (physical) interface %d.",
323 usb->bus, usb->address, sdi->connection_id, USB_INTERFACE);
609bfd75
BV
324 libusb_release_interface(usb->devhdl, USB_INTERFACE);
325 libusb_reset_device(usb->devhdl);
326 libusb_close(usb->devhdl);
327 usb->devhdl = NULL;
697785d1
UH
328
329 return SR_OK;
a1bb33af
UH
330}
331
dd7a72ea
UH
332static int config_get(uint32_t key, GVariant **data,
333 const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
a1bb33af 334{
310e9e9b 335 struct dev_context *devc;
a1bb33af 336
53b4680f 337 (void)cg;
8f996b89 338
dcd438ee
UH
339 if (!sdi)
340 return SR_ERR_ARG;
341
342 devc = sdi->priv;
343
584560f1 344 switch (key) {
123e1313 345 case SR_CONF_SAMPLERATE:
dcd438ee 346 *data = g_variant_new_uint64(devc->cur_samplerate);
bf43ea23 347 break;
05f853b5 348 case SR_CONF_CAPTURE_RATIO:
dcd438ee 349 *data = g_variant_new_uint64(devc->capture_ratio);
05f853b5 350 break;
7142d6b9 351 case SR_CONF_VOLTAGE_THRESHOLD:
43995cda 352 *data = std_gvar_tuple_double(devc->cur_threshold, devc->cur_threshold);
67055d4c 353 break;
bf43ea23 354 default:
bd6fbf62 355 return SR_ERR_NA;
a1bb33af
UH
356 }
357
626409ab 358 return SR_OK;
a1bb33af
UH
359}
360
dd7a72ea
UH
361static int config_set(uint32_t key, GVariant *data,
362 const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
a1bb33af 363{
310e9e9b 364 struct dev_context *devc;
7142d6b9 365 gdouble low, high;
a1bb33af 366
53b4680f 367 (void)cg;
8f996b89 368
b0baddef 369 devc = sdi->priv;
a1bb33af 370
584560f1 371 switch (key) {
1953564a 372 case SR_CONF_SAMPLERATE:
8386096f 373 return zp_set_samplerate(devc, g_variant_get_uint64(data));
1953564a 374 case SR_CONF_LIMIT_SAMPLES:
8386096f 375 return set_limit_samples(devc, g_variant_get_uint64(data));
1953564a 376 case SR_CONF_CAPTURE_RATIO:
efad7ccc
UH
377 devc->capture_ratio = g_variant_get_uint64(data);
378 break;
7142d6b9
RD
379 case SR_CONF_VOLTAGE_THRESHOLD:
380 g_variant_get(data, "(dd)", &low, &high);
381 return set_voltage_threshold(devc, (low + high) / 2.0);
fed16f06 382 default:
bd6fbf62 383 return SR_ERR_NA;
a1bb33af 384 }
e495a676
UH
385
386 return SR_OK;
a1bb33af
UH
387}
388
dd7a72ea
UH
389static int config_list(uint32_t key, GVariant **data,
390 const struct sr_dev_inst *sdi, const struct sr_channel_group *cg)
a1c743fc 391{
17548571 392 struct dev_context *devc;
a1c743fc
BV
393
394 switch (key) {
9a6517d1 395 case SR_CONF_DEVICE_OPTIONS:
e66d1892 396 return STD_CONFIG_LIST(key, data, sdi, cg, NULL, drvopts, devopts);
a1c743fc 397 case SR_CONF_SAMPLERATE:
17548571 398 devc = sdi->priv;
463160cb 399 if (devc->prof->max_sampling_freq == 100)
53012da6 400 *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates_100));
463160cb 401 else if (devc->prof->max_sampling_freq == 200)
53012da6 402 *data = std_gvar_samplerates(ARRAY_AND_SIZE(samplerates_200));
463160cb 403 else {
17548571
UH
404 sr_err("Internal error: Unknown max. samplerate: %d.",
405 devc->prof->max_sampling_freq);
406 return SR_ERR_ARG;
407 }
a1c743fc 408 break;
28731bab 409 case SR_CONF_TRIGGER_MATCH:
53012da6 410 *data = std_gvar_array_i32(ARRAY_AND_SIZE(trigger_matches));
c50277a6 411 break;
7142d6b9 412 case SR_CONF_VOLTAGE_THRESHOLD:
7bc3cfe6 413 *data = std_gvar_min_max_step_thresholds(-6.0, 6.0, 0.1);
7142d6b9 414 break;
f0de2dd0
BV
415 case SR_CONF_LIMIT_SAMPLES:
416 if (!sdi)
417 return SR_ERR_ARG;
418 devc = sdi->priv;
a162eeb2 419 *data = std_gvar_tuple_u64(0, devc->max_sample_depth);
f0de2dd0 420 break;
a1c743fc 421 default:
bd6fbf62 422 return SR_ERR_NA;
a1c743fc
BV
423 }
424
425 return SR_OK;
426}
427
695dc859 428static int dev_acquisition_start(const struct sr_dev_inst *sdi)
a1bb33af 429{
609bfd75
BV
430 struct dev_context *devc;
431 struct sr_usb_dev_inst *usb;
b9c735a2 432 struct sr_datafeed_packet packet;
9c939c51 433 struct sr_datafeed_logic logic;
42ceb777 434 unsigned int samples_read;
a1bb33af 435 int res;
e495a676 436 unsigned int packet_num, n;
a1bb33af 437 unsigned char *buf;
42ceb777
RD
438 unsigned int status;
439 unsigned int stop_address;
440 unsigned int now_address;
441 unsigned int trigger_address;
442 unsigned int trigger_offset;
443 unsigned int triggerbar;
444 unsigned int ramsize_trigger;
445 unsigned int memory_size;
446 unsigned int valid_samples;
447 unsigned int discard;
448 int trigger_now;
a1bb33af 449
208c1d35 450 devc = sdi->priv;
a1bb33af 451
28731bab
BV
452 if (analyzer_add_triggers(sdi) != SR_OK) {
453 sr_err("Failed to configure triggers.");
014359e3
BV
454 return SR_ERR;
455 }
456
609bfd75
BV
457 usb = sdi->conn;
458
0ab0cb94
TY
459 set_triggerbar(devc);
460
e495a676 461 /* Push configured settings to device. */
609bfd75 462 analyzer_configure(usb->devhdl);
a143e4e5 463
609bfd75 464 analyzer_start(usb->devhdl);
6d116114 465 sr_info("Waiting for data.");
609bfd75 466 analyzer_wait_data(usb->devhdl);
a1bb33af 467
42ceb777
RD
468 status = analyzer_read_status(usb->devhdl);
469 stop_address = analyzer_get_stop_address(usb->devhdl);
470 now_address = analyzer_get_now_address(usb->devhdl);
471 trigger_address = analyzer_get_trigger_address(usb->devhdl);
472
473 triggerbar = analyzer_get_triggerbar_address();
474 ramsize_trigger = analyzer_get_ramsize_trigger_address();
475
476 n = get_memory_size(devc->memory_size);
477 memory_size = n / 4;
478
479 sr_info("Status = 0x%x.", status);
480 sr_info("Stop address = 0x%x.", stop_address);
481 sr_info("Now address = 0x%x.", now_address);
482 sr_info("Trigger address = 0x%x.", trigger_address);
483 sr_info("Triggerbar address = 0x%x.", triggerbar);
484 sr_info("Ramsize trigger = 0x%x.", ramsize_trigger);
485 sr_info("Memory size = 0x%x.", memory_size);
a1bb33af 486
bee2b016 487 std_session_send_df_header(sdi);
f366e86c 488
42ceb777
RD
489 /* Check for empty capture */
490 if ((status & STATUS_READY) && !stop_address) {
bee2b016 491 std_session_send_df_end(sdi);
42ceb777
RD
492 return SR_OK;
493 }
494
a95f142e 495 buf = g_malloc(PACKET_SIZE);
b53738ba 496
42ceb777
RD
497 /* Check if the trigger is in the samples we are throwing away */
498 trigger_now = now_address == trigger_address ||
499 ((now_address + 1) % memory_size) == trigger_address;
500
501 /*
502 * STATUS_READY doesn't clear until now_address advances past
503 * addr 0, but for our logic, clear it in that case
504 */
505 if (!now_address)
506 status &= ~STATUS_READY;
507
609bfd75 508 analyzer_read_start(usb->devhdl);
42ceb777
RD
509
510 /* Calculate how much data to discard */
511 discard = 0;
512 if (status & STATUS_READY) {
513 /*
514 * We haven't wrapped around, we need to throw away data from
515 * our current position to the end of the buffer.
516 * Additionally, the first two samples captured are always
517 * bogus.
518 */
519 discard += memory_size - now_address + 2;
520 now_address = 2;
521 }
522
523 /* If we have more samples than we need, discard them */
524 valid_samples = (stop_address - now_address) % memory_size;
525 if (valid_samples > ramsize_trigger + triggerbar) {
526 discard += valid_samples - (ramsize_trigger + triggerbar);
527 now_address += valid_samples - (ramsize_trigger + triggerbar);
528 }
529
530 sr_info("Need to discard %d samples.", discard);
531
532 /* Calculate how far in the trigger is */
533 if (trigger_now)
534 trigger_offset = 0;
535 else
536 trigger_offset = (trigger_address - now_address) % memory_size;
537
538 /* Recalculate the number of samples available */
539 valid_samples = (stop_address - now_address) % memory_size;
540
fed16f06 541 /* Send the incoming transfer to the session bus. */
42ceb777 542 samples_read = 0;
0ab0cb94 543 for (packet_num = 0; packet_num < n / PACKET_SIZE; packet_num++) {
42ceb777
RD
544 unsigned int len;
545 unsigned int buf_offset;
546
609bfd75 547 res = analyzer_read_data(usb->devhdl, buf, PACKET_SIZE);
6d116114 548 sr_info("Tried to read %d bytes, actually read %d bytes.",
b08024a8 549 PACKET_SIZE, res);
a1bb33af 550
42ceb777
RD
551 if (discard >= PACKET_SIZE / 4) {
552 discard -= PACKET_SIZE / 4;
553 continue;
554 }
555
556 len = PACKET_SIZE - discard * 4;
557 buf_offset = discard * 4;
558 discard = 0;
559
560 /* Check if we've read all the samples */
561 if (samples_read + len / 4 >= valid_samples)
562 len = (valid_samples - samples_read) * 4;
563 if (!len)
564 break;
565
566 if (samples_read < trigger_offset &&
567 samples_read + len / 4 > trigger_offset) {
568 /* Send out samples remaining before trigger */
569 packet.type = SR_DF_LOGIC;
570 packet.payload = &logic;
571 logic.length = (trigger_offset - samples_read) * 4;
572 logic.unitsize = 4;
573 logic.data = buf + buf_offset;
695dc859 574 sr_session_send(sdi, &packet);
42ceb777
RD
575 len -= logic.length;
576 samples_read += logic.length / 4;
577 buf_offset += logic.length;
578 }
579
580 if (samples_read == trigger_offset) {
581 /* Send out trigger */
582 packet.type = SR_DF_TRIGGER;
583 packet.payload = NULL;
695dc859 584 sr_session_send(sdi, &packet);
42ceb777
RD
585 }
586
587 /* Send out data (or data after trigger) */
5a2326a7 588 packet.type = SR_DF_LOGIC;
9c939c51 589 packet.payload = &logic;
42ceb777 590 logic.length = len;
9c939c51 591 logic.unitsize = 4;
42ceb777 592 logic.data = buf + buf_offset;
695dc859 593 sr_session_send(sdi, &packet);
42ceb777 594 samples_read += len / 4;
a1bb33af 595 }
609bfd75 596 analyzer_read_stop(usb->devhdl);
a1bb33af
UH
597 g_free(buf);
598
bee2b016 599 std_session_send_df_end(sdi);
a1bb33af 600
e46b8fb1 601 return SR_OK;
a1bb33af
UH
602}
603
695dc859 604static int dev_acquisition_stop(struct sr_dev_inst *sdi)
a1bb33af 605{
609bfd75 606 struct sr_usb_dev_inst *usb;
a1bb33af 607
bee2b016 608 std_session_send_df_end(sdi);
a1bb33af 609
609bfd75
BV
610 usb = sdi->conn;
611 analyzer_reset(usb->devhdl);
fed16f06 612 /* TODO: Need to cancel and free any queued up transfers. */
3010f21c
UH
613
614 return SR_OK;
a1bb33af
UH
615}
616
dd5c48a6 617static struct sr_dev_driver zeroplus_logic_cube_driver_info = {
e519ba86 618 .name = "zeroplus-logic-cube",
8fdecced 619 .longname = "ZEROPLUS Logic Cube LAP-C series",
e519ba86 620 .api_version = 1,
c2fdcc25 621 .init = std_init,
700d6b64 622 .cleanup = std_cleanup,
6078d2c9 623 .scan = scan,
c01bf34c 624 .dev_list = std_dev_list,
f778bf02 625 .dev_clear = std_dev_clear,
035a1078
BV
626 .config_get = config_get,
627 .config_set = config_set,
a1c743fc 628 .config_list = config_list,
6078d2c9
UH
629 .dev_open = dev_open,
630 .dev_close = dev_close,
631 .dev_acquisition_start = dev_acquisition_start,
632 .dev_acquisition_stop = dev_acquisition_stop,
41812aca 633 .context = NULL,
a1bb33af 634};
dd5c48a6 635SR_REGISTER_DEV_DRIVER(zeroplus_logic_cube_driver_info);