/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
/*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details:
*
* Copyright (C) 2011 Google, Inc.
*/
#include <ModemManager.h>
#define _LIBMM_INSIDE_MM
#include <libmm-glib.h>
#include "libqcdm/src/commands.h"
#include "mm-iface-modem.h"
#include "mm-iface-modem-cdma.h"
#include "mm-base-modem.h"
#include "mm-modem-helpers.h"
#include "mm-log.h"
#define REGISTRATION_CHECK_TIMEOUT_SEC 30
#define SUBSYSTEM_CDMA1X "cdma1x"
#define SUBSYSTEM_EVDO "evdo"
#define REGISTRATION_CHECK_CONTEXT_TAG "cdma-registration-check-context-tag"
static GQuark registration_check_context_quark;
/*****************************************************************************/
void
mm_iface_modem_cdma_bind_simple_status (MMIfaceModemCdma *self,
MMSimpleStatus *status)
{
MmGdbusModemCdma *skeleton;
g_object_get (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton)
return;
g_object_bind_property (skeleton, "cdma1x-registration-state",
status, MM_SIMPLE_PROPERTY_CDMA_CDMA1X_REGISTRATION_STATE,
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_bind_property (skeleton, "sid",
status, MM_SIMPLE_PROPERTY_CDMA_SID,
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_bind_property (skeleton, "nid",
status, MM_SIMPLE_PROPERTY_CDMA_NID,
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_bind_property (skeleton, "evdo-registration-state",
status, MM_SIMPLE_PROPERTY_CDMA_EVDO_REGISTRATION_STATE,
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_unref (skeleton);
}
/*****************************************************************************/
typedef struct {
MmGdbusModemCdma *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModemCdma *self;
gchar *carrier;
} HandleActivateContext;
static void
handle_activate_context_free (HandleActivateContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_free (ctx->carrier);
g_free (ctx);
}
static void
handle_activate_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
HandleActivateContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate_finish (self, res,&error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
mm_gdbus_modem_cdma_complete_activate (ctx->skeleton, ctx->invocation);
handle_activate_context_free (ctx);
}
static void
handle_activate_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleActivateContext *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_activate_context_free (ctx);
return;
}
/* If we're already activated, nothing to do */
if (mm_gdbus_modem_cdma_get_activation_state (ctx->skeleton) == MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED) {
mm_dbg ("Modem is already activated");
mm_gdbus_modem_cdma_complete_activate (ctx->skeleton, ctx->invocation);
handle_activate_context_free (ctx);
return;
}
/* If activating OTA is not implemented, report an error */
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate ||
!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot perform OTA activation: "
"operation not supported");
handle_activate_context_free (ctx);
return;
}
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
switch (modem_state) {
case MM_MODEM_STATE_FAILED:
case MM_MODEM_STATE_UNKNOWN:
case MM_MODEM_STATE_LOCKED:
/* We should never have such request (interface wasn't exported yet) */
g_assert_not_reached ();
break;
case MM_MODEM_STATE_INITIALIZING:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform OTA activation: "
"device not fully initialized yet");
handle_activate_context_free (ctx);
return;
case MM_MODEM_STATE_ENABLED:
case MM_MODEM_STATE_SEARCHING:
case MM_MODEM_STATE_REGISTERED:
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate (
MM_IFACE_MODEM_CDMA (self),
ctx->carrier,
(GAsyncReadyCallback)handle_activate_ready,
ctx);
return;
case MM_MODEM_STATE_DISABLING:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform OTA activation: "
"currently being disabled");
break;
case MM_MODEM_STATE_ENABLING:
case MM_MODEM_STATE_DISABLED:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform OTA activation: "
"not enabled yet");
break;
case MM_MODEM_STATE_DISCONNECTING:
case MM_MODEM_STATE_CONNECTING:
case MM_MODEM_STATE_CONNECTED:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform OTA activation: "
"modem is connected");
break;
}
handle_activate_context_free (ctx);
}
static gboolean
handle_activate (MmGdbusModemCdma *skeleton,
GDBusMethodInvocation *invocation,
const gchar *carrier,
MMIfaceModemCdma *self)
{
HandleActivateContext *ctx;
ctx = g_new (HandleActivateContext, 1);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->carrier = g_strdup (carrier);
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_activate_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
typedef struct {
MmGdbusModemCdma *skeleton;
GDBusMethodInvocation *invocation;
MMIfaceModemCdma *self;
GVariant *dictionary;
} HandleActivateManualContext;
static void
handle_activate_manual_context_free (HandleActivateManualContext *ctx)
{
g_object_unref (ctx->skeleton);
g_object_unref (ctx->invocation);
g_object_unref (ctx->self);
g_variant_unref (ctx->dictionary);
g_free (ctx);
}
static void
handle_activate_manual_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
HandleActivateManualContext *ctx)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate_manual_finish (self, res,&error))
g_dbus_method_invocation_take_error (ctx->invocation, error);
else
mm_gdbus_modem_cdma_complete_activate_manual (ctx->skeleton, ctx->invocation);
handle_activate_manual_context_free (ctx);
}
static void
handle_activate_manual_auth_ready (MMBaseModem *self,
GAsyncResult *res,
HandleActivateManualContext *ctx)
{
MMCdmaManualActivationProperties *properties;
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_activate_manual_context_free (ctx);
return;
}
/* If we're already activated, nothing to do */
if (mm_gdbus_modem_cdma_get_activation_state (ctx->skeleton) == MM_MODEM_CDMA_ACTIVATION_STATE_ACTIVATED) {
mm_dbg ("Modem is already activated");
mm_gdbus_modem_cdma_complete_activate_manual (ctx->skeleton, ctx->invocation);
handle_activate_manual_context_free (ctx);
return;
}
/* If manual activation is not implemented, report an error */
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate_manual ||
!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate_manual_finish) {
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_UNSUPPORTED,
"Cannot perform manual activation: "
"operation not supported");
handle_activate_manual_context_free (ctx);
return;
}
/* Parse input properties */
properties = mm_cdma_manual_activation_properties_new_from_dictionary (ctx->dictionary, &error);
if (!properties) {
g_dbus_method_invocation_take_error (ctx->invocation, error);
handle_activate_manual_context_free (ctx);
return;
}
modem_state = MM_MODEM_STATE_UNKNOWN;
g_object_get (self,
MM_IFACE_MODEM_STATE, &modem_state,
NULL);
switch (modem_state) {
case MM_MODEM_STATE_FAILED:
case MM_MODEM_STATE_UNKNOWN:
case MM_MODEM_STATE_LOCKED:
/* We should never have such request (interface wasn't exported yet) */
g_assert_not_reached ();
break;
case MM_MODEM_STATE_INITIALIZING:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform manual activation: "
"device not fully initialized yet");
break;
case MM_MODEM_STATE_ENABLED:
case MM_MODEM_STATE_SEARCHING:
case MM_MODEM_STATE_REGISTERED:
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->activate_manual (
MM_IFACE_MODEM_CDMA (self),
properties,
(GAsyncReadyCallback)handle_activate_manual_ready,
ctx);
g_object_unref (properties);
return;
case MM_MODEM_STATE_DISABLING:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform manual activation: "
"currently being disabled");
break;
case MM_MODEM_STATE_ENABLING:
case MM_MODEM_STATE_DISABLED:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform manual activation: "
"not enabled yet");
break;
case MM_MODEM_STATE_DISCONNECTING:
case MM_MODEM_STATE_CONNECTING:
case MM_MODEM_STATE_CONNECTED:
g_dbus_method_invocation_return_error (ctx->invocation,
MM_CORE_ERROR,
MM_CORE_ERROR_WRONG_STATE,
"Cannot perform manual activation: "
"modem is connected");
break;
}
g_object_unref (properties);
handle_activate_manual_context_free (ctx);
}
static gboolean
handle_activate_manual (MmGdbusModemCdma *skeleton,
GDBusMethodInvocation *invocation,
GVariant *dictionary,
MMIfaceModemCdma *self)
{
HandleActivateManualContext *ctx;
ctx = g_new (HandleActivateManualContext, 1);
ctx->skeleton = g_object_ref (skeleton);
ctx->invocation = g_object_ref (invocation);
ctx->self = g_object_ref (self);
ctx->dictionary = g_variant_ref (dictionary);
mm_base_modem_authorize (MM_BASE_MODEM (self),
invocation,
MM_AUTHORIZATION_DEVICE_CONTROL,
(GAsyncReadyCallback)handle_activate_manual_auth_ready,
ctx);
return TRUE;
}
/*****************************************************************************/
/* Register in the CDMA network.
* Note that the registration in the CDMA network is usually automatic; so this
* method will really just try to ensure the modem is registered. If not
* registered, it will wait until it is, up to N seconds.
*/
gboolean
mm_iface_modem_cdma_register_in_network_finish (MMIfaceModemCdma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
register_in_network_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->register_in_network_finish (self, res, &error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
void
mm_iface_modem_cdma_register_in_network (MMIfaceModemCdma *self,
guint max_registration_time,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
task = g_task_new (self, NULL, callback, user_data);
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->register_in_network (
self,
max_registration_time,
(GAsyncReadyCallback)register_in_network_ready,
task);
}
/*****************************************************************************/
typedef struct _RunRegistrationChecksContext RunRegistrationChecksContext;
static void registration_check_step (GTask *task);
typedef enum {
REGISTRATION_CHECK_STEP_FIRST,
REGISTRATION_CHECK_STEP_SETUP_REGISTRATION_CHECKS,
REGISTRATION_CHECK_STEP_QCDM_CALL_MANAGER_STATE,
REGISTRATION_CHECK_STEP_QCDM_HDR_STATE,
REGISTRATION_CHECK_STEP_QCDM_CDMA1X_SERVING_SYSTEM,
REGISTRATION_CHECK_STEP_QCDM_LAST,
REGISTRATION_CHECK_STEP_AT_CDMA_SERVICE_STATUS,
REGISTRATION_CHECK_STEP_AT_CDMA1X_SERVING_SYSTEM,
REGISTRATION_CHECK_STEP_AT_LAST,
REGISTRATION_CHECK_STEP_DETAILED_REGISTRATION_STATE,
REGISTRATION_CHECK_STEP_LAST,
} RegistrationCheckStep;
struct _RunRegistrationChecksContext {
RegistrationCheckStep step;
MMModemCdmaRegistrationState cdma1x_state;
MMModemCdmaRegistrationState evdo_state;
gboolean cdma1x_supported;
gboolean evdo_supported;
gboolean skip_qcdm_call_manager_step;
gboolean skip_qcdm_hdr_step;
gboolean skip_at_cdma_service_status_step;
gboolean skip_at_cdma1x_serving_system_step;
gboolean skip_detailed_registration_state;
guint call_manager_system_mode;
guint call_manager_operating_mode;
guint8 hdr_session_state;
guint8 hdr_almp_state;
guint8 hdr_hybrid_mode;
guint cdma1x_class;
guint cdma1x_band;
guint cdma1x_sid;
guint cdma1x_nid;
};
gboolean
mm_iface_modem_cdma_run_registration_checks_finish (MMIfaceModemCdma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
setup_registration_checks_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
RunRegistrationChecksContext *ctx;
GError *error = NULL;
ctx = g_task_get_task_data (task);
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_registration_checks_finish (
self,
res,
&ctx->skip_qcdm_call_manager_step,
&ctx->skip_qcdm_hdr_step,
&ctx->skip_at_cdma_service_status_step,
&ctx->skip_at_cdma1x_serving_system_step,
&ctx->skip_detailed_registration_state,
&error)) {
/* Make it fatal */
g_task_return_error (task, error);
g_object_unref (task);
return;
}
/* Go on to next step */
ctx->step++;
registration_check_step (task);
}
static void
get_call_manager_state_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
RunRegistrationChecksContext *ctx;
GError *error = NULL;
ctx = g_task_get_task_data (task);
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_call_manager_state_finish (
self,
res,
&ctx->call_manager_system_mode,
&ctx->call_manager_operating_mode,
&error)) {
mm_dbg ("Could not get call manager state: %s", error->message);
g_error_free (error);
/* Fallback to AT-based check */
ctx->step = REGISTRATION_CHECK_STEP_AT_CDMA_SERVICE_STATUS;
registration_check_step (task);
return;
}
/* If no CDMA service, just finish checks */
if (ctx->call_manager_operating_mode != QCDM_CMD_CM_SUBSYS_STATE_INFO_OPERATING_MODE_ONLINE) {
ctx->step = REGISTRATION_CHECK_STEP_LAST;
registration_check_step (task);
return;
}
/* Go on to next step */
ctx->step++;
registration_check_step (task);
}
static void
get_hdr_state_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
RunRegistrationChecksContext *ctx;
GError *error = NULL;
ctx = g_task_get_task_data (task);
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_hdr_state_finish (
self,
res,
&ctx->hdr_hybrid_mode,
&ctx->hdr_session_state,
&ctx->hdr_almp_state,
&error)) {
mm_dbg ("Could not get HDR state: %s", error->message);
g_error_free (error);
/* Fallback to AT-based check */
ctx->step = REGISTRATION_CHECK_STEP_AT_CDMA_SERVICE_STATUS;
registration_check_step (task);
return;
}
/* Go on to next step */
ctx->step++;
registration_check_step (task);
}
static void
parse_qcdm_results (GTask *task)
{
RunRegistrationChecksContext *ctx;
ctx = g_task_get_task_data (task);
mm_dbg ("QCDM CM System Mode: %d", ctx->call_manager_system_mode);
mm_dbg ("QCDM HDR Hybrid Mode: %d", ctx->hdr_hybrid_mode);
mm_dbg ("QCDM HDR Session State: %d", ctx->hdr_session_state);
mm_dbg ("QCDM HDR ALMP State: %d", ctx->hdr_almp_state);
/* Set QCDM-obtained registration info */
switch (ctx->call_manager_system_mode) {
case QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_CDMA:
ctx->cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
if ( ctx->hdr_hybrid_mode
&& ctx->hdr_session_state == QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_OPEN
&& ( ctx->hdr_almp_state == QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_IDLE
|| ctx->hdr_almp_state == QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_CONNECTED))
ctx->evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
break;
case QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_HDR:
ctx->evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
break;
case QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_AMPS:
case QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_NO_SERVICE:
case QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_WCDMA:
default:
break;
}
if (ctx->cdma1x_state != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN ||
ctx->evdo_state != MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN)
/* Jump to get detailed registration state */
ctx->step = REGISTRATION_CHECK_STEP_DETAILED_REGISTRATION_STATE;
else
/* If no CDMA service, just finish checks */
ctx->step = REGISTRATION_CHECK_STEP_LAST;
registration_check_step (task);
}
static void
get_service_status_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
RunRegistrationChecksContext *ctx;
GError *error = NULL;
gboolean has_service = FALSE;
ctx = g_task_get_task_data (task);
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_service_status_finish (self,
res,
&has_service,
&error)) {
mm_warn ("Could not get service status: %s", error->message);
g_task_return_error (task, error);
g_object_unref (task);
return;
}
if (!has_service) {
/* There is no CDMA service at all, end registration checks */
mm_dbg ("No CDMA service found");
ctx->step = REGISTRATION_CHECK_STEP_LAST;
} else
/* If we do have service, go on to next step */
ctx->step++;
registration_check_step (task);
}
static void
get_cdma1x_serving_system_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
RunRegistrationChecksContext *ctx;
GError *error = NULL;
ctx = g_task_get_task_data (task);
/* Note: used for *both* AT and QCDM serving system checks */
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system_finish (
self,
res,
&ctx->cdma1x_class,
&ctx->cdma1x_band,
&ctx->cdma1x_sid,
&ctx->cdma1x_nid,
&error)) {
/* Treat as fatal all errors except for no-network */
if (!g_error_matches (error,
MM_MOBILE_EQUIPMENT_ERROR,
MM_MOBILE_EQUIPMENT_ERROR_NO_NETWORK)) {
mm_warn ("Could not get serving system: %s", error->message);
g_task_return_error (task, error);
g_object_unref (task);
return;
}
ctx->cdma1x_sid = MM_MODEM_CDMA_SID_UNKNOWN;
ctx->cdma1x_nid = MM_MODEM_CDMA_NID_UNKNOWN;
}
/* TODO: not sure why we also take class/band here */
/* Go on to next step */
ctx->step++;
registration_check_step (task);
}
static void
parse_at_results (GTask *task)
{
RunRegistrationChecksContext *ctx;
ctx = g_task_get_task_data (task);
/* 99999 means unknown/no service */
if (ctx->cdma1x_sid == MM_MODEM_CDMA_SID_UNKNOWN &&
ctx->cdma1x_nid == MM_MODEM_CDMA_NID_UNKNOWN) {
/* Not registered in CDMA network, end registration checks */
mm_dbg ("Not registered in any CDMA network");
ctx->step = REGISTRATION_CHECK_STEP_LAST;
} else {
/* We're registered on the CDMA 1x network (at least) */
ctx->cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED;
/* Jump to get detailed registration state */
ctx->step = REGISTRATION_CHECK_STEP_DETAILED_REGISTRATION_STATE;
}
registration_check_step (task);
}
static void
get_detailed_registration_state_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
RunRegistrationChecksContext *ctx;
GError *error = NULL;
MMModemCdmaRegistrationState detailed_cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
MMModemCdmaRegistrationState detailed_evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
ctx = g_task_get_task_data (task);
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_detailed_registration_state_finish (
self,
res,
&detailed_cdma1x_state,
&detailed_evdo_state,
&error)) {
/* This error is NOT fatal. If we get an error here, we'll just fallback
* to the non-detailed values we already got. */
mm_dbg ("Could not get more detailed registration state: %s", error->message);
} else {
ctx->cdma1x_state = detailed_cdma1x_state;
ctx->evdo_state = detailed_evdo_state;
}
/* Go on to next step */
ctx->step++;
registration_check_step (task);
}
static void
registration_check_step (GTask *task)
{
MMIfaceModemCdma *self;
RunRegistrationChecksContext *ctx;
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case REGISTRATION_CHECK_STEP_FIRST:
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_SETUP_REGISTRATION_CHECKS:
/* Allow implementations to run an initial setup check. This setup allows
* to specify which of the next steps will be completely skipped. Useful
* when implementations have a best get_detailed_registration_state()
* so that they just need that to be run. */
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_registration_checks &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_registration_checks_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_registration_checks (
self,
(GAsyncReadyCallback)setup_registration_checks_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_QCDM_CALL_MANAGER_STATE:
mm_dbg ("Starting QCDM-based registration checks");
if (!ctx->skip_qcdm_call_manager_step &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_call_manager_state &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_call_manager_state_finish) {
/* Start by trying to get the call manager state. */
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_call_manager_state (
self,
(GAsyncReadyCallback)get_call_manager_state_ready,
task);
return;
}
/* Fallback to AT-based check */
mm_dbg (" Skipping all QCDM-based checks and falling back to AT-based checks");
ctx->step = REGISTRATION_CHECK_STEP_AT_CDMA_SERVICE_STATUS;
registration_check_step (task);
return;
case REGISTRATION_CHECK_STEP_QCDM_HDR_STATE:
if (ctx->evdo_supported &&
!ctx->skip_qcdm_hdr_step &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_hdr_state &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_hdr_state_finish) {
/* Get HDR (EVDO) state. */
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_hdr_state (
self,
(GAsyncReadyCallback)get_hdr_state_ready,
task);
return;
}
mm_dbg (" Skipping HDR check");
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_QCDM_CDMA1X_SERVING_SYSTEM:
/* We only care about SID/NID here; nothing to do with registration
* state.
*/
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system (
self,
(GAsyncReadyCallback)get_cdma1x_serving_system_ready,
task);
return;
}
mm_dbg (" Skipping CDMA1x Serving System check");
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_QCDM_LAST:
/* When we get all QCDM results, parse them */
parse_qcdm_results (task);
return;
case REGISTRATION_CHECK_STEP_AT_CDMA_SERVICE_STATUS:
mm_dbg ("Starting AT-based registration checks");
/* If we don't have means to get service status, just assume we do have
* CDMA service and keep on */
if (!ctx->skip_at_cdma_service_status_step &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_service_status &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_service_status_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_service_status (
self,
(GAsyncReadyCallback)get_service_status_ready,
task);
return;
}
mm_dbg (" Skipping CDMA service status check, assuming with service");
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_AT_CDMA1X_SERVING_SYSTEM:
/* Now that we have some sort of service, check if the the device is
* registered on the network.
*/
/* Some devices key the AT+CSS? response off the 1X state, but if the
* device has EVDO service but no 1X service, then reading AT+CSS? will
* error out too early. Let subclasses that know that their AT+CSS?
* response is wrong in this case handle more specific registration
* themselves; if they do, they'll set these callbacks to NULL..
*/
if (!ctx->skip_at_cdma1x_serving_system_step &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system (
self,
(GAsyncReadyCallback)get_cdma1x_serving_system_ready,
task);
return;
}
mm_dbg (" Skipping CDMA1x Serving System check");
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_AT_LAST:
/* When we get all AT results, parse them */
parse_at_results (task);
return;
case REGISTRATION_CHECK_STEP_DETAILED_REGISTRATION_STATE:
mm_dbg ("Starting detailed registration state check");
/* We let classes implementing this interface to look for more detailed
* registration info. */
if (!ctx->skip_detailed_registration_state &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_detailed_registration_state &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_detailed_registration_state_finish) {
/* We pass the CDMA1x/EVDO registration states we got up to now.
* If the implementation can't improve the detail, it must either
* return the values it already got as input, or issue an error,
* and we'll assume it couldn't get any better value. */
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_detailed_registration_state (
self,
ctx->cdma1x_state,
ctx->evdo_state,
(GAsyncReadyCallback)get_detailed_registration_state_ready,
task);
return;
}
mm_dbg (" Skipping detailed registration state check");
/* Fall down to next step */
ctx->step++;
case REGISTRATION_CHECK_STEP_LAST:
/* We are done without errors! */
mm_dbg ("All CDMA registration state checks done");
mm_iface_modem_cdma_update_cdma1x_registration_state (self,
ctx->cdma1x_state,
ctx->cdma1x_sid,
ctx->cdma1x_nid);
mm_iface_modem_cdma_update_evdo_registration_state (self,
ctx->evdo_state);
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
static void
custom_run_registration_checks_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
GError *error = NULL;
if (!MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->run_registration_checks_finish (self, res, &error))
g_task_return_error (task, error);
else
g_task_return_boolean (task, TRUE);
g_object_unref (task);
}
void
mm_iface_modem_cdma_run_registration_checks (MMIfaceModemCdma *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
GTask *task;
gboolean cdma1x_supported;
gboolean evdo_supported;
task = g_task_new (self, NULL, callback, user_data);
g_object_get (self,
MM_IFACE_MODEM_CDMA_EVDO_NETWORK_SUPPORTED, &evdo_supported,
MM_IFACE_MODEM_CDMA_CDMA1X_NETWORK_SUPPORTED, &cdma1x_supported,
NULL);
mm_dbg ("Running registration checks (CDMA1x: '%s', EV-DO: '%s')",
cdma1x_supported ? "yes" : "no",
evdo_supported ? "yes" : "no");
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->run_registration_checks &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->run_registration_checks_finish) {
/* Plugins implementing full custom registration checks shouldn't implement
* sub-steps of the generic registration check sequence */
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_registration_checks != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_registration_checks_finish != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_call_manager_state != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_call_manager_state_finish != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_hdr_state != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_hdr_state_finish != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_service_status != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_service_status_finish != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_cdma1x_serving_system_finish != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_detailed_registration_state != NULL);
g_warn_if_fail (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->get_detailed_registration_state_finish != NULL);
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->run_registration_checks (
self,
cdma1x_supported,
evdo_supported,
(GAsyncReadyCallback)custom_run_registration_checks_ready,
task);
} else {
RunRegistrationChecksContext *ctx;
ctx = g_new0 (RunRegistrationChecksContext, 1);
ctx->cdma1x_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
ctx->evdo_state = MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN;
ctx->call_manager_system_mode = QCDM_CMD_CM_SUBSYS_STATE_INFO_SYSTEM_MODE_NO_SERVICE;
ctx->hdr_session_state = QCDM_CMD_HDR_SUBSYS_STATE_INFO_SESSION_STATE_CLOSED;
ctx->hdr_almp_state = QCDM_CMD_HDR_SUBSYS_STATE_INFO_ALMP_STATE_INACTIVE;
ctx->hdr_hybrid_mode = 0;
ctx->evdo_supported = evdo_supported;
ctx->cdma1x_supported = cdma1x_supported;
g_task_set_task_data (task, ctx, g_free);
registration_check_step (task);
}
}
/*****************************************************************************/
void
mm_iface_modem_cdma_update_access_technologies (MMIfaceModemCdma *self,
MMModemAccessTechnology access_tech)
{
MMModemCdmaRegistrationState cdma1x_state;
MMModemCdmaRegistrationState evdo_state;
g_object_get (self,
MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE, &cdma1x_state,
MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE, &evdo_state,
NULL);
/* Even if registration state didn't change, report access technology,
* but only if something valid to report */
if (cdma1x_state == MM_MODEM_CDMA_REGISTRATION_STATE_HOME ||
cdma1x_state == MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING ||
cdma1x_state == MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED ||
evdo_state == MM_MODEM_CDMA_REGISTRATION_STATE_HOME ||
evdo_state == MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING ||
evdo_state == MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED) {
if (access_tech != MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN)
mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self),
access_tech,
MM_IFACE_MODEM_CDMA_ALL_ACCESS_TECHNOLOGIES_MASK);
} else
mm_iface_modem_update_access_technologies (MM_IFACE_MODEM (self),
MM_MODEM_ACCESS_TECHNOLOGY_UNKNOWN,
MM_IFACE_MODEM_CDMA_ALL_ACCESS_TECHNOLOGIES_MASK);
}
void
mm_iface_modem_cdma_update_evdo_registration_state (MMIfaceModemCdma *self,
MMModemCdmaRegistrationState state)
{
MmGdbusModemCdma *skeleton = NULL;
gboolean supported = FALSE;
g_object_get (self,
MM_IFACE_MODEM_CDMA_EVDO_NETWORK_SUPPORTED, &supported,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton)
return;
if (supported) {
/* The property in the interface is bound to the property
* in the skeleton, so just updating here is enough */
g_object_set (self,
MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE, state,
NULL);
switch (state) {
case MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED:
case MM_MODEM_CDMA_REGISTRATION_STATE_HOME:
case MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING:
mm_iface_modem_update_subsystem_state (MM_IFACE_MODEM (self),
SUBSYSTEM_EVDO,
MM_MODEM_STATE_REGISTERED,
MM_MODEM_STATE_CHANGE_REASON_UNKNOWN);
break;
case MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN:
mm_iface_modem_update_subsystem_state (MM_IFACE_MODEM (self),
SUBSYSTEM_EVDO,
MM_MODEM_STATE_ENABLED,
MM_MODEM_STATE_CHANGE_REASON_UNKNOWN);
break;
}
}
g_object_unref (skeleton);
}
void
mm_iface_modem_cdma_update_cdma1x_registration_state (MMIfaceModemCdma *self,
MMModemCdmaRegistrationState state,
guint sid,
guint nid)
{
MmGdbusModemCdma *skeleton = NULL;
gboolean supported = FALSE;
g_object_get (self,
MM_IFACE_MODEM_CDMA_CDMA1X_NETWORK_SUPPORTED, &supported,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton)
return;
if (supported) {
/* The property in the interface is bound to the property
* in the skeleton, so just updating here is enough */
g_object_set (self,
MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE, state,
NULL);
switch (state) {
case MM_MODEM_CDMA_REGISTRATION_STATE_REGISTERED:
case MM_MODEM_CDMA_REGISTRATION_STATE_HOME:
case MM_MODEM_CDMA_REGISTRATION_STATE_ROAMING:
mm_gdbus_modem_cdma_set_sid (skeleton, sid);
mm_gdbus_modem_cdma_set_nid (skeleton, nid);
mm_iface_modem_update_subsystem_state (MM_IFACE_MODEM (self),
SUBSYSTEM_CDMA1X,
MM_MODEM_STATE_REGISTERED,
MM_MODEM_STATE_CHANGE_REASON_UNKNOWN);
break;
case MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN:
if (mm_gdbus_modem_cdma_get_sid (skeleton) != MM_MODEM_CDMA_SID_UNKNOWN)
mm_gdbus_modem_cdma_set_sid (skeleton, MM_MODEM_CDMA_SID_UNKNOWN);
if (mm_gdbus_modem_cdma_get_nid (skeleton) != MM_MODEM_CDMA_NID_UNKNOWN)
mm_gdbus_modem_cdma_set_nid (skeleton, MM_MODEM_CDMA_NID_UNKNOWN);
mm_iface_modem_update_subsystem_state (MM_IFACE_MODEM (self),
SUBSYSTEM_CDMA1X,
MM_MODEM_STATE_ENABLED,
MM_MODEM_STATE_CHANGE_REASON_UNKNOWN);
break;
}
}
g_object_unref (skeleton);
}
/*****************************************************************************/
typedef struct {
guint timeout_source;
gboolean running;
} RegistrationCheckContext;
static void
registration_check_context_free (RegistrationCheckContext *ctx)
{
if (ctx->timeout_source)
g_source_remove (ctx->timeout_source);
g_free (ctx);
}
static void
periodic_registration_checks_ready (MMIfaceModemCdma *self,
GAsyncResult *res)
{
RegistrationCheckContext *ctx;
GError *error = NULL;
mm_iface_modem_cdma_run_registration_checks_finish (self, res, &error);
if (error) {
mm_dbg ("Couldn't refresh CDMA registration status: '%s'", error->message);
g_error_free (error);
}
/* Remove the running tag */
ctx = g_object_get_qdata (G_OBJECT (self), registration_check_context_quark);
if (ctx)
ctx->running = FALSE;
}
static gboolean
periodic_registration_check (MMIfaceModemCdma *self)
{
RegistrationCheckContext *ctx;
/* Only launch a new one if not one running already */
ctx = g_object_get_qdata (G_OBJECT (self), registration_check_context_quark);
if (!ctx->running) {
ctx->running = TRUE;
mm_iface_modem_cdma_run_registration_checks (
self,
(GAsyncReadyCallback)periodic_registration_checks_ready,
NULL);
}
return G_SOURCE_CONTINUE;
}
static void
periodic_registration_check_disable (MMIfaceModemCdma *self)
{
if (G_UNLIKELY (!registration_check_context_quark))
registration_check_context_quark = (g_quark_from_static_string (
REGISTRATION_CHECK_CONTEXT_TAG));
/* Overwriting the data will free the previous context */
g_object_set_qdata (G_OBJECT (self),
registration_check_context_quark,
NULL);
mm_dbg ("Periodic CDMA registration checks disabled");
}
static void
periodic_registration_check_enable (MMIfaceModemCdma *self)
{
RegistrationCheckContext *ctx;
if (G_UNLIKELY (!registration_check_context_quark))
registration_check_context_quark = (g_quark_from_static_string (
REGISTRATION_CHECK_CONTEXT_TAG));
ctx = g_object_get_qdata (G_OBJECT (self), registration_check_context_quark);
/* If context is already there, we're already enabled */
if (ctx)
return;
/* Create context and keep it as object data */
mm_dbg ("Periodic CDMA registration checks enabled");
ctx = g_new0 (RegistrationCheckContext, 1);
ctx->timeout_source = g_timeout_add_seconds (REGISTRATION_CHECK_TIMEOUT_SEC,
(GSourceFunc)periodic_registration_check,
self);
g_object_set_qdata_full (G_OBJECT (self),
registration_check_context_quark,
ctx,
(GDestroyNotify)registration_check_context_free);
}
/*****************************************************************************/
static GVariant *
build_empty_dictionary (void)
{
GVariantBuilder builder;
g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
return g_variant_builder_end (&builder);
}
void
mm_iface_modem_cdma_update_activation_state (MMIfaceModemCdma *self,
MMModemCdmaActivationState activation_state,
const GError *activation_error)
{
MmGdbusModemCdma *skeleton = NULL;
MMCdmaActivationError error = MM_CDMA_ACTIVATION_ERROR_NONE;
g_object_get (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton)
return;
if (activation_error) {
mm_dbg ("Activation failed: %s", activation_error->message);
if (activation_error->domain == MM_CDMA_ACTIVATION_ERROR)
error = activation_error->code;
else {
mm_warn ("Error given is not an activation error");
error = MM_CDMA_ACTIVATION_ERROR_UNKNOWN;
}
}
/* Flush current change before signaling the state change,
* so that clients get the proper state already in the
* state-changed callback */
mm_gdbus_modem_cdma_set_activation_state (skeleton, activation_state);
g_dbus_interface_skeleton_flush (G_DBUS_INTERFACE_SKELETON (skeleton));
/* We don't know what changed, so just return an empty dictionary for now */
mm_gdbus_modem_cdma_emit_activation_state_changed (skeleton,
activation_state,
error,
build_empty_dictionary ());
g_object_unref (skeleton);
}
/*****************************************************************************/
typedef struct _DisablingContext DisablingContext;
static void interface_disabling_step (GTask *task);
typedef enum {
DISABLING_STEP_FIRST,
DISABLING_STEP_PERIODIC_REGISTRATION_CHECKS,
DISABLING_STEP_DISABLE_UNSOLICITED_EVENTS,
DISABLING_STEP_CLEANUP_UNSOLICITED_EVENTS,
DISABLING_STEP_LAST
} DisablingStep;
struct _DisablingContext {
DisablingStep step;
MmGdbusModemCdma *skeleton;
};
static void
disabling_context_free (DisablingContext *ctx)
{
if (ctx->skeleton)
g_object_unref (ctx->skeleton);
g_free (ctx);
}
gboolean
mm_iface_modem_cdma_disable_finish (MMIfaceModemCdma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
disable_unsolicited_events_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
DisablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->disable_unsolicited_events_finish (self, res, &error);
if (error) {
mm_dbg ("Couldn't disable unsolicited events: '%s'", error->message);
g_error_free (error);
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_disabling_step (task);
}
static void
cleanup_unsolicited_events_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
DisablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->cleanup_unsolicited_events_finish (self, res, &error);
if (error) {
mm_dbg ("Couldn't cleanup unsolicited events: '%s'", error->message);
g_error_free (error);
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_disabling_step (task);
}
static void
interface_disabling_step (GTask *task)
{
MMIfaceModemCdma *self;
DisablingContext *ctx;
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case DISABLING_STEP_FIRST:
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_PERIODIC_REGISTRATION_CHECKS:
periodic_registration_check_disable (self);
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_DISABLE_UNSOLICITED_EVENTS:
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->disable_unsolicited_events &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->disable_unsolicited_events_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->disable_unsolicited_events (
self,
(GAsyncReadyCallback)disable_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_CLEANUP_UNSOLICITED_EVENTS:
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->cleanup_unsolicited_events &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->cleanup_unsolicited_events_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->cleanup_unsolicited_events (
self,
(GAsyncReadyCallback)cleanup_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case DISABLING_STEP_LAST:
/* We are done without errors! */
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
void
mm_iface_modem_cdma_disable (MMIfaceModemCdma *self,
GAsyncReadyCallback callback,
gpointer user_data)
{
DisablingContext *ctx;
GTask *task;
ctx = g_new0 (DisablingContext, 1);
ctx->step = DISABLING_STEP_FIRST;
task = g_task_new (self, NULL, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)disabling_context_free);
g_object_get (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &ctx->skeleton,
NULL);
if (!ctx->skeleton) {
g_task_return_new_error (task,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get interface skeleton");
g_object_unref (task);
return;
}
interface_disabling_step (task);
}
/*****************************************************************************/
typedef struct _EnablingContext EnablingContext;
static void interface_enabling_step (GTask *task);
typedef enum {
ENABLING_STEP_FIRST,
ENABLING_STEP_SETUP_UNSOLICITED_EVENTS,
ENABLING_STEP_ENABLE_UNSOLICITED_EVENTS,
ENABLING_STEP_PERIODIC_REGISTRATION_CHECKS,
ENABLING_STEP_LAST
} EnablingStep;
struct _EnablingContext {
EnablingStep step;
MmGdbusModemCdma *skeleton;
};
static void
enabling_context_free (EnablingContext *ctx)
{
if (ctx->skeleton)
g_object_unref (ctx->skeleton);
g_free (ctx);
}
gboolean
mm_iface_modem_cdma_enable_finish (MMIfaceModemCdma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
static void
setup_unsolicited_events_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
EnablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_unsolicited_events_finish (self, res, &error);
if (error) {
/* This error shouldn't be treated as critical */
mm_dbg ("Setting up unsolicited events failed: '%s'", error->message);
g_error_free (error);
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_enabling_step (task);
}
static void
enable_unsolicited_events_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
EnablingContext *ctx;
GError *error = NULL;
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->enable_unsolicited_events_finish (self, res, &error);
if (error) {
/* This error shouldn't be treated as critical */
mm_dbg ("Enabling unsolicited events failed: '%s'", error->message);
g_error_free (error);
}
/* Go on to next step */
ctx = g_task_get_task_data (task);
ctx->step++;
interface_enabling_step (task);
}
static void
interface_enabling_step (GTask *task)
{
MMIfaceModemCdma *self;
EnablingContext *ctx;
/* Don't run new steps if we're cancelled */
if (g_task_return_error_if_cancelled (task)) {
g_object_unref (task);
return;
}
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case ENABLING_STEP_FIRST:
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_SETUP_UNSOLICITED_EVENTS:
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_unsolicited_events &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_unsolicited_events_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->setup_unsolicited_events (
self,
(GAsyncReadyCallback)setup_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_ENABLE_UNSOLICITED_EVENTS:
if (MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->enable_unsolicited_events &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->enable_unsolicited_events_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->enable_unsolicited_events (
self,
(GAsyncReadyCallback)enable_unsolicited_events_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_PERIODIC_REGISTRATION_CHECKS:
periodic_registration_check_enable (self);
/* Fall down to next step */
ctx->step++;
case ENABLING_STEP_LAST:
/* We are done without errors! */
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
void
mm_iface_modem_cdma_enable (MMIfaceModemCdma *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
EnablingContext *ctx;
GTask *task;
ctx = g_new0 (EnablingContext, 1);
ctx->step = ENABLING_STEP_FIRST;
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)enabling_context_free);
g_object_get (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &ctx->skeleton,
NULL);
if (!ctx->skeleton) {
g_task_return_new_error (task,
MM_CORE_ERROR,
MM_CORE_ERROR_FAILED,
"Couldn't get interface skeleton");
g_object_unref (task);
return;
}
interface_enabling_step (task);
}
/*****************************************************************************/
typedef struct _InitializationContext InitializationContext;
static void interface_initialization_step (GTask *task);
typedef enum {
INITIALIZATION_STEP_FIRST,
INITIALIZATION_STEP_MEID,
INITIALIZATION_STEP_ESN,
INITIALIZATION_STEP_ACTIVATION_STATE,
INITIALIZATION_STEP_LAST
} InitializationStep;
struct _InitializationContext {
MmGdbusModemCdma *skeleton;
InitializationStep step;
};
static void
initialization_context_free (InitializationContext *ctx)
{
g_object_unref (ctx->skeleton);
g_free (ctx);
}
#undef STR_REPLY_READY_FN
#define STR_REPLY_READY_FN(NAME,DISPLAY) \
static void \
load_##NAME##_ready (MMIfaceModemCdma *self, \
GAsyncResult *res, \
GTask *task) \
{ \
InitializationContext *ctx; \
GError *error = NULL; \
gchar *val; \
\
ctx = g_task_get_task_data (task); \
\
val = MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_##NAME##_finish (self, res, &error); \
mm_gdbus_modem_cdma_set_##NAME (ctx->skeleton, val); \
g_free (val); \
\
if (error) { \
mm_warn ("couldn't load %s: '%s'", DISPLAY, error->message); \
g_error_free (error); \
} \
\
/* Go on to next step */ \
ctx->step++; \
interface_initialization_step (task); \
}
STR_REPLY_READY_FN (meid, "MEID")
STR_REPLY_READY_FN (esn, "ESN")
static void
load_activation_state_ready (MMIfaceModemCdma *self,
GAsyncResult *res,
GTask *task)
{
InitializationContext *ctx;
GError *error = NULL;
MMModemCdmaActivationState state;
ctx = g_task_get_task_data (task);
state = MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_activation_state_finish (self, res, &error);
mm_gdbus_modem_cdma_set_activation_state (ctx->skeleton, state);
if (error) {
mm_warn ("couldn't load activation state: '%s'", error->message);
g_error_free (error);
}
/* Go on to next step */
ctx->step++;
interface_initialization_step (task);
}
static void
interface_initialization_step (GTask *task)
{
MMIfaceModemCdma *self;
InitializationContext *ctx;
/* Don't run new steps if we're cancelled */
if (g_task_return_error_if_cancelled (task)) {
g_object_unref (task);
return;
}
self = g_task_get_source_object (task);
ctx = g_task_get_task_data (task);
switch (ctx->step) {
case INITIALIZATION_STEP_FIRST:
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_MEID:
/* MEID value is meant to be loaded only once during the whole
* lifetime of the modem. Therefore, if we already have it loaded,
* don't try to load it again. */
if (!mm_gdbus_modem_cdma_get_meid (ctx->skeleton) &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_meid &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_meid_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_meid (
self,
(GAsyncReadyCallback)load_meid_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_ESN:
/* ESN value is meant to be loaded only once during the whole
* lifetime of the modem. Therefore, if we already have it loaded,
* don't try to load it again. */
if (!mm_gdbus_modem_cdma_get_esn (ctx->skeleton) &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_esn &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_esn_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_esn (
self,
(GAsyncReadyCallback)load_esn_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_ACTIVATION_STATE:
/* Initial activation state is meant to be loaded only once during the
* whole lifetime of the modem. Therefore, if we already have it loaded,
* don't try to load it again. */
if (mm_gdbus_modem_cdma_get_activation_state (ctx->skeleton) == MM_MODEM_CDMA_ACTIVATION_STATE_UNKNOWN &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_activation_state &&
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_activation_state_finish) {
MM_IFACE_MODEM_CDMA_GET_INTERFACE (self)->load_activation_state (
self,
(GAsyncReadyCallback)load_activation_state_ready,
task);
return;
}
/* Fall down to next step */
ctx->step++;
case INITIALIZATION_STEP_LAST:
/* We are done without errors! */
/* Handle method invocations */
g_signal_connect (ctx->skeleton,
"handle-activate",
G_CALLBACK (handle_activate),
self);
g_signal_connect (ctx->skeleton,
"handle-activate-manual",
G_CALLBACK (handle_activate_manual),
self);
/* Finally, export the new interface */
mm_gdbus_object_skeleton_set_modem_cdma (MM_GDBUS_OBJECT_SKELETON (self),
MM_GDBUS_MODEM_CDMA (ctx->skeleton));
g_task_return_boolean (task, TRUE);
g_object_unref (task);
return;
}
g_assert_not_reached ();
}
gboolean
mm_iface_modem_cdma_initialize_finish (MMIfaceModemCdma *self,
GAsyncResult *res,
GError **error)
{
return g_task_propagate_boolean (G_TASK (res), error);
}
void
mm_iface_modem_cdma_initialize (MMIfaceModemCdma *self,
GCancellable *cancellable,
GAsyncReadyCallback callback,
gpointer user_data)
{
InitializationContext *ctx;
MmGdbusModemCdma *skeleton = NULL;
GTask *task;
/* Did we already create it? */
g_object_get (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, &skeleton,
NULL);
if (!skeleton) {
skeleton = mm_gdbus_modem_cdma_skeleton_new ();
/* Set all initial property defaults */
mm_gdbus_modem_cdma_set_meid (skeleton, NULL);
mm_gdbus_modem_cdma_set_esn (skeleton, NULL);
mm_gdbus_modem_cdma_set_sid (skeleton, MM_MODEM_CDMA_SID_UNKNOWN);
mm_gdbus_modem_cdma_set_nid (skeleton, MM_MODEM_CDMA_NID_UNKNOWN);
mm_gdbus_modem_cdma_set_activation_state (skeleton, MM_MODEM_CDMA_ACTIVATION_STATE_UNKNOWN);
/* Bind our Registration State properties */
g_object_bind_property (self, MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE,
skeleton, "cdma1x-registration-state",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_bind_property (self, MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE,
skeleton, "evdo-registration-state",
G_BINDING_DEFAULT | G_BINDING_SYNC_CREATE);
g_object_set (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, skeleton,
NULL);
}
/* Perform async initialization here */
ctx = g_new0 (InitializationContext, 1);
ctx->step = INITIALIZATION_STEP_FIRST;
ctx->skeleton = skeleton;
task = g_task_new (self, cancellable, callback, user_data);
g_task_set_task_data (task, ctx, (GDestroyNotify)initialization_context_free);
interface_initialization_step (task);
}
void
mm_iface_modem_cdma_shutdown (MMIfaceModemCdma *self)
{
/* Remove RegistrationCheckContext object to make sure any pending
* invocation of periodic_registration_check is cancelled before the
* DBus skeleton is removed. */
if (G_LIKELY (registration_check_context_quark))
g_object_set_qdata (G_OBJECT (self),
registration_check_context_quark,
NULL);
/* Unexport DBus interface and remove the skeleton */
mm_gdbus_object_skeleton_set_modem_cdma (MM_GDBUS_OBJECT_SKELETON (self), NULL);
g_object_set (self,
MM_IFACE_MODEM_CDMA_DBUS_SKELETON, NULL,
NULL);
}
/*****************************************************************************/
static void
iface_modem_cdma_init (gpointer g_iface)
{
static gboolean initialized = FALSE;
if (initialized)
return;
/* Properties */
g_object_interface_install_property
(g_iface,
g_param_spec_object (MM_IFACE_MODEM_CDMA_DBUS_SKELETON,
"CDMA DBus skeleton",
"DBus skeleton for the CDMA interface",
MM_GDBUS_TYPE_MODEM_CDMA_SKELETON,
G_PARAM_READWRITE));
g_object_interface_install_property
(g_iface,
g_param_spec_enum (MM_IFACE_MODEM_CDMA_CDMA1X_REGISTRATION_STATE,
"CDMA1x Registration State",
"Registration state of the modem in the CDMA1x network",
MM_TYPE_MODEM_CDMA_REGISTRATION_STATE,
MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
G_PARAM_READWRITE));
g_object_interface_install_property
(g_iface,
g_param_spec_enum (MM_IFACE_MODEM_CDMA_EVDO_REGISTRATION_STATE,
"EV-DO Registration State",
"Registration state of the modem in the EV-DO network",
MM_TYPE_MODEM_CDMA_REGISTRATION_STATE,
MM_MODEM_CDMA_REGISTRATION_STATE_UNKNOWN,
G_PARAM_READWRITE));
g_object_interface_install_property
(g_iface,
g_param_spec_boolean (MM_IFACE_MODEM_CDMA_CDMA1X_NETWORK_SUPPORTED,
"CDMA1x network supported",
"Whether the modem works in the CDMA1x network",
TRUE,
G_PARAM_READWRITE));
g_object_interface_install_property
(g_iface,
g_param_spec_boolean (MM_IFACE_MODEM_CDMA_EVDO_NETWORK_SUPPORTED,
"EV-DO network supported",
"Whether the modem works in the EV-DO network",
TRUE,
G_PARAM_READWRITE));
initialized = TRUE;
}
GType
mm_iface_modem_cdma_get_type (void)
{
static GType iface_modem_cdma_type = 0;
if (!G_UNLIKELY (iface_modem_cdma_type)) {
static const GTypeInfo info = {
sizeof (MMIfaceModemCdma), /* class_size */
iface_modem_cdma_init, /* base_init */
NULL, /* base_finalize */
};
iface_modem_cdma_type = g_type_register_static (G_TYPE_INTERFACE,
"MMIfaceModemCdma",
&info,
0);
g_type_interface_add_prerequisite (iface_modem_cdma_type, MM_TYPE_IFACE_MODEM);
}
return iface_modem_cdma_type;
}