static int ril_voicecall_probe(struct ofono_voicecall *vc, unsigned int vendor, void *data) { GRil *ril = data; struct voicecall_data *vd; vd = g_try_new0(struct voicecall_data, 1); if (vd == NULL) return -ENOMEM; vd->ril = g_ril_clone(ril); vd->vendor = vendor; vd->tone_duration = TONE_DURATION; ofono_voicecall_set_data(vc, vd); /* * TODO: analyze if capability check is needed * and/or timer should be adjusted. * * ofono_voicecall_register() needs to be called after * the driver has been set in ofono_voicecall_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(2, ril_delayed_register, vc); 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 ril_gprs_probe(struct ofono_gprs *gprs, unsigned int vendor, void *data) { GRil *ril = data; struct gprs_data *gd; gd = g_try_new0(struct gprs_data, 1); if (gd == NULL) return -ENOMEM; gd->ril = g_ril_clone(ril); gd->ofono_attached = FALSE; gd->max_cids = 0; gd->rild_status = -1; gd->true_status = -1; gd->notified = FALSE; gd->registerid = -1; gd->timer_id = 0; gd->fake_timer_id = 0; gd->fake_cbd = NULL; registered = FALSE; ofono_gprs_set_data(gprs, gd); ril_gprs_registration_status(gprs, NULL, NULL); return 0; }
static int ril_sms_probe(struct ofono_sms *sms, unsigned int vendor, void *user) { GRil *ril = user; struct sms_data *data; data = g_new0(struct sms_data, 1); data->ril = g_ril_clone(ril); data->vendor = vendor; ofono_sms_set_data(sms, data); /* * TODO: analyze if capability check is needed * and/or timer should be adjusted. * * ofono_sms_register() needs to be called after * the driver has been set in ofono_sms_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. */ data->timer_id = g_timeout_add_seconds(2, ril_delayed_register, sms); return 0; }
static int ril_devinfo_probe(struct ofono_devinfo *info, unsigned int vendor, void *data) { GRil *ril = NULL; if (data != NULL) ril = g_ril_clone(data); ofono_devinfo_set_data(info, ril); DBG(""); /* * TODO: analyze if capability check is needed * and/or timer should be adjusted. * * ofono_devinfo_register() needs to be called after * the driver has been set in ofono_devinfo_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, info); return 0; }
static int ril_call_volume_probe(struct ofono_call_volume *cv, unsigned int vendor, void *data) { GRil *ril = data; struct cv_data *cvd; cvd = g_new0(struct cv_data, 1); if (cvd == NULL) return -ENOMEM; cvd->ril = g_ril_clone(ril); cvd->vendor = vendor; ofono_call_volume_set_data(cv, cvd); /* * ofono_call_volume_register() needs to be called after * the driver has been set in ofono_call_volume_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 an idle event instead. */ g_idle_add(ril_delayed_register, cv); 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 = 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_sim_probe(struct ofono_sim *sim, unsigned int vendor, void *data) { GRil *ril = data; struct sim_data *sd; int i; DBG(""); sd = g_new0(struct sim_data, 1); sd->ril = g_ril_clone(ril); for (i = 0; i < OFONO_SIM_PASSWORD_INVALID; i++) sd->retries[i] = -1; current_sim = sim; ofono_sim_set_data(sim, sd); /* * TODO: analyze if capability check is needed * and/or timer should be adjusted. * * ofono_sim_register() needs to be called after the * driver has been set in ofono_sim_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 an idle event * instead. */ sd->idle_id = g_idle_add(ril_sim_register, sim); return 0; }
static int ril_ussd_probe(struct ofono_ussd *ussd, unsigned int vendor, void *user) { GRil *ril = user; struct ussd_data *ud = g_try_new0(struct ussd_data, 1); ud->ril = g_ril_clone(ril); ofono_ussd_set_data(ussd, ud); ud->timer_id = g_timeout_add_seconds(2, ril_delayed_register, ussd); return 0; }
static int ril_call_barring_probe(struct ofono_call_barring *cb, unsigned int vendor, void *user) { GRil *ril = user; struct barring_data *bd = g_try_new0(struct barring_data, 1); bd->ril = g_ril_clone(ril); ofono_call_barring_set_data(cb, bd); bd->timer_id = g_timeout_add_seconds(2, ril_delayed_register, cb); return 0; }
static int ril_radio_settings_probe(struct ofono_radio_settings *rs, unsigned int vendor, void *user) { GRil *ril = user; struct radio_data *rsd = g_try_new0(struct radio_data, 1); rsd->ril = g_ril_clone(ril); ofono_radio_settings_set_data(rs, rsd); g_timeout_add_seconds(2, ril_delayed_register, rs); return 0; }
static int ril_call_settings_probe(struct ofono_call_settings *cs, unsigned int vendor, void *user) { GRil *ril = user; struct settings_data *sd = g_new0(struct settings_data, 1); sd->ril = g_ril_clone(ril); ofono_call_settings_set_data(cs, sd); g_idle_add(ril_delayed_register, cs); return 0; }
static int ril_netmon_probe(struct ofono_netmon *netmon, unsigned int vendor, void *user) { GRil *ril = user; struct netmon_data *ud = g_new0(struct netmon_data, 1); ud->ril = g_ril_clone(ril); ofono_netmon_set_data(netmon, ud); g_idle_add(ril_delayed_register, netmon); return 0; }
static int ril_cbs_probe(struct ofono_cbs *cbs, unsigned int vendor, void *user) { GRil *ril = user; struct cbs_data *cd = g_try_new0(struct cbs_data, 1); cd->ril = g_ril_clone(ril); ofono_cbs_set_data(cbs, cd); g_timeout_add_seconds(2, ril_delayed_register, cbs); return 0; }
static int ril_call_barring_probe(struct ofono_call_barring *cb, unsigned int vendor, void *user) { GRil *ril = user; struct barring_data *bd = g_try_new0(struct barring_data, 1); if (bd == NULL) return -ENOMEM; bd->ril = g_ril_clone(ril); ofono_call_barring_set_data(cb, bd); g_idle_add(ril_delayed_register, cb); return 0; }
void ril_gprs_start(struct ril_gprs_driver_data *driver_data, struct ofono_gprs *gprs, struct ril_gprs_data *gd) { gd->ril = g_ril_clone(driver_data->gril); gd->modem = driver_data->modem; gd->ofono_attached = FALSE; gd->max_cids = 0; gd->rild_status = -1; gd->tech = RADIO_TECH_UNKNOWN; /* AOSP RILD tracks data network state together with voice */ gd->state_changed_unsol = RIL_UNSOL_RESPONSE_VOICE_NETWORK_STATE_CHANGED; ofono_gprs_set_data(gprs, gd); get_active_data_calls(gprs); }
static int ril_radio_settings_probe(struct ofono_radio_settings *rs, unsigned int vendor, void *user) { GRil *ril = user; struct radio_data *rsd = g_try_new0(struct radio_data, 1); if (rsd == NULL) { ofono_error("%s: cannot allocate memory", __func__); return -ENOMEM; } rsd->ril = g_ril_clone(ril); ofono_radio_settings_set_data(rs, rsd); g_idle_add(ril_delayed_register, rs); return 0; }
static int mtk_radio_settings_probe(struct ofono_radio_settings *rs, unsigned int vendor, void *user) { struct ril_radio_settings_driver_data* rs_init_data = user; struct radio_data *rsd = g_try_new0(struct radio_data, 1); if (rsd == NULL) { ofono_error("%s: cannot allocate memory", __func__); return -ENOMEM; } rsd->ril = g_ril_clone(rs_init_data->gril); rsd->modem = rs_init_data->modem; ofono_radio_settings_set_data(rs, rsd); mtk_set_fast_dormancy(rs, FALSE, ril_delayed_register, rs); return 0; }
static int ril_gprs_context_probe(struct ofono_gprs_context *gc, unsigned int vendor, void *data) { GRil *ril = data; struct gprs_context_data *gcd; gcd = g_try_new0(struct gprs_context_data, 1); if (gcd == NULL) return -ENOMEM; gcd->ril = g_ril_clone(ril); set_context_disconnected(gcd); ofono_gprs_context_set_data(gc, gcd); gcd->regid = -1; gcd->regid = g_ril_register(gcd->ril, RIL_UNSOL_DATA_CALL_LIST_CHANGED, ril_gprs_context_call_list_changed, gc); return 0; }
static int ril_devinfo_probe(struct ofono_devinfo *info, unsigned int vendor, void *data) { GRil *ril = NULL; if (data != NULL) ril = g_ril_clone(data); ofono_devinfo_set_data(info, ril); /* * ofono_devinfo_register() needs to be called after * the driver has been set in ofono_devinfo_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 an idle event instead. */ g_idle_add(ril_delayed_register, info); return 0; }
static int ril_gprs_probe(struct ofono_gprs *gprs, unsigned int vendor, void *data) { GRil *ril = data; struct gprs_data *gd; DBG(""); gd = g_try_new0(struct gprs_data, 1); if (gd == NULL) return -ENOMEM; gd->ril = g_ril_clone(ril); gd->max_cids = 0; gd->status = -1; ofono_gprs_set_data(gprs, gd); ril_gprs_registration_status(gprs, NULL, NULL); return 0; }
static int ril_sim_probe(struct ofono_sim *sim, unsigned int vendor, void *data) { struct ril_sim_data *ril_data = data; GRil *ril = ril_data->gril; struct sim_data *sd; int i; sd = g_new0(struct sim_data, 1); sd->ril = g_ril_clone(ril); sd->vendor = vendor; sd->aid_str = NULL; sd->app_str = NULL; sd->app_type = RIL_APPTYPE_UNKNOWN; sd->passwd_state = OFONO_SIM_PASSWORD_NONE; sd->passwd_type = OFONO_SIM_PASSWORD_NONE; sd->modem = ril_data->modem; sd->ril_state_watch = ril_data->ril_state_watch; for (i = 0; i < OFONO_SIM_PASSWORD_INVALID; i++) sd->retries[i] = -1; ofono_sim_set_data(sim, sd); /* * TODO: analyze if capability check is needed * and/or timer should be adjusted. * * ofono_sim_register() needs to be called after the * driver has been set in ofono_sim_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 an idle event * instead. */ g_idle_add(ril_sim_register, sim); return 0; }
static int ril_radio_settings_probe(struct ofono_radio_settings *rs, unsigned int vendor, void *user) { GRil *ril = user; struct cb_data *cbd = NULL; int ret; struct radio_data *rsd = g_try_new0(struct radio_data, 1); rsd->ril = g_ril_clone(ril); if (ril_get_net_config(rsd)) { cbd = cb_data_new2(rsd, NULL, NULL); ret = g_ril_send(rsd->ril, RIL_REQUEST_GET_PREFERRED_NETWORK_TYPE, NULL, 0, ril_rat_mode_cb, cbd, g_free); if (ret <= 0) g_free(cbd); } ofono_radio_settings_set_data(rs, rsd); rsd->timer_id = g_timeout_add_seconds(2, ril_delayed_register, rs); return 0; }
static int ril_stk_probe(struct ofono_stk *stk, unsigned int vendor, void *data) { GRil *ril = data; struct stk_data *sd; DBG(""); sd = g_try_new0(struct stk_data, 1); if (sd == NULL) return -ENOMEM; sd->ril = g_ril_clone(ril); ofono_stk_set_data(stk, sd); /* Register interface in this phase for stk agent */ ofono_stk_register(stk); subscribed = FALSE; /* UI language for local info */ ril_stk_set_lang(); return 0; }