broadband-modem-qmi: use version from the client to know supported commands

Instead of always trying to use the newest commands and falling back to the
deprecated one when found that it is not supported, use the service version
given by the client to determine which is the best command to use.

Still, sometimes we need to handle ourselves the fallback to the deprecated
command, when we don't exactly know in which service version the new behaviour
was added (e.g. the 'Mode Preference' TLV in 'Get/Set System Selection
Preference' was last updated in NAS 1.16, but we don't exactly know when it
was added).

src/mm-broadband-modem-qmi.c

@@ -49,22 +49,7 @@ struct _MMBroadbandModemQmiPrivate {
     gchar *esn;
 
     /* Allowed mode related */
-    gboolean has_system_selection_preference;
     gboolean has_mode_preference_in_system_selection_preference;
-    gboolean has_technology_preference;
-
-    /* Signal quality related.
-     * We assume that the presence of all these items can be controlled by the
-     * same flag:
-     *  - 'Get Signal Info'
-     *  - 'Config Signal Info'
-     *  - 'Signal Info' indications
-     *  - 'Signal Info' TLV in 'Register Indications'
-     */
-    gboolean has_signal_info;
-
-    /* Common */
-    gboolean has_register_indications;
 
     /* 3GPP and CDMA share unsolicited events setup/enable/disable/cleanup */
     gboolean unsolicited_events_enabled;
@@ -1212,8 +1197,6 @@ load_signal_quality_finish (MMIfaceModem *self,
                                  G_SIMPLE_ASYNC_RESULT (res)));
 }
 
-static void load_signal_quality_context_step (LoadSignalQualityContext *ctx);
-
 static gint8
 signal_info_get_quality (MMBroadbandModemQmi *self,
                          QmiMessageNasGetSignalInfoOutput *output)
@@ -1268,16 +1251,6 @@ get_signal_info_ready (QmiClientNas *client,
 
     output = qmi_client_nas_get_signal_info_finish (client, res, &error);
     if (!output) {
-        /* If the command is not supported, fallback to the deprecated one */
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED)) {
-            g_error_free (error);
-            ctx->self->priv->has_signal_info = FALSE;
-            load_signal_quality_context_step (ctx);
-            return;
-        }
-
         g_simple_async_result_take_error (ctx->result, error);
         load_signal_quality_context_complete_and_free (ctx);
         return;
@@ -1377,28 +1350,6 @@ get_signal_strength_ready (QmiClientNas *client,
     load_signal_quality_context_complete_and_free (ctx);
 }
 
-static void
-load_signal_quality_context_step (LoadSignalQualityContext *ctx)
-{
-    if (ctx->self->priv->has_signal_info) {
-        qmi_client_nas_get_signal_info (QMI_CLIENT_NAS (ctx->client),
-                                        NULL,
-                                        10,
-                                        NULL,
-                                        (GAsyncReadyCallback)get_signal_info_ready,
-                                        ctx);
-        return;
-    }
-
-    /* Fallback to the deprecated mode if the new one not supported */
-    qmi_client_nas_get_signal_strength (QMI_CLIENT_NAS (ctx->client),
-                                        NULL,
-                                        10,
-                                        NULL,
-                                        (GAsyncReadyCallback)get_signal_strength_ready,
-                                        ctx);
-}
-
 static void
 load_signal_quality (MMIfaceModem *self,
                      GAsyncReadyCallback callback,
@@ -1421,7 +1372,22 @@ load_signal_quality (MMIfaceModem *self,
                                              load_signal_quality);
 
     mm_dbg ("loading signal quality...");
-    load_signal_quality_context_step (ctx);
+
+    /* Signal info introduced in NAS 1.8 */
+    if (qmi_client_check_version (ctx->client, 1, 8))
+        qmi_client_nas_get_signal_info (QMI_CLIENT_NAS (ctx->client),
+                                        NULL,
+                                        10,
+                                        NULL,
+                                        (GAsyncReadyCallback)get_signal_info_ready,
+                                        ctx);
+    else
+        qmi_client_nas_get_signal_strength (QMI_CLIENT_NAS (ctx->client),
+                                            NULL,
+                                            10,
+                                            NULL,
+                                            (GAsyncReadyCallback)get_signal_strength_ready,
+                                            ctx);
 }
 
 /*****************************************************************************/
@@ -1719,10 +1685,6 @@ get_technology_preference_ready (QmiClientNas *client,
 
     output = qmi_client_nas_get_technology_preference_finish (client, res, &error);
     if (!output) {
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED))
-            ctx->self->priv->has_technology_preference = FALSE;
         mm_dbg ("QMI operation failed: %s", error->message);
         g_error_free (error);
     } else if (!qmi_message_nas_get_technology_preference_output_get_result (output, &error)) {
@@ -1824,10 +1786,6 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
 
     output = qmi_client_nas_get_system_selection_preference_finish (client, res, &error);
     if (!output) {
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED))
-            ctx->self->priv->has_system_selection_preference = FALSE;
         mm_dbg ("QMI operation failed: %s", error->message);
         g_error_free (error);
     } else if (!qmi_message_nas_get_system_selection_preference_output_get_result (output, &error)) {
@@ -1940,10 +1898,15 @@ load_allowed_modes (MMIfaceModem *self,
                                              callback,
                                              user_data,
                                              load_allowed_modes);
+
+    /* System selection preference introduced in NAS 1.1
+     * TODO: Not sure when the System Selection Preference got the
+     * 'Mode Preference' TLV, so we'll need to handle the fallback. */
     ctx->run_get_system_selection_preference =
-        (ctx->self->priv->has_system_selection_preference &&
+        (qmi_client_check_version (client, 1, 1) &&
          ctx->self->priv->has_mode_preference_in_system_selection_preference);
-    ctx->run_get_technology_preference = ctx->self->priv->has_technology_preference;
+    /* Technology preference introduced in NAS 1.7 */
+    ctx->run_get_technology_preference = qmi_client_check_version (client, 1, 7);
 
     load_allowed_modes_context_step (ctx);
 }
@@ -1991,10 +1954,6 @@ set_technology_preference_ready (QmiClientNas *client,
 
     output = qmi_client_nas_set_technology_preference_finish (client, res, &error);
     if (!output) {
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED))
-            ctx->self->priv->has_technology_preference = FALSE;
         mm_dbg ("QMI operation failed: %s", error->message);
         g_error_free (error);
     } else if (!qmi_message_nas_set_technology_preference_output_get_result (output, &error)) {
@@ -2022,10 +1981,6 @@ allowed_modes_set_system_selection_preference_ready (QmiClientNas *client,
 
     output = qmi_client_nas_set_system_selection_preference_finish (client, res, &error);
     if (!output) {
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED))
-            ctx->self->priv->has_system_selection_preference = FALSE;
         mm_dbg ("QMI operation failed: %s", error->message);
         g_error_free (error);
     } else if (!qmi_message_nas_set_system_selection_preference_output_get_result (output, &error)) {
@@ -2250,10 +2205,14 @@ set_allowed_modes (MMIfaceModem *self,
                                              set_allowed_modes);
     ctx->allowed = allowed;
     ctx->preferred = preferred;
+    /* System selection preference introduced in NAS 1.1
+     * TODO: Not sure when the System Selection Preference got the
+     * 'Mode Preference' TLV, so we'll need to handle the fallback. */
     ctx->run_set_system_selection_preference =
-        (ctx->self->priv->has_system_selection_preference &&
+        (qmi_client_check_version (client, 1, 1) &&
          ctx->self->priv->has_mode_preference_in_system_selection_preference);
-    ctx->run_set_technology_preference = ctx->self->priv->has_technology_preference;
+    /* Technology preference introduced in NAS 1.7 */
+    ctx->run_set_technology_preference = qmi_client_check_version (client, 1, 7);
 
     set_allowed_modes_context_step (ctx);
 }
@@ -2766,22 +2725,21 @@ modem_cdma_load_esn (MMIfaceModemCdma *_self,
 }
 
 /*****************************************************************************/
-/* Enabling/disabling unsolicited events (3GPP and CDMA interface) */
+/* Enabling/disabling unsolicited events (3GPP and CDMA interface)
-
+ *
-typedef enum {
+ * If NAS >= 1.8:
-    ENABLE_UNSOLICITED_EVENTS_STEP_FIRST = 0,
+ *   - Config Signal Info (only when enabling)
-    ENABLE_UNSOLICITED_EVENTS_STEP_CONFIG_SIGNAL_INFO,
+ *   - Register Indications with Signal Info
-    ENABLE_UNSOLICITED_EVENTS_STEP_RI_SIGNAL_QUALITY,
+ *
-    ENABLE_UNSOLICITED_EVENTS_STEP_SER_SIGNAL_QUALITY,
+ * If NAS < 1.8:
-    ENABLE_UNSOLICITED_EVENTS_STEP_LAST
+ *   - Set Event Report with Signal Strength
-} EnableUnsolicitedEventsStep;
+ */
 
 typedef struct {
     MMBroadbandModemQmi *self;
-    gboolean enable;
     GSimpleAsyncResult *result;
     QmiClientNas *client;
-    EnableUnsolicitedEventsStep step;
+    gboolean enable;
 } EnableUnsolicitedEventsContext;
 
 static void
@@ -2802,12 +2760,10 @@ common_enable_disable_unsolicited_events_finish (MMBroadbandModemQmi *self,
     return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
 }
 
-static void enable_unsolicited_events_context_step (EnableUnsolicitedEventsContext *ctx);
-
 static void
-ser_signal_quality_ready (QmiClientNas *client,
+ser_signal_strength_ready (QmiClientNas *client,
-                          GAsyncResult *res,
+                           GAsyncResult *res,
-                          EnableUnsolicitedEventsContext *ctx)
+                           EnableUnsolicitedEventsContext *ctx)
 {
     QmiMessageNasSetEventReportOutput *output = NULL;
     GError *error = NULL;
@@ -2824,48 +2780,87 @@ ser_signal_quality_ready (QmiClientNas *client,
     if (output)
         qmi_message_nas_set_event_report_output_unref (output);
 
-    /* Keep on */
+    /* Just ignore errors for now */
-    ctx->step++;
+    ctx->self->priv->unsolicited_events_enabled = ctx->enable;
-    enable_unsolicited_events_context_step (ctx);
+    g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    enable_unsolicited_events_context_complete_and_free (ctx);
 }
 
 static void
-ri_signal_quality_ready (QmiClientNas *client,
+common_enable_disable_unsolicited_events_signal_strength (EnableUnsolicitedEventsContext *ctx)
-                         GAsyncResult *res,
+{
-                         EnableUnsolicitedEventsContext *ctx)
+    /* The device doesn't really like to have many threshold values, so don't
+     * grow this array without checking first */
+    static const gint8 thresholds_data[] = { -80, -40, 0, 40, 80 };
+    QmiMessageNasSetEventReportInput *input;
+    GArray *thresholds;
+
+    input = qmi_message_nas_set_event_report_input_new ();
+
+    /* Prepare thresholds, separated 20 each */
+    thresholds = g_array_sized_new (FALSE, FALSE, sizeof (gint8), G_N_ELEMENTS (thresholds_data));
+
+    /* Only set thresholds during enable */
+    if (ctx->enable)
+        g_array_append_vals (thresholds, thresholds_data, G_N_ELEMENTS (thresholds_data));
+
+    qmi_message_nas_set_event_report_input_set_signal_strength_indicator (
+        input,
+        ctx->enable,
+        thresholds,
+        NULL);
+    g_array_unref (thresholds);
+    qmi_client_nas_set_event_report (
+        ctx->client,
+        input,
+        5,
+        NULL,
+        (GAsyncReadyCallback)ser_signal_strength_ready,
+        ctx);
+    qmi_message_nas_set_event_report_input_unref (input);
+}
+
+static void
+ri_signal_info_ready (QmiClientNas *client,
+                      GAsyncResult *res,
+                      EnableUnsolicitedEventsContext *ctx)
 {
     QmiMessageNasRegisterIndicationsOutput *output = NULL;
     GError *error = NULL;
 
     output = qmi_client_nas_register_indications_finish (client, res, &error);
     if (!output) {
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED))
-            ctx->self->priv->has_register_indications = FALSE;
-
         mm_dbg ("QMI operation failed: '%s'", error->message);
         g_error_free (error);
     } else if (!qmi_message_nas_register_indications_output_get_result (output, &error)) {
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED))
-            ctx->self->priv->has_signal_info = FALSE;
-
         mm_dbg ("Couldn't register indications: '%s'", error->message);
         g_error_free (error);
-        qmi_message_nas_register_indications_output_unref (output);
-    } else {
-        /* Signal quality related indications setup done, skip the deprecated step */
-        qmi_message_nas_register_indications_output_unref (output);
-        ctx->step = ENABLE_UNSOLICITED_EVENTS_STEP_SER_SIGNAL_QUALITY + 1;
-        enable_unsolicited_events_context_step (ctx);
-        return;
     }
 
-    /* Keep on */
+    if (output)
-    ctx->step++;
+        qmi_message_nas_register_indications_output_unref (output);
-    enable_unsolicited_events_context_step (ctx);
+
+    /* Just ignore errors for now */
+    ctx->self->priv->unsolicited_events_enabled = ctx->enable;
+    g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    enable_unsolicited_events_context_complete_and_free (ctx);
+}
+
+static void
+common_enable_disable_unsolicited_events_signal_info (EnableUnsolicitedEventsContext *ctx)
+{
+    QmiMessageNasRegisterIndicationsInput *input;
+
+    input = qmi_message_nas_register_indications_input_new ();
+    qmi_message_nas_register_indications_input_set_signal_info (input, ctx->enable, NULL);
+    qmi_client_nas_register_indications (
+        ctx->client,
+        input,
+        5,
+        NULL,
+        (GAsyncReadyCallback)ri_signal_info_ready,
+        ctx);
+    qmi_message_nas_register_indications_input_unref (input);
 }
 
 static void
@@ -2878,134 +2873,54 @@ config_signal_info_ready (QmiClientNas *client,
 
     output = qmi_client_nas_config_signal_info_finish (client, res, &error);
     if (!output) {
-        /* If config signal info is unsupported, completely skip trying to
-         * use Register Indications */
-        if (g_error_matches (error,
-                             QMI_CORE_ERROR,
-                             QMI_CORE_ERROR_UNSUPPORTED)) {
-            ctx->self->priv->has_signal_info = FALSE;
-            ctx->step = ENABLE_UNSOLICITED_EVENTS_STEP_SER_SIGNAL_QUALITY;
-        } else
-            ctx->step++;
-
         mm_dbg ("QMI operation failed: '%s'", error->message);
         g_error_free (error);
-        enable_unsolicited_events_context_step (ctx);
+    } else if (!qmi_message_nas_config_signal_info_output_get_result (output, &error)) {
-        return;
-    }
-
-    if (!qmi_message_nas_config_signal_info_output_get_result (output, &error)) {
         mm_dbg ("Couldn't config signal info: '%s'", error->message);
         g_error_free (error);
     }
 
-    qmi_message_nas_config_signal_info_output_unref (output);
+    if (output)
+        qmi_message_nas_config_signal_info_output_unref (output);
 
     /* Keep on */
-    ctx->step++;
+    common_enable_disable_unsolicited_events_signal_info (ctx);
-    enable_unsolicited_events_context_step (ctx);
 }
 
 static void
-enable_unsolicited_events_context_step (EnableUnsolicitedEventsContext *ctx)
+common_enable_disable_unsolicited_events_signal_info_config (EnableUnsolicitedEventsContext *ctx)
 {
-    switch (ctx->step) {
+    /* RSSI values go between -105 and -60 for 3GPP technologies,
-    case ENABLE_UNSOLICITED_EVENTS_STEP_FIRST:
+     * and from -105 to -90 in 3GPP2 technologies (approx). */
-        /* Fall down */
+    static const gint8 thresholds_data[] = { -100, -97, -95, -92, -90, -85, -80, -75, -70, -65 };
-        ctx->step++;
+    QmiMessageNasConfigSignalInfoInput *input;
+    GArray *thresholds;
 
-    case ENABLE_UNSOLICITED_EVENTS_STEP_CONFIG_SIGNAL_INFO:
+    /* Signal info config only to be run when enabling */
-        if (ctx->self->priv->has_signal_info &&
+    if (!ctx->enable) {
-            ctx->enable) {
+        common_enable_disable_unsolicited_events_signal_info (ctx);
-            /* RSSI values go between -105 and -60 for 3GPP technologies,
-             * and from -105 to -90 in 3GPP2 technologies (approx). */
-            static const gint8 thresholds_data[] = { -100, -97, -95, -92, -90, -85, -80, -75, -70, -65 };
-            QmiMessageNasConfigSignalInfoInput *input;
-            GArray *thresholds;
-
-            input = qmi_message_nas_config_signal_info_input_new ();
-
-            /* Prepare thresholds, separated 20 each */
-            thresholds = g_array_sized_new (FALSE, FALSE, sizeof (gint8), G_N_ELEMENTS (thresholds_data));
-            g_array_append_vals (thresholds, thresholds_data, G_N_ELEMENTS (thresholds_data));
-
-            qmi_message_nas_config_signal_info_input_set_rssi_threshold (
-                input,
-                thresholds,
-                NULL);
-            g_array_unref (thresholds);
-            qmi_client_nas_config_signal_info (
-                ctx->client,
-                input,
-                5,
-                NULL,
-                (GAsyncReadyCallback)config_signal_info_ready,
-                ctx);
-            qmi_message_nas_config_signal_info_input_unref (input);
-            return;
-        }
-        /* Fall down */
-        ctx->step++;
-
-    case ENABLE_UNSOLICITED_EVENTS_STEP_RI_SIGNAL_QUALITY:
-        if (ctx->self->priv->has_register_indications &&
-            ctx->self->priv->has_signal_info) {
-            QmiMessageNasRegisterIndicationsInput *input;
-
-            input = qmi_message_nas_register_indications_input_new ();
-            qmi_message_nas_register_indications_input_set_signal_strength (input, ctx->enable, NULL);
-            qmi_client_nas_register_indications (
-                ctx->client,
-                input,
-                5,
-                NULL,
-                (GAsyncReadyCallback)ri_signal_quality_ready,
-                ctx);
-            qmi_message_nas_register_indications_input_unref (input);
-            return;
-        }
-        /* Fall down */
-        ctx->step++;
-
-    case ENABLE_UNSOLICITED_EVENTS_STEP_SER_SIGNAL_QUALITY: {
-        /* The device doesn't really like to have many threshold values, so don't
-         * grow this array without checking first */
-        static const gint8 thresholds_data[] = { -80, -40, 0, 40, 80 };
-        QmiMessageNasSetEventReportInput *input;
-        GArray *thresholds;
-
-        input = qmi_message_nas_set_event_report_input_new ();
-
-        /* Prepare thresholds, separated 20 each */
-        thresholds = g_array_sized_new (FALSE, FALSE, sizeof (gint8), G_N_ELEMENTS (thresholds_data));
-
-        /* Only set thresholds during enable */
-        if (ctx->enable)
-            g_array_append_vals (thresholds, thresholds_data, G_N_ELEMENTS (thresholds_data));
-
-        qmi_message_nas_set_event_report_input_set_signal_strength_indicator (
-            input,
-            ctx->enable,
-            thresholds,
-            NULL);
-        g_array_unref (thresholds);
-        qmi_client_nas_set_event_report (
-            ctx->client,
-            input,
-            5,
-            NULL,
-            (GAsyncReadyCallback)ser_signal_quality_ready,
-            ctx);
-        qmi_message_nas_set_event_report_input_unref (input);
         return;
     }
 
-    case ENABLE_UNSOLICITED_EVENTS_STEP_LAST:
+    input = qmi_message_nas_config_signal_info_input_new ();
-        ctx->self->priv->unsolicited_events_enabled = ctx->enable;
+
-        g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+    /* Prepare thresholds, separated 20 each */
-        enable_unsolicited_events_context_complete_and_free (ctx);
+    thresholds = g_array_sized_new (FALSE, FALSE, sizeof (gint8), G_N_ELEMENTS (thresholds_data));
-        return;
+    g_array_append_vals (thresholds, thresholds_data, G_N_ELEMENTS (thresholds_data));
-    }
+
+    qmi_message_nas_config_signal_info_input_set_rssi_threshold (
+        input,
+        thresholds,
+        NULL);
+    g_array_unref (thresholds);
+    qmi_client_nas_config_signal_info (
+        ctx->client,
+        input,
+        5,
+        NULL,
+        (GAsyncReadyCallback)config_signal_info_ready,
+        ctx);
+    qmi_message_nas_config_signal_info_input_unref (input);
 }
 
 static void
@@ -3042,8 +2957,12 @@ common_enable_disable_unsolicited_events (MMBroadbandModemQmi *self,
     ctx->client = g_object_ref (client);
     ctx->enable = enable;
     ctx->result = result;
-    ctx->step = ENABLE_UNSOLICITED_EVENTS_STEP_FIRST;
+
-    enable_unsolicited_events_context_step (ctx);
+    /* Signal info introduced in NAS 1.8 */
+    if (qmi_client_check_version (client, 1, 8))
+        common_enable_disable_unsolicited_events_signal_info_config (ctx);
+    else
+        common_enable_disable_unsolicited_events_signal_strength (ctx);
 }
 
 /*****************************************************************************/
@@ -3243,18 +3162,21 @@ common_setup_cleanup_unsolicited_events (MMBroadbandModemQmi *self,
         self->priv->event_report_indication_id = 0;
     }
 
-    /* Connect/Disconnect "Signal Info" indications */
+    /* Connect/Disconnect "Signal Info" indications.
-    if (enable) {
+     * Signal info introduced in NAS 1.8 */
-        g_assert (self->priv->signal_info_indication_id == 0);
+    if (qmi_client_check_version (client, 1, 8)) {
-        self->priv->signal_info_indication_id =
+        if (enable) {
-            g_signal_connect (client,
+            g_assert (self->priv->signal_info_indication_id == 0);
-                              "signal-info",
+            self->priv->signal_info_indication_id =
-                              G_CALLBACK (signal_info_indication_cb),
+                g_signal_connect (client,
-                              self);
+                                  "signal-info",
-    } else {
+                                  G_CALLBACK (signal_info_indication_cb),
-        g_assert (self->priv->signal_info_indication_id != 0);
+                                  self);
-        g_signal_handler_disconnect (client, self->priv->signal_info_indication_id);
+        } else {
-        self->priv->signal_info_indication_id = 0;
+            g_assert (self->priv->signal_info_indication_id != 0);
+            g_signal_handler_disconnect (client, self->priv->signal_info_indication_id);
+            self->priv->signal_info_indication_id = 0;
+        }
     }
 
     g_simple_async_result_set_op_res_gboolean (result, TRUE);
@@ -3506,12 +3428,9 @@ mm_broadband_modem_qmi_init (MMBroadbandModemQmi *self)
                                               MM_TYPE_BROADBAND_MODEM_QMI,
                                               MMBroadbandModemQmiPrivate);
 
-    /* Always try to use the newest command available first */
+    /* Some initial defaults for when we need to gather info about
-    self->priv->has_signal_info = TRUE;
+     * supported commands/TLVs */
-    self->priv->has_system_selection_preference = TRUE;
     self->priv->has_mode_preference_in_system_selection_preference = TRUE;
-    self->priv->has_technology_preference = TRUE;
-    self->priv->has_register_indications = TRUE;
 }
 
 static void