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