void ofono_power_set(struct telephony_service *service, bool power, telephony_result_cb cb, void *data)
{
struct cb_data *cbd = cb_data_new(cb, data);
struct ofono_data *od = telephony_service_get_data(service);
bool powered = false;
struct telephony_error error;
if (od->power_set_pending) {
error.code = TELEPHONY_ERROR_ALREADY_INPROGRESS;
cb(&error, data);
return;
}
od->power_set_pending = true;
od->power_target = power;
cbd->user = od;
powered = ofono_modem_get_powered(od->modem);
if (!powered) {
ofono_modem_set_powered(od->modem, power, set_powered_cb, cbd);
}
else {
ofono_modem_set_online(od->modem, power, set_online_cb, cbd);
}
}
void ofono_power_query(struct telephony_service *service, telephony_power_query_cb cb, void *data)
{
bool powered = false;
struct ofono_data *od = telephony_service_get_data(service);
struct telephony_error error;
if (!od->modem) {
error.code = TELEPHONY_ERROR_INTERNAL;
cb(&error, false, data);
return;
}
powered = ofono_modem_get_powered(od->modem) &&
ofono_modem_get_online(od->modem);
cb(NULL, powered, data);
}
static void sap_connect_reply(DBusPendingCall *call, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct sap_data *data = ofono_modem_get_data(modem);
DBusError derr;
DBusMessage *reply;
int fd, err;
DBG("");
reply = dbus_pending_call_steal_reply(call);
data->call = NULL;
if (ofono_modem_get_powered(modem))
goto done;
dbus_error_init(&derr);
if (dbus_set_error_from_message(&derr, reply)) {
DBG("Connect reply: %s", derr.message);
dbus_error_free(&derr);
goto done;
}
if (!dbus_message_get_args(reply, NULL, DBUS_TYPE_UNIX_FD, &fd,
DBUS_TYPE_INVALID))
goto done;
data->hw_modem = sap_hw_modem;
data->sap_driver = sap_hw_driver;
err = data->sap_driver->enable(data->hw_modem, modem, fd);
if (!err || err == -EINPROGRESS) {
dbus_message_unref(reply);
return;
}
done:
ofono_modem_set_powered(modem, FALSE);
dbus_message_unref(reply);
}
static gboolean mtk_connected(gpointer user_data)
{
struct ofono_modem *modem = (struct ofono_modem *) user_data;
struct mtk_data *md = ofono_modem_get_data(modem);
ofono_info("[slot %d] CONNECTED", md->slot);
DBG("calling set_powered(TRUE)");
if (!ofono_modem_get_powered(modem))
ofono_modem_set_powered(modem, TRUE);
create_atoms_on_connection(modem);
if (md->pending_cb)
md->pending_cb(md->pending_cbd);
/* Call the function just once */
return FALSE;
}
static void modem_watch(struct ofono_modem *modem, gboolean added, void *user)
{
DBG("modem: %p, added: %d", modem, added);
if (added == FALSE) {
DBG("Removing modem %p from the list", modem);
modems = g_list_remove(modems, modem);
return;
}
if (ofono_modem_get_powered(modem) == TRUE) {
DBG("Adding modem %p to the list", modem);
modems = g_list_append(modems, modem);
if (modems->next == NULL) {
create_tcp(DUN_PORT, OFONO_EMULATOR_TYPE_DUN);
create_tcp(HFP_PORT, OFONO_EMULATOR_TYPE_HFP);
}
}
__ofono_modem_add_powered_watch(modem, powered_watch, NULL, NULL);
}
static void hfp_connect_reply(DBusPendingCall *call, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct hfp_data *data = ofono_modem_get_data(modem);
DBusError derr;
DBusMessage *reply, *msg;
reply = dbus_pending_call_steal_reply(call);
if (ofono_modem_get_powered(modem))
goto done;
dbus_error_init(&derr);
if (!dbus_set_error_from_message(&derr, reply))
goto done;
DBG("Connect reply: %s", derr.message);
if (dbus_error_has_name(&derr, DBUS_ERROR_NO_REPLY)) {
msg = dbus_message_new_method_call(BLUEZ_SERVICE,
data->handsfree_path,
BLUEZ_GATEWAY_INTERFACE, "Disconnect");
if (msg == NULL)
ofono_error("Disconnect failed");
else
g_dbus_send_message(connection, msg);
}
ofono_modem_set_powered(modem, FALSE);
dbus_error_free(&derr);
done:
dbus_message_unref(reply);
data->call = NULL;
}
static void test_modem_get_powered()
{
ofono_modem_get_powered(g_modem);
}
static void state_change(struct ste_modem *stemodem, enum ste_operation op)
{
switch (stemodem->state) {
case STE_STATE_OFF:
/*
* The STE Modem is in state OFF and we're waiting for
* the Modem Init Daemon to signal that modem is ready
* in order to create and register the modem.
*/
switch (op) {
case STE_OP_READY:
stemodem->modem = ofono_modem_create(stemodem->serial,
"ste");
if (stemodem->modem == NULL) {
ofono_error("Could not create modem %s, %s",
stemodem->path,
stemodem->serial);
return;
}
DBG("register modem %s, %s", stemodem->path,
stemodem->serial);
if (stemodem->interface != NULL)
ofono_modem_set_string(stemodem->modem,
"Interface",
stemodem->interface);
ofono_modem_register(stemodem->modem);
stemodem->state = STE_STATE_READY;
break;
case STE_OP_STARTING:
case STE_OP_RESTART:
case STE_OP_OFF:
break;
}
break;
case STE_STATE_READY:
/*
* The STE Modem is ready and the modem has been created
* and registered in oFono. In this state two things can
* happen: Modem restarts or is turned off. Turning off
* the modem is an exceptional situation e.g. high-temperature,
* low battery or upgrade. In this scenario we remove the
* STE modem from oFono.
*/
switch (op) {
case STE_OP_READY:
break;
case STE_OP_STARTING:
case STE_OP_RESTART:
DBG("reset ongoing %s", stemodem->path);
/* Note: Consider to power off modem here? */
stemodem->state = STE_STATE_RESET;
break;
case STE_OP_OFF:
DBG("STE modem unregistering %s", stemodem->path);
ofono_modem_remove(stemodem->modem);
stemodem->modem = NULL;
stemodem->state = STE_STATE_OFF;
break;
}
break;
case STE_STATE_RESET:
/*
* The STE Modem is resetting.In this state two things can
* happen: Modem restarts succeeds, or modem is turned off.
*/
switch (op) {
case STE_OP_STARTING:
case STE_OP_RESTART:
break;
case STE_OP_READY:
DBG("STE modem reset complete %s", stemodem->path);
if (ofono_modem_get_powered(stemodem->modem))
ofono_modem_reset(stemodem->modem);
stemodem->state = STE_STATE_READY;
break;
case STE_OP_OFF:
DBG("STE modem unregistering %s", stemodem->path);
ofono_modem_remove(stemodem->modem);
stemodem->modem = NULL;
stemodem->state = STE_STATE_OFF;
break;
}
break;
}
}
static void modem_prop_changed_cb(const gchar *name, void *data)
{
struct ofono_data *od = data;
bool powered = false, online = false;
const char *path = ofono_modem_get_path(od->modem);
if (g_str_equal(name, "Online")) {
online = ofono_modem_get_online(od->modem);
telephony_service_power_status_notify(od->service, online);
}
else if (g_str_equal(name, "Interfaces")) {
if (!od->sim && ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_SIM_MANAGER)) {
od->sim = ofono_sim_manager_create(path);
ofono_sim_manager_register_prop_changed_handler(od->sim, sim_prop_changed_cb, od);
}
else if (od->sim && !ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_SIM_MANAGER)) {
ofono_sim_manager_free(od->sim);
od->sim = NULL;
}
if (!od->netreg && ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_NETWORK_REGISTRATION)) {
od->netreg = ofono_network_registration_create(path);
ofono_network_registration_register_prop_changed_handler(od->netreg, network_prop_changed_cb, od);
}
else if (od->netreg && !ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_NETWORK_REGISTRATION)) {
ofono_network_registration_free(od->netreg);
od->netreg = NULL;
notify_no_network_registration(od->service);
}
if (!od->rs && ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_RADIO_SETTINGS)) {
od->rs = ofono_radio_settings_create(path);
}
else if (od->rs && !ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_RADIO_SETTINGS)) {
ofono_radio_settings_free(od->rs);
od->rs = NULL;
}
if (!od->vm && ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_VOICE_CALL_MANAGER)) {
od->vm = ofono_voicecall_manager_create(path);
}
else if (od->vm && !ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_VOICE_CALL_MANAGER)) {
ofono_voicecall_manager_free(od->vm);
od->vm = NULL;
}
if (!od->mm && ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_MESSAGE_MANAGER)) {
od->mm = ofono_message_manager_create(path);
ofono_message_manager_set_incoming_message_callback(od->mm, incoming_message_cb, od);
}
else if (od->mm && !ofono_modem_is_interface_supported(od->modem, OFONO_MODEM_INTERFACE_MESSAGE_MANAGER)) {
ofono_message_manager_free(od->mm);
od->mm = NULL;
}
}
else if (g_str_equal(name, "Powered")) {
powered = ofono_modem_get_powered(od->modem);
/* We need to handle power status changes differently when in initialization phase */
if (od->initializing && powered) {
telephony_service_availability_changed_notify(od->service, true);
od->initializing = false;
}
telephony_service_power_status_notify(od->service, powered);
}
}
