src/hardware/ikalogic-scanaplus/api.c

   1 /*
   2  * This file is part of the libsigrok project.
   3  *
   4  * Copyright (C) 2013 Uwe Hermann <uwe@hermann-uwe.de>
   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 2 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, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301 USA
  19  */
  20
  21 #include "protocol.h"
  22
  23 #define USB_VENDOR_ID                   0x0403
  24 #define USB_DEVICE_ID                   0x6014
  25 #define USB_VENDOR_NAME                 "IKALOGIC"
  26 #define USB_MODEL_NAME                  "ScanaPLUS"
  27 #define USB_IPRODUCT                    "SCANAPLUS"
  28
  29 #define SAMPLE_BUF_SIZE                 (8 * 1024 * 1024)
  30
  31 static const uint32_t devopts[] = {
  32         SR_CONF_LOGIC_ANALYZER,
  33         SR_CONF_LIMIT_SAMPLES | SR_CONF_SET,
  34         SR_CONF_LIMIT_MSEC | SR_CONF_SET,
  35         SR_CONF_SAMPLERATE | SR_CONF_GET | SR_CONF_SET | SR_CONF_LIST,
  36 };
  37
  38 /* Channels are numbered 1-9. */
  39 static const char *channel_names[] = {
  40         "1", "2", "3", "4", "5", "6", "7", "8", "9",
  41 };
  42
  43 /* Note: The IKALOGIC ScanaPLUS always samples at 100MHz. */
  44 static const uint64_t samplerates[1] = { SR_MHZ(100) };
  45
  46 SR_PRIV struct sr_dev_driver ikalogic_scanaplus_driver_info;
  47
  48 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data);
  49
  50 static void clear_helper(void *priv)
  51 {
  52         struct dev_context *devc;
  53
  54         devc = priv;
  55
  56         ftdi_free(devc->ftdic);
  57         g_free(devc->compressed_buf);
  58         g_free(devc->sample_buf);
  59         g_free(devc);
  60 }
  61
  62 static int dev_clear(const struct sr_dev_driver *di)
  63 {
  64         return std_dev_clear(di, clear_helper);
  65 }
  66
  67 static int init(struct sr_dev_driver *di, struct sr_context *sr_ctx)
  68 {
  69         return std_init(sr_ctx, di, LOG_PREFIX);
  70 }
  71
  72 static GSList *scan(struct sr_dev_driver *di, GSList *options)
  73 {
  74         struct sr_dev_inst *sdi;
  75         struct drv_context *drvc;
  76         struct dev_context *devc;
  77         GSList *devices;
  78         unsigned int i;
  79         int ret;
  80
  81         (void)options;
  82
  83         drvc = di->context;
  84
  85         devices = NULL;
  86
  87         /* Allocate memory for our private device context. */
  88         devc = g_malloc0(sizeof(struct dev_context));
  89
  90         /* Allocate memory for the incoming compressed samples. */
  91         if (!(devc->compressed_buf = g_try_malloc0(COMPRESSED_BUF_SIZE))) {
  92                 sr_err("compressed_buf malloc failed.");
  93                 goto err_free_devc;
  94         }
  95
  96         /* Allocate memory for the uncompressed samples. */
  97         if (!(devc->sample_buf = g_try_malloc0(SAMPLE_BUF_SIZE))) {
  98                 sr_err("sample_buf malloc failed.");
  99                 goto err_free_compressed_buf;
 100         }
 101
 102         /* Allocate memory for the FTDI context (ftdic) and initialize it. */
 103         if (!(devc->ftdic = ftdi_new())) {
 104                 sr_err("Failed to initialize libftdi.");
 105                 goto err_free_sample_buf;
 106         }
 107
 108         /* Check for the device and temporarily open it. */
 109         ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID, USB_DEVICE_ID,
 110                                  USB_IPRODUCT, NULL);
 111         if (ret < 0) {
 112                 /* Log errors, except for -3 ("device not found"). */
 113                 if (ret != -3)
 114                         sr_err("Failed to open device (%d): %s", ret,
 115                                ftdi_get_error_string(devc->ftdic));
 116                 goto err_free_ftdic;
 117         }
 118
 119         /* Register the device with libsigrok. */
 120         sdi = g_malloc0(sizeof(struct sr_dev_inst));
 121         sdi->status = SR_ST_INITIALIZING;
 122         sdi->vendor = g_strdup(USB_VENDOR_NAME);
 123         sdi->model = g_strdup(USB_MODEL_NAME);
 124         sdi->driver = di;
 125         sdi->priv = devc;
 126
 127         for (i = 0; i < ARRAY_SIZE(channel_names); i++)
 128                 sr_channel_new(sdi, i, SR_CHANNEL_LOGIC, TRUE, channel_names[i]);
 129
 130         devices = g_slist_append(devices, sdi);
 131         drvc->instances = g_slist_append(drvc->instances, sdi);
 132
 133         /* Close device. We'll reopen it again when we need it. */
 134         scanaplus_close(devc);
 135
 136         return devices;
 137
 138         scanaplus_close(devc);
 139 err_free_ftdic:
 140         ftdi_free(devc->ftdic); /* NOT free() or g_free()! */
 141 err_free_sample_buf:
 142         g_free(devc->sample_buf);
 143 err_free_compressed_buf:
 144         g_free(devc->compressed_buf);
 145 err_free_devc:
 146         g_free(devc);
 147
 148         return NULL;
 149 }
 150
 151 static GSList *dev_list(const struct sr_dev_driver *di)
 152 {
 153         return ((struct drv_context *)(di->context))->instances;
 154 }
 155
 156 static int dev_open(struct sr_dev_inst *sdi)
 157 {
 158         struct dev_context *devc;
 159         int ret;
 160
 161         devc = sdi->priv;
 162
 163         /* Select interface A, otherwise communication will fail. */
 164         ret = ftdi_set_interface(devc->ftdic, INTERFACE_A);
 165         if (ret < 0) {
 166                 sr_err("Failed to set FTDI interface A (%d): %s", ret,
 167                        ftdi_get_error_string(devc->ftdic));
 168                 return SR_ERR;
 169         }
 170         sr_dbg("FTDI chip interface A set successfully.");
 171
 172         /* Open the device. */
 173         ret = ftdi_usb_open_desc(devc->ftdic, USB_VENDOR_ID, USB_DEVICE_ID,
 174                                  USB_IPRODUCT, NULL);
 175         if (ret < 0) {
 176                 sr_err("Failed to open device (%d): %s", ret,
 177                        ftdi_get_error_string(devc->ftdic));
 178                 return SR_ERR;
 179         }
 180         sr_dbg("FTDI device opened successfully.");
 181
 182         /* Purge RX/TX buffers in the FTDI chip. */
 183         if ((ret = ftdi_usb_purge_buffers(devc->ftdic)) < 0) {
 184                 sr_err("Failed to purge FTDI RX/TX buffers (%d): %s.",
 185                        ret, ftdi_get_error_string(devc->ftdic));
 186                 goto err_dev_open_close_ftdic;
 187         }
 188         sr_dbg("FTDI chip buffers purged successfully.");
 189
 190         /* Reset the FTDI bitmode. */
 191         ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_RESET);
 192         if (ret < 0) {
 193                 sr_err("Failed to reset the FTDI chip bitmode (%d): %s.",
 194                        ret, ftdi_get_error_string(devc->ftdic));
 195                 goto err_dev_open_close_ftdic;
 196         }
 197         sr_dbg("FTDI chip bitmode reset successfully.");
 198
 199         /* Set FTDI bitmode to "sync FIFO". */
 200         ret = ftdi_set_bitmode(devc->ftdic, 0xff, BITMODE_SYNCFF);
 201         if (ret < 0) {
 202                 sr_err("Failed to put FTDI chip into sync FIFO mode (%d): %s.",
 203                        ret, ftdi_get_error_string(devc->ftdic));
 204                 goto err_dev_open_close_ftdic;
 205         }
 206         sr_dbg("FTDI chip sync FIFO mode entered successfully.");
 207
 208         /* Set the FTDI latency timer to 2. */
 209         ret = ftdi_set_latency_timer(devc->ftdic, 2);
 210         if (ret < 0) {
 211                 sr_err("Failed to set FTDI latency timer (%d): %s.",
 212                        ret, ftdi_get_error_string(devc->ftdic));
 213                 goto err_dev_open_close_ftdic;
 214         }
 215         sr_dbg("FTDI chip latency timer set successfully.");
 216
 217         /* Set the FTDI read data chunk size to 64kB. */
 218         ret = ftdi_read_data_set_chunksize(devc->ftdic, 64 * 1024);
 219         if (ret < 0) {
 220                 sr_err("Failed to set FTDI read data chunk size (%d): %s.",
 221                        ret, ftdi_get_error_string(devc->ftdic));
 222                 goto err_dev_open_close_ftdic;
 223         }
 224         sr_dbg("FTDI chip read data chunk size set successfully.");
 225
 226         /* Get the ScanaPLUS device ID from the FTDI EEPROM. */
 227         if ((ret = scanaplus_get_device_id(devc)) < 0) {
 228                 sr_err("Failed to get ScanaPLUS device ID: %d.", ret);
 229                 goto err_dev_open_close_ftdic;
 230         }
 231         sr_dbg("Received ScanaPLUS device ID successfully: %02x %02x %02x.",
 232                devc->devid[0], devc->devid[1], devc->devid[2]);
 233
 234         sdi->status = SR_ST_ACTIVE;
 235
 236         return SR_OK;
 237
 238 err_dev_open_close_ftdic:
 239         scanaplus_close(devc);
 240         return SR_ERR;
 241 }
 242
 243 static int dev_close(struct sr_dev_inst *sdi)
 244 {
 245         int ret;
 246         struct dev_context *devc;
 247
 248         ret = SR_OK;
 249         devc = sdi->priv;
 250
 251         if (sdi->status == SR_ST_ACTIVE) {
 252                 sr_dbg("Status ACTIVE, closing device.");
 253                 ret = scanaplus_close(devc);
 254         } else {
 255                 sr_spew("Status not ACTIVE, nothing to do.");
 256         }
 257
 258         sdi->status = SR_ST_INACTIVE;
 259
 260         return ret;
 261 }
 262
 263 static int cleanup(const struct sr_dev_driver *di)
 264 {
 265         return dev_clear(di);
 266 }
 267
 268 static int config_get(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 269                 const struct sr_channel_group *cg)
 270 {
 271         (void)sdi;
 272         (void)cg;
 273
 274         switch (key) {
 275         case SR_CONF_SAMPLERATE:
 276                 /* The ScanaPLUS samplerate is 100MHz and can't be changed. */
 277                 *data = g_variant_new_uint64(SR_MHZ(100));
 278                 break;
 279         default:
 280                 return SR_ERR_NA;
 281         }
 282
 283         return SR_OK;
 284 }
 285
 286 static int config_set(uint32_t key, GVariant *data, const struct sr_dev_inst *sdi,
 287                 const struct sr_channel_group *cg)
 288 {
 289         struct dev_context *devc;
 290
 291         (void)cg;
 292
 293         if (sdi->status != SR_ST_ACTIVE)
 294                 return SR_ERR_DEV_CLOSED;
 295
 296         devc = sdi->priv;
 297
 298         switch (key) {
 299         case SR_CONF_SAMPLERATE:
 300                 if (g_variant_get_uint64(data) != SR_MHZ(100)) {
 301                         sr_err("ScanaPLUS only supports samplerate = 100MHz.");
 302                         return SR_ERR_ARG;
 303                 }
 304                 /* Nothing to do, the ScanaPLUS samplerate is always 100MHz. */
 305                 break;
 306         case SR_CONF_LIMIT_MSEC:
 307                 if (g_variant_get_uint64(data) == 0)
 308                         return SR_ERR_ARG;
 309                 devc->limit_msec = g_variant_get_uint64(data);
 310                 break;
 311         case SR_CONF_LIMIT_SAMPLES:
 312                 if (g_variant_get_uint64(data) == 0)
 313                         return SR_ERR_ARG;
 314                 devc->limit_samples = g_variant_get_uint64(data);
 315                 break;
 316         default:
 317                 return SR_ERR_NA;
 318         }
 319
 320         return SR_OK;
 321 }
 322
 323 static int config_list(uint32_t key, GVariant **data, const struct sr_dev_inst *sdi,
 324                 const struct sr_channel_group *cg)
 325 {
 326         GVariant *gvar;
 327         GVariantBuilder gvb;
 328
 329         (void)sdi;
 330         (void)cg;
 331
 332         switch (key) {
 333         case SR_CONF_DEVICE_OPTIONS:
 334                 *data = g_variant_new_fixed_array(G_VARIANT_TYPE_UINT32,
 335                                 devopts, ARRAY_SIZE(devopts), sizeof(uint32_t));
 336                 break;
 337         case SR_CONF_SAMPLERATE:
 338                 g_variant_builder_init(&gvb, G_VARIANT_TYPE("a{sv}"));
 339                 gvar = g_variant_new_fixed_array(G_VARIANT_TYPE("t"),
 340                                 samplerates, ARRAY_SIZE(samplerates),
 341                                 sizeof(uint64_t));
 342                 g_variant_builder_add(&gvb, "{sv}", "samplerates", gvar);
 343                 *data = g_variant_builder_end(&gvb);
 344                 break;
 345         default:
 346                 return SR_ERR_NA;
 347         }
 348
 349         return SR_OK;
 350 }
 351
 352 static int dev_acquisition_start(const struct sr_dev_inst *sdi, void *cb_data)
 353 {
 354         int ret;
 355         struct dev_context *devc;
 356
 357         if (sdi->status != SR_ST_ACTIVE)
 358                 return SR_ERR_DEV_CLOSED;
 359
 360         if (!(devc = sdi->priv))
 361                 return SR_ERR_BUG;
 362
 363         if (!devc->ftdic)
 364                 return SR_ERR_BUG;
 365
 366         /* TODO: Configure channels later (thresholds etc.). */
 367
 368         devc->cb_data = cb_data;
 369
 370         /* Properly reset internal variables before every new acquisition. */
 371         devc->compressed_bytes_ignored = 0;
 372         devc->samples_sent = 0;
 373         devc->bytes_received = 0;
 374
 375         if ((ret = scanaplus_init(devc)) < 0)
 376                 return ret;
 377
 378         if ((ret = scanaplus_start_acquisition(devc)) < 0)
 379                 return ret;
 380
 381         /* Send header packet to the session bus. */
 382         std_session_send_df_header(sdi, LOG_PREFIX);
 383
 384         /* Hook up a dummy handler to receive data from the device. */
 385         sr_session_source_add(sdi->session, -1, G_IO_IN, 0, scanaplus_receive_data, (void *)sdi);
 386
 387         return SR_OK;
 388 }
 389
 390 static int dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 391 {
 392         struct sr_datafeed_packet packet;
 393
 394         (void)cb_data;
 395
 396         sr_dbg("Stopping acquisition.");
 397         sr_session_source_remove(sdi->session, -1);
 398
 399         /* Send end packet to the session bus. */
 400         sr_dbg("Sending SR_DF_END.");
 401         packet.type = SR_DF_END;
 402         sr_session_send(sdi, &packet);
 403
 404         return SR_OK;
 405 }
 406
 407 SR_PRIV struct sr_dev_driver ikalogic_scanaplus_driver_info = {
 408         .name = "ikalogic-scanaplus",
 409         .longname = "IKALOGIC ScanaPLUS",
 410         .api_version = 1,
 411         .init = init,
 412         .cleanup = cleanup,
 413         .scan = scan,
 414         .dev_list = dev_list,
 415         .dev_clear = dev_clear,
 416         .config_get = config_get,
 417         .config_set = config_set,
 418         .config_list = config_list,
 419         .dev_open = dev_open,
 420         .dev_close = dev_close,
 421         .dev_acquisition_start = dev_acquisition_start,
 422         .dev_acquisition_stop = dev_acquisition_stop,
 423         .context = NULL,
 424 };