]> sigrok.org Git - libsigrok.git/blob - hardware/hantek-dso/api.c
sr/drivers: add API calls sr_dev_inst_list() and sr_dev_inst_clear()
[libsigrok.git] / hardware / hantek-dso / api.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
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
20 #include <stdio.h>
21 #include <stdint.h>
22 #include <stdlib.h>
23 #include <sys/types.h>
24 #include <sys/stat.h>
25 #include <fcntl.h>
26 #include <unistd.h>
27 #include <string.h>
28 #include <sys/time.h>
29 #include <inttypes.h>
30 #include <glib.h>
31 #include <libusb.h>
32 #include "libsigrok.h"
33 #include "libsigrok-internal.h"
34 #include "config.h"
35 #include "dso.h"
36
37
38 /* Max time in ms before we want to check on USB events */
39 /* TODO tune this properly */
40 #define TICK    1
41
42 static const int hwcaps[] = {
43         SR_HWCAP_OSCILLOSCOPE,
44         SR_HWCAP_LIMIT_SAMPLES,
45         SR_HWCAP_CONTINUOUS,
46         SR_HWCAP_TIMEBASE,
47         SR_HWCAP_BUFFERSIZE,
48         SR_HWCAP_TRIGGER_SOURCE,
49         SR_HWCAP_TRIGGER_SLOPE,
50         SR_HWCAP_HORIZ_TRIGGERPOS,
51         SR_HWCAP_FILTER,
52         SR_HWCAP_VDIV,
53         SR_HWCAP_COUPLING,
54         0,
55 };
56
57 static const char *probe_names[] = {
58         "CH1",
59         "CH2",
60         NULL,
61 };
62
63 static const struct dso_profile dev_profiles[] = {
64         {       0x04b4, 0x2090, 0x04b5, 0x2090,
65                 "Hantek", "DSO-2090",
66                 FIRMWARE_DIR "/hantek-dso-2xxx.fw" },
67         {       0x04b4, 0x2150, 0x04b5, 0x2150,
68                 "Hantek", "DSO-2150",
69                 FIRMWARE_DIR "/hantek-dso-2xxx.fw" },
70         {       0x04b4, 0x2250, 0x04b5, 0x2250,
71                 "Hantek", "DSO-2250",
72                 FIRMWARE_DIR "/hantek-dso-2xxx.fw" },
73         {       0x04b4, 0x5200, 0x04b5, 0x5200,
74                 "Hantek", "DSO-5200",
75                 FIRMWARE_DIR "/hantek-dso-5xxx.fw" },
76         {       0x04b4, 0x520a, 0x04b5, 0x520a,
77                 "Hantek", "DSO-5200A",
78                 FIRMWARE_DIR "/hantek-dso-5xxx.fw" },
79         { 0, 0, 0, 0, 0, 0, 0 },
80 };
81
82 static const uint64_t buffersizes[] = {
83         10240,
84         32768,
85         /* TODO: 65535 */
86         0,
87 };
88
89 static const struct sr_rational timebases[] = {
90         /* microseconds */
91         { 10, 1000000 },
92         { 20, 1000000 },
93         { 40, 1000000 },
94         { 100, 1000000 },
95         { 200, 1000000 },
96         { 400, 1000000 },
97         /* milliseconds */
98         { 1, 1000 },
99         { 2, 1000 },
100         { 4, 1000 },
101         { 10, 1000 },
102         { 20, 1000 },
103         { 40, 1000 },
104         { 100, 1000 },
105         { 200, 1000 },
106         { 400, 1000 },
107         { 0, 0},
108 };
109
110 static const struct sr_rational vdivs[] = {
111         /* millivolts */
112         { 10, 1000 },
113         { 20, 1000 },
114         { 50, 1000 },
115         { 100, 1000 },
116         { 200, 1000 },
117         { 500, 1000 },
118         /* volts */
119         { 1, 1 },
120         { 2, 1 },
121         { 5, 1 },
122         { 0, 0 },
123 };
124
125 static const char *trigger_sources[] = {
126         "CH1",
127         "CH2",
128         "EXT",
129         /* TODO: forced */
130         NULL,
131 };
132
133 static const char *filter_targets[] = {
134         "CH1",
135         "CH2",
136         /* TODO: "TRIGGER", */
137         NULL,
138 };
139
140 static const char *coupling[] = {
141         "AC",
142         "DC",
143         "GND",
144         NULL,
145 };
146
147 SR_PRIV struct sr_dev_driver hantek_dso_driver_info;
148 static struct sr_dev_driver *hdi = &hantek_dso_driver_info;
149 static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi,
150                 void *cb_data);
151
152 static struct sr_dev_inst *dso_dev_new(int index, const struct dso_profile *prof)
153 {
154         struct sr_dev_inst *sdi;
155         struct sr_probe *probe;
156         struct drv_context *drvc;
157         struct dev_context *devc;
158         int i;
159
160         sdi = sr_dev_inst_new(index, SR_ST_INITIALIZING,
161                 prof->vendor, prof->model, NULL);
162         if (!sdi)
163                 return NULL;
164         sdi->driver = hdi;
165
166         /* Add only the real probes -- EXT isn't a source of data, only
167          * a trigger source internal to the device.
168          */
169         for (i = 0; probe_names[i]; i++) {
170                 if (!(probe = sr_probe_new(i, SR_PROBE_ANALOG, TRUE,
171                                 probe_names[i])))
172                         return NULL;
173                 sdi->probes = g_slist_append(sdi->probes, probe);
174         }
175
176         if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
177                 sr_err("hantek-dso: devc malloc failed");
178                 return NULL;
179         }
180         devc->profile = prof;
181         devc->dev_state = IDLE;
182         devc->timebase = DEFAULT_TIMEBASE;
183         devc->ch1_enabled = TRUE;
184         devc->ch2_enabled = TRUE;
185         devc->voltage_ch1 = DEFAULT_VOLTAGE;
186         devc->voltage_ch2 = DEFAULT_VOLTAGE;
187         devc->coupling_ch1 = DEFAULT_COUPLING;
188         devc->coupling_ch2 = DEFAULT_COUPLING;
189         devc->voffset_ch1 = DEFAULT_VERT_OFFSET;
190         devc->voffset_ch2 = DEFAULT_VERT_OFFSET;
191         devc->voffset_trigger = DEFAULT_VERT_TRIGGERPOS;
192         devc->framesize = DEFAULT_FRAMESIZE;
193         devc->triggerslope = SLOPE_POSITIVE;
194         devc->triggersource = g_strdup(DEFAULT_TRIGGER_SOURCE);
195         devc->triggerposition = DEFAULT_HORIZ_TRIGGERPOS;
196         sdi->priv = devc;
197         drvc = hdi->priv;
198         drvc->instances = g_slist_append(drvc->instances, sdi);
199
200         return sdi;
201 }
202
203 static int configure_probes(const struct sr_dev_inst *sdi)
204 {
205         struct dev_context *devc;
206         const struct sr_probe *probe;
207         const GSList *l;
208
209         devc = sdi->priv;
210
211         devc->ch1_enabled = devc->ch2_enabled = FALSE;
212         for (l = sdi->probes; l; l = l->next) {
213                 probe = (struct sr_probe *)l->data;
214                 if (probe->index == 0)
215                         devc->ch1_enabled = probe->enabled;
216                 else if (probe->index == 1)
217                         devc->ch2_enabled = probe->enabled;
218         }
219
220         return SR_OK;
221 }
222
223 /* Properly close and free all devices. */
224 static int clear_instances(void)
225 {
226         struct sr_dev_inst *sdi;
227         struct drv_context *drvc;
228         struct dev_context *devc;
229         GSList *l;
230
231         drvc = hdi->priv;
232         for (l = drvc->instances; l; l = l->next) {
233                 if (!(sdi = l->data)) {
234                         /* Log error, but continue cleaning up the rest. */
235                         sr_err("hantek-dso: %s: sdi was NULL, continuing", __func__);
236                         continue;
237                 }
238                 if (!(devc = sdi->priv)) {
239                         /* Log error, but continue cleaning up the rest. */
240                         sr_err("hantek-dso: %s: sdi->priv was NULL, continuing", __func__);
241                         continue;
242                 }
243                 dso_close(sdi);
244                 sr_usb_dev_inst_free(devc->usb);
245                 g_free(devc->triggersource);
246
247                 sr_dev_inst_free(sdi);
248         }
249
250         g_slist_free(drvc->instances);
251         drvc->instances = NULL;
252
253         return SR_OK;
254 }
255
256 static int hw_init(void)
257 {
258         struct drv_context *drvc;
259
260         if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
261                 sr_err("hantek-dso: driver context malloc failed.");
262                 return SR_ERR;
263         }
264
265         if (libusb_init(&drvc->usb_context) != 0) {
266                 g_free(drvc);
267                 sr_err("hantek-dso: Failed to initialize USB.");
268                 return SR_ERR;
269         }
270
271         hdi->priv = drvc;
272
273         return SR_OK;
274 }
275
276 static GSList *hw_scan(GSList *options)
277 {
278         struct sr_dev_inst *sdi;
279         const struct dso_profile *prof;
280         struct drv_context *drvc;
281         struct dev_context *devc;
282         GSList *devices;
283         struct libusb_device_descriptor des;
284         libusb_device **devlist;
285         int devcnt, ret, i, j;
286
287         (void)options;
288         devcnt = 0;
289         devices = 0;
290         drvc = hdi->priv;
291         drvc->instances = NULL;
292
293         clear_instances();
294
295         /* Find all Hantek DSO devices and upload firmware to all of them. */
296         libusb_get_device_list(drvc->usb_context, &devlist);
297         for (i = 0; devlist[i]; i++) {
298                 if ((ret = libusb_get_device_descriptor(devlist[i], &des))) {
299                         sr_err("hantek-dso: failed to get device descriptor: %d", ret);
300                         continue;
301                 }
302
303                 prof = NULL;
304                 for (j = 0; dev_profiles[j].orig_vid; j++) {
305                         if (des.idVendor == dev_profiles[j].orig_vid
306                                 && des.idProduct == dev_profiles[j].orig_pid) {
307                                 /* Device matches the pre-firmware profile. */
308                                 prof = &dev_profiles[j];
309                                 sr_dbg("hantek-dso: Found a %s %s.", prof->vendor, prof->model);
310                                 sdi = dso_dev_new(devcnt, prof);
311                                 devices = g_slist_append(devices, sdi);
312                                 devc = sdi->priv;
313                                 if (ezusb_upload_firmware(devlist[i], USB_CONFIGURATION,
314                                                 prof->firmware) == SR_OK)
315                                         /* Remember when the firmware on this device was updated */
316                                         devc->fw_updated = g_get_monotonic_time();
317                                 else
318                                         sr_err("hantek-dso: firmware upload failed for "
319                                                "device %d", devcnt);
320                                 /* Dummy USB address of 0xff will get overwritten later. */
321                                 devc->usb = sr_usb_dev_inst_new(
322                                                 libusb_get_bus_number(devlist[i]), 0xff, NULL);
323                                 devcnt++;
324                                 break;
325                         } else if (des.idVendor == dev_profiles[j].fw_vid
326                                 && des.idProduct == dev_profiles[j].fw_pid) {
327                                 /* Device matches the post-firmware profile. */
328                                 prof = &dev_profiles[j];
329                                 sr_dbg("hantek-dso: Found a %s %s.", prof->vendor, prof->model);
330                                 sdi = dso_dev_new(devcnt, prof);
331                                 sdi->status = SR_ST_INACTIVE;
332                                 devices = g_slist_append(devices, sdi);
333                                 devc = sdi->priv;
334                                 devc->usb = sr_usb_dev_inst_new(
335                                                 libusb_get_bus_number(devlist[i]),
336                                                 libusb_get_device_address(devlist[i]), NULL);
337                                 devcnt++;
338                                 break;
339                         }
340                 }
341                 if (!prof)
342                         /* not a supported VID/PID */
343                         continue;
344         }
345         libusb_free_device_list(devlist, 1);
346
347         return devices;
348 }
349
350 static GSList *hw_dev_list(void)
351 {
352         struct drv_context *drvc;
353
354         drvc = hdi->priv;
355
356         return drvc->instances;
357 }
358
359 static int hw_dev_open(struct sr_dev_inst *sdi)
360 {
361         struct dev_context *devc;
362         int64_t timediff_us, timediff_ms;
363         int err;
364
365         devc = sdi->priv;
366
367         /*
368          * if the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
369          * for the FX2 to renumerate
370          */
371         err = SR_ERR;
372         if (devc->fw_updated > 0) {
373                 sr_info("hantek-dso: waiting for device to reset");
374                 /* takes at least 300ms for the FX2 to be gone from the USB bus */
375                 g_usleep(300 * 1000);
376                 timediff_ms = 0;
377                 while (timediff_ms < MAX_RENUM_DELAY_MS) {
378                         if ((err = dso_open(sdi)) == SR_OK)
379                                 break;
380                         g_usleep(100 * 1000);
381                         timediff_us = g_get_monotonic_time() - devc->fw_updated;
382                         timediff_ms = timediff_us / 1000;
383                         sr_spew("hantek-dso: waited %" PRIi64 " ms", timediff_ms);
384                 }
385                 sr_info("hantek-dso: device came back after %d ms", timediff_ms);
386         } else {
387                 err = dso_open(sdi);
388         }
389
390         if (err != SR_OK) {
391                 sr_err("hantek-dso: unable to open device");
392                 return SR_ERR;
393         }
394
395         err = libusb_claim_interface(devc->usb->devhdl, USB_INTERFACE);
396         if (err != 0) {
397                 sr_err("hantek-dso: Unable to claim interface: %d", err);
398                 return SR_ERR;
399         }
400
401         return SR_OK;
402 }
403
404 static int hw_dev_close(struct sr_dev_inst *sdi)
405 {
406
407         dso_close(sdi);
408
409         return SR_OK;
410 }
411
412 static int hw_cleanup(void)
413 {
414         struct drv_context *drvc;
415
416         if (!(drvc = hdi->priv))
417                 return SR_OK;
418
419         clear_instances();
420
421         if (drvc->usb_context)
422                 libusb_exit(drvc->usb_context);
423         drvc->usb_context = NULL;
424
425         return SR_OK;
426 }
427
428 static int hw_info_get(int info_id, const void **data,
429        const struct sr_dev_inst *sdi)
430 {
431         uint64_t tmp;
432
433         (void)sdi;
434
435         switch (info_id) {
436         case SR_DI_HWCAPS:
437                 *data = hwcaps;
438                 break;
439         case SR_DI_NUM_PROBES:
440                 *data = GINT_TO_POINTER(NUM_PROBES);
441                 break;
442         case SR_DI_PROBE_NAMES:
443                 *data = probe_names;
444                 break;
445         case SR_DI_BUFFERSIZES:
446                 *data = buffersizes;
447                 break;
448         case SR_DI_TIMEBASES:
449                 *data = timebases;
450                 break;
451         case SR_DI_TRIGGER_SOURCES:
452                 *data = trigger_sources;
453                 break;
454         case SR_DI_FILTERS:
455                 *data = filter_targets;
456                 break;
457         case SR_DI_VDIVS:
458                 *data = vdivs;
459                 break;
460         case SR_DI_COUPLING:
461                 *data = coupling;
462                 break;
463         /* TODO remove this */
464         case SR_DI_CUR_SAMPLERATE:
465                 *data = &tmp;
466                 break;
467         default:
468                 return SR_ERR_ARG;
469         }
470
471         return SR_OK;
472 }
473
474 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
475                 const void *value)
476 {
477         struct dev_context *devc;
478         struct sr_rational tmp_rat;
479         float tmp_float;
480         uint64_t tmp_u64;
481         int ret, i;
482         char **targets;
483
484         if (sdi->status != SR_ST_ACTIVE)
485                 return SR_ERR;
486
487         ret = SR_OK;
488         devc = sdi->priv;
489         switch (hwcap) {
490         case SR_HWCAP_LIMIT_FRAMES:
491                 devc->limit_frames = *(const uint64_t *)value;
492                 break;
493         case SR_HWCAP_TRIGGER_SLOPE:
494                 tmp_u64 = *(const int *)value;
495                 if (tmp_u64 != SLOPE_NEGATIVE && tmp_u64 != SLOPE_POSITIVE)
496                         ret = SR_ERR_ARG;
497                 devc->triggerslope = tmp_u64;
498                 break;
499         case SR_HWCAP_HORIZ_TRIGGERPOS:
500                 tmp_float = *(const float *)value;
501                 if (tmp_float < 0.0 || tmp_float > 1.0) {
502                         sr_err("hantek-dso: trigger position should be between 0.0 and 1.0");
503                         ret = SR_ERR_ARG;
504                 } else
505                         devc->triggerposition = tmp_float;
506                 break;
507         case SR_HWCAP_BUFFERSIZE:
508                 tmp_u64 = *(const int *)value;
509                 for (i = 0; buffersizes[i]; i++) {
510                         if (buffersizes[i] == tmp_u64) {
511                                 devc->framesize = tmp_u64;
512                                 break;
513                         }
514                 }
515                 if (buffersizes[i] == 0)
516                         ret = SR_ERR_ARG;
517                 break;
518         case SR_HWCAP_TIMEBASE:
519                 tmp_rat = *(const struct sr_rational *)value;
520                 for (i = 0; timebases[i].p && timebases[i].q; i++) {
521                         if (timebases[i].p == tmp_rat.p
522                                         && timebases[i].q == tmp_rat.q) {
523                                 devc->timebase = i;
524                                 break;
525                         }
526                 }
527                 if (timebases[i].p == 0 && timebases[i].q == 0)
528                         ret = SR_ERR_ARG;
529                 break;
530         case SR_HWCAP_TRIGGER_SOURCE:
531                 for (i = 0; trigger_sources[i]; i++) {
532                         if (!strcmp(value, trigger_sources[i])) {
533                                 devc->triggersource = g_strdup(value);
534                                 break;
535                         }
536                 }
537                 if (trigger_sources[i] == 0)
538                         ret = SR_ERR_ARG;
539                 break;
540         case SR_HWCAP_FILTER:
541                 devc->filter_ch1 = devc->filter_ch2 = devc->filter_trigger = 0;
542                 targets = g_strsplit(value, ",", 0);
543                 for (i = 0; targets[i]; i++) {
544                         if (targets[i] == '\0')
545                                 /* Empty filter string can be used to clear them all. */
546                                 ;
547                         else if (!strcmp(targets[i], "CH1"))
548                                 devc->filter_ch1 = TRUE;
549                         else if (!strcmp(targets[i], "CH2"))
550                                 devc->filter_ch2 = TRUE;
551                         else if (!strcmp(targets[i], "TRIGGER"))
552                                 devc->filter_trigger = TRUE;
553                         else {
554                                 sr_err("invalid filter target %s", targets[i]);
555                                 ret = SR_ERR_ARG;
556                         }
557                 }
558                 g_strfreev(targets);
559                 break;
560         case SR_HWCAP_VDIV:
561                 /* TODO not supporting vdiv per channel yet */
562                 tmp_rat = *(const struct sr_rational *)value;
563                 for (i = 0; vdivs[i].p && vdivs[i].q; i++) {
564                         if (vdivs[i].p == tmp_rat.p
565                                         && vdivs[i].q == tmp_rat.q) {
566                                 devc->voltage_ch1 = i;
567                                 devc->voltage_ch2 = i;
568                                 break;
569                         }
570                 }
571                 if (vdivs[i].p == 0 && vdivs[i].q == 0)
572                         ret = SR_ERR_ARG;
573                 break;
574         case SR_HWCAP_COUPLING:
575                 /* TODO not supporting coupling per channel yet */
576                 for (i = 0; coupling[i]; i++) {
577                         if (!strcmp(value, coupling[i])) {
578                                 devc->coupling_ch1 = i;
579                                 devc->coupling_ch2 = i;
580                                 break;
581                         }
582                 }
583                 if (coupling[i] == 0)
584                         ret = SR_ERR_ARG;
585                 break;
586         default:
587                 ret = SR_ERR_ARG;
588         }
589
590         return ret;
591 }
592
593 static void send_chunk(struct dev_context *devc, unsigned char *buf,
594                 int num_samples)
595 {
596         struct sr_datafeed_packet packet;
597         struct sr_datafeed_analog analog;
598         float ch1, ch2, range;
599         int num_probes, data_offset, i;
600
601         num_probes = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
602         packet.type = SR_DF_ANALOG;
603         packet.payload = &analog;
604         /* TODO: support for 5xxx series 9-bit samples */
605         analog.num_samples = num_samples;
606         analog.mq = SR_MQ_VOLTAGE;
607         analog.unit = SR_UNIT_VOLT;
608         analog.data = g_try_malloc(analog.num_samples * sizeof(float) * num_probes);
609         data_offset = 0;
610         for (i = 0; i < analog.num_samples; i++) {
611                 /* The device always sends data for both channels. If a channel
612                  * is disabled, it contains a copy of the enabled channel's
613                  * data. However, we only send the requested channels to the bus.
614                  *
615                  * Voltage values are encoded as a value 0-255 (0-512 on the 5200*),
616                  * where the value is a point in the range represented by the vdiv
617                  * setting. There are 8 vertical divs, so e.g. 500mV/div represents
618                  * 4V peak-to-peak where 0 = -2V and 255 = +2V.
619                  */
620                 /* TODO: support for 5xxx series 9-bit samples */
621                 if (devc->ch1_enabled) {
622                         range = ((float)vdivs[devc->voltage_ch1].p / vdivs[devc->voltage_ch1].q) * 8;
623                         ch1 = range / 255 * *(buf + i * 2 + 1);
624                         /* Value is centered around 0V. */
625                         ch1 -= range / 2;
626                         analog.data[data_offset++] = ch1;
627                 }
628                 if (devc->ch2_enabled) {
629                         range = ((float)vdivs[devc->voltage_ch2].p / vdivs[devc->voltage_ch2].q) * 8;
630                         ch2 = range / 255 * *(buf + i * 2);
631                         ch2 -= range / 2;
632                         analog.data[data_offset++] = ch2;
633                 }
634         }
635         sr_session_send(devc->cb_data, &packet);
636
637 }
638
639 /* Called by libusb (as triggered by handle_event()) when a transfer comes in.
640  * Only channel data comes in asynchronously, and all transfers for this are
641  * queued up beforehand, so this just needs so chuck the incoming data onto
642  * the libsigrok session bus.
643  */
644 static void receive_transfer(struct libusb_transfer *transfer)
645 {
646         struct sr_datafeed_packet packet;
647         struct dev_context *devc;
648         int num_samples, pre;
649
650         devc = transfer->user_data;
651         sr_dbg("hantek-dso: receive_transfer(): status %d received %d bytes",
652                         transfer->status, transfer->actual_length);
653
654         if (transfer->actual_length == 0)
655                 /* Nothing to send to the bus. */
656                 return;
657
658         num_samples = transfer->actual_length / 2;
659
660         sr_dbg("hantek-dso: got %d-%d/%d samples in frame", devc->samp_received + 1,
661                         devc->samp_received + num_samples, devc->framesize);
662
663         /* The device always sends a full frame, but the beginning of the frame
664          * doesn't represent the trigger point. The offset at which the trigger
665          * happened came in with the capture state, so we need to start sending
666          * from there up the session bus. The samples in the frame buffer before
667          * that trigger point came after the end of the device's frame buffer was
668          * reached, and it wrapped around to overwrite up until the trigger point.
669          */
670         if (devc->samp_received < devc->trigger_offset) {
671                 /* Trigger point not yet reached. */
672                 if (devc->samp_received + num_samples < devc->trigger_offset) {
673                         /* The entire chunk is before the trigger point. */
674                         memcpy(devc->framebuf + devc->samp_buffered * 2,
675                                         transfer->buffer, num_samples * 2);
676                         devc->samp_buffered += num_samples;
677                 } else {
678                         /* This chunk hits or overruns the trigger point.
679                          * Store the part before the trigger fired, and
680                          * send the rest up to the session bus. */
681                         pre = devc->trigger_offset - devc->samp_received;
682                         memcpy(devc->framebuf + devc->samp_buffered * 2,
683                                         transfer->buffer, pre * 2);
684                         devc->samp_buffered += pre;
685
686                         /* The rest of this chunk starts with the trigger point. */
687                         sr_dbg("hantek-dso: reached trigger point, %d samples buffered",
688                                         devc->samp_buffered);
689
690                         /* Avoid the corner case where the chunk ended at
691                          * exactly the trigger point. */
692                         if (num_samples > pre)
693                                 send_chunk(devc, transfer->buffer + pre * 2,
694                                                 num_samples - pre);
695                 }
696         } else {
697                 /* Already past the trigger point, just send it all out. */
698                 send_chunk(devc, transfer->buffer,
699                                 num_samples);
700         }
701
702         devc->samp_received += num_samples;
703
704         /* Everything in this transfer was either copied to the buffer or
705          * sent to the session bus. */
706         g_free(transfer->buffer);
707         libusb_free_transfer(transfer);
708
709         if (devc->samp_received >= devc->framesize) {
710                 /* That was the last chunk in this frame. Send the buffered
711                  * pre-trigger samples out now, in one big chunk. */
712                 sr_dbg("hantek-dso: end of frame, sending %d pre-trigger buffered samples",
713                                 devc->samp_buffered);
714                 send_chunk(devc, devc->framebuf, devc->samp_buffered);
715
716                 /* Mark the end of this frame. */
717                 packet.type = SR_DF_FRAME_END;
718                 sr_session_send(devc->cb_data, &packet);
719
720                 if (devc->limit_frames && ++devc->num_frames == devc->limit_frames) {
721                         /* Terminate session */
722                         devc->dev_state = STOPPING;
723                 } else {
724                         devc->dev_state = NEW_CAPTURE;
725                 }
726         }
727
728 }
729
730 static int handle_event(int fd, int revents, void *cb_data)
731 {
732         const struct sr_dev_inst *sdi;
733         struct sr_datafeed_packet packet;
734         struct timeval tv;
735         struct drv_context *drvc;
736         struct dev_context *devc;
737         const struct libusb_pollfd **lupfd;
738         int num_probes, i;
739         uint32_t trigger_offset;
740         uint8_t capturestate;
741
742         /* Avoid compiler warnings. */
743         (void)fd;
744         (void)revents;
745
746         drvc = hdi->priv;
747         sdi = cb_data;
748         devc = sdi->priv;
749         if (devc->dev_state == STOPPING) {
750                 /* We've been told to wind up the acquisition. */
751                 sr_dbg("hantek-dso: stopping acquisition");
752                 /* TODO: doesn't really cancel pending transfers so they might
753                  * come in after SR_DF_END is sent. */
754                 lupfd = libusb_get_pollfds(drvc->usb_context);
755                 for (i = 0; lupfd[i]; i++)
756                         sr_source_remove(lupfd[i]->fd);
757                 free(lupfd);
758
759                 packet.type = SR_DF_END;
760                 sr_session_send(sdi, &packet);
761
762                 devc->dev_state = IDLE;
763
764                 return TRUE;
765         }
766
767         /* Always handle pending libusb events. */
768         tv.tv_sec = tv.tv_usec = 0;
769         libusb_handle_events_timeout(drvc->usb_context, &tv);
770
771         /* TODO: ugh */
772         if (devc->dev_state == NEW_CAPTURE) {
773                 if (dso_capture_start(devc) != SR_OK)
774                         return TRUE;
775                 if (dso_enable_trigger(devc) != SR_OK)
776                         return TRUE;
777 //              if (dso_force_trigger(devc) != SR_OK)
778 //                      return TRUE;
779                 sr_dbg("hantek-dso: successfully requested next chunk");
780                 devc->dev_state = CAPTURE;
781                 return TRUE;
782         }
783         if (devc->dev_state != CAPTURE)
784                 return TRUE;
785
786         if ((dso_get_capturestate(devc, &capturestate, &trigger_offset)) != SR_OK)
787                 return TRUE;
788
789         sr_dbg("hantek-dso: capturestate %d", capturestate);
790         sr_dbg("hantek-dso: trigger offset 0x%.6x", trigger_offset);
791         switch (capturestate) {
792         case CAPTURE_EMPTY:
793                 if (++devc->capture_empty_count >= MAX_CAPTURE_EMPTY) {
794                         devc->capture_empty_count = 0;
795                         if (dso_capture_start(devc) != SR_OK)
796                                 break;
797                         if (dso_enable_trigger(devc) != SR_OK)
798                                 break;
799 //                      if (dso_force_trigger(devc) != SR_OK)
800 //                              break;
801                         sr_dbg("hantek-dso: successfully requested next chunk");
802                 }
803                 break;
804         case CAPTURE_FILLING:
805                 /* no data yet */
806                 break;
807         case CAPTURE_READY_8BIT:
808                 /* Remember where in the captured frame the trigger is. */
809                 devc->trigger_offset = trigger_offset;
810
811                 num_probes = (devc->ch1_enabled && devc->ch2_enabled) ? 2 : 1;
812                 devc->framebuf = g_try_malloc(devc->framesize * num_probes * 2);
813                 devc->samp_buffered = devc->samp_received = 0;
814
815                 /* Tell the scope to send us the first frame. */
816                 if (dso_get_channeldata(devc, receive_transfer) != SR_OK)
817                         break;
818
819                 /* Don't hit the state machine again until we're done fetching
820                  * the data we just told the scope to send.
821                  */
822                 devc->dev_state = FETCH_DATA;
823
824                 /* Tell the frontend a new frame is on the way. */
825                 packet.type = SR_DF_FRAME_BEGIN;
826                 sr_session_send(sdi, &packet);
827                 break;
828         case CAPTURE_READY_9BIT:
829                 /* TODO */
830                 sr_err("not yet supported");
831                 break;
832         case CAPTURE_TIMEOUT:
833                 /* Doesn't matter, we'll try again next time. */
834                 break;
835         default:
836                 sr_dbg("unknown capture state");
837         }
838
839         return TRUE;
840 }
841
842 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
843                 void *cb_data)
844 {
845         const struct libusb_pollfd **lupfd;
846         struct sr_datafeed_packet packet;
847         struct sr_datafeed_header header;
848         struct sr_datafeed_meta_analog meta;
849         struct drv_context *drvc;
850         struct dev_context *devc;
851         int i;
852
853         drvc = hdi->priv;
854         if (sdi->status != SR_ST_ACTIVE)
855                 return SR_ERR;
856
857         devc = sdi->priv;
858         devc->cb_data = cb_data;
859
860         if (configure_probes(sdi) != SR_OK) {
861                 sr_err("hantek-dso: failed to configured probes");
862                 return SR_ERR;
863         }
864
865         if (dso_init(devc) != SR_OK)
866                 return SR_ERR;
867
868         if (dso_capture_start(devc) != SR_OK)
869                 return SR_ERR;
870
871         devc->dev_state = CAPTURE;
872         lupfd = libusb_get_pollfds(drvc->usb_context);
873         for (i = 0; lupfd[i]; i++)
874                 sr_source_add(lupfd[i]->fd, lupfd[i]->events, TICK, handle_event,
875                                 (void *)sdi);
876         free(lupfd);
877
878         /* Send header packet to the session bus. */
879         packet.type = SR_DF_HEADER;
880         packet.payload = (unsigned char *)&header;
881         header.feed_version = 1;
882         gettimeofday(&header.starttime, NULL);
883         sr_session_send(cb_data, &packet);
884
885         /* Send metadata about the SR_DF_ANALOG packets to come. */
886         packet.type = SR_DF_META_ANALOG;
887         packet.payload = &meta;
888         meta.num_probes = NUM_PROBES;
889         sr_session_send(cb_data, &packet);
890
891         return SR_OK;
892 }
893
894 static int hw_dev_acquisition_stop(const struct sr_dev_inst *sdi,
895                 void *cb_data)
896 {
897         struct dev_context *devc;
898
899         (void)cb_data;
900
901         if (sdi->status != SR_ST_ACTIVE)
902                 return SR_ERR;
903
904         devc = sdi->priv;
905         devc->dev_state = STOPPING;
906
907         return SR_OK;
908 }
909
910 SR_PRIV struct sr_dev_driver hantek_dso_driver_info = {
911         .name = "hantek-dso",
912         .longname = "Hantek DSO",
913         .api_version = 1,
914         .init = hw_init,
915         .cleanup = hw_cleanup,
916         .scan = hw_scan,
917         .dev_list = hw_dev_list,
918         .dev_clear = clear_instances,
919         .dev_open = hw_dev_open,
920         .dev_close = hw_dev_close,
921         .info_get = hw_info_get,
922         .dev_config_set = hw_dev_config_set,
923         .dev_acquisition_start = hw_dev_acquisition_start,
924         .dev_acquisition_stop = hw_dev_acquisition_stop,
925         .priv = NULL,
926 };