static void cfun_disable_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct he910_data *data = ofono_modem_get_data(modem);
DBG("%p", modem);
g_at_chat_unref(data->chat);
data->chat = NULL;
if (ok)
ofono_modem_set_powered(modem, FALSE);
}
static void rsen_enable_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct telit_data *data = ofono_modem_get_data(modem);
DBG("%p", modem);
if (!ok) {
ofono_modem_set_powered(data->sap_modem, FALSE);
sap_close_io(modem);
return;
}
}
static void mux_setup_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
int fd;
DBG("");
if (data->mux_init_timeout > 0) {
g_source_remove(data->mux_init_timeout);
data->mux_init_timeout = 0;
}
g_at_chat_unref(data->dlcs[AUX_DLC]);
data->dlcs[AUX_DLC] = NULL;
if (!ok)
goto error;
if (data->mux_ldisc < 0) {
ofono_info("Using internal multiplexer");
setup_internal_mux(modem);
return;
}
fd = g_io_channel_unix_get_fd(data->device);
if (ioctl(fd, TIOCGETD, &data->saved_ldisc) < 0) {
ofono_error("Failed to get current line discipline");
goto error;
}
if (ioctl(fd, TIOCSETD, &data->mux_ldisc) < 0) {
ofono_error("Failed to set multiplexer line discipline");
goto error;
}
data->dlc_poll_count = 0;
data->dlc_poll_source = g_timeout_add_seconds(1, dlc_ready_check,
modem);
return;
error:
data->saved_ldisc = -1;
g_io_channel_unref(data->device);
data->device = NULL;
ofono_modem_set_powered(modem, FALSE);
}
static void cfun_enable(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct sierra_data *data = ofono_modem_get_data(modem);
DBG("");
if (!ok) {
g_at_chat_unref(data->modem);
data->modem = NULL;
}
ofono_modem_set_powered(modem, ok);
}
static void ril_connected(struct ril_msg *message, gpointer user_data)
{
struct ofono_modem *modem = (struct ofono_modem *) user_data;
struct ril_data *ril = ofono_modem_get_data(modem);
ofono_info("[UNSOL]< %s", ril_unsol_request_to_string(message->req));
/* TODO: need a disconnect function to restart things! */
ril->connected = TRUE;
DBG("calling set_powered(TRUE)");
ofono_modem_set_powered(modem, TRUE);
}
static void sim_inserted(struct ril_msg *message, gpointer user_data)
{
struct ofono_modem *modem = (struct ofono_modem *) user_data;
struct mtk_data *md = ofono_modem_get_data(modem);
DBG("");
g_ril_print_unsol_no_args(md->ril, message);
if (getenv("OFONO_RIL_HOT_SIM_SWAP")) {
ofono_modem_set_powered(modem, FALSE);
g_idle_add(mtk_connected, modem);
}
}
static void sim_removed(struct ril_msg *message, gpointer user_data)
{
struct ofono_modem *modem = (struct ofono_modem *) user_data;
struct mtk_data *md = ofono_modem_get_data(modem);
DBG("");
g_ril_print_unsol_no_args(md->ril, message);
md->sim_plmn_type = MTK_PLMN_TYPE_UNKNOWN;
ofono_modem_set_powered(modem, FALSE);
g_idle_add(mtk_connected, modem);
}
static void slc_established(gpointer userdata)
{
struct ofono_modem *modem = userdata;
struct hfp_data *data = ofono_modem_get_data(modem);
DBusMessage *msg;
ofono_modem_set_powered(modem, TRUE);
msg = dbus_message_new_method_return(data->slc_msg);
g_dbus_send_message(connection, msg);
dbus_message_unref(data->slc_msg);
data->slc_msg = NULL;
ofono_info("Service level connection established");
}
static void cfun_enable(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
DBG("");
if (!ok) {
shutdown_device(data);
ofono_modem_set_powered(modem, FALSE);
return;
}
g_at_chat_send(data->dlcs[AUX_DLC], "AT+XGENDATA", xgendata_prefix,
xgendata_query, modem, NULL);
}
static void cfun_disable_cb(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct telit_data *data = ofono_modem_get_data(modem);
DBG("%p", modem);
g_at_chat_unref(data->chat);
data->chat = NULL;
if (data->sim_inserted_source > 0)
g_source_remove(data->sim_inserted_source);
if (ok)
ofono_modem_set_powered(modem, FALSE);
}
static void hfp_disconnected_cb(gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct hfp *hfp = ofono_modem_get_data(modem);
struct hfp_slc_info *info = &hfp->info;
DBG("HFP disconnected");
ofono_modem_set_powered(modem, FALSE);
ofono_handsfree_card_remove(hfp->card);
hfp->card = NULL;
g_at_chat_unref(info->chat);
info->chat = NULL;
}
static void sim_status_cb(struct ril_msg *message, gpointer user_data)
{
DBG("error=%d", message->error);
struct ofono_modem *modem = user_data;
struct ril_data *ril = ofono_modem_get_data(modem);
struct sim_status status;
struct sim_app *apps[MAX_UICC_APPS];
/*
* ril.h claims this should NEVER fail!
* However this isn't quite true. So,
* on anything other than SUCCESS, we
* log an error, and schedule another
* GET_SIM_STATUS request.
*/
if (message->error != RIL_E_SUCCESS) {
ril->sim_status_retries++;
ofono_error("GET_SIM_STATUS reques failed: %d; retries: %d",
message->error, ril->sim_status_retries);
if (ril->sim_status_retries < MAX_SIM_STATUS_RETRIES)
ril->timer_id = g_timeout_add_seconds(2, (GSourceFunc)
send_get_sim_status,
(gpointer) modem);
else
ofono_error("Max retries for GET_SIM_STATUS exceeded!");
} else {
/* Returns TRUE if cardstate == PRESENT */
if (ril_util_parse_sim_status(ril->modem, message,
&status, apps)) {
if (status.num_apps)
ril_util_free_sim_apps(apps, status.num_apps);
} else {
ofono_warn("No SIM card present.");
}
/*
* We cannot power on modem, but we need to get
* certain interfaces up to be able to make emergency calls
* in offline mode and without SIM
*/
ofono_modem_set_powered(modem, TRUE);
}
}
static void cfun_disable(gboolean ok, GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
DBG("");
if (data->dlc_poll_source > 0) {
g_source_remove(data->dlc_poll_source);
data->dlc_poll_source = 0;
}
shutdown_device(data);
if (ok)
ofono_modem_set_powered(modem, FALSE);
}
static void slc_established(gpointer userdata)
{
struct ofono_modem *modem = userdata;
struct hfp *hfp = ofono_modem_get_data(modem);
DBusMessage *msg;
ofono_modem_set_powered(modem, TRUE);
msg = dbus_message_new_method_return(hfp->msg);
g_dbus_send_message(ofono_dbus_get_connection(), msg);
dbus_message_unref(hfp->msg);
hfp->msg = NULL;
ofono_info("Service level connection established");
ofono_handsfree_card_register(hfp->card);
}
static void phonesim_disconnected(gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct phonesim_data *data = ofono_modem_get_data(modem);
DBG("");
ofono_modem_set_powered(modem, FALSE);
g_at_chat_unref(data->chat);
data->chat = NULL;
if (data->mux) {
g_at_mux_shutdown(data->mux);
g_at_mux_unref(data->mux);
data->mux = NULL;
}
}
static gboolean dlc_ready_check(gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
struct stat st;
int i;
DBG("");
data->dlc_poll_count++;
if (stat(dlc_nodes[AUX_DLC], &st) < 0) {
/* only possible error is ENOENT */
if (data->dlc_poll_count > 6)
goto error;
return TRUE;
}
for (i = 0; i < NUM_DLC; i++) {
GIOChannel *channel = g_at_tty_open(dlc_nodes[i], NULL);
data->dlcs[i] = create_chat(channel, modem, dlc_prefixes[i]);
if (data->dlcs[i] == NULL) {
ofono_error("Failed to open %s", dlc_nodes[i]);
goto error;
}
}
data->dlc_poll_source = 0;
/* iterate through mainloop */
data->dlc_init_source = g_timeout_add_seconds(0, dlc_setup, modem);
return FALSE;
error:
data->dlc_poll_source = 0;
shutdown_device(data);
ofono_modem_set_powered(modem, FALSE);
return FALSE;
}
static gboolean mux_timeout_cb(gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct ifx_data *data = ofono_modem_get_data(modem);
ofono_error("Timeout with multiplexer setup");
data->mux_init_timeout = 0;
g_at_chat_unref(data->dlcs[AUX_DLC]);
data->dlcs[AUX_DLC] = NULL;
g_io_channel_unref(data->device);
data->device = NULL;
ofono_modem_set_powered(modem, FALSE);
return FALSE;
}
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 void slc_failed(gpointer userdata)
{
struct ofono_modem *modem = userdata;
struct hfp_data *data = ofono_modem_get_data(modem);
DBusMessage *msg;
msg = g_dbus_create_error(data->slc_msg, HFP_AGENT_ERROR_INTERFACE
".Failed",
"HFP Handshake failed");
g_dbus_send_message(connection, msg);
dbus_message_unref(data->slc_msg);
data->slc_msg = NULL;
ofono_error("Service level connection failed");
ofono_modem_set_powered(modem, FALSE);
g_at_chat_unref(data->info.chat);
data->info.chat = NULL;
}
static void mux_setup(GAtMux *mux, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct phonesim_data *data = ofono_modem_get_data(modem);
GIOChannel *io;
GAtSyntax *syntax;
DBG("%p", mux);
if (mux == NULL) {
ofono_modem_set_powered(modem, FALSE);
return;
}
data->mux = mux;
if (getenv("OFONO_AT_DEBUG"))
g_at_mux_set_debug(data->mux, phonesim_debug, "");
g_at_mux_start(mux);
io = g_at_mux_create_channel(mux);
if (data->calypso)
syntax = g_at_syntax_new_gsm_permissive();
else
syntax = g_at_syntax_new_gsmv1();
data->chat = g_at_chat_new(io, syntax);
g_at_syntax_unref(syntax);
g_io_channel_unref(io);
if (getenv("OFONO_AT_DEBUG"))
g_at_chat_set_debug(data->chat, phonesim_debug, "");
if (data->calypso)
g_at_chat_set_wakeup_command(data->chat, "AT\r", 500, 5000);
g_at_chat_send(data->chat, "ATE0", NULL, NULL, NULL, NULL);
g_at_chat_send(data->chat, "AT+CFUN=1", none_prefix,
cfun_set_on_cb, modem, NULL);
}
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 DBusMessage *profile_disconnection(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
struct ofono_modem *modem;
struct hfp *hfp;
const char *device;
struct hfp_slc_info *info;
DBusMessageIter entry;
DBG("Profile handler RequestDisconnection");
if (dbus_message_iter_init(msg, &entry) == FALSE)
goto error;
if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_OBJECT_PATH)
goto error;
dbus_message_iter_get_basic(&entry, &device);
modem = ofono_modem_find(device_path_compare, (void *) device);
if (modem == NULL)
goto error;
ofono_modem_set_powered(modem, FALSE);
hfp = ofono_modem_get_data(modem);
info = &hfp->info;
ofono_handsfree_card_remove(hfp->card);
hfp->card = NULL;
g_at_chat_unref(info->chat);
info->chat = NULL;
return dbus_message_new_method_return(msg);
error:
return g_dbus_create_error(msg,
BLUEZ_ERROR_INTERFACE ".Rejected",
"Invalid arguments in method call");
}
void ofono_modem_reset(struct ofono_modem *modem)
{
int err;
DBG("%p", modem);
if (modem->pending) {
DBusMessage *reply = __ofono_error_failed(modem->pending);
__ofono_dbus_pending_reply(&modem->pending, reply);
}
if (modem->modem_state == MODEM_STATE_ONLINE)
modem->get_online = TRUE;
ofono_modem_set_powered(modem, FALSE);
err = set_powered(modem, TRUE);
if (err == -EINPROGRESS)
return;
modem_change_state(modem, MODEM_STATE_PRE_SIM);
}
static void hfp_power_down(DBusPendingCall *call, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct hfp_data *data = ofono_modem_get_data(modem);
DBusMessage *reply;
DBusError derr;
reply = dbus_pending_call_steal_reply(call);
dbus_error_init(&derr);
if (dbus_set_error_from_message(&derr, reply)) {
DBG("Disconnect reply: %s", derr.message);
dbus_error_free(&derr);
goto done;
}
ofono_modem_set_powered(modem, FALSE);
done:
dbus_message_unref(reply);
data->call = NULL;
}
static void slc_failed(gpointer userdata)
{
struct ofono_modem *modem = userdata;
struct hfp *hfp = ofono_modem_get_data(modem);
struct hfp_slc_info *info = &hfp->info;
DBusMessage *msg;
msg = g_dbus_create_error(hfp->msg, BLUEZ_ERROR_INTERFACE
".Failed",
"HFP Handshake failed");
g_dbus_send_message(ofono_dbus_get_connection(), msg);
dbus_message_unref(hfp->msg);
hfp->msg = NULL;
ofono_error("Service level connection failed");
ofono_modem_set_powered(modem, FALSE);
ofono_handsfree_card_remove(hfp->card);
hfp->card = NULL;
g_at_chat_unref(info->chat);
info->chat = NULL;
}
static void telit_rsen_notify(GAtResult *result, gpointer user_data)
{
struct ofono_modem *modem = user_data;
struct telit_data *data = ofono_modem_get_data(modem);
int status;
GAtResultIter iter;
DBG("%p", modem);
g_at_result_iter_init(&iter, result);
if (!g_at_result_iter_next(&iter, "#RSEN:"))
return;
g_at_result_iter_next_number(&iter, &status);
if (status == 0) {
ofono_modem_set_powered(data->sap_modem, FALSE);
sap_close_io(modem);
return;
}
telit_enable(modem);
}
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 slc_established(gpointer userdata)
{
struct ofono_modem *modem = userdata;
ofono_modem_set_powered(modem, TRUE);
}
