static int ril_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
void *data)
{
GRil *ril = data;
struct netreg_data *nd;
nd = g_new0(struct netreg_data, 1);
nd->ril = g_ril_clone(ril);
nd->vendor = vendor;
nd->tech = RADIO_TECH_UNKNOWN;
nd->time.sec = -1;
nd->time.min = -1;
nd->time.hour = -1;
nd->time.mday = -1;
nd->time.mon = -1;
nd->time.year = -1;
nd->time.dst = 0;
nd->time.utcoff = 0;
ofono_netreg_set_data(netreg, nd);
/*
* ofono_netreg_register() needs to be called after
* the driver has been set in ofono_netreg_create(),
* which calls this function. Most other drivers make
* some kind of capabilities query to the modem, and then
* call register in the callback; we use the idle loop here.
*/
g_idle_add(ril_delayed_register, netreg);
return 0;
}
static int ril_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
void *data)
{
GRil *ril = data;
struct netreg_data *nd;
nd = g_new0(struct netreg_data, 1);
nd->ril = g_ril_clone(ril);
nd->vendor = vendor;
nd->tech = -1;
nd->time.sec = -1;
nd->time.min = -1;
nd->time.hour = -1;
nd->time.mday = -1;
nd->time.mon = -1;
nd->time.year = -1;
nd->time.dst = 0;
nd->time.utcoff = 0;
ofono_netreg_set_data(netreg, nd);
/*
* TODO: analyze if capability check is needed
* and/or timer should be adjusted.
*
* ofono_netreg_register() needs to be called after
* the driver has been set in ofono_netreg_create(),
* which calls this function. Most other drivers make
* some kind of capabilities query to the modem, and then
* call register in the callback; we use a timer instead.
*/
g_timeout_add_seconds(1, ril_delayed_register, netreg);
return 0;
}
static int at_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
void *data)
{
GAtChat *chat = data;
struct netreg_data *nd;
nd = g_new0(struct netreg_data, 1);
nd->chat = g_at_chat_clone(chat);
nd->vendor = vendor;
nd->tech = -1;
nd->time.sec = -1;
nd->time.min = -1;
nd->time.hour = -1;
nd->time.mday = -1;
nd->time.mon = -1;
nd->time.year = -1;
nd->time.dst = 0;
nd->time.utcoff = 0;
ofono_netreg_set_data(netreg, nd);
g_at_chat_send(nd->chat, "AT+CREG=?", creg_prefix,
at_creg_test_cb, netreg, NULL);
return 0;
}
static void hfp_netreg_remove(struct ofono_netreg *netreg)
{
struct netreg_data *nd = ofono_netreg_get_data(netreg);
ofono_netreg_set_data(netreg, NULL);
g_free(nd);
}
static void ril_netreg_remove(struct ofono_netreg *netreg)
{
struct netreg_data *nd = ofono_netreg_get_data(netreg);
if (nd->nitz_timeout)
g_source_remove(nd->nitz_timeout);
ofono_netreg_set_data(netreg, NULL);
g_ril_unref(nd->ril);
g_free(nd);
}
static void hfp_netreg_remove(struct ofono_netreg *netreg)
{
struct netreg_data *nd = ofono_netreg_get_data(netreg);
if (nd->register_source != 0)
g_source_remove(nd->register_source);
ofono_netreg_set_data(netreg, NULL);
g_at_chat_unref(nd->chat);
g_free(nd);
}
static int hfp_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
void *user_data)
{
struct hfp_slc_info *info = user_data;
struct netreg_data *nd;
nd = g_new0(struct netreg_data, 1);
nd->chat = g_at_chat_clone(info->chat);
memcpy(nd->cind_pos, info->cind_pos, HFP_INDICATOR_LAST);
memcpy(nd->cind_val, info->cind_val, HFP_INDICATOR_LAST);
ofono_netreg_set_data(netreg, nd);
nd->register_source = g_idle_add(hfp_netreg_register, netreg);
return 0;
}
static int hfp_netreg_probe(struct ofono_netreg *netreg, unsigned int vendor,
void *user_data)
{
struct hfp_data *data = user_data;
struct netreg_data *nd;
nd = g_new0(struct netreg_data, 1);
nd->chat = data->chat;
memcpy(nd->cind_pos, data->cind_pos, HFP_INDICATOR_LAST);
memcpy(nd->cind_val, data->cind_val, HFP_INDICATOR_LAST);
ofono_netreg_set_data(netreg, nd);
g_at_chat_register(nd->chat, "+CIEV:", ciev_notify, FALSE,
netreg, NULL);
g_idle_add(hfp_netreg_register, netreg);
return 0;
}
static void create_nas_cb(struct qmi_service *service, void *user_data)
{
struct ofono_netreg *netreg = user_data;
struct netreg_data *data = ofono_netreg_get_data(netreg);
struct qmi_param *param;
struct qmi_nas_param_event_signal_strength ss = { .report = 0x01,
.count = 5, .dbm[0] = -55, .dbm[1] = -65,
.dbm[2] = -75, .dbm[3] = -85, .dbm[4] = -95 };
DBG("");
if (!service) {
ofono_error("Failed to request NAS service");
ofono_netreg_remove(netreg);
return;
}
data->nas = qmi_service_ref(service);
qmi_service_register(data->nas, QMI_NAS_EVENT,
event_notify, netreg, NULL);
qmi_service_register(data->nas, QMI_NAS_SS_INFO_IND,
ss_info_notify, netreg, NULL);
param = qmi_param_new();
if (!param)
goto done;
qmi_param_append(param, QMI_NAS_PARAM_REPORT_SIGNAL_STRENGTH,
sizeof(ss), &ss);
qmi_param_append_uint8(param, QMI_NAS_PARAM_REPORT_RF_INFO, 0x01);
if (qmi_service_send(data->nas, QMI_NAS_SET_EVENT, param,
set_event_cb, netreg, NULL) > 0)
return;
qmi_param_free(param);
done:
ofono_netreg_register(netreg);
}
static int qmi_netreg_probe(struct ofono_netreg *netreg,
unsigned int vendor, void *user_data)
{
struct qmi_device *device = user_data;
struct netreg_data *data;
DBG("");
data = g_new0(struct netreg_data, 1);
data->operator.name[0] = '\0';
data->operator.mcc[0] = '\0';
data->operator.mnc[0] = '\0';
data->operator.status = -1;
data->operator.tech = -1;
data->current_rat = QMI_NAS_NETWORK_RAT_NO_CHANGE;
ofono_netreg_set_data(netreg, data);
qmi_service_create_shared(device, QMI_SERVICE_NAS,
create_nas_cb, netreg, NULL);
return 0;
}
static void qmi_netreg_remove(struct ofono_netreg *netreg)
{
struct netreg_data *data = ofono_netreg_get_data(netreg);
DBG("");
ofono_netreg_set_data(netreg, NULL);
qmi_service_unregister_all(data->nas);
qmi_service_unref(data->nas);
g_free(data);
}
static struct ofono_netreg_driver driver = {
.name = "qmimodem",
.probe = qmi_netreg_probe,
.remove = qmi_netreg_remove,
.registration_status = qmi_registration_status,
.current_operator = qmi_current_operator,
.list_operators = qmi_list_operators,
.register_auto = qmi_register_auto,
.register_manual = qmi_register_manual,
.strength = qmi_signal_strength,
};
void qmi_netreg_init(void)
{
ofono_netreg_driver_register(&driver);
}
void qmi_netreg_exit(void)
{
ofono_netreg_driver_unregister(&driver);
}
