]> sigrok.org Git - libsigrok.git/blame - hardware/serial-dmm/api.c
projects / libsigrok.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
radioshack-dmm: Separate protocol parser from driver
[libsigrok.git] / hardware / serial-dmm / api.c
CommitLineData
7dc55d93
AG		 1/*
2 * This file is part of the sigrok project.
3 *
4 * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
5 * Copyright (C) 2012 Alexandru Gagniuc <mr.nuke.me@gmail.com>
729b01f9 6 * Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
7dc55d93
AG		 7 *
8 * This program is free software: you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation, either version 3 of the License, or
11 * (at your option) any later version.
12 *
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
17 *
18 * You should have received a copy of the GNU General Public License
19 * along with this program. If not, see <http://www.gnu.org/licenses/>.
20 */
21
22#include <glib.h>
7dc55d93
AG		 23#include <sys/types.h>
24#include <sys/stat.h>
25#include <fcntl.h>
26#include <string.h>
27#include <errno.h>
bbabddbd
UH		 28#include "libsigrok.h"
29#include "libsigrok-internal.h"
30#include "protocol.h"
7dc55d93
AG		 31
32static const int hwopts[] = {
33 SR_HWOPT_CONN,
34 SR_HWOPT_SERIALCOMM,
35 0,
36};
37
38static const int hwcaps[] = {
39 SR_HWCAP_MULTIMETER,
40 SR_HWCAP_LIMIT_SAMPLES,
41 SR_HWCAP_CONTINUOUS,
42 0,
43};
44
45static const char *probe_names[] = {
46 "Probe",
47 NULL,
48};
49
f086b830 50SR_PRIV struct sr_dev_driver digitek_dt4000zc_driver_info;
729b01f9 51SR_PRIV struct sr_dev_driver tekpower_tp4000zc_driver_info;
ce3777ad 52SR_PRIV struct sr_dev_driver metex_me31_driver_info;
f0ac4929 53SR_PRIV struct sr_dev_driver peaktech_3410_driver_info;
5887c9cc 54SR_PRIV struct sr_dev_driver mastech_mas345_driver_info;
6dca2f16 55SR_PRIV struct sr_dev_driver va_va18b_driver_info;
a53da082 56SR_PRIV struct sr_dev_driver metex_m3640d_driver_info;
a376ffea 57SR_PRIV struct sr_dev_driver peaktech_4370_driver_info;
d4bd66a0 58SR_PRIV struct sr_dev_driver pce_pce_dm32_driver_info;
d5ce233f 59SR_PRIV struct sr_dev_driver radioshack_22_168_driver_info;
f086b830 60
ce3777ad
UH		 61static struct sr_dev_driver *di_dt4000zc = &digitek_dt4000zc_driver_info;
62static struct sr_dev_driver *di_tp4000zc = &tekpower_tp4000zc_driver_info;
63static struct sr_dev_driver *di_me31 = &metex_me31_driver_info;
f0ac4929 64static struct sr_dev_driver *di_3410 = &peaktech_3410_driver_info;
5887c9cc 65static struct sr_dev_driver *di_mas345 = &mastech_mas345_driver_info;
6dca2f16 66static struct sr_dev_driver *di_va18b = &va_va18b_driver_info;
a53da082 67static struct sr_dev_driver *di_m3640d = &metex_m3640d_driver_info;
a376ffea 68static struct sr_dev_driver *di_4370 = &peaktech_4370_driver_info;
d4bd66a0 69static struct sr_dev_driver *di_pce_dm32 = &pce_pce_dm32_driver_info;
d5ce233f 70static struct sr_dev_driver *di_22_168 = &radioshack_22_168_driver_info;
729b01f9
UH		 71
72/* After hw_init() this will point to a device-specific entry (see above). */
73static struct sr_dev_driver *di = NULL;
74
75SR_PRIV struct dmm_info dmms[] = {
f086b830 76 {
ce3777ad
UH		 77 "Digitek", "DT4000ZC", "2400/8n1", 2400,
78 FS9721_PACKET_SIZE, NULL,
79 sr_fs9721_packet_valid, sr_fs9721_parse,
f086b830
UH		 80 dmm_details_dt4000zc,
81 },
729b01f9 82 {
ce3777ad
UH		 83 "TekPower", "TP4000ZC", "2400/8n1", 2400,
84 FS9721_PACKET_SIZE, NULL,
85 sr_fs9721_packet_valid, sr_fs9721_parse,
729b01f9
UH		 86 dmm_details_tp4000zc,
87 },
ce3777ad
UH		 88 {
89 "Metex", "ME-31", "600/7n2/rts=0/dtr=1", 600,
90 METEX14_PACKET_SIZE, sr_metex14_packet_request,
91 sr_metex14_packet_valid, sr_metex14_parse,
92 NULL,
93 },
f0ac4929
UH		 94 {
95 "Peaktech", "3410", "600/7n2/rts=0/dtr=1", 600,
96 METEX14_PACKET_SIZE, sr_metex14_packet_request,
97 sr_metex14_packet_valid, sr_metex14_parse,
98 NULL,
99 },
5887c9cc
UH		 100 {
101 "MASTECH", "MAS345", "600/7n2/rts=0/dtr=1", 600,
102 METEX14_PACKET_SIZE, sr_metex14_packet_request,
103 sr_metex14_packet_valid, sr_metex14_parse,
104 NULL,
105 },
6dca2f16
UH		 106 {
107 "V&A", "VA18B", "2400/8n1", 2400,
108 FS9721_PACKET_SIZE, NULL,
109 sr_fs9721_packet_valid, sr_fs9721_parse,
110 dmm_details_va18b,
111 },
a53da082
UH		 112 {
113 "Metex", "M-3640D", "1200/7n2/rts=0/dtr=1", 1200,
114 METEX14_PACKET_SIZE, sr_metex14_packet_request,
115 sr_metex14_packet_valid, sr_metex14_parse,
116 NULL,
117 },
a376ffea
UH		 118 {
119 "PeakTech", "4370", "1200/7n2/rts=0/dtr=1", 1200,
120 METEX14_PACKET_SIZE, sr_metex14_packet_request,
121 sr_metex14_packet_valid, sr_metex14_parse,
122 NULL,
123 },
d4bd66a0
UH		 124 {
125 "PCE", "PCE-DM32", "2400/8n1", 2400,
126 FS9721_PACKET_SIZE, NULL,
127 sr_fs9721_packet_valid, sr_fs9721_parse,
128 dmm_details_pce_dm32,
129 },
d5ce233f
AG		 130 {
131 "RadioShack", "22-168", "1200/7n2/rts=0/dtr=1", 1200,
132 METEX14_PACKET_SIZE, sr_metex14_packet_request,
133 sr_metex14_packet_valid, sr_metex14_parse,
134 NULL,
135 },
729b01f9 136};
7dc55d93
AG		 137
138/* Properly close and free all devices. */
139static int clear_instances(void)
140{
141 struct sr_dev_inst *sdi;
142 struct drv_context *drvc;
143 struct dev_context *devc;
144 GSList *l;
145
146 if (!(drvc = di->priv))
147 return SR_OK;
148
149 drvc = di->priv;
150 for (l = drvc->instances; l; l = l->next) {
151 if (!(sdi = l->data))
152 continue;
153 if (!(devc = sdi->priv))
154 continue;
155 sr_serial_dev_inst_free(devc->serial);
156 sr_dev_inst_free(sdi);
157 }
158 g_slist_free(drvc->instances);
159 drvc->instances = NULL;
160
161 return SR_OK;
162}
163
729b01f9 164static int hw_init(int dmm)
7dc55d93
AG		 165{
166 struct drv_context *drvc;
167
168 if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
bbabddbd
UH		 169 sr_err("Driver context malloc failed.");
170 return SR_ERR_MALLOC;
7dc55d93
AG		 171 }
172
f086b830 173 if (dmm == DIGITEK_DT4000ZC)
ce3777ad 174 di = di_dt4000zc;
729b01f9 175 if (dmm == TEKPOWER_TP4000ZC)
ce3777ad
UH		 176 di = di_tp4000zc;
177 if (dmm == METEX_ME31)
178 di = di_me31;
f0ac4929
UH		 179 if (dmm == PEAKTECH_3410)
180 di = di_3410;
5887c9cc
UH		 181 if (dmm == MASTECH_MAS345)
182 di = di_mas345;
6dca2f16
UH		 183 if (dmm == VA_VA18B)
184 di = di_va18b;
a53da082
UH		 185 if (dmm == METEX_M3640D)
186 di = di_m3640d;
a376ffea
UH		 187 if (dmm == PEAKTECH_4370)
188 di = di_4370;
d4bd66a0
UH		 189 if (dmm == PCE_PCE_DM32)
190 di = di_pce_dm32;
d5ce233f
AG		 191 if (dmm == RADIOSHACK_22_168)
192 di = di_22_168;
729b01f9
UH		 193 sr_dbg("Selected '%s' subdriver.", di->name);
194
7dc55d93
AG		 195 di->priv = drvc;
196
197 return SR_OK;
198}
199
f086b830
UH		 200static int hw_init_digitek_dt4000zc(void)
201{
202 return hw_init(DIGITEK_DT4000ZC);
203}
204
729b01f9
UH		 205static int hw_init_tekpower_tp4000zc(void)
206{
207 return hw_init(TEKPOWER_TP4000ZC);
208}
209
ce3777ad
UH		 210static int hw_init_metex_me31(void)
211{
212 return hw_init(METEX_ME31);
213}
214
f0ac4929
UH		 215static int hw_init_peaktech_3410(void)
216{
217 return hw_init(PEAKTECH_3410);
218}
219
5887c9cc
UH		 220static int hw_init_mastech_mas345(void)
221{
222 return hw_init(MASTECH_MAS345);
223}
224
6dca2f16
UH		 225static int hw_init_va_va18b(void)
226{
227 return hw_init(VA_VA18B);
228}
229
a53da082
UH		 230static int hw_init_metex_m3640d(void)
231{
232 return hw_init(METEX_M3640D);
233}
234
a376ffea
UH		 235static int hw_init_peaktech_4370(void)
236{
237 return hw_init(PEAKTECH_4370);
238}
239
d4bd66a0
UH		 240static int hw_init_pce_pce_dm32(void)
241{
242 return hw_init(PCE_PCE_DM32);
243}
244
d5ce233f
AG		 245static int hw_init_radioshack_22_168(void)
246{
247 return hw_init(RADIOSHACK_22_168);
248}
249
729b01f9 250static GSList *scan(const char *conn, const char *serialcomm, int dmm)
7dc55d93
AG		 251{
252 struct sr_dev_inst *sdi;
253 struct drv_context *drvc;
254 struct dev_context *devc;
255 struct sr_probe *probe;
d35afa87 256 struct sr_serial_dev_inst *serial;
7dc55d93 257 GSList *devices;
2546b05c
AG		 258 int dropped, ret;
259 size_t len;
260 uint8_t buf[128];
7dc55d93 261
d35afa87 262 if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
7dc55d93 263 return NULL;
d35afa87 264
ce3777ad 265 if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
7dc55d93 266 return NULL;
7dc55d93 267
ce3777ad 268 sr_info("Probing port %s.", conn);
7dc55d93
AG		 269
270 drvc = di->priv;
7dc55d93 271 devices = NULL;
d35afa87 272 serial_flush(serial);
bbabddbd
UH		 273
274 /*
275 * There's no way to get an ID from the multimeter. It just sends data
276 * periodically, so the best we can do is check if the packets match
277 * the expected format.
278 */
7dc55d93 279
2546b05c
AG		 280 /* Let's get a bit of data and see if we can find a packet. */
281 len = sizeof(buf);
7dc55d93 282
ce3777ad
UH		 283 /* Request a packet if the DMM requires this. */
284 if (dmms[dmm].packet_request) {
285 if ((ret = dmms[dmm].packet_request(serial)) < 0) {
286 sr_err("Failed to request packet: %d.", ret);
287 return FALSE;
288 }
289 }
290
729b01f9
UH		 291 ret = serial_stream_detect(serial, buf, &len, dmms[dmm].packet_size,
292 dmms[dmm].packet_valid, 1000,
293 dmms[dmm].baudrate);
2546b05c
AG		 294 if (ret != SR_OK)
295 goto scan_cleanup;
7dc55d93 296
2546b05c
AG		 297 /*
298 * If we dropped more than two packets worth of data, something is
299 * wrong. We shouldn't quit however, since the dropped bytes might be
300 * just zeroes at the beginning of the stream. Those can occur as a
301 * combination of the nonstandard cable that ships with this device and
302 * the serial port or USB to serial adapter.
303 */
729b01f9
UH		 304 dropped = len - dmms[dmm].packet_size;
305 if (dropped > 2 * dmms[dmm].packet_size)
6bef68a7 306 sr_warn("Had to drop too much data.");
7dc55d93 307
2546b05c 308 sr_info("Found device on port %s.", conn);
7dc55d93 309
729b01f9
UH		 310 if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, dmms[dmm].vendor,
311 dmms[dmm].device, "")))
2546b05c 312 goto scan_cleanup;
6bef68a7 313
2546b05c
AG		 314 if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
315 sr_err("Device context malloc failed.");
316 goto scan_cleanup;
7dc55d93
AG		 317 }
318
2546b05c
AG		 319 devc->serial = serial;
320
321 sdi->priv = devc;
322 sdi->driver = di;
323 if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
324 goto scan_cleanup;
325 sdi->probes = g_slist_append(sdi->probes, probe);
326 drvc->instances = g_slist_append(drvc->instances, sdi);
327 devices = g_slist_append(devices, sdi);
328
329scan_cleanup:
d35afa87 330 serial_close(serial);
2546b05c 331
7dc55d93
AG		 332 return devices;
333}
334
335static GSList *hw_scan(GSList *options)
336{
337 struct sr_hwopt *opt;
338 GSList *l, *devices;
339 const char *conn, *serialcomm;
729b01f9 340 int dmm;
7dc55d93
AG		 341
342 conn = serialcomm = NULL;
343 for (l = options; l; l = l->next) {
344 opt = l->data;
345 switch (opt->hwopt) {
346 case SR_HWOPT_CONN:
347 conn = opt->value;
348 break;
349 case SR_HWOPT_SERIALCOMM:
350 serialcomm = opt->value;
351 break;
352 }
353 }
354 if (!conn)
355 return NULL;
356
f086b830 357 if (!strcmp(di->name, "digitek-dt4000zc"))
729b01f9 358 dmm = 0;
f086b830
UH		 359 if (!strcmp(di->name, "tekpower-tp4000zc"))
360 dmm = 1;
ce3777ad
UH		 361 if (!strcmp(di->name, "metex-me31"))
362 dmm = 2;
f0ac4929
UH		 363 if (!strcmp(di->name, "peaktech-3410"))
364 dmm = 3;
5887c9cc
UH		 365 if (!strcmp(di->name, "mastech-mas345"))
366 dmm = 4;
6dca2f16
UH		 367 if (!strcmp(di->name, "va-va18b"))
368 dmm = 5;
a53da082
UH		 369 if (!strcmp(di->name, "metex-m3640d"))
370 dmm = 6;
a376ffea
UH		 371 if (!strcmp(di->name, "peaktech-4370"))
372 dmm = 7;
d4bd66a0
UH		 373 if (!strcmp(di->name, "pce-pce-dm32"))
374 dmm = 8;
d5ce233f
AG		 375 if (!strcmp(di->name, "radioshack-22-168"))
376 dmm = 9;
729b01f9 377
7dc55d93
AG		 378 if (serialcomm) {
379 /* Use the provided comm specs. */
729b01f9 380 devices = scan(conn, serialcomm, dmm);
7dc55d93 381 } else {
d35afa87 382 /* Try the default. */
729b01f9 383 devices = scan(conn, dmms[dmm].conn, dmm);
7dc55d93
AG		 384 }
385
386 return devices;
387}
388
389static GSList *hw_dev_list(void)
390{
391 struct drv_context *drvc;
392
393 drvc = di->priv;
394
395 return drvc->instances;
396}
397
398static int hw_dev_open(struct sr_dev_inst *sdi)
399{
400 struct dev_context *devc;
401
402 if (!(devc = sdi->priv)) {
403 sr_err("sdi->priv was NULL.");
404 return SR_ERR_BUG;
405 }
406
ce3777ad 407 if (serial_open(devc->serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
7dc55d93 408 return SR_ERR;
bbabddbd 409
7dc55d93
AG		 410 sdi->status = SR_ST_ACTIVE;
411
412 return SR_OK;
413}
414
415static int hw_dev_close(struct sr_dev_inst *sdi)
416{
417 struct dev_context *devc;
418
419 if (!(devc = sdi->priv)) {
420 sr_err("sdi->priv was NULL.");
421 return SR_ERR_BUG;
422 }
423
424 if (devc->serial && devc->serial->fd != -1) {
d35afa87 425 serial_close(devc->serial);
7dc55d93
AG		 426 sdi->status = SR_ST_INACTIVE;
427 }
428
429 return SR_OK;
430}
431
432static int hw_cleanup(void)
433{
434 clear_instances();
435
436 return SR_OK;
437}
438
439static int hw_info_get(int info_id, const void **data,
bbabddbd 440 const struct sr_dev_inst *sdi)
7dc55d93 441{
bbabddbd 442 (void)sdi;
7dc55d93
AG		 443
444 switch (info_id) {
445 case SR_DI_HWOPTS:
446 *data = hwopts;
447 break;
448 case SR_DI_HWCAPS:
449 *data = hwcaps;
450 break;
451 case SR_DI_NUM_PROBES:
452 *data = GINT_TO_POINTER(1);
453 break;
454 case SR_DI_PROBE_NAMES:
455 *data = probe_names;
456 break;
457 default:
458 return SR_ERR_ARG;
459 }
460
461 return SR_OK;
462}
463
464static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
bbabddbd 465 const void *value)
7dc55d93
AG		 466{
467 struct dev_context *devc;
468
469 if (sdi->status != SR_ST_ACTIVE)
470 return SR_ERR;
471
472 if (!(devc = sdi->priv)) {
473 sr_err("sdi->priv was NULL.");
474 return SR_ERR_BUG;
475 }
476
477 switch (hwcap) {
478 case SR_HWCAP_LIMIT_SAMPLES:
479 devc->limit_samples = *(const uint64_t *)value;
480 sr_dbg("Setting sample limit to %" PRIu64 ".",
481 devc->limit_samples);
482 break;
483 default:
484 sr_err("Unknown capability: %d.", hwcap);
485 return SR_ERR;
486 break;
487 }
488
489 return SR_OK;
490}
491
492static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
bbabddbd 493 void *cb_data)
7dc55d93
AG		 494{
495 struct sr_datafeed_packet packet;
496 struct sr_datafeed_header header;
497 struct sr_datafeed_meta_analog meta;
498 struct dev_context *devc;
729b01f9 499 int (*receive_data)(int, int, void *) = NULL;
7dc55d93
AG		 500
501 if (!(devc = sdi->priv)) {
502 sr_err("sdi->priv was NULL.");
503 return SR_ERR_BUG;
504 }
505
506 sr_dbg("Starting acquisition.");
507
508 devc->cb_data = cb_data;
509
bbabddbd
UH		 510 /*
511 * Reset the number of samples to take. If we've already collected our
7dc55d93 512 * quota, but we start a new session, and don't reset this, we'll just
bbabddbd
UH		 513 * quit without acquiring any new samples.
514 */
7dc55d93
AG		 515 devc->num_samples = 0;
516
517 /* Send header packet to the session bus. */
518 sr_dbg("Sending SR_DF_HEADER.");
519 packet.type = SR_DF_HEADER;
520 packet.payload = (uint8_t *)&header;
521 header.feed_version = 1;
522 gettimeofday(&header.starttime, NULL);
523 sr_session_send(devc->cb_data, &packet);
524
525 /* Send metadata about the SR_DF_ANALOG packets to come. */
526 sr_dbg("Sending SR_DF_META_ANALOG.");
527 packet.type = SR_DF_META_ANALOG;
528 packet.payload = &meta;
529 meta.num_probes = 1;
530 sr_session_send(devc->cb_data, &packet);
531
f086b830
UH		 532 if (!strcmp(di->name, "digitek-dt4000zc"))
533 receive_data = digitek_dt4000zc_receive_data;
729b01f9
UH		 534 if (!strcmp(di->name, "tekpower-tp4000zc"))
535 receive_data = tekpower_tp4000zc_receive_data;
ce3777ad
UH		 536 if (!strcmp(di->name, "metex-me31"))
537 receive_data = metex_me31_receive_data;
f0ac4929
UH		 538 if (!strcmp(di->name, "peaktech-3410"))
539 receive_data = peaktech_3410_receive_data;
5887c9cc
UH		 540 if (!strcmp(di->name, "mastech-mas345"))
541 receive_data = mastech_mas345_receive_data;
6dca2f16
UH		 542 if (!strcmp(di->name, "va-va18b"))
543 receive_data = va_va18b_receive_data;
a53da082
UH		 544 if (!strcmp(di->name, "metex-m3640d"))
545 receive_data = metex_m3640d_receive_data;
a376ffea
UH		 546 if (!strcmp(di->name, "peaktech-4370"))
547 receive_data = peaktech_4370_receive_data;
d4bd66a0
UH		 548 if (!strcmp(di->name, "pce-pce-dm32"))
549 receive_data = pce_pce_dm32_receive_data;
d5ce233f
AG		 550 if (!strcmp(di->name, "radioshack-22-168"))
551 receive_data = radioshack_22_168_receive_data;
729b01f9 552
bbabddbd 553 /* Poll every 50ms, or whenever some data comes in. */
7dc55d93 554 sr_source_add(devc->serial->fd, G_IO_IN, 50,
729b01f9 555 receive_data, (void *)sdi);
7dc55d93
AG		 556
557 return SR_OK;
558}
559
69b07d14 560static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
7dc55d93
AG		 561{
562 struct sr_datafeed_packet packet;
563 struct dev_context *devc;
564
565 if (sdi->status != SR_ST_ACTIVE)
566 return SR_ERR;
567
568 if (!(devc = sdi->priv)) {
569 sr_err("sdi->priv was NULL.");
570 return SR_ERR_BUG;
571 }
572
573 sr_dbg("Stopping acquisition.");
574
575 sr_source_remove(devc->serial->fd);
576 hw_dev_close((struct sr_dev_inst *)sdi);
577
578 /* Send end packet to the session bus. */
579 sr_dbg("Sending SR_DF_END.");
580 packet.type = SR_DF_END;
581 sr_session_send(cb_data, &packet);
582
583 return SR_OK;
584}
585
f086b830
UH		 586SR_PRIV struct sr_dev_driver digitek_dt4000zc_driver_info = {
587 .name = "digitek-dt4000zc",
588 .longname = "Digitek DT4000ZC",
589 .api_version = 1,
590 .init = hw_init_digitek_dt4000zc,
591 .cleanup = hw_cleanup,
592 .scan = hw_scan,
593 .dev_list = hw_dev_list,
594 .dev_clear = clear_instances,
595 .dev_open = hw_dev_open,
596 .dev_close = hw_dev_close,
597 .info_get = hw_info_get,
598 .dev_config_set = hw_dev_config_set,
599 .dev_acquisition_start = hw_dev_acquisition_start,
600 .dev_acquisition_stop = hw_dev_acquisition_stop,
601 .priv = NULL,
602};
603
729b01f9
UH		 604SR_PRIV struct sr_dev_driver tekpower_tp4000zc_driver_info = {
605 .name = "tekpower-tp4000zc",
606 .longname = "TekPower TP4000ZC",
7dc55d93 607 .api_version = 1,
729b01f9 608 .init = hw_init_tekpower_tp4000zc,
7dc55d93
AG		 609 .cleanup = hw_cleanup,
610 .scan = hw_scan,
611 .dev_list = hw_dev_list,
612 .dev_clear = clear_instances,
613 .dev_open = hw_dev_open,
614 .dev_close = hw_dev_close,
615 .info_get = hw_info_get,
616 .dev_config_set = hw_dev_config_set,
617 .dev_acquisition_start = hw_dev_acquisition_start,
618 .dev_acquisition_stop = hw_dev_acquisition_stop,
619 .priv = NULL,
620};
ce3777ad
UH		 621
622SR_PRIV struct sr_dev_driver metex_me31_driver_info = {
623 .name = "metex-me31",
624 .longname = "Metex ME-31",
625 .api_version = 1,
626 .init = hw_init_metex_me31,
627 .cleanup = hw_cleanup,
628 .scan = hw_scan,
629 .dev_list = hw_dev_list,
630 .dev_clear = clear_instances,
631 .dev_open = hw_dev_open,
632 .dev_close = hw_dev_close,
633 .info_get = hw_info_get,
634 .dev_config_set = hw_dev_config_set,
635 .dev_acquisition_start = hw_dev_acquisition_start,
636 .dev_acquisition_stop = hw_dev_acquisition_stop,
637 .priv = NULL,
638};
f0ac4929
UH		 639
640SR_PRIV struct sr_dev_driver peaktech_3410_driver_info = {
641 .name = "peaktech-3410",
642 .longname = "PeakTech 3410",
643 .api_version = 1,
644 .init = hw_init_peaktech_3410,
645 .cleanup = hw_cleanup,
646 .scan = hw_scan,
647 .dev_list = hw_dev_list,
648 .dev_clear = clear_instances,
649 .dev_open = hw_dev_open,
650 .dev_close = hw_dev_close,
651 .info_get = hw_info_get,
652 .dev_config_set = hw_dev_config_set,
653 .dev_acquisition_start = hw_dev_acquisition_start,
654 .dev_acquisition_stop = hw_dev_acquisition_stop,
655 .priv = NULL,
656};
5887c9cc
UH		 657
658SR_PRIV struct sr_dev_driver mastech_mas345_driver_info = {
659 .name = "mastech-mas345",
660 .longname = "MASTECH MAS345",
661 .api_version = 1,
662 .init = hw_init_mastech_mas345,
663 .cleanup = hw_cleanup,
664 .scan = hw_scan,
665 .dev_list = hw_dev_list,
666 .dev_clear = clear_instances,
667 .dev_open = hw_dev_open,
668 .dev_close = hw_dev_close,
669 .info_get = hw_info_get,
670 .dev_config_set = hw_dev_config_set,
671 .dev_acquisition_start = hw_dev_acquisition_start,
672 .dev_acquisition_stop = hw_dev_acquisition_stop,
673 .priv = NULL,
674};
6dca2f16
UH		 675
676SR_PRIV struct sr_dev_driver va_va18b_driver_info = {
677 .name = "va-va18b",
678 .longname = "V&A VA18B",
679 .api_version = 1,
680 .init = hw_init_va_va18b,
681 .cleanup = hw_cleanup,
682 .scan = hw_scan,
683 .dev_list = hw_dev_list,
684 .dev_clear = clear_instances,
685 .dev_open = hw_dev_open,
686 .dev_close = hw_dev_close,
687 .info_get = hw_info_get,
688 .dev_config_set = hw_dev_config_set,
689 .dev_acquisition_start = hw_dev_acquisition_start,
690 .dev_acquisition_stop = hw_dev_acquisition_stop,
691 .priv = NULL,
692};
a53da082
UH		 693
694SR_PRIV struct sr_dev_driver metex_m3640d_driver_info = {
695 .name = "metex-m3640d",
696 .longname = "Metex M-3640D",
697 .api_version = 1,
698 .init = hw_init_metex_m3640d,
699 .cleanup = hw_cleanup,
700 .scan = hw_scan,
701 .dev_list = hw_dev_list,
702 .dev_clear = clear_instances,
703 .dev_open = hw_dev_open,
704 .dev_close = hw_dev_close,
705 .info_get = hw_info_get,
706 .dev_config_set = hw_dev_config_set,
707 .dev_acquisition_start = hw_dev_acquisition_start,
708 .dev_acquisition_stop = hw_dev_acquisition_stop,
709 .priv = NULL,
710};
a376ffea
UH		 711
712SR_PRIV struct sr_dev_driver peaktech_4370_driver_info = {
713 .name = "peaktech-4370",
714 .longname = "PeakTech 4370",
715 .api_version = 1,
716 .init = hw_init_peaktech_4370,
717 .cleanup = hw_cleanup,
718 .scan = hw_scan,
719 .dev_list = hw_dev_list,
720 .dev_clear = clear_instances,
721 .dev_open = hw_dev_open,
722 .dev_close = hw_dev_close,
723 .info_get = hw_info_get,
724 .dev_config_set = hw_dev_config_set,
725 .dev_acquisition_start = hw_dev_acquisition_start,
726 .dev_acquisition_stop = hw_dev_acquisition_stop,
727 .priv = NULL,
728};
d4bd66a0
UH		 729
730SR_PRIV struct sr_dev_driver pce_pce_dm32_driver_info = {
731 .name = "pce-pce-dm32",
732 .longname = "PCE PCE-DM32",
733 .api_version = 1,
734 .init = hw_init_pce_pce_dm32,
735 .cleanup = hw_cleanup,
736 .scan = hw_scan,
737 .dev_list = hw_dev_list,
738 .dev_clear = clear_instances,
739 .dev_open = hw_dev_open,
740 .dev_close = hw_dev_close,
741 .info_get = hw_info_get,
742 .dev_config_set = hw_dev_config_set,
743 .dev_acquisition_start = hw_dev_acquisition_start,
744 .dev_acquisition_stop = hw_dev_acquisition_stop,
745 .priv = NULL,
746};
747
d5ce233f
AG		 748SR_PRIV struct sr_dev_driver radioshack_22_168_driver_info = {
749 .name = "radioshack-22-168",
750 .longname = "RadioShack 22-168",
751 .api_version = 1,
752 .init = hw_init_radioshack_22_168,
753 .cleanup = hw_cleanup,
754 .scan = hw_scan,
755 .dev_list = hw_dev_list,
756 .dev_clear = clear_instances,
757 .dev_open = hw_dev_open,
758 .dev_close = hw_dev_close,
759 .info_get = hw_info_get,
760 .dev_config_set = hw_dev_config_set,
761 .dev_acquisition_start = hw_dev_acquisition_start,
762 .dev_acquisition_stop = hw_dev_acquisition_stop,
763 .priv = NULL,
764};
Hardware access and backend lib