hardware/link-mso19/api.c

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   4  * Copyright (C) 2011 Daniel Ribeiro <drwyrm@gmail.com>
   5  * Copyright (C) 2012 Renato Caldas <rmsc@fe.up.pt>
   6  * Copyright (C) 2013 Lior Elazary <lelazary@yahoo.com>
   7  *
   8  * This program is free software: you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation, either version 3 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  20  */
  21
  22 #include "protocol.h"
  23
  24 static const int hwcaps[] = {
  25         SR_HWCAP_LOGIC_ANALYZER,
  26         SR_HWCAP_SAMPLERATE,
  27   SR_HWCAP_TRIGGER_SLOPE,
  28   SR_HWCAP_HORIZ_TRIGGERPOS,
  29 //      SR_HWCAP_CAPTURE_RATIO,
  30         SR_HWCAP_LIMIT_SAMPLES,
  31 //      SR_HWCAP_RLE,
  32         0,
  33 };
  34
  35 /*
  36  * Probes are numbered 0 to 7.
  37  *
  38  * See also: http://www.linkinstruments.com/images/mso19_1113.gif
  39  */
  40 SR_PRIV const char *mso19_probe_names[NUM_PROBES + 1] = {
  41         "0", "1", "2", "3", "4", "5", "6", "7", NULL
  42 };
  43
  44 /*supported samplerates */
  45 static const struct sr_samplerates samplerates = {
  46         SR_HZ(100),
  47         SR_MHZ(200),
  48         SR_HZ(100),
  49         NULL,
  50 };
  51
  52 SR_PRIV struct sr_dev_driver link_mso19_driver_info;
  53 static struct sr_dev_driver *di = &link_mso19_driver_info;
  54
  55 static int hw_init(struct sr_context *sr_ctx)
  56 {
  57         struct drv_context *drvc;
  58
  59         if (!(drvc = g_try_malloc0(sizeof(struct drv_context)))) {
  60                 sr_err("Driver context malloc failed.");
  61                 return SR_ERR_MALLOC;
  62         }
  63         drvc->sr_ctx = sr_ctx;
  64         di->priv = drvc;
  65
  66         return SR_OK;
  67 }
  68
  69 static GSList *hw_scan(GSList *options)
  70 {
  71   int i;
  72
  73         (void)options;
  74         GSList *devices = NULL;
  75
  76         const char* conn = NULL;
  77   const char* serialcomm = NULL;
  78   GSList *l;
  79         for (l = options; l; l = l->next) {
  80                 struct sr_hwopt* opt = l->data;
  81                 switch (opt->hwopt) {
  82                 case SR_HWOPT_CONN:
  83                         conn = opt->value;
  84                         break;
  85                 case SR_HWOPT_SERIALCOMM:
  86                         serialcomm = opt->value;
  87                         break;
  88                 }
  89         }
  90         if (!conn)
  91     conn = SERIALCONN;
  92         if (serialcomm == NULL)
  93                 serialcomm = SERIALCOMM;
  94
  95         struct udev *udev = udev_new();
  96         if (!udev) {
  97                 sr_err("Failed to initialize udev.");
  98         }
  99         struct udev_enumerate *enumerate = udev_enumerate_new(udev);
 100         udev_enumerate_add_match_subsystem(enumerate, "usb-serial");
 101         udev_enumerate_scan_devices(enumerate);
 102         struct udev_list_entry *devs = udev_enumerate_get_list_entry(enumerate);
 103         struct udev_list_entry *dev_list_entry;
 104   for (dev_list_entry = devs;
 105       dev_list_entry != NULL;
 106       dev_list_entry = udev_list_entry_get_next(dev_list_entry))
 107   {
 108                 const char *syspath = udev_list_entry_get_name(dev_list_entry);
 109                 struct udev_device *dev = udev_device_new_from_syspath(udev, syspath);
 110                 const char *sysname = udev_device_get_sysname(dev);
 111                 struct udev_device *parent = udev_device_get_parent_with_subsystem_devtype(
 112         dev, "usb", "usb_device");
 113
 114                 if (!parent) {
 115                         sr_err("Unable to find parent usb device for %s",
 116                                sysname);
 117                         continue;
 118                 }
 119
 120                 const char *idVendor = udev_device_get_sysattr_value(parent, "idVendor");
 121                 const char *idProduct = udev_device_get_sysattr_value(parent, "idProduct");
 122                 if (strcmp(USB_VENDOR, idVendor)
 123                                 || strcmp(USB_PRODUCT, idProduct))
 124                         continue;
 125
 126                 const char* iSerial = udev_device_get_sysattr_value(parent, "serial");
 127                 const char* iProduct = udev_device_get_sysattr_value(parent, "product");
 128
 129     char path[32];
 130                 snprintf(path, sizeof(path), "/dev/%s", sysname);
 131     conn = path;
 132
 133                 size_t s = strcspn(iProduct, " ");
 134     char product[32];
 135     char manufacturer[32];
 136                 if (s > sizeof(product) ||
 137                                 strlen(iProduct) - s > sizeof(manufacturer)) {
 138       sr_err("Could not parse iProduct: %s.", iProduct);
 139                         continue;
 140                 }
 141                 strncpy(product, iProduct, s);
 142                 product[s] = 0;
 143                 strcpy(manufacturer, iProduct + s + 1);
 144
 145     //Create the device context and set its params
 146     struct dev_context *devc;
 147     if (!(devc = g_try_malloc0(sizeof(struct dev_context)))) {
 148       sr_err("Device context malloc failed.");
 149       return devices;
 150     }
 151
 152     if (mso_parse_serial(iSerial, iProduct, devc) != SR_OK) {
 153       sr_err("Invalid iSerial: %s.", iSerial);
 154       g_free(devc);
 155       return devices;
 156     }
 157
 158     char hwrev[32];
 159     sprintf(hwrev, "r%d", devc->hwrev);
 160     devc->ctlbase1 = 0;
 161     devc->protocol_trigger.spimode = 0;
 162     for (i = 0; i < 4; i++) {
 163       devc->protocol_trigger.word[i] = 0;
 164       devc->protocol_trigger.mask[i] = 0xff;
 165     }
 166
 167     if (!(devc->serial = sr_serial_dev_inst_new(conn, serialcomm)))
 168     {
 169       g_free(devc);
 170       return devices;
 171     }
 172
 173     struct sr_dev_inst *sdi = sr_dev_inst_new(0, SR_ST_INACTIVE,
 174         manufacturer, product, hwrev);
 175
 176     if (!sdi) {
 177       sr_err("Unable to create device instance for %s",
 178           sysname);
 179       sr_dev_inst_free(sdi);
 180       g_free(devc);
 181       return devices;
 182     }
 183
 184     sdi->driver = di;
 185     sdi->priv = devc;
 186
 187     for (i = 0; i < NUM_PROBES; i++) {
 188       struct sr_probe *probe;
 189       if (!(probe = sr_probe_new(i, SR_PROBE_LOGIC, TRUE,
 190               mso19_probe_names[i])))
 191         return 0;
 192       sdi->probes = g_slist_append(sdi->probes, probe);
 193     }
 194
 195     //Add the driver
 196     struct drv_context *drvc = di->priv;
 197     drvc->instances = g_slist_append(drvc->instances, sdi);
 198     devices = g_slist_append(devices, sdi);
 199   }
 200
 201         return devices;
 202 }
 203
 204 static GSList *hw_dev_list(void)
 205 {
 206         struct drv_context *drvc;
 207
 208         drvc = di->priv;
 209
 210         return drvc->instances;
 211 }
 212
 213 static int hw_dev_open(struct sr_dev_inst *sdi)
 214 {
 215         struct dev_context *devc;
 216
 217         devc = sdi->priv;
 218
 219         if (serial_open(devc->serial, SERIAL_RDWR) != SR_OK)
 220                 return SR_ERR;
 221
 222         sdi->status = SR_ST_ACTIVE;
 223
 224         /* FIXME: discard serial buffer */
 225         mso_check_trigger(devc->serial, &devc->trigger_state);
 226         sr_dbg("Trigger state: 0x%x.", devc->trigger_state);
 227
 228         int ret = mso_reset_adc(sdi);
 229         if (ret != SR_OK)
 230                 return ret;
 231
 232         mso_check_trigger(devc->serial, &devc->trigger_state);
 233         sr_dbg("Trigger state: 0x%x.", devc->trigger_state);
 234
 235   //    ret = mso_reset_fsm(sdi);
 236   //    if (ret != SR_OK)
 237   //            return ret;
 238   //    return SR_ERR;
 239
 240         return SR_OK;
 241 }
 242
 243 static int hw_dev_close(struct sr_dev_inst *sdi)
 244 {
 245         struct dev_context *devc;
 246
 247         devc = sdi->priv;
 248
 249         if (devc->serial && devc->serial->fd != -1) {
 250                 serial_close(devc->serial);
 251                 sdi->status = SR_ST_INACTIVE;
 252         }
 253
 254         return SR_OK;
 255 }
 256
 257 static int hw_cleanup(void)
 258 {
 259         GSList *l;
 260         struct sr_dev_inst *sdi;
 261         struct drv_context *drvc;
 262         struct dev_context *devc;
 263         int ret = SR_OK;
 264
 265         if (!(drvc = di->priv))
 266                 return SR_OK;
 267
 268         /* Properly close and free all devices. */
 269         for (l = drvc->instances; l; l = l->next) {
 270                 if (!(sdi = l->data)) {
 271                         /* Log error, but continue cleaning up the rest. */
 272                         sr_err("%s: sdi was NULL, continuing", __func__);
 273                         ret = SR_ERR_BUG;
 274                         continue;
 275                 }
 276                 if (!(devc = sdi->priv)) {
 277                         /* Log error, but continue cleaning up the rest. */
 278                         sr_err("%s: sdi->priv was NULL, continuing", __func__);
 279                         ret = SR_ERR_BUG;
 280                         continue;
 281                 }
 282                 hw_dev_close(sdi);
 283                 sr_serial_dev_inst_free(devc->serial);
 284                 sr_dev_inst_free(sdi);
 285         }
 286         g_slist_free(drvc->instances);
 287         drvc->instances = NULL;
 288
 289         return ret;
 290 }
 291
 292 static int hw_info_get(int info_id, const void **data,
 293        const struct sr_dev_inst *sdi)
 294 {
 295         struct dev_context *devc;
 296
 297         switch (info_id) {
 298         case SR_DI_HWCAPS:
 299                 *data = hwcaps;
 300                 break;
 301         case SR_DI_NUM_PROBES:
 302                 *data = GINT_TO_POINTER(1);
 303                 break;
 304         case SR_DI_PROBE_NAMES:
 305                 *data = mso19_probe_names;
 306                 break;
 307         case SR_DI_SAMPLERATES:
 308                 *data = &samplerates;
 309                 break;
 310         case SR_DI_TRIGGER_TYPES:
 311                 *data = (char *)TRIGGER_TYPES;
 312                 break;
 313         case SR_DI_CUR_SAMPLERATE:
 314                 if (sdi) {
 315                         devc = sdi->priv;
 316                         *data = &devc->cur_rate;
 317                 } else
 318                         return SR_ERR;
 319                 break;
 320         default:
 321                 return SR_ERR_ARG;
 322         }
 323
 324         return SR_OK;
 325 }
 326
 327 static int hw_dev_config_set(const struct sr_dev_inst *sdi, int hwcap,
 328                 const void *value)
 329 {
 330         int ret;
 331
 332         struct dev_context *devc;
 333   devc = sdi->priv;
 334
 335         if (sdi->status != SR_ST_ACTIVE)
 336                 return SR_ERR;
 337
 338         switch (hwcap) {
 339         case SR_HWCAP_SAMPLERATE:
 340                 return mso_configure_rate(sdi, *(const uint64_t *) value);
 341                 ret = SR_OK;
 342                 break;
 343         case SR_HWCAP_LIMIT_SAMPLES:
 344     {
 345       const uint64_t num_samples = *(const uint64_t *)value;
 346       if (num_samples < 1024)
 347       {
 348         sr_err("minimum of 1024 samples required");
 349         ret = SR_ERR_ARG;
 350
 351       } else {
 352         devc->limit_samples = num_samples;
 353         sr_dbg("setting limit_samples to %i\n", num_samples);
 354         ret = SR_OK;
 355       }
 356     }
 357                 break;
 358   case SR_HWCAP_CAPTURE_RATIO:
 359     ret = SR_OK;
 360                 break;
 361   case SR_HWCAP_TRIGGER_SLOPE:
 362     {
 363       const uint64_t slope = *(const uint64_t *)value;
 364       if (slope != SLOPE_NEGATIVE && slope != SLOPE_POSITIVE)
 365       {
 366         sr_err("Invalid trigger slope");
 367         ret = SR_ERR_ARG;
 368       } else {
 369         devc->trigger_slope = slope;
 370         ret = SR_OK;
 371       }
 372     }
 373     break;
 374   case SR_HWCAP_HORIZ_TRIGGERPOS:
 375     {
 376       const float pos = *(const float *)value;
 377       if (pos < 0 || pos > 255) {
 378         sr_err("Trigger position (%f) should be between 0 and 255.", pos);
 379         ret = SR_ERR_ARG;
 380       } else {
 381         int trigger_pos = (int)pos;
 382         devc->trigger_holdoff[0] = trigger_pos&0xff;
 383         ret = SR_OK;
 384       }
 385     }
 386     break;
 387
 388         case SR_HWCAP_RLE:
 389     ret = SR_OK;
 390                 break;
 391         default:
 392                 ret = SR_ERR;
 393         }
 394
 395         return ret;
 396 }
 397
 398 static int hw_dev_acquisition_start(const struct sr_dev_inst *sdi,
 399                 void *cb_data)
 400 {
 401         struct sr_datafeed_packet *packet;
 402         struct sr_datafeed_header *header;
 403         struct sr_datafeed_meta_logic meta;
 404         struct dev_context *devc;
 405         int ret = SR_ERR;
 406
 407
 408         devc = sdi->priv;
 409
 410         if (sdi->status != SR_ST_ACTIVE)
 411                 return SR_ERR;
 412
 413         if (mso_configure_probes(sdi) != SR_OK) {
 414                 sr_err("Failed to configure probes.");
 415                 return SR_ERR;
 416         }
 417
 418         /* FIXME: No need to do full reconfigure every time */
 419 //      ret = mso_reset_fsm(sdi);
 420 //      if (ret != SR_OK)
 421 //              return ret;
 422
 423         /* FIXME: ACDC Mode */
 424         devc->ctlbase1 &= 0x7f;
 425 //      devc->ctlbase1 |= devc->acdcmode;
 426
 427         ret = mso_configure_rate(sdi, devc->cur_rate);
 428         if (ret != SR_OK)
 429                 return ret;
 430
 431         /* set dac offset */
 432         ret = mso_dac_out(sdi, devc->dac_offset);
 433         if (ret != SR_OK)
 434                 return ret;
 435
 436         ret = mso_configure_threshold_level(sdi);
 437         if (ret != SR_OK)
 438                 return ret;
 439
 440
 441         ret = mso_configure_trigger(sdi);
 442         if (ret != SR_OK)
 443                 return ret;
 444
 445
 446         /* END of config hardware part */
 447   ret = mso_arm(sdi);
 448   if (ret != SR_OK)
 449     return ret;
 450
 451         /* Start acquisition on the device. */
 452         mso_check_trigger(devc->serial, &devc->trigger_state);
 453         ret = mso_check_trigger(devc->serial, NULL);
 454         if (ret != SR_OK)
 455                 return ret;
 456
 457   sr_source_add(devc->serial->fd, G_IO_IN, -1, mso_receive_data, cb_data);
 458
 459         if (!(packet = g_try_malloc(sizeof(struct sr_datafeed_packet)))) {
 460                 sr_err("Datafeed packet malloc failed.");
 461                 return SR_ERR_MALLOC;
 462         }
 463
 464         if (!(header = g_try_malloc(sizeof(struct sr_datafeed_header)))) {
 465                 sr_err("Datafeed header malloc failed.");
 466                 g_free(packet);
 467                 return SR_ERR_MALLOC;
 468         }
 469
 470
 471         packet->type = SR_DF_HEADER;
 472         packet->payload = (unsigned char *)header;
 473         header->feed_version = 1;
 474         gettimeofday(&header->starttime, NULL);
 475         sr_session_send(cb_data, packet);
 476
 477         packet->type = SR_DF_META_LOGIC;
 478         packet->payload = &meta;
 479         meta.samplerate = devc->cur_rate;
 480         meta.num_probes = NUM_PROBES;
 481         sr_session_send(cb_data, packet);
 482
 483         g_free(header);
 484         g_free(packet);
 485
 486         return SR_OK;
 487 }
 488
 489 /* This stops acquisition on ALL devices, ignoring dev_index. */
 490 static int hw_dev_acquisition_stop(struct sr_dev_inst *sdi, void *cb_data)
 491 {
 492         /* Avoid compiler warnings. */
 493         (void)cb_data;
 494
 495         stop_acquisition(sdi);
 496
 497         return SR_OK;
 498 }
 499
 500 SR_PRIV struct sr_dev_driver link_mso19_driver_info = {
 501         .name = "link-mso19",
 502         .longname = "Link Instruments MSO-19",
 503         .api_version = 1,
 504         .init = hw_init,
 505         .cleanup = hw_cleanup,
 506         .scan = hw_scan,
 507         .dev_list = hw_dev_list,
 508         .dev_clear = hw_cleanup,
 509         .dev_open = hw_dev_open,
 510         .dev_close = hw_dev_close,
 511         .info_get = hw_info_get,
 512         .dev_config_set = hw_dev_config_set,
 513         .dev_acquisition_start = hw_dev_acquisition_start,
 514         .dev_acquisition_stop = hw_dev_acquisition_stop,
 515         .priv = NULL,
 516 };