aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/mm-broadband-modem-qmi.c102
-rw-r--r--src/mm-iface-modem-simple.c22
-rw-r--r--src/mm-iface-modem.c198
-rw-r--r--src/mm-iface-modem.h16
4 files changed, 192 insertions, 146 deletions
diff --git a/src/mm-broadband-modem-qmi.c b/src/mm-broadband-modem-qmi.c
index 853d940f..3e4ced73 100644
--- a/src/mm-broadband-modem-qmi.c
+++ b/src/mm-broadband-modem-qmi.c
@@ -2468,7 +2468,7 @@ modem_factory_reset (MMIfaceModem *self,
}
/*****************************************************************************/
-/* Load allowed modes (Modem interface) */
+/* Load current modes (Modem interface) */
typedef struct {
MMBroadbandModemQmi *self;
@@ -2476,15 +2476,15 @@ typedef struct {
GSimpleAsyncResult *result;
gboolean run_get_system_selection_preference;
gboolean run_get_technology_preference;
-} LoadAllowedModesContext;
+} LoadCurrentModesContext;
typedef struct {
MMModemMode allowed;
MMModemMode preferred;
-} LoadAllowedModesResult;
+} LoadCurrentModesResult;
static void
-load_allowed_modes_context_complete_and_free (LoadAllowedModesContext *ctx)
+load_current_modes_context_complete_and_free (LoadCurrentModesContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
@@ -2494,13 +2494,13 @@ load_allowed_modes_context_complete_and_free (LoadAllowedModesContext *ctx)
}
static gboolean
-load_allowed_modes_finish (MMIfaceModem *self,
+load_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
MMModemMode *allowed,
MMModemMode *preferred,
GError **error)
{
- LoadAllowedModesResult *result;
+ LoadCurrentModesResult *result;
if (g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error))
return FALSE;
@@ -2511,14 +2511,14 @@ load_allowed_modes_finish (MMIfaceModem *self,
return TRUE;
}
-static void load_allowed_modes_context_step (LoadAllowedModesContext *ctx);
+static void load_current_modes_context_step (LoadCurrentModesContext *ctx);
static void
get_technology_preference_ready (QmiClientNas *client,
GAsyncResult *res,
- LoadAllowedModesContext *ctx)
+ LoadCurrentModesContext *ctx)
{
- LoadAllowedModesResult *result = NULL;
+ LoadCurrentModesResult *result = NULL;
QmiMessageNasGetTechnologyPreferenceOutput *output = NULL;
GError *error = NULL;
@@ -2547,7 +2547,7 @@ get_technology_preference_ready (QmiClientNas *client,
g_free (str);
} else {
/* We got a valid value from here */
- result = g_new (LoadAllowedModesResult, 1);
+ result = g_new (LoadCurrentModesResult, 1);
result->allowed = allowed;
result->preferred = MM_MODEM_MODE_NONE;
}
@@ -2558,7 +2558,7 @@ get_technology_preference_ready (QmiClientNas *client,
if (!result) {
ctx->run_get_technology_preference = FALSE;
- load_allowed_modes_context_step (ctx);
+ load_current_modes_context_step (ctx);
return;
}
@@ -2566,15 +2566,15 @@ get_technology_preference_ready (QmiClientNas *client,
ctx->result,
result,
(GDestroyNotify)g_free);
- load_allowed_modes_context_complete_and_free (ctx);
+ load_current_modes_context_complete_and_free (ctx);
}
static void
-allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
+current_modes_get_system_selection_preference_ready (QmiClientNas *client,
GAsyncResult *res,
- LoadAllowedModesContext *ctx)
+ LoadCurrentModesContext *ctx)
{
- LoadAllowedModesResult *result = NULL;
+ LoadCurrentModesResult *result = NULL;
QmiMessageNasGetSystemSelectionPreferenceOutput *output = NULL;
GError *error = NULL;
QmiNasRatModePreference mode_preference_mask = 0;
@@ -2605,7 +2605,7 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
QmiNasGsmWcdmaAcquisitionOrderPreference gsm_or_wcdma;
/* We got a valid value from here */
- result = g_new (LoadAllowedModesResult, 1);
+ result = g_new (LoadCurrentModesResult, 1);
result->allowed = allowed;
result->preferred = MM_MODEM_MODE_NONE;
@@ -2626,7 +2626,7 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
if (!result) {
/* Try with the deprecated command */
ctx->run_get_system_selection_preference = FALSE;
- load_allowed_modes_context_step (ctx);
+ load_current_modes_context_step (ctx);
return;
}
@@ -2634,11 +2634,11 @@ allowed_modes_get_system_selection_preference_ready (QmiClientNas *client,
ctx->result,
result,
(GDestroyNotify)g_free);
- load_allowed_modes_context_complete_and_free (ctx);
+ load_current_modes_context_complete_and_free (ctx);
}
static void
-load_allowed_modes_context_step (LoadAllowedModesContext *ctx)
+load_current_modes_context_step (LoadCurrentModesContext *ctx)
{
if (ctx->run_get_system_selection_preference) {
qmi_client_nas_get_system_selection_preference (
@@ -2646,7 +2646,7 @@ load_allowed_modes_context_step (LoadAllowedModesContext *ctx)
NULL, /* no input */
5,
NULL, /* cancellable */
- (GAsyncReadyCallback)allowed_modes_get_system_selection_preference_ready,
+ (GAsyncReadyCallback)current_modes_get_system_selection_preference_ready,
ctx);
return;
}
@@ -2666,16 +2666,16 @@ load_allowed_modes_context_step (LoadAllowedModesContext *ctx)
ctx->result,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
- "Loading allowed modes is not supported by this device");
- load_allowed_modes_context_complete_and_free (ctx);
+ "Loading current modes is not supported by this device");
+ load_current_modes_context_complete_and_free (ctx);
}
static void
-load_allowed_modes (MMIfaceModem *self,
+load_current_modes (MMIfaceModem *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
- LoadAllowedModesContext *ctx;
+ LoadCurrentModesContext *ctx;
QmiClient *client = NULL;
if (!ensure_qmi_client (MM_BROADBAND_MODEM_QMI (self),
@@ -2683,13 +2683,13 @@ load_allowed_modes (MMIfaceModem *self,
callback, user_data))
return;
- ctx = g_new0 (LoadAllowedModesContext, 1);
+ ctx = g_new0 (LoadCurrentModesContext, 1);
ctx->self = g_object_ref (self);
ctx->client = g_object_ref (client);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
- load_allowed_modes);
+ load_current_modes);
/* System selection preference introduced in NAS 1.1 */
ctx->run_get_system_selection_preference = qmi_client_check_version (client, 1, 1);
@@ -2697,7 +2697,7 @@ load_allowed_modes (MMIfaceModem *self,
/* Technology preference introduced in NAS 1.0, so always available */
ctx->run_get_technology_preference = TRUE;
- load_allowed_modes_context_step (ctx);
+ load_current_modes_context_step (ctx);
}
/*****************************************************************************/
@@ -2711,10 +2711,10 @@ typedef struct {
MMModemMode preferred;
gboolean run_set_system_selection_preference;
gboolean run_set_technology_preference;
-} SetAllowedModesContext;
+} SetCurrentModesContext;
static void
-set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
+set_current_modes_context_complete_and_free (SetCurrentModesContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
@@ -2724,19 +2724,19 @@ set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
}
static gboolean
-set_allowed_modes_finish (MMIfaceModem *self,
+set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
GError **error)
{
return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (res), error);
}
-static void set_allowed_modes_context_step (SetAllowedModesContext *ctx);
+static void set_current_modes_context_step (SetCurrentModesContext *ctx);
static void
set_technology_preference_ready (QmiClientNas *client,
GAsyncResult *res,
- SetAllowedModesContext *ctx)
+ SetCurrentModesContext *ctx)
{
QmiMessageNasSetTechnologyPreferenceOutput *output = NULL;
GError *error = NULL;
@@ -2756,19 +2756,19 @@ set_technology_preference_ready (QmiClientNas *client,
if (error)
g_error_free (error);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
qmi_message_nas_set_technology_preference_output_unref (output);
return;
}
ctx->run_set_technology_preference = FALSE;
- set_allowed_modes_context_step (ctx);
+ set_current_modes_context_step (ctx);
}
static void
allowed_modes_set_system_selection_preference_ready (QmiClientNas *client,
GAsyncResult *res,
- SetAllowedModesContext *ctx)
+ SetCurrentModesContext *ctx)
{
QmiMessageNasSetSystemSelectionPreferenceOutput *output = NULL;
GError *error = NULL;
@@ -2784,18 +2784,18 @@ allowed_modes_set_system_selection_preference_ready (QmiClientNas *client,
} else {
/* Good! TODO: do we really need to wait for the indication? */
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
qmi_message_nas_set_system_selection_preference_output_unref (output);
return;
}
/* Try with the deprecated command */
ctx->run_set_system_selection_preference = FALSE;
- set_allowed_modes_context_step (ctx);
+ set_current_modes_context_step (ctx);
}
static void
-set_allowed_modes_context_step (SetAllowedModesContext *ctx)
+set_current_modes_context_step (SetCurrentModesContext *ctx)
{
if (ctx->run_set_system_selection_preference) {
QmiMessageNasSetSystemSelectionPreferenceInput *input;
@@ -2814,7 +2814,7 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
"Unhandled allowed mode setting: '%s'",
str);
g_free (str);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2853,7 +2853,7 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Cannot set specific preferred mode");
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2869,7 +2869,7 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
"Unhandled allowed mode setting: '%s'",
str);
g_free (str);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2892,17 +2892,17 @@ set_allowed_modes_context_step (SetAllowedModesContext *ctx)
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Setting allowed modes is not supported by this device");
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
}
static void
-set_allowed_modes (MMIfaceModem *self,
+set_current_modes (MMIfaceModem *self,
MMModemMode allowed,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data)
{
- SetAllowedModesContext *ctx;
+ SetCurrentModesContext *ctx;
QmiClient *client = NULL;
if (!ensure_qmi_client (MM_BROADBAND_MODEM_QMI (self),
@@ -2910,13 +2910,13 @@ set_allowed_modes (MMIfaceModem *self,
callback, user_data))
return;
- ctx = g_new0 (SetAllowedModesContext, 1);
+ ctx = g_new0 (SetCurrentModesContext, 1);
ctx->self = g_object_ref (self);
ctx->client = g_object_ref (client);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
- set_allowed_modes);
+ set_current_modes);
if (allowed == MM_MODEM_MODE_ANY && ctx->preferred == MM_MODEM_MODE_NONE) {
ctx->allowed = (MM_MODEM_MODE_2G | MM_MODEM_MODE_3G);
@@ -2934,7 +2934,7 @@ set_allowed_modes (MMIfaceModem *self,
/* Technology preference introduced in NAS 1.0, so always available */
ctx->run_set_technology_preference = TRUE;
- set_allowed_modes_context_step (ctx);
+ set_current_modes_context_step (ctx);
}
/*****************************************************************************/
@@ -8222,10 +8222,10 @@ iface_modem_init (MMIfaceModem *iface)
iface->load_supported_charsets_finish = NULL;
iface->setup_charset = NULL;
iface->setup_charset_finish = NULL;
- iface->load_allowed_modes = load_allowed_modes;
- iface->load_allowed_modes_finish = load_allowed_modes_finish;
- iface->set_allowed_modes = set_allowed_modes;
- iface->set_allowed_modes_finish = set_allowed_modes_finish;
+ iface->load_current_modes = load_current_modes;
+ iface->load_current_modes_finish = load_current_modes_finish;
+ iface->set_current_modes = set_current_modes;
+ iface->set_current_modes_finish = set_current_modes_finish;
iface->load_signal_quality = load_signal_quality;
iface->load_signal_quality_finish = load_signal_quality_finish;
iface->load_current_bands = modem_load_current_bands;
diff --git a/src/mm-iface-modem-simple.c b/src/mm-iface-modem-simple.c
index 0ab46567..5d1e1b21 100644
--- a/src/mm-iface-modem-simple.c
+++ b/src/mm-iface-modem-simple.c
@@ -174,7 +174,7 @@ typedef enum {
CONNECTION_STEP_WAIT_FOR_INITIALIZED,
CONNECTION_STEP_ENABLE,
CONNECTION_STEP_WAIT_FOR_ENABLED,
- CONNECTION_STEP_ALLOWED_MODES,
+ CONNECTION_STEP_CURRENT_MODES,
CONNECTION_STEP_CURRENT_BANDS,
CONNECTION_STEP_REGISTER,
CONNECTION_STEP_BEARER,
@@ -275,7 +275,7 @@ register_in_3gpp_or_cdma_network_ready (MMIfaceModemSimple *self,
}
static gboolean
-after_set_allowed_modes_timeout_cb (ConnectionContext *ctx)
+after_set_current_modes_timeout_cb (ConnectionContext *ctx)
{
/* Allowed modes set... almost there! */
ctx->step++;
@@ -284,13 +284,13 @@ after_set_allowed_modes_timeout_cb (ConnectionContext *ctx)
}
static void
-set_allowed_modes_ready (MMBaseModem *self,
+set_current_modes_ready (MMBaseModem *self,
GAsyncResult *res,
ConnectionContext *ctx)
{
GError *error = NULL;
- if (!mm_iface_modem_set_allowed_modes_finish (MM_IFACE_MODEM (self), res, &error)) {
+ if (!mm_iface_modem_set_current_modes_finish (MM_IFACE_MODEM (self), res, &error)) {
if (g_error_matches (error,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED)) {
@@ -309,7 +309,7 @@ set_allowed_modes_ready (MMBaseModem *self,
* a couple of seconds to settle down. This sleep time just makes sure that
* the modem has enough time to report being unregistered. */
mm_dbg ("Will wait to settle down after updating allowed modes");
- g_timeout_add_seconds (2, (GSourceFunc)after_set_allowed_modes_timeout_cb, ctx);
+ g_timeout_add_seconds (2, (GSourceFunc)after_set_current_modes_timeout_cb, ctx);
}
static gboolean
@@ -556,21 +556,21 @@ connection_step (ConnectionContext *ctx)
ctx);
return;
- case CONNECTION_STEP_ALLOWED_MODES: {
+ case CONNECTION_STEP_CURRENT_MODES: {
MMModemMode allowed_modes = MM_MODEM_MODE_ANY;
MMModemMode preferred_mode = MM_MODEM_MODE_NONE;
- mm_info ("Simple connect state (%d/%d): Allowed mode",
+ mm_info ("Simple connect state (%d/%d): Current modes",
ctx->step, CONNECTION_STEP_LAST);
/* Don't set modes unless explicitly requested to do so */
- if (mm_simple_connect_properties_get_allowed_modes (ctx->properties,
+ if (mm_simple_connect_properties_get_current_modes (ctx->properties,
&allowed_modes,
&preferred_mode)) {
- mm_iface_modem_set_allowed_modes (MM_IFACE_MODEM (ctx->self),
+ mm_iface_modem_set_current_modes (MM_IFACE_MODEM (ctx->self),
allowed_modes,
preferred_mode,
- (GAsyncReadyCallback)set_allowed_modes_ready,
+ (GAsyncReadyCallback)set_current_modes_ready,
ctx);
return;
}
@@ -790,7 +790,7 @@ connect_auth_ready (MMBaseModem *self,
mm_dbg (" PIN: %s", VALIDATE_UNSPECIFIED (mm_simple_connect_properties_get_pin (ctx->properties)));
- if (mm_simple_connect_properties_get_allowed_modes (ctx->properties, &allowed, &preferred)) {
+ if (mm_simple_connect_properties_get_current_modes (ctx->properties, &allowed, &preferred)) {
str = mm_modem_mode_build_string_from_mask (allowed);
mm_dbg (" Allowed mode: %s", str);
g_free (str);
diff --git a/src/mm-iface-modem.c b/src/mm-iface-modem.c
index 135f18f0..59be9e67 100644
--- a/src/mm-iface-modem.c
+++ b/src/mm-iface-modem.c
@@ -2124,7 +2124,7 @@ handle_set_current_bands (MmGdbusModem *skeleton,
}
/*****************************************************************************/
-/* ALLOWED MODES */
+/* Set current modes */
typedef struct {
MMIfaceModem *self;
@@ -2132,10 +2132,10 @@ typedef struct {
GSimpleAsyncResult *result;
MMModemMode allowed;
MMModemMode preferred;
-} SetAllowedModesContext;
+} SetCurrentModesContext;
static void
-set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
+set_current_modes_context_complete_and_free (SetCurrentModesContext *ctx)
{
g_simple_async_result_complete_in_idle (ctx->result);
g_object_unref (ctx->result);
@@ -2146,7 +2146,7 @@ set_allowed_modes_context_complete_and_free (SetAllowedModesContext *ctx)
}
gboolean
-mm_iface_modem_set_allowed_modes_finish (MMIfaceModem *self,
+mm_iface_modem_set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
GError **error)
{
@@ -2154,39 +2154,87 @@ mm_iface_modem_set_allowed_modes_finish (MMIfaceModem *self,
}
static void
-set_allowed_modes_ready (MMIfaceModem *self,
+after_set_load_current_modes_ready (MMIfaceModem *self,
+ GAsyncResult *res,
+ SetCurrentModesContext *ctx)
+{
+ MMModemMode allowed = MM_MODEM_MODE_NONE;
+ MMModemMode preferred = MM_MODEM_MODE_NONE;
+ GError *error = NULL;
+
+ if (!MM_IFACE_MODEM_GET_INTERFACE (self)->load_current_modes_finish (self,
+ res,
+ &allowed,
+ &preferred,
+ &error)) {
+ /* Errors when getting allowed/preferred won't be critical */
+ mm_warn ("couldn't load current allowed/preferred modes: '%s'", error->message);
+ g_error_free (error);
+
+ /* If errors getting allowed modes, default to the ones we asked for */
+ mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", ctx->allowed, ctx->preferred));
+ } else
+ mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", allowed, preferred));
+
+ /* Done */
+ set_current_modes_context_complete_and_free (ctx);
+}
+
+static void
+set_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
- SetAllowedModesContext *ctx)
+ SetCurrentModesContext *ctx)
{
+ MMModemState modem_state;
GError *error = NULL;
- if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes_finish (self, res, &error))
+ if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes_finish (self, res, &error)) {
g_simple_async_result_take_error (ctx->result, error);
- else {
- mm_gdbus_modem_set_allowed_modes (ctx->skeleton, ctx->allowed);
- mm_gdbus_modem_set_preferred_mode (ctx->skeleton, ctx->preferred);
- g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+ set_current_modes_context_complete_and_free (ctx);
+ return;
}
- set_allowed_modes_context_complete_and_free (ctx);
+ /* If modem is not enabled, avoid updating the current modes */
+ modem_state = MM_MODEM_STATE_UNKNOWN;
+ g_object_get (ctx->self,
+ MM_IFACE_MODEM_STATE, &modem_state,
+ NULL);
+ if (modem_state >= MM_MODEM_STATE_ENABLING) {
+ if (MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes &&
+ MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes_finish) {
+ MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes (
+ ctx->self,
+ (GAsyncReadyCallback)after_set_load_current_modes_ready,
+ ctx);
+ return;
+ }
+
+ mm_gdbus_modem_set_current_modes (ctx->skeleton,
+ g_variant_new ("(uu)",
+ ctx->allowed,
+ ctx->preferred));
+ }
+
+ g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
+ set_current_modes_context_complete_and_free (ctx);
}
void
-mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
+mm_iface_modem_set_current_modes (MMIfaceModem *self,
MMModemMode allowed,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data)
{
GArray *supported;
- SetAllowedModesContext *ctx;
- MMModemMode current_allowed;
- MMModemMode current_preferred;
+ SetCurrentModesContext *ctx;
+ MMModemMode current_allowed = MM_MODEM_MODE_ANY;
+ MMModemMode current_preferred = MM_MODEM_MODE_NONE;
guint i;
/* If setting allowed modes is not implemented, report an error */
- if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes ||
- !MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes_finish) {
+ if (!MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes ||
+ !MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes_finish) {
g_simple_async_report_error_in_idle (G_OBJECT (self),
callback,
user_data,
@@ -2197,12 +2245,12 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
}
/* Setup context */
- ctx = g_new0 (SetAllowedModesContext, 1);
+ ctx = g_new0 (SetCurrentModesContext, 1);
ctx->self = g_object_ref (self);
ctx->result = g_simple_async_result_new (G_OBJECT (self),
callback,
user_data,
- mm_iface_modem_set_allowed_modes);
+ mm_iface_modem_set_current_modes);
ctx->allowed = allowed;
ctx->preferred = preferred;
g_object_get (self,
@@ -2213,7 +2261,7 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get interface skeleton");
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2228,7 +2276,7 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot change modes: only one combination supported");
g_array_unref (supported);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2257,7 +2305,7 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
MM_CORE_ERROR_UNSUPPORTED,
"The given combination of allowed and preferred modes is not supported");
g_array_unref (supported);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
}
@@ -2265,12 +2313,14 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
g_array_unref (supported);
/* Check if we already are in the requested setup */
- current_allowed = mm_gdbus_modem_get_allowed_modes (ctx->skeleton);
- current_preferred = mm_gdbus_modem_get_preferred_mode (ctx->skeleton);
+ g_variant_get (mm_gdbus_modem_get_current_modes (ctx->skeleton),
+ "(uu)",
+ &current_allowed,
+ &current_preferred);
if (current_allowed == allowed &&
current_preferred == preferred) {
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
@@ -2290,16 +2340,16 @@ mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
g_free (preferred_str);
g_free (allowed_str);
- set_allowed_modes_context_complete_and_free (ctx);
+ set_current_modes_context_complete_and_free (ctx);
return;
}
ctx->allowed = allowed;
ctx->preferred = preferred;
- MM_IFACE_MODEM_GET_INTERFACE (self)->set_allowed_modes (self,
+ MM_IFACE_MODEM_GET_INTERFACE (self)->set_current_modes (self,
allowed,
preferred,
- (GAsyncReadyCallback)set_allowed_modes_ready,
+ (GAsyncReadyCallback)set_current_modes_ready,
ctx);
}
@@ -2309,10 +2359,10 @@ typedef struct {
MMIfaceModem *self;
MMModemMode allowed;
MMModemMode preferred;
-} HandleSetAllowedModesContext;
+} HandleSetCurrentModesContext;
static void
-handle_set_allowed_modes_context_free (HandleSetAllowedModesContext *ctx)
+handle_set_current_modes_context_free (HandleSetCurrentModesContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
@@ -2321,31 +2371,31 @@ handle_set_allowed_modes_context_free (HandleSetAllowedModesContext *ctx)
}
static void
-handle_set_allowed_modes_ready (MMIfaceModem *self,
+handle_set_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
- HandleSetAllowedModesContext *ctx)
+ HandleSetCurrentModesContext *ctx)
{
GError *error = NULL;
- if (!mm_iface_modem_set_allowed_modes_finish (self, res, &error))
+ if (!mm_iface_modem_set_current_modes_finish (self, res, &error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
- mm_gdbus_modem_complete_set_allowed_modes (ctx->skeleton, ctx->invocation);
+ mm_gdbus_modem_complete_set_current_modes (ctx->skeleton, ctx->invocation);
- handle_set_allowed_modes_context_free (ctx);
+ handle_set_current_modes_context_free (ctx);
}
static void
-handle_set_allowed_modes_auth_ready (MMBaseModem *self,
+handle_set_current_modes_auth_ready (MMBaseModem *self,
GAsyncResult *res,
- HandleSetAllowedModesContext *ctx)
+ HandleSetCurrentModesContext *ctx)
{
MMModemState modem_state;
GError *error = NULL;
if (!mm_base_modem_authorize_finish (self, res, &error)) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
- handle_set_allowed_modes_context_free (ctx);
+ handle_set_current_modes_context_free (ctx);
return;
}
@@ -2360,37 +2410,39 @@ handle_set_allowed_modes_auth_ready (MMBaseModem *self,
MM_CORE_ERROR_WRONG_STATE,
"Cannot set allowed modes: "
"not initialized/unlocked yet");
- handle_set_allowed_modes_context_free (ctx);
+ handle_set_current_modes_context_free (ctx);
return;
}
- mm_iface_modem_set_allowed_modes (MM_IFACE_MODEM (self),
+ mm_iface_modem_set_current_modes (MM_IFACE_MODEM (self),
ctx->allowed,
ctx->preferred,
- (GAsyncReadyCallback)handle_set_allowed_modes_ready,
+ (GAsyncReadyCallback)handle_set_current_modes_ready,
ctx);
}
static gboolean
-handle_set_allowed_modes (MmGdbusModem *skeleton,
+handle_set_current_modes (MmGdbusModem *skeleton,
GDBusMethodInvocation *invocation,
- guint allowed,
- guint preferred,
+ GVariant *variant,
MMIfaceModem *self)
{
- HandleSetAllowedModesContext *ctx;
+ HandleSetCurrentModesContext *ctx;
- ctx = g_new (HandleSetAllowedModesContext, 1);
+ ctx = g_new (HandleSetCurrentModesContext, 1);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
- ctx->allowed = allowed;
- ctx->preferred = preferred;
+
+ g_variant_get (variant,
+ "(uu)",
+ &ctx->allowed,
+ &ctx->preferred);
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
- (GAsyncReadyCallback)handle_set_allowed_modes_auth_ready,
+ (GAsyncReadyCallback)handle_set_current_modes_auth_ready,
ctx);
return TRUE;
}
@@ -2982,7 +3034,7 @@ static void interface_disabling_step (DisablingContext *ctx);
typedef enum {
DISABLING_STEP_FIRST,
DISABLING_STEP_CURRENT_BANDS,
- DISABLING_STEP_ALLOWED_MODES,
+ DISABLING_STEP_CURRENT_MODES,
DISABLING_STEP_LAST
} DisablingStep;
@@ -3027,10 +3079,9 @@ interface_disabling_step (DisablingContext *ctx)
/* Fall down to next step */
ctx->step++;
- case DISABLING_STEP_ALLOWED_MODES:
+ case DISABLING_STEP_CURRENT_MODES:
/* Clear allowed/preferred modes */
- mm_gdbus_modem_set_allowed_modes (ctx->skeleton, MM_MODEM_MODE_NONE);
- mm_gdbus_modem_set_preferred_mode (ctx->skeleton, MM_MODEM_MODE_NONE);
+ mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", MM_MODEM_MODE_NONE, MM_MODEM_MODE_NONE));
/* Fall down to next step */
ctx->step++;
@@ -3086,7 +3137,7 @@ typedef enum {
ENABLING_STEP_FLOW_CONTROL,
ENABLING_STEP_SUPPORTED_CHARSETS,
ENABLING_STEP_CHARSET,
- ENABLING_STEP_ALLOWED_MODES,
+ ENABLING_STEP_CURRENT_MODES,
ENABLING_STEP_CURRENT_BANDS,
ENABLING_STEP_LAST
} EnablingStep;
@@ -3213,7 +3264,7 @@ setup_charset_ready (MMIfaceModem *self,
}
static void
-load_allowed_modes_ready (MMIfaceModem *self,
+load_current_modes_ready (MMIfaceModem *self,
GAsyncResult *res,
EnablingContext *ctx)
{
@@ -3221,7 +3272,7 @@ load_allowed_modes_ready (MMIfaceModem *self,
MMModemMode preferred = MM_MODEM_MODE_NONE;
GError *error = NULL;
- if (!MM_IFACE_MODEM_GET_INTERFACE (self)->load_allowed_modes_finish (self,
+ if (!MM_IFACE_MODEM_GET_INTERFACE (self)->load_current_modes_finish (self,
res,
&allowed,
&preferred,
@@ -3231,12 +3282,9 @@ load_allowed_modes_ready (MMIfaceModem *self,
g_error_free (error);
/* If errors getting allowed modes, assume ANY/NONE */
- allowed = MM_MODEM_MODE_ANY;
- preferred = MM_MODEM_MODE_NONE;
- }
-
- mm_gdbus_modem_set_allowed_modes (ctx->skeleton, allowed);
- mm_gdbus_modem_set_preferred_mode (ctx->skeleton, preferred);
+ mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", MM_MODEM_MODE_ANY, MM_MODEM_MODE_NONE));
+ } else
+ mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", allowed, preferred));
/* Done, Go on to next step */
ctx->step++;
@@ -3374,20 +3422,19 @@ interface_enabling_step (EnablingContext *ctx)
/* Fall down to next step */
ctx->step++;
- case ENABLING_STEP_ALLOWED_MODES:
- if (MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_allowed_modes &&
- MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_allowed_modes_finish) {
- MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_allowed_modes (
+ case ENABLING_STEP_CURRENT_MODES:
+ if (MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes &&
+ MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes_finish) {
+ MM_IFACE_MODEM_GET_INTERFACE (ctx->self)->load_current_modes (
ctx->self,
- (GAsyncReadyCallback)load_allowed_modes_ready,
+ (GAsyncReadyCallback)load_current_modes_ready,
ctx);
return;
}
- /* If no way to get allowed modes, assume allowed=any,
- * and none preferred */
- mm_gdbus_modem_set_allowed_modes (ctx->skeleton, MM_MODEM_MODE_ANY);
- mm_gdbus_modem_set_preferred_mode (ctx->skeleton, MM_MODEM_MODE_NONE);
+ /* If no way to get modes, assume ANY/NONE */
+ mm_gdbus_modem_set_current_modes (ctx->skeleton, g_variant_new ("(uu)", MM_MODEM_MODE_ANY, MM_MODEM_MODE_NONE));
+
/* Fall down to next step */
ctx->step++;
@@ -4227,8 +4274,8 @@ interface_initialization_step (InitializationContext *ctx)
G_CALLBACK (handle_set_current_bands),
ctx->self);
g_signal_connect (ctx->skeleton,
- "handle-set-allowed-modes",
- G_CALLBACK (handle_set_allowed_modes),
+ "handle-set-current-modes",
+ G_CALLBACK (handle_set_current_modes),
ctx->self);
g_simple_async_result_set_op_res_gboolean (ctx->result, TRUE);
}
@@ -4289,8 +4336,7 @@ mm_iface_modem_initialize (MMIfaceModem *self,
mm_gdbus_modem_set_access_technologies (skeleton, MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN);
mm_gdbus_modem_set_signal_quality (skeleton, g_variant_new ("(ub)", 0, FALSE));
mm_gdbus_modem_set_supported_modes (skeleton, mm_common_build_mode_combinations_default ());
- mm_gdbus_modem_set_allowed_modes (skeleton, MM_MODEM_MODE_NONE);
- mm_gdbus_modem_set_preferred_mode (skeleton, MM_MODEM_MODE_NONE);
+ mm_gdbus_modem_set_current_modes (skeleton,g_variant_new ("(uu)", MM_MODEM_MODE_NONE, MM_MODEM_MODE_NONE));
mm_gdbus_modem_set_supported_bands (skeleton, mm_common_build_bands_unknown ());
mm_gdbus_modem_set_current_bands (skeleton, mm_common_build_bands_unknown ());
mm_gdbus_modem_set_supported_ip_families (skeleton, MM_BEARER_IP_FAMILY_NONE);
diff --git a/src/mm-iface-modem.h b/src/mm-iface-modem.h
index 65b0243f..8ba1da66 100644
--- a/src/mm-iface-modem.h
+++ b/src/mm-iface-modem.h
@@ -130,11 +130,11 @@ struct _MMIfaceModem {
GAsyncResult *res,
GError **error);
- /* Loading of the AllowedModes and PreferredMode properties */
- void (*load_allowed_modes) (MMIfaceModem *self,
+ /* Loading of the Modes property */
+ void (*load_current_modes) (MMIfaceModem *self,
GAsyncReadyCallback callback,
gpointer user_data);
- gboolean (*load_allowed_modes_finish) (MMIfaceModem *self,
+ gboolean (*load_current_modes_finish) (MMIfaceModem *self,
GAsyncResult *res,
MMModemMode *allowed,
MMModemMode *preferred,
@@ -226,13 +226,13 @@ struct _MMIfaceModem {
GAsyncResult *res,
GError **error);
- /* Asynchronous allowed mode setting operation */
- void (*set_allowed_modes) (MMIfaceModem *self,
+ /* Asynchronous current mode setting operation */
+ void (*set_current_modes) (MMIfaceModem *self,
MMModemMode modes,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data);
- gboolean (*set_allowed_modes_finish) (MMIfaceModem *self,
+ gboolean (*set_current_modes_finish) (MMIfaceModem *self,
GAsyncResult *res,
GError **error);
@@ -417,12 +417,12 @@ void mm_iface_modem_update_signal_quality (MMIfaceModem *self,
guint signal_quality);
/* Allow setting allowed modes */
-void mm_iface_modem_set_allowed_modes (MMIfaceModem *self,
+void mm_iface_modem_set_current_modes (MMIfaceModem *self,
MMModemMode allowed,
MMModemMode preferred,
GAsyncReadyCallback callback,
gpointer user_data);
-gboolean mm_iface_modem_set_allowed_modes_finish (MMIfaceModem *self,
+gboolean mm_iface_modem_set_current_modes_finish (MMIfaceModem *self,
GAsyncResult *res,
GError **error);
generated by cgit v1.2.3-70-g09d2 (git 2.46.0) at 2025-06-07 20:09:32 +0000