Voice call SS notifications (4th version)

index e140281..ce6c10a 100644
@@ -41,7 +41,6 @@ static int atmodem_init(void)
 	at_call_meter_init();
 	at_call_settings_init();
 	at_phonebook_init();
-	at_ssn_init();
 	at_ussd_init();
 	at_sms_init();
 	at_sim_init();

@@ -63,7 +62,6 @@ static void atmodem_exit(void)
 	at_sim_exit();
 	at_sms_exit();
 	at_ussd_exit();
-	at_ssn_exit();
 	at_phonebook_exit();
 	at_call_settings_exit();
 	at_call_meter_exit();

index 1b7cf67..a6720d1 100644
@@ -54,9 +54,6 @@ extern void at_sms_exit(void);
 extern void at_phonebook_init(void);
 extern void at_phonebook_exit(void);
 
-extern void at_ssn_init(void);
-extern void at_ssn_exit(void);
-
 extern void at_devinfo_init(void);
 extern void at_devinfo_exit(void);
 

147 lines not on this page · raw message

index ba5cd54..1e3d3f3 100644
@@ -44,7 +44,6 @@ static int isimodem_init(void)
 	isi_sms_init();
 	isi_cbs_init();
 	isi_sim_init();
-	isi_ssn_init();
 	isi_ussd_init();
 	isi_call_forwarding_init();
 	isi_call_settings_init();

@@ -67,7 +66,6 @@ static void isimodem_exit(void)
 	isi_sms_exit();
 	isi_cbs_exit();
 	isi_sim_exit();
-	isi_ssn_exit();
 	isi_ussd_exit();
 	isi_call_forwarding_exit();
 	isi_call_settings_exit();

index ed64f9d..f5e1657 100644
@@ -43,9 +43,6 @@ extern void isi_sim_exit(void);
 extern void isi_ussd_init(void);
 extern void isi_ussd_exit(void);
 
-extern void isi_ssn_init(void);
-extern void isi_ssn_exit(void);
-
 extern void isi_call_forwarding_init(void);
 extern void isi_call_forwarding_exit(void);
 

503 lines not on this page · raw message

61 lines not on this page · raw message

index 0e29256..e014581 100644
@@ -52,7 +52,6 @@
 #include <ofono/phonebook.h>
 #include <ofono/sim.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/voicecall.h>
 #include <ofono/stk.h>

@@ -534,7 +533,6 @@ static void calypso_post_sim(struct ofono_modem *modem)
 				data->dlcs[NETREG_DLC]);
 	ofono_call_meter_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 	ofono_call_barring_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
-	ofono_ssn_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 	ofono_call_volume_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 
 	mw = ofono_message_waiting_create(modem);

index 22bacdc..b882463 100644
@@ -45,7 +45,6 @@
 #include <ofono/phonebook.h>
 #include <ofono/sim.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/voicecall.h>
 

@@ -184,7 +183,6 @@ static void g1_post_sim(struct ofono_modem *modem)
 	ofono_netreg_create(modem, 0, "atmodem", chat);
 	ofono_call_meter_create(modem, 0, "atmodem", chat);
 	ofono_call_barring_create(modem, 0, "atmodem", chat);
-	ofono_ssn_create(modem, 0, "atmodem", chat);
 	ofono_sms_create(modem, OFONO_VENDOR_QUALCOMM_MSM, "atmodem", chat);
 	ofono_phonebook_create(modem, 0, "atmodem", chat);
 

index 6f05677..e33716d 100644
@@ -48,7 +48,6 @@
 #include <ofono/call-forwarding.h>
 #include <ofono/call-settings.h>
 #include <ofono/call-barring.h>
-#include <ofono/ssn.h>
 #include <ofono/phonebook.h>
 #include <ofono/message-waiting.h>
 #include <ofono/log.h>

@@ -685,7 +684,6 @@ static void huawei_post_online(struct ofono_modem *modem)
 		ofono_call_forwarding_create(modem, 0, "atmodem", data->pcui);
 		ofono_call_settings_create(modem, 0, "atmodem", data->pcui);
 		ofono_call_barring_create(modem, 0, "atmodem", data->pcui);
-		ofono_ssn_create(modem, 0, "atmodem", data->pcui);
 
 		mw = ofono_message_waiting_create(modem);
 		if (mw)

index 527a8c4..37cd2bb 100644
@@ -47,7 +47,6 @@
 #include <ofono/call-settings.h>
 #include <ofono/call-volume.h>
 #include <ofono/message-waiting.h>
-#include <ofono/ssn.h>
 #include <ofono/sim.h>
 #include <ofono/cbs.h>
 #include <ofono/sms.h>

@@ -717,7 +716,6 @@ static void ifx_post_online(struct ofono_modem *modem)
 	ofono_cbs_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 	ofono_ussd_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 
-	ofono_ssn_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 	ofono_call_settings_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 	ofono_call_meter_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);
 	ofono_call_barring_create(modem, 0, "atmodem", data->dlcs[AUX_DLC]);

index 2d17b43..7252d26 100644
@@ -46,7 +46,6 @@
 #include <ofono/cbs.h>
 #include <ofono/sim.h>
 #include <ofono/ussd.h>
-#include <ofono/ssn.h>
 #include <ofono/call-forwarding.h>
 #include <ofono/call-settings.h>
 #include <ofono/call-barring.h>

@@ -431,7 +430,6 @@ static void isiusb_post_online(struct ofono_modem *modem)
 	ofono_netreg_create(modem, 0, "wgmodem2.5", isi->modem);
 	ofono_sms_create(modem, 0, "isimodem", isi->modem);
 	ofono_cbs_create(modem, 0, "isimodem", isi->modem);
-	ofono_ssn_create(modem, 0, "isimodem", isi->modem);
 	ofono_ussd_create(modem, 0, "isimodem", isi->modem);
 	ofono_call_settings_create(modem, 0, "isimodem", isi->modem);
 	ofono_call_barring_create(modem, 0, "isimodem", isi->modem);

index 2fb3896..953f634 100644
@@ -44,7 +44,6 @@
 #include <ofono/sim.h>
 #include <ofono/cbs.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/call-volume.h>
 #include <ofono/voicecall.h>

@@ -313,7 +312,6 @@ static void linktop_post_online(struct ofono_modem *modem)
 	ofono_netreg_create(modem, OFONO_VENDOR_MBM, "atmodem", data->control);
 	ofono_call_meter_create(modem, 0, "atmodem", data->control);
 	ofono_call_barring_create(modem, 0, "atmodem", data->control);
-	ofono_ssn_create(modem, 0, "atmodem", data->control);
 	ofono_call_volume_create(modem, 0, "atmodem", data->control);
 	ofono_cbs_create(modem, 0, "atmodem", data->control);
 

index c685266..b6af2cb 100644
@@ -45,7 +45,6 @@
 #include <ofono/cbs.h>
 #include <ofono/sim.h>
 #include <ofono/ussd.h>
-#include <ofono/ssn.h>
 #include <ofono/call-forwarding.h>
 #include <ofono/call-settings.h>
 #include <ofono/call-barring.h>

@@ -509,7 +508,6 @@ static void n900_post_online(struct ofono_modem *modem)
 	ofono_netreg_create(modem, 0, "isimodem", isi->modem);
 	ofono_sms_create(modem, 0, "isimodem", isi->modem);
 	ofono_cbs_create(modem, 0, "isimodem", isi->modem);
-	ofono_ssn_create(modem, 0, "isimodem", isi->modem);
 	ofono_ussd_create(modem, 0, "isimodem", isi->modem);
 	ofono_call_settings_create(modem, 0, "isimodem", isi->modem);
 	ofono_call_barring_create(modem, 0, "isimodem", isi->modem);

index 2b36fe0..76832dd 100644
@@ -54,7 +54,6 @@
 #include <ofono/sim.h>
 #include <ofono/stk.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/voicecall.h>
 #include <ofono/gprs.h>

@@ -651,7 +650,6 @@ static void phonesim_post_online(struct ofono_modem *modem)
 
 	ofono_call_meter_create(modem, 0, "atmodem", data->chat);
 	ofono_call_barring_create(modem, 0, "atmodem", data->chat);
-	ofono_ssn_create(modem, 0, "atmodem", data->chat);
 	ofono_call_volume_create(modem, 0, "atmodem", data->chat);
 
 	if (!data->calypso)

index efae573..36b3148 100644
@@ -50,7 +50,6 @@
 #include <ofono/sim.h>
 #include <ofono/cbs.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/call-volume.h>
 #include <ofono/voicecall.h>

@@ -470,7 +469,6 @@ static void ste_post_online(struct ofono_modem *modem)
 					"atmodem", data->chat[AT_NET]);
 	ofono_call_meter_create(modem, 0, "atmodem", data->chat[AT_DEFAULT]);
 	ofono_call_barring_create(modem, 0, "atmodem", data->chat[AT_DEFAULT]);
-	ofono_ssn_create(modem, 0, "atmodem", data->chat[AT_DEFAULT]);
 	ofono_call_volume_create(modem, 0, "atmodem", data->chat[AT_DEFAULT]);
 	ofono_cbs_create(modem, 0, "atmodem", data->chat[AT_DEFAULT]);
 

index f58f33d..257113e 100644
@@ -44,7 +44,6 @@
 #include <ofono/phonebook.h>
 #include <ofono/sim.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/voicecall.h>
 

@@ -208,7 +207,6 @@ static void tc65_post_online(struct ofono_modem *modem)
 	ofono_netreg_create(modem, 0, "atmodem", chat);
 	ofono_call_meter_create(modem, 0, "atmodem", chat);
 	ofono_call_barring_create(modem, 0, "atmodem", chat);
-	ofono_ssn_create(modem, 0, "atmodem", chat);
 
 	gprs = ofono_gprs_create(modem, 0, "atmodem", chat);
 	gc = ofono_gprs_context_create(modem, 0, "atmodem", chat);

index 73bd9b1..d47d854 100644
@@ -48,7 +48,6 @@
 #include <ofono/cbs.h>
 #include <ofono/sim.h>
 #include <ofono/ussd.h>
-#include <ofono/ssn.h>
 #include <ofono/call-forwarding.h>
 #include <ofono/call-settings.h>
 #include <ofono/call-barring.h>

@@ -460,7 +459,6 @@ static void u8500_post_online(struct ofono_modem *modem)
 	ofono_netreg_create(modem, 0, "wgmodem2.5", isi->modem);
 	ofono_sms_create(modem, 0, "isimodem", isi->modem);
 	ofono_cbs_create(modem, 0, "isimodem", isi->modem);
-	ofono_ssn_create(modem, 0, "wgmodem2.5", isi->modem);
 	ofono_ussd_create(modem, 0, "isimodem", isi->modem);
 	ofono_call_settings_create(modem, 0, "isimodem", isi->modem);
 	ofono_call_barring_create(modem, 0, "isimodem", isi->modem);

index cb55f85..4d234e4 100644
@@ -44,7 +44,6 @@
 #include <ofono/phonebook.h>
 #include <ofono/sim.h>
 #include <ofono/sms.h>
-#include <ofono/ssn.h>
 #include <ofono/ussd.h>
 #include <ofono/voicecall.h>
 

@@ -156,7 +155,6 @@ static void wavecom_post_sim(struct ofono_modem *modem)
 	ofono_netreg_create(modem, 0, "atmodem", chat);
 	ofono_call_meter_create(modem, 0, "atmodem", chat);
 	ofono_call_barring_create(modem, 0, "atmodem", chat);
-	ofono_ssn_create(modem, 0, "atmodem", chat);
 	ofono_sms_create(modem, 0, "atmodem", chat);
 	ofono_phonebook_create(modem, 0, "atmodem", chat);
 

index 995a1a5..1628df3 100644
@@ -346,23 +346,6 @@ struct sms;
 int __ofono_sms_sim_download(struct ofono_stk *stk, const struct sms *msg,
 				__ofono_sms_sim_download_cb_t cb, void *data);
 
-#include <ofono/ssn.h>
-
-typedef void (*ofono_ssn_mo_notify_cb)(int index, void *user);
-typedef void (*ofono_ssn_mt_notify_cb)(int index,
-					const struct ofono_phone_number *ph,
-					void *user);
-
-unsigned int __ofono_ssn_mo_watch_add(struct ofono_ssn *ssn, int code1,
-					ofono_ssn_mo_notify_cb cb, void *user,
-					ofono_destroy_func destroy);
-gboolean __ofono_ssn_mo_watch_remove(struct ofono_ssn *ssn, unsigned int id);
-
-unsigned int __ofono_ssn_mt_watch_add(struct ofono_ssn *ssn, int code2,
-					ofono_ssn_mt_notify_cb cb, void *user,
-					ofono_destroy_func destroy);
-gboolean __ofono_ssn_mt_watch_remove(struct ofono_ssn *ssn, unsigned int id);
-
 #include <ofono/ussd.h>
 
 typedef gboolean (*ofono_ussd_ssc_cb_t)(int type,

247 lines not on this page · raw message

index f00eb08..5e6da02 100644
@@ -160,6 +160,12 @@ void ofono_voicecall_set_data(struct ofono_voicecall *vc, void *data);
 void *ofono_voicecall_get_data(struct ofono_voicecall *vc);
 int ofono_voicecall_get_next_callid(struct ofono_voicecall *vc);
 
+void ofono_voicecall_ssn_mo_notify(struct ofono_voicecall *vc, unsigned int id,
+					int code, int index);
+void ofono_voicecall_ssn_mt_notify(struct ofono_voicecall *vc, unsigned int id,
+					int code, int index,
+					const struct ofono_phone_number *ph);
+
 #ifdef __cplusplus
 }
 #endif

index ec001c0..7eee7dd 100644
@@ -70,6 +70,8 @@ struct voicecall {
 	uint8_t icon_id;
 	gboolean untracked;
 	gboolean dial_result_handled;
+	ofono_bool_t remote_held;
+	ofono_bool_t remote_multiparty;
 };
 
 struct dial_request {

@@ -400,6 +402,12 @@ static void append_voicecall_properties(struct voicecall *v,
 
 	ofono_dbus_dict_append(dict, "Multiparty", DBUS_TYPE_BOOLEAN, &mpty);
 
+	ofono_dbus_dict_append(dict, "RemoteHeld", DBUS_TYPE_BOOLEAN,
+				&v->remote_held);
+
+	ofono_dbus_dict_append(dict, "RemoteMultiparty", DBUS_TYPE_BOOLEAN,
+				&v->remote_multiparty);
+
 	if (v->message)
 		ofono_dbus_dict_append(dict, "Information",
 						DBUS_TYPE_STRING, &v->message);

@@ -1869,6 +1877,8 @@ static GDBusMethodTable manager_methods[] = {
 };
 
 static GDBusSignalTable manager_signals[] = {
+	{ "Forwarded",	 	 "s" },
+	{ "BarringActive",	 "s" },
 	{ "PropertyChanged",	"sv" },
 	{ "CallAdded",		"oa{sv}" },
 	{ "CallRemoved",	"o" },

@@ -2684,3 +2694,167 @@ void __ofono_voicecall_tone_cancel(struct ofono_voicecall *vc, int id)
 		tone_request_run(vc);
 	}
 }
+
+static void ssn_mt_forwarded_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code,
+					const struct ofono_phone_number *ph)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+	const char *path = __ofono_atom_get_path(vc->atom);
+	char *info = "incoming";
+
+	g_dbus_emit_signal(conn, path, OFONO_VOICECALL_MANAGER_INTERFACE,
+				"Forwarded",
+				DBUS_TYPE_STRING, &info,
+				DBUS_TYPE_INVALID);
+}
+
+static struct voicecall *voicecall_select(struct ofono_voicecall *vc,
+						unsigned int id, int code)
+{
+	struct voicecall *v = NULL;
+	GSList *l;
+
+	if (id != 0) {
+		l = g_slist_find_custom(vc->call_list, GUINT_TO_POINTER(id),
+				call_compare_by_id);
+
+		if (l == NULL)
+			return NULL;
+
+		v = l->data;
+	} else if (g_slist_length(vc->call_list) == 1) {
+		v = vc->call_list->data;
+
+		switch (code) {
+		case SS_MT_VOICECALL_RETRIEVED:
+			if (v->remote_held != TRUE)
+				return NULL;
+			break;
+		case SS_MT_VOICECALL_ON_HOLD:
+			if (v->remote_held == TRUE)
+				return NULL;
+			break;
+		case SS_MT_MULTIPARTY_VOICECALL:
+			if (v->remote_multiparty == TRUE)
+				return NULL;
+			break;
+		default:
+			return NULL;
+		}
+	}
+
+	return v;
+}
+
+static void ssn_mt_remote_held_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code,
+					const struct ofono_phone_number *ph)
+{
+	struct voicecall *v = voicecall_select(vc, id, code);
+	DBusConnection *conn = ofono_dbus_get_connection();
+	const char *path;
+
+	if (v == NULL)
+		return;
+
+	if (code == SS_MT_VOICECALL_ON_HOLD)
+		v->remote_held = TRUE;
+	else
+		v->remote_held = FALSE;
+
+	path = voicecall_build_path(vc, v->call);
+
+	ofono_dbus_signal_property_changed(conn, path,
+						OFONO_VOICECALL_INTERFACE,
+						"RemoteHeld", DBUS_TYPE_BOOLEAN,
+						&v->remote_held);
+}
+
+static void ssn_mt_remote_multiparty_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code,
+					const struct ofono_phone_number *ph)
+{
+	struct voicecall *v = voicecall_select(vc, id, code);
+	DBusConnection *conn = ofono_dbus_get_connection();
+	const char *path;
+
+	if (v == NULL)
+		return;
+
+	v->remote_multiparty = TRUE;
+
+	path = voicecall_build_path(vc, v->call);
+
+	ofono_dbus_signal_property_changed(conn, path,
+					OFONO_VOICECALL_INTERFACE,
+					"RemoteMultiparty", DBUS_TYPE_BOOLEAN,
+					&v->remote_multiparty);
+}
+
+void ofono_voicecall_ssn_mt_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code, int index,
+					const struct ofono_phone_number *ph)
+{
+	switch (code) {
+	case SS_MT_CALL_FORWARDED:
+		ssn_mt_forwarded_notify(vc, id, code, ph);
+		break;
+	case SS_MT_VOICECALL_ON_HOLD:
+		ssn_mt_remote_held_notify(vc, id, code, ph);
+		break;
+	case SS_MT_VOICECALL_RETRIEVED:
+		ssn_mt_remote_held_notify(vc, id, code, ph);
+		break;
+	case SS_MT_MULTIPARTY_VOICECALL:
+		ssn_mt_remote_multiparty_notify(vc, id, code, ph);
+		break;
+	}
+}
+
+static void ssn_mo_call_barred_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+	const char *path = __ofono_atom_get_path(vc->atom);
+	const char *info;
+
+	if (code == SS_MO_INCOMING_BARRING)
+		info = "remote";
+	else
+		info = "local";
+
+	g_dbus_emit_signal(conn, path, OFONO_VOICECALL_MANAGER_INTERFACE,
+				"BarringActive",
+				DBUS_TYPE_STRING, &info,
+				DBUS_TYPE_INVALID);
+}
+
+static void ssn_mo_forwarded_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+	const char *path = __ofono_atom_get_path(vc->atom);
+	char *info = "outgoing";
+
+	g_dbus_emit_signal(conn, path, OFONO_VOICECALL_MANAGER_INTERFACE,
+				"Forwarded",
+				DBUS_TYPE_STRING, &info,
+				DBUS_TYPE_INVALID);
+}
+
+void ofono_voicecall_ssn_mo_notify(struct ofono_voicecall *vc,
+					unsigned int id, int code, int index)
+{
+	switch (code) {
+	case SS_MO_OUTGOING_BARRING:
+		ssn_mo_call_barred_notify(vc, id, code);
+		break;
+	case SS_MO_INCOMING_BARRING:
+		ssn_mo_call_barred_notify(vc, id, code);
+		break;
+	case SS_MO_CALL_FORWARDED:
+		ssn_mo_forwarded_notify(vc, id, code);
+		break;
+	}
+}

index ee055da..7d70c85 100644
@@ -967,6 +967,63 @@ static void busy_notify(GAtResult *result, gpointer user_data)
 			clcc_poll_cb, vc, NULL);
 }
 
+static void cssi_notify(GAtResult *result, gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+	GAtResultIter iter;
+	int code, index;
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "+CSSI:"))
+		return;
+
+	if (!g_at_result_iter_next_number(&iter, &code))
+		return;
+
+	if (!g_at_result_iter_next_number(&iter, &index))
+		index = 0;
+
+	ofono_voicecall_ssn_mo_notify(vc, 0, code, index);
+}
+
+static void cssu_notify(GAtResult *result, gpointer user_data)
+{
+	struct ofono_voicecall *vc = user_data;
+	GAtResultIter iter;
+	int code;
+	int index = -1;
+	const char *num;
+	struct ofono_phone_number ph;
+
+	ph.number[0] = '\0';
+	ph.type = 129;
+
+	g_at_result_iter_init(&iter, result);
+
+	if (!g_at_result_iter_next(&iter, "+CSSU:"))
+		return;
+
+	if (!g_at_result_iter_next_number(&iter, &code))
+		return;
+
+	/* This field is optional, if we can't read it, try to skip it */
+	if (!g_at_result_iter_next_number(&iter, &index) &&
+			!g_at_result_iter_skip_next(&iter))
+		goto out;
+
+	if (!g_at_result_iter_next_string(&iter, &num))
+		goto out;
+
+	strncpy(ph.number, num, OFONO_MAX_PHONE_NUMBER_LENGTH);
+
+	if (!g_at_result_iter_next_number(&iter, &ph.type))
+		return;
+
+out:
+	ofono_voicecall_ssn_mt_notify(vc, 0, code, index, &ph);
+}
+
 static void vtd_query_cb(gboolean ok, GAtResult *result, gpointer user_data)
 {
 	struct ofono_voicecall *vc = user_data;

@@ -1015,6 +1072,9 @@ static void at_voicecall_initialized(gboolean ok, GAtResult *result,
 
 	/* Populate the call list */
 	g_at_chat_send(vd->chat, "AT+CLCC", clcc_prefix, clcc_cb, vc, NULL);
+
+	g_at_chat_register(vd->chat, "+CSSI:", cssi_notify, FALSE, vc, NULL);
+	g_at_chat_register(vd->chat, "+CSSU:", cssu_notify, FALSE, vc, NULL);
 }
 
 static int at_voicecall_probe(struct ofono_voicecall *vc, unsigned int vendor,

@@ -1038,6 +1098,7 @@ static int at_voicecall_probe(struct ofono_voicecall *vc, unsigned int vendor,
 	g_at_chat_send(vd->chat, "AT+CDIP=1", NULL, NULL, NULL, NULL);
 	g_at_chat_send(vd->chat, "AT+CNAP=1", NULL, NULL, NULL, NULL);
 	g_at_chat_send(vd->chat, "AT+COLP=1", NULL, NULL, NULL, NULL);
+	g_at_chat_send(vd->chat, "AT+CSSN=1,1", NULL, NULL, NULL, NULL);
 	g_at_chat_send(vd->chat, "AT+VTD?", NULL,
 				vtd_query_cb, vc, NULL);
 	g_at_chat_send(vd->chat, "AT+CCWA=1", NULL,

index 9507255..165f3b4 100644
@@ -739,6 +739,362 @@ static void isi_call_terminated_ind_cb(const GIsiMessage *msg, void *data)
 	isi_call_notify(ovc, call);
 }
 
+static gboolean decode_notify(GIsiSubBlockIter *iter)
+{
+	uint8_t byte;
+
+	if (!g_isi_sb_iter_get_byte(iter, &byte, 2))
+		return FALSE;
+
+	switch (byte) {
+	case CALL_NOTIFY_USER_SUSPENDED:
+		DBG("CALL_NOTIFY_USER_SUSPENDED");
+		break;
+
+	case CALL_NOTIFY_USER_RESUMED:
+		DBG("CALL_NOTIFY_USER_RESUMED");
+		break;
+
+	case CALL_NOTIFY_BEARER_CHANGE:
+		DBG("CALL_NOTIFY_BEARER_CHANGE");
+		break;
+
+	default:
+		DBG("Unknown notification: 0x%02X", byte);
+	}
+
+	return TRUE;
+}
+
+static gboolean decode_ss_code(GIsiSubBlockIter *iter, int *cssi, int *cssu)
+{
+	uint16_t word;
+
+	if (!g_isi_sb_iter_get_word(iter, &word, 2))
+		return FALSE;
+
+	switch (word) {
+	case CALL_SSC_ALL_FWDS:
+		DBG("Call forwarding is active");
+		break;
+
+	case CALL_SSC_ALL_COND_FWD:
+		*cssi = SS_MO_CONDITIONAL_FORWARDING;
+		DBG("Some of conditional call forwardings active");
+		break;
+
+	case CALL_SSC_CFU:
+		*cssi = SS_MO_UNCONDITIONAL_FORWARDING;
+		DBG("Unconditional call forwarding is active");
+		break;
+
+	case CALL_SSC_OUTGOING_BARR_SERV:
+		*cssi = SS_MO_OUTGOING_BARRING;
+		DBG("Outgoing calls are barred");
+		break;
+
+	case CALL_SSC_INCOMING_BARR_SERV:
+		*cssi = SS_MO_INCOMING_BARRING;
+		DBG("Incoming calls are barred");
+		break;
+
+	case CALL_SSC_CALL_WAITING:
+		DBG("Incoming calls are barred");
+		break;
+
+	case CALL_SSC_CLIR:
+		DBG("CLIR connected unknown indication.");
+		break;
+
+	case CALL_SSC_MPTY:
+		*cssu = SS_MT_MULTIPARTY_VOICECALL;
+		DBG("Multiparty call entered.");
+		break;
+
+	case CALL_SSC_CALL_HOLD:
+		*cssu = SS_MT_VOICECALL_HOLD_RELEASED;
+		DBG("Call on hold has been released.");
+		break;
+
+	default:
+		DBG("Unknown/unhandled notification: 0x%02X", word);
+		break;
+	}
+
+	return TRUE;
+}
+
+static gboolean decode_ss_status(GIsiSubBlockIter *iter)
+{
+	uint8_t byte;
+
+	if (!g_isi_sb_iter_get_byte(iter, &byte, 2))
+		return FALSE;
+
+	if (byte & CALL_SS_STATUS_ACTIVE)
+		DBG("CALL_SS_STATUS_ACTIVE");
+
+	if (byte & CALL_SS_STATUS_REGISTERED)
+		DBG("CALL_SS_STATUS_REGISTERED");
+
+	if (byte & CALL_SS_STATUS_PROVISIONED)
+		DBG("CALL_SS_STATUS_PROVISIONED");
+
+	if (byte & CALL_SS_STATUS_QUIESCENT)
+		DBG("CALL_SS_STATUS_QUIESCENT");
+
+	return TRUE;
+}
+
+static gboolean decode_ss_notify(GIsiSubBlockIter *iter, int *cssi, int *cssu)
+{
+	uint8_t byte;
+
+	if (!g_isi_sb_iter_get_byte(iter, &byte, 2))
+		return FALSE;
+
+	if (byte & CALL_SSN_INCOMING_IS_FWD) {
+		*cssu = SS_MT_CALL_FORWARDED;
+		DBG("This is a forwarded call #1.");
+	}
+
+	if (byte & CALL_SSN_INCOMING_FWD)
+		DBG("This is a forwarded call #2.");
+
+	if (byte & CALL_SSN_OUTGOING_FWD) {
+		*cssi = SS_MO_CALL_FORWARDED;
+		DBG("Call has been forwarded.");
+	}
+
+	return TRUE;
+}
+
+static gboolean decode_ss_notify_indicator(GIsiSubBlockIter *iter, int *cssi)
+{
+	uint8_t byte;
+
+	if (!g_isi_sb_iter_get_byte(iter, &byte, 2))
+		return FALSE;
+
+	if (byte & CALL_SSI_CALL_IS_WAITING) {
+		*cssi = SS_MO_CALL_WAITING;
+		DBG("Call is waiting.");
+	}
+
+	if (byte & CALL_SSI_MPTY)
+		DBG("Multiparty call");
+
+	if (byte & CALL_SSI_CLIR_SUPPR_REJ) {
+		*cssi = SS_MO_CLIR_SUPPRESSION_REJECTED;
+		DBG("CLIR suppression rejected");
+	}
+
+	return TRUE;
+}
+
+static gboolean decode_ss_hold_indicator(GIsiSubBlockIter *iter, int *cssu)
+{
+	uint8_t byte;
+
+	if (!g_isi_sb_iter_get_byte(iter, &byte, 2))
+		return FALSE;
+
+	if (byte == CALL_HOLD_IND_RETRIEVED) {
+		*cssu = SS_MT_VOICECALL_RETRIEVED;
+		DBG("Call has been retrieved");
+	} else if (byte & CALL_HOLD_IND_ON_HOLD) {
+		*cssu = SS_MT_VOICECALL_ON_HOLD;
+		DBG("Call has been put on hold");
+	} else {
+		return FALSE;
+	}
+
+	return TRUE;
+}
+
+static gboolean decode_ss_ect_indicator(GIsiSubBlockIter *iter, int *cssu)
+{
+	uint8_t byte;
+
+	if (!g_isi_sb_iter_get_byte(iter, &byte, 2))
+		return FALSE;
+
+	if (byte & CALL_ECT_CALL_STATE_ALERT) {
+		*cssu = SS_MT_VOICECALL_IN_TRANSFER;
+		DBG("Call is being connected with the remote party in "
+			"alerting state");
+	}
+
+	if (byte & CALL_ECT_CALL_STATE_ACTIVE) {
+		*cssu = SS_MT_VOICECALL_TRANSFERRED;
+		DBG("Call has been connected with the other remote "
+			"party in explicit call transfer operation.");
+	}
+
+	return TRUE;
+}
+
+static gboolean decode_remote_address(GIsiSubBlockIter *iter,
+					struct ofono_phone_number *number,
+					int *index)
+{
+	uint8_t type, len;
+	char *addr;
+
+	if (!g_isi_sb_iter_get_byte(iter, &type, 2))
+		return FALSE;
+
+	if (!g_isi_sb_iter_get_byte(iter, &len, 5))
+		return FALSE;
+
+	if (len > OFONO_MAX_PHONE_NUMBER_LENGTH)
+		return FALSE;
+
+	if (!g_isi_sb_iter_get_alpha_tag(iter, &addr, 2 * len, 6))
+		return FALSE;
+
+	strncpy(number->number, addr, len);
+	number->number[OFONO_MAX_PHONE_NUMBER_LENGTH] = '\0';
+	number->type = type;
+
+	g_free(addr);
+
+	return TRUE;
+}
+
+static gboolean decode_cug_info(GIsiSubBlockIter *iter, int *index, int *cssu)
+{
+	uint8_t pref;
+	uint8_t access;
+	uint16_t word;
+
+	if (!g_isi_sb_iter_get_byte(iter, &pref, 2))
+		return FALSE;
+
+	if (!g_isi_sb_iter_get_byte(iter, &access, 3))
+		return FALSE;
+
+	if (!g_isi_sb_iter_get_word(iter, &word, 4))
+		return FALSE;
+
+	DBG("Preferential CUG: 0x%02X", pref);
+	DBG("CUG output access: 0x%02X", access);
+
+	*index = word;
+	*cssu = SS_MO_CUG_CALL;
+
+	return TRUE;
+}
+
+static void notification_ind_cb(const GIsiMessage *msg, void *data)
+{
+	struct ofono_voicecall *ovc = data;
+	GIsiSubBlockIter iter;
+
+	struct ofono_phone_number number;
+	int index = 0;
+	int cssi = -1;
+	int cssu = -1;
+	uint8_t call_id;
+
+	if (ovc == NULL || g_isi_msg_id(msg) != CALL_GSM_NOTIFICATION_IND ||
+			!g_isi_msg_data_get_byte(msg, 0, &call_id) ||
+			(call_id & 7) == 0)
+		return;
+
+	DBG("Received CallServer notification for call: 0x%02X", call_id);
+
+	for (g_isi_sb_iter_init(&iter, msg, 2);
+			g_isi_sb_iter_is_valid(&iter);
+			g_isi_sb_iter_next(&iter)) {
+
+		switch (g_isi_sb_iter_get_id(&iter)) {
+		case CALL_GSM_NOTIFY:
+
+			if (!decode_notify(&iter))
+				return;
+
+			break;
+
+		case CALL_GSM_SS_CODE:
+
+			if (!decode_ss_code(&iter, &cssi, &cssu))
+				return;
+
+			break;
+
+		case CALL_GSM_SS_STATUS:
+
+			if (!decode_ss_status(&iter))
+				return;
+
+			break;
+
+		case CALL_GSM_SS_NOTIFY:
+
+			if (!decode_ss_notify(&iter, &cssi, &cssu))
+				return;
+
+			break;
+
+		case CALL_GSM_SS_NOTIFY_INDICATOR:
+
+			if (!decode_ss_notify_indicator(&iter, &cssi))
+				return;
+
+			break;
+
+		case CALL_GSM_SS_HOLD_INDICATOR:
+
+
+			if (!decode_ss_hold_indicator(&iter, &cssu))
+				return;
+
+			break;
+
+		case CALL_GSM_SS_ECT_INDICATOR:
+
+			if (!decode_ss_ect_indicator(&iter, &cssu))
+				return;
+
+			break;
+
+		case CALL_GSM_REMOTE_ADDRESS:
+
+			if (!decode_remote_address(&iter, &number, &index))
+				return;
+
+			break;
+
+		case CALL_GSM_REMOTE_SUBADDRESS:
+			break;
+
+		case CALL_GSM_CUG_INFO:
+
+			if (!decode_cug_info(&iter, &index, &cssu))
+				return;
+
+			break;
+
+		case CALL_ORIGIN_INFO:
+			break;
+
+		case CALL_GSM_ALERTING_PATTERN:
+			break;
+
+		case CALL_ALERTING_INFO:
+			break;
+		}
+	}
+
+	if (cssi != -1)
+		ofono_voicecall_ssn_mo_notify(ovc, call_id & 7, cssi, index);
+
+	if (cssu != -1)
+		ofono_voicecall_ssn_mt_notify(ovc, call_id & 7, cssu, index,
+						&number);
+}
+
 static void isi_call_answer_resp(const GIsiMessage *msg, void *data)
 {
 	struct isi_call_req_ctx *irc = data;

@@ -1436,6 +1792,9 @@ static void call_verify_cb(const GIsiMessage *msg, void *data)
 		DBG("Failed to request call status");
 
 	ofono_voicecall_register(ovc);
+
+	g_isi_client_ind_subscribe(ivc->client, CALL_GSM_NOTIFICATION_IND,
+					notification_ind_cb, ovc);
 }
 
 static int probe_by_resource(struct ofono_voicecall *ovc, uint8_t resource,