src/hardware/sysclk-lwla/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2014 Daniel Elstner <daniel.kitta@gmail.com>
   5  *
   6  * This program is free software: you can redistribute it and/or modify
   7  * it under the terms of the GNU General Public License as published by
   8  * the Free Software Foundation, either version 3 of the License, or
   9  * (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  * GNU General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #include "protocol.h"
  21 #include "libsigrok.h"
  22 #include "libsigrok-internal.h"
  23 #include <glib.h>
  24 #include <libusb.h>
  25 #include <stdlib.h>
  26 #include <string.h>
  27
  28 static const uint32_t scanopts[] = {
  29         SR_CONF_CONN,
  30 };
  31
  32 static const uint32_t devopts[] = {
  33         SR_CONF_LOGIC_ANALYZER,
  34         SR_CONF_LIMIT_SAMPLES | SR_CONF_GET | SR_CONF_SET,
  35         SR_CONF_LIMIT_MSEC | SR_CONF_GET | SR_CONF_SET,
  36         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  37         SR_CONF_EXTERNAL_CLOCK | SR_CONF_GET | SR_CONF_SET,
  38         SR_CONF_CLOCK_EDGE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  39         SR_CONF_TRIGGER_MATCH | SR_CONF_LIST,
  40         SR_CONF_TRIGGER_SOURCE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  41         SR_CONF_TRIGGER_SLOPE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  42 };
  43
  44 static const int32_t trigger_matches[] = {
  45         SR_TRIGGER_ZERO,
  46         SR_TRIGGER_ONE,
  47         SR_TRIGGER_RISING,
  48         SR_TRIGGER_FALLING,
  49 };
  50
  51 /* The hardware supports more samplerates than these, but these are the
  52  * options hardcoded into the vendor's Windows GUI.
  53  */
  54 static const uint64_t samplerates[] = {
  55         SR_MHZ(125), SR_MHZ(100),
  56         SR_MHZ(50),  SR_MHZ(20),  SR_MHZ(10),
  57         SR_MHZ(5),   SR_MHZ(2),   SR_MHZ(1),
  58         SR_KHZ(500), SR_KHZ(200), SR_KHZ(100),
  59         SR_KHZ(50),  SR_KHZ(20),  SR_KHZ(10),
  60         SR_KHZ(5),   SR_KHZ(2),   SR_KHZ(1),
  61         SR_HZ(500),  SR_HZ(200),  SR_HZ(100),
  62 };
  63
  64 /* Names assigned to available trigger sources.  Indices must match
  65  * trigger_source enum values.
  66  */
  67 static const char *const trigger_source_names[] = { "CH", "TRG" };
  68
  69 /* Names assigned to available trigger slope choices.  Indices must
  70  * match the signal_edge enum values.
  71  */
  72 static const char *const signal_edge_names[] = { "r", "f" };
  73
  74 SR_PRIV struct sr_dev_driver sysclk_lwla_driver_info;
  75 static struct sr_dev_driver *const di = &sysclk_lwla_driver_info;
  76
  77 static int init(struct sr_context *sr_ctx)
  78 {
  79         return std_init(sr_ctx, di, LOG_PREFIX);
  80 }
  81
  82 static GSList *gen_channel_list(int num_channels)
  83 {
  84         GSList *list;
  85         struct sr_channel *ch;
  86         int i;
  87         char name[8];
  88
  89         list = NULL;
  90
  91         for (i = num_channels; i > 0; --i) {
  92                 /* The LWLA series simply number channels from CH1 to CHxx. */
  93                 g_snprintf(name, sizeof(name), "CH%d", i);
  94
  95                 ch = sr_channel_new(i - 1, SR_CHANNEL_LOGIC, TRUE, name);
  96                 list = g_slist_prepend(list, ch);
  97         }
  98
  99         return list;
 100 }
 101
 102 static struct sr_dev_inst *dev_inst_new(void)
 103 {
 104         struct sr_dev_inst *sdi;
 105         struct dev_context *devc;
 106
 107         /* Allocate memory for our private driver context. */
 108         devc = g_try_new0(struct dev_context, 1);
 109         if (!devc) {
 110                 sr_err("Device context malloc failed.");
 111                 return NULL;
 112         }
 113
 114         /* Register the device with libsigrok. */
 115         sdi = sr_dev_inst_new();
 116         sdi->status = SR_ST_INACTIVE;
 117         sdi->vendor = g_strdup(VENDOR_NAME);
 118         sdi->model = g_strdup(MODEL_NAME);
 119
 120         /* Enable all channels to match the default channel configuration. */
 121         devc->channel_mask = ALL_CHANNELS_MASK;
 122         devc->samplerate = DEFAULT_SAMPLERATE;
 123
 124         sdi->priv = devc;
 125         sdi->channels = gen_channel_list(NUM_CHANNELS);
 126
 127         return sdi;
 128 }
 129
 130 static GSList *scan(GSList *options)
 131 {
 132         GSList *usb_devices, *devices, *node;
 133         struct drv_context *drvc;
 134         struct sr_dev_inst *sdi;
 135         struct sr_usb_dev_inst *usb;
 136         struct sr_config *src;
 137         const char *conn;
 138
 139         drvc = di->priv;
 140         conn = USB_VID_PID;
 141
 142         for (node = options; node != NULL; node = node->next) {
 143                 src = node->data;
 144                 if (src->key == SR_CONF_CONN) {
 145                         conn = g_variant_get_string(src->data, NULL);
 146                         break;
 147                 }
 148         }
 149         usb_devices = sr_usb_find(drvc->sr_ctx->libusb_ctx, conn);
 150         devices = NULL;
 151
 152         for (node = usb_devices; node != NULL; node = node->next) {
 153                 usb = node->data;
 154
 155                 /* Create sigrok device instance. */
 156                 sdi = dev_inst_new();
 157                 if (!sdi) {
 158                         sr_usb_dev_inst_free(usb);
 159                         continue;
 160                 }
 161                 sdi->driver = di;
 162                 sdi->inst_type = SR_INST_USB;
 163                 sdi->conn = usb;
 164
 165                 /* Register device instance with driver. */
 166                 drvc->instances = g_slist_append(drvc->instances, sdi);
 167                 devices = g_slist_append(devices, sdi);
 168         }
 169
 170         g_slist_free(usb_devices);
 171
 172         return devices;
 173 }
 174
 175 static GSList *dev_list(void)
 176 {
 177         struct drv_context *drvc;
 178
 179         drvc = di->priv;
 180
 181         return drvc->instances;
 182 }
 183
 184 static void clear_dev_context(void *priv)
 185 {
 186         struct dev_context *devc;
 187
 188         devc = priv;
 189
 190         sr_dbg("Device context cleared.");
 191
 192         lwla_free_acquisition_state(devc->acquisition);
 193         g_free(devc);
 194 }
 195
 196 static int dev_clear(void)
 197 {
 198         return std_dev_clear(di, &clear_dev_context);
 199 }
 200
 201 static int dev_open(struct sr_dev_inst *sdi)
 202 {
 203         struct drv_context *drvc;
 204         struct sr_usb_dev_inst *usb;
 205         int ret;
 206
 207         drvc = di->priv;
 208
 209         if (!drvc) {
 210                 sr_err("Driver was not initialized.");
 211                 return SR_ERR;
 212         }
 213
 214         usb = sdi->conn;
 215
 216         ret = sr_usb_open(drvc->sr_ctx->libusb_ctx, usb);
 217         if (ret != SR_OK)
 218                 return ret;
 219
 220         ret = libusb_claim_interface(usb->devhdl, USB_INTERFACE);
 221         if (ret < 0) {
 222                 sr_err("Failed to claim interface: %s.",
 223                         libusb_error_name(ret));
 224                 return SR_ERR;
 225         }
 226
 227         sdi->status = SR_ST_INITIALIZING;
 228
 229         ret = lwla_init_device(sdi);
 230
 231         if (ret == SR_OK)
 232                 sdi->status = SR_ST_ACTIVE;
 233
 234         return ret;
 235 }
 236
 237 static int dev_close(struct sr_dev_inst *sdi)
 238 {
 239         struct sr_usb_dev_inst *usb;
 240
 241         if (!di->priv) {
 242                 sr_err("Driver was not initialized.");
 243                 return SR_ERR;
 244         }
 245
 246         usb = sdi->conn;
 247         if (!usb->devhdl)
 248                 return SR_OK;
 249
 250         sdi->status = SR_ST_INACTIVE;
 251
 252         /* Trigger download of the shutdown bitstream. */
 253         if (lwla_set_clock_config(sdi) != SR_OK)
 254                 sr_err("Unable to shut down device.");
 255
 256         libusb_release_interface(usb->devhdl, USB_INTERFACE);
 257         libusb_close(usb->devhdl);
 258
 259         usb->devhdl = NULL;
 260
 261         return SR_OK;
 262 }
 263
 264 static int cleanup(void)
 265 {
 266         return dev_clear();
 267 }
 268
 269 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 270                       const struct sr_channel_group *cg)
 271 {
 272         struct dev_context *devc;
 273         size_t idx;
 274
 275         (void)cg;
 276
 277         if (!sdi)
 278                 return SR_ERR_ARG;
 279
 280         devc = sdi->priv;
 281
 282         switch (key) {
 283         case SR_CONF_SAMPLERATE:
 284                 *data = g_variant_new_uint64(devc->samplerate);
 285                 break;
 286         case SR_CONF_LIMIT_MSEC:
 287                 *data = g_variant_new_uint64(devc->limit_msec);
 288                 break;
 289         case SR_CONF_LIMIT_SAMPLES:
 290                 *data = g_variant_new_uint64(devc->limit_samples);
 291                 break;
 292         case SR_CONF_EXTERNAL_CLOCK:
 293                 *data = g_variant_new_boolean(devc->cfg_clock_source
 294                                                 == CLOCK_EXT_CLK);
 295                 break;
 296         case SR_CONF_CLOCK_EDGE:
 297                 idx = devc->cfg_clock_edge;
 298                 if (idx >= G_N_ELEMENTS(signal_edge_names))
 299                         return SR_ERR_BUG;
 300                 *data = g_variant_new_string(signal_edge_names[idx]);
 301                 break;
 302         case SR_CONF_TRIGGER_SOURCE:
 303                 idx = devc->cfg_trigger_source;
 304                 if (idx >= G_N_ELEMENTS(trigger_source_names))
 305                         return SR_ERR_BUG;
 306                 *data = g_variant_new_string(trigger_source_names[idx]);
 307                 break;
 308         case SR_CONF_TRIGGER_SLOPE:
 309                 idx = devc->cfg_trigger_slope;
 310                 if (idx >= G_N_ELEMENTS(signal_edge_names))
 311                         return SR_ERR_BUG;
 312                 *data = g_variant_new_string(signal_edge_names[idx]);
 313                 break;
 314         default:
 315                 return SR_ERR_NA;
 316         }
 317
 318         return SR_OK;
 319 }
 320
 321 /* Helper for mapping a string-typed configuration value to an index
 322  * within a table of possible values.
 323  */
 324 static int lookup_index(GVariant *value, const char *const *table, int len)
 325 {
 326         const char *entry;
 327         int i;
 328
 329         entry = g_variant_get_string(value, NULL);
 330         if (!entry)
 331                 return -1;
 332
 333         /* Linear search is fine for very small tables. */
 334         for (i = 0; i < len; ++i) {
 335                 if (strcmp(entry, table[i]) == 0)
 336                         return i;
 337         }
 338         return -1;
 339 }
 340
 341 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 342                       const struct sr_channel_group *cg)
 343 {
 344         uint64_t value;
 345         struct dev_context *devc;
 346         int idx;
 347
 348         (void)cg;
 349
 350         devc = sdi->priv;
 351         if (!devc)
 352                 return SR_ERR_DEV_CLOSED;
 353
 354         switch (key) {
 355         case SR_CONF_SAMPLERATE:
 356                 value = g_variant_get_uint64(data);
 357                 if (value < samplerates[G_N_ELEMENTS(samplerates) - 1]
 358                                 || value > samplerates[0])
 359                         return SR_ERR_SAMPLERATE;
 360                 devc->samplerate = value;
 361                 break;
 362         case SR_CONF_LIMIT_MSEC:
 363                 value = g_variant_get_uint64(data);
 364                 if (value > MAX_LIMIT_MSEC)
 365                         return SR_ERR_ARG;
 366                 devc->limit_msec = value;
 367                 break;
 368         case SR_CONF_LIMIT_SAMPLES:
 369                 value = g_variant_get_uint64(data);
 370                 if (value > MAX_LIMIT_SAMPLES)
 371                         return SR_ERR_ARG;
 372                 devc->limit_samples = value;
 373                 break;
 374         case SR_CONF_EXTERNAL_CLOCK:
 375                 devc->cfg_clock_source = (g_variant_get_boolean(data))
 376                         ? CLOCK_EXT_CLK : CLOCK_INTERNAL;
 377                 break;
 378         case SR_CONF_CLOCK_EDGE:
 379                 idx = lookup_index(data, signal_edge_names,
 380                                    G_N_ELEMENTS(signal_edge_names));
 381                 if (idx < 0)
 382                         return SR_ERR_ARG;
 383                 devc->cfg_clock_edge = idx;
 384                 break;
 385         case SR_CONF_TRIGGER_SOURCE:
 386                 idx = lookup_index(data, trigger_source_names,
 387                                    G_N_ELEMENTS(trigger_source_names));
 388                 if (idx < 0)
 389                         return SR_ERR_ARG;
 390                 devc->cfg_trigger_source = idx;
 391                 break;
 392         case SR_CONF_TRIGGER_SLOPE:
 393                 idx = lookup_index(data, signal_edge_names,
 394                                    G_N_ELEMENTS(signal_edge_names));
 395                 if (idx < 0)
 396                         return SR_ERR_ARG;
 397                 devc->cfg_trigger_slope = idx;
 398                 break;
 399         default:
 400                 return SR_ERR_NA;
 401         }
 402
 403         return SR_OK;
 404 }
 405
 406 static int config_channel_set(const struct sr_dev_inst *sdi,
 407                 struct sr_channel *ch, unsigned int changes)
 408 {
 409         uint64_t channel_bit;
 410         struct dev_context *devc;
 411
 412         devc = sdi->priv;
 413         if (!devc)
 414                 return SR_ERR_DEV_CLOSED;
 415
 416         if (ch->index < 0 || ch->index >= NUM_CHANNELS) {
 417                 sr_err("Channel index %d out of range.", ch->index);
 418                 return SR_ERR_BUG;
 419         }
 420         channel_bit = (uint64_t)1 << ch->index;
 421
 422         if ((changes & SR_CHANNEL_SET_ENABLED) != 0) {
 423                 /* Enable or disable input channel for this channel. */
 424                 if (ch->enabled)
 425                         devc->channel_mask |= channel_bit;
 426                 else
 427                         devc->channel_mask &= ~channel_bit;
 428         }
 429
 430         return SR_OK;
 431 }
 432
 433 static int config_commit(const struct sr_dev_inst *sdi)
 434 {
 435         if (sdi->status != SR_ST_ACTIVE) {
 436                 sr_err("Device not ready (status %d).", (int)sdi->status);
 437                 return SR_ERR;
 438         }
 439
 440         return lwla_set_clock_config(sdi);
 441 }
 442
 443 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 444                        const struct sr_channel_group *cg)
 445 {
 446         GVariant *gvar;
 447         GVariantBuilder gvb;
 448
 449         (void)sdi;
 450         (void)cg;
 451
 452         switch (key) {
 453         case SR_CONF_SCAN_OPTIONS:
 454                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 455                                 scanopts, ARRAY_SIZE(scanopts), sizeof(uint32_t));
 456                 break;
 457         case SR_CONF_DEVICE_OPTIONS:
 458                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 459                                 devopts, G_N_ELEMENTS(devopts), sizeof(uint32_t));
 460                 break;
 461         case SR_CONF_SAMPLERATE:
 462                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 463                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
 464                                 samplerates, G_N_ELEMENTS(samplerates),
 465                                 sizeof(uint64_t));
 466                 g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
 467                 *data = g_variant_builder_end(&gvb);
 468                 break;
 469         case SR_CONF_TRIGGER_MATCH:
 470                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
 471                                 trigger_matches, ARRAY_SIZE(trigger_matches),
 472                                 sizeof(int32_t));
 473                 break;
 474         case SR_CONF_TRIGGER_SOURCE:
 475                 *data = g_variant_new_strv(trigger_source_names,
 476                                            G_N_ELEMENTS(trigger_source_names));
 477                 break;
 478         case SR_CONF_TRIGGER_SLOPE:
 479         case SR_CONF_CLOCK_EDGE:
 480                 *data = g_variant_new_strv(signal_edge_names,
 481                                            G_N_ELEMENTS(signal_edge_names));
 482                 break;
 483         default:
 484                 return SR_ERR_NA;
 485         }
 486
 487         return SR_OK;
 488 }
 489
 490 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 491 {
 492         struct drv_context *drvc;
 493         struct dev_context *devc;
 494         struct acquisition_state *acq;
 495         int ret;
 496
 497         (void)cb_data;
 498
 499         if (sdi->status != SR_ST_ACTIVE)
 500                 return SR_ERR_DEV_CLOSED;
 501
 502         devc = sdi->priv;
 503         drvc = di->priv;
 504
 505         if (devc->acquisition) {
 506                 sr_err("Acquisition still in progress?");
 507                 return SR_ERR;
 508         }
 509         acq = lwla_alloc_acquisition_state();
 510         if (!acq)
 511                 return SR_ERR_MALLOC;
 512
 513         devc->stopping_in_progress = FALSE;
 514         devc->transfer_error = FALSE;
 515
 516         sr_info("Starting acquisition.");
 517
 518         devc->acquisition = acq;
 519         lwla_convert_trigger(sdi);
 520         ret = lwla_setup_acquisition(sdi);
 521         if (ret != SR_OK) {
 522                 sr_err("Failed to set up acquisition.");
 523                 devc->acquisition = NULL;
 524                 lwla_free_acquisition_state(acq);
 525                 return ret;
 526         }
 527
 528         ret = lwla_start_acquisition(sdi);
 529         if (ret != SR_OK) {
 530                 sr_err("Failed to start acquisition.");
 531                 devc->acquisition = NULL;
 532                 lwla_free_acquisition_state(acq);
 533                 return ret;
 534         }
 535         usb_source_add(sdi->session, drvc->sr_ctx, 100, &lwla_receive_data,
 536                        (struct sr_dev_inst *)sdi);
 537
 538         sr_info("Waiting for data.");
 539
 540         /* Send header packet to the session bus. */
 541         std_session_send_df_header(sdi, LOG_PREFIX);
 542
 543         return SR_OK;
 544 }
 545
 546 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 547 {
 548         (void)cb_data;
 549
 550         if (sdi->status != SR_ST_ACTIVE)
 551                 return SR_ERR_DEV_CLOSED;
 552
 553         sr_dbg("Stopping acquisition.");
 554
 555         sdi->status = SR_ST_STOPPING;
 556
 557         return SR_OK;
 558 }
 559
 560 SR_PRIV struct sr_dev_driver sysclk_lwla_driver_info = {
 561         .name = "sysclk-lwla",
 562         .longname = "SysClk LWLA series",
 563         .api_version = 1,
 564         .init = init,
 565         .cleanup = cleanup,
 566         .scan = scan,
 567         .dev_list = dev_list,
 568         .dev_clear = dev_clear,
 569         .config_get = config_get,
 570         .config_set = config_set,
 571         .config_channel_set = config_channel_set,
 572         .config_commit = config_commit,
 573         .config_list = config_list,
 574         .dev_open = dev_open,
 575         .dev_close = dev_close,
 576         .dev_acquisition_start = dev_acquisition_start,
 577         .dev_acquisition_stop = dev_acquisition_stop,
 578         .priv = NULL,
 579 };