src/hardware/hantek-6xxx/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2015 Christer Ekholm <christerekholm@gmail.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 <config.h>
  21 #include "protocol.h"
  22
  23 /* Max time in ms before we want to check on USB events */
  24 #define TICK 200
  25
  26 #define RANGE(ch) (((float)vdivs[devc->voltage[ch]][0] / vdivs[devc->voltage[ch]][1]) * VDIV_MULTIPLIER)
  27
  28 static const uint32_t scanopts[] = {
  29         SR_CONF_CONN,
  30 };
  31
  32 static const uint32_t drvopts[] = {
  33         SR_CONF_OSCILLOSCOPE,
  34 };
  35
  36 static const uint32_t devopts[] = {
  37         SR_CONF_CONN | SR_CONF_GET,
  38         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  39         SR_CONF_NUM_VDIV | SR_CONF_GET,
  40         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  41         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
  42 };
  43
  44 static const uint32_t devopts_cg[] = {
  45         SR_CONF_VDIV | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  46         SR_CONF_COUPLING | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  47 };
  48
  49 static const char *channel_names[] = {
  50         "CH1", "CH2",
  51 };
  52
  53 static const char *coupling[] = {
  54         "AC", "DC",
  55 };
  56
  57 static const struct hantek_6xxx_profile dev_profiles[] = {
  58         {
  59                 0x04b4, 0x6022, 0x04b5, 0x6022,
  60                 "Hantek", "6022BE", "hantek-6022be.fw",
  61         },
  62         {
  63                 0x8102, 0x8102, 0x1D50, 0x608E,
  64                 "Sainsmart", "DDS120", "sainsmart-dds120.fw",
  65         },
  66         ALL_ZERO
  67 };
  68
  69 static const uint64_t samplerates[] = {
  70         SAMPLERATE_VALUES
  71 };
  72
  73 static const uint64_t vdivs[][2] = {
  74         VDIV_VALUES
  75 };
  76
  77 static int read_channel(const struct sr_dev_inst *sdi, uint32_t amount);
  78
  79 static int dev_acquisition_stop(struct sr_dev_inst *sdi);
  80
  81 static struct sr_dev_inst *hantek_6xxx_dev_new(struct sr_dev_driver *di,
  82         const struct hantek_6xxx_profile *prof)
  83 {
  84         struct sr_dev_inst *sdi;
  85         struct sr_channel *ch;
  86         struct sr_channel_group *cg;
  87         struct drv_context *drvc;
  88         struct dev_context *devc;
  89         unsigned int i;
  90
  91         sdi = g_malloc0(sizeof(struct sr_dev_inst));
  92         sdi->status = SR_ST_INITIALIZING;
  93         sdi->vendor = g_strdup(prof->vendor);
  94         sdi->model = g_strdup(prof->model);
  95         sdi->driver = di;
  96
  97         for (i = 0; i < ARRAY_SIZE(channel_names); i++) {
  98                 ch = sr_channel_new(sdi, i, SR_CHANNEL_ANALOG, TRUE, channel_names[i]);
  99                 cg = g_malloc0(sizeof(struct sr_channel_group));
 100                 cg->name = g_strdup(channel_names[i]);
 101                 cg->channels = g_slist_append(cg->channels, ch);
 102                 sdi->channel_groups = g_slist_append(sdi->channel_groups, cg);
 103         }
 104
 105         devc = g_malloc0(sizeof(struct dev_context));
 106
 107         for (i = 0; i < NUM_CHANNELS; i++) {
 108                 devc->ch_enabled[i] = TRUE;
 109                 devc->voltage[i] = DEFAULT_VOLTAGE;
 110                 devc->coupling[i] = DEFAULT_COUPLING;
 111         }
 112
 113         devc->sample_buf = NULL;
 114         devc->sample_buf_write = 0;
 115         devc->sample_buf_size = 0;
 116
 117         devc->profile = prof;
 118         devc->dev_state = IDLE;
 119         devc->samplerate = DEFAULT_SAMPLERATE;
 120
 121         sdi->priv = devc;
 122         drvc = sdi->driver->context;
 123         drvc->instances = g_slist_append(drvc->instances, sdi);
 124
 125         return sdi;
 126 }
 127
 128 static int configure_channels(const struct sr_dev_inst *sdi)
 129 {
 130         struct dev_context *devc;
 131         const GSList *l;
 132         int p;
 133         struct sr_channel *ch;
 134         devc = sdi->priv;
 135
 136         g_slist_free(devc->enabled_channels);
 137         devc->enabled_channels = NULL;
 138         memset(devc->ch_enabled, 0, sizeof(devc->ch_enabled));
 139
 140         for (l = sdi->channels, p = 0; l; l = l->next, p++) {
 141                 ch = l->data;
 142                 if (p < NUM_CHANNELS) {
 143                         devc->ch_enabled[p] = ch->enabled;
 144                         devc->enabled_channels = g_slist_append(devc->enabled_channels, ch);
 145                 }
 146         }
 147
 148         return SR_OK;
 149 }
 150
 151 static void clear_dev_context(void *priv)
 152 {
 153         struct dev_context *devc;
 154
 155         devc = priv;
 156         g_slist_free(devc->enabled_channels);
 157         g_free(devc);
 158 }
 159
 160 static int dev_clear(const struct sr_dev_driver *di)
 161 {
 162         return std_dev_clear(di, clear_dev_context);
 163 }
 164
 165 static GSList *scan(struct sr_dev_driver *di, GSList *options)
 166 {
 167         struct drv_context *drvc;
 168         struct dev_context *devc;
 169         struct sr_dev_inst *sdi;
 170         struct sr_usb_dev_inst *usb;
 171         struct sr_config *src;
 172         const struct hantek_6xxx_profile *prof;
 173         GSList *l, *devices, *conn_devices;
 174         struct libusb_device_descriptor des;
 175         libusb_device **devlist;
 176         int i, j;
 177         const char *conn;
 178         char connection_id[64];
 179
 180         drvc = di->context;
 181
 182         devices = 0;
 183
 184         conn = NULL;
 185         for (l = options; l; l = l->next) {
 186                 src = l->data;
 187                 if (src->key == SR_CONF_CONN) {
 188                         conn = g_variant_get_string(src->data, NULL);
 189                         break;
 190                 }
 191         }
 192         if (conn)
 193                 conn_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
 194         else
 195                 conn_devices = NULL;
 196
 197         /* Find all Hantek 60xx devices and upload firmware to all of them. */
 198         libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
 199         for (i = 0; devlist[i]; i++) {
 200                 if (conn) {
 201                         usb = NULL;
 202                         for (l = conn_devices; l; l = l->next) {
 203                                 usb = l->data;
 204                                 if (usb->bus == libusb_get_bus_number(devlist[i])
 205                                         && usb->address == libusb_get_device_address(devlist[i]))
 206                                         break;
 207                         }
 208                         if (!l)
 209                                 /* This device matched none of the ones that
 210                                  * matched the conn specification. */
 211                                 continue;
 212                 }
 213
 214                 libusb_get_device_descriptor(devlist[i], &des);
 215
 216                 usb_get_port_path(devlist[i], connection_id, sizeof(connection_id));
 217
 218                 prof = NULL;
 219                 for (j = 0; j < (int)ARRAY_SIZE(dev_profiles); j++) {
 220                         if (des.idVendor == dev_profiles[j].orig_vid
 221                                 && des.idProduct == dev_profiles[j].orig_pid) {
 222                                 /* Device matches the pre-firmware profile. */
 223                                 prof = &dev_profiles[j];
 224                                 sr_dbg("Found a %s %s.", prof->vendor, prof->model);
 225                                 sdi = hantek_6xxx_dev_new(di, prof);
 226                                 sdi->connection_id = g_strdup(connection_id);
 227                                 devices = g_slist_append(devices, sdi);
 228                                 devc = sdi->priv;
 229                                 if (ezusb_upload_firmware(drvc->sr_ctx, devlist[i],
 230                                                 USB_CONFIGURATION, prof->firmware) == SR_OK)
 231                                         /* Remember when the firmware on this device was updated. */
 232                                         devc->fw_updated = g_get_monotonic_time();
 233                                 else
 234                                         sr_err("Firmware upload failed.");
 235                                 /* Dummy USB address of 0xff will get overwritten later. */
 236                                 sdi->conn = sr_usb_dev_inst_new(
 237                                                 libusb_get_bus_number(devlist[i]), 0xff, NULL);
 238                                 break;
 239                         } else if (des.idVendor == dev_profiles[j].fw_vid
 240                                 && des.idProduct == dev_profiles[j].fw_pid) {
 241                                 /* Device matches the post-firmware profile. */
 242                                 prof = &dev_profiles[j];
 243                                 sr_dbg("Found a %s %s.", prof->vendor, prof->model);
 244                                 sdi = hantek_6xxx_dev_new(di, prof);
 245                                 sdi->connection_id = g_strdup(connection_id);
 246                                 sdi->status = SR_ST_INACTIVE;
 247                                 devices = g_slist_append(devices, sdi);
 248                                 sdi->inst_type = SR_INST_USB;
 249                                 sdi->conn = sr_usb_dev_inst_new(
 250                                                 libusb_get_bus_number(devlist[i]),
 251                                                 libusb_get_device_address(devlist[i]), NULL);
 252                                 break;
 253                         }
 254                 }
 255                 if (!prof)
 256                         /* Not a supported VID/PID. */
 257                         continue;
 258         }
 259         libusb_free_device_list(devlist, 1);
 260
 261         return devices;
 262 }
 263
 264 static int dev_open(struct sr_dev_inst *sdi)
 265 {
 266         struct dev_context *devc;
 267         struct sr_usb_dev_inst *usb;
 268         int64_t timediff_us, timediff_ms;
 269         int err;
 270
 271         devc = sdi->priv;
 272         usb = sdi->conn;
 273
 274         /*
 275          * If the firmware was recently uploaded, wait up to MAX_RENUM_DELAY_MS
 276          * for the FX2 to renumerate.
 277          */
 278         err = SR_ERR;
 279         if (devc->fw_updated > 0) {
 280                 sr_info("Waiting for device to reset.");
 281                 /* Takes >= 300ms for the FX2 to be gone from the USB bus. */
 282                 g_usleep(300 * 1000);
 283                 timediff_ms = 0;
 284                 while (timediff_ms < MAX_RENUM_DELAY_MS) {
 285                         if ((err = hantek_6xxx_open(sdi)) == SR_OK)
 286                                 break;
 287                         g_usleep(100 * 1000);
 288                         timediff_us = g_get_monotonic_time() - devc->fw_updated;
 289                         timediff_ms = timediff_us / 1000;
 290                         sr_spew("Waited %" PRIi64 " ms.", timediff_ms);
 291                 }
 292                 if (timediff_ms < MAX_RENUM_DELAY_MS)
 293                         sr_info("Device came back after %"PRIu64" ms.", timediff_ms);
 294         } else {
 295                 err = hantek_6xxx_open(sdi);
 296         }
 297
 298         if (err != SR_OK) {
 299                 sr_err("Unable to open device.");
 300                 return SR_ERR;
 301         }
 302
 303         err = libusb_claim_interface(usb->devhdl, USB_INTERFACE);
 304         if (err != 0) {
 305                 sr_err("Unable to claim interface: %s.",
 306                            libusb_error_name(err));
 307                 return SR_ERR;
 308         }
 309
 310         return SR_OK;
 311 }
 312
 313 static int dev_close(struct sr_dev_inst *sdi)
 314 {
 315         hantek_6xxx_close(sdi);
 316
 317         return SR_OK;
 318 }
 319
 320 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 321                 const struct sr_channel_group *cg)
 322 {
 323         struct dev_context *devc;
 324         struct sr_usb_dev_inst *usb;
 325         char str[128];
 326         const uint64_t *vdiv;
 327         int ch_idx;
 328
 329         switch (key) {
 330         case SR_CONF_NUM_VDIV:
 331                 *data = g_variant_new_int32(ARRAY_SIZE(vdivs));
 332                 break;
 333         }
 334
 335         if (!sdi)
 336                 return SR_ERR_ARG;
 337
 338         devc = sdi->priv;
 339         if (!cg) {
 340                 switch (key) {
 341                 case SR_CONF_SAMPLERATE:
 342                         *data = g_variant_new_uint64(devc->samplerate);
 343                         break;
 344                 case SR_CONF_LIMIT_MSEC:
 345                         *data = g_variant_new_uint64(devc->limit_msec);
 346                         break;
 347                 case SR_CONF_LIMIT_SAMPLES:
 348                         *data = g_variant_new_uint64(devc->limit_samples);
 349                         break;
 350                 case SR_CONF_CONN:
 351                         if (!sdi->conn)
 352                                 return SR_ERR_ARG;
 353                         usb = sdi->conn;
 354                         if (usb->address == 255)
 355                                 /* Device still needs to re-enumerate after firmware
 356                                  * upload, so we don't know its (future) address. */
 357                                 return SR_ERR;
 358                         snprintf(str, 128, "%d.%d", usb->bus, usb->address);
 359                         *data = g_variant_new_string(str);
 360                         break;
 361                 default:
 362                         return SR_ERR_NA;
 363                 }
 364         } else {
 365                 if (sdi->channel_groups->data == cg)
 366                         ch_idx = 0;
 367                 else if (sdi->channel_groups->next->data == cg)
 368                         ch_idx = 1;
 369                 else
 370                         return SR_ERR_ARG;
 371                 switch (key) {
 372                 case SR_CONF_VDIV:
 373                         vdiv = vdivs[devc->voltage[ch_idx]];
 374                         *data = g_variant_new("(tt)", vdiv[0], vdiv[1]);
 375                         break;
 376                 case SR_CONF_COUPLING:
 377                         *data = g_variant_new_string(coupling[devc->coupling[ch_idx]]);
 378                         break;
 379                 }
 380         }
 381
 382         return SR_OK;
 383 }
 384
 385 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 386                 const struct sr_channel_group *cg)
 387 {
 388         struct dev_context *devc;
 389         uint64_t p, q;
 390         int tmp_int, ch_idx, ret;
 391         unsigned int i;
 392         const char *tmp_str;
 393
 394         if (sdi->status != SR_ST_ACTIVE)
 395                 return SR_ERR_DEV_CLOSED;
 396
 397         ret = SR_OK;
 398         devc = sdi->priv;
 399         if (!cg) {
 400                 switch (key) {
 401                 case SR_CONF_SAMPLERATE:
 402                         devc->samplerate = g_variant_get_uint64(data);
 403                         hantek_6xxx_update_samplerate(sdi);
 404                         break;
 405                 case SR_CONF_LIMIT_MSEC:
 406                         devc->limit_msec = g_variant_get_uint64(data);
 407                         break;
 408                 case SR_CONF_LIMIT_SAMPLES:
 409                         devc->limit_samples = g_variant_get_uint64(data);
 410                         break;
 411                 default:
 412                         ret = SR_ERR_NA;
 413                         break;
 414                 }
 415         } else {
 416                 if (sdi->channel_groups->data == cg)
 417                         ch_idx = 0;
 418                 else if (sdi->channel_groups->next->data == cg)
 419                         ch_idx = 1;
 420                 else
 421                         return SR_ERR_ARG;
 422                 switch (key) {
 423                 case SR_CONF_VDIV:
 424                         g_variant_get(data, "(tt)", &p, &q);
 425                         tmp_int = -1;
 426                         for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
 427                                 if (vdivs[i][0] == p && vdivs[i][1] == q) {
 428                                         tmp_int = i;
 429                                         break;
 430                                 }
 431                         }
 432                         if (tmp_int >= 0) {
 433                                 devc->voltage[ch_idx] = tmp_int;
 434                                 hantek_6xxx_update_vdiv(sdi);
 435                         } else
 436                                 ret = SR_ERR_ARG;
 437                         break;
 438                 case SR_CONF_COUPLING:
 439                         tmp_str = g_variant_get_string(data, NULL);
 440                         for (i = 0; coupling[i]; i++) {
 441                                 if (!strcmp(tmp_str, coupling[i])) {
 442                                         devc->coupling[ch_idx] = i;
 443                                         break;
 444                                 }
 445                         }
 446                         if (coupling[i] == 0)
 447                                 ret = SR_ERR_ARG;
 448                         break;
 449                 default:
 450                         ret = SR_ERR_NA;
 451                         break;
 452                 }
 453         }
 454
 455         return ret;
 456 }
 457
 458 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 459                 const struct sr_channel_group *cg)
 460 {
 461         GVariant *tuple, *rational[2];
 462         GVariantBuilder gvb;
 463         unsigned int i;
 464         GVariant *gvar;
 465
 466         if (key == SR_CONF_SCAN_OPTIONS) {
 467                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 468                         scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 469                 return SR_OK;
 470         } else if (key == SR_CONF_DEVICE_OPTIONS && !sdi) {
 471                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 472                         drvopts, ARRAY_SIZE(drvopts), sizeof(uint32_t));
 473                 return SR_OK;
 474         }
 475
 476         if (!sdi)
 477                 return SR_ERR_ARG;
 478
 479         if (!cg) {
 480                 switch (key) {
 481                 case SR_CONF_DEVICE_OPTIONS:
 482                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 483                                 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 484                         break;
 485                 case SR_CONF_SAMPLERATE:
 486                         g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 487                         gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
 488                                 samplerates, ARRAY_SIZE(samplerates),
 489                                 sizeof(uint64_t));
 490                         g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
 491                         *data = g_variant_builder_end(&gvb);
 492                         break;
 493                 default:
 494                         return SR_ERR_NA;
 495                 }
 496         } else {
 497                 switch (key) {
 498                 case SR_CONF_DEVICE_OPTIONS:
 499                         *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 500                                 devopts_cg, ARRAY_SIZE(devopts_cg), sizeof(uint32_t));
 501                         break;
 502                 case SR_CONF_COUPLING:
 503                         *data = g_variant_new_strv(coupling, ARRAY_SIZE(coupling));
 504                         break;
 505                 case SR_CONF_VDIV:
 506                         g_variant_builder_init(&gvb, G_VARIANT_TYPE_ARRAY);
 507                         for (i = 0; i < ARRAY_SIZE(vdivs); i++) {
 508                                 rational[0] = g_variant_new_uint64(vdivs[i][0]);
 509                                 rational[1] = g_variant_new_uint64(vdivs[i][1]);
 510                                 tuple = g_variant_new_tuple(rational, 2);
 511                                 g_variant_builder_add_value(&gvb, tuple);
 512                         }
 513                         *data = g_variant_builder_end(&gvb);
 514                         break;
 515                 default:
 516                         return SR_ERR_NA;
 517                 }
 518         }
 519
 520         return SR_OK;
 521 }
 522
 523 /* Minimise data amount for limit_samples and limit_msec limits. */
 524 static uint32_t data_amount(const struct sr_dev_inst *sdi)
 525 {
 526         struct dev_context *devc = sdi->priv;
 527         uint32_t data_left;
 528         int32_t time_left;
 529
 530         if (devc->limit_msec) {
 531                 time_left = devc->limit_msec - (g_get_monotonic_time() - devc->aq_started) / 1000;
 532                 data_left = devc->samplerate * MAX(time_left, 0) * NUM_CHANNELS / 1000;
 533         } else if (devc->limit_samples) {
 534                 data_left = (devc->limit_samples - devc->samp_received) * NUM_CHANNELS;
 535         } else {
 536                 data_left = devc->samplerate * NUM_CHANNELS;
 537         }
 538
 539         data_left += MIN_PACKET_SIZE; /* Driver does not handle small buffers. */
 540
 541         sr_spew("data_amount %u", data_left);
 542
 543         return data_left;
 544 }
 545
 546 static void send_chunk(struct sr_dev_inst *sdi, unsigned char *buf,
 547                 int num_samples)
 548 {
 549         struct sr_datafeed_packet packet;
 550         struct sr_datafeed_analog_old analog;
 551         struct dev_context *devc = sdi->priv;
 552         int num_channels, data_offset, i;
 553
 554         const float ch1_bit = RANGE(0) / 255;
 555         const float ch2_bit = RANGE(1) / 255;
 556         const float ch1_center = RANGE(0) / 2;
 557         const float ch2_center = RANGE(1) / 2;
 558
 559         const gboolean ch1_ena = !!devc->ch_enabled[0];
 560         const gboolean ch2_ena = !!devc->ch_enabled[1];
 561
 562         num_channels = (ch1_ena && ch2_ena) ? 2 : 1;
 563         packet.type = SR_DF_ANALOG_OLD;
 564         packet.payload = &analog;
 565
 566         analog.channels = devc->enabled_channels;
 567         analog.num_samples = num_samples;
 568         analog.mq = SR_MQ_VOLTAGE;
 569         analog.unit = SR_UNIT_VOLT;
 570         analog.mqflags = 0;
 571
 572         analog.data = g_try_malloc(analog.num_samples * sizeof(float) * num_channels);
 573         if (!analog.data) {
 574                 sr_err("Analog data buffer malloc failed.");
 575                 devc->dev_state = STOPPING;
 576                 return;
 577         }
 578
 579         data_offset = 0;
 580         for (i = 0; i < num_samples; i++) {
 581                 /*
 582                  * The device always sends data for both channels. If a channel
 583                  * is disabled, it contains a copy of the enabled channel's
 584                  * data. However, we only send the requested channels to
 585                  * the bus.
 586                  *
 587                  * Voltage values are encoded as a value 0-255, where the
 588                  * value is a point in the range represented by the vdiv
 589                  * setting. There are 10 vertical divs, so e.g. 500mV/div
 590                  * represents 5V peak-to-peak where 0 = -2.5V and 255 = +2.5V.
 591                  */
 592                 if (ch1_ena)
 593                         analog.data[data_offset++] = (ch1_bit * *(buf + i * 2) - ch1_center);
 594                 if (ch2_ena)
 595                         analog.data[data_offset++] = (ch2_bit * *(buf + i * 2 + 1) - ch2_center);
 596         }
 597
 598         sr_session_send(sdi, &packet);
 599         g_free(analog.data);
 600 }
 601
 602 static void send_data(struct sr_dev_inst *sdi, struct libusb_transfer *buf[], uint64_t samples)
 603 {
 604         int i = 0;
 605         uint64_t send = 0;
 606         uint32_t chunk;
 607
 608         while (send < samples) {
 609                 chunk = MIN(samples - send, (uint64_t)(buf[i]->actual_length / NUM_CHANNELS));
 610                 send += chunk;
 611                 send_chunk(sdi, buf[i]->buffer, chunk);
 612
 613                 /*
 614                  * Everything in this transfer was either copied to the buffer
 615                  * or sent to the session bus.
 616                  */
 617                 g_free(buf[i]->buffer);
 618                 libusb_free_transfer(buf[i]);
 619                 i++;
 620         }
 621 }
 622
 623 /*
 624  * Called by libusb (as triggered by handle_event()) when a transfer comes in.
 625  * Only channel data comes in asynchronously, and all transfers for this are
 626  * queued up beforehand, so this just needs to chuck the incoming data onto
 627  * the libsigrok session bus.
 628  */
 629 static void LIBUSB_CALL receive_transfer(struct libusb_transfer *transfer)
 630 {
 631         struct sr_dev_inst *sdi;
 632         struct dev_context *devc;
 633
 634         sdi = transfer->user_data;
 635         devc = sdi->priv;
 636
 637         if (devc->dev_state == FLUSH) {
 638                 g_free(transfer->buffer);
 639                 libusb_free_transfer(transfer);
 640                 devc->dev_state = CAPTURE;
 641                 devc->aq_started = g_get_monotonic_time();
 642                 read_channel(sdi, data_amount(sdi));
 643                 return;
 644         }
 645
 646         if (devc->dev_state != CAPTURE)
 647                 return;
 648
 649         if (!devc->sample_buf) {
 650                 devc->sample_buf_size = 10;
 651                 devc->sample_buf = g_try_malloc(devc->sample_buf_size * sizeof(transfer));
 652                 devc->sample_buf_write = 0;
 653         }
 654
 655         if (devc->sample_buf_write >= devc->sample_buf_size) {
 656                 devc->sample_buf_size += 10;
 657                 devc->sample_buf = g_try_realloc(devc->sample_buf,
 658                                 devc->sample_buf_size * sizeof(transfer));
 659                 if (!devc->sample_buf) {
 660                         sr_err("Sample buffer malloc failed.");
 661                         devc->dev_state = STOPPING;
 662                         return;
 663                 }
 664         }
 665
 666         devc->sample_buf[devc->sample_buf_write++] = transfer;
 667         devc->samp_received += transfer->actual_length / NUM_CHANNELS;
 668
 669         sr_spew("receive_transfer(): calculated samplerate == %" PRIu64 "ks/s",
 670                 (uint64_t)(transfer->actual_length * 1000 /
 671                 (g_get_monotonic_time() - devc->read_start_ts + 1) /
 672                 NUM_CHANNELS));
 673
 674         sr_spew("receive_transfer(): status %s received %d bytes.",
 675                 libusb_error_name(transfer->status), transfer->actual_length);
 676
 677         if (transfer->actual_length == 0)
 678                 /* Nothing to send to the bus. */
 679                 return;
 680
 681         if (devc->limit_samples && devc->samp_received >= devc->limit_samples) {
 682                 sr_info("Requested number of samples reached, stopping. %"
 683                         PRIu64 " <= %" PRIu64, devc->limit_samples,
 684                         devc->samp_received);
 685                 send_data(sdi, devc->sample_buf, devc->limit_samples);
 686                 sdi->driver->dev_acquisition_stop(sdi);
 687         } else if (devc->limit_msec && (g_get_monotonic_time() -
 688                         devc->aq_started) / 1000 >= devc->limit_msec) {
 689                 sr_info("Requested time limit reached, stopping. %d <= %d",
 690                         (uint32_t)devc->limit_msec,
 691                         (uint32_t)(g_get_monotonic_time() - devc->aq_started) / 1000);
 692                 send_data(sdi, devc->sample_buf, devc->samp_received);
 693                 g_free(devc->sample_buf);
 694                 devc->sample_buf = NULL;
 695                 sdi->driver->dev_acquisition_stop(sdi);
 696         } else {
 697                 read_channel(sdi, data_amount(sdi));
 698         }
 699 }
 700
 701 static int read_channel(const struct sr_dev_inst *sdi, uint32_t amount)
 702 {
 703         int ret;
 704         struct dev_context *devc;
 705
 706         devc = sdi->priv;
 707
 708         amount = MIN(amount, MAX_PACKET_SIZE);
 709         ret = hantek_6xxx_get_channeldata(sdi, receive_transfer, amount);
 710         devc->read_start_ts = g_get_monotonic_time();
 711         devc->read_data_amount = amount;
 712
 713         return ret;
 714 }
 715
 716 static int handle_event(int fd, int revents, void *cb_data)
 717 {
 718         const struct sr_dev_inst *sdi;
 719         struct timeval tv;
 720         struct sr_dev_driver *di;
 721         struct dev_context *devc;
 722         struct drv_context *drvc;
 723
 724         (void)fd;
 725         (void)revents;
 726
 727         sdi = cb_data;
 728         di = sdi->driver;
 729         drvc = di->context;
 730         devc = sdi->priv;
 731
 732         /* Always handle pending libusb events. */
 733         tv.tv_sec = tv.tv_usec = 0;
 734         libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
 735
 736         if (devc->dev_state == STOPPING) {
 737                 /* We've been told to wind up the acquisition. */
 738                 sr_dbg("Stopping acquisition.");
 739
 740                 hantek_6xxx_stop_data_collecting(sdi);
 741                 /*
 742                  * TODO: Doesn't really cancel pending transfers so they might
 743                  * come in after SR_DF_END is sent.
 744                  */
 745                 usb_source_remove(sdi->session, drvc->sr_ctx);
 746
 747                 std_session_send_df_end(sdi, LOG_PREFIX);
 748
 749                 devc->dev_state = IDLE;
 750
 751                 return TRUE;
 752         }
 753
 754         return TRUE;
 755 }
 756
 757 static int dev_acquisition_start(const struct sr_dev_inst *sdi)
 758 {
 759         struct dev_context *devc;
 760         struct sr_dev_driver *di = sdi->driver;
 761         struct drv_context *drvc = di->context;
 762
 763         if (sdi->status != SR_ST_ACTIVE)
 764                 return SR_ERR_DEV_CLOSED;
 765
 766         devc = sdi->priv;
 767
 768         if (configure_channels(sdi) != SR_OK) {
 769                 sr_err("Failed to configure channels.");
 770                 return SR_ERR;
 771         }
 772
 773         if (hantek_6xxx_init(sdi) != SR_OK)
 774                 return SR_ERR;
 775
 776         std_session_send_df_header(sdi, LOG_PREFIX);
 777
 778         devc->samp_received = 0;
 779         devc->dev_state = FLUSH;
 780
 781         usb_source_add(sdi->session, drvc->sr_ctx, TICK,
 782                        handle_event, (void *)sdi);
 783
 784         hantek_6xxx_start_data_collecting(sdi);
 785
 786         read_channel(sdi, FLUSH_PACKET_SIZE);
 787
 788         return SR_OK;
 789 }
 790
 791 static int dev_acquisition_stop(struct sr_dev_inst *sdi)
 792 {
 793         struct dev_context *devc;
 794
 795         if (sdi->status != SR_ST_ACTIVE)
 796                 return SR_ERR;
 797
 798         devc = sdi->priv;
 799         devc->dev_state = STOPPING;
 800
 801         g_free(devc->sample_buf); devc->sample_buf = NULL;
 802
 803         return SR_OK;
 804 }
 805
 806 static struct sr_dev_driver hantek_6xxx_driver_info = {
 807         .name = "hantek-6xxx",
 808         .longname = "Hantek 6xxx",
 809         .api_version = 1,
 810         .init = std_init,
 811         .cleanup = std_cleanup,
 812         .scan = scan,
 813         .dev_list = std_dev_list,
 814         .dev_clear = dev_clear,
 815         .config_get = config_get,
 816         .config_set = config_set,
 817         .config_list = config_list,
 818         .dev_open = dev_open,
 819         .dev_close = dev_close,
 820         .dev_acquisition_start = dev_acquisition_start,
 821         .dev_acquisition_stop = dev_acquisition_stop,
 822         .context = NULL,
 823 };
 824 SR_REGISTER_DEV_DRIVER(hantek_6xxx_driver_info);