]> sigrok.org Git - libsigrok.git/blob - src/hardware/lascar-el-usb/protocol.c
1437773c502cfbbc30ddd9e1c8becec4f5d25981
[libsigrok.git] / src / hardware / lascar-el-usb / protocol.c
1 /*
2  * This file is part of the libsigrok 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 <config.h>
21 #include <stdlib.h>
22 #include <sys/time.h>
23 #include <string.h>
24 #include <math.h>
25 #include <glib.h>
26 #include <libsigrok/libsigrok.h>
27 #include "libsigrok-internal.h"
28 #include "protocol.h"
29
30 extern struct sr_dev_driver lascar_el_usb_driver_info;
31 struct sr_dev_driver *di = &lascar_el_usb_driver_info;
32
33 static const struct elusb_profile profiles[] = {
34         { 1, "EL-USB-1", LOG_UNSUPPORTED },
35         { 2, "EL-USB-1", LOG_UNSUPPORTED },
36         { 3, "EL-USB-2", LOG_TEMP_RH },
37         { 4, "EL-USB-3", LOG_UNSUPPORTED },
38         { 5, "EL-USB-4", LOG_UNSUPPORTED },
39         { 6, "EL-USB-3", LOG_UNSUPPORTED },
40         { 7, "EL-USB-4", LOG_UNSUPPORTED },
41         { 8, "EL-USB-LITE", LOG_UNSUPPORTED },
42         { 9, "EL-USB-CO", LOG_CO },
43         { 10, "EL-USB-TC", LOG_UNSUPPORTED },
44         { 11, "EL-USB-CO300", LOG_CO },
45         { 12, "EL-USB-2-LCD", LOG_TEMP_RH },
46         { 13, "EL-USB-2+", LOG_TEMP_RH },
47         { 14, "EL-USB-1-PRO", LOG_UNSUPPORTED },
48         { 15, "EL-USB-TC-LCD", LOG_UNSUPPORTED },
49         { 16, "EL-USB-2-LCD+", LOG_TEMP_RH },
50         { 17, "EL-USB-5", LOG_UNSUPPORTED },
51         { 18, "EL-USB-1-RCG", LOG_UNSUPPORTED },
52         { 19, "EL-USB-1-LCD", LOG_UNSUPPORTED },
53         { 20, "EL-OEM-3", LOG_UNSUPPORTED },
54         { 21, "EL-USB-1-LCD", LOG_UNSUPPORTED },
55         { 0, NULL, 0 }
56 };
57
58 static libusb_device_handle *lascar_open(struct libusb_device *dev)
59 {
60         libusb_device_handle *dev_hdl;
61         int ret;
62
63         if ((ret = libusb_open(dev, &dev_hdl)) != 0) {
64                 sr_dbg("failed to open device for scan: %s",
65                                 libusb_error_name(ret));
66                 return NULL;
67         }
68
69         /* Some of these fail, but it needs doing -- some sort of mode
70          * setup for the SiLabs F32x. */
71         libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
72                         0x00, 0xffff, 0x00, NULL, 0, 50);
73         libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
74                         0x02, 0x0002, 0x00, NULL, 0, 50);
75         libusb_control_transfer(dev_hdl, LIBUSB_REQUEST_TYPE_VENDOR,
76                         0x02, 0x0001, 0x00, NULL, 0, 50);
77
78         return dev_hdl;
79 }
80
81 static void LIBUSB_CALL mark_xfer(struct libusb_transfer *xfer)
82 {
83
84         xfer->user_data = GINT_TO_POINTER(1);
85
86 }
87
88 SR_PRIV int lascar_get_config(libusb_device_handle *dev_hdl,
89                 unsigned char *configblock, int *configlen)
90 {
91         struct drv_context *drvc;
92         struct libusb_transfer *xfer_in, *xfer_out;
93         struct timeval tv;
94         int64_t start;
95         int buflen;
96         unsigned char cmd[3], buf[MAX_CONFIGBLOCK_SIZE];
97
98         sr_spew("Reading config block.");
99
100         drvc = di->context;
101         *configlen = 0;
102
103         if (!(xfer_in = libusb_alloc_transfer(0)) ||
104                         !(xfer_out = libusb_alloc_transfer(0)))
105                 return SR_ERR;
106
107         /* Flush anything the F321 still has queued. */
108         while (libusb_bulk_transfer(dev_hdl, LASCAR_EP_IN, buf, 256, &buflen,
109                         5) == 0 && buflen > 0)
110                 ;
111
112         /* Keep a read request waiting in the wings, ready to pounce
113          * the moment the device sends something. */
114         libusb_fill_bulk_transfer(xfer_in, dev_hdl, LASCAR_EP_IN,
115                         buf, 256, mark_xfer, 0, BULK_XFER_TIMEOUT);
116         if (libusb_submit_transfer(xfer_in) != 0)
117                 goto cleanup;
118
119         /* Request device configuration structure. */
120         cmd[0] = 0x00;
121         cmd[1] = 0xff;
122         cmd[2] = 0xff;
123         libusb_fill_bulk_transfer(xfer_out, dev_hdl, LASCAR_EP_OUT,
124                         cmd, 3, mark_xfer, 0, 100);
125         if (libusb_submit_transfer(xfer_out) != 0)
126                 goto cleanup;
127
128         tv.tv_sec = 0;
129         tv.tv_usec = 0;
130         start = g_get_monotonic_time();
131         while (!xfer_in->user_data || !xfer_out->user_data) {
132                 if (g_get_monotonic_time() - start > SCAN_TIMEOUT) {
133                         start = 0;
134                         break;
135                 }
136                 g_usleep(SLEEP_US_LONG);
137                 libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
138         }
139         if (!start) {
140                 sr_dbg("no response");
141                 goto cleanup;
142         }
143         if (xfer_in->actual_length != 3) {
144                 sr_dbg("expected 3-byte header, got %d bytes", xfer_in->actual_length);
145                 goto cleanup;
146         }
147
148         /* Got configuration structure header. */
149         sr_spew("Response to config request: 0x%.2x 0x%.2x 0x%.2x ",
150                         buf[0], buf[1], buf[2]);
151         buflen = buf[1] | (buf[2] << 8);
152         if (buf[0] != 0x02 || buflen > MAX_CONFIGBLOCK_SIZE) {
153                 sr_dbg("Invalid response to config request: "
154                                 "0x%.2x 0x%.2x 0x%.2x ", buf[0], buf[1], buf[2]);
155                 libusb_close(dev_hdl);
156                 goto cleanup;
157         }
158
159         /* Get configuration structure. */
160         xfer_in->length = buflen;
161         xfer_in->user_data = 0;
162         if (libusb_submit_transfer(xfer_in) != 0)
163                 goto cleanup;
164         while (!xfer_in->user_data) {
165                 if (g_get_monotonic_time() - start > SCAN_TIMEOUT) {
166                         start = 0;
167                         break;
168                 }
169                 g_usleep(SLEEP_US_LONG);
170                 libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
171         }
172         if (!start) {
173                 sr_dbg("Timeout waiting for configuration structure.");
174                 goto cleanup;
175         }
176         if (xfer_in->actual_length != buflen) {
177                 sr_dbg("expected %d-byte structure, got %d bytes", buflen,
178                                 xfer_in->actual_length);
179                 goto cleanup;
180         }
181
182         memcpy(configblock, buf, buflen);
183         *configlen = buflen;
184
185 cleanup:
186         if (!xfer_in->user_data || !xfer_out->user_data) {
187                 if (!xfer_in->user_data)
188                         libusb_cancel_transfer(xfer_in);
189                 if (!xfer_out->user_data)
190                         libusb_cancel_transfer(xfer_out);
191                 start = g_get_monotonic_time();
192                 while (!xfer_in->user_data || !xfer_out->user_data) {
193                         if (g_get_monotonic_time() - start > EVENTS_TIMEOUT)
194                                 break;
195                         g_usleep(SLEEP_US_SHORT);
196                         libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
197                 }
198         }
199         libusb_free_transfer(xfer_in);
200         libusb_free_transfer(xfer_out);
201
202         return *configlen ? SR_OK : SR_ERR;
203 }
204
205 static int lascar_save_config(libusb_device_handle *dev_hdl,
206                 unsigned char *config, int configlen)
207 {
208         struct drv_context *drvc;
209         struct libusb_transfer *xfer_in, *xfer_out;
210         struct timeval tv;
211         int64_t start;
212         int buflen, ret;
213         unsigned char cmd[3], buf[256];
214
215         sr_spew("Writing config block.");
216
217         drvc = di->context;
218
219         if (!(xfer_in = libusb_alloc_transfer(0)) ||
220                         !(xfer_out = libusb_alloc_transfer(0)))
221                 return SR_ERR;
222
223         /* Flush anything the F321 still has queued. */
224         while (libusb_bulk_transfer(dev_hdl, LASCAR_EP_IN, buf, 256, &buflen,
225                         5) == 0 && buflen > 0)
226                 ;
227         ret = SR_OK;
228
229         /* Keep a read request waiting in the wings, ready to pounce
230          * the moment the device sends something. */
231         libusb_fill_bulk_transfer(xfer_in, dev_hdl, LASCAR_EP_IN,
232                         buf, 256, mark_xfer, 0, BULK_XFER_TIMEOUT);
233         if (libusb_submit_transfer(xfer_in) != 0) {
234                 ret = SR_ERR;
235                 goto cleanup;
236         }
237
238         /* Request device configuration structure. */
239         cmd[0] = 0x01;
240         cmd[1] = configlen & 0xff;
241         cmd[2] = (configlen >> 8) & 0xff;
242         libusb_fill_bulk_transfer(xfer_out, dev_hdl, LASCAR_EP_OUT,
243                         cmd, 3, mark_xfer, 0, 100);
244         if (libusb_submit_transfer(xfer_out) != 0) {
245                 ret = SR_ERR;
246                 goto cleanup;
247         }
248         tv.tv_sec = 0;
249         tv.tv_usec = 0;
250         while (!xfer_out->user_data) {
251                 g_usleep(SLEEP_US_LONG);
252                 libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
253         }
254
255         libusb_fill_bulk_transfer(xfer_out, dev_hdl, LASCAR_EP_OUT,
256                         config, configlen, mark_xfer, 0, 100);
257         if (libusb_submit_transfer(xfer_out) != 0) {
258                 ret = SR_ERR;
259                 goto cleanup;
260         }
261         while (!xfer_in->user_data || !xfer_out->user_data) {
262                 g_usleep(SLEEP_US_LONG);
263                 libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
264         }
265
266         if (xfer_in->actual_length != 1 || buf[0] != 0xff) {
267                 sr_dbg("unexpected response after transfer");
268                 ret = SR_ERR;
269         }
270
271 cleanup:
272         if (!xfer_in->user_data || !xfer_out->user_data) {
273                 if (!xfer_in->user_data)
274                         libusb_cancel_transfer(xfer_in);
275                 if (!xfer_out->user_data)
276                         libusb_cancel_transfer(xfer_out);
277                 start = g_get_monotonic_time();
278                 while (!xfer_in->user_data || !xfer_out->user_data) {
279                         if (g_get_monotonic_time() - start > EVENTS_TIMEOUT)
280                                 break;
281                         g_usleep(SLEEP_US_SHORT);
282                         libusb_handle_events_timeout(drvc->sr_ctx->libusb_ctx, &tv);
283                 }
284         }
285         libusb_free_transfer(xfer_in);
286         libusb_free_transfer(xfer_out);
287
288         return ret;
289 }
290
291 static struct sr_dev_inst *lascar_identify(unsigned char *config)
292 {
293         struct dev_context *devc;
294         const struct elusb_profile *profile;
295         struct sr_dev_inst *sdi;
296         int modelid, i;
297         char firmware[5];
298
299         modelid = config[0];
300         sdi = NULL;
301         if (modelid) {
302                 profile = NULL;
303                 for (i = 0; profiles[i].modelid; i++) {
304                         if (profiles[i].modelid == modelid) {
305                                 profile = &profiles[i];
306                                 break;
307                         }
308                 }
309                 if (!profile) {
310                         sr_dbg("unknown EL-USB modelid %d", modelid);
311                         return NULL;
312                 }
313
314                 i = config[52] | (config[53] << 8);
315                 memcpy(firmware, config + 0x30, 4);
316                 firmware[4] = '\0';
317                 sr_dbg("found %s with firmware version %s serial %d",
318                                 profile->modelname, firmware, i);
319
320                 if (profile->logformat == LOG_UNSUPPORTED) {
321                         sr_dbg("unsupported EL-USB logformat for %s", profile->modelname);
322                         return NULL;
323                 }
324
325                 sdi = g_malloc0(sizeof(struct sr_dev_inst));
326                 sdi->status = SR_ST_INACTIVE;
327                 sdi->vendor = g_strdup(LASCAR_VENDOR);
328                 sdi->model = g_strdup(profile->modelname);
329                 sdi->version = g_strdup(firmware);
330                 sdi->driver = di;
331
332                 if (profile->logformat == LOG_TEMP_RH) {
333                         /* Model this as two channels: temperature and humidity. */
334                         sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "Temp");
335                         sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "Hum");
336                 } else if (profile->logformat == LOG_CO) {
337                         sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "CO");
338                 } else {
339                         sr_channel_new(sdi, 0, SR_CHANNEL_ANALOG, TRUE, "P1");
340                 }
341
342                 devc = g_malloc0(sizeof(struct dev_context));
343                 sdi->priv = devc;
344                 devc->profile = profile;
345         }
346
347         return sdi;
348 }
349
350 SR_PRIV struct sr_dev_inst *lascar_scan(int bus, int address)
351 {
352         struct drv_context *drvc;
353         struct sr_dev_inst *sdi;
354         struct libusb_device **devlist;
355         struct libusb_device_descriptor des;
356         libusb_device_handle *dev_hdl;
357         int dummy, ret, i;
358         unsigned char config[MAX_CONFIGBLOCK_SIZE];
359
360         drvc = di->context;
361         sdi = NULL;
362
363         libusb_get_device_list(drvc->sr_ctx->libusb_ctx, &devlist);
364         for (i = 0; devlist[i]; i++) {
365                 if ((ret = libusb_get_device_descriptor(devlist[i], &des))) {
366                         sr_err("Failed to get device descriptor: %d.", ret);
367                         continue;
368                 }
369
370                 if (libusb_get_bus_number(devlist[i]) != bus ||
371                                 libusb_get_device_address(devlist[i]) != address)
372                         continue;
373
374                 if (!(dev_hdl = lascar_open(devlist[i])))
375                         continue;
376
377                 if (lascar_get_config(dev_hdl, config, &dummy) != SR_OK)
378                         continue;
379
380                 libusb_close(dev_hdl);
381                 sdi = lascar_identify(config);
382         }
383
384         return sdi;
385 }
386
387 static void lascar_el_usb_dispatch(struct sr_dev_inst *sdi, unsigned char *buf,
388                 int buflen)
389 {
390         struct dev_context *devc;
391         struct sr_datafeed_packet packet;
392         struct sr_datafeed_analog analog;
393         struct sr_channel *ch;
394         float *temp, *rh;
395         uint16_t s;
396         int samples, samples_left, i, j;
397
398         devc = sdi->priv;
399
400         samples = buflen / devc->sample_size;
401         samples_left = devc->logged_samples - devc->rcvd_samples;
402         if (samples_left < samples)
403                 samples = samples_left;
404         switch (devc->profile->logformat) {
405         case LOG_TEMP_RH:
406                 packet.type = SR_DF_ANALOG;
407                 packet.payload = &analog;
408                 analog.mqflags = 0;
409                 if (!(temp = g_try_malloc(sizeof(float) * samples)))
410                         break;
411                 if (!(rh = g_try_malloc(sizeof(float) * samples)))
412                         break;
413                 for (i = 0, j = 0; i < samples; i++) {
414                         /* Both Celsius and Fahrenheit stored at base -40. */
415                         if (devc->temp_unit == 0)
416                                 /* Celsius is stored in half-degree increments. */
417                                 temp[j] = buf[i * 2] / 2 - 40;
418                         else
419                                 temp[j] = buf[i * 2] - 40;
420
421                         rh[j] = buf[i * 2 + 1] / 2;
422
423                         if (temp[j] == 0.0 && rh[j] == 0.0)
424                                 /* Skip invalid measurement. */
425                                 continue;
426                         j++;
427                 }
428                 analog.num_samples = j;
429
430                 ch = sdi->channels->data;
431                 if (ch->enabled) {
432                         analog.channels = g_slist_append(NULL, ch);
433                         analog.mq = SR_MQ_TEMPERATURE;
434                         if (devc->temp_unit == 1)
435                                 analog.unit = SR_UNIT_FAHRENHEIT;
436                         else
437                                 analog.unit = SR_UNIT_CELSIUS;
438                         analog.data = temp;
439                         sr_session_send(devc->cb_data, &packet);
440                         g_slist_free(analog.channels);
441                 }
442
443                 ch = sdi->channels->next->data;
444                 if (ch->enabled) {
445                         analog.channels = g_slist_append(NULL, ch);
446                         analog.mq = SR_MQ_RELATIVE_HUMIDITY;
447                         analog.unit = SR_UNIT_PERCENTAGE;
448                         analog.data = rh;
449                         sr_session_send(devc->cb_data, &packet);
450                         g_slist_free(analog.channels);
451                 }
452
453                 g_free(temp);
454                 g_free(rh);
455                 break;
456         case LOG_CO:
457                 packet.type = SR_DF_ANALOG;
458                 packet.payload = &analog;
459                 analog.channels = sdi->channels;
460                 analog.num_samples = samples;
461                 analog.mq = SR_MQ_CARBON_MONOXIDE;
462                 analog.unit = SR_UNIT_CONCENTRATION;
463                 analog.mqflags = 0;
464                 if (!(analog.data = g_try_malloc(sizeof(float) * samples)))
465                         break;
466                 for (i = 0; i < samples; i++) {
467                         s = (buf[i * 2] << 8) | buf[i * 2 + 1];
468                         analog.data[i] = (s * devc->co_high + devc->co_low) / (1000 * 1000);
469                         if (analog.data[i] < 0.0)
470                                 analog.data[i] = 0.0;
471                 }
472                 sr_session_send(devc->cb_data, &packet);
473                 g_free(analog.data);
474                 break;
475         default:
476                 /* How did we even get this far? */
477                 break;
478         }
479         devc->rcvd_samples += samples;
480
481 }
482
483 SR_PRIV int lascar_el_usb_handle_events(int fd, int revents, void *cb_data)
484 {
485         struct drv_context *drvc = di->context;
486         struct sr_datafeed_packet packet;
487         struct sr_dev_inst *sdi;
488         struct timeval tv;
489
490         (void)fd;
491         (void)revents;
492
493         sdi = cb_data;
494
495         if (sdi->status == SR_ST_STOPPING) {
496                 usb_source_remove(sdi->session, drvc->sr_ctx);
497
498                 packet.type = SR_DF_END;
499                 sr_session_send(cb_data, &packet);
500         }
501
502         memset(&tv, 0, sizeof(struct timeval));
503         libusb_handle_events_timeout_completed(drvc->sr_ctx->libusb_ctx, &tv,
504                                                NULL);
505
506         return TRUE;
507 }
508
509 SR_PRIV void LIBUSB_CALL lascar_el_usb_receive_transfer(struct libusb_transfer *transfer)
510 {
511         struct dev_context *devc;
512         struct sr_dev_inst *sdi;
513         int ret;
514         gboolean packet_has_error;
515
516         sdi = transfer->user_data;
517         devc = sdi->priv;
518
519         packet_has_error = FALSE;
520         switch (transfer->status) {
521         case LIBUSB_TRANSFER_NO_DEVICE:
522                 /* USB device was unplugged. */
523                 dev_acquisition_stop(sdi, sdi);
524                 return;
525         case LIBUSB_TRANSFER_COMPLETED:
526         case LIBUSB_TRANSFER_TIMED_OUT: /* We may have received some data though */
527                 break;
528         default:
529                 packet_has_error = TRUE;
530                 break;
531         }
532
533         if (!packet_has_error) {
534                 if (devc->rcvd_samples < devc->logged_samples)
535                         lascar_el_usb_dispatch(sdi, transfer->buffer,
536                                         transfer->actual_length);
537                 devc->rcvd_bytes += transfer->actual_length;
538                 sr_spew("received %d/%d bytes (%d/%d samples)",
539                                 devc->rcvd_bytes, devc->log_size,
540                                 devc->rcvd_samples, devc->logged_samples);
541                 if (devc->rcvd_bytes >= devc->log_size)
542                         dev_acquisition_stop(sdi, sdi);
543         }
544
545         if (sdi->status == SR_ST_ACTIVE) {
546                 /* Send the same request again. */
547                 if ((ret = libusb_submit_transfer(transfer) != 0)) {
548                         sr_err("Unable to resubmit transfer: %s.",
549                                libusb_error_name(ret));
550                         g_free(transfer->buffer);
551                         libusb_free_transfer(transfer);
552                         dev_acquisition_stop(sdi, sdi);
553                 }
554         } else {
555                 /* This was the last transfer we're going to receive, so
556                  * clean up now. */
557                 g_free(transfer->buffer);
558                 libusb_free_transfer(transfer);
559         }
560
561 }
562
563 static int get_flags(unsigned char *configblock)
564 {
565         int flags;
566
567         flags = (configblock[32] | (configblock[33] << 8)) & 0x1fff;
568         sr_spew("Read flags (0x%.4x).", flags);
569
570         return flags;
571 }
572
573 static int set_flags(unsigned char *configblock, int flags)
574 {
575
576         sr_spew("Setting flags to 0x%.4x.", flags);
577         configblock[32] = flags & 0xff;
578         configblock[33] = (flags >> 8) & 0x1f;
579
580         return flags;
581 }
582
583 SR_PRIV int lascar_is_logging(const struct sr_dev_inst *sdi)
584 {
585         struct dev_context *devc;
586         struct sr_usb_dev_inst *usb;
587         int dummy, flags, ret;
588
589         devc = sdi->priv;
590         usb = sdi->conn;
591
592         if (lascar_get_config(usb->devhdl, devc->config, &dummy) != SR_OK)
593                 return -1;
594
595         flags = get_flags(devc->config);
596         if (flags & 0x0100)
597                 ret = 1;
598         else
599                 ret = 0;
600
601         return ret;
602 }
603
604 SR_PRIV int lascar_start_logging(const struct sr_dev_inst *sdi)
605 {
606         struct dev_context *devc;
607         struct sr_usb_dev_inst *usb;
608         int len, flags, ret;
609
610         devc = sdi->priv;
611         usb = sdi->conn;
612
613         if (lascar_get_config(usb->devhdl, devc->config, &len) != SR_OK)
614                 return SR_ERR;
615
616         /* Turn on logging. */
617         flags = get_flags(devc->config);
618         flags |= 0x0100;
619         set_flags(devc->config, flags);
620
621         /* Start logging in 0 seconds. */
622         memset(devc->config + 24, 0, 4);
623
624         ret = lascar_save_config(usb->devhdl, devc->config, len);
625         sr_info("Started internal logging.");
626
627         return ret;
628 }
629
630 SR_PRIV int lascar_stop_logging(const struct sr_dev_inst *sdi)
631 {
632         struct dev_context *devc;
633         struct sr_usb_dev_inst *usb;
634         int len, flags, ret;
635
636         devc = sdi->priv;
637         usb = sdi->conn;
638
639         if (lascar_get_config(usb->devhdl, devc->config, &len) != SR_OK)
640                 return SR_ERR;
641
642         flags = get_flags(devc->config);
643         flags &= ~0x0100;
644         set_flags(devc->config, flags);
645
646         ret = lascar_save_config(usb->devhdl, devc->config, len);
647         sr_info("Stopped internal logging.");
648
649         return ret;
650 }