sr: moved sigrok.h so libsigrok/libsigrok.h
[sigrok:sigrok.git] / libsigrok / hardware / genericdmm / api.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2012 Uwe Hermann <uwe@hermann-uwe.de>
5  * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
20  */
21
22 #include <stdlib.h>
23 #include <string.h>
24 #include <fcntl.h>
25 #include "libsigrok.h"
26 #include "libsigrok-internal.h"
27 #include "genericdmm.h"
28
29
30 extern SR_PRIV struct dmmchip dmmchip_fs9922;
31
32 static struct dev_profile dev_profiles[] = {
33         { "victor-70c", "Victor", "70C", &dmmchip_fs9922,
34                 0x1244, 0xd237, DMM_TRANSPORT_USBHID },
35         { "mastech-va18b", "Mastech", "VA18B", NULL, 0, 0, DMM_TRANSPORT_SERIAL},
36 };
37
38 static const int hwcaps[] = {
39         SR_HWCAP_MULTIMETER,
40         SR_HWCAP_LIMIT_SAMPLES,
41         SR_HWCAP_LIMIT_MSEC,
42         SR_HWCAP_CONTINUOUS,
43         SR_HWCAP_MODEL,
44         SR_HWCAP_CONN,
45         SR_HWCAP_SERIALCOMM,
46         0,
47 };
48
49 static const char *probe_names[] = {
50         "Probe",
51         NULL,
52 };
53
54 /* TODO need a way to keep these local to the static library */
55 SR_PRIV GSList *genericdmm_dev_insts = NULL;
56 SR_PRIV libusb_context *genericdmm_usb_context = NULL;
57
58
59 static int hw_init(const char *devinfo)
60 {
61         struct sr_dev_inst *sdi;
62         struct context *ctx;
63         int devcnt = 0;
64
65         /* Avoid compiler warnings. */
66         (void)devinfo;
67
68         if (libusb_init(&genericdmm_usb_context) != 0) {
69                 sr_err("genericdmm: Failed to initialize USB.");
70                 return 0;
71         }
72
73         if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
74                 sr_err("genericdmm: ctx malloc failed.");
75                 return 0;
76         }
77
78         devcnt = g_slist_length(genericdmm_dev_insts);
79         if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, "Generic DMM",
80                         NULL, NULL))) {
81                 sr_err("genericdmm: sr_dev_inst_new returned NULL.");
82                 return 0;
83         }
84         sdi->priv = ctx;
85         genericdmm_dev_insts = g_slist_append(genericdmm_dev_insts, sdi);
86
87         /* Always initialized just one device instance. */
88         return 0;
89 }
90
91 static int hw_dev_open(int dev_index)
92 {
93         struct sr_dev_inst *sdi;
94         struct context *ctx;
95
96         if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
97                 sr_err("genericdmm: sdi was NULL.");
98                 return SR_ERR_BUG;
99         }
100
101         if (!(ctx = sdi->priv)) {
102                 sr_err("genericdmm: sdi->priv was NULL.");
103                 return SR_ERR_BUG;
104         }
105
106         sr_dbg("genericdmm: Opening serial port '%s'.", ctx->serial->port);
107
108         switch (ctx->profile->transport) {
109         case DMM_TRANSPORT_USBHID:
110                 /* TODO */
111                 break;
112         case DMM_TRANSPORT_SERIAL:
113                 /* TODO: O_NONBLOCK? */
114                 ctx->serial->fd = serial_open(ctx->serial->port, O_RDWR | O_NONBLOCK);
115                 if (ctx->serial->fd == -1) {
116                         sr_err("genericdmm: Couldn't open serial port '%s'.",
117                                ctx->serial->port);
118                         return SR_ERR;
119                 }
120                 //      serial_set_params(ctx->serial->fd, 2400, 8, 0, 1, 2);
121                 break;
122         default:
123                 sr_err("No transport set.");
124         }
125
126         return SR_OK;
127 }
128
129 static int hw_dev_close(int dev_index)
130 {
131         struct sr_dev_inst *sdi;
132         struct context *ctx;
133
134         if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
135                 sr_err("genericdmm: %s: sdi was NULL.", __func__);
136                 return SR_ERR_BUG;
137         }
138
139         if (!(ctx = sdi->priv)) {
140                 sr_err("genericdmm: %s: sdi->priv was NULL.", __func__);
141                 return SR_ERR_BUG;
142         }
143
144         /* TODO: Check for != NULL. */
145
146         switch (ctx->profile->transport) {
147         case DMM_TRANSPORT_USBHID:
148                 /* TODO */
149                 break;
150         case DMM_TRANSPORT_SERIAL:
151                 if (ctx->serial && ctx->serial->fd != -1) {
152                         serial_close(ctx->serial->fd);
153                         ctx->serial->fd = -1;
154                         sdi->status = SR_ST_INACTIVE;
155                 }
156                 break;
157         }
158
159         return SR_OK;
160 }
161
162 static int hw_cleanup(void)
163 {
164         GSList *l;
165         struct sr_dev_inst *sdi;
166         struct context *ctx;
167
168         /* Properly close and free all devices. */
169         for (l = genericdmm_dev_insts; l; l = l->next) {
170                 if (!(sdi = l->data)) {
171                         /* Log error, but continue cleaning up the rest. */
172                         sr_err("genericdmm: sdi was NULL, continuing.");
173                         continue;
174                 }
175                 if (!(ctx = sdi->priv)) {
176                         /* Log error, but continue cleaning up the rest. */
177                         sr_err("genericdmm: sdi->priv was NULL, continuing.");
178                         continue;
179                 }
180
181                 if (ctx->profile) {
182                         switch (ctx->profile->transport) {
183                         case DMM_TRANSPORT_USBHID:
184                                 /* TODO */
185                                 break;
186                         case DMM_TRANSPORT_SERIAL:
187                                 if (ctx->serial && ctx->serial->fd != -1)
188                                         serial_close(ctx->serial->fd);
189                                 sr_serial_dev_inst_free(ctx->serial);
190                                 break;
191                         }
192                 }
193
194                 sr_dev_inst_free(sdi);
195         }
196
197         g_slist_free(genericdmm_dev_insts);
198         genericdmm_dev_insts = NULL;
199
200         if (genericdmm_usb_context)
201                 libusb_exit(genericdmm_usb_context);
202
203         return SR_OK;
204 }
205
206 static const void *hw_dev_info_get(int dev_index, int dev_info_id)
207 {
208         struct sr_dev_inst *sdi;
209         struct context *ctx;
210         const void *info;
211
212         if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
213                 sr_err("genericdmm: sdi was NULL.");
214                 return NULL;
215         }
216
217         if (!(ctx = sdi->priv)) {
218                 sr_err("genericdmm: sdi->priv was NULL.");
219                 return NULL;
220         }
221
222                 sr_spew("genericdmm: dev_index %d, dev_info_id %d.",
223                                 dev_index, dev_info_id);
224
225         switch (dev_info_id) {
226         case SR_DI_INST:
227                 info = sdi;
228                 sr_spew("genericdmm: Returning sdi.");
229                 break;
230         case SR_DI_NUM_PROBES:
231                 info = GINT_TO_POINTER(1);
232                 sr_spew("genericdmm: Returning number of probes: 1.");
233                 break;
234         case SR_DI_PROBE_NAMES:
235                 info = probe_names;
236                 sr_spew("genericdmm: Returning probenames.");
237                 break;
238         case SR_DI_CUR_SAMPLERATE:
239                 /* TODO get rid of this */
240                 info = NULL;
241                 sr_spew("genericdmm: Returning samplerate: 0.");
242                 break;
243         default:
244                 /* Unknown device info ID. */
245                 sr_err("genericdmm: Unknown device info ID: %d.", dev_info_id);
246                 info = NULL;
247                 break;
248         }
249
250         return info;
251 }
252
253 static int hw_dev_status_get(int dev_index)
254 {
255         struct sr_dev_inst *sdi;
256
257         if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
258                 sr_err("genericdmm: sdi was NULL, device not found.");
259                 return SR_ST_NOT_FOUND;
260         }
261
262         sr_dbg("genericdmm: Returning status: %d.", sdi->status);
263
264         return sdi->status;
265 }
266
267 static const int *hw_hwcap_get_all(void)
268 {
269         sr_spew("genericdmm: Returning list of device capabilities.");
270
271         return hwcaps;
272 }
273
274 static int parse_conn_vidpid(struct sr_dev_inst *sdi, const char *conn)
275 {
276         struct context *ctx;
277         libusb_device **devlist;
278         struct libusb_device_descriptor des;
279         GRegex *reg;
280         GMatchInfo *match;
281         int vid, pid, found, err, i;
282         char *vidstr, *pidstr;
283
284         found = FALSE;
285
286         reg = g_regex_new(DMM_CONN_USB_VIDPID, 0, 0, NULL);
287         if (g_regex_match(reg, conn, 0, &match)) {
288                 /* Extract VID. */
289                 if (!(vidstr = g_match_info_fetch(match, 0))) {
290                         sr_err("failed to fetch VID from regex");
291                         goto err;
292                 }
293                 vid = strtoul(vidstr, NULL, 16);
294                 g_free(vidstr);
295                 if (vid > 0xffff) {
296                         sr_err("invalid VID");
297                         goto err;
298                 }
299
300                 /* Extract PID. */
301                 if (!(pidstr = g_match_info_fetch(match, 0))) {
302                         sr_err("failed to fetch PID from regex");
303                         goto err;
304                 }
305                 pid = strtoul(pidstr, NULL, 16);
306                 g_free(pidstr);
307                 if (pid > 0xffff) {
308                         sr_err("invalid PID");
309                         goto err;
310                 }
311
312                 /* Looks like a valid VID:PID, but is it connected? */
313                 libusb_get_device_list(genericdmm_usb_context, &devlist);
314                 for (i = 0; devlist[i]; i++) {
315                         if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
316                                 sr_err("genericdmm: failed to get device descriptor: %d", err);
317                                 goto err;
318                         }
319
320                         if (des.idVendor == vid && des.idProduct == pid) {
321                                 ctx = sdi->priv;
322                                 ctx->usb = sr_usb_dev_inst_new(
323                                                 libusb_get_bus_number(devlist[i]),
324                                                 libusb_get_device_address(devlist[i]), NULL);
325                                 found = TRUE;
326                                 break;
327                         }
328                 }
329                 libusb_free_device_list(devlist, 1);
330         }
331
332 err:
333         if (match)
334                 g_match_info_unref(match);
335         g_regex_unref(reg);
336
337         return found;
338 }
339
340 static int parse_conn_busaddr(struct sr_dev_inst *sdi, const char *conn)
341 {
342         struct context *ctx;
343         libusb_device **devlist;
344         struct libusb_device_descriptor des;
345         GRegex *reg;
346         GMatchInfo *match;
347         int bus, addr, found, err, i;
348         char *busstr, *addrstr;
349
350         found = FALSE;
351
352         reg = g_regex_new(DMM_CONN_USB_BUSADDR, 0, 0, NULL);
353         if (g_regex_match(reg, conn, 0, &match)) {
354                 /* Extract bus. */
355                 if (!(busstr = g_match_info_fetch(match, 0))) {
356                         sr_err("failed to fetch bus from regex");
357                         goto err;
358                 }
359                 bus = strtoul(busstr, NULL, 16);
360                 g_free(busstr);
361                 if (bus > 64) {
362                         sr_err("invalid bus");
363                         goto err;
364                 }
365
366                 /* Extract address. */
367                 if (!(addrstr = g_match_info_fetch(match, 0))) {
368                         sr_err("failed to fetch address from regex");
369                         goto err;
370                 }
371                 addr = strtoul(addrstr, NULL, 16);
372                 g_free(addrstr);
373                 if (addr > 127) {
374                         sr_err("invalid address");
375                         goto err;
376                 }
377
378                 /* Looks like a valid bus/address, but is it connected? */
379                 libusb_get_device_list(genericdmm_usb_context, &devlist);
380                 for (i = 0; devlist[i]; i++) {
381                         if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
382                                 sr_err("genericdmm: failed to get device descriptor: %d", err);
383                                 goto err;
384                         }
385
386                         if (libusb_get_bus_number(devlist[i]) == bus
387                                         && libusb_get_device_address(devlist[i]) == addr) {
388                                 ctx = sdi->priv;
389                                 ctx->usb = sr_usb_dev_inst_new(bus, addr, NULL);
390                                 found = TRUE;
391                                 break;
392                         }
393                 }
394                 libusb_free_device_list(devlist, 1);
395         }
396
397 err:
398         if (match)
399                 g_match_info_unref(match);
400         g_regex_unref(reg);
401
402         return found;
403 }
404
405 static int parse_conn_serial(struct sr_dev_inst *sdi, const char *conn)
406 {
407         int found;
408
409         found = FALSE;
410
411         /* TODO */
412
413         return found;
414 }
415
416 static int parse_conn(struct sr_dev_inst *sdi, const char *conn)
417 {
418
419         if (parse_conn_vidpid(sdi, conn))
420                 return SR_OK;
421
422         if (parse_conn_busaddr(sdi, conn))
423                 return SR_OK;
424
425         if (parse_conn_serial(sdi, conn))
426                 return SR_OK;
427
428         sr_err("Invalid connection specification");
429
430         return SR_ERR;
431 }
432
433 static int parse_serialcomm(struct sr_dev_inst *sdi, const char *conn)
434 {
435
436         /* TODO */
437         /* set ctx->serial_* */
438
439         return SR_OK;
440 }
441
442 static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
443 {
444         struct sr_dev_inst *sdi;
445         struct context *ctx;
446         int i;
447
448         if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
449                 sr_err("genericdmm: sdi was NULL.");
450                 return SR_ERR_BUG;
451         }
452
453         if (!(ctx = sdi->priv)) {
454                 sr_err("genericdmm: sdi->priv was NULL.");
455                 return SR_ERR_BUG;
456         }
457
458         sr_spew("genericdmm: dev_index %d, hwcap %d.", dev_index, hwcap);
459
460         switch (hwcap) {
461         case SR_HWCAP_LIMIT_MSEC:
462                 if (*(const uint64_t *)value == 0) {
463                         sr_err("genericdmm: LIMIT_MSEC can't be 0.");
464                         return SR_ERR;
465                 }
466                 ctx->limit_msec = *(const uint64_t *)value;
467                 sr_dbg("genericdmm: Setting LIMIT_MSEC to %" PRIu64 ".",
468                        ctx->limit_msec);
469                 break;
470         case SR_HWCAP_LIMIT_SAMPLES:
471                 ctx->limit_samples = *(const uint64_t *)value;
472                 sr_dbg("genericdmm: Setting LIMIT_SAMPLES to %" PRIu64 ".",
473                        ctx->limit_samples);
474                 break;
475         case SR_HWCAP_MODEL:
476                 for (i = 0; dev_profiles[i].model; i++) {
477                         if (!strcasecmp(dev_profiles[i].model, value)) {
478                                 ctx->profile = &dev_profiles[i];
479                                 /* Frontends access these fields directly, so we
480                                  * need to copy them over. */
481                                 sdi->vendor = g_strdup(dev_profiles[i].vendor);
482                                 sdi->model = g_strdup(dev_profiles[i].model);
483                                 /* This is the first time we actually know which
484                                  * DMM chip we're talking to, so let's init
485                                  * anything specific to it now */
486                                 if (ctx->profile->chip->init)
487                                         if (ctx->profile->chip->init(ctx) != SR_OK)
488                                                 return SR_ERR;
489                                 break;
490                         }
491                 }
492                 if (!ctx->profile) {
493                         sr_err("unknown model %s", value);
494                         return SR_ERR;
495                 }
496                 break;
497         case SR_HWCAP_CONN:
498                 if (parse_conn(sdi, value) != SR_OK)
499                         return SR_ERR_ARG;
500                 break;
501         case SR_HWCAP_SERIALCOMM:
502                 if (parse_serialcomm(sdi, value) != SR_OK)
503                         return SR_ERR_ARG;
504                 break;
505         default:
506                 sr_err("genericdmm: Unknown capability: %d.", hwcap);
507                 return SR_ERR;
508                 break;
509         }
510
511         return SR_OK;
512 }
513
514 static int receive_data(int fd, int revents, void *cb_data)
515 {
516         struct sr_dev_inst *sdi;
517         struct context *ctx;
518
519         if (!(sdi = cb_data))
520                 return FALSE;
521
522         if (!(ctx = sdi->priv))
523                 return FALSE;
524
525         if (revents != G_IO_IN) {
526                 sr_err("genericdmm: No data?");
527                 return FALSE;
528         }
529
530         switch (ctx->profile->transport) {
531         case DMM_TRANSPORT_USBHID:
532                 /* TODO */
533                 break;
534         case DMM_TRANSPORT_SERIAL:
535                 /* TODO */
536                 break;
537         }
538
539         return TRUE;
540 }
541
542 static int hw_dev_acquisition_start(int dev_index, void *cb_data)
543 {
544         struct sr_datafeed_packet packet;
545         struct sr_datafeed_header header;
546         struct sr_datafeed_meta_analog meta;
547         struct sr_dev_inst *sdi;
548         struct context *ctx;
549
550         if (!(sdi = sr_dev_inst_get(genericdmm_dev_insts, dev_index))) {
551                 sr_err("genericdmm: sdi was NULL.");
552                 return SR_ERR_BUG;
553         }
554
555         if (!(ctx = sdi->priv)) {
556                 sr_err("genericdmm: sdi->priv was NULL.");
557                 return SR_ERR_BUG;
558         }
559
560         sr_dbg("genericdmm: Starting acquisition.");
561
562         ctx->cb_data = cb_data;
563
564         /* Send header packet to the session bus. */
565         sr_dbg("genericdmm: Sending SR_DF_HEADER.");
566         packet.type = SR_DF_HEADER;
567         packet.payload = (uint8_t *)&header;
568         header.feed_version = 1;
569         gettimeofday(&header.starttime, NULL);
570         sr_session_send(ctx->cb_data, &packet);
571
572         /* Send metadata about the SR_DF_ANALOG packets to come. */
573         sr_dbg("genericdmm: Sending SR_DF_META_ANALOG.");
574         packet.type = SR_DF_META_ANALOG;
575         packet.payload = &meta;
576         meta.num_probes = 1;
577         sr_session_send(ctx->cb_data, &packet);
578
579         /* Hook up a proxy handler to receive data from the device. */
580         switch (ctx->profile->transport) {
581         case DMM_TRANSPORT_USBHID:
582                 /* TODO libusb FD setup */
583                 break;
584         case DMM_TRANSPORT_SERIAL:
585                 /* TODO serial FD setup */
586                 // sr_source_add(ctx->serial->fd, G_IO_IN, -1, receive_data, sdi);
587                 break;
588         }
589
590         return SR_OK;
591 }
592
593 static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
594 {
595         struct sr_datafeed_packet packet;
596
597         /* Avoid compiler warnings. */
598         (void)dev_index;
599
600         sr_dbg("genericdmm: Stopping acquisition.");
601
602         /* Send end packet to the session bus. */
603         sr_dbg("genericdmm: Sending SR_DF_END.");
604         packet.type = SR_DF_END;
605         sr_session_send(cb_data, &packet);
606
607         return SR_OK;
608 }
609
610 SR_PRIV struct sr_dev_driver genericdmm_driver_info = {
611         .name = "genericdmm",
612         .longname = "Generic DMM",
613         .api_version = 1,
614         .init = hw_init,
615         .cleanup = hw_cleanup,
616         .dev_open = hw_dev_open,
617         .dev_close = hw_dev_close,
618         .dev_info_get = hw_dev_info_get,
619         .dev_status_get = hw_dev_status_get,
620         .hwcap_get_all = hw_hwcap_get_all,
621         .dev_config_set = hw_dev_config_set,
622         .dev_acquisition_start = hw_dev_acquisition_start,
623         .dev_acquisition_stop = hw_dev_acquisition_stop,
624 };