]> sigrok.org Git - libsigrok.git/blame - hardware/serial-dmm/api.c
rs9lcd: Fix segfault with unusual modes.
[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
7dc55d93
AG
22#include <sys/types.h>
23#include <sys/stat.h>
24#include <fcntl.h>
25#include <string.h>
26#include <errno.h>
22f54192 27#include <glib.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;
40830061 61SR_PRIV struct sr_dev_driver voltcraft_vc820_ser_driver_info;
54d11221 62SR_PRIV struct sr_dev_driver voltcraft_vc840_ser_driver_info;
f086b830 63
729b01f9 64SR_PRIV struct dmm_info dmms[] = {
f086b830 65 {
ce3777ad
UH
66 "Digitek", "DT4000ZC", "2400/8n1", 2400,
67 FS9721_PACKET_SIZE, NULL,
68 sr_fs9721_packet_valid, sr_fs9721_parse,
f086b830 69 dmm_details_dt4000zc,
dccfe015 70 &digitek_dt4000zc_driver_info, receive_data_DIGITEK_DT4000ZC,
f086b830 71 },
729b01f9 72 {
ce3777ad
UH
73 "TekPower", "TP4000ZC", "2400/8n1", 2400,
74 FS9721_PACKET_SIZE, NULL,
75 sr_fs9721_packet_valid, sr_fs9721_parse,
729b01f9 76 dmm_details_tp4000zc,
dccfe015 77 &tekpower_tp4000zc_driver_info, receive_data_TEKPOWER_TP4000ZC,
729b01f9 78 },
ce3777ad
UH
79 {
80 "Metex", "ME-31", "600/7n2/rts=0/dtr=1", 600,
81 METEX14_PACKET_SIZE, sr_metex14_packet_request,
82 sr_metex14_packet_valid, sr_metex14_parse,
83 NULL,
dccfe015 84 &metex_me31_driver_info, receive_data_METEX_ME31,
ce3777ad 85 },
f0ac4929
UH
86 {
87 "Peaktech", "3410", "600/7n2/rts=0/dtr=1", 600,
88 METEX14_PACKET_SIZE, sr_metex14_packet_request,
89 sr_metex14_packet_valid, sr_metex14_parse,
90 NULL,
dccfe015 91 &peaktech_3410_driver_info, receive_data_PEAKTECH_3410,
f0ac4929 92 },
5887c9cc
UH
93 {
94 "MASTECH", "MAS345", "600/7n2/rts=0/dtr=1", 600,
95 METEX14_PACKET_SIZE, sr_metex14_packet_request,
96 sr_metex14_packet_valid, sr_metex14_parse,
97 NULL,
dccfe015 98 &mastech_mas345_driver_info, receive_data_MASTECH_MAS345,
5887c9cc 99 },
6dca2f16
UH
100 {
101 "V&A", "VA18B", "2400/8n1", 2400,
102 FS9721_PACKET_SIZE, NULL,
103 sr_fs9721_packet_valid, sr_fs9721_parse,
104 dmm_details_va18b,
dccfe015 105 &va_va18b_driver_info, receive_data_VA_VA18B,
6dca2f16 106 },
a53da082
UH
107 {
108 "Metex", "M-3640D", "1200/7n2/rts=0/dtr=1", 1200,
109 METEX14_PACKET_SIZE, sr_metex14_packet_request,
110 sr_metex14_packet_valid, sr_metex14_parse,
111 NULL,
dccfe015 112 &metex_m3640d_driver_info, receive_data_METEX_M3640D,
a53da082 113 },
a376ffea
UH
114 {
115 "PeakTech", "4370", "1200/7n2/rts=0/dtr=1", 1200,
116 METEX14_PACKET_SIZE, sr_metex14_packet_request,
117 sr_metex14_packet_valid, sr_metex14_parse,
118 NULL,
dccfe015 119 &peaktech_4370_driver_info, receive_data_PEAKTECH_4370,
a376ffea 120 },
d4bd66a0
UH
121 {
122 "PCE", "PCE-DM32", "2400/8n1", 2400,
123 FS9721_PACKET_SIZE, NULL,
124 sr_fs9721_packet_valid, sr_fs9721_parse,
125 dmm_details_pce_dm32,
dccfe015 126 &pce_pce_dm32_driver_info, receive_data_PCE_PCE_DM32,
d4bd66a0 127 },
d5ce233f
AG
128 {
129 "RadioShack", "22-168", "1200/7n2/rts=0/dtr=1", 1200,
130 METEX14_PACKET_SIZE, sr_metex14_packet_request,
131 sr_metex14_packet_valid, sr_metex14_parse,
132 NULL,
dccfe015 133 &radioshack_22_168_driver_info, receive_data_RADIOSHACK_22_168,
d5ce233f 134 },
21829e67
AG
135 {
136 "RadioShack", "22-812", "4800/8n1/rts=0/dtr=1", 4800,
137 RS9LCD_PACKET_SIZE, NULL,
138 sr_rs9lcd_packet_valid, sr_rs9lcd_parse,
139 NULL,
dccfe015 140 &radioshack_22_812_driver_info, receive_data_RADIOSHACK_22_812,
21829e67 141 },
40830061
UH
142 {
143 "Voltcraft", "VC-820 (UT-D02 cable)", "2400/8n1/rts=0/dtr=1",
144 2400, FS9721_PACKET_SIZE, NULL,
145 sr_fs9721_packet_valid, sr_fs9721_parse,
146 NULL,
147 &voltcraft_vc820_ser_driver_info, receive_data_VOLTCRAFT_VC820,
148 },
54d11221
UH
149 {
150 "Voltcraft", "VC-840 (UT-D02 cable)", "2400/8n1/rts=0/dtr=1",
151 2400, FS9721_PACKET_SIZE, NULL,
152 sr_fs9721_packet_valid, sr_fs9721_parse,
153 NULL,
154 &voltcraft_vc840_ser_driver_info, receive_data_VOLTCRAFT_VC840,
155 },
729b01f9 156};
7dc55d93
AG
157
158/* Properly close and free all devices. */
fd9b2b86 159static int clear_instances(int dmm)
7dc55d93
AG
160{
161 struct sr_dev_inst *sdi;
162 struct drv_context *drvc;
163 struct dev_context *devc;
164 GSList *l;
fd9b2b86 165 struct sr_dev_driver *di;
7dc55d93 166
fd9b2b86 167 di = dmms[dmm].di;
26be4ebe 168
7dc55d93
AG
169 if (!(drvc = di->priv))
170 return SR_OK;
171
172 drvc = di->priv;
173 for (l = drvc->instances; l; l = l->next) {
174 if (!(sdi = l->data))
175 continue;
176 if (!(devc = sdi->priv))
177 continue;
178 sr_serial_dev_inst_free(devc->serial);
179 sr_dev_inst_free(sdi);
180 }
181 g_slist_free(drvc->instances);
182 drvc->instances = NULL;
183
184 return SR_OK;
185}
186
34f06b90 187static int hw_init(struct sr_context *sr_ctx, int dmm)
7dc55d93
AG
188{
189 struct drv_context *drvc;
190
191 if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
bbabddbd
UH
192 sr_err("Driver context malloc failed.");
193 return SR_ERR_MALLOC;
7dc55d93
AG
194 }
195
06b7a8af 196 sr_dbg("Selected '%s' subdriver.", dmms[dmm].di->name);
729b01f9 197
1ebe4b4e 198 drvc->sr_ctx = sr_ctx;
06b7a8af 199 dmms[dmm].di->priv = drvc;
7dc55d93
AG
200
201 return SR_OK;
202}
203
729b01f9 204static GSList *scan(const char *conn, const char *serialcomm, int dmm)
7dc55d93
AG
205{
206 struct sr_dev_inst *sdi;
207 struct drv_context *drvc;
208 struct dev_context *devc;
209 struct sr_probe *probe;
d35afa87 210 struct sr_serial_dev_inst *serial;
7dc55d93 211 GSList *devices;
2546b05c
AG
212 int dropped, ret;
213 size_t len;
214 uint8_t buf[128];
7dc55d93 215
d35afa87 216 if (!(serial = sr_serial_dev_inst_new(conn, serialcomm)))
7dc55d93 217 return NULL;
d35afa87 218
ce3777ad 219 if (serial_open(serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
7dc55d93 220 return NULL;
7dc55d93 221
22f54192 222 sr_info("Probing serial port %s.", conn);
7dc55d93 223
06b7a8af 224 drvc = dmms[dmm].di->priv;
7dc55d93 225 devices = NULL;
d35afa87 226 serial_flush(serial);
bbabddbd 227
ce3777ad
UH
228 /* Request a packet if the DMM requires this. */
229 if (dmms[dmm].packet_request) {
230 if ((ret = dmms[dmm].packet_request(serial)) < 0) {
231 sr_err("Failed to request packet: %d.", ret);
232 return FALSE;
233 }
234 }
235
22f54192
UH
236 /*
237 * There's no way to get an ID from the multimeter. It just sends data
238 * periodically (or upon request), so the best we can do is check if
239 * the packets match the expected format.
240 */
241
242 /* Let's get a bit of data and see if we can find a packet. */
243 len = sizeof(buf);
729b01f9
UH
244 ret = serial_stream_detect(serial, buf, &len, dmms[dmm].packet_size,
245 dmms[dmm].packet_valid, 1000,
246 dmms[dmm].baudrate);
2546b05c
AG
247 if (ret != SR_OK)
248 goto scan_cleanup;
7dc55d93 249
2546b05c
AG
250 /*
251 * If we dropped more than two packets worth of data, something is
252 * wrong. We shouldn't quit however, since the dropped bytes might be
253 * just zeroes at the beginning of the stream. Those can occur as a
22f54192
UH
254 * combination of the nonstandard cable that ships with some devices
255 * and the serial port or USB to serial adapter.
2546b05c 256 */
729b01f9
UH
257 dropped = len - dmms[dmm].packet_size;
258 if (dropped > 2 * dmms[dmm].packet_size)
6bef68a7 259 sr_warn("Had to drop too much data.");
7dc55d93 260
2546b05c 261 sr_info("Found device on port %s.", conn);
7dc55d93 262
729b01f9
UH
263 if (!(sdi = sr_dev_inst_new(0, SR_ST_INACTIVE, dmms[dmm].vendor,
264 dmms[dmm].device, "")))
2546b05c 265 goto scan_cleanup;
6bef68a7 266
2546b05c
AG
267 if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
268 sr_err("Device context malloc failed.");
269 goto scan_cleanup;
7dc55d93
AG
270 }
271
2546b05c
AG
272 devc->serial = serial;
273
274 sdi->priv = devc;
06b7a8af 275 sdi->driver = dmms[dmm].di;
2546b05c
AG
276 if (!(probe = sr_probe_new(0, SR_PROBE_ANALOG, TRUE, "P1")))
277 goto scan_cleanup;
278 sdi->probes = g_slist_append(sdi->probes, probe);
279 drvc->instances = g_slist_append(drvc->instances, sdi);
280 devices = g_slist_append(devices, sdi);
281
282scan_cleanup:
d35afa87 283 serial_close(serial);
2546b05c 284
7dc55d93
AG
285 return devices;
286}
287
ea4c6c23 288static GSList *hw_scan(GSList *options, int dmm)
7dc55d93
AG
289{
290 struct sr_hwopt *opt;
291 GSList *l, *devices;
292 const char *conn, *serialcomm;
293
294 conn = serialcomm = NULL;
295 for (l = options; l; l = l->next) {
296 opt = l->data;
297 switch (opt->hwopt) {
298 case SR_HWOPT_CONN:
299 conn = opt->value;
300 break;
301 case SR_HWOPT_SERIALCOMM:
302 serialcomm = opt->value;
303 break;
304 }
305 }
306 if (!conn)
307 return NULL;
308
309 if (serialcomm) {
310 /* Use the provided comm specs. */
729b01f9 311 devices = scan(conn, serialcomm, dmm);
7dc55d93 312 } else {
d35afa87 313 /* Try the default. */
729b01f9 314 devices = scan(conn, dmms[dmm].conn, dmm);
7dc55d93
AG
315 }
316
317 return devices;
318}
319
ca4b1309 320static GSList *hw_dev_list(int dmm)
7dc55d93
AG
321{
322 struct drv_context *drvc;
323
ca4b1309 324 drvc = dmms[dmm].di->priv;
7dc55d93
AG
325
326 return drvc->instances;
327}
328
329static int hw_dev_open(struct sr_dev_inst *sdi)
330{
331 struct dev_context *devc;
332
333 if (!(devc = sdi->priv)) {
334 sr_err("sdi->priv was NULL.");
335 return SR_ERR_BUG;
336 }
337
ce3777ad 338 if (serial_open(devc->serial, SERIAL_RDWR | SERIAL_NONBLOCK) != SR_OK)
7dc55d93 339 return SR_ERR;
bbabddbd 340
7dc55d93
AG
341 sdi->status = SR_ST_ACTIVE;
342
343 return SR_OK;
344}
345
346static int hw_dev_close(struct sr_dev_inst *sdi)
347{
348 struct dev_context *devc;
349
350 if (!(devc = sdi->priv)) {
351 sr_err("sdi->priv was NULL.");
352 return SR_ERR_BUG;
353 }
354
355 if (devc->serial && devc->serial->fd != -1) {
d35afa87 356 serial_close(devc->serial);
7dc55d93
AG
357 sdi->status = SR_ST_INACTIVE;
358 }
359
360 return SR_OK;
361}
362
0c23677d 363static int hw_cleanup(int dmm)
7dc55d93 364{
fd9b2b86 365 clear_instances(dmm);
7dc55d93
AG
366
367 return SR_OK;
368}
369
370static int hw_info_get(int info_id, const void **data,
bbabddbd 371 const struct sr_dev_inst *sdi)
7dc55d93 372{
bbabddbd 373 (void)sdi;
7dc55d93
AG
374
375 switch (info_id) {
376 case SR_DI_HWOPTS:
377 *data = hwopts;
378 break;
379 case SR_DI_HWCAPS:
380 *data = hwcaps;
381 break;
382 case SR_DI_NUM_PROBES:
383 *data = GINT_TO_POINTER(1);
384 break;
385 case SR_DI_PROBE_NAMES:
386 *data = probe_names;
387 break;
388 default:
389 return SR_ERR_ARG;
390 }
391
392 return SR_OK;
393}
394
395static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
bbabddbd 396 const void *value)
7dc55d93
AG
397{
398 struct dev_context *devc;
399
400 if (sdi->status != SR_ST_ACTIVE)
401 return SR_ERR;
402
403 if (!(devc = sdi->priv)) {
404 sr_err("sdi->priv was NULL.");
405 return SR_ERR_BUG;
406 }
407
408 switch (hwcap) {
409 case SR_HWCAP_LIMIT_SAMPLES:
410 devc->limit_samples = *(const uint64_t *)value;
411 sr_dbg("Setting sample limit to %" PRIu64 ".",
412 devc->limit_samples);
413 break;
414 default:
415 sr_err("Unknown capability: %d.", hwcap);
416 return SR_ERR;
417 break;
418 }
419
420 return SR_OK;
421}
422
423static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
16b7b790 424 void *cb_data, int dmm)
7dc55d93
AG
425{
426 struct sr_datafeed_packet packet;
427 struct sr_datafeed_header header;
428 struct sr_datafeed_meta_analog meta;
429 struct dev_context *devc;
430
431 if (!(devc = sdi->priv)) {
432 sr_err("sdi->priv was NULL.");
433 return SR_ERR_BUG;
434 }
435
436 sr_dbg("Starting acquisition.");
437
438 devc->cb_data = cb_data;
439
bbabddbd
UH
440 /*
441 * Reset the number of samples to take. If we've already collected our
7dc55d93 442 * quota, but we start a new session, and don't reset this, we'll just
bbabddbd
UH
443 * quit without acquiring any new samples.
444 */
7dc55d93
AG
445 devc->num_samples = 0;
446
447 /* Send header packet to the session bus. */
448 sr_dbg("Sending SR_DF_HEADER.");
449 packet.type = SR_DF_HEADER;
450 packet.payload = (uint8_t *)&header;
451 header.feed_version = 1;
452 gettimeofday(&header.starttime, NULL);
453 sr_session_send(devc->cb_data, &packet);
454
455 /* Send metadata about the SR_DF_ANALOG packets to come. */
456 sr_dbg("Sending SR_DF_META_ANALOG.");
457 packet.type = SR_DF_META_ANALOG;
458 packet.payload = &meta;
459 meta.num_probes = 1;
460 sr_session_send(devc->cb_data, &packet);
461
bbabddbd 462 /* Poll every 50ms, or whenever some data comes in. */
7dc55d93 463 sr_source_add(devc->serial->fd, G_IO_IN, 50,
16b7b790 464 dmms[dmm].receive_data, (void *)sdi);
7dc55d93
AG
465
466 return SR_OK;
467}
468
69b07d14 469static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
7dc55d93
AG
470{
471 struct sr_datafeed_packet packet;
472 struct dev_context *devc;
473
474 if (sdi->status != SR_ST_ACTIVE)
475 return SR_ERR;
476
477 if (!(devc = sdi->priv)) {
478 sr_err("sdi->priv was NULL.");
479 return SR_ERR_BUG;
480 }
481
482 sr_dbg("Stopping acquisition.");
483
484 sr_source_remove(devc->serial->fd);
485 hw_dev_close((struct sr_dev_inst *)sdi);
486
487 /* Send end packet to the session bus. */
488 sr_dbg("Sending SR_DF_END.");
489 packet.type = SR_DF_END;
490 sr_session_send(cb_data, &packet);
491
492 return SR_OK;
493}
494
3098b390
AG
495/* Driver-specific API function wrappers */
496#define HW_INIT(X) \
497static int hw_init_##X(struct sr_context *sr_ctx) { return hw_init(sr_ctx, X); }
498#define HW_CLEANUP(X) \
499static int hw_cleanup_##X(void) { return hw_cleanup(X); }
500#define HW_SCAN(X) \
501static GSList *hw_scan_##X(GSList *options) { return hw_scan(options, X); }
502#define HW_DEV_LIST(X) \
503static GSList *hw_dev_list_##X(void) { return hw_dev_list(X); }
504#define CLEAR_INSTANCES(X) \
505static int clear_instances_##X(void) { return clear_instances(X); }
16b7b790
UH
506#define HW_DEV_ACQUISITION_START(X) \
507static int hw_dev_acquisition_start_##X(const struct sr_dev_inst *sdi, \
508void *cb_data) { return hw_dev_acquisition_start(sdi, cb_data, X); }
3098b390
AG
509
510/* Driver structs and API function wrappers */
f1437c68 511#define DRV(ID, ID_UPPER, NAME, LONGNAME) \
3098b390
AG
512HW_INIT(ID_UPPER) \
513HW_CLEANUP(ID_UPPER) \
514HW_SCAN(ID_UPPER) \
515HW_DEV_LIST(ID_UPPER) \
516CLEAR_INSTANCES(ID_UPPER) \
16b7b790 517HW_DEV_ACQUISITION_START(ID_UPPER) \
f1437c68
UH
518SR_PRIV struct sr_dev_driver ID##_driver_info = { \
519 .name = NAME, \
520 .longname = LONGNAME, \
521 .api_version = 1, \
522 .init = hw_init_##ID_UPPER, \
0c23677d 523 .cleanup = hw_cleanup_##ID_UPPER, \
ea4c6c23 524 .scan = hw_scan_##ID_UPPER, \
ca4b1309 525 .dev_list = hw_dev_list_##ID_UPPER, \
fd9b2b86 526 .dev_clear = clear_instances_##ID_UPPER, \
f1437c68
UH
527 .dev_open = hw_dev_open, \
528 .dev_close = hw_dev_close, \
529 .info_get = hw_info_get, \
530 .dev_config_set = hw_dev_config_set, \
16b7b790 531 .dev_acquisition_start = hw_dev_acquisition_start_##ID_UPPER, \
f1437c68
UH
532 .dev_acquisition_stop = hw_dev_acquisition_stop, \
533 .priv = NULL, \
21829e67 534};
3098b390 535
f1437c68
UH
536DRV(digitek_dt4000zc, DIGITEK_DT4000ZC, "digitek-dt4000zc", "Digitek DT4000ZC")
537DRV(tekpower_tp4000zc, TEKPOWER_TP4000ZC, "tekpower-tp4000zc", "TekPower TP4000ZC")
538DRV(metex_me31, METEX_ME31, "metex-me31", "Metex ME-31")
539DRV(peaktech_3410, PEAKTECH_3410, "peaktech-3410", "PeakTech 3410")
540DRV(mastech_mas345, MASTECH_MAS345, "mastech-mas345", "MASTECH MAS345")
541DRV(va_va18b, VA_VA18B, "va-va18b", "V&A VA18B")
542DRV(metex_m3640d, METEX_M3640D, "metex-m3640d", "Metex M-3640D")
543DRV(peaktech_4370, PEAKTECH_4370, "peaktech-4370", "PeakTech 4370")
544DRV(pce_pce_dm32, PCE_PCE_DM32, "pce-pce-dm32", "PCE PCE-DM32")
545DRV(radioshack_22_168, RADIOSHACK_22_168, "radioshack-22-168", "RadioShack 22-168")
546DRV(radioshack_22_812, RADIOSHACK_22_812, "radioshack-22-812", "RadioShack 22-812")
40830061
UH
547DRV(voltcraft_vc820_ser, VOLTCRAFT_VC820, "voltcraft-vc820-ser", "Voltcraft VC-820 (UT-D02 cable)")
548DRV(voltcraft_vc840_ser, VOLTCRAFT_VC840, "voltcraft-vc840-ser", "Voltcraft VC-840 (UT-D02 cable)")