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 int hw_init(void)
 191 {
 192
 193         if (libusb_init(&genericdmm_usb_context) != 0) {
 194                 sr_err("genericdmm: Failed to initialize USB.");
 195                 return SR_ERR;
 196         }
 197
 198
 199         return SR_OK;
 200 }
 201
 202 static int hw_scan(void)
 203 {
 204         struct sr_dev_inst *sdi;
 205         struct context *ctx;
 206         int devcnt = 0;
 207
 208         if (!(ctx = g_try_malloc0(sizeof(struct context)))) {
 209                 sr_err("genericdmm: ctx malloc failed.");
 210                 return 0;
 211         }
 212
 213         devcnt = g_slist_length(genericdmm_dev_insts);
 214         if (!(sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, "Generic DMM",
 215                         NULL, NULL))) {
 216                 sr_err("genericdmm: sr_dev_inst_new returned NULL.");
 217                 return 0;
 218         }
 219         sdi->priv = ctx;
 220         genericdmm_dev_insts = g_slist_append(genericdmm_dev_insts, sdi);
 221
 222         /* Always initialized just one device instance. */
 223         return 0;
 224 }
 225
 226 static int hw_dev_open(int dev_index)
 227 {
 228         struct sr_dev_inst *sdi;
 229         struct context *ctx;
 230
 231         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 232                 sr_err("genericdmm: sdi was NULL.");
 233                 return SR_ERR_BUG;
 234         }
 235
 236         if (!(ctx = sdi->priv)) {
 237                 sr_err("genericdmm: sdi->priv was NULL.");
 238                 return SR_ERR_BUG;
 239         }
 240
 241         sr_dbg("genericdmm: Opening serial port '%s'.", ctx->serial->port);
 242
 243         switch (ctx->profile->transport) {
 244         case DMM_TRANSPORT_USBHID:
 245                 /* TODO */
 246                 break;
 247         case DMM_TRANSPORT_SERIAL:
 248                 /* TODO: O_NONBLOCK? */
 249                 ctx->serial->fd = serial_open(ctx->serial->port, O_RDWR | O_NONBLOCK);
 250                 if (ctx->serial->fd == -1) {
 251                         sr_err("genericdmm: Couldn't open serial port '%s'.",
 252                                ctx->serial->port);
 253                         return SR_ERR;
 254                 }
 255                 //      serial_set_params(ctx->serial->fd, 2400, 8, 0, 1, 2);
 256                 break;
 257         default:
 258                 sr_err("No transport set.");
 259         }
 260
 261         return SR_OK;
 262 }
 263
 264 static int hw_dev_close(int dev_index)
 265 {
 266         struct sr_dev_inst *sdi;
 267         struct context *ctx;
 268
 269         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 270                 sr_err("genericdmm: %s: sdi was NULL.", __func__);
 271                 return SR_ERR_BUG;
 272         }
 273
 274         if (!(ctx = sdi->priv)) {
 275                 sr_err("genericdmm: %s: sdi->priv was NULL.", __func__);
 276                 return SR_ERR_BUG;
 277         }
 278
 279         /* TODO: Check for != NULL. */
 280
 281         switch (ctx->profile->transport) {
 282         case DMM_TRANSPORT_USBHID:
 283                 /* TODO */
 284                 break;
 285         case DMM_TRANSPORT_SERIAL:
 286                 if (ctx->serial && ctx->serial->fd != -1) {
 287                         serial_close(ctx->serial->fd);
 288                         ctx->serial->fd = -1;
 289                         sdi->status = SR_ST_INACTIVE;
 290                 }
 291                 break;
 292         }
 293
 294         return SR_OK;
 295 }
 296
 297 static int hw_cleanup(void)
 298 {
 299         GSList *l;
 300         struct sr_dev_inst *sdi;
 301         struct context *ctx;
 302
 303         /* Properly close and free all devices. */
 304         for (l = gdi->instances; l; l = l->next) {
 305                 if (!(sdi = l->data)) {
 306                         /* Log error, but continue cleaning up the rest. */
 307                         sr_err("genericdmm: sdi was NULL, continuing.");
 308                         continue;
 309                 }
 310                 if (!(ctx = sdi->priv)) {
 311                         /* Log error, but continue cleaning up the rest. */
 312                         sr_err("genericdmm: sdi->priv was NULL, continuing.");
 313                         continue;
 314                 }
 315
 316                 if (ctx->profile) {
 317                         switch (ctx->profile->transport) {
 318                         case DMM_TRANSPORT_USBHID:
 319                                 /* TODO */
 320                                 break;
 321                         case DMM_TRANSPORT_SERIAL:
 322                                 if (ctx->serial && ctx->serial->fd != -1)
 323                                         serial_close(ctx->serial->fd);
 324                                 sr_serial_dev_inst_free(ctx->serial);
 325                                 break;
 326                         }
 327                 }
 328
 329                 sr_dev_inst_free(sdi);
 330         }
 331
 332         g_slist_free(gdi->instances);
 333         gdi->instances = NULL;
 334
 335         if (genericdmm_usb_context)
 336                 libusb_exit(genericdmm_usb_context);
 337
 338         return SR_OK;
 339 }
 340
 341 static const void *hw_dev_info_get(int dev_index, int dev_info_id)
 342 {
 343         struct sr_dev_inst *sdi;
 344         struct context *ctx;
 345         const void *info;
 346
 347         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 348                 sr_err("genericdmm: sdi was NULL.");
 349                 return NULL;
 350         }
 351
 352         if (!(ctx = sdi->priv)) {
 353                 sr_err("genericdmm: sdi->priv was NULL.");
 354                 return NULL;
 355         }
 356
 357                 sr_spew("genericdmm: dev_index %d, dev_info_id %d.",
 358                                 dev_index, dev_info_id);
 359
 360         switch (dev_info_id) {
 361         case SR_DI_INST:
 362                 info = sdi;
 363                 sr_spew("genericdmm: Returning sdi.");
 364                 break;
 365         case SR_DI_NUM_PROBES:
 366                 info = GINT_TO_POINTER(1);
 367                 sr_spew("genericdmm: Returning number of probes: 1.");
 368                 break;
 369         case SR_DI_PROBE_NAMES:
 370                 info = probe_names;
 371                 sr_spew("genericdmm: Returning probenames.");
 372                 break;
 373         case SR_DI_CUR_SAMPLERATE:
 374                 /* TODO get rid of this */
 375                 info = NULL;
 376                 sr_spew("genericdmm: Returning samplerate: 0.");
 377                 break;
 378         default:
 379                 /* Unknown device info ID. */
 380                 sr_err("genericdmm: Unknown device info ID: %d.", dev_info_id);
 381                 info = NULL;
 382                 break;
 383         }
 384
 385         return info;
 386 }
 387
 388 static int hw_dev_status_get(int dev_index)
 389 {
 390         struct sr_dev_inst *sdi;
 391
 392         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 393                 sr_err("genericdmm: sdi was NULL, device not found.");
 394                 return SR_ST_NOT_FOUND;
 395         }
 396
 397         sr_dbg("genericdmm: Returning status: %d.", sdi->status);
 398
 399         return sdi->status;
 400 }
 401
 402 static const int *hw_hwcap_get_all(void)
 403 {
 404         sr_spew("genericdmm: Returning list of device capabilities.");
 405
 406         return hwcaps;
 407 }
 408
 409 static int hw_dev_config_set(int dev_index, int hwcap, const void *value)
 410 {
 411         struct sr_dev_inst *sdi;
 412         struct context *ctx;
 413
 414         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 415                 sr_err("genericdmm: sdi was NULL.");
 416                 return SR_ERR_BUG;
 417         }
 418
 419         if (!(ctx = sdi->priv)) {
 420                 sr_err("genericdmm: sdi->priv was NULL.");
 421                 return SR_ERR_BUG;
 422         }
 423
 424         sr_spew("genericdmm: dev_index %d, hwcap %d.", dev_index, hwcap);
 425
 426         switch (hwcap) {
 427         case SR_HWCAP_LIMIT_MSEC:
 428                 if (*(const uint64_t *)value == 0) {
 429                         sr_err("genericdmm: LIMIT_MSEC can't be 0.");
 430                         return SR_ERR;
 431                 }
 432                 ctx->limit_msec = *(const uint64_t *)value;
 433                 sr_dbg("genericdmm: Setting LIMIT_MSEC to %" PRIu64 ".",
 434                        ctx->limit_msec);
 435                 break;
 436         case SR_HWCAP_LIMIT_SAMPLES:
 437                 ctx->limit_samples = *(const uint64_t *)value;
 438                 sr_dbg("genericdmm: Setting LIMIT_SAMPLES to %" PRIu64 ".",
 439                        ctx->limit_samples);
 440                 break;
 441         default:
 442                 sr_err("genericdmm: Unknown capability: %d.", hwcap);
 443                 return SR_ERR;
 444                 break;
 445         }
 446
 447         return SR_OK;
 448 }
 449
 450 static int receive_data(int fd, int revents, void *cb_data)
 451 {
 452         struct sr_dev_inst *sdi;
 453         struct context *ctx;
 454
 455         if (!(sdi = cb_data))
 456                 return FALSE;
 457
 458         if (!(ctx = sdi->priv))
 459                 return FALSE;
 460
 461         if (revents != G_IO_IN) {
 462                 sr_err("genericdmm: No data?");
 463                 return FALSE;
 464         }
 465
 466         switch (ctx->profile->transport) {
 467         case DMM_TRANSPORT_USBHID:
 468                 /* TODO */
 469                 break;
 470         case DMM_TRANSPORT_SERIAL:
 471                 /* TODO */
 472                 break;
 473         }
 474
 475         return TRUE;
 476 }
 477
 478 static int hw_dev_acquisition_start(int dev_index, void *cb_data)
 479 {
 480         struct sr_datafeed_packet packet;
 481         struct sr_datafeed_header header;
 482         struct sr_datafeed_meta_analog meta;
 483         struct sr_dev_inst *sdi;
 484         struct context *ctx;
 485
 486         if (!(sdi = sr_dev_inst_get(gdi->instances, dev_index))) {
 487                 sr_err("genericdmm: sdi was NULL.");
 488                 return SR_ERR_BUG;
 489         }
 490
 491         if (!(ctx = sdi->priv)) {
 492                 sr_err("genericdmm: sdi->priv was NULL.");
 493                 return SR_ERR_BUG;
 494         }
 495
 496         sr_dbg("genericdmm: Starting acquisition.");
 497
 498         ctx->cb_data = cb_data;
 499
 500         /* Send header packet to the session bus. */
 501         sr_dbg("genericdmm: Sending SR_DF_HEADER.");
 502         packet.type = SR_DF_HEADER;
 503         packet.payload = (uint8_t *)&header;
 504         header.feed_version = 1;
 505         gettimeofday(&header.starttime, NULL);
 506         sr_session_send(ctx->cb_data, &packet);
 507
 508         /* Send metadata about the SR_DF_ANALOG packets to come. */
 509         sr_dbg("genericdmm: Sending SR_DF_META_ANALOG.");
 510         packet.type = SR_DF_META_ANALOG;
 511         packet.payload = &meta;
 512         meta.num_probes = 1;
 513         sr_session_send(ctx->cb_data, &packet);
 514
 515         /* Hook up a proxy handler to receive data from the device. */
 516         switch (ctx->profile->transport) {
 517         case DMM_TRANSPORT_USBHID:
 518                 /* TODO libusb FD setup */
 519                 break;
 520         case DMM_TRANSPORT_SERIAL:
 521                 /* TODO serial FD setup */
 522                 // sr_source_add(ctx->serial->fd, G_IO_IN, -1, receive_data, sdi);
 523                 break;
 524         }
 525
 526         return SR_OK;
 527 }
 528
 529 static int hw_dev_acquisition_stop(int dev_index, void *cb_data)
 530 {
 531         struct sr_datafeed_packet packet;
 532
 533         /* Avoid compiler warnings. */
 534         (void)dev_index;
 535
 536         sr_dbg("genericdmm: Stopping acquisition.");
 537
 538         /* Send end packet to the session bus. */
 539         sr_dbg("genericdmm: Sending SR_DF_END.");
 540         packet.type = SR_DF_END;
 541         sr_session_send(cb_data, &packet);
 542
 543         return SR_OK;
 544 }
 545
 546 SR_PRIV struct sr_dev_driver genericdmm_driver_info = {
 547         .name = "genericdmm",
 548         .longname = "Generic DMM",
 549         .api_version = 1,
 550         .init = hw_init,
 551         .cleanup = hw_cleanup,
 552         .scan = hw_scan,
 553         .dev_open = hw_dev_open,
 554         .dev_close = hw_dev_close,
 555         .dev_info_get = hw_dev_info_get,
 556         .dev_status_get = hw_dev_status_get,
 557         .hwcap_get_all = hw_hwcap_get_all,
 558         .dev_config_set = hw_dev_config_set,
 559         .dev_acquisition_start = hw_dev_acquisition_start,
 560         .dev_acquisition_stop = hw_dev_acquisition_stop,
 561         .instances = NULL,
 562 };