src/hardware/ikalogic-scanalogic2/protocol.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 Marc Schink <sigrok-dev@marcschink.de>
   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 extern struct sr_dev_driver ikalogic_scanalogic2_driver_info;
  24
  25 extern uint64_t sl2_samplerates[NUM_SAMPLERATES];
  26
  27 static void stop_acquisition(struct sr_dev_inst *sdi)
  28 {
  29         struct drv_context *drvc = sdi->driver->context;
  30         struct dev_context *devc;
  31         struct sr_datafeed_packet packet;
  32
  33         devc = sdi->priv;
  34
  35         /* Remove USB file descriptors from polling. */
  36         usb_source_remove(sdi->session, drvc->sr_ctx);
  37
  38         packet.type = SR_DF_END;
  39         sr_session_send(devc->cb_data, &packet);
  40
  41         sdi->status = SR_ST_ACTIVE;
  42 }
  43
  44 static void abort_acquisition(struct sr_dev_inst *sdi)
  45 {
  46         struct drv_context *drvc = sdi->driver->context;
  47         struct dev_context *devc;
  48         struct sr_datafeed_packet packet;
  49
  50         devc = sdi->priv;
  51
  52         /* Remove USB file descriptors from polling. */
  53         usb_source_remove(sdi->session, drvc->sr_ctx);
  54
  55         packet.type = SR_DF_END;
  56         sr_session_send(devc->cb_data, &packet);
  57
  58         sdi->driver->dev_close(sdi);
  59 }
  60
  61 static void buffer_sample_data(const struct sr_dev_inst *sdi)
  62 {
  63         struct dev_context *devc;
  64         unsigned int offset, packet_length;
  65
  66         devc = sdi->priv;
  67
  68         if (devc->channels[devc->channel]->enabled) {
  69                 offset = devc->sample_packet * PACKET_NUM_SAMPLE_BYTES;
  70
  71                 /*
  72                  * Determine the packet length to ensure that the last packet
  73                  * will not exceed the buffer size.
  74                  */
  75                 packet_length = MIN(PACKET_NUM_SAMPLE_BYTES,
  76                         MAX_DEV_SAMPLE_BYTES - offset);
  77
  78                 /*
  79                  * Skip the first 4 bytes of the source buffer because they
  80                  * contain channel and packet information only.
  81                  */
  82                 memcpy(devc->sample_buffer[devc->channel] + offset,
  83                         devc->xfer_data_in + 4, packet_length);
  84         }
  85 }
  86
  87 static void process_sample_data(const struct sr_dev_inst *sdi)
  88 {
  89         struct dev_context *devc;
  90         struct sr_datafeed_packet packet;
  91         struct sr_datafeed_logic logic;
  92         uint8_t i, j, tmp, buffer[PACKET_NUM_SAMPLES], *ptr[NUM_CHANNELS];
  93         uint16_t offset, n = 0;
  94         int8_t k;
  95
  96         devc = sdi->priv;
  97         offset = devc->sample_packet * PACKET_NUM_SAMPLE_BYTES;
  98
  99         /*
 100          * Array of pointers to the sample data of all channels up to the last
 101          * enabled one for an uniform access to them. Note that the currently
 102          * received samples always belong to the last enabled channel.
 103          */
 104         for (i = 0; i < devc->num_enabled_channels - 1; i++)
 105                 ptr[i] = devc->sample_buffer[devc->channel_map[i]] + offset;
 106
 107         /*
 108          * Skip the first 4 bytes of the buffer because they contain channel
 109          * and packet information only.
 110          */
 111         ptr[i] = devc->xfer_data_in + 4;
 112
 113         for (i = 0; i < PACKET_NUM_SAMPLE_BYTES; i++) {
 114                 /* Stop processing if all requested samples are processed. */
 115                 if (devc->samples_processed == devc->limit_samples)
 116                         break;
 117
 118                 k = 7;
 119
 120                 if (devc->samples_processed == 0) {
 121                         /*
 122                          * Adjust the position of the first sample to be
 123                          * processed because possibly more samples than
 124                          * necessary might have been acquired. This is because
 125                          * the number of acquired samples is always rounded up
 126                          * to a multiple of 8.
 127                          */
 128                         k = k - (devc->pre_trigger_bytes * 8) +
 129                                 devc->pre_trigger_samples;
 130
 131                         sr_dbg("Start processing at sample: %d.", 7 - k);
 132
 133                         /*
 134                          * Send the trigger before the first sample is
 135                          * processed if no pre trigger samples were calculated
 136                          * through the capture ratio.
 137                          */
 138                         if (devc->trigger_type != TRIGGER_TYPE_NONE &&
 139                                         devc->pre_trigger_samples == 0) {
 140                                 packet.type = SR_DF_TRIGGER;
 141                                 sr_session_send(devc->cb_data, &packet);
 142                         }
 143                 }
 144
 145                 for (; k >= 0; k--) {
 146                         /*
 147                          * Stop processing if all requested samples are
 148                          * processed.
 149                          */
 150                         if (devc->samples_processed == devc->limit_samples)
 151                                 break;
 152
 153                         buffer[n] = 0;
 154
 155                         /*
 156                          * Extract the current sample for each enabled channel
 157                          * and store them in the buffer.
 158                          */
 159                         for (j = 0; j < devc->num_enabled_channels; j++) {
 160                                 tmp = (ptr[j][i] & (1 << k)) >> k;
 161                                 buffer[n] |= tmp << devc->channel_map[j];
 162                         }
 163
 164                         n++;
 165                         devc->samples_processed++;
 166
 167                         /*
 168                          * Send all processed samples and the trigger if the
 169                          * number of processed samples reaches the calculated
 170                          * number of pre trigger samples.
 171                          */
 172                         if (devc->samples_processed == devc->pre_trigger_samples &&
 173                                         devc->trigger_type != TRIGGER_TYPE_NONE) {
 174                                 packet.type = SR_DF_LOGIC;
 175                                 packet.payload = &logic;
 176                                 logic.length = n;
 177                                 logic.unitsize = 1;
 178                                 logic.data = buffer;
 179                                 sr_session_send(devc->cb_data, &packet);
 180
 181                                 packet.type = SR_DF_TRIGGER;
 182                                 sr_session_send(devc->cb_data, &packet);
 183
 184                                 n = 0;
 185                         }
 186                 }
 187         }
 188
 189         if (n > 0) {
 190                 packet.type = SR_DF_LOGIC;
 191                 packet.payload = &logic;
 192                 logic.length = n;
 193                 logic.unitsize = 1;
 194                 logic.data = buffer;
 195                 sr_session_send(devc->cb_data, &packet);
 196         }
 197 }
 198
 199 SR_PRIV int ikalogic_scanalogic2_receive_data(int fd, int revents, void *cb_data)
 200 {
 201         struct sr_dev_inst *sdi;
 202         struct sr_dev_driver *di;
 203         struct dev_context *devc;
 204         struct drv_context *drvc;
 205         struct timeval tv;
 206         int64_t current_time, time_elapsed;
 207         int ret = 0;
 208
 209         (void)fd;
 210         (void)revents;
 211
 212         if (!(sdi = cb_data))
 213                 return TRUE;
 214
 215         if (!(devc = sdi->priv))
 216                 return TRUE;
 217
 218         di = sdi->driver;
 219         drvc = di->context;
 220         current_time = g_get_monotonic_time();
 221
 222         if (devc->state == STATE_WAIT_DATA_READY &&
 223                         !devc->wait_data_ready_locked) {
 224                 time_elapsed = current_time - devc->wait_data_ready_time;
 225
 226                 /*
 227                  * Check here for stopping in addition to the transfer
 228                  * callback functions to avoid waiting until the
 229                  * WAIT_DATA_READY_INTERVAL has expired.
 230                  */
 231                 if (sdi->status == SR_ST_STOPPING) {
 232                         if (!devc->stopping_in_progress) {
 233                                 devc->next_state = STATE_RESET_AND_IDLE;
 234                                 devc->stopping_in_progress = TRUE;
 235                                 ret = libusb_submit_transfer(devc->xfer_in);
 236                         }
 237                 } else if (time_elapsed >= WAIT_DATA_READY_INTERVAL) {
 238                         devc->wait_data_ready_locked = TRUE;
 239                         ret = libusb_submit_transfer(devc->xfer_in);
 240                 }
 241         }
 242
 243         if (ret != 0) {
 244                 sr_err("Submit transfer failed: %s.", libusb_error_name(ret));
 245                 abort_acquisition(sdi);
 246                 return TRUE;
 247         }
 248
 249         tv.tv_sec = 0;
 250         tv.tv_usec = 0;
 251
 252         libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx, &tv,
 253                 NULL);
 254
 255         /* Check if an error occurred on a transfer. */
 256         if (devc->transfer_error)
 257                 abort_acquisition(sdi);
 258
 259         return TRUE;
 260 }
 261
 262 SR_PRIV void LIBUSB_CALL sl2_receive_transfer_in( struct libusb_transfer *transfer)
 263 {
 264         struct sr_dev_inst *sdi;
 265         struct dev_context *devc;
 266         uint8_t last_channel;
 267         int ret = 0;
 268
 269         sdi = transfer->user_data;
 270         devc = sdi->priv;
 271
 272         if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
 273                 sr_err("Transfer to device failed: %s.",
 274                         libusb_error_name(transfer->status));
 275                 devc->transfer_error = TRUE;
 276                 return;
 277         }
 278
 279         if (sdi->status == SR_ST_STOPPING && !devc->stopping_in_progress) {
 280                 devc->next_state = STATE_RESET_AND_IDLE;
 281                 devc->stopping_in_progress = TRUE;
 282
 283                 if (libusb_submit_transfer(devc->xfer_in) != 0) {
 284                         sr_err("Submit transfer failed: %s.",
 285                                 libusb_error_name(ret));
 286                         devc->transfer_error = TRUE;
 287                 }
 288
 289                 return;
 290         }
 291
 292         if (devc->state != devc->next_state)
 293                 sr_spew("State changed from %i to %i.",
 294                         devc->state, devc->next_state);
 295         devc->state = devc->next_state;
 296
 297         if (devc->state == STATE_WAIT_DATA_READY) {
 298                 /* Check if the received data are a valid device status. */
 299                 if (devc->xfer_data_in[0] == 0x05) {
 300                         if (devc->xfer_data_in[1] == STATUS_WAITING_FOR_TRIGGER)
 301                                 sr_dbg("Waiting for trigger.");
 302                         else if (devc->xfer_data_in[1] == STATUS_SAMPLING)
 303                                 sr_dbg("Sampling in progress.");
 304                 }
 305
 306                 /*
 307                  * Check if the received data are a valid device status and the
 308                  * sample data are ready.
 309                  */
 310                 if (devc->xfer_data_in[0] == 0x05 &&
 311                                 devc->xfer_data_in[1] == STATUS_DATA_READY) {
 312                         devc->next_state = STATE_RECEIVE_DATA;
 313                         ret = libusb_submit_transfer(transfer);
 314                 } else {
 315                         devc->wait_data_ready_locked = FALSE;
 316                         devc->wait_data_ready_time = g_get_monotonic_time();
 317                 }
 318         } else if (devc->state == STATE_RECEIVE_DATA) {
 319                 last_channel = devc->channel_map[devc->num_enabled_channels - 1];
 320
 321                 if (devc->channel < last_channel) {
 322                         buffer_sample_data(sdi);
 323                 } else if (devc->channel == last_channel) {
 324                         process_sample_data(sdi);
 325                 } else {
 326                         /*
 327                          * Stop acquisition because all samples of enabled
 328                          * channels are processed.
 329                          */
 330                         devc->next_state = STATE_RESET_AND_IDLE;
 331                 }
 332
 333                 devc->sample_packet++;
 334                 devc->sample_packet %= devc->num_sample_packets;
 335
 336                 if (devc->sample_packet == 0)
 337                         devc->channel++;
 338
 339                 ret = libusb_submit_transfer(transfer);
 340         } else if (devc->state == STATE_RESET_AND_IDLE) {
 341                 /* Check if the received data are a valid device status. */
 342                 if (devc->xfer_data_in[0] == 0x05) {
 343                         if (devc->xfer_data_in[1] == STATUS_DEVICE_READY) {
 344                                 devc->next_state = STATE_IDLE;
 345                                 devc->xfer_data_out[0] = CMD_IDLE;
 346                         } else {
 347                                 devc->next_state = STATE_WAIT_DEVICE_READY;
 348                                 devc->xfer_data_out[0] = CMD_RESET;
 349                         }
 350
 351                         ret = libusb_submit_transfer(devc->xfer_out);
 352                 } else {
 353                         /*
 354                          * The received device status is invalid which
 355                          * indicates that the device is not ready to accept
 356                          * commands. Request a new device status until a valid
 357                          * device status is received.
 358                          */
 359                         ret = libusb_submit_transfer(transfer);
 360                 }
 361         } else if (devc->state == STATE_WAIT_DEVICE_READY) {
 362                 /* Check if the received data are a valid device status. */
 363                 if (devc->xfer_data_in[0] == 0x05) {
 364                         if (devc->xfer_data_in[1] == STATUS_DEVICE_READY) {
 365                                 devc->next_state = STATE_IDLE;
 366                                 devc->xfer_data_out[0] = CMD_IDLE;
 367                         } else {
 368                                 /*
 369                                  * The received device status is valid but the
 370                                  * device is not ready. Probably the device did
 371                                  * not recognize the last reset. Reset the
 372                                  * device again.
 373                                  */
 374                                 devc->xfer_data_out[0] = CMD_RESET;
 375                         }
 376
 377                         ret = libusb_submit_transfer(devc->xfer_out);
 378                 } else {
 379                         /*
 380                          * The device is not ready and therefore not able to
 381                          * change to the idle state. Request a new device
 382                          * status until the device is ready.
 383                          */
 384                         ret = libusb_submit_transfer(transfer);
 385                 }
 386         }
 387
 388         if (ret != 0) {
 389                 sr_err("Submit transfer failed: %s.", libusb_error_name(ret));
 390                 devc->transfer_error = TRUE;
 391         }
 392 }
 393
 394 SR_PRIV void LIBUSB_CALL sl2_receive_transfer_out( struct libusb_transfer *transfer)
 395 {
 396         struct sr_dev_inst *sdi;
 397         struct dev_context *devc;
 398         int ret = 0;
 399
 400         sdi = transfer->user_data;
 401         devc = sdi->priv;
 402
 403         if (transfer->status != LIBUSB_TRANSFER_COMPLETED) {
 404                 sr_err("Transfer to device failed: %s.",
 405                         libusb_error_name(transfer->status));
 406                 devc->transfer_error = TRUE;
 407                 return;
 408         }
 409
 410         if (sdi->status == SR_ST_STOPPING && !devc->stopping_in_progress) {
 411                 devc->next_state = STATE_RESET_AND_IDLE;
 412                 devc->stopping_in_progress = TRUE;
 413
 414                 if (libusb_submit_transfer(devc->xfer_in) != 0) {
 415                         sr_err("Submit transfer failed: %s.",
 416                                 libusb_error_name(ret));
 417
 418                         devc->transfer_error = TRUE;
 419                 }
 420
 421                 return;
 422         }
 423
 424         if (devc->state != devc->next_state)
 425                 sr_spew("State changed from %i to %i.",
 426                         devc->state, devc->next_state);
 427         devc->state = devc->next_state;
 428
 429         if (devc->state == STATE_IDLE) {
 430                 stop_acquisition(sdi);
 431         } else if (devc->state == STATE_SAMPLE) {
 432                 devc->next_state = STATE_WAIT_DATA_READY;
 433                 ret = libusb_submit_transfer(devc->xfer_in);
 434         } else if (devc->state == STATE_WAIT_DEVICE_READY) {
 435                 ret = libusb_submit_transfer(devc->xfer_in);
 436         }
 437
 438         if (ret != 0) {
 439                 sr_err("Submit transfer failed: %s.", libusb_error_name(ret));
 440                 devc->transfer_error = TRUE;
 441         }
 442 }
 443
 444 SR_PRIV int sl2_set_samplerate(const struct sr_dev_inst *sdi,
 445                 uint64_t samplerate)
 446 {
 447         struct dev_context *devc;
 448         unsigned int i;
 449
 450         devc = sdi->priv;
 451
 452         for (i = 0; i < NUM_SAMPLERATES; i++) {
 453                 if (sl2_samplerates[i] == samplerate) {
 454                         devc->samplerate = samplerate;
 455                         devc->samplerate_id = NUM_SAMPLERATES - i - 1;
 456                         return SR_OK;
 457                 }
 458         }
 459
 460         return SR_ERR_ARG;
 461 }
 462
 463 SR_PRIV int sl2_set_limit_samples(const struct sr_dev_inst *sdi,
 464                                   uint64_t limit_samples)
 465 {
 466         struct dev_context *devc;
 467
 468         devc = sdi->priv;
 469
 470         if (limit_samples == 0) {
 471                 sr_err("Invalid number of limit samples: %" PRIu64 ".",
 472                         limit_samples);
 473                 return SR_ERR_ARG;
 474         }
 475
 476         if (limit_samples > MAX_SAMPLES)
 477                 limit_samples = MAX_SAMPLES;
 478
 479         sr_dbg("Limit samples set to %" PRIu64 ".", limit_samples);
 480
 481         devc->limit_samples = limit_samples;
 482
 483         return SR_OK;
 484 }
 485
 486 SR_PRIV int sl2_convert_trigger(const struct sr_dev_inst *sdi)
 487 {
 488         struct dev_context *devc;
 489         struct sr_trigger *trigger;
 490         struct sr_trigger_stage *stage;
 491         struct sr_trigger_match *match;
 492         const GSList *l, *m;
 493         int num_triggers_anyedge;
 494
 495         devc = sdi->priv;
 496
 497         /* Disable the trigger by default. */
 498         devc->trigger_channel = TRIGGER_CHANNEL_0;
 499         devc->trigger_type = TRIGGER_TYPE_NONE;
 500
 501         if (!(trigger = sr_session_trigger_get(sdi->session)))
 502                 return SR_OK;
 503
 504         if (g_slist_length(trigger->stages) > 1) {
 505                 sr_err("This device only supports 1 trigger stage.");
 506                 return SR_ERR;
 507         }
 508
 509         num_triggers_anyedge = 0;
 510         for (l = trigger->stages; l; l = l->next) {
 511                 stage = l->data;
 512                 for (m = stage->matches; m; m = m->next) {
 513                         match = m->data;
 514                         if (!match->channel->enabled)
 515                                 /* Ignore disabled channels with a trigger. */
 516                                 continue;
 517                         devc->trigger_channel = match->channel->index + 1;
 518                         switch (match->match) {
 519                         case SR_TRIGGER_RISING:
 520                                 devc->trigger_type = TRIGGER_TYPE_POSEDGE;
 521                                 break;
 522                         case SR_TRIGGER_FALLING:
 523                                 devc->trigger_type = TRIGGER_TYPE_NEGEDGE;
 524                                 break;
 525                         case SR_TRIGGER_EDGE:
 526                                 devc->trigger_type = TRIGGER_TYPE_ANYEDGE;
 527                                 num_triggers_anyedge++;
 528                                 break;
 529                         }
 530                 }
 531         }
 532
 533         /*
 534          * Set trigger to any edge on all channels if the trigger for each
 535          * channel is set to any edge.
 536          */
 537         if (num_triggers_anyedge == NUM_CHANNELS) {
 538                 devc->trigger_channel = TRIGGER_CHANNEL_ALL;
 539                 devc->trigger_type = TRIGGER_TYPE_ANYEDGE;
 540         }
 541
 542         sr_dbg("Trigger set to channel 0x%02x and type 0x%02x.",
 543                 devc->trigger_channel, devc->trigger_type);
 544
 545         return SR_OK;
 546 }
 547
 548 SR_PRIV int sl2_set_capture_ratio(const struct sr_dev_inst *sdi,
 549                                   uint64_t capture_ratio)
 550 {
 551         struct dev_context *devc;
 552
 553         devc = sdi->priv;
 554
 555         if (capture_ratio > 100) {
 556                 sr_err("Invalid capture ratio: %" PRIu64 " %%.", capture_ratio);
 557                 return SR_ERR_ARG;
 558         }
 559
 560         sr_info("Capture ratio set to %" PRIu64 " %%.", capture_ratio);
 561
 562         devc->capture_ratio = capture_ratio;
 563
 564         return SR_OK;
 565 }
 566
 567 SR_PRIV int sl2_set_after_trigger_delay(const struct sr_dev_inst *sdi,
 568                                         uint64_t after_trigger_delay)
 569 {
 570         struct dev_context *devc;
 571
 572         devc = sdi->priv;
 573
 574         if (after_trigger_delay > MAX_AFTER_TRIGGER_DELAY) {
 575                 sr_err("Invalid after trigger delay: %" PRIu64 " ms.",
 576                         after_trigger_delay);
 577                 return SR_ERR_ARG;
 578         }
 579
 580         sr_info("After trigger delay set to %" PRIu64 " ms.",
 581                 after_trigger_delay);
 582
 583         devc->after_trigger_delay = after_trigger_delay;
 584
 585         return SR_OK;
 586 }
 587
 588 SR_PRIV void sl2_calculate_trigger_samples(const struct sr_dev_inst *sdi)
 589 {
 590         struct dev_context *devc;
 591         uint64_t pre_trigger_samples, post_trigger_samples;
 592         uint16_t pre_trigger_bytes, post_trigger_bytes;
 593         uint8_t cr;
 594
 595         devc = sdi->priv;
 596         cr = devc->capture_ratio;
 597
 598         /* Ignore the capture ratio if no trigger is enabled. */
 599         if (devc->trigger_type == TRIGGER_TYPE_NONE)
 600                 cr = 0;
 601
 602         pre_trigger_samples = (devc->limit_samples * cr) / 100;
 603         post_trigger_samples = (devc->limit_samples * (100 - cr)) / 100;
 604
 605         /*
 606          * Increase the number of post trigger samples by one to compensate the
 607          * possible loss of a sample through integer rounding.
 608          */
 609         if (pre_trigger_samples + post_trigger_samples != devc->limit_samples)
 610                 post_trigger_samples++;
 611
 612         /*
 613          * The device requires the number of samples in multiples of 8 which
 614          * will also be called sample bytes in the following.
 615          */
 616         pre_trigger_bytes = pre_trigger_samples / 8;
 617         post_trigger_bytes = post_trigger_samples / 8;
 618
 619         /*
 620          * Round up the number of sample bytes to ensure that at least the
 621          * requested number of samples will be acquired. Note that due to this
 622          * rounding the buffer to store these sample bytes needs to be at least
 623          * one sample byte larger than the minimal number of sample bytes
 624          * needed to store the requested samples.
 625          */
 626         if (pre_trigger_samples % 8 != 0)
 627                 pre_trigger_bytes++;
 628
 629         if (post_trigger_samples % 8 != 0)
 630                 post_trigger_bytes++;
 631
 632         sr_info("Pre trigger samples: %" PRIu64 ".", pre_trigger_samples);
 633         sr_info("Post trigger samples: %" PRIu64 ".", post_trigger_samples);
 634         sr_dbg("Pre trigger sample bytes: %" PRIu16 ".", pre_trigger_bytes);
 635         sr_dbg("Post trigger sample bytes: %" PRIu16 ".", post_trigger_bytes);
 636
 637         devc->pre_trigger_samples = pre_trigger_samples;
 638         devc->pre_trigger_bytes = pre_trigger_bytes;
 639         devc->post_trigger_bytes = post_trigger_bytes;
 640 }
 641
 642 SR_PRIV int sl2_get_device_info(struct sr_usb_dev_inst usb,
 643                 struct device_info *dev_info)
 644 {
 645         struct drv_context *drvc;
 646         uint8_t buffer[PACKET_LENGTH];
 647         int ret;
 648
 649         drvc = ikalogic_scanalogic2_driver_info.context;
 650
 651         if (!dev_info)
 652                 return SR_ERR_ARG;
 653
 654         if (sr_usb_open(drvc->sr_ctx->libusb_ctx, &usb) != SR_OK)
 655                 return SR_ERR;
 656
 657         /*
 658          * Determine if a kernel driver is active on this interface and, if so,
 659          * detach it.
 660          */
 661         if (libusb_kernel_driver_active(usb.devhdl, USB_INTERFACE) == 1) {
 662                 ret = libusb_detach_kernel_driver(usb.devhdl,
 663                         USB_INTERFACE);
 664
 665                 if (ret < 0) {
 666                         sr_err("Failed to detach kernel driver: %s.",
 667                                 libusb_error_name(ret));
 668                         libusb_close(usb.devhdl);
 669                         return SR_ERR;
 670                 }
 671         }
 672
 673         ret = libusb_claim_interface(usb.devhdl, USB_INTERFACE);
 674
 675         if (ret) {
 676                 sr_err("Failed to claim interface: %s.",
 677                         libusb_error_name(ret));
 678                 libusb_close(usb.devhdl);
 679                 return SR_ERR;
 680         }
 681
 682         memset(buffer, 0, sizeof(buffer));
 683
 684         /*
 685          * Reset the device to ensure it is in a proper state to request the
 686          * device information.
 687          */
 688         buffer[0] = CMD_RESET;
 689         if ((ret = sl2_transfer_out(usb.devhdl, buffer)) != PACKET_LENGTH) {
 690                 sr_err("Resetting of device failed: %s.",
 691                         libusb_error_name(ret));
 692                 libusb_release_interface(usb.devhdl, USB_INTERFACE);
 693                 libusb_close(usb.devhdl);
 694                 return SR_ERR;
 695         }
 696
 697         buffer[0] = CMD_INFO;
 698         if ((ret = sl2_transfer_out(usb.devhdl, buffer)) != PACKET_LENGTH) {
 699                 sr_err("Requesting of device information failed: %s.",
 700                         libusb_error_name(ret));
 701                 libusb_release_interface(usb.devhdl, USB_INTERFACE);
 702                 libusb_close(usb.devhdl);
 703                 return SR_ERR;
 704         }
 705
 706         if ((ret = sl2_transfer_in(usb.devhdl, buffer)) != PACKET_LENGTH) {
 707                 sr_err("Receiving of device information failed: %s.",
 708                         libusb_error_name(ret));
 709                 libusb_release_interface(usb.devhdl, USB_INTERFACE);
 710                 libusb_close(usb.devhdl);
 711                 return SR_ERR;
 712         }
 713
 714         memcpy(&(dev_info->serial), buffer + 1, sizeof(uint32_t));
 715         dev_info->serial = GUINT32_FROM_LE(dev_info->serial);
 716
 717         dev_info->fw_ver_major = buffer[5];
 718         dev_info->fw_ver_minor = buffer[6];
 719
 720         buffer[0] = CMD_RESET;
 721         if ((ret = sl2_transfer_out(usb.devhdl, buffer)) != PACKET_LENGTH) {
 722                 sr_err("Device reset failed: %s.", libusb_error_name(ret));
 723                 libusb_release_interface(usb.devhdl, USB_INTERFACE);
 724                 libusb_close(usb.devhdl);
 725                 return SR_ERR;
 726         }
 727
 728         /*
 729          * Set the device to idle state. If the device is not in idle state it
 730          * possibly will reset itself after a few seconds without being used
 731          * and thereby close the connection.
 732          */
 733         buffer[0] = CMD_IDLE;
 734         if ((ret = sl2_transfer_out(usb.devhdl, buffer)) != PACKET_LENGTH) {
 735                 sr_err("Failed to set device in idle state: %s.",
 736                         libusb_error_name(ret));
 737                 libusb_release_interface(usb.devhdl, USB_INTERFACE);
 738                 libusb_close(usb.devhdl);
 739                 return SR_ERR;
 740         }
 741
 742         ret = libusb_release_interface(usb.devhdl, USB_INTERFACE);
 743
 744         if (ret < 0) {
 745                 sr_err("Failed to release interface: %s.",
 746                         libusb_error_name(ret));
 747                 libusb_close(usb.devhdl);
 748                 return SR_ERR;
 749         }
 750
 751         libusb_close(usb.devhdl);
 752
 753         return SR_OK;
 754 }
 755
 756 SR_PRIV int sl2_transfer_in(libusb_device_handle *dev_handle, uint8_t *data)
 757 {
 758         return libusb_control_transfer(dev_handle, USB_REQUEST_TYPE_IN,
 759                 USB_HID_GET_REPORT, USB_HID_REPORT_TYPE_FEATURE, USB_INTERFACE,
 760                 (unsigned char *)data, PACKET_LENGTH, USB_TIMEOUT_MS);
 761 }
 762
 763 SR_PRIV int sl2_transfer_out(libusb_device_handle *dev_handle, uint8_t *data)
 764 {
 765         return libusb_control_transfer(dev_handle, USB_REQUEST_TYPE_OUT,
 766                 USB_HID_SET_REPORT, USB_HID_REPORT_TYPE_FEATURE, USB_INTERFACE,
 767                 (unsigned char *)data, PACKET_LENGTH, USB_TIMEOUT_MS);
 768 }