Merge lp:~awe/ofono/midori-switch-4g-update into lp:~phablet-team/ofono/ubuntu

[Tony Espy]

  * Add automatic SIM slot capability switching for midori:
   * include: gprs: remove set ia
   * gprs: remove calls to set_ia_apn
   * gril: fix memory leak, print radio_caps event
   * ril: create radio settings when onlining
   * rilmodem: gprs: remove set_ia_apn
   * rilmodem: radio-settings: enable switch slots caps
   * qcommsimmodem: remote set_ia_apn
   * qcommsimmodem: adapt to radio settings changes
   * mtkmodem: adapt to radio settings changes
   * mtkmodem: remove set_ia_apn
   * mtk2modem: remove set_ia_apn

This change adds support for dynamic switching of radio capabilities for dual-standby modems which use the rilmodem driver ( eg. midori ).

Instead of having to explicitly call a DBus method to switch which SIM slot has the ability use 3g or 4g, now the client just uses the standard method of changing the network technology preference. If this new setting requires the slot capabilities to be swapped, rilmodem will do this automatically on behalf of the client.

This change re-works some of the code necessary for LTE support, and as such, we should ensure that LTE still works properly on the MX4 ( EU / China only ).

[Scott Sweeny (ssweeny)]

LGTM

review: Approve

=== modified file 'debian/changelog'
--- debian/changelog	2016-07-01 17:31:30 +0000
+++ debian/changelog	2016-07-19 15:19:28 +0000
@@ -1,3 +1,21 @@
+ofono (1.17.bzr6919+16.10.20160719-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Alfonso Sanchez-Beato ]
+  * Add automatic SIM slot capability switching for midori:
+   * include: gprs: remove set ia
+   * gprs: remove calls to set_ia_apn
+   * gril: fix memory leak, print radio_caps event
+   * ril: create radio settings when onlining
+   * rilmodem: gprs: remove set_ia_apn
+   * rilmodem: radio-settings: enable switch slots caps
+   * qcommsimmodem: remote set_ia_apn
+   * qcommsimmodem: adapt to radio settings changes
+   * mtkmodem: adapt to radio settings changes
+   * mtkmodem: remove set_ia_apn
+   * mtk2modem: remove set_ia_apn
+
+ -- Tony Espy <[e-mail]>  Tue, 19 Jul 2016 10:29:20 -0400
+
 ofono (1.17.bzr6919+16.10.20160701.2-0ubuntu1) yakkety; urgency=medium
 
   [ Ratchanan Srirattanamet ]
 
=== modified file 'drivers/mtk2modem/gprs.c'
--- drivers/mtk2modem/gprs.c	2016-06-28 06:50:11 +0000
+++ drivers/mtk2modem/gprs.c	2016-07-19 15:19:28 +0000
@@ -74,7 +74,6 @@
 	.remove			= ril_gprs_remove,
 	.set_attached		= ril_gprs_set_attached,
 	.attached_status	= ril_gprs_registration_status,
-	.set_ia_apn		= ril_gprs_set_ia_apn,
 };
 
 void mtk2_gprs_init(void)
 
=== modified file 'drivers/mtkmodem/gprs.c'
--- drivers/mtkmodem/gprs.c	2015-09-29 08:46:20 +0000
+++ drivers/mtkmodem/gprs.c	2016-07-19 15:19:28 +0000
@@ -175,7 +175,6 @@
 	.remove			= mtk_gprs_remove,
 	.set_attached		= mtk_gprs_set_attached,
 	.attached_status	= ril_gprs_registration_status,
-	.set_ia_apn		= ril_gprs_set_ia_apn,
 };
 
 void mtk_gprs_init(void)
 
=== modified file 'drivers/mtkmodem/radio-settings.c'
--- drivers/mtkmodem/radio-settings.c	2015-09-29 08:46:20 +0000
+++ drivers/mtkmodem/radio-settings.c	2016-07-19 15:19:28 +0000
@@ -105,6 +105,8 @@
 	}
 }
 
+static struct ofono_radio_settings_driver driver;
+
 static int mtk_radio_settings_probe(struct ofono_radio_settings *rs,
 					unsigned int vendor, void *user)
 {
@@ -116,6 +118,7 @@
 		return -ENOMEM;
 	}
 
+	rsd->virt_tbl = &driver;
 	rsd->ril = g_ril_clone(rs_init_data->gril);
 	rsd->modem = rs_init_data->modem;
 
@@ -159,6 +162,8 @@
 			available_rats |= OFONO_RADIO_ACCESS_MODE_LTE;
 	}
 
+	rd->available_rats = available_rats;
+
 	CALLBACK_WITH_SUCCESS(cb, available_rats, cbd->data);
 }
 
 
=== modified file 'drivers/qcommsimmodem/gprs.c'
--- drivers/qcommsimmodem/gprs.c	2016-04-15 14:12:39 +0000
+++ drivers/qcommsimmodem/gprs.c	2016-07-19 15:19:28 +0000
@@ -104,7 +104,6 @@
 	.remove			= ril_gprs_remove,
 	.set_attached		= qcom_msim_gprs_set_attached,
 	.attached_status	= ril_gprs_registration_status,
-	.set_ia_apn		= ril_gprs_set_ia_apn,
 };
 
 void qcom_msim_gprs_init(void)
 
=== modified file 'drivers/qcommsimmodem/radio-settings.c'
--- drivers/qcommsimmodem/radio-settings.c	2016-02-25 11:59:14 +0000
+++ drivers/qcommsimmodem/radio-settings.c	2016-07-19 15:19:28 +0000
@@ -225,6 +225,8 @@
 		qcom_msim_do_set_rat_mode(rs, pref, cbd);
 }
 
+static struct ofono_radio_settings_driver driver;
+
 static int qcom_msim_radio_settings_probe(struct ofono_radio_settings *rs,
 					unsigned int vendor, void *user)
 {
@@ -237,6 +239,7 @@
 		return -ENOMEM;
 	}
 
+	rsd->virt_tbl = &driver;
 	rsd->ril = g_ril_clone(rs_init_data->gril);
 	rsd->modem = rs_init_data->modem;
 
 
=== modified file 'drivers/rilmodem/gprs.c'
--- drivers/rilmodem/gprs.c	2016-06-30 17:41:18 +0000
+++ drivers/rilmodem/gprs.c	2016-07-19 15:19:28 +0000
@@ -106,53 +106,6 @@
 	}
 }
 
-static void set_ia_apn_cb(struct ril_msg *message, gpointer user_data)
-{
-	struct cb_data *cbd = user_data;
-	ofono_gprs_cb_t cb = cbd->cb;
-	struct ofono_gprs *gprs = cbd->user;
-	struct ril_gprs_data *gd = ofono_gprs_get_data(gprs);
-
-	if (message->error != RIL_E_SUCCESS) {
-		ofono_error("%s: reply failure: %s", __func__,
-				ril_error_to_string(message->error));
-		CALLBACK_WITH_FAILURE(cb, cbd->data);
-		return;
-	}
-
-	g_ril_print_response_no_args(gd->ril, message);
-
-	CALLBACK_WITH_SUCCESS(cb, cbd->data);
-}
-
-void ril_gprs_set_ia_apn(struct ofono_gprs *gprs, const char *apn,
-				enum ofono_gprs_proto proto, const char *user,
-				const char *passwd, const char *mccmnc,
-				ofono_gprs_cb_t cb, void *data)
-{
-	struct ril_gprs_data *gd = ofono_gprs_get_data(gprs);
-	struct cb_data *cbd;
-	struct parcel rilp;
-
-	if (!ofono_modem_get_boolean(gd->modem, MODEM_PROP_LTE_CAPABLE)) {
-		CALLBACK_WITH_SUCCESS(cb, data);
-		return;
-	}
-
-	cbd = cb_data_new(cb, data, gprs);
-
-	g_ril_request_set_initial_attach_apn(gd->ril, apn, proto, user, passwd,
-						mccmnc, &rilp);
-
-	if (g_ril_send(gd->ril, RIL_REQUEST_SET_INITIAL_ATTACH_APN,
-			&rilp, set_ia_apn_cb, cbd, g_free) == 0) {
-		ofono_error("%s: failure sending request", __func__);
-
-		g_free(cbd);
-		CALLBACK_WITH_FAILURE(cb, data);
-	}
-}
-
 static void ril_gprs_state_change(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_gprs *gprs = user_data;
@@ -604,7 +557,6 @@
 	.remove			= ril_gprs_remove,
 	.set_attached		= ril_gprs_set_attached,
 	.attached_status	= ril_gprs_registration_status,
-	.set_ia_apn		= ril_gprs_set_ia_apn,
 };
 
 void ril_gprs_init(void)
 
=== modified file 'drivers/rilmodem/gprs.h'
--- drivers/rilmodem/gprs.h	2016-06-16 13:29:18 +0000
+++ drivers/rilmodem/gprs.h	2016-07-19 15:19:28 +0000
@@ -42,7 +42,3 @@
 						ofono_gprs_cb_t cb, void *data);
 void ril_gprs_registration_status(struct ofono_gprs *gprs,
 					ofono_gprs_status_cb_t cb, void *data);
-void ril_gprs_set_ia_apn(struct ofono_gprs *gprs, const char *apn,
-				enum ofono_gprs_proto proto, const char *user,
-				const char *passwd, const char *mccmnc,
-				ofono_gprs_cb_t cb, void *data);
 
=== modified file 'drivers/rilmodem/radio-settings.c'
--- drivers/rilmodem/radio-settings.c	2016-06-30 16:41:34 +0000
+++ drivers/rilmodem/radio-settings.c	2016-07-19 15:19:28 +0000
@@ -30,9 +30,11 @@
 #include <stdlib.h>
 #include <string.h>
 #include <errno.h>
+#include <stdint.h>
 
 #include <glib.h>
 
+#include <ofono.h>
 #include <ofono/log.h>
 #include <ofono/modem.h>
 #include <ofono/radio-settings.h>
@@ -46,6 +48,63 @@
 #include "grilreply.h"
 #include "radio-settings.h"
 
+struct radio_data *radio_data_0;
+struct radio_data *radio_data_1;
+
+static int g_session;
+
+static struct radio_data *radio_data_complement(struct radio_data *rd)
+{
+	if (rd == radio_data_0)
+		return radio_data_1;
+	else
+		return radio_data_0;
+}
+
+static void set_ia_apn_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct ofono_radio_settings *rs = user_data;
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: reply failure: %s", __func__,
+				ril_error_to_string(message->error));
+		return;
+	}
+
+	g_ril_print_response_no_args(rd->ril, message);
+}
+
+static void set_ia_apn(struct ofono_radio_settings *rs)
+{
+	char mccmnc[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1];
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	struct parcel rilp;
+	struct ofono_gprs *gprs;
+	const struct ofono_gprs_primary_context *ia_ctx;
+
+	if ((rd->available_rats & OFONO_RADIO_ACCESS_MODE_LTE) == 0)
+		return;
+
+	gprs = __ofono_atom_find(OFONO_ATOM_TYPE_GPRS, rd->modem);
+	if (gprs == NULL)
+		return;
+
+	/* Ask for APN data */
+	ia_ctx = ofono_gprs_get_ia_apn(gprs, mccmnc);
+	if (ia_ctx == NULL)
+		return;
+
+	g_ril_request_set_initial_attach_apn(rd->ril, ia_ctx->apn,
+						ia_ctx->proto, ia_ctx->username,
+						ia_ctx->password, mccmnc,
+						&rilp);
+
+	if (g_ril_send(rd->ril, RIL_REQUEST_SET_INITIAL_ATTACH_APN,
+			&rilp, set_ia_apn_cb, rs, NULL) == 0)
+		ofono_error("%s: failure sending request", __func__);
+}
+
 static void ril_set_rat_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
@@ -54,7 +113,13 @@
 	ofono_radio_settings_rat_mode_set_cb_t cb = cbd->cb;
 
 	if (message->error == RIL_E_SUCCESS) {
+		rd->rat_mode = rd->pending_mode;
+
 		g_ril_print_response_no_args(rd->ril, message);
+
+		if (rd->rat_mode == OFONO_RADIO_ACCESS_MODE_LTE)
+			set_ia_apn(rs);
+
 		CALLBACK_WITH_SUCCESS(cb, cbd->data);
 	} else {
 		ofono_error("%s: rat mode setting failed", __func__);
@@ -62,13 +127,10 @@
 	}
 }
 
-void ril_set_rat_mode(struct ofono_radio_settings *rs,
-			enum ofono_radio_access_mode mode,
-			ofono_radio_settings_rat_mode_set_cb_t cb,
-			void *data)
+static void set_preferred_network(struct radio_data *rd, struct cb_data *cbd,
+					enum ofono_radio_access_mode mode)
 {
-	struct radio_data *rd = ofono_radio_settings_get_data(rs);
-	struct cb_data *cbd = cb_data_new(cb, data, rs);
+	ofono_radio_settings_rat_mode_set_cb_t cb = cbd->cb;
 	struct parcel rilp;
 	int pref = PREF_NET_TYPE_GSM_WCDMA;
 
@@ -87,14 +149,340 @@
 		break;
 	}
 
+	rd->pending_mode = mode;
+
 	g_ril_request_set_preferred_network_type(rd->ril, pref, &rilp);
 
 	if (g_ril_send(rd->ril, RIL_REQUEST_SET_PREFERRED_NETWORK_TYPE,
 				&rilp, ril_set_rat_cb, cbd, g_free) == 0) {
 		ofono_error("%s: unable to set rat mode", __func__);
 		g_free(cbd);
-		CALLBACK_WITH_FAILURE(cb, data);
-	}
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+	}
+}
+
+static gboolean send_set_radio_cap(struct radio_data *rd,
+					int session, int phase, int ril_rats,
+					const char *logical_modem, int status,
+					GRilResponseFunc cb)
+{
+	struct parcel rilp;
+	int version = 1;
+
+	parcel_init(&rilp);
+
+	parcel_w_int32(&rilp, version);
+	parcel_w_int32(&rilp, session);
+	parcel_w_int32(&rilp, phase);
+	parcel_w_int32(&rilp, ril_rats);
+	parcel_w_string(&rilp, logical_modem);
+	parcel_w_int32(&rilp, status);
+
+	g_ril_append_print_buf(rd->ril, "(%d,%d,%d,0x%X,%s,%d)", version,
+			session, phase, ril_rats, logical_modem, status);
+
+	if (g_ril_send(rd->ril, RIL_REQUEST_SET_RADIO_CAPABILITY,
+						&rilp, cb, rd, NULL) == 0)
+		return FALSE;
+
+	return TRUE;
+}
+
+static unsigned set_rat_from_ril_rat(int ril_rat)
+{
+	unsigned rat = 0;
+
+	if (ril_rat & RIL_RAF_GSM)
+		rat |= OFONO_RADIO_ACCESS_MODE_GSM;
+
+	if (ril_rat & (RIL_RAF_UMTS | RIL_RAF_TD_SCDMA))
+		rat |= OFONO_RADIO_ACCESS_MODE_UMTS;
+
+	if (ril_rat & RIL_RAF_LTE)
+		rat |= OFONO_RADIO_ACCESS_MODE_LTE;
+
+	return rat;
+}
+
+static void set_preferred_cb(const struct ofono_error *error, void *data)
+{
+	struct radio_data *rd = data;
+
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+		ofono_error("%s: error setting radio access mode", __func__);
+
+		return;
+	}
+
+	ofono_radio_settings_set_rat_mode(rd->radio_settings, rd->rat_mode);
+}
+
+static enum ofono_radio_access_mode
+				get_best_available_tech(unsigned available_rats)
+{
+	int i;
+	uint32_t tech;
+
+	for (i = sizeof(uint32_t) * CHAR_BIT; i > 0; i--) {
+		tech = 1 << (i - 1);
+
+		if ((available_rats & tech) != 0)
+			break;
+	}
+
+	if (i == 0)
+		tech = OFONO_RADIO_ACCESS_MODE_GSM;
+
+	return tech;
+}
+
+static void switch_finish_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct radio_data *rd = user_data;
+	struct switch_data *sd = rd->switch_d;
+	struct radio_data *rd1 = sd->rd_1;
+	struct radio_data *rd2 = sd->rd_2;
+	struct reply_radio_capability *caps;
+
+	sd->pending_msgs--;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: error %s", __func__,
+				ril_error_to_string(message->error));
+		return;
+	}
+
+	caps = g_ril_reply_parse_get_radio_capability(rd->ril, message);
+	if (caps == NULL) {
+		ofono_error("%s: parse error", __func__);
+		return;
+	}
+
+	if (sd->pending_msgs != 0)
+		return;
+
+	ofono_info("Switching radio caps between slots - FINISH");
+
+	set_preferred_network(rd1, sd->cbd, sd->mode_to_switch);
+
+	/*
+	 * If the complementary slot does not support anymore its current
+	 * technology, we change it to the best possible among available ones.
+	 */
+	if ((rd2->rat_mode & rd2->available_rats) == 0) {
+
+		struct cb_data *cbd =
+			cb_data_new(set_preferred_cb, rd2, rd2->radio_settings);
+
+		set_preferred_network(rd2, cbd,
+				get_best_available_tech(rd2->available_rats));
+	}
+
+	rd1->switch_d = NULL;
+	rd2->switch_d = NULL;
+	g_free(sd);
+	g_free(caps);
+}
+
+static void radio_caps_event(struct ril_msg *message, gpointer user_data)
+{
+	struct radio_data *rd = user_data;
+	struct switch_data *sd = rd->switch_d;
+	struct radio_data *rd1;
+	struct radio_data *rd2;
+	struct reply_radio_capability *caps;
+
+	if (sd == NULL)
+		return;
+
+	rd1 = sd->rd_1;
+	rd2 = sd->rd_2;
+
+	caps = g_ril_reply_parse_get_radio_capability(rd->ril, message);
+	if (caps == NULL) {
+		ofono_error("%s: parse error", __func__);
+		return;
+	}
+
+	/*
+	 * Update rats. They come also in the replies to SET_RADIO_CAPABILITY,
+	 * but those seem to be unreliable, at least for midori.
+	 */
+	rd->ril_rats = caps->rat;
+	rd->available_rats = set_rat_from_ril_rat(caps->rat);
+
+	strcpy(rd->modem_uuid, caps->modem_uuid);
+
+	sd->pending_msgs--;
+
+	if (sd->pending_msgs != 0)
+		return;
+
+	DBG("Sending requests for FINISH phase");
+
+	send_set_radio_cap(rd1, g_session, RIL_RC_PHASE_FINISH,
+				rd1->ril_rats, rd1->modem_uuid,
+				RIL_RC_STATUS_SUCCESS, switch_finish_cb);
+	send_set_radio_cap(rd2, g_session, RIL_RC_PHASE_FINISH,
+				rd2->ril_rats, rd2->modem_uuid,
+				RIL_RC_STATUS_SUCCESS, switch_finish_cb);
+	sd->pending_msgs = 2;
+
+	g_free(caps);
+}
+
+/*
+ * This function is just for completeness, as we actually need to wait for the
+ * unsolocited events to continue the capabilities switch.
+ */
+static void switch_apply_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct radio_data *rd = user_data;
+	struct reply_radio_capability *caps;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: error %s", __func__,
+				ril_error_to_string(message->error));
+		return;
+	}
+
+	caps = g_ril_reply_parse_get_radio_capability(rd->ril, message);
+	if (caps == NULL)
+		ofono_error("%s: parse error", __func__);
+
+	g_free(caps);
+}
+
+static void switch_start_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct radio_data *rd = user_data;
+	struct switch_data *sd = rd->switch_d;
+	struct radio_data *rd1 = sd->rd_1;
+	struct radio_data *rd2 = sd->rd_2;
+	struct reply_radio_capability *caps;
+
+	sd->pending_msgs--;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: error %s", __func__,
+				ril_error_to_string(message->error));
+		return;
+	}
+
+	caps = g_ril_reply_parse_get_radio_capability(rd->ril, message);
+	if (caps == NULL) {
+		ofono_error("%s: parse error", __func__);
+		return;
+	}
+
+	if (sd->pending_msgs != 0)
+		return;
+
+	DBG("Sending requests for APPLY phase");
+
+	send_set_radio_cap(rd1, g_session, RIL_RC_PHASE_APPLY,
+				rd2->ril_rats, rd2->modem_uuid,
+				RIL_RC_STATUS_NONE, switch_apply_cb);
+	send_set_radio_cap(rd2, g_session, RIL_RC_PHASE_APPLY,
+				rd1->ril_rats, rd1->modem_uuid,
+				RIL_RC_STATUS_NONE, switch_apply_cb);
+	sd->pending_msgs = 2;
+
+	g_free(caps);
+}
+
+static void switch_caps(struct switch_data *sd)
+{
+	struct radio_data *rd1 = sd->rd_1;
+	struct radio_data *rd2 = sd->rd_2;
+
+	/* START phase */
+	g_session++;
+
+	send_set_radio_cap(rd1, g_session, RIL_RC_PHASE_START,
+				rd1->ril_rats, rd1->modem_uuid,
+				RIL_RC_STATUS_NONE, switch_start_cb);
+	send_set_radio_cap(rd2, g_session, RIL_RC_PHASE_START,
+				rd2->ril_rats, rd2->modem_uuid,
+				RIL_RC_STATUS_NONE, switch_start_cb);
+	sd->pending_msgs = 2;
+}
+
+static void get_rs_with_mode(struct ofono_modem *modem, void *data)
+{
+	struct switch_data *sd = data;
+	struct radio_data *rd_ref = sd->rd_1;
+	struct ofono_atom *atom;
+	struct ofono_radio_settings *rs;
+	struct radio_data *rd;
+	const char *standby_group, *modem_group;
+
+	atom = __ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_RADIO_SETTINGS);
+	if (atom == NULL)
+		return;
+
+	rs = __ofono_atom_get_data(atom);
+	rd = ofono_radio_settings_get_data(rs);
+	if (rd == rd_ref)
+		return;
+
+	standby_group = ofono_modem_get_string(rd_ref->modem, "StandbyGroup");
+	if (standby_group == NULL)
+		return;
+
+	modem_group = ofono_modem_get_string(modem, "StandbyGroup");
+	if (g_strcmp0(standby_group, modem_group) != 0)
+		return;
+
+	if ((rd->available_rats & sd->mode_to_switch) == 0)
+		return;
+
+	sd->rd_2 = rd;
+}
+
+void ril_set_rat_mode(struct ofono_radio_settings *rs,
+			enum ofono_radio_access_mode mode,
+			ofono_radio_settings_rat_mode_set_cb_t cb,
+			void *data)
+{
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	struct cb_data *cbd = cb_data_new(cb, data, rs);
+	struct switch_data *sd = NULL;
+
+	if (rd->switch_d != NULL)
+		goto error;
+
+	if ((rd->available_rats & mode) == 0) {
+		if (g_ril_get_version(rd->ril) < 11)
+			goto error;
+
+		/* Check if we can switch rats with other slot */
+		sd = g_malloc0(sizeof (*sd));
+		sd->rd_1 = rd;
+		sd->mode_to_switch = mode;
+		sd->cbd = cbd;
+
+		__ofono_modem_foreach(get_rs_with_mode, sd);
+
+		if (sd->rd_2 == NULL)
+			goto error;
+
+		ofono_info("Switching radio caps between slots - START");
+		sd->rd_1->switch_d = sd;
+		sd->rd_2->switch_d = sd;
+
+		switch_caps(sd);
+	} else {
+		set_preferred_network(rd, cbd, mode);
+	}
+
+	return;
+
+error:
+	ofono_error("%s: unable to set rat mode", __func__);
+	g_free(sd);
+	g_free(cbd);
+	CALLBACK_WITH_FAILURE(cb, data);
 }
 
 static void ril_rat_mode_cb(struct ril_msg *message, gpointer user_data)
@@ -108,15 +496,13 @@
 	if (message->error != RIL_E_SUCCESS) {
 		ofono_error("%s: error %s", __func__,
 				ril_error_to_string(message->error));
-		CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
-		return;
+		goto error;
 	}
 
 	pref = g_ril_reply_parse_get_preferred_network_type(rd->ril, message);
 	if (pref < 0) {
 		ofono_error("%s: parse error", __func__);
-		CALLBACK_WITH_FAILURE(cb, -1, cbd->data);
-		return;
+		goto error;
 	}
 
 	/*
@@ -144,7 +530,22 @@
 		break;
 	}
 
+	rd->rat_mode = mode;
+
 	CALLBACK_WITH_SUCCESS(cb, mode, cbd->data);
+
+	return;
+
+error:
+	/*
+	 * If error, we assume GSM. This is preferable to not being able to
+	 * access the radio settings properties. Midori returns error if we
+	 * have not completed successfully a capability switch. This should
+	 * not happen if there are no bugs in our implementation, but it is
+	 * better to leave this here so system settings shows something that
+	 * can be manually changed by the user, just in case.
+	 */
+	CALLBACK_WITH_SUCCESS(cb, OFONO_RADIO_ACCESS_MODE_GSM, cbd->data);
 }
 
 void ril_query_rat_mode(struct ofono_radio_settings *rs,
@@ -211,19 +612,18 @@
 
 static ofono_bool_t query_available_rats_cb(gpointer user_data)
 {
-	unsigned int available_rats;
 	struct cb_data *cbd = user_data;
 	ofono_radio_settings_available_rats_query_cb_t cb = cbd->cb;
 	struct ofono_radio_settings *rs = cbd->user;
 	struct radio_data *rd = ofono_radio_settings_get_data(rs);
 
-	available_rats = OFONO_RADIO_ACCESS_MODE_GSM
-				| OFONO_RADIO_ACCESS_MODE_UMTS;
-
-	if (ofono_modem_get_boolean(rd->modem, MODEM_PROP_LTE_CAPABLE))
-		available_rats |= OFONO_RADIO_ACCESS_MODE_LTE;
-
-	CALLBACK_WITH_SUCCESS(cb, available_rats, cbd->data);
+	rd->available_rats = OFONO_RADIO_ACCESS_MODE_GSM
+						| OFONO_RADIO_ACCESS_MODE_UMTS;
+
+	if (getenv("OFONO_RIL_RAT_LTE") != NULL)
+		rd->available_rats |= OFONO_RADIO_ACCESS_MODE_LTE;
+
+	CALLBACK_WITH_SUCCESS(cb, rd->available_rats, cbd->data);
 
 	g_free(cbd);
 
@@ -232,12 +632,13 @@
 
 static void get_radio_caps_cb(struct ril_msg *message, gpointer user_data)
 {
-	unsigned int available_rats = 0;
 	struct cb_data *cbd = user_data;
 	ofono_radio_settings_available_rats_query_cb_t cb = cbd->cb;
 	struct ofono_radio_settings *rs = cbd->user;
 	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+	struct radio_data *rd_comp;
 	struct reply_radio_capability *caps;
+	unsigned all_rats;
 
 	if (message->error != RIL_E_SUCCESS) {
 		ofono_error("%s: error %s", __func__,
@@ -253,18 +654,21 @@
 		return;
 	}
 
-	if (caps->rat & RIL_RAF_GSM)
-		available_rats |= OFONO_RADIO_ACCESS_MODE_GSM;
-
-	if (caps->rat & (RIL_RAF_UMTS | RIL_RAF_TD_SCDMA))
-		available_rats |= OFONO_RADIO_ACCESS_MODE_UMTS;
-
-	if (caps->rat & RIL_RAF_LTE)
-		available_rats |= OFONO_RADIO_ACCESS_MODE_LTE;
+	rd->ril_rats = caps->rat;
+	rd->available_rats = set_rat_from_ril_rat(caps->rat);
+
+	strcpy(rd->modem_uuid, caps->modem_uuid);
 
 	g_free(caps);
 
-	CALLBACK_WITH_SUCCESS(cb, available_rats, cbd->data);
+	/* We show all rats, as we can switch the ownership between slots */
+	all_rats = rd->available_rats;
+
+	rd_comp = radio_data_complement(rd);
+	if (rd_comp != NULL)
+		all_rats |= rd_comp->available_rats;
+
+	CALLBACK_WITH_SUCCESS(cb, all_rats, cbd->data);
 }
 
 void ril_query_available_rats(struct ofono_radio_settings *rs,
@@ -286,20 +690,90 @@
 	}
 }
 
+static void gprs_watch_cb(struct ofono_atom *atom,
+				enum ofono_atom_watch_condition cond,
+				void *data)
+{
+	struct ofono_radio_settings *rs = data;
+
+	if (cond != OFONO_ATOM_WATCH_CONDITION_REGISTERED)
+		return;
+
+	set_ia_apn(rs);
+}
+
+static void set_safe_preferred_cb(const struct ofono_error *error, void *data)
+{
+	if (error->type != OFONO_ERROR_TYPE_NO_ERROR) {
+		ofono_error("%s: error setting radio access mode", __func__);
+
+		return;
+	}
+}
+
+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).
+	 */
+	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,
+				get_best_available_tech(rd->available_rats));
+	}
+
+	/*
+	 * 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 ril_after_query_rat_mode(const struct ofono_error *error,
+					enum ofono_radio_access_mode mode,
+					void *data)
+{
+	struct ofono_radio_settings *rs = data;
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+
+	rd->virt_tbl->query_available_rats(rs, radio_settings_register, rs);
+}
+
 void ril_delayed_register(const struct ofono_error *error, void *user_data)
 {
 	struct ofono_radio_settings *rs = user_data;
+	struct radio_data *rd = ofono_radio_settings_get_data(rs);
 
 	if (error->type != OFONO_ERROR_TYPE_NO_ERROR)
 		ofono_error("%s: cannot set default fast dormancy", __func__);
 
-	/*
-	 * 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);
+	rd->radio_settings = rs;
+
+	if (ofono_modem_get_integer(rd->modem, "Slot") == 0)
+		radio_data_0 = rd;
+	else
+		radio_data_1 = rd;
+
+	rd->virt_tbl->query_rat_mode(rs, ril_after_query_rat_mode, rs);
 }
 
+static struct ofono_radio_settings_driver driver;
+
 static int ril_radio_settings_probe(struct ofono_radio_settings *rs,
 					unsigned int vendor, void *user)
 {
@@ -311,6 +785,7 @@
 		return -ENOMEM;
 	}
 
+	rsd->virt_tbl = &driver;
 	rsd->ril = g_ril_clone(rs_init_data->gril);
 	rsd->modem = rs_init_data->modem;
 
@@ -324,8 +799,12 @@
 void ril_radio_settings_remove(struct ofono_radio_settings *rs)
 {
 	struct radio_data *rd = ofono_radio_settings_get_data(rs);
+
 	ofono_radio_settings_set_data(rs, NULL);
 
+	if (rd->gprs_atom_watch)
+		__ofono_modem_remove_atom_watch(rd->modem, rd->gprs_atom_watch);
+
 	g_ril_unref(rd->ril);
 	g_free(rd);
 }
 
=== modified file 'drivers/rilmodem/radio-settings.h'
--- drivers/rilmodem/radio-settings.h	2015-07-31 13:44:26 +0000
+++ drivers/rilmodem/radio-settings.h	2016-07-19 15:19:28 +0000
@@ -19,11 +19,30 @@
  *
  */
 
+struct switch_data;
+
 struct radio_data {
+	struct ofono_radio_settings_driver *virt_tbl;
 	GRil *ril;
 	struct ofono_modem *modem;
+	struct ofono_radio_settings *radio_settings;
 	gboolean fast_dormancy;
 	gboolean pending_fd;
+	int rat_mode;
+	int pending_mode;
+	unsigned available_rats;
+	int ril_rats;
+	char modem_uuid[RIL_MAX_UUID_LENGTH];
+	struct switch_data *switch_d;
+	unsigned gprs_atom_watch;
+};
+
+struct switch_data {
+	struct radio_data *rd_1;
+	struct radio_data *rd_2;
+	enum ofono_radio_access_mode mode_to_switch;
+	int pending_msgs;
+	struct cb_data *cbd;
 };
 
 void ril_delayed_register(const struct ofono_error *error, void *user_data);
 
=== modified file 'gril/grilreply.c'
--- gril/grilreply.c	2016-06-28 15:26:37 +0000
+++ gril/grilreply.c	2016-07-19 15:19:28 +0000
@@ -1477,8 +1477,11 @@
 	reply->phase = parcel_r_int32(&rilp);
 	reply->rat = parcel_r_int32(&rilp);
 	modem_uuid = parcel_r_string(&rilp);
-	if (modem_uuid != NULL)
-		strcpy(reply->modem_uuid, modem_uuid);
+	if (modem_uuid != NULL) {
+		strncpy(reply->modem_uuid, modem_uuid,
+						sizeof(reply->modem_uuid) - 1);
+		g_free(modem_uuid);
+	}
 
 	reply->status = parcel_r_int32(&rilp);
 
@@ -1552,7 +1555,10 @@
 				reply->modem_uuid,
 				ril_rc_status_to_string(reply->status));
 
-	g_ril_print_response(gril, message);
+	if (message->unsolicited)
+		g_ril_print_unsol(gril, message);
+	else
+		g_ril_print_response(gril, message);
 
 end:
 	return reply;
 
=== modified file 'include/gprs.h'
--- include/gprs.h	2015-01-28 13:58:34 +0000
+++ include/gprs.h	2016-07-19 15:19:28 +0000
@@ -46,10 +46,6 @@
 				ofono_gprs_cb_t cb, void *data);
 	void (*attached_status)(struct ofono_gprs *gprs,
 					ofono_gprs_status_cb_t cb, void *data);
-	void (*set_ia_apn)(struct ofono_gprs *gprs, const char *apn,
-				enum ofono_gprs_proto proto, const char *user,
-				const char *passwd, const char *mccmnc,
-				ofono_gprs_cb_t cb, void *data);
 };
 
 enum gprs_suspend_cause {
@@ -82,6 +78,8 @@
 				unsigned int min, unsigned int max);
 void ofono_gprs_add_context(struct ofono_gprs *gprs,
 				struct ofono_gprs_context *gc);
+const struct ofono_gprs_primary_context *ofono_gprs_get_ia_apn(
+					struct ofono_gprs *gprs, char *mccmnc);
 
 #ifdef __cplusplus
 }
 
=== modified file 'plugins/ril.c'
--- plugins/ril.c	2016-06-30 17:41:18 +0000
+++ plugins/ril.c	2016-07-19 15:19:28 +0000
@@ -128,6 +128,33 @@
 	return RILMODEM;
 }
 
+/*
+ * oFono moves to "Online" state only when told to online the modem AND there is
+ * a SIM a card. However, we want to have RadioSettings even when there is no
+ * SIM, but we also want it *only* when we are online. Normally, ofono atoms are
+ * created/destroyed when the ofono state changes, but for this atom the ofono
+ * states do not fit, as we do never move from Offline state if there is no SIM.
+ * Therefore, we handle this atom on modem onlining/offlining.
+ */
+static void manage_radio_settings_atom(struct ofono_modem *modem)
+{
+	struct ril_data *rd = ofono_modem_get_data(modem);
+	struct ofono_radio_settings *rs;
+
+	rs = __ofono_atom_find(OFONO_ATOM_TYPE_RADIO_SETTINGS, modem);
+
+	if (rd->ofono_online && rs == NULL) {
+		struct ril_radio_settings_driver_data rs_data =
+							{ rd->ril, modem };
+
+		ofono_radio_settings_create(modem, rd->vendor,
+			get_driver_type(rd, OFONO_ATOM_TYPE_RADIO_SETTINGS),
+			&rs_data);
+	} else if(!rd->ofono_online && rs != NULL) {
+		ofono_radio_settings_remove(rs);
+	}
+}
+
 static void ril_send_power(struct ril_data *rd, ofono_bool_t online,
 				GRilResponseFunc func, gpointer user_data)
 {
@@ -206,6 +233,8 @@
 
 		DBG("%s: set_online OK: rd->ofono_online: %d",
 						__func__, rd->ofono_online);
+		manage_radio_settings_atom(modem);
+
 		CALLBACK_WITH_SUCCESS(cb, rd->set_online_cbd->data);
 
 		g_free(rd->set_online_cbd);
@@ -286,7 +315,6 @@
 	struct ril_data *rd = ofono_modem_get_data(modem);
 	struct ril_voicecall_driver_data vc_data = { rd->ril, modem };
 	struct ril_sim_data sim_data;
-	struct ril_radio_settings_driver_data rs_data = { rd->ril, modem };
 
 	DBG("");
 
@@ -306,16 +334,6 @@
 
 	rd->sim = ofono_sim_create(modem, rd->vendor,
 			get_driver_type(rd, OFONO_ATOM_TYPE_SIM), &sim_data);
-
-	/*
-	 * We need to create radio settings here so FastDormancy property is
-	 * available even when there is no SIM (no SIM -> post_sim and
-	 * post_online are not called) so we can make the modem enter low power
-	 * state in that case.
-	 */
-	ofono_radio_settings_create(modem, rd->vendor,
-			get_driver_type(rd, OFONO_ATOM_TYPE_RADIO_SETTINGS),
-			&rs_data);
 }
 
 void ril_post_sim(struct ofono_modem *modem)
@@ -334,7 +352,7 @@
 			get_driver_type(rd, OFONO_ATOM_TYPE_PHONEBOOK), modem);
 }
 
-static void create_post_online_atoms(struct ofono_modem *modem)
+void ril_post_online(struct ofono_modem *modem)
 {
 	struct ril_data *rd = ofono_modem_get_data(modem);
 	struct ofono_gprs *gprs;
@@ -382,47 +400,6 @@
 	}
 }
 
-static void get_radio_caps_cb(struct ril_msg *message, gpointer user_data)
-{
-	struct ofono_modem *modem = user_data;
-	struct ril_data *rd = ofono_modem_get_data(modem);
-	struct reply_radio_capability *caps;
-
-	if (message->error == RIL_E_SUCCESS) {
-		caps = g_ril_reply_parse_get_radio_capability(rd->ril, message);
-		if (caps != NULL && (caps->rat & RIL_RAF_LTE)) {
-			ofono_modem_set_boolean(modem,
-						MODEM_PROP_LTE_CAPABLE, TRUE);
-			g_free(caps);
-		}
-	} else {
-		ofono_error("%s: RIL error %s", __func__,
-					ril_error_to_string(message->error));
-	}
-
-	create_post_online_atoms(modem);
-}
-
-void ril_post_online(struct ofono_modem *modem)
-{
-	struct ril_data *rd = ofono_modem_get_data(modem);
-	ofono_bool_t lte_cap;
-
-	/* Radio ON -> we can ask for capabilities */
-	if (g_ril_get_version(rd->ril) >= 11) {
-		if (g_ril_send(rd->ril, RIL_REQUEST_GET_RADIO_CAPABILITY, NULL,
-					get_radio_caps_cb, modem, NULL))
-			return;
-
-		ofono_error("%s: error sending GET_RADIO_CAPABILITY", __func__);
-	}
-
-	lte_cap = getenv("OFONO_RIL_RAT_LTE") ? TRUE : FALSE;
-	ofono_modem_set_boolean(modem, MODEM_PROP_LTE_CAPABLE, lte_cap);
-
-	create_post_online_atoms(modem);
-}
-
 static void ril_set_online_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct ril_data *rd = user_data;
@@ -449,11 +426,14 @@
 static gboolean set_online_done_cb(gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
-	struct ril_data *rd = cbd->user;
+	struct ofono_modem *modem = cbd->user;
+	struct ril_data *rd = ofono_modem_get_data(modem);
 	ofono_modem_online_cb_t cb = cbd->cb;
 
 	DBG("%s: set_online OK: rd->ofono_online: %d",
 						__func__, rd->ofono_online);
+	manage_radio_settings_atom(modem);
+
 	CALLBACK_WITH_SUCCESS(cb, cbd->data);
 	g_free(cbd);
 
@@ -464,7 +444,7 @@
 			ofono_modem_online_cb_t callback, void *data)
 {
 	struct ril_data *rd = ofono_modem_get_data(modem);
-	struct cb_data *cbd = cb_data_new(callback, data, rd);
+	struct cb_data *cbd = cb_data_new(callback, data, modem);
 
 	rd->ofono_online = online;
 
 
=== modified file 'src/gprs.c'
--- src/gprs.c	2016-06-28 15:26:37 +0000
+++ src/gprs.c	2016-07-19 15:19:28 +0000
@@ -3444,32 +3444,20 @@
 	return gprs->contexts->data;
 }
 
-static void set_ia_apn_cb(const struct ofono_error *error, void *data)
-{
-	if (error->type != OFONO_ERROR_TYPE_NO_ERROR)
-		ofono_error("Could not set IA APN");
-}
-
-static void set_ia_apn(struct ofono_gprs *gprs)
+const struct ofono_gprs_primary_context *ofono_gprs_get_ia_apn(
+					struct ofono_gprs *gprs, char *mccmnc)
 {
 	struct pri_context *ctx = gprs_context_for_ia(gprs);
-	struct ofono_gprs_primary_context *ofono_ctx;
-	char mccmnc[OFONO_MAX_MCC_LENGTH + OFONO_MAX_MNC_LENGTH + 1];
 	const char *mcc = ofono_sim_get_mcc(gprs->sim);
 	const char *mnc = ofono_sim_get_mnc(gprs->sim);
 
 	if (ctx == NULL)
-		return;
-
-	ofono_ctx = &ctx->context;
+		return NULL;
 
 	strcpy(mccmnc, mcc);
 	strcpy(mccmnc + strlen(mcc), mnc);
 
-	gprs->driver->set_ia_apn(gprs, ofono_ctx->apn, ofono_ctx->proto,
-					ofono_ctx->username,
-					ofono_ctx->password, mccmnc,
-					set_ia_apn_cb, gprs);
+	return &ctx->context;
 }
 
 static void ofono_gprs_finish_register(struct ofono_gprs *gprs)
@@ -3481,9 +3469,6 @@
 	if (gprs->contexts == NULL) /* Automatic provisioning failed */
 		add_context(gprs, NULL, OFONO_GPRS_CONTEXT_TYPE_INTERNET);
 
-	if (gprs->driver->set_ia_apn)
-		set_ia_apn(gprs);
-
 	if (!g_dbus_register_interface(conn, path,
 					OFONO_CONNECTION_MANAGER_INTERFACE,
 					manager_methods, manager_signals, NULL,