cli: stop immediately if SRD PD registration fails
[sigrok-cli.git] / sigrok-cli.c
index d5427a785b82e4287799363d09c77be30e07ef7c..359c34b8fd54877dd43f6583cf867b2effb63e7a 100644 (file)
@@ -38,7 +38,6 @@
 
 extern struct sr_hwcap_option sr_hwcap_options[];
 
-static gboolean debug = 0;
 static uint64_t limit_samples = 0;
 static struct sr_output_format *output_format = NULL;
 static int default_output_format = FALSE;
@@ -58,28 +57,44 @@ static gchar *opt_triggers = NULL;
 static gchar *opt_pds = NULL;
 static gchar *opt_pd_stack = NULL;
 static gchar *opt_input_format = NULL;
-static gchar *opt_format = NULL;
+static gchar *opt_output_format = NULL;
 static gchar *opt_time = NULL;
 static gchar *opt_samples = NULL;
 static gchar *opt_continuous = NULL;
 
 static GOptionEntry optargs[] = {
-       {"version", 'V', 0, G_OPTION_ARG_NONE, &opt_version, "Show version and support list", NULL},
-       {"loglevel", 'l', 0, G_OPTION_ARG_INT, &opt_loglevel, "Select libsigrok loglevel", NULL},
-       {"list-devices", 'D', 0, G_OPTION_ARG_NONE, &opt_list_devs, "List devices", NULL},
-       {"input-file", 'i', 0, G_OPTION_ARG_FILENAME, &opt_input_file, "Load input from file", NULL},
-       {"output-file", 'o', 0, G_OPTION_ARG_FILENAME, &opt_output_file, "Save output to file", NULL},
-       {"device", 'd', 0, G_OPTION_ARG_STRING, &opt_dev, "Use device ID", NULL},
-       {"probes", 'p', 0, G_OPTION_ARG_STRING, &opt_probes, "Probes to use", NULL},
-       {"triggers", 't', 0, G_OPTION_ARG_STRING, &opt_triggers, "Trigger configuration", NULL},
-       {"wait-trigger", 'w', 0, G_OPTION_ARG_NONE, &opt_wait_trigger, "Wait for trigger", NULL},
-       {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING, &opt_pds, "Protocol decoder sequence", NULL},
-       {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING, &opt_pd_stack, "Protocol decoder stack", NULL},
-       {"input-format", 'I', 0, G_OPTION_ARG_STRING, &opt_input_format, "Input format", NULL},
-       {"format", 'f', 0, G_OPTION_ARG_STRING, &opt_format, "Output format", NULL},
-       {"time", 0, 0, G_OPTION_ARG_STRING, &opt_time, "How long to sample (ms)", NULL},
-       {"samples", 0, 0, G_OPTION_ARG_STRING, &opt_samples, "Number of samples to acquire", NULL},
-       {"continuous", 0, 0, G_OPTION_ARG_NONE, &opt_continuous, "Sample continuously", NULL},
+       {"version", 'V', 0, G_OPTION_ARG_NONE, &opt_version,
+                       "Show version and support list", NULL},
+       {"loglevel", 'l', 0, G_OPTION_ARG_INT, &opt_loglevel,
+                       "Select libsigrok/libsigrokdecode loglevel", NULL},
+       {"list-devices", 'D', 0, G_OPTION_ARG_NONE, &opt_list_devs,
+                       "Scan for devices", NULL},
+       {"device", 'd', 0, G_OPTION_ARG_STRING, &opt_dev,
+                       "Use specified device", NULL},
+       {"input-file", 'i', 0, G_OPTION_ARG_FILENAME, &opt_input_file,
+                       "Load input from file", NULL},
+       {"input-format", 'I', 0, G_OPTION_ARG_STRING, &opt_input_format,
+                       "Input format", NULL},
+       {"output-file", 'o', 0, G_OPTION_ARG_FILENAME, &opt_output_file,
+                       "Save output to file", NULL},
+       {"output-format", 'O', 0, G_OPTION_ARG_STRING, &opt_output_format,
+                       "Output format", NULL},
+       {"probes", 'p', 0, G_OPTION_ARG_STRING, &opt_probes,
+                       "Probes to use", NULL},
+       {"triggers", 't', 0, G_OPTION_ARG_STRING, &opt_triggers,
+                       "Trigger configuration", NULL},
+       {"wait-trigger", 'w', 0, G_OPTION_ARG_NONE, &opt_wait_trigger,
+                       "Wait for trigger", NULL},
+       {"protocol-decoders", 'a', 0, G_OPTION_ARG_STRING, &opt_pds,
+                       "Protocol decoders to run", NULL},
+       {"protocol-decoder-stack", 's', 0, G_OPTION_ARG_STRING, &opt_pd_stack,
+                       "Protocol decoder stack", NULL},
+       {"time", 0, 0, G_OPTION_ARG_STRING, &opt_time,
+                       "How long to sample (ms)", NULL},
+       {"samples", 0, 0, G_OPTION_ARG_STRING, &opt_samples,
+                       "Number of samples to acquire", NULL},
+       {"continuous", 0, 0, G_OPTION_ARG_NONE, &opt_continuous,
+                       "Sample continuously", NULL},
        {NULL, 0, 0, 0, NULL, NULL, NULL}
 };
 
@@ -94,6 +109,11 @@ static void show_version(void)
 
        printf("sigrok-cli %s\n\n", VERSION);
 
+       printf("Using libsigrok %s (lib version %s).\n",
+              sr_package_version_string_get(), sr_lib_version_string_get());
+       printf("Using libsigrokdecode %s (lib version %s).\n\n",
+              srd_package_version_string_get(), srd_lib_version_string_get());
+
        printf("Supported hardware drivers:\n");
        drivers = sr_driver_list();
        for (i = 0; drivers[i]; i++) {
@@ -115,15 +135,17 @@ static void show_version(void)
 
        if (srd_init(NULL) == SRD_OK) {
                printf("Supported protocol decoders:\n");
-               srd_decoders_load_all();
-               for (l = srd_decoders_list(); l; l = l->next) {
+               srd_decoder_load_all();
+               for (l = srd_decoder_list(); l; l = l->next) {
                        dec = l->data;
                        printf("  %-20s %s\n", dec->id, dec->longname);
+                       /* Print protocol description upon "-l 3" or higher. */
+                       if (opt_loglevel >= SR_LOG_INFO)
+                               printf("  %-20s %s\n", "", dec->desc);
                }
                srd_exit();
        }
        printf("\n");
-
 }
 
 static void print_dev_line(const struct sr_dev *dev)
@@ -212,9 +234,9 @@ static void show_dev_detail(void)
 
                if (hwo->hwcap == SR_HWCAP_PATTERN_MODE) {
                        printf("    %s", hwo->shortname);
-                       if (sr_dev_info_get(dev, SR_DI_PATTERNMODES,
+                       if (sr_dev_info_get(dev, SR_DI_PATTERNS,
                                        (const void **)&stropts) == SR_OK) {
-                               printf(" - supported modes:\n");
+                               printf(" - supported patterns:\n");
                                for (i = 0; stropts[i]; i++)
                                        printf("      %s\n", stropts[i]);
                        } else {
@@ -262,37 +284,61 @@ static void show_pd_detail(void)
        GSList *l;
        struct srd_decoder *dec;
        char **pdtokens, **pdtok, **ann, *doc;
+       struct srd_probe *p;
 
        pdtokens = g_strsplit(opt_pds, ",", -1);
        for (pdtok = pdtokens; *pdtok; pdtok++) {
                if (!(dec = srd_decoder_get_by_id(*pdtok))) {
-                       printf("Protocol decoder %s not found.", *pdtok);
+                       printf("Protocol decoder %s not found.\n", *pdtok);
                        return;
                }
                printf("ID: %s\nName: %s\nLong name: %s\nDescription: %s\n",
                                dec->id, dec->name, dec->longname, dec->desc);
                printf("License: %s\n", dec->license);
+               printf("Annotations:\n");
                if (dec->annotations) {
-                       printf("Annotations:\n");
                        for (l = dec->annotations; l; l = l->next) {
                                ann = l->data;
                                printf("- %s\n  %s\n", ann[0], ann[1]);
                        }
+               } else {
+                       printf("None.\n");
+               }
+               /* TODO: Print supported decoder options. */
+               printf("Required probes:\n");
+               if (dec->probes) {
+                       for (l = dec->probes; l; l = l->next) {
+                               p = l->data;
+                               printf("- %s (%s): %s\n",
+                                      p->name, p->id, p->desc);
+                       }
+               } else {
+                       printf("None.\n");
+               }
+               printf("Optional probes:\n");
+               if (dec->opt_probes) {
+                       for (l = dec->opt_probes; l; l = l->next) {
+                               p = l->data;
+                               printf("- %s (%s): %s\n",
+                                      p->name, p->id, p->desc);
+                       }
+               } else {
+                       printf("None.\n");
                }
-               if ((doc = srd_decoder_doc(dec))) {
-                       printf("Documentation:\n%s\n", doc[0] == '\n' ? doc+1 : doc);
+               if ((doc = srd_decoder_doc_get(dec))) {
+                       printf("Documentation:\n%s\n",
+                              doc[0] == '\n' ? doc + 1 : doc);
                        g_free(doc);
                }
        }
 
        g_strfreev(pdtokens);
-
 }
 
 static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
 {
        static struct sr_output *o = NULL;
-       static int probelist[SR_MAX_NUM_PROBES] = { 0 };
+       static int probelist[SR_MAX_NUM_PROBES + 1] = { 0 };
        static uint64_t received_samples = 0;
        static int unitsize = 0;
        static int triggered = 0;
@@ -302,7 +348,7 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
        struct sr_datafeed_logic *logic;
        int num_enabled_probes, sample_size, ret, i;
        uint64_t output_len, filter_out_len;
-       char *output_buf, *filter_out;
+       uint8_t *output_buf, *filter_out;
 
        /* If the first packet to come in isn't a header, don't even try. */
        if (packet->type != SR_DF_HEADER && o == NULL)
@@ -311,10 +357,10 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
        sample_size = -1;
        switch (packet->type) {
        case SR_DF_HEADER:
-               g_message("cli: Received SR_DF_HEADER");
+               g_debug("cli: Received SR_DF_HEADER");
                /* Initialize the output module. */
                if (!(o = g_try_malloc(sizeof(struct sr_output)))) {
-                       printf("Output module malloc failed.\n");
+                       g_critical("Output module malloc failed.");
                        exit(1);
                }
                o->format = output_format;
@@ -322,7 +368,7 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
                o->param = output_format_param;
                if (o->format->init) {
                        if (o->format->init(o) != SR_OK) {
-                               printf("Output format initialization failed.\n");
+                               g_critical("Output format initialization failed.");
                                exit(1);
                        }
                }
@@ -346,23 +392,25 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
                                outfile = NULL;
                                ret = sr_datastore_new(unitsize, &(dev->datastore));
                                if (ret != SR_OK) {
-                                       printf("Failed to create datastore.\n");
+                                       g_critical("Failed to create datastore.");
                                        exit(1);
                                }
                        } else {
                                /* saving to a file in whatever format was set
-                                * with --format, so all we need is a filehandle */
+                                * with -O, so all we need is a filehandle */
                                outfile = g_fopen(opt_output_file, "wb");
                        }
                }
-               if (opt_pds)
-                       srd_session_start(num_enabled_probes, unitsize,
-                                       header->samplerate);
+               if (opt_pds) {
+                       if (srd_session_start(num_enabled_probes, unitsize,
+                                       header->samplerate) != SRD_OK)
+                               sr_session_halt();
+               }
                break;
        case SR_DF_END:
-               g_message("cli: Received SR_DF_END");
+               g_debug("cli: Received SR_DF_END");
                if (!o) {
-                       g_message("cli: double end!");
+                       g_debug("cli: double end!");
                        break;
                }
                if (o->format->event) {
@@ -375,10 +423,10 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
                        }
                }
                if (limit_samples && received_samples < limit_samples)
-                       printf("Device only sent %" PRIu64 " samples.\n",
+                       g_warning("Device only sent %" PRIu64 " samples.",
                               received_samples);
                if (opt_continuous)
-                       printf("Device stopped after %" PRIu64 " samples.\n",
+                       g_warning("Device stopped after %" PRIu64 " samples.",
                               received_samples);
                sr_session_halt();
                if (outfile && outfile != stdout)
@@ -387,7 +435,7 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
                o = NULL;
                break;
        case SR_DF_TRIGGER:
-               g_message("cli: received SR_DF_TRIGGER");
+               g_debug("cli: received SR_DF_TRIGGER");
                if (o->format->event)
                        o->format->event(o, SR_DF_TRIGGER, &output_buf,
                                         &output_len);
@@ -438,7 +486,7 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
                goto cleanup;
 
        if (opt_pds) {
-               if (srd_session_feed(received_samples, (uint8_t*)filter_out,
+               if (srd_session_send(received_samples, (uint8_t*)filter_out,
                                filter_out_len) != SRD_OK)
                        sr_session_halt();
        } else {
@@ -454,7 +502,6 @@ static void datafeed_in(struct sr_dev *dev, struct sr_datafeed_packet *packet)
 cleanup:
        g_free(filter_out);
        received_samples += logic->length / sample_size;
-
 }
 
 /* Register the given PDs for this session.
@@ -466,6 +513,7 @@ static int register_pds(struct sr_dev *dev, const char *pdstring)
 {
        GHashTable *pd_opthash;
        struct srd_decoder_inst *di;
+       int ret;
        char **pdtokens, **pdtok, *pd_name;
 
        /* Avoid compiler warnings. */
@@ -474,22 +522,25 @@ static int register_pds(struct sr_dev *dev, const char *pdstring)
        g_datalist_init(&pd_ann_visible);
        pdtokens = g_strsplit(pdstring, ",", -1);
        pd_opthash = NULL;
+       ret = 0;
        pd_name = NULL;
 
        for (pdtok = pdtokens; *pdtok; pdtok++) {
                if (!(pd_opthash = parse_generic_arg(*pdtok))) {
-                       fprintf(stderr, "Invalid protocol decoder option '%s'.\n", *pdtok);
+                       g_critical("Invalid protocol decoder option '%s'.", *pdtok);
                        goto err_out;
                }
 
                pd_name = g_strdup(g_hash_table_lookup(pd_opthash, "sigrok_key"));
                g_hash_table_remove(pd_opthash, "sigrok_key");
                if (srd_decoder_load(pd_name) != SRD_OK) {
-                       fprintf(stderr, "Failed to load protocol decoder %s\n", pd_name);
+                       g_critical("Failed to load protocol decoder %s.", pd_name);
+                       ret = 1;
                        goto err_out;
                }
                if (!(di = srd_inst_new(pd_name, pd_opthash))) {
-                       fprintf(stderr, "Failed to instantiate protocol decoder %s\n", pd_name);
+                       g_critical("Failed to instantiate protocol decoder %s.", pd_name);
+                       ret = 1;
                        goto err_out;
                }
                g_datalist_set_data(&pd_ann_visible, di->inst_id, pd_name);
@@ -498,8 +549,10 @@ static int register_pds(struct sr_dev *dev, const char *pdstring)
                 * is the probe name as specified in the decoder class, and the
                 * value is the probe number i.e. the order in which the PD's
                 * incoming samples are arranged. */
-               if (srd_inst_probes_set(di, pd_opthash) != SRD_OK)
+               if (srd_inst_probe_set_all(di, pd_opthash) != SRD_OK) {
+                       ret = 1;
                        goto err_out;
+               }
                g_hash_table_destroy(pd_opthash);
                pd_opthash = NULL;
        }
@@ -511,7 +564,7 @@ err_out:
        if (pd_name)
                g_free(pd_name);
 
-       return 0;
+       return ret;
 }
 
 void show_pd_annotation(struct srd_proto_data *pdata, void *cb_data)
@@ -539,7 +592,6 @@ void show_pd_annotation(struct srd_proto_data *pdata, void *cb_data)
        for (i = 0; annotations[i]; i++)
                printf("\"%s\" ", annotations[i]);
        printf("\n");
-
 }
 
 static int select_probes(struct sr_dev *dev)
@@ -596,8 +648,7 @@ static struct sr_input_format *determine_input_file_format(
        /* If there are no input formats, return NULL right away. */
        inputs = sr_input_list();
        if (!inputs) {
-               fprintf(stderr, "cli: %s: no supported input formats "
-                       "available", __func__);
+               g_critical("No supported input formats available.");
                return NULL;
        }
 
@@ -606,14 +657,14 @@ static struct sr_input_format *determine_input_file_format(
                for (i = 0; inputs[i]; i++) {
                        if (strcasecmp(inputs[i]->id, opt_input_format))
                                continue;
-                       printf("Using user-specified input file format"
-                              " '%s'.\n", inputs[i]->id);
+                       g_debug("Using user-specified input file format '%s'.",
+                                       inputs[i]->id);
                        return inputs[i];
                }
 
                /* The user specified an unknown input format, return NULL. */
-               fprintf(stderr, "Error: Specified input file format '%s' is "
-                       "unknown.\n", opt_input_format);
+               g_critical("Error: specified input file format '%s' is "
+                       "unknown.", opt_input_format);
                return NULL;
        }
 
@@ -625,11 +676,10 @@ static struct sr_input_format *determine_input_file_format(
 
        /* Return NULL if no input module wanted to touch this. */
        if (!inputs[i]) {
-               fprintf(stderr, "Error: No matching input module found.\n");
+               g_critical("Error: no matching input module found.");
                return NULL;
        }
                
-       printf("Using input file format '%s'.\n", inputs[i]->id);
        return inputs[i];
 }
 
@@ -639,29 +689,27 @@ static void load_input_file_format(void)
        struct sr_input *in;
        struct sr_input_format *input_format;
 
-       input_format = determine_input_file_format(opt_input_file,
-                                                  opt_input_format);
-       if (!input_format) {
-               fprintf(stderr, "Error: Couldn't detect input file format.\n");
+       if (!(input_format = determine_input_file_format(opt_input_file,
+                                                  opt_input_format)))
+               /* The exact cause was already logged. */
                return;
-       }
 
        if (stat(opt_input_file, &st) == -1) {
-               printf("Failed to load %s: %s\n", opt_input_file,
+               g_critical("Failed to load %s: %s", opt_input_file,
                        strerror(errno));
                exit(1);
        }
 
        /* Initialize the input module. */
        if (!(in = g_try_malloc(sizeof(struct sr_input)))) {
-               printf("Failed to allocate input module.\n");
+               g_critical("Failed to allocate input module.");
                exit(1);
        }
        in->format = input_format;
        in->param = input_format_param;
        if (in->format->init) {
                if (in->format->init(in) != SR_OK) {
-                       printf("Input format init failed.\n");
+                       g_critical("Input format init failed.");
                        exit(1);
                }
        }
@@ -672,7 +720,7 @@ static void load_input_file_format(void)
        sr_session_new();
        sr_session_datafeed_callback_add(datafeed_in);
        if (sr_session_dev_add(in->vdev) != SR_OK) {
-               printf("Failed to use device.\n");
+               g_critical("Failed to use device.");
                sr_session_destroy();
                return;
        }
@@ -680,10 +728,9 @@ static void load_input_file_format(void)
        input_format->loadfile(in, opt_input_file);
        if (opt_output_file && default_output_format) {
                if (sr_session_save(opt_output_file) != SR_OK)
-                       printf("Failed to save session.\n");
+                       g_critical("Failed to save session.");
        }
        sr_session_destroy();
-
 }
 
 static void load_input_file(void)
@@ -700,7 +747,6 @@ static void load_input_file(void)
                /* fall back on input modules */
                load_input_file_format();
        }
-
 }
 
 int num_real_devs(void)
@@ -737,7 +783,7 @@ static int set_dev_options(struct sr_dev *dev, GHashTable *args)
                                continue;
                        if ((value == NULL) && 
                            (sr_hwcap_options[i].type != SR_T_BOOL)) {
-                               printf("Option '%s' needs a value.\n", (char *)key);
+                               g_critical("Option '%s' needs a value.", (char *)key);
                                return SR_ERR;
                        }
                        found = TRUE;
@@ -767,14 +813,14 @@ static int set_dev_options(struct sr_dev *dev, GHashTable *args)
                        }
 
                        if (ret != SR_OK) {
-                               printf("Failed to set device option '%s'.\n", (char *)key);
+                               g_critical("Failed to set device option '%s'.", (char *)key);
                                return ret;
                        }
                        else
                                break;
                }
                if (!found) {
-                       printf("Unknown device option '%s'.\n", (char *) key);
+                       g_critical("Unknown device option '%s'.", (char *) key);
                        return SR_ERR;
                }
        }
@@ -796,7 +842,7 @@ static void run_session(void)
                devspec = g_hash_table_lookup(devargs, "sigrok_key");
                dev = parse_devstring(devspec);
                if (!dev) {
-                       g_warning("Device not found.");
+                       g_critical("Device not found.");
                        return;
                }
                g_hash_table_remove(devargs, "sigrok_key");
@@ -807,10 +853,10 @@ static void run_session(void)
                        devargs = NULL;
                        dev = parse_devstring("0");
                } else if (num_devs == 0) {
-                       printf("No devices found.\n");
+                       g_critical("No devices found.");
                        return;
                } else {
-                       printf("%d devices found, please select one.\n", num_devs);
+                       g_critical("%d devices found, please select one.", num_devs);
                        return;
                }
        }
@@ -819,7 +865,7 @@ static void run_session(void)
        sr_session_datafeed_callback_add(datafeed_in);
 
        if (sr_session_dev_add(dev) != SR_OK) {
-               printf("Failed to use device.\n");
+               g_critical("Failed to use device.");
                sr_session_destroy();
                return;
        }
@@ -837,7 +883,7 @@ static void run_session(void)
 
        if (opt_continuous) {
                if (!sr_driver_hwcap_exists(dev->driver, SR_HWCAP_CONTINUOUS)) {
-                       printf("This device does not support continuous sampling.");
+                       g_critical("This device does not support continuous sampling.");
                        sr_session_destroy();
                        return;
                }
@@ -863,7 +909,7 @@ static void run_session(void)
        if (opt_time) {
                time_msec = sr_parse_timestring(opt_time);
                if (time_msec == 0) {
-                       printf("Invalid time '%s'\n", opt_time);
+                       g_critical("Invalid time '%s'", opt_time);
                        sr_session_destroy();
                        return;
                }
@@ -871,7 +917,7 @@ static void run_session(void)
                if (sr_driver_hwcap_exists(dev->driver, SR_HWCAP_LIMIT_MSEC)) {
                        if (dev->driver->dev_config_set(dev->driver_index,
                            SR_HWCAP_LIMIT_MSEC, &time_msec) != SR_OK) {
-                               printf("Failed to configure time limit.\n");
+                               g_critical("Failed to configure time limit.");
                                sr_session_destroy();
                                return;
                        }
@@ -889,14 +935,14 @@ static void run_session(void)
                                limit_samples = (*samplerate) * time_msec / (uint64_t)1000;
                        }
                        if (limit_samples == 0) {
-                               printf("Not enough time at this samplerate.\n");
+                               g_critical("Not enough time at this samplerate.");
                                sr_session_destroy();
                                return;
                        }
 
                        if (dev->driver->dev_config_set(dev->driver_index,
                            SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK) {
-                               printf("Failed to configure time-based sample limit.\n");
+                               g_critical("Failed to configure time-based sample limit.");
                                sr_session_destroy();
                                return;
                        }
@@ -907,7 +953,7 @@ static void run_session(void)
                if ((sr_parse_sizestring(opt_samples, &limit_samples) != SR_OK)
                        || (dev->driver->dev_config_set(dev->driver_index,
                            SR_HWCAP_LIMIT_SAMPLES, &limit_samples) != SR_OK)) {
-                       printf("Failed to configure sample limit.\n");
+                       g_critical("Failed to configure sample limit.");
                        sr_session_destroy();
                        return;
                }
@@ -915,13 +961,13 @@ static void run_session(void)
 
        if (dev->driver->dev_config_set(dev->driver_index,
                  SR_HWCAP_PROBECONFIG, (char *)dev->probes) != SR_OK) {
-               printf("Failed to configure probes.\n");
+               g_critical("Failed to configure probes.");
                sr_session_destroy();
                return;
        }
 
        if (sr_session_start() != SR_OK) {
-               printf("Failed to start session.\n");
+               g_critical("Failed to start session.");
                sr_session_destroy();
                return;
        }
@@ -936,10 +982,9 @@ static void run_session(void)
 
        if (opt_output_file && default_output_format) {
                if (sr_session_save(opt_output_file) != SR_OK)
-                       printf("Failed to save session.\n");
+                       g_critical("Failed to save session.");
        }
        sr_session_destroy();
-
 }
 
 static void logger(const gchar *log_domain, GLogLevelFlags log_level,
@@ -953,15 +998,10 @@ static void logger(const gchar *log_domain, GLogLevelFlags log_level,
         * All messages, warnings, errors etc. go to stderr (not stdout) in
         * order to not mess up the CLI tool data output, e.g. VCD output.
         */
-       if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_WARNING)) {
+       if (log_level & (G_LOG_LEVEL_ERROR | G_LOG_LEVEL_CRITICAL | G_LOG_LEVEL_WARNING)
+                       || opt_loglevel > SR_LOG_WARN) {
                fprintf(stderr, "%s\n", message);
                fflush(stderr);
-       } else {
-               if ((log_level & G_LOG_LEVEL_MESSAGE && debug == 1)
-                   || debug == 2) {
-                       printf("%s\n", message);
-                       fflush(stderr);
-               }
        }
 }
 
@@ -978,29 +1018,25 @@ int main(int argc, char **argv)
        char *fmtspec, **pds;
 
        g_log_set_default_handler(logger, NULL);
-       if (getenv("SIGROK_DEBUG"))
-               debug = strtol(getenv("SIGROK_DEBUG"), NULL, 10);
 
        error = NULL;
        context = g_option_context_new(NULL);
        g_option_context_add_main_entries(context, optargs, NULL);
 
        if (!g_option_context_parse(context, &argc, &argv, &error)) {
-               g_warning("%s", error->message);
+               g_critical("%s", error->message);
                return 1;
        }
 
        /* Set the loglevel (amount of messages to output) for libsigrok. */
        if (sr_log_loglevel_set(opt_loglevel) != SR_OK) {
-               fprintf(stderr, "cli: %s: sr_log_loglevel_set(%d) failed\n",
-                       __func__, opt_loglevel);
+               g_critical("sr_log_loglevel_set(%d) failed.", opt_loglevel);
                return 1;
        }
 
        /* Set the loglevel (amount of messages to output) for libsigrokdecode. */
        if (srd_log_loglevel_set(opt_loglevel) != SRD_OK) {
-               fprintf(stderr, "cli: %s: srd_log_loglevel_set(%d) failed\n",
-                       __func__, opt_loglevel);
+               g_critical("srd_log_loglevel_set(%d) failed.", opt_loglevel);
                return 1;
        }
 
@@ -1009,60 +1045,68 @@ int main(int argc, char **argv)
 
        if (opt_pds) {
                if (srd_init(NULL) != SRD_OK) {
-                       printf("Failed to initialize sigrokdecode\n");
+                       g_critical("Failed to initialize sigrokdecode.");
                        return 1;
                }
                if (register_pds(NULL, opt_pds) != 0) {
-                       printf("Failed to register protocol decoders\n");
+                       g_critical("Failed to register protocol decoders.");
                        return 1;
                }
-               if (srd_register_callback(SRD_OUTPUT_ANN,
+               if (srd_pd_output_callback_add(SRD_OUTPUT_ANN,
                                show_pd_annotation, NULL) != SRD_OK) {
-                       printf("Failed to register protocol decoder callback\n");
+                       g_critical("Failed to register protocol decoder callback.");
                        return 1;
                }
-       }
 
-       if (opt_pd_stack) {
-               pds = g_strsplit(opt_pd_stack, ",", 0);
-               if (g_strv_length(pds) < 2) {
-                       printf("Specify at least two protocol decoders to stack.\n");
-                       return 1;
-               }
+               pds = g_strsplit(opt_pds, ",", 0);
+               if (g_strv_length(pds) > 1) {
+                       if (opt_pd_stack) {
+                               /* A stack setup was specified, use that. */
+                               g_strfreev(pds);
+                               pds = g_strsplit(opt_pd_stack, ",", 0);
+                               if (g_strv_length(pds) < 2) {
+                                       g_strfreev(pds);
+                                       g_critical("Specify at least two protocol decoders to stack.");
+                                       return 1;
+                               }
+                       }
 
-               if (!(di_from = srd_inst_find_by_id(pds[0]))) {
-                       printf("Cannot stack protocol decoder '%s': instance not found.\n", pds[0]);
-                       return 1;
-               }
-               for (i = 1; pds[i]; i++) {
-                       if (!(di_to = srd_inst_find_by_id(pds[i]))) {
-                               printf("Cannot stack protocol decoder '%s': instance not found.\n", pds[i]);
+                       if (!(di_from = srd_inst_find_by_id(pds[0]))) {
+                               g_critical("Cannot stack protocol decoder '%s': "
+                                               "instance not found.", pds[0]);
                                return 1;
                        }
-                       if ((ret = srd_inst_stack(di_from, di_to) != SRD_OK))
-                               return ret;
+                       for (i = 1; pds[i]; i++) {
+                               if (!(di_to = srd_inst_find_by_id(pds[i]))) {
+                                       g_critical("Cannot stack protocol decoder '%s': "
+                                                       "instance not found.", pds[i]);
+                                       return 1;
+                               }
+                               if ((ret = srd_inst_stack(di_from, di_to)) != SRD_OK)
+                                       return ret;
 
-                       /* Don't show annotation from this PD. Only the last PD in
-                        * the stack will be left on the annotation list.
-                        */
-                       g_datalist_remove_data(&pd_ann_visible, di_from->inst_id);
+                               /* Don't show annotation from this PD. Only the last PD in
+                                * the stack will be left on the annotation list.
+                                */
+                               g_datalist_remove_data(&pd_ann_visible, di_from->inst_id);
 
-                       di_from = di_to;
+                               di_from = di_to;
+                       }
                }
                g_strfreev(pds);
        }
 
-       if (!opt_format) {
-               opt_format = DEFAULT_OUTPUT_FORMAT;
+       if (!opt_output_format) {
+               opt_output_format = DEFAULT_OUTPUT_FORMAT;
                /* we'll need to remember this so when saving to a file
                 * later, sigrok session format will be used.
                 */
                default_output_format = TRUE;
        }
-       fmtargs = parse_generic_arg(opt_format);
+       fmtargs = parse_generic_arg(opt_output_format);
        fmtspec = g_hash_table_lookup(fmtargs, "sigrok_key");
        if (!fmtspec) {
-               printf("Invalid output format.\n");
+               g_critical("Invalid output format.");
                return 1;
        }
        outputs = sr_output_list();
@@ -1081,7 +1125,7 @@ int main(int argc, char **argv)
                break;
        }
        if (!output_format) {
-               printf("invalid output format %s\n", opt_format);
+               g_critical("Invalid output format %s.", opt_output_format);
                return 1;
        }