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) {
 382                         if (device->plugin->stop_acquisition)
 383                                 device->plugin->stop_acquisition(device->plugin_index, device);
 384                         if (device->plugin->cleanup)
 385                                 device->plugin->cleanup();
 386                 }
 387         }
 388
 389         return SR_OK;
 390 }
 391
 392 /**
 393  * TODO.
 394  *
 395  * TODO: Various error checks.
 396  *
 397  * @param packet TODO.
 398  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 399  */
 400 static int datafeed_dump(struct sr_datafeed_packet *packet)
 401 {
 402         struct sr_datafeed_logic *logic;
 403
 404         if (!packet) {
 405                 sr_err("session: %s: packet was NULL", __func__);
 406                 return SR_ERR_ARG;
 407         }
 408
 409         /* TODO: Validity checks for packet contents. */
 410
 411         switch (packet->type) {
 412         case SR_DF_HEADER:
 413                 sr_dbg("bus: received SR_DF_HEADER");
 414                 break;
 415         case SR_DF_TRIGGER:
 416                 sr_dbg("bus: received SR_DF_TRIGGER at %lu ms",
 417                        packet->timeoffset / 1000000);
 418                 break;
 419         case SR_DF_LOGIC:
 420                 logic = packet->payload;
 421                 /* TODO: Check for logic != NULL. */
 422                 sr_dbg("bus: received SR_DF_LOGIC at %f ms duration %f ms, "
 423                        "%" PRIu64 " bytes", packet->timeoffset / 1000000.0,
 424                        packet->duration / 1000000.0, logic->length);
 425                 break;
 426         case SR_DF_END:
 427                 sr_dbg("bus: received SR_DF_END");
 428                 break;
 429         default:
 430                 /* TODO: Abort? */
 431                 sr_err("bus: received unknown packet type %d", packet->type);
 432                 break;
 433         }
 434
 435         return SR_OK;
 436 }
 437
 438 /**
 439  * TODO.
 440  *
 441  * @param device TODO.
 442  * @param packet TODO.
 443  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments.
 444  */
 445 int sr_session_bus(struct sr_device *device, struct sr_datafeed_packet *packet)
 446 {
 447         GSList *l;
 448         sr_datafeed_callback cb;
 449
 450         if (!device) {
 451                 sr_err("session: %s: device was NULL", __func__);
 452                 return SR_ERR_ARG;
 453         }
 454
 455         if (!device->plugin) {
 456                 sr_err("session: %s: device->plugin was NULL", __func__);
 457                 return SR_ERR_ARG;
 458         }
 459
 460         if (!packet) {
 461                 sr_err("session: %s: packet was NULL", __func__);
 462                 return SR_ERR_ARG;
 463         }
 464
 465         /*
 466          * TODO: Send packet through PD pipe, and send the output of that to
 467          * the callbacks as well.
 468          */
 469         for (l = session->datafeed_callbacks; l; l = l->next) {
 470                 cb = l->data;
 471                 /* TODO: Check for cb != NULL. */
 472                 datafeed_dump(packet);
 473                 cb(device, packet);
 474         }
 475
 476         return SR_OK;
 477 }
 478
 479 /**
 480  * TODO.
 481  *
 482  * TODO: Switch to g_try_malloc0() / g_free().
 483  * TODO: More error checks etc.
 484  *
 485  * @param fd TODO.
 486  * @param events TODO.
 487  * @param timeout TODO.
 488  * @param callback TODO.
 489  * @param user_data TODO.
 490  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 491  *         SR_ERR_MALLOC upon memory allocation errors.
 492  */
 493 int sr_session_source_add(int fd, int events, int timeout,
 494                 sr_receive_data_callback callback, void *user_data)
 495 {
 496         struct source *new_sources, *s;
 497
 498         if (!callback) {
 499                 sr_err("session: %s: callback was NULL", __func__);
 500                 return SR_ERR_ARG;
 501         }
 502
 503         /* Note: user_data can be NULL, that's not a bug. */
 504
 505         new_sources = calloc(1, sizeof(struct source) * (num_sources + 1));
 506         if (!new_sources) {
 507                 sr_err("session: %s: new_sources malloc failed", __func__);
 508                 return SR_ERR_MALLOC;
 509         }
 510
 511         if (sources) {
 512                 memcpy(new_sources, sources,
 513                        sizeof(struct source) * num_sources);
 514                 free(sources);
 515         }
 516
 517         s = &new_sources[num_sources++];
 518         s->fd = fd;
 519         s->events = events;
 520         s->timeout = timeout;
 521         s->cb = callback;
 522         s->user_data = user_data;
 523         sources = new_sources;
 524
 525         if (timeout != source_timeout && timeout > 0
 526             && (source_timeout == -1 || timeout < source_timeout))
 527                 source_timeout = timeout;
 528
 529         return SR_OK;
 530 }
 531
 532 /**
 533  * Remove the source belonging to the specified file descriptor.
 534  *
 535  * TODO: More error checks.
 536  * TODO: Switch to g_try_malloc0() / g_free().
 537  *
 538  * @param fd TODO.
 539  * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments, or
 540  *         SR_ERR_MALLOC upon memory allocation errors, SR_ERR_BUG upon
 541  *         internal errors.
 542  */
 543 int sr_session_source_remove(int fd)
 544 {
 545         struct source *new_sources;
 546         int old, new;
 547
 548         if (!sources) {
 549                 sr_err("session: %s: sources was NULL", __func__);
 550                 return SR_ERR_BUG; /* TODO: Other? */
 551         }
 552
 553         /* TODO: Check if 'fd' valid. */
 554
 555         new_sources = calloc(1, sizeof(struct source) * num_sources);
 556         if (!new_sources) {
 557                 sr_err("session: %s: new_sources malloc failed", __func__);
 558                 return SR_ERR_MALLOC;
 559         }
 560
 561         for (old = 0, new = 0; old < num_sources; old++) {
 562                 if (sources[old].fd != fd)
 563                         memcpy(&new_sources[new++], &sources[old],
 564                                sizeof(struct source));
 565         }
 566
 567         if (old != new) {
 568                 free(sources);
 569                 sources = new_sources;
 570                 num_sources--;
 571         } else {
 572                 /* Target fd was not found. */
 573                 free(new_sources);
 574         }
 575
 576         return SR_OK;
 577 }