sigrok.h

   1 /*
   2  * This file is part of the sigrok project.
   3  *
   4  * Copyright (C) 2010 Bert Vermeulen <bert@biot.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 #ifndef SIGROK_SIGROK_H
  21 #define SIGROK_SIGROK_H
  22
  23 #include <stdio.h>
  24 #include <sys/time.h>
  25 #include <stdint.h>
  26 #include <inttypes.h>
  27 #include <glib.h>
  28 #include <libusb.h>
  29
  30
  31 /*
  32  * Status/error codes returned by libsigrok functions.
  33  *
  34  * All possible return codes of libsigrok functions must be listed here.
  35  * Functions should never return hardcoded numbers as status, but rather
  36  * use these #defines instead. All error codes are negative numbers.
  37  *
  38  * The error codes are globally unique in libsigrok, i.e. if one of the
  39  * libsigrok functions returns a "malloc error" it must be exactly the same
  40  * return value as used by all other functions to indicate "malloc error".
  41  * There must be no functions which indicate two different errors via the
  42  * same return code.
  43  *
  44  * Also, for compatibility reasons, no defined return codes are ever removed
  45  * or reused for different #defines later. You can only add new #defines and
  46  * return codes, but never remove or redefine existing ones.
  47  */
  48 #define SIGROK_OK                 0 /* No error */
  49 #define SIGROK_ERR               -1 /* Generic/unspecified error */
  50 #define SIGROK_ERR_MALLOC        -2 /* Malloc/calloc/realloc error */
  51 #define SIGROK_ERR_SAMPLERATE    -3 /* Incorrect samplerate */
  52
  53 /* limited by uint64_t */
  54 #define MAX_NUM_PROBES 64
  55 #define MAX_PROBENAME_LEN 32
  56
  57
  58 /* Handy little macros */
  59 #define KHZ(n) ((n) * 1000)
  60 #define MHZ(n) ((n) * 1000000)
  61 #define GHZ(n) ((n) * 1000000000)
  62
  63 #define HZ_TO_NS(n) (1000000000 / (n))
  64
  65 #ifndef ARRAY_SIZE
  66 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
  67 #endif
  68
  69 #ifndef ARRAY_AND_SIZE
  70 #define ARRAY_AND_SIZE(a) (a), ARRAY_SIZE(a)
  71 #endif
  72
  73
  74 typedef int (*receive_data_callback) (int fd, int revents, void *user_data);
  75
  76
  77 /* Data types used by hardware plugins for set_configuration() */
  78 enum {
  79         T_UINT64,
  80         T_CHAR,
  81 };
  82
  83 enum {
  84         PROTO_RAW,
  85 };
  86
  87 /* (Unused) protocol decoder stack entry */
  88 struct protocol {
  89         char *name;
  90         int id;
  91         int stackindex;
  92 };
  93
  94
  95
  96 /* datafeed_packet.type values */
  97 enum {
  98         DF_HEADER,
  99         DF_END,
 100         DF_TRIGGER,
 101         DF_LOGIC,
 102         DF_ANALOG,
 103         DF_PD,
 104 };
 105
 106 struct datafeed_packet {
 107         uint16_t type;
 108         uint64_t length;
 109         uint16_t unitsize;
 110         void *payload;
 111 };
 112
 113 struct datafeed_header {
 114         int feed_version;
 115         struct timeval starttime;
 116         uint64_t samplerate;
 117         int protocol_id;
 118         int num_analog_probes;
 119         int num_logic_probes;
 120 };
 121
 122
 123
 124 struct input {
 125         struct input_format *format;
 126         char *param;
 127         struct device *vdevice;
 128 };
 129
 130 struct input_format {
 131         char *extension;
 132         char *description;
 133         int (*format_match) (const char *filename);
 134         int (*init) (struct input *in);
 135         int (*loadfile) (struct input *in, const char *filename);
 136 };
 137
 138
 139
 140 struct output {
 141         struct output_format *format;
 142         struct device *device;
 143         char *param;
 144         void *internal;
 145 };
 146
 147 struct output_format {
 148         char *extension;
 149         char *description;
 150         int df_type;
 151         int (*init) (struct output *o);
 152         int (*data) (struct output *o, char *data_in, uint64_t length_in,
 153                      char **data_out, uint64_t *length_out);
 154         int (*event) (struct output *o, int event_type, char **data_out,
 155                       uint64_t *length_out);
 156 };
 157
 158
 159 struct analyzer {
 160         char *name;
 161         char *filename;
 162         /*
 163          * TODO: Parameters? If so, configured plugins need another struct.
 164          * TODO: Input and output format?
 165          */
 166 };
 167
 168
 169 /* Size of a chunk in units */
 170 #define DATASTORE_CHUNKSIZE 512000
 171
 172 struct datastore {
 173         /* Size in bytes of the number of units stored in this datastore */
 174         int ds_unitsize;
 175         unsigned int num_units; /* TODO: uint64_t */
 176         GSList *chunklist;
 177 };
 178
 179
 180 /*
 181  * This represents a generic device connected to the system.
 182  * For device-specific information, ask the plugin. The plugin_index refers
 183  * to the device index within that plugin; it may be handling more than one
 184  * device. All relevant plugin calls take a device_index parameter for this.
 185  */
 186 struct device {
 187         /* Which plugin handles this device */
 188         struct device_plugin *plugin;
 189         /* A plugin may handle multiple devices of the same type */
 190         int plugin_index;
 191         /* List of struct probe* */
 192         GSList *probes;
 193         /* Data acquired by this device, if any */
 194         struct datastore *datastore;
 195 };
 196
 197 enum {
 198         PROBE_TYPE_LOGIC,
 199         PROBE_TYPE_ANALOG,
 200 };
 201
 202 struct probe {
 203         int index;
 204         int type;
 205         gboolean enabled;
 206         char *name;
 207         char *trigger;
 208 };
 209
 210 extern GSList *devices;
 211
 212
 213 /* Hardware plugin capabilities */
 214 enum {
 215         HWCAP_DUMMY,             /* Used to terminate lists */
 216         HWCAP_LOGIC_ANALYZER,
 217         HWCAP_SAMPLERATE,        /* Change samplerate */
 218         HWCAP_PROBECONFIG,       /* Configure probe mask */
 219         HWCAP_CAPTURE_RATIO,     /* Set pre/post-trigger capture ratio */
 220         HWCAP_LIMIT_MSEC,        /* Set a time limit for sample acquisition */
 221         HWCAP_LIMIT_SAMPLES,     /* Set a limit on number of samples */
 222         HWCAP_CONTINUOUS,
 223 };
 224
 225 struct hwcap_option {
 226         int capability;
 227         int type;
 228         char *description;
 229         char *shortname;
 230 };
 231
 232
 233 struct sigrok_device_instance {
 234         int index;
 235         int status;
 236         int instance_type;
 237         char *vendor;
 238         char *model;
 239         char *version;
 240         void *priv;
 241         union {
 242                 struct usb_device_instance *usb;
 243                 struct serial_device_instance *serial;
 244         };
 245 };
 246
 247 /* sigrok_device_instance types */
 248 enum {
 249         USB_INSTANCE,
 250         SERIAL_INSTANCE,
 251 };
 252
 253 struct usb_device_instance {
 254         uint8_t bus;
 255         uint8_t address;
 256         struct libusb_device_handle *devhdl;
 257 };
 258
 259 struct serial_device_instance {
 260         char *port;
 261         int fd;
 262 };
 263
 264 /* Device instance status */
 265 enum {
 266         ST_NOT_FOUND,
 267         /* Found, but still booting */
 268         ST_INITIALIZING,
 269         /* Live, but not in use */
 270         ST_INACTIVE,
 271         /* Actively in use in a session */
 272         ST_ACTIVE,
 273 };
 274
 275 /*
 276  * TODO: This sucks, you just kinda have to "know" the returned type.
 277  * TODO: Need a DI to return the number of trigger stages supported.
 278  */
 279
 280 /* Device info IDs */
 281 enum {
 282         /* struct sigrok_device_instance for this specific device */
 283         DI_INSTANCE,
 284         /* The number of probes connected to this device */
 285         DI_NUM_PROBES,
 286         /* Samplerates supported by this device, (struct samplerates) */
 287         DI_SAMPLERATES,
 288         /* Types of trigger supported, out of "01crf" (char *) */
 289         DI_TRIGGER_TYPES,
 290         /* The currently set samplerate in Hz (uint64_t) */
 291         DI_CUR_SAMPLERATE,
 292 };
 293
 294 /*
 295  * A device supports either a range of samplerates with steps of a given
 296  * granularity, or is limited to a set of defined samplerates. Use either
 297  * step or list, but not both.
 298  */
 299 struct samplerates {
 300         uint64_t low;
 301         uint64_t high;
 302         uint64_t step;
 303         uint64_t *list;
 304 };
 305
 306 struct device_plugin {
 307         /* Plugin-specific */
 308         char *name;
 309         int api_version;
 310         int (*init) (char *deviceinfo);
 311         void (*cleanup) (void);
 312
 313         /* Device-specific */
 314         int (*open) (int device_index);
 315         void (*close) (int device_index);
 316         void *(*get_device_info) (int device_index, int device_info_id);
 317         int (*get_status) (int device_index);
 318         int *(*get_capabilities) (void);
 319         int (*set_configuration) (int device_index, int capability, void *value);
 320         int (*start_acquisition) (int device_index, gpointer session_device_id);
 321         void (*stop_acquisition) (int device_index, gpointer session_device_id);
 322 };
 323
 324 struct gsource_fd {
 325         GSource source;
 326         GPollFD gpfd;
 327         /* Not really using this */
 328         GSource *timeout_source;
 329 };
 330
 331 struct session {
 332         /* List of struct device* */
 333         GSList *devices;
 334         /* List of struct analyzer* */
 335         GSList *analyzers;
 336         /* Datafeed callbacks */
 337         GSList *datafeed_callbacks;
 338         GTimeVal starttime;
 339 };
 340
 341 #include "sigrok-proto.h"
 342 #endif