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 sr_hwopt victor_70c_vidpid[] = {
  33         { SR_HWOPT_CONN, "1244.d237" },
  34         { 0, NULL }
  35 };
  36 static struct dev_profile dev_profiles[] = {
  37         { "victor-70c", "Victor", "70C", &dmmchip_fs9922,
  38                 DMM_TRANSPORT_USBHID, victor_70c_vidpid
  39         },
  40         { "mastech-va18b", "Mastech", "VA18B", NULL, DMM_TRANSPORT_SERIAL, NULL},
  41         { NULL, NULL, NULL, NULL, 0, NULL }
  42 };
  43
  44 static const int hwcaps[] = {
  45         SR_HWCAP_MULTIMETER,
  46         SR_HWCAP_LIMIT_SAMPLES,
  47         SR_HWCAP_LIMIT_MSEC,
  48         SR_HWCAP_CONTINUOUS,
  49         SR_HWOPT_MODEL,
  50         SR_HWOPT_CONN,
  51         SR_HWOPT_SERIALCOMM,
  52         0,
  53 };
  54
  55 static const char *probe_names[] = {
  56         "Probe",
  57         NULL,
  58 };
  59
  60 SR_PRIV struct sr_dev_driver genericdmm_driver_info;
  61 static struct sr_dev_driver *gdi = &genericdmm_driver_info;
  62 /* TODO need a way to keep this local to the static library */
  63 SR_PRIV libusb_context *genericdmm_usb_context = NULL;
  64
  65
  66 static GSList *connect_usb(const char *conn)
  67 {
  68         struct sr_dev_inst *sdi;
  69         struct context *ctx;
  70         libusb_device **devlist;
  71         struct libusb_device_descriptor des;
  72         GSList *devices;
  73         GRegex *reg;
  74         GMatchInfo *match;
  75         int vid, pid, bus, addr, devcnt, err, i;
  76         char *mstr;
  77
  78         vid = pid = bus = addr = 0;
  79         reg = g_regex_new(DMM_CONN_USB_VIDPID, 0, 0, NULL);
  80         if (g_regex_match(reg, conn, 0, &match)) {
  81                 /* Extract VID. */
  82                 if ((mstr = g_match_info_fetch(match, 1)))
  83                         vid = strtoul(mstr, NULL, 16);
  84                 g_free(mstr);
  85
  86                 /* Extract PID. */
  87                 if ((mstr = g_match_info_fetch(match, 2)))
  88                         pid = strtoul(mstr, NULL, 16);
  89                 g_free(mstr);
  90         } else {
  91                 g_match_info_unref(match);
  92                 g_regex_unref(reg);
  93                 reg = g_regex_new(DMM_CONN_USB_BUSADDR, 0, 0, NULL);
  94                 if (g_regex_match(reg, conn, 0, &match)) {
  95                         /* Extract bus. */
  96                         if ((mstr = g_match_info_fetch(match, 0)))
  97                                 bus = strtoul(mstr, NULL, 16);
  98                         g_free(mstr);
  99
 100                         /* Extract address. */
 101                         if ((mstr = g_match_info_fetch(match, 0)))
 102                                 addr = strtoul(mstr, NULL, 16);
 103                         g_free(mstr);
 104                 }
 105         }
 106         g_match_info_unref(match);
 107         g_regex_unref(reg);
 108
 109         if (vid + pid + bus + addr == 0)
 110                 return NULL;
 111
 112         if (bus > 64) {
 113                 sr_err("invalid bus");
 114                 return NULL;
 115         }
 116
 117         if (addr > 127) {
 118                 sr_err("invalid address");
 119                 return NULL;
 120         }
 121
 122         /* Looks like a valid USB device specification, but is it connected? */
 123         devices = NULL;
 124         libusb_get_device_list(genericdmm_usb_context, &devlist);
 125         for (i = 0; devlist[i]; i++) {
 126                 if ((err = libusb_get_device_descriptor(devlist[i], &des))) {
 127                         sr_err("genericdmm: failed to get device descriptor: %d", err);
 128                         continue;
 129                 }
 130
 131                 if (vid + pid && (des.idVendor != vid || des.idProduct != pid))
 132                         /* VID/PID specified, but no match. */
 133                         continue;
 134
 135                 if (bus + addr && (
 136                                 libusb_get_bus_number(devlist[i]) != bus
 137                                 || libusb_get_device_address(devlist[i]) != addr))
 138                         /* Bus/address specified, but no match. */
 139                         continue;
 140
 141                 /* Found one. */
 142                 if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
 143                         sr_err("genericdmm: ctx malloc failed.");
 144                         return 0;
 145                 }
 146
 147                 devcnt = g_slist_length(gdi->instances);
 148                 if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE,
 149                                 "Generic DMM", NULL, NULL))) {
 150                         sr_err("genericdmm: sr_dev_inst_new returned NULL.");
 151                         return NULL;
 152                 }
 153                 sdi->priv = ctx;
 154                 ctx->usb = sr_usb_dev_inst_new(
 155                                 libusb_get_bus_number(devlist[i]),
 156                                 libusb_get_device_address(devlist[i]), NULL);
 157                 devices = g_slist_append(devices, sdi);
 158         }
 159         libusb_free_device_list(devlist, 1);
 160
 161         return devices;
 162 }
 163
 164 static GSList *connect_serial(const char *conn, const char *serialcomm)
 165 {
 166         GSList *devices;
 167
 168         devices = NULL;
 169
 170         /* TODO */
 171         sr_dbg("not yet implemented");
 172
 173         return devices;
 174 }
 175
 176 GSList *genericdmm_connect(const char *conn, const char *serialcomm)
 177 {
 178         GSList *devices;
 179
 180         if (serialcomm)
 181                 /* Must be a serial port. */
 182                 return connect_serial(conn, serialcomm);
 183
 184         if ((devices = connect_usb(conn)))
 185                 return devices;
 186
 187         return NULL;
 188 }
 189
 190 static GSList *default_scan(GSList *options)
 191 {
 192         GSList *l, *devices;
 193         struct sr_hwopt *opt;
 194         const char *conn, *serialcomm;
 195
 196         devices = NULL;
 197         conn = serialcomm = NULL;
 198         for (l = options; l; l = l->next) {
 199                 opt = l->data;
 200                 switch (opt->hwopt) {
 201                 case SR_HWOPT_CONN:
 202                         conn = opt->value;
 203                         break;
 204                 case SR_HWOPT_SERIALCOMM:
 205                         serialcomm = opt->value;
 206                         break;
 207                 }
 208         }
 209         if (conn)
 210                 devices = genericdmm_connect(conn, serialcomm);
 211
 212         return devices;
 213 }
 214
 215 static int hw_init(void)
 216 {
 217
 218         if (libusb_init(&genericdmm_usb_context) != 0) {
 219                 sr_err("genericdmm: Failed to initialize USB.");
 220                 return SR_ERR;
 221         }
 222
 223
 224         return SR_OK;
 225 }
 226
 227 static GSList *hw_scan(GSList *options)
 228 {
 229         GSList *l, *ldef, *defopts, *newopts, *devices;
 230         struct sr_hwopt *opt, *defopt;
 231         struct dev_profile *pr, *profile;
 232         const char *model;
 233
 234         /* Separate model from the options list. */
 235         model = NULL;
 236         newopts = NULL;
 237         for (l = options; l; l = l->next) {
 238                 opt = l->data;
 239                 if (opt->hwopt == SR_HWOPT_MODEL)
 240                         model = opt->value;
 241                 else
 242                         /* New list with references to the original data. */
 243                         newopts = g_slist_append(newopts, opt);
 244         }
 245         if (!model) {
 246                 sr_err("Need a model to scan for.");
 247                 return NULL;
 248         }
 249
 250         /* Find a profile with this model name. */
 251         profile = NULL;
 252         for (pr = dev_profiles; pr->modelid; pr++) {
 253                 if (!strcmp(pr->modelid, model)) {
 254                         profile = pr;
 255                         break;
 256                 }
 257         }
 258         if (!profile) {
 259                 sr_err("Unknown model %s.", model);
 260                 return NULL;
 261         }
 262
 263         /* Initialize the DMM chip driver. */
 264         if (profile->chip->init)
 265                 profile->chip->init();
 266
 267         /* Convert the profile's default options list to a GSList. */
 268         defopts = NULL;
 269         for (opt = profile->defaults_opts; opt->hwopt; opt++) {
 270                 /* New list with references to const data in the profile. */
 271                 defopts = g_slist_append(defopts, opt);
 272         }
 273
 274         /* Options given as argument to this function override the
 275          * profile's default options.
 276          */
 277         for (ldef = defopts; ldef; ldef = ldef->next) {
 278                 defopt = ldef->data;
 279                 for (l = newopts; l; l = l->next) {
 280                         opt = l->data;
 281                         if (opt->hwopt == defopt->hwopt) {
 282                                 /* Override the default, and drop it from the
 283                                  * options list.
 284                                  */
 285                                 ldef->data = l->data;
 286                                 newopts = g_slist_remove(newopts, opt);
 287                                 break;
 288                         }
 289                 }
 290         }
 291         /* Whatever is left in newopts wasn't in the default options. */
 292         defopts = g_slist_concat(defopts, newopts);
 293         g_slist_free(newopts);
 294
 295         if (profile->chip->scan)
 296                 /* The DMM chip driver wants to do its own scanning. */
 297                 devices = profile->chip->scan(defopts);
 298         else
 299                 devices = default_scan(defopts);
 300         g_slist_free(defopts);
 301
 302         if (devices) {
 303                 /* TODO: need to fix up sdi->index fields */
 304                 /* Add a copy of these new devices to the driver instances. */
 305                 for (l = devices; l; l = l->next)
 306                         gdi->instances = g_slist_append(gdi->instances, l->data);
 307         }
 308
 309         return devices;
 310 }
 311
 312 static int hw_dev_open(int dev_index)
 313 {
 314         struct sr_dev_inst *sdi;
 315         struct context *ctx;
 316
 317         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 318                 sr_err("genericdmm: sdi was NULL.");
 319                 return SR_ERR_BUG;
 320         }
 321
 322         if (!(ctx = sdi->priv)) {
 323                 sr_err("genericdmm: sdi->priv was NULL.");
 324                 return SR_ERR_BUG;
 325         }
 326
 327         sr_dbg("genericdmm: Opening serial port '%s'.", ctx->serial->port);
 328
 329         switch (ctx->profile->transport) {
 330         case DMM_TRANSPORT_USBHID:
 331                 /* TODO */
 332                 break;
 333         case DMM_TRANSPORT_SERIAL:
 334                 /* TODO: O_NONBLOCK? */
 335                 ctx->serial->fd = serial_open(ctx->serial->port, O_RDWR | O_NONBLOCK);
 336                 if (ctx->serial->fd == -1) {
 337                         sr_err("genericdmm: Couldn't open serial port '%s'.",
 338                                ctx->serial->port);
 339                         return SR_ERR;
 340                 }
 341                 //      serial_set_params(ctx->serial->fd, 2400, 8, 0, 1, 2);
 342                 break;
 343         default:
 344                 sr_err("No transport set.");
 345         }
 346
 347         return SR_OK;
 348 }
 349
 350 static int hw_dev_close(int dev_index)
 351 {
 352         struct sr_dev_inst *sdi;
 353         struct context *ctx;
 354
 355         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 356                 sr_err("genericdmm: %s: sdi was NULL.", __func__);
 357                 return SR_ERR_BUG;
 358         }
 359
 360         if (!(ctx = sdi->priv)) {
 361                 sr_err("genericdmm: %s: sdi->priv was NULL.", __func__);
 362                 return SR_ERR_BUG;
 363         }
 364
 365         /* TODO: Check for != NULL. */
 366
 367         switch (ctx->profile->transport) {
 368         case DMM_TRANSPORT_USBHID:
 369                 /* TODO */
 370                 break;
 371         case DMM_TRANSPORT_SERIAL:
 372                 if (ctx->serial && ctx->serial->fd != -1) {
 373                         serial_close(ctx->serial->fd);
 374                         ctx->serial->fd = -1;
 375                         sdi->status = SR_ST_INACTIVE;
 376                 }
 377                 break;
 378         }
 379
 380         return SR_OK;
 381 }
 382
 383 static int hw_cleanup(void)
 384 {
 385         GSList *l;
 386         struct sr_dev_inst *sdi;
 387         struct context *ctx;
 388
 389         /* Properly close and free all devices. */
 390         for (l = gdi->instances; l; l = l->next) {
 391                 if (!(sdi = l->data)) {
 392                         /* Log error, but continue cleaning up the rest. */
 393                         sr_err("genericdmm: sdi was NULL, continuing.");
 394                         continue;
 395                 }
 396                 if (!(ctx = sdi->priv)) {
 397                         /* Log error, but continue cleaning up the rest. */
 398                         sr_err("genericdmm: sdi->priv was NULL, continuing.");
 399                         continue;
 400                 }
 401
 402                 if (ctx->profile) {
 403                         switch (ctx->profile->transport) {
 404                         case DMM_TRANSPORT_USBHID:
 405                                 /* TODO */
 406                                 break;
 407                         case DMM_TRANSPORT_SERIAL:
 408                                 if (ctx->serial && ctx->serial->fd != -1)
 409                                         serial_close(ctx->serial->fd);
 410                                 sr_serial_dev_inst_free(ctx->serial);
 411                                 break;
 412                         }
 413                 }
 414
 415                 sr_dev_inst_free(sdi);
 416         }
 417
 418         g_slist_free(gdi->instances);
 419         gdi->instances = NULL;
 420
 421         if (genericdmm_usb_context)
 422                 libusb_exit(genericdmm_usb_context);
 423
 424         return SR_OK;
 425 }
 426
 427 static const void *hw_dev_info_get(int dev_index, int dev_info_id)
 428 {
 429         struct sr_dev_inst *sdi;
 430         struct context *ctx;
 431         const void *info;
 432
 433         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 434                 sr_err("genericdmm: sdi was NULL.");
 435                 return NULL;
 436         }
 437
 438         if (!(ctx = sdi->priv)) {
 439                 sr_err("genericdmm: sdi->priv was NULL.");
 440                 return NULL;
 441         }
 442
 443                 sr_spew("genericdmm: dev_index %d, dev_info_id %d.",
 444                                 dev_index, dev_info_id);
 445
 446         switch (dev_info_id) {
 447         case SR_DI_INST:
 448                 info = sdi;
 449                 sr_spew("genericdmm: Returning sdi.");
 450                 break;
 451         case SR_DI_NUM_PROBES:
 452                 info = GINT_TO_POINTER(1);
 453                 sr_spew("genericdmm: Returning number of probes: 1.");
 454                 break;
 455         case SR_DI_PROBE_NAMES:
 456                 info = probe_names;
 457                 sr_spew("genericdmm: Returning probenames.");
 458                 break;
 459         case SR_DI_CUR_SAMPLERATE:
 460                 /* TODO get rid of this */
 461                 info = NULL;
 462                 sr_spew("genericdmm: Returning samplerate: 0.");
 463                 break;
 464         default:
 465                 /* Unknown device info ID. */
 466                 sr_err("genericdmm: Unknown device info ID: %d.", dev_info_id);
 467                 info = NULL;
 468                 break;
 469         }
 470
 471         return info;
 472 }
 473
 474 static int hw_dev_status_get(int dev_index)
 475 {
 476         struct sr_dev_inst *sdi;
 477
 478         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 479                 sr_err("genericdmm: sdi was NULL, device not found.");
 480                 return SR_ST_NOT_FOUND;
 481         }
 482
 483         sr_dbg("genericdmm: Returning status: %d.", sdi->status);
 484
 485         return sdi->status;
 486 }
 487
 488 static const int *hw_hwcap_get_all(void)
 489 {
 490         sr_spew("genericdmm: Returning list of device capabilities.");
 491
 492         return hwcaps;
 493 }
 494
 495 static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
 496 {
 497         struct sr_dev_inst *sdi;
 498         struct context *ctx;
 499
 500         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 501                 sr_err("genericdmm: sdi was NULL.");
 502                 return SR_ERR_BUG;
 503         }
 504
 505         if (!(ctx = sdi->priv)) {
 506                 sr_err("genericdmm: sdi->priv was NULL.");
 507                 return SR_ERR_BUG;
 508         }
 509
 510         sr_spew("genericdmm: dev_index %d, hwcap %d.", dev_index, hwcap);
 511
 512         switch (hwcap) {
 513         case SR_HWCAP_LIMIT_MSEC:
 514                 if (*(const uint64_t *)value == 0) {
 515                         sr_err("genericdmm: LIMIT_MSEC can't be 0.");
 516                         return SR_ERR;
 517                 }
 518                 ctx->limit_msec = *(const uint64_t *)value;
 519                 sr_dbg("genericdmm: Setting LIMIT_MSEC to %" PRIu64 ".",
 520                        ctx->limit_msec);
 521                 break;
 522         case SR_HWCAP_LIMIT_SAMPLES:
 523                 ctx->limit_samples = *(const uint64_t *)value;
 524                 sr_dbg("genericdmm: Setting LIMIT_SAMPLES to %" PRIu64 ".",
 525                        ctx->limit_samples);
 526                 break;
 527         default:
 528                 sr_err("genericdmm: Unknown capability: %d.", hwcap);
 529                 return SR_ERR;
 530                 break;
 531         }
 532
 533         return SR_OK;
 534 }
 535
 536 static int receive_data(int fd, int revents, void *cb_data)
 537 {
 538         struct sr_dev_inst *sdi;
 539         struct context *ctx;
 540
 541         if (!(sdi = cb_data))
 542                 return FALSE;
 543
 544         if (!(ctx = sdi->priv))
 545                 return FALSE;
 546
 547         if (revents != G_IO_IN) {
 548                 sr_err("genericdmm: No data?");
 549                 return FALSE;
 550         }
 551
 552         switch (ctx->profile->transport) {
 553         case DMM_TRANSPORT_USBHID:
 554                 /* TODO */
 555                 break;
 556         case DMM_TRANSPORT_SERIAL:
 557                 /* TODO */
 558                 break;
 559         }
 560
 561         return TRUE;
 562 }
 563
 564 static int hw_dev_acquisition_start(int dev_index, void *cb_data)
 565 {
 566         struct sr_datafeed_packet packet;
 567         struct sr_datafeed_header header;
 568         struct sr_datafeed_meta_analog meta;
 569         struct sr_dev_inst *sdi;
 570         struct context *ctx;
 571
 572         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 573                 sr_err("genericdmm: sdi was NULL.");
 574                 return SR_ERR_BUG;
 575         }
 576
 577         if (!(ctx = sdi->priv)) {
 578                 sr_err("genericdmm: sdi->priv was NULL.");
 579                 return SR_ERR_BUG;
 580         }
 581
 582         sr_dbg("genericdmm: Starting acquisition.");
 583
 584         ctx->cb_data = cb_data;
 585
 586         /* Send header packet to the session bus. */
 587         sr_dbg("genericdmm: Sending SR_DF_HEADER.");
 588         packet.type = SR_DF_HEADER;
 589         packet.payload = (uint8_t *)&header;
 590         header.feed_version = 1;
 591         gettimeofday(&header.starttime, NULL);
 592         sr_session_send(ctx->cb_data, &packet);
 593
 594         /* Send metadata about the SR_DF_ANALOG packets to come. */
 595         sr_dbg("genericdmm: Sending SR_DF_META_ANALOG.");
 596         packet.type = SR_DF_META_ANALOG;
 597         packet.payload = &meta;
 598         meta.num_probes = 1;
 599         sr_session_send(ctx->cb_data, &packet);
 600
 601         /* Hook up a proxy handler to receive data from the device. */
 602         switch (ctx->profile->transport) {
 603         case DMM_TRANSPORT_USBHID:
 604                 /* TODO libusb FD setup */
 605                 break;
 606         case DMM_TRANSPORT_SERIAL:
 607                 /* TODO serial FD setup */
 608                 // sr_source_add(ctx->serial->fd, G_IO_IN, -1, receive_data, sdi);
 609                 break;
 610         }
 611
 612         return SR_OK;
 613 }
 614
 615 static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
 616 {
 617         struct sr_datafeed_packet packet;
 618
 619         /* Avoid compiler warnings. */
 620         (void)dev_index;
 621
 622         sr_dbg("genericdmm: Stopping acquisition.");
 623
 624         /* Send end packet to the session bus. */
 625         sr_dbg("genericdmm: Sending SR_DF_END.");
 626         packet.type = SR_DF_END;
 627         sr_session_send(cb_data, &packet);
 628
 629         return SR_OK;
 630 }
 631
 632 SR_PRIV struct sr_dev_driver genericdmm_driver_info = {
 633         .name = "genericdmm",
 634         .longname = "Generic DMM",
 635         .api_version = 1,
 636         .init = hw_init,
 637         .cleanup = hw_cleanup,
 638         .scan = hw_scan,
 639         .dev_open = hw_dev_open,
 640         .dev_close = hw_dev_close,
 641         .dev_info_get = hw_dev_info_get,
 642         .dev_status_get = hw_dev_status_get,
 643         .hwcap_get_all = hw_hwcap_get_all,
 644         .dev_config_set = hw_dev_config_set,
 645         .dev_acquisition_start = hw_dev_acquisition_start,
 646         .dev_acquisition_stop = hw_dev_acquisition_stop,
 647         .instances = NULL,
 648 };