session.c

   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 #include "config.h"
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <unistd.h>
  24 #include <string.h>
  25 #include <glib.h>
  26 #include "sigrok.h"
  27 #include "sigrok-internal.h"
  28
  29 /* demo.c */
  30 extern GIOChannel channels[2];
  31
  32 struct source {
  33         int fd;
  34         int events;
  35         int timeout;
  36         sr_receive_data_callback cb;
  37         void *user_data;
  38 };
  39
  40 /* There can only be one session at a time. */
  41 /* 'session' is not static, it's used elsewhere (via 'extern'). */
  42 struct sr_session *session;
  43 static int num_sources = 0;
  44
  45 static struct source *sources = NULL;
  46 static int source_timeout = -1;
  47
  48 /**
  49  * Create a new session.
  50  *
  51  * TODO.
  52  *
  53  * TODO: Should return int?
  54  * TODO: Should it use the file-global "session" variable or take an argument?
  55  *       The same question applies to all the other session functions.
  56  *
  57  * @return A pointer to the newly allocated session, or NULL upon errors.
  58  */
  59 struct sr_session *sr_session_new(void)
  60 {
  61         if (!(session = calloc(1, sizeof(struct sr_session)))) {
  62                 sr_err("session: %s: session malloc failed", __func__);
  63                 return NULL; /* TODO: SR_ERR_MALLOC? */
  64         }
  65
  66         return session;
  67 }
  68
  69 /**
  70  * Destroy the current session.
  71  *
  72  * This frees up all memory used by the session.
  73  *
  74  * @return SR_OK upon success, SR_ERR_BUG if no session exists.
  75  */
  76 int sr_session_destroy(void)
  77 {
  78         if (!session) {
  79                 sr_warn("session: %s: session was NULL", __func__);
  80                 return SR_ERR_BUG;
  81         }
  82
  83         g_slist_free(session->devices);
  84         session->devices = NULL;
  85
  86         /* TODO: Error checks needed? */
  87
  88         /* TODO: Loop over protocol decoders and free them. */
  89
  90         g_free(session);
  91         session = NULL;
  92
  93         return SR_OK;
  94 }
  95
  96 /**
  97  * Remove all the devices from the current session. TODO?
  98  *
  99  * The session itself (i.e., the struct sr_session) is not free'd and still
 100  * exists after this function returns.
 101  *
 102  * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 103  */
 104 int sr_session_device_clear(void)
 105 {
 106         if (!session) {
 107                 sr_warn("session: %s: session was NULL", __func__);
 108                 return SR_ERR_BUG;
 109         }
 110
 111         g_slist_free(session->devices);
 112         session->devices = NULL;
 113
 114         return SR_OK;
 115 }
 116
 117 /**
 118  * Add a device to the current session.
 119  *
 120  * @param device The device to add to the current session. Must not be NULL.
 121  *               Also, device->plugin and device->plugin->opendev must not
 122  *               be NULL.
 123  *
 124  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 125  */
 126 int sr_session_device_add(struct sr_device *device)
 127 {
 128         int ret;
 129
 130         if (!device) {
 131                 sr_err("session: %s: device was NULL", __func__);
 132                 return SR_ERR_ARG;
 133         }
 134
 135         if (!device->plugin) {
 136                 sr_err("session: %s: device->plugin was NULL", __func__);
 137                 return SR_ERR_ARG;
 138         }
 139
 140         if (!device->plugin->opendev) {
 141                 sr_err("session: %s: device->plugin->opendev was NULL",
 142                        __func__);
 143                 return SR_ERR_ARG;
 144         }
 145
 146         if (!session) {
 147                 sr_err("session: %s: session was NULL", __func__);
 148                 return SR_ERR; /* TODO: SR_ERR_BUG? */
 149         }
 150
 151         if ((ret = device->plugin->opendev(device->plugin_index)) != SR_OK) {
 152                 sr_err("session: %s: opendev failed (%d)", __func__, ret);
 153                 return ret;
 154         }
 155
 156         session->devices = g_slist_append(session->devices, device);
 157
 158         return SR_OK;
 159 }
 160
 161 /**
 162  * Clear all datafeed callbacks in the current session.
 163  *
 164  * TODO.
 165  *
 166  * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 167  */
 168 int sr_session_datafeed_callback_clear(void)
 169 {
 170         if (!session) {
 171                 sr_err("session: %s: session was NULL", __func__);
 172                 return SR_ERR_BUG;
 173         }
 174
 175         g_slist_free(session->datafeed_callbacks);
 176         session->datafeed_callbacks = NULL;
 177
 178         return SR_OK;
 179 }
 180
 181 /**
 182  * Add a datafeed callback to the current session.
 183  *
 184  * @param callback TODO.
 185  * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 186  */
 187 int sr_session_datafeed_callback_add(sr_datafeed_callback callback)
 188 {
 189         if (!session) {
 190                 sr_err("session: %s: session was NULL", __func__);
 191                 return SR_ERR_BUG;
 192         }
 193
 194         /* TODO: Is 'callback' allowed to be NULL? */
 195
 196         session->datafeed_callbacks =
 197             g_slist_append(session->datafeed_callbacks, callback);
 198
 199         return SR_OK;
 200 }
 201
 202 /**
 203  * TODO.
 204  */
 205 static int sr_session_run_poll(void)
 206 {
 207         GPollFD *fds, my_gpollfd;
 208         int ret, i;
 209
 210         fds = NULL;
 211         while (session->running) {
 212                 if (fds)
 213                         free(fds);
 214
 215                 /* Construct g_poll()'s array. */
 216                 /* TODO: Check malloc return value. */
 217                 fds = malloc(sizeof(GPollFD) * num_sources);
 218                 if (!fds) {
 219                         sr_err("session: %s: fds malloc failed", __func__);
 220                         return SR_ERR_MALLOC;
 221                 }
 222                 for (i = 0; i < num_sources; i++) {
 223 #ifdef _WIN32
 224                         g_io_channel_win32_make_pollfd(&channels[0],
 225                                         sources[i].events, &my_gpollfd);
 226 #else
 227                         my_gpollfd.fd = sources[i].fd;
 228                         my_gpollfd.events = sources[i].events;
 229                         fds[i] = my_gpollfd;
 230 #endif
 231                 }
 232
 233                 ret = g_poll(fds, num_sources, source_timeout);
 234
 235                 for (i = 0; i < num_sources; i++) {
 236                         if (fds[i].revents > 0 || (ret == 0
 237                                 && source_timeout == sources[i].timeout)) {
 238                                 /*
 239                                  * Invoke the source's callback on an event,
 240                                  * or if the poll timeout out and this source
 241                                  * asked for that timeout.
 242                                  */
 243                                 if (!sources[i].cb(fds[i].fd, fds[i].revents,
 244                                                   sources[i].user_data))
 245                                         sr_session_source_remove(sources[i].fd);
 246                         }
 247                 }
 248         }
 249         free(fds);
 250
 251         return SR_OK;
 252 }
 253
 254 /**
 255  * Start a session.
 256  *
 257  * There can only be one session at a time. TODO
 258  *
 259  * @return SR_OK upon success, SR_ERR upon errors.
 260  */
 261 int sr_session_start(void)
 262 {
 263         struct sr_device *device;
 264         GSList *l;
 265         int ret;
 266
 267         if (!session) {
 268                 sr_err("session: %s: session was NULL; a session must be "
 269                        "created first, before starting it.", __func__);
 270                 return SR_ERR; /* TODO: SR_ERR_BUG? */
 271         }
 272
 273         if (!session->devices) {
 274                 /* TODO: Actually the case? */
 275                 sr_err("session: %s: session->devices was NULL; a session "
 276                        "cannot be started without devices.", __func__);
 277                 return SR_ERR; /* TODO: SR_ERR_BUG? */
 278         }
 279
 280         /* TODO: Check plugin_index validity? */
 281
 282         sr_info("session: starting");
 283
 284         for (l = session->devices; l; l = l->next) {
 285                 device = l->data;
 286                 /* TODO: Check for device != NULL. */
 287                 if ((ret = device->plugin->start_acquisition(
 288                                 device->plugin_index, device)) != SR_OK) {
 289                         sr_err("session: %s: could not start an acquisition "
 290                                "(%d)", __func__, ret);
 291                         break;
 292                 }
 293         }
 294
 295         /* TODO: What if there are multiple devices? Which return code? */
 296
 297         return ret;
 298 }
 299
 300 /**
 301  * Run the session.
 302  *
 303  * TODO: Various error checks etc.
 304  *
 305  * @return SR_OK upon success, SR_ERR_BUG upon errors.
 306  */
 307 int sr_session_run(void)
 308 {
 309         if (!session) {
 310                 sr_err("session: %s: session was NULL; a session must be "
 311                        "created first, before running it.", __func__);
 312                 return SR_ERR_BUG;
 313         }
 314
 315         if (!session->devices) {
 316                 /* TODO: Actually the case? */
 317                 sr_err("session: %s: session->devices was NULL; a session "
 318                        "cannot be run without devices.", __func__);
 319                 return SR_ERR_BUG;
 320         }
 321
 322         sr_info("session: running");
 323         session->running = TRUE;
 324
 325         /* Do we have real sources? */
 326         if (num_sources == 1 && sources[0].fd == -1) {
 327                 /* Dummy source, freewheel over it. */
 328                 while (session->running)
 329                         sources[0].cb(-1, 0, sources[0].user_data);
 330         } else {
 331                 /* Real sources, use g_poll() main loop. */
 332                 sr_session_run_poll();
 333         }
 334
 335         return SR_OK;
 336 }
 337
 338 /**
 339  * Halt the current session.
 340  *
 341  * TODO.
 342  *
 343  * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 344  */
 345 int sr_session_halt(void)
 346 {
 347         if (!session) {
 348                 sr_err("session: %s: session was NULL", __func__);
 349                 return SR_ERR_BUG;
 350         }
 351
 352         sr_info("session: halting");
 353         session->running = FALSE;
 354
 355         return SR_OK;
 356 }
 357
 358 /**
 359  * Stop the current session.
 360  *
 361  * TODO: Difference to halt?
 362  *
 363  * @return SR_OK upon success, SR_ERR_BUG if no session exists.
 364  */
 365 int sr_session_stop(void)
 366 {
 367         struct sr_device *device;
 368         GSList *l;
 369
 370         if (!session) {
 371                 sr_err("session: %s: session was NULL", __func__);
 372                 return SR_ERR_BUG;
 373         }
 374
 375         sr_info("session: stopping");
 376         session->running = FALSE;
 377
 378         for (l = session->devices; l; l = l->next) {
 379                 device = l->data;
 380                 /* Check for device != NULL. */
 381                 if (device->plugin && device->plugin->stop_acquisition)
 382                         device->plugin->stop_acquisition(device->plugin_index, device);
 383         }
 384
 385         return SR_OK;
 386 }
 387
 388 /**
 389  * TODO.
 390  *
 391  * TODO: Various error checks.
 392  *
 393  * @param packet TODO.
 394  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 395  */
 396 static int datafeed_dump(struct sr_datafeed_packet *packet)
 397 {
 398         struct sr_datafeed_logic *logic;
 399
 400         if (!packet) {
 401                 sr_err("session: %s: packet was NULL", __func__);
 402                 return SR_ERR_ARG;
 403         }
 404
 405         /* TODO: Validity checks for packet contents. */
 406
 407         switch (packet->type) {
 408         case SR_DF_HEADER:
 409                 sr_dbg("bus: received SR_DF_HEADER");
 410                 break;
 411         case SR_DF_TRIGGER:
 412                 sr_dbg("bus: received SR_DF_TRIGGER at %lu ms",
 413                        packet->timeoffset / 1000000);
 414                 break;
 415         case SR_DF_LOGIC:
 416                 logic = packet->payload;
 417                 /* TODO: Check for logic != NULL. */
 418                 sr_dbg("bus: received SR_DF_LOGIC at %f ms duration %f ms, "
 419                        "%" PRIu64 " bytes", packet->timeoffset / 1000000.0,
 420                        packet->duration / 1000000.0, logic->length);
 421                 break;
 422         case SR_DF_END:
 423                 sr_dbg("bus: received SR_DF_END");
 424                 break;
 425         default:
 426                 /* TODO: Abort? */
 427                 sr_err("bus: received unknown packet type %d", packet->type);
 428                 break;
 429         }
 430
 431         return SR_OK;
 432 }
 433
 434 /**
 435  * TODO.
 436  *
 437  * @param device TODO.
 438  * @param packet TODO.
 439  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 440  */
 441 int sr_session_bus(struct sr_device *device, struct sr_datafeed_packet *packet)
 442 {
 443         GSList *l;
 444         sr_datafeed_callback cb;
 445
 446         if (!device) {
 447                 sr_err("session: %s: device was NULL", __func__);
 448                 return SR_ERR_ARG;
 449         }
 450
 451         if (!device->plugin) {
 452                 sr_err("session: %s: device->plugin was NULL", __func__);
 453                 return SR_ERR_ARG;
 454         }
 455
 456         if (!packet) {
 457                 sr_err("session: %s: packet was NULL", __func__);
 458                 return SR_ERR_ARG;
 459         }
 460
 461         /*
 462          * TODO: Send packet through PD pipe, and send the output of that to
 463          * the callbacks as well.
 464          */
 465         for (l = session->datafeed_callbacks; l; l = l->next) {
 466                 cb = l->data;
 467                 /* TODO: Check for cb != NULL. */
 468                 datafeed_dump(packet);
 469                 cb(device, packet);
 470         }
 471
 472         return SR_OK;
 473 }
 474
 475 /**
 476  * TODO.
 477  *
 478  * TODO: Switch to g_try_malloc0() / g_free().
 479  * TODO: More error checks etc.
 480  *
 481  * @param fd TODO.
 482  * @param events TODO.
 483  * @param timeout TODO.
 484  * @param callback TODO.
 485  * @param user_data TODO.
 486  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 487  *         SR_ERR_MALLOC upon memory allocation errors.
 488  */
 489 int sr_session_source_add(int fd, int events, int timeout,
 490                 sr_receive_data_callback callback, void *user_data)
 491 {
 492         struct source *new_sources, *s;
 493
 494         if (!callback) {
 495                 sr_err("session: %s: callback was NULL", __func__);
 496                 return SR_ERR_ARG;
 497         }
 498
 499         /* Note: user_data can be NULL, that's not a bug. */
 500
 501         new_sources = calloc(1, sizeof(struct source) * (num_sources + 1));
 502         if (!new_sources) {
 503                 sr_err("session: %s: new_sources malloc failed", __func__);
 504                 return SR_ERR_MALLOC;
 505         }
 506
 507         if (sources) {
 508                 memcpy(new_sources, sources,
 509                        sizeof(struct source) * num_sources);
 510                 free(sources);
 511         }
 512
 513         s = &new_sources[num_sources++];
 514         s->fd = fd;
 515         s->events = events;
 516         s->timeout = timeout;
 517         s->cb = callback;
 518         s->user_data = user_data;
 519         sources = new_sources;
 520
 521         if (timeout != source_timeout && timeout > 0
 522             && (source_timeout == -1 || timeout < source_timeout))
 523                 source_timeout = timeout;
 524
 525         return SR_OK;
 526 }
 527
 528 /**
 529  * Remove the source belonging to the specified file descriptor.
 530  *
 531  * TODO: More error checks.
 532  * TODO: Switch to g_try_malloc0() / g_free().
 533  *
 534  * @param fd TODO.
 535  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 536  *         SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
 537  *         internal errors.
 538  */
 539 int sr_session_source_remove(int fd)
 540 {
 541         struct source *new_sources;
 542         int old, new;
 543
 544         if (!sources) {
 545                 sr_err("session: %s: sources was NULL", __func__);
 546                 return SR_ERR_BUG; /* TODO: Other? */
 547         }
 548
 549         /* TODO: Check if 'fd' valid. */
 550
 551         new_sources = calloc(1, sizeof(struct source) * num_sources);
 552         if (!new_sources) {
 553                 sr_err("session: %s: new_sources malloc failed", __func__);
 554                 return SR_ERR_MALLOC;
 555         }
 556
 557         for (old = 0, new = 0; old < num_sources; old++) {
 558                 if (sources[old].fd != fd)
 559                         memcpy(&new_sources[new++], &sources[old],
 560                                sizeof(struct source));
 561         }
 562
 563         if (old != new) {
 564                 free(sources);
 565                 sources = new_sources;
 566                 num_sources--;
 567         } else {
 568                 /* Target fd was not found. */
 569                 free(new_sources);
 570         }
 571
 572         return SR_OK;
 573 }