Merge branch 'stray_call' into 'master'

Fix data connection dying after switching radio tech

See merge request mer-core/ofono!198

ofono/drivers/ril/ril_constants.h

@@ -320,6 +320,14 @@ enum ril_cell_info_type {
 	RIL_CELL_INFO_TYPE_TD_SCDMA = 5
 };
 
+enum ril_restricted_state {
+	RIL_RESTRICTED_STATE_NONE         = 0x00,
+	RIL_RESTRICTED_STATE_CS_EMERGENCY = 0x01,
+	RIL_RESTRICTED_STATE_CS_NORMAL    = 0x02,
+	RIL_RESTRICTED_STATE_CS_ALL       = 0x04,
+	RIL_RESTRICTED_STATE_PS_ALL       = 0x10
+};
+
 /* Suplementary services Service class*/
 #define SERVICE_CLASS_NONE 0
 

ofono/drivers/ril/ril_data.c

@@ -76,6 +76,12 @@ enum ril_data_priv_flags {
 typedef GObjectClass RilDataClass;
 typedef struct ril_data RilData;
 
+enum ril_data_io_event_id {
+	IO_EVENT_DATA_CALL_LIST_CHANGED,
+	IO_EVENT_RESTRICTED_STATE_CHANGED,
+	IO_EVENT_COUNT
+};
+
 enum ril_data_settings_event_id {
 	SETTINGS_EVENT_IMSI_CHANGED,
 	SETTINGS_EVENT_PREF_MODE,
@@ -94,9 +100,11 @@ struct ril_data_priv {
 	struct ril_radio *radio;
 	struct ril_network *network;
 	struct ril_data_manager *dm;
-	enum ril_data_priv_flags flags;
 	struct ril_vendor_hook *vendor_hook;
 
+	enum ril_data_priv_flags flags;
+	enum ril_restricted_state restricted_state;
+
 	struct ril_data_request *req_queue;
 	struct ril_data_request *pending_req;
 
@@ -104,8 +112,9 @@ struct ril_data_priv {
 	guint slot;
 	char *log_prefix;
 	guint query_id;
-	gulong io_event_id;
+	gulong io_event_id[IO_EVENT_COUNT];
 	gulong settings_event_id[SETTINGS_EVENT_COUNT];
+	GHashTable* grab;
 };
 
 enum ril_data_signal {
@@ -177,7 +186,7 @@ struct ril_data_request_allow_data {
 
 static void ril_data_manager_check_data(struct ril_data_manager *dm);
 static void ril_data_manager_check_network_mode(struct ril_data_manager *dm);
-
+static void ril_data_call_deact_cid(struct ril_data *data, int cid);
 static void ril_data_power_update(struct ril_data *self);
 static void ril_data_signal_emit(struct ril_data *self, enum ril_data_signal id)
 {
@@ -537,6 +546,10 @@ struct ril_data_call *ril_data_call_find(struct ril_data_call_list *list,
 static void ril_data_set_calls(struct ril_data *self,
 					struct ril_data_call_list *list)
 {
+	struct ril_data_priv *priv = self->priv;
+	GHashTableIter it;
+	gpointer key;
+
 	if (!ril_data_call_list_equal(self->data_calls, list)) {
 		DBG("data calls changed");
 		ril_data_call_list_free(self->data_calls);
@@ -545,6 +558,63 @@ static void ril_data_set_calls(struct ril_data *self,
 	} else {
 		ril_data_call_list_free(list);
 	}
+
+	/* Clean up the grab table */
+	g_hash_table_iter_init(&it, priv->grab);
+	while (g_hash_table_iter_next(&it, &key, NULL)) {
+		const int cid = GPOINTER_TO_INT(key);
+
+		if (!ril_data_call_find(self->data_calls, cid)) {
+			g_hash_table_iter_remove(&it);
+		}
+	}
+
+	if (self->data_calls) {
+		GSList *l;
+
+		/* Disconnect stray calls (one at a time) */
+		for (l = self->data_calls->calls; l; l = l->next) {
+			struct ril_data_call *dc = l->data;
+
+			key = GINT_TO_POINTER(dc->cid);
+			if (!g_hash_table_contains(priv->grab, key)) {
+				DBG_(self, "stray call %u", dc->cid);
+				ril_data_call_deact_cid(self, dc->cid);
+				break;
+			}
+		}
+	}
+}
+
+static void ril_data_check_allowed(struct ril_data *self, gboolean was_allowed)
+{
+	if (ril_data_allowed(self) != was_allowed) {
+		ril_data_signal_emit(self, SIGNAL_ALLOW_CHANGED);
+	}
+}
+
+static void ril_data_restricted_state_changed_cb(GRilIoChannel *io, guint event,
+				const void *data, guint len, void *user_data)
+{
+	struct ril_data *self = RIL_DATA(user_data);
+	GRilIoParser rilp;
+	guint32 count, state;
+
+	GASSERT(event == RIL_UNSOL_RESTRICTED_STATE_CHANGED);
+	grilio_parser_init(&rilp, data, len);
+	if (grilio_parser_get_uint32(&rilp, &count) && count == 1 &&
+				grilio_parser_get_uint32(&rilp, &state) &&
+				grilio_parser_at_end(&rilp)) {
+		struct ril_data_priv *priv = self->priv;
+
+		if (priv->restricted_state != state) {
+			const gboolean was_allowed = ril_data_allowed(self);
+
+			DBG_(self, "restricted state 0x%02x", state);
+			priv->restricted_state = state;
+			ril_data_check_allowed(self, was_allowed);
+		}
+	}
 }
 
 static void ril_data_call_list_changed_cb(GRilIoChannel *io, guint event,
@@ -1044,6 +1114,11 @@ static struct ril_data_request *ril_data_call_deact_new(struct ril_data *data,
 	return req;
 }
 
+static void ril_data_call_deact_cid(struct ril_data *data, int cid)
+{
+	ril_data_request_queue(ril_data_call_deact_new(data, cid, NULL, NULL));
+}
+
 /*==========================================================================*
  * ril_data_allow_request
  *==========================================================================*/
@@ -1070,9 +1145,7 @@ static void ril_data_allow_cb(GRilIoChannel *io, int ril_status,
 			DBG_(data, "data off");
 		}
 
-		if (ril_data_allowed(data) != was_allowed) {
-			ril_data_signal_emit(data, SIGNAL_ALLOW_CHANGED);
-		}
+		ril_data_check_allowed(data, was_allowed);
 	}
 
 	ril_data_request_finish(req);
@@ -1188,9 +1261,15 @@ struct ril_data *ril_data_new(struct ril_data_manager *dm, const char *name,
 		priv->radio = ril_radio_ref(radio);
 		priv->network = ril_network_ref(network);
 		priv->vendor_hook = ril_vendor_hook_ref(vendor_hook);
-		priv->io_event_id = grilio_channel_add_unsol_event_handler(io,
+
+		priv->io_event_id[IO_EVENT_DATA_CALL_LIST_CHANGED] =
+			grilio_channel_add_unsol_event_handler(io,
 				ril_data_call_list_changed_cb,
 				RIL_UNSOL_DATA_CALL_LIST_CHANGED, self);
+		priv->io_event_id[IO_EVENT_RESTRICTED_STATE_CHANGED] =
+			grilio_channel_add_unsol_event_handler(io,
+				ril_data_restricted_state_changed_cb,
+				RIL_UNSOL_RESTRICTED_STATE_CHANGED, self);
 
 		priv->settings_event_id[SETTINGS_EVENT_IMSI_CHANGED] =
 			ril_sim_settings_add_imsi_changed_handler(settings,
@@ -1264,6 +1343,8 @@ void ril_data_unref(struct ril_data *self)
 gboolean ril_data_allowed(struct ril_data *self)
 {
 	return G_LIKELY(self) &&
+		(self->priv->restricted_state &
+			RIL_RESTRICTED_STATE_PS_ALL) == 0 &&
 		(self->priv->flags &
 			(RIL_DATA_FLAG_ALLOWED | RIL_DATA_FLAG_ON)) ==
 			(RIL_DATA_FLAG_ALLOWED | RIL_DATA_FLAG_ON);
@@ -1278,9 +1359,7 @@ static void ril_data_deactivate_all(struct ril_data *self)
 			struct ril_data_call *call = l->data;
 			if (call->status == PDP_FAIL_NONE) {
 				DBG_(self, "deactivating call %u", call->cid);
-				ril_data_request_queue(
-					ril_data_call_deact_new(self,
-						call->cid, NULL, NULL));
+				ril_data_call_deact_cid(self, call->cid);
 			}
 		}
 	}
@@ -1348,9 +1427,7 @@ static void ril_data_disallow(struct ril_data *self)
 		ril_data_power_update(self);
 	}
 
-	if (ril_data_allowed(self) != was_allowed) {
-		ril_data_signal_emit(self, SIGNAL_ALLOW_CHANGED);
-	}
+	ril_data_check_allowed(self, was_allowed);
 }
 
 static void ril_data_max_speed_cb(gpointer data, gpointer max_speed)
@@ -1449,12 +1526,39 @@ struct ril_data_request *ril_data_call_deactivate(struct ril_data *self,
 	return req;
 }
 
+gboolean ril_data_call_grab(struct ril_data *self, int cid, void *cookie)
+{
+	if (self && cookie && ril_data_call_find(self->data_calls, cid)) {
+		struct ril_data_priv *priv = self->priv;
+		gpointer key = GINT_TO_POINTER(cid);
+		void *prev = g_hash_table_lookup(priv->grab, key);
+
+		if (!prev) {
+			g_hash_table_insert(priv->grab, key, cookie);
+			return TRUE;
+		} else {
+			return (prev == cookie);
+		}
+	}
+	return FALSE;
+}
+
+void ril_data_call_release(struct ril_data *self, int cid, void *cookie)
+{
+	if (self && cookie) {
+		struct ril_data_priv *priv = self->priv;
+
+		g_hash_table_remove(priv->grab, GUINT_TO_POINTER(cid));
+	}
+}
+
 static void ril_data_init(struct ril_data *self)
 {
 	struct ril_data_priv *priv = G_TYPE_INSTANCE_GET_PRIVATE(self,
 		RIL_DATA_TYPE, struct ril_data_priv);
 
 	self->priv = priv;
+	priv->grab = g_hash_table_new(g_direct_hash, g_direct_equal);
 }
 
 static void ril_data_dispose(GObject *object)
@@ -1468,7 +1572,7 @@ static void ril_data_dispose(GObject *object)
 
 	ril_sim_settings_remove_handlers(settings, priv->settings_event_id,
 					G_N_ELEMENTS(priv->settings_event_id));
-	grilio_channel_remove_handlers(priv->io, &priv->io_event_id, 1);
+	grilio_channel_remove_all_handlers(priv->io, priv->io_event_id);
 	grilio_queue_cancel_all(priv->q, FALSE);
 	priv->query_id = 0;
 
@@ -1482,6 +1586,7 @@ static void ril_data_dispose(GObject *object)
 
 	dm->data_list = g_slist_remove(dm->data_list, self);
 	ril_data_manager_check_data(dm);
+	g_hash_table_destroy(priv->grab);
 	G_OBJECT_CLASS(ril_data_parent_class)->dispose(object);
 }
 

ofono/drivers/ril/ril_data.h

@@ -123,6 +123,9 @@ struct ril_data_request *ril_data_call_deactivate(struct ril_data *data,
 void ril_data_request_detach(struct ril_data_request *req);
 void ril_data_request_cancel(struct ril_data_request *req);
 
+gboolean ril_data_call_grab(struct ril_data *data, int cid, void *cookie);
+void ril_data_call_release(struct ril_data *data, int cid, void *cookie);
+
 void ril_data_call_free(struct ril_data_call *call);
 struct ril_data_call *ril_data_call_dup(const struct ril_data_call *call);
 struct ril_data_call *ril_data_call_find(struct ril_data_call_list *list,

ofono/drivers/ril/ril_gprs_context.c

@@ -88,6 +88,7 @@ static int ril_gprs_context_address_family(const char *addr)
 static void ril_gprs_context_free_active_call(struct ril_gprs_context *gcd)
 {
 	if (gcd->active_call) {
+		ril_data_call_release(gcd->data, gcd->active_call->cid, gcd);
 		ril_data_call_free(gcd->active_call);
 		gcd->active_call = NULL;
 	}
@@ -111,6 +112,7 @@ static void ril_gprs_context_set_active_call(struct ril_gprs_context *gcd,
 			gcd->mtu_watch = mtu_watch_new(MAX_MTU);
 		}
 		mtu_watch_set_ifname(gcd->mtu_watch, call->ifname);
+		ril_data_call_grab(gcd->data, call->cid, gcd);
 	} else {
 		ril_gprs_context_free_active_call(gcd);
 	}

ofono/drivers/ril/ril_radio_caps.c

@@ -1284,6 +1284,24 @@ static GSList *ril_radio_caps_manager_empty_slots
 	return found;
 }
 
+static guint ril_radio_caps_manager_sim_count
+					(struct ril_radio_caps_manager *self)
+{
+	const GPtrArray *list = self->caps_list;
+	guint i, count = 0;
+
+	for (i = 0; i < list->len; i++) {
+		const struct ril_radio_caps *caps = list->pdata[i];
+
+		if (caps->simcard->status->card_state ==
+						RIL_CARDSTATE_PRESENT) {
+			count++;
+		}
+	}
+
+	return count;
+}
+
 /**
  * There could be no capability mismatch but LTE could be enabled for
  * the slot that has no SIM card in it. That's a waste, fix it.
@@ -1327,7 +1345,7 @@ static void ril_radio_caps_manager_check(struct ril_radio_caps_manager *self)
 	if (ril_radio_caps_manager_can_check(self)) {
 		const int first = ril_radio_caps_manager_first_mismatch(self);
 
-		if (first >= 0) {
+		if (first >= 0 && ril_radio_caps_manager_sim_count(self) > 1) {
 			if (ril_radio_caps_manager_update_caps(self, first)) {
 				ril_radio_caps_manager_start_transaction(self);
 			}

ofono/drivers/ril/ril_vendor_mtk.c

@@ -27,6 +27,7 @@
 #include <grilio_queue.h>
 
 #include <gutil_macros.h>
+#include <gutil_misc.h>
 
 #include "ofono.h"
 
@@ -83,6 +84,7 @@ struct ril_vendor_hook_mtk_auto {
 struct ril_mtk_msg {
 	gboolean attach_apn_has_roaming_protocol;
 	guint request_resume_registration;
+	guint request_set_call_indication;
 
 	/* See ril_vendor_mtk_auto_detect_event */
 #define unsol_msgs unsol_ps_network_state_changed
@@ -97,6 +99,7 @@ struct ril_mtk_msg {
 static const struct ril_mtk_msg msg_mtk1 = {
 	.attach_apn_has_roaming_protocol = TRUE,
 	.request_resume_registration = 2050,
+	.request_set_call_indication = 2065,
 	.unsol_ps_network_state_changed = 3012,
 	.unsol_registration_suspended = 3021,
 	.unsol_incoming_call_indication = 3037,
@@ -106,6 +109,7 @@ static const struct ril_mtk_msg msg_mtk1 = {
 static const struct ril_mtk_msg msg_mtk2 = {
 	.attach_apn_has_roaming_protocol = FALSE,
 	.request_resume_registration = 2065,
+	.request_set_call_indication = 2086,
 	.unsol_ps_network_state_changed = 3015,
 	.unsol_registration_suspended = 3024,
 	.unsol_incoming_call_indication = 3042,
@@ -132,6 +136,8 @@ static const char *ril_vendor_mtk_request_to_string
 
 	if (request == msg->request_resume_registration) {
 		return "MTK_RESUME_REGISTRATION";
+	} else if (request == msg->request_set_call_indication) {
+		return "MTK_SET_CALL_INDICATION";
 	} else {
 		return NULL;
 	}
@@ -340,12 +346,55 @@ static void ril_vendor_mtk_ps_network_state_changed(GRilIoChannel *io,
 	ril_network_query_registration_state(self->network);
 }
 
-static void ril_vendor_mtk_call_state_changed(GRilIoChannel *io,
-		guint id, const void *data, guint len, void *user_data)
+static void ril_vendor_mtk_incoming_call_indication(GRilIoChannel *io, guint id,
+				const void *data, guint len, void *user_data)
 {
-	/* Ignore the payload, let ril_voicecall.c do its normal stuff */
-	grilio_channel_inject_unsol_event(io,
-			RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, NULL, 0);
+	struct ril_vendor_hook_mtk *self = user_data;
+	const struct ril_mtk_msg *msg = self->msg;
+	GRilIoRequest* req = NULL;
+
+	GASSERT(id == msg->unsol_incoming_call_indication);
+
+	if (msg->request_set_call_indication) {
+		int nparams, cid, seq;
+		gchar *call_id = NULL, *seq_no = NULL;
+		GRilIoParser rilp;
+
+		grilio_parser_init(&rilp, data, len);
+
+		if (grilio_parser_get_int32(&rilp, &nparams) && nparams >= 5 &&
+			(call_id = grilio_parser_get_utf8(&rilp)) != NULL &&
+			grilio_parser_skip_string(&rilp) /* number */ &&
+			grilio_parser_skip_string(&rilp) /* type */ &&
+			grilio_parser_skip_string(&rilp) /* call_mode */ &&
+			(seq_no = grilio_parser_get_utf8(&rilp)) != NULL &&
+				gutil_parse_int(call_id, 10, &cid) &&
+				gutil_parse_int(seq_no, 10, &seq)) {
+
+			DBG("slot=%u,cid=%d,seq=%d", self->slot, cid, seq);
+			req = grilio_request_new();
+			grilio_request_append_int32(req, 3); /* Param count */
+			/* mode - IMS_ALLOW_INCOMING_CALL_INDICATION: */
+			grilio_request_append_int32(req, 0);
+			grilio_request_append_int32(req, cid);
+			grilio_request_append_int32(req, seq);
+		} else {
+			DBG("failed to parse INCOMING_CALL_INDICATION");
+		}
+
+		g_free(call_id);
+		g_free(seq_no);
+	}
+
+	if (req) {
+		grilio_queue_send_request(self->q, req,
+					msg->request_set_call_indication);
+		grilio_request_unref(req);
+	} else {
+		/* Let ril_voicecall.c know that something happened */
+		grilio_channel_inject_unsol_event(io,
+				RIL_UNSOL_RESPONSE_CALL_STATE_CHANGED, NULL, 0);
+	}
 }
 
 static GRilIoRequest *ril_vendor_mtk_data_call_req
@@ -443,7 +492,7 @@ static void ril_vendor_mtk_hook_subscribe(struct ril_vendor_hook_mtk *self)
 	if (msg->unsol_incoming_call_indication) {
 		self->ril_event_id[MTK_EVENT_INCOMING_CALL_INDICATION] =
 			grilio_channel_add_unsol_event_handler(self->io,
-				ril_vendor_mtk_call_state_changed,
+				ril_vendor_mtk_incoming_call_indication,
 				msg->unsol_incoming_call_indication, self);
 	}
 }