/*
* Indicate oFono that a SMS driver is ready for operation
*
* This is called after ofono_sms_create() was done and the modem
* driver determined that a modem supports SMS correctly. Once this
* call succeeds, the D-BUS interface for SMS goes live.
*/
void ofono_sms_register(struct ofono_sms *sms)
{
DBusConnection *conn = ofono_dbus_get_connection();
struct ofono_modem *modem = __ofono_atom_get_modem(sms->atom);
const char *path = __ofono_atom_get_path(sms->atom);
struct ofono_sim *sim;
if (!g_dbus_register_interface(conn, path,
OFONO_MESSAGE_MANAGER_INTERFACE,
sms_manager_methods,
sms_manager_signals,
NULL, sms, NULL)) {
ofono_error("Could not create %s interface",
OFONO_MESSAGE_MANAGER_INTERFACE);
return;
}
ofono_modem_add_interface(modem, OFONO_MESSAGE_MANAGER_INTERFACE);
sms->mw_watch = __ofono_modem_add_atom_watch(modem,
OFONO_ATOM_TYPE_MESSAGE_WAITING,
mw_watch, sms, NULL);
sms->netreg_watch = __ofono_modem_add_atom_watch(modem,
OFONO_ATOM_TYPE_NETREG,
netreg_watch, sms, NULL);
sim = __ofono_atom_find(OFONO_ATOM_TYPE_SIM, modem);
/*
* If we have a sim atom, we can uniquely identify the SIM,
* otherwise create an sms assembly which doesn't backup the fragment
* store.
*/
if (sim) {
const char *imsi;
imsi = ofono_sim_get_imsi(sim);
sms->assembly = sms_assembly_new(imsi);
sms->sr_assembly = status_report_assembly_new(imsi);
sms_load_settings(sms, imsi);
} else {
sms->assembly = sms_assembly_new(NULL);
sms->sr_assembly = status_report_assembly_new(NULL);
sms->bearer = 3; /* Default to CS then PS */
}
if (sms->driver->bearer_set)
sms->driver->bearer_set(sms, sms->bearer,
bearer_init_callback, sms);
sms_restore_tx_queue(sms);
sms->text_handlers = __ofono_watchlist_new(g_free);
sms->datagram_handlers = __ofono_watchlist_new(g_free);
__ofono_atom_register(sms->atom, sms_unregister);
}
static void modem_watch(struct ofono_modem *modem, gboolean added, void *user)
{
DBG("modem: %p, added: %d", modem, added);
if (added == FALSE)
return;
__ofono_modem_add_atom_watch(modem, OFONO_ATOM_TYPE_SIM,
sim_watch, modem, NULL);
__ofono_modem_add_atom_watch(modem, OFONO_ATOM_TYPE_VOICECALL,
voicecall_watch, modem, NULL);
}
static void radio_settings_register(const struct ofono_error *error,
unsigned int available_rats,
void *data)
{
struct ofono_radio_settings *rs = data;
struct radio_data *rd = ofono_radio_settings_get_data(rs);
g_ril_register(rd->ril, RIL_UNSOL_RADIO_CAPABILITY,
radio_caps_event, rd);
rd->gprs_atom_watch =
__ofono_modem_add_atom_watch(rd->modem, OFONO_ATOM_TYPE_GPRS,
gprs_watch_cb, rs, NULL);
/*
* If the preferred technology was unknown/unsupported, change to a
* valid one (midori can return PREF_NET_TYPE_CDMA_ONLY, for instance).
* Changing to anything above GSM can prevent other radios restoring
* their settings.
*/
if (rd->rat_mode == OFONO_RADIO_ACCESS_MODE_ANY) {
struct cb_data *cbd = cb_data_new(set_safe_preferred_cb, rd,
rd->radio_settings);
set_preferred_network(rd, cbd, OFONO_RADIO_ACCESS_MODE_GSM);
}
/*
* We register in all cases, setting FD some times fails until radio is
* available (this happens on turbo and maybe in other devices).
*/
ofono_radio_settings_register(rs);
}
static void modem_watch(struct ofono_modem *modem, gboolean added, void *user)
{
DBG("modem: %p, added: %d", modem, added);
if (added == FALSE)
return;
__ofono_modem_add_atom_watch(modem, OFONO_ATOM_TYPE_GPRS,
gprs_watch, modem, NULL);
}
void ofono_devinfo_register(struct ofono_devinfo *info)
{
struct ofono_modem *modem = __ofono_atom_get_modem(info->atom);
__ofono_atom_register(info->atom, devinfo_unregister);
info->dun_watch = __ofono_modem_add_atom_watch(modem,
OFONO_ATOM_TYPE_EMULATOR_DUN,
dun_watch, info, NULL);
query_manufacturer(info);
}
static void modem_watch(struct ofono_modem *modem, gboolean added, void *user)
{
struct push_notification *pn;
DBG("modem: %p, added: %d", modem, added);
if (added == FALSE)
return;
pn = g_try_new0(struct push_notification, 1);
if (pn == NULL)
return;
pn->modem = modem;
__ofono_modem_add_atom_watch(modem, OFONO_ATOM_TYPE_SMS,
sms_watch, pn, g_free);
}
static void create_online_atoms(struct ofono_modem *modem)
{
struct mtk_data *md = ofono_modem_get_data(modem);
struct ril_radio_settings_driver_data rs_data = { md->ril, modem };
md->sim_data.gril = md->ril;
md->sim_data.modem = modem;
md->sim_data.ril_state_watch = sim_state_watch;
md->sim = ofono_sim_create(modem, OFONO_RIL_VENDOR_MTK,
RILMODEM, &md->sim_data);
g_assert(md->sim != NULL);
/* Radio settings does not depend on the SIM */
ofono_radio_settings_create(modem, OFONO_RIL_VENDOR_MTK,
MTKMODEM, &rs_data);
if (md->netreg_watch == 0)
md->netreg_watch =
__ofono_modem_add_atom_watch(modem,
OFONO_ATOM_TYPE_NETREG,
netreg_watch, modem, NULL);
}
int ofono_modem_register(struct ofono_modem *modem)
{
DBusConnection *conn = ofono_dbus_get_connection();
GSList *l;
DBG("%p", modem);
if (modem == NULL)
return -EINVAL;
if (powering_down == TRUE)
return -EBUSY;
if (modem->driver != NULL)
return -EALREADY;
for (l = g_driver_list; l; l = l->next) {
const struct ofono_modem_driver *drv = l->data;
if (g_strcmp0(drv->name, modem->driver_type))
continue;
if (drv->probe(modem) < 0)
continue;
modem->driver = drv;
break;
}
if (modem->driver == NULL)
return -ENODEV;
if (!g_dbus_register_interface(conn, modem->path,
OFONO_MODEM_INTERFACE,
modem_methods, modem_signals, NULL,
modem, NULL)) {
ofono_error("Modem register failed on path %s", modem->path);
if (modem->driver->remove)
modem->driver->remove(modem);
modem->driver = NULL;
return -EIO;
}
g_free(modem->driver_type);
modem->driver_type = NULL;
modem->atom_watches = __ofono_watchlist_new(g_free);
modem->online_watches = __ofono_watchlist_new(g_free);
modem->powered_watches = __ofono_watchlist_new(g_free);
emit_modem_added(modem);
call_modemwatches(modem, TRUE);
modem->sim_watch = __ofono_modem_add_atom_watch(modem,
OFONO_ATOM_TYPE_SIM,
sim_watch, modem, NULL);
return 0;
}
static int phonesim_enable(struct ofono_modem *modem)
{
struct phonesim_data *data = ofono_modem_get_data(modem);
GIOChannel *io;
GAtSyntax *syntax;
const char *address, *value;
int sk, port;
DBG("%p", modem);
address = ofono_modem_get_string(modem, "Address");
if (address == NULL)
return -EINVAL;
port = ofono_modem_get_integer(modem, "Port");
if (port < 0)
return -EINVAL;
value = ofono_modem_get_string(modem, "Modem");
if (!g_strcmp0(value, "calypso"))
data->calypso = TRUE;
value = ofono_modem_get_string(modem, "Multiplexer");
if (!g_strcmp0(value, "internal"))
data->use_mux = TRUE;
sk = connect_socket(address, port);
if (sk < 0)
return sk;
io = g_io_channel_unix_new(sk);
if (io == NULL) {
close(sk);
return -ENOMEM;
}
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 (data->chat == NULL)
return -ENOMEM;
if (getenv("OFONO_AT_DEBUG"))
g_at_chat_set_debug(data->chat, phonesim_debug, "");
g_at_chat_set_disconnect_function(data->chat,
phonesim_disconnected, modem);
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%CUNS=0",
NULL, NULL, NULL, NULL);
}
if (data->use_mux) {
g_at_chat_send(data->chat, "ATE0", NULL, NULL, NULL, NULL);
g_at_mux_setup_gsm0710(data->chat, mux_setup, modem, NULL);
g_at_chat_unref(data->chat);
data->chat = NULL;
return -EINPROGRESS;
}
g_at_chat_send(data->chat, "AT+CSCS=\"GSM\"", none_prefix,
NULL, NULL, NULL);
g_at_chat_register(data->chat, "+CRST:",
crst_notify, FALSE, modem, NULL);
g_at_chat_register(data->chat, "+CBC:",
cbc_notify, FALSE, modem, NULL);
g_at_chat_send(data->chat, "AT+CBC", none_prefix, NULL, NULL, NULL);
data->hfp_watch = __ofono_modem_add_atom_watch(modem,
OFONO_ATOM_TYPE_EMULATOR_HFP,
emulator_hfp_watch, data, NULL);
return 0;
}
