Merge lp:~phablet-team/ofono/vivid-update-1 into lp:~phablet-team/ofono/ubuntu

[Tony Espy]

  * grilreply.c, parcel.c, rilmodem: merge data and voice reg parsing
    This change splits the orginal parsing code for data and voice
    registration replies, cleaning up some of original parsing code
    which wasn't very elegant.
  * Makefile.am, rilmodem, src/sim*.*, include/sim.h,
    plugins/mtk.c, ril.c: enable SIM phonebook import support
  * rilmodem/sim.c, plugins/mtk.c, ril.c: fix SIM interface signals (LP: #1376250)
  * plugins/mtk.c: fix krillin slow socket disconnection (LP: #1388030)
  * Makefile.am, doc/mtk-settings-api.txt, mtkmodem,
    plugins/mtk.c, test, unit: support krillin 3g slot switch (LP: #1373388)

This change brings vivid up to the latest HEAD of the rilmodem git tree. Changes include:

 * Merge of RIL data and voice reg parsing code. This change splits the orginal parsing code for data and voice registration replies, cleaning up some of original parsing code which wasn't very elegant.

 * enable SIM phonebook import support

 * fix SIM interface signals (LP: #1376250)

 * fix krillin slow socket disconnection (LP: #1388030)

 * support krillin 3g slot switch (LP: #1373388)

[PS Jenkins bot (ps-jenkins)]

PASSED: Continuous integration, rev:6882
http://jenkins.qa.ubuntu.com/job/phablet-team-ofono-ubuntu-ci/63/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/phablet-team-ofono-ubuntu-vivid-amd64-ci/1
    SUCCESS: http://jenkins.qa.ubuntu.com/job/phablet-team-ofono-ubuntu-vivid-armhf-ci/1
        deb: http://jenkins.qa.ubuntu.com/job/phablet-team-ofono-ubuntu-vivid-armhf-ci/1/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/phablet-team-ofono-ubuntu-vivid-i386-ci/1

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/phablet-team-ofono-ubuntu-ci/63/rebuild

review: Approve (continuous-integration)

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Diff seems good, approving.

review: Approve

[Alfonso Sanchez-Beato (alfonsosanchezbeato)]

Tested on krillin, image #169, following https://wiki.ubuntu.com/Process/Merges/TestPlans/ofono

All test cases but the supplementary services ones executed and passed, plus tests for targeted bugs and new features.

=== modified file 'Makefile.am'
--- Makefile.am	2014-07-29 21:21:56 +0000
+++ Makefile.am	2014-11-20 00:09:27 +0000
@@ -146,7 +146,8 @@
 			drivers/mtkmodem/mtkreply.c \
 			drivers/mtkmodem/voicecall.c \
 			drivers/mtkmodem/gprs.c \
-			drivers/mtkmodem/radio-settings.c
+			drivers/mtkmodem/radio-settings.c \
+			drivers/mtkmodem/mtksettings.c
 
 builtin_modules += rilmodem
 builtin_sources += drivers/rilmodem/rilmodem.h \
@@ -166,8 +167,8 @@
 			drivers/rilmodem/call-settings.c \
 			drivers/rilmodem/call-forwarding.c \
 			drivers/rilmodem/radio-settings.c \
-			drivers/rilmodem/call-barring.c
-
+			drivers/rilmodem/call-barring.c \
+			drivers/rilmodem/phonebook.c
 endif
 
 if ISIMODEM

=== modified file 'debian/changelog'
--- debian/changelog	2014-10-10 08:53:32 +0000
+++ debian/changelog	2014-11-20 00:09:27 +0000
@@ -1,3 +1,19 @@
+ofono (1.12.bzr6882+14.10.20141120-0ubuntu1) UNRELEASED; urgency=medium
+
+  [ Alfonso Sanchez-Beato ]
+  * grilreply.c, parcel.c, rilmodem: merge data and voice reg parsing
+    This change splits the orginal parsing code for data and voice
+    registration replies, cleaning up some of original parsing code
+    which wasn't very elegant.
+  * Makefile.am, rilmodem, src/sim*.*, include/sim.h,
+    plugins/mtk.c, ril.c: enable SIM phonebook import support
+  * rilmodem/sim.c, plugins/mtk.c, ril.c: fix SIM interface signals (LP: #1376250)
+  * plugins/mtk.c: fix krillin slow socket disconnection (LP: #1388030)
+  * Makefile.am, doc/mtk-settings-api.txt, mtkmodem,
+    plugins/mtk.c, test, unit: support krillin 3g slot switch (LP: #1373388)
+
+ -- Ubuntu daily release <[e-mail]>  Wed, 19 Nov 2014 18:28:00 -0500
+
 ofono (1.12.bzr6880+14.10.20141010-0ubuntu1) utopic; urgency=medium
 
   [ Alfonso Sanchez-Beato ]

=== added file 'doc/mtk-settings-api.txt'
--- doc/mtk-settings-api.txt	1970-01-01 00:00:00 +0000
+++ doc/mtk-settings-api.txt	2014-11-20 00:09:27 +0000
@@ -0,0 +1,49 @@
+MediaTek settings hierarchy
+===========================
+
+Service		org.ofono
+Interface	org.ofono.MtkSettings
+Object path	[variable prefix]/{modem0,modem1,...}
+
+Methods		dict GetProperties()
+
+			Returns all MtkSettings properties. See the
+			properties section for available properties.
+
+			Possible Errors: [service].Error.InProgress
+					 [service].Error.NotImplemented
+					 [service].Error.Failed
+
+		void SetProperty(string name, variant value)
+
+			Changes the value of the specified property. Only
+			properties that are listed as readwrite are
+			changeable. On success a PropertyChanged signal
+			will be emitted.
+
+			Possible Errors: [service].Error.InProgress
+					 [service].Error.NotImplemented
+					 [service].Error.InvalidArguments
+					 [service].Error.Failed
+
+Signals		PropertyChanged(string property, variant value)
+
+			This signal indicates a changed value of the given
+			property.
+
+Properties	boolean Has3G [readwrite]
+
+			If true, the modem has 3G capabilities, otherwise it is
+			just 2G. Only one of the modems can have this set at a
+			time (note that in fact the modem hardware is shared
+			among all ofono MTK modems, and that each ofono MTK
+			modem represents one physical slot in the phone).
+
+			When we set the property to TRUE, all MTK modems are
+			reset, and after that this property will be false for
+			all modems except for the one for which we set the
+			property. Note that setting this property to FALSE is
+			not allowed to avoid confusion, as one and only one of
+			the modems must have it set to true and we can have
+			the case of more than two modems.
+

=== modified file 'drivers/mtkmodem/mtk_constants.h'
--- drivers/mtkmodem/mtk_constants.h	2014-07-28 07:12:26 +0000
+++ drivers/mtkmodem/mtk_constants.h	2014-11-20 00:09:27 +0000
@@ -30,6 +30,7 @@
 #define MTK_RIL_REQUEST_RADIO_POWERON 2033
 #define MTK_RIL_REQUEST_SET_CALL_INDICATION 2036
 #define MTK_RIL_REQUEST_GET_3G_CAPABILITY 2038
+#define MTK_RIL_REQUEST_SET_3G_CAPABILITY 2039
 #define MTK_RIL_REQUEST_SET_FD_MODE 2073
 
 /* RIL Unsolicited Messages */

=== modified file 'drivers/mtkmodem/mtkreply.c'
--- drivers/mtkmodem/mtkreply.c	2014-07-24 08:31:18 +0000
+++ drivers/mtkmodem/mtkreply.c	2014-11-20 00:09:27 +0000
@@ -35,7 +35,7 @@
 					const struct ril_msg *message)
 {
 	struct parcel rilp;
-	int sim_3g, numint, slot;
+	int slot_3g, numint;
 
 	g_ril_init_parcel(message, &rilp);
 
@@ -49,19 +49,18 @@
 	 * Bitmap with 3g capability per slot. Reply is the same regardless of
 	 * the socket used to sent the request.
 	 */
-	sim_3g = parcel_r_int32(&rilp);
+	slot_3g = parcel_r_int32(&rilp);
 
 	if (rilp.malformed) {
 		ofono_error("%s: malformed parcel", __func__);
 		goto error;
 	}
 
-	g_ril_append_print_buf(gril, "{%d}", sim_3g);
+	g_ril_append_print_buf(gril, "{%d}", slot_3g);
 	g_ril_print_response(gril, message);
 
-	slot = g_ril_get_slot(gril);
-
-	return (sim_3g >> slot) & 0x01;
+	/* Do it zero-based */
+	return slot_3g - 1;
 
 error:
 	return -1;

=== modified file 'drivers/mtkmodem/mtkrequest.c'
--- drivers/mtkmodem/mtkrequest.c	2014-06-12 10:49:29 +0000
+++ drivers/mtkmodem/mtkrequest.c	2014-11-20 00:09:27 +0000
@@ -122,3 +122,14 @@
 		g_ril_append_print_buf(gril, "%s)", print_buf);
 	}
 }
+
+void g_mtk_request_set_3g_capability(GRil *gril, struct parcel *rilp)
+{
+	int mode = g_ril_get_slot(gril) + 1;
+
+	parcel_init(rilp);
+	parcel_w_int32(rilp, 1);
+	parcel_w_int32(rilp, mode);
+
+	g_ril_append_print_buf(gril, "(%d)", mode);
+}

=== modified file 'drivers/mtkmodem/mtkrequest.h'
--- drivers/mtkmodem/mtkrequest.h	2014-06-12 10:49:29 +0000
+++ drivers/mtkmodem/mtkrequest.h	2014-11-20 00:09:27 +0000
@@ -102,6 +102,12 @@
 void g_mtk_request_set_fd_mode(GRil *gril, int mode, int param1,
 					int param2, struct parcel *rilp);
 
+/*
+ * Sets the slot to which the GRil object is connected as the one with 3G
+ * capabilities. This makes the other slot just 2G.
+ */
+void g_mtk_request_set_3g_capability(GRil *gril, struct parcel *rilp);
+
 #ifdef __cplusplus
 }
 #endif

=== added file 'drivers/mtkmodem/mtksettings.c'
--- drivers/mtkmodem/mtksettings.c	1970-01-01 00:00:00 +0000
+++ drivers/mtkmodem/mtksettings.c	2014-11-20 00:09:27 +0000
@@ -0,0 +1,261 @@
+/*
+ *
+ *  oFono - Open Source Telephony
+ *
+ *  Copyright (C) 2014  Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+#include <string.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <errno.h>
+#include <glib.h>
+#include <gdbus.h>
+#include <ofono.h>
+
+#define OFONO_API_SUBJECT_TO_CHANGE
+#include <ofono/plugin.h>
+#include <ofono/log.h>
+#include <ofono/modem.h>
+#include <ofono/dbus.h>
+
+#include "drivers/mtkmodem/mtk_constants.h"
+#include "drivers/mtkmodem/mtkrequest.h"
+#include "drivers/mtkmodem/mtkutil.h"
+#include "mtksettings.h"
+
+#define MTK_SETTINGS_INTERFACE "org.ofono.MtkSettings"
+
+struct mtk_settings_data {
+	struct ofono_modem *modem;
+	GRil *ril;
+	ofono_bool_t has_3g;
+	ofono_bool_t has_3g_pending;
+	DBusMessage *pending;
+};
+
+static void set_3g(struct mtk_settings_data *msd, ofono_bool_t has_3g)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+	const char *path = ofono_modem_get_path(msd->modem);
+	dbus_bool_t value = has_3g;
+
+	if (msd->has_3g == has_3g)
+		return;
+
+	ofono_dbus_signal_property_changed(conn, path, MTK_SETTINGS_INTERFACE,
+						"Has3G", DBUS_TYPE_BOOLEAN,
+						&value);
+	msd->has_3g = has_3g;
+}
+
+static void set_3g_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct mtk_settings_data *msd = user_data;
+	DBusMessage *reply;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: Error setting 3G", __func__);
+
+		msd->has_3g_pending = msd->has_3g;
+
+		reply = __ofono_error_failed(msd->pending);
+		__ofono_dbus_pending_reply(&msd->pending, reply);
+
+		return;
+	}
+
+	g_ril_print_response_no_args(msd->ril, message);
+
+	reply = dbus_message_new_method_return(msd->pending);
+	__ofono_dbus_pending_reply(&msd->pending, reply);
+
+	set_3g(msd, msd->has_3g_pending);
+
+	mtk_reset_all_modems();
+}
+
+static DBusMessage *set_property(DBusConnection *conn, DBusMessage *msg,
+					void *data)
+{
+	struct mtk_settings_data *msd = data;
+	DBusMessageIter iter;
+	DBusMessageIter var;
+	const char *property;
+
+	if (msd->pending)
+		return __ofono_error_busy(msg);
+
+	if (!dbus_message_iter_init(msg, &iter))
+		return __ofono_error_invalid_args(msg);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+		return __ofono_error_invalid_args(msg);
+
+	dbus_message_iter_get_basic(&iter, &property);
+	dbus_message_iter_next(&iter);
+
+	if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+		return __ofono_error_invalid_args(msg);
+
+	dbus_message_iter_recurse(&iter, &var);
+
+	if (g_strcmp0(property, "Has3G") == 0) {
+		dbus_bool_t value;
+		struct parcel rilp;
+
+		if (dbus_message_iter_get_arg_type(&var) != DBUS_TYPE_BOOLEAN)
+			return __ofono_error_invalid_args(msg);
+
+		dbus_message_iter_get_basic(&var, &value);
+
+		if (msd->has_3g_pending == (ofono_bool_t) value)
+			return dbus_message_new_method_return(msg);
+
+		/*
+		 * We can only set to true, as setting to false could be
+		 * confusing in a multi-sim environment (>2 SIM)
+		 */
+		if (value == FALSE)
+			return __ofono_error_invalid_args(msg);
+
+		g_mtk_request_set_3g_capability(msd->ril, &rilp);
+
+		if (g_ril_send(msd->ril, MTK_RIL_REQUEST_SET_3G_CAPABILITY,
+				&rilp, set_3g_cb, msd, NULL) == 0) {
+			ofono_error("%s: unable to set 3G for slot", __func__);
+			return __ofono_error_failed(msg);
+		}
+
+		msd->pending = dbus_message_ref(msg);
+		msd->has_3g_pending = value;
+
+		return NULL;
+	}
+
+	return __ofono_error_invalid_args(msg);
+}
+
+static DBusMessage *get_properties(DBusConnection *conn,
+					DBusMessage *msg, void *data)
+{
+	struct mtk_settings_data *msd = data;
+	DBusMessage *reply;
+	DBusMessageIter iter;
+	DBusMessageIter dict;
+
+	reply = dbus_message_new_method_return(msg);
+	if (reply == NULL)
+		return NULL;
+
+	dbus_message_iter_init_append(reply, &iter);
+
+	dbus_message_iter_open_container(&iter, DBUS_TYPE_ARRAY,
+					OFONO_PROPERTIES_ARRAY_SIGNATURE,
+					&dict);
+
+	ofono_dbus_dict_append(&dict, "Has3G",
+				DBUS_TYPE_BOOLEAN, &msd->has_3g);
+
+	dbus_message_iter_close_container(&iter, &dict);
+
+	return reply;
+}
+
+static const GDBusMethodTable mtk_settings_methods[] = {
+	{ GDBUS_ASYNC_METHOD("GetProperties",
+			NULL, GDBUS_ARGS({ "properties", "a{sv}" }),
+			get_properties) },
+	{ GDBUS_ASYNC_METHOD("SetProperty",
+			GDBUS_ARGS({ "property", "s" }, { "value", "v" }),
+			NULL, set_property) },
+	{ }
+};
+
+static const GDBusSignalTable mtk_settings_signals[] = {
+	{ GDBUS_SIGNAL("PropertyChanged",
+			GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+	{ }
+};
+
+
+static void register_interface(struct mtk_settings_data *msd)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+
+	if (!g_dbus_register_interface(conn, ofono_modem_get_path(msd->modem),
+					MTK_SETTINGS_INTERFACE,
+					mtk_settings_methods,
+					mtk_settings_signals,
+					NULL, msd, NULL)) {
+		ofono_error("Could not create %s interface",
+				MTK_SETTINGS_INTERFACE);
+		return;
+	}
+
+	ofono_modem_add_interface(msd->modem, MTK_SETTINGS_INTERFACE);
+}
+
+static void unregister_interface(struct mtk_settings_data *msd)
+{
+	DBusConnection *conn = ofono_dbus_get_connection();
+
+	ofono_modem_remove_interface(msd->modem, MTK_SETTINGS_INTERFACE);
+
+	g_dbus_unregister_interface(conn,
+					ofono_modem_get_path(msd->modem),
+					MTK_SETTINGS_INTERFACE);
+}
+
+struct mtk_settings_data *mtk_settings_create(struct ofono_modem *modem,
+						GRil *ril, ofono_bool_t has_3g)
+{
+	struct mtk_settings_data *msd = g_try_malloc0(sizeof(*msd));
+
+	DBG("");
+
+	if (msd == NULL) {
+		ofono_error("%s: Cannot allocate mtk_settings_data", __func__);
+		return NULL;
+	}
+
+	msd->modem = modem;
+	msd->ril = g_ril_clone(ril);
+
+	msd->has_3g = has_3g;
+	msd->has_3g_pending = has_3g;
+
+	register_interface(msd);
+
+	return msd;
+}
+
+void mtk_settings_remove(struct mtk_settings_data *msd)
+{
+	DBG("");
+
+	if (msd == NULL)
+		return;
+
+	unregister_interface(msd);
+
+	g_ril_unref(msd->ril);
+	g_free(msd);
+}

=== added file 'drivers/mtkmodem/mtksettings.h'
--- drivers/mtkmodem/mtksettings.h	1970-01-01 00:00:00 +0000
+++ drivers/mtkmodem/mtksettings.h	2014-11-20 00:09:27 +0000
@@ -0,0 +1,43 @@
+/*
+ *
+ *  MTK driver for ofono/rilmodem
+ *
+ *  Copyright (C) 2014  Canonical Ltd.
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+
+#ifndef MTKSETTINGS_H
+#define MTKSETTINGS_H
+
+#include <ofono/types.h>
+
+#include "gril.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+struct mtk_settings_data;
+
+struct mtk_settings_data *mtk_settings_create(struct ofono_modem *modem,
+						GRil *ril, ofono_bool_t has_3g);
+void mtk_settings_remove(struct mtk_settings_data *msd);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* MTKSETTINGS_H */

=== modified file 'drivers/mtkmodem/mtkutil.c'
--- drivers/mtkmodem/mtkutil.c	2014-07-28 07:12:26 +0000
+++ drivers/mtkmodem/mtkutil.c	2014-11-20 00:09:27 +0000
@@ -41,6 +41,8 @@
 		return "MTK_RIL_REQUEST_SET_CALL_INDICATION";
 	case MTK_RIL_REQUEST_GET_3G_CAPABILITY:
 		return "MTK_RIL_REQUEST_GET_3G_CAPABILITY";
+	case MTK_RIL_REQUEST_SET_3G_CAPABILITY:
+		return "MTK_RIL_REQUEST_SET_3G_CAPABILITY";
 	case MTK_RIL_REQUEST_SET_FD_MODE:
 		return "MTK_RIL_REQUEST_SET_FD_MODE";
 	default:

=== modified file 'drivers/mtkmodem/mtkutil.h'
--- drivers/mtkmodem/mtkutil.h	2014-07-31 06:45:32 +0000
+++ drivers/mtkmodem/mtkutil.h	2014-11-20 00:09:27 +0000
@@ -34,6 +34,8 @@
 void mtk_set_attach_state(struct ofono_modem *modem, ofono_bool_t attached);
 void mtk_detach_received(struct ofono_modem *modem);
 
+void mtk_reset_all_modems(void);
+
 struct mtk_gprs_data {
 	GRil *gril;
 	struct ofono_modem *modem;

=== modified file 'drivers/mtkmodem/radio-settings.c'
--- drivers/mtkmodem/radio-settings.c	2014-09-25 12:16:25 +0000
+++ drivers/mtkmodem/radio-settings.c	2014-11-20 00:09:27 +0000
@@ -132,7 +132,7 @@
 	struct radio_data *rd = ofono_radio_settings_get_data(rs);
 	ofono_radio_settings_modem_rats_query_cb_t cb = cbd->cb;
 	ofono_bool_t modem_rats[OFONO_RADIO_ACCESS_MODE_LAST] = { FALSE };
-	int is_3g;
+	int slot_3g, is_3g;
 
 	if (message->error != RIL_E_SUCCESS) {
 		ofono_error("%s: error %s", __func__,
@@ -141,13 +141,15 @@
 		return;
 	}
 
-	is_3g = g_mtk_reply_parse_get_3g_capability(rd->ril, message);
-	if (is_3g < 0) {
+	slot_3g = g_mtk_reply_parse_get_3g_capability(rd->ril, message);
+	if (slot_3g < 0) {
 		ofono_error("%s: parse error", __func__);
 		CALLBACK_WITH_FAILURE(cb, NULL, cbd->data);
 		return;
 	}
 
+	is_3g = (g_ril_get_slot(rd->ril) == slot_3g);
+
 	modem_rats[OFONO_RADIO_ACCESS_MODE_GSM] = TRUE;
 
 	if (is_3g) {

=== modified file 'drivers/rilmodem/gprs.c'
--- drivers/rilmodem/gprs.c	2014-09-26 14:34:59 +0000
+++ drivers/rilmodem/gprs.c	2014-11-20 00:09:27 +0000
@@ -175,7 +175,7 @@
 	ofono_gprs_status_cb_t cb = cbd->cb;
 	struct ofono_gprs *gprs = cbd->user;
 	struct ril_gprs_data *gd = ofono_gprs_get_data(gprs);
-	struct reply_reg_state *reply;
+	struct reply_data_reg_state *reply;
 	gboolean attached = FALSE;
 	gboolean notify_status = FALSE;
 	int old_status;
@@ -189,7 +189,8 @@
 		goto error;
 	}
 
-	if ((reply = g_ril_reply_parse_reg_state(gd->ril, message)) == NULL)
+	if ((reply = g_ril_reply_parse_data_reg_state(gd->ril, message))
+			== NULL)
 		goto error;
 
 	/*
@@ -207,8 +208,8 @@
 	 *    function.  A valid ofono cb exists.
 	 */
 
-	if (gd->rild_status != reply->status) {
-		gd->rild_status = reply->status;
+	if (gd->rild_status != reply->reg_state.status) {
+		gd->rild_status = reply->reg_state.status;
 
 		if (cb == NULL)
 			notify_status = TRUE;
@@ -219,12 +220,15 @@
 	 * attached status set by the core GPRS code ( controlled
 	 * by the ConnnectionManager's 'Powered' property ).
 	 */
-	attached = (reply->status == NETWORK_REGISTRATION_STATUS_REGISTERED ||
-			reply->status == NETWORK_REGISTRATION_STATUS_ROAMING);
+	attached = (reply->reg_state.status ==
+				NETWORK_REGISTRATION_STATUS_REGISTERED ||
+			reply->reg_state.status ==
+				NETWORK_REGISTRATION_STATUS_ROAMING);
 
 	if (attached && gd->ofono_attached == FALSE) {
 		DBG("attached=true; ofono_attached=false; return !REGISTERED");
-		reply->status = NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
+		reply->reg_state.status =
+			NETWORK_REGISTRATION_STATUS_NOT_REGISTERED;
 
 		/*
 		 * Further optimization so that if ril_status ==
@@ -234,7 +238,7 @@
 		 * As is, this results in unecessary status notify calls
 		 * when nothing has changed.
 		 */
-		if (notify_status && reply->status == old_status)
+		if (notify_status && reply->reg_state.status == old_status)
 			notify_status = FALSE;
 	}
 
@@ -278,22 +282,22 @@
 					NETWORK_REGISTRATION_STATUS_ROAMING)) {
 			DBG("calling ofono_gprs_detached_notify()");
 			ofono_gprs_detached_notify(gprs);
-			reply->tech = RADIO_TECH_UNKNOWN;
+			reply->reg_state.tech = RADIO_TECH_UNKNOWN;
 		} else {
 			DBG("calling ofono_gprs_status_notify()");
-			ofono_gprs_status_notify(gprs, reply->status);
+			ofono_gprs_status_notify(gprs, reply->reg_state.status);
 		}
 	}
 
-	if (gd->tech != reply->tech) {
-		gd->tech = reply->tech;
+	if (gd->tech != reply->reg_state.tech) {
+		gd->tech = reply->reg_state.tech;
 
 		ofono_gprs_bearer_notify(gprs,
-					ril_tech_to_bearer_tech(reply->tech));
+				ril_tech_to_bearer_tech(reply->reg_state.tech));
 	}
 
 	if (cb)
-		CALLBACK_WITH_SUCCESS(cb, reply->status, cbd->data);
+		CALLBACK_WITH_SUCCESS(cb, reply->reg_state.status, cbd->data);
 
 	g_free(reply);
 

=== modified file 'drivers/rilmodem/network-registration.c'
--- drivers/rilmodem/network-registration.c	2014-08-11 12:41:12 +0000
+++ drivers/rilmodem/network-registration.c	2014-11-20 00:09:27 +0000
@@ -129,7 +129,8 @@
 		goto error;
 	}
 
-	if ((reply = g_ril_reply_parse_reg_state(nd->ril, message)) == NULL)
+	if ((reply = g_ril_reply_parse_voice_reg_state(nd->ril, message))
+			== NULL)
 		goto error;
 
 	nd->tech = reply->tech;

=== added file 'drivers/rilmodem/phonebook.c'
--- drivers/rilmodem/phonebook.c	1970-01-01 00:00:00 +0000
+++ drivers/rilmodem/phonebook.c	2014-11-20 00:09:27 +0000
@@ -0,0 +1,1054 @@
+/*
+ *
+ *  oFono - Open Source Telephony - RIL Modem Support
+ *
+ *  Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+ *  Copyright (C) ST-Ericsson SA 2010.
+ *  Copyright (C) 2008-2011  Intel Corporation. All rights reserved.
+ *  Copyright (C) 2013 Jolla Ltd
+ *  Contact: Jussi Kangas <[e-mail]>
+ *  Copyright (C) 2014  Canonical Ltd
+ *
+ *  This program is free software; you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License version 2 as
+ *  published by the Free Software Foundation.
+ *
+ *  This program is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with this program; if not, write to the Free Software
+ *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ *
+ */
+#ifdef HAVE_CONFIG_H
+#include <config.h>
+#endif
+
+#define _GNU_SOURCE
+#include <stdio.h>
+#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/phonebook.h>
+#include <sim.h>
+#include <simfs.h>
+#include <util.h>
+
+#include "gril.h"
+#include "simutil.h"
+#include "common.h"
+
+#include "rilmodem.h"
+
+#define UNUSED	0xFF
+
+#define EXT1_CP_SUBADDRESS	1
+#define EXT1_ADDITIONAL_DATA	2
+
+/* TON (Type Of Number) See TS 24.008 */
+#define TON_MASK		0x70
+#define TON_INTERNATIONAL	0x10
+
+enum constructed_tag {
+	TYPE_1_TAG = 0xA8,
+	TYPE_2_TAG = 0xA9,
+	TYPE_3_TAG = 0xAA
+};
+
+enum file_type_tag {
+	TYPE_ADN = 0xC0,
+	TYPE_IAP = 0xC1,
+	TYPE_EXT1 = 0xC2,
+	TYPE_SNE = 0xC3,
+	TYPE_ANR = 0xC4,
+	TYPE_PBC = 0xC5,
+	TYPE_GPR = 0xC6,
+	TYPE_AAS = 0xC7,
+	TYPE_GAS = 0xC8,
+	TYPE_UID = 0xC9,
+	TYPE_EMAIL = 0xCA,
+	TYPE_CCP1 = 0xCB
+};
+
+struct pb_file_info {
+	enum constructed_tag pbr_type;
+	int file_id;
+	enum file_type_tag file_type;
+	int file_length;
+	int record_length;
+};
+
+struct record_to_read {
+	int file_id;
+	enum file_type_tag type_tag;
+	int record_length;
+	int record;
+	int adn_idx;
+	gboolean anr_ext;	/* Is it an EXT1 record for ANR? */
+	gboolean set_by_iap;	/* Type 2 file? */
+};
+
+struct phonebook_entry {
+	int entry;
+	char *name;
+	char *number;
+	char *email;
+	char *anr;
+	char *sne;
+};
+
+unsigned char sim_path[] = { 0x3F, 0x00, 0x7F, 0x10 };
+unsigned char usim_path[] = { 0x3F, 0x00, 0x7F, 0x10, 0x5F, 0x3A };
+
+/*
+ * Table for BCD to utf8 conversion. See table 4.4 in TS 31.102.
+ * BCD 0x0C indicates pause before sending following digits as DTMF tones.
+ * BCD 0x0D is a wildcard that means "any digit". These values are mapped to
+ * ',' and '?', following the Android/iPhone convention for the first and Nokia
+ * convention for the second (only OEM that I have seen that supports this
+ * feature). BCD 0x0E is reserved, we convert it to 'r'.
+ */
+static const char digit_to_utf8[] = "0123456789*#,?r\0";
+
+/* One of these for each record in EF_PBR */
+struct pb_ref_rec {
+	GSList *pb_files;	/* File ids to read (pb_file_info nodes) */
+	GSList *pb_next;	/* Next file info to read */
+	GSList *pending_records;	/* List of record_to_read */
+	GSList *next_record;	/* Next record_to_read to process */
+	GTree *phonebook;	/* Container of phonebook_entry structures */
+};
+
+struct pb_data {
+	GSList *pb_refs;
+	GSList *pb_ref_next;
+	struct ofono_sim *sim;
+	struct ofono_sim_context *sim_context;
+	const unsigned char *df_path;
+	size_t df_size;
+};
+
+static void read_info_cb(int ok, unsigned char file_status,
+				int total_length, int record_length,
+				void *userdata);
+
+static gint comp_int(gconstpointer a, gconstpointer b)
+{
+	int a_val = GPOINTER_TO_INT(a);
+	int b_val = GPOINTER_TO_INT(b);
+
+	return a_val - b_val;
+}
+
+static const struct pb_file_info *
+ext1_info(const GSList *pb_files)
+{
+	const GSList *l;
+	for (l = pb_files; l; l = l->next) {
+		const struct pb_file_info *f_info = l->data;
+		if (f_info->file_type == TYPE_EXT1)
+			return f_info;
+	}
+
+	return NULL;
+}
+
+static struct phonebook_entry *handle_adn(size_t len, const unsigned char *msg,
+					struct pb_ref_rec *ref, int adn_idx)
+{
+	unsigned name_length = len - 14;
+	unsigned number_start = name_length;
+	unsigned number_length;
+	unsigned extension_record = UNUSED;
+	unsigned i, prefix;
+	char *number = NULL;
+	char *name = sim_string_to_utf8(msg, name_length);
+	struct phonebook_entry *new_entry;
+
+	/* Length contains also TON & NPI */
+	number_length = msg[number_start];
+
+	if (number_length != UNUSED && number_length != 0) {
+		number_length--;
+		/* '+' + number + terminator */
+		number = g_try_malloc0(2 * number_length + 2);
+
+		if (number) {
+			prefix = 0;
+
+			if ((msg[number_start + 1] & TON_MASK)
+					== TON_INTERNATIONAL) {
+				number[0] = '+';
+				prefix = 1;
+			}
+
+			for (i = 0; i < number_length; i++) {
+
+				number[2 * i + prefix] =
+					digit_to_utf8[msg[number_start + 2 + i]
+							& 0x0f];
+				number[2 * i + 1 + prefix] =
+					digit_to_utf8[msg[number_start + 2 + i]
+							>> 4];
+			}
+
+			extension_record = msg[len - 1];
+		}
+	}
+
+	DBG("ADN name %s, number %s ", name, number);
+	DBG("number length %d extension_record %d",
+		2 * number_length, extension_record);
+
+	if ((name == NULL || *name == '\0') && number == NULL)
+		goto end;
+
+	new_entry = g_try_malloc0(sizeof(*new_entry));
+	if (new_entry == NULL) {
+		ofono_error("%s: out of memory", __func__);
+		goto end;
+	}
+
+	new_entry->name = name;
+	new_entry->number = number;
+
+	DBG("Creating PB entry %d with", adn_idx);
+	DBG("name %s and number %s", new_entry->name, new_entry->number);
+
+	g_tree_insert(ref->phonebook, GINT_TO_POINTER(adn_idx), new_entry);
+
+	if (extension_record != UNUSED) {
+		struct record_to_read *ext_rec =
+			g_try_malloc0(sizeof(*ext_rec));
+		const struct pb_file_info *f_info = ext1_info(ref->pb_files);
+
+		if (ext_rec && f_info) {
+			ext_rec->file_id = f_info->file_id;
+			ext_rec->type_tag = TYPE_EXT1;
+			ext_rec->record_length = f_info->record_length;
+			ext_rec->record = extension_record;
+			ext_rec->adn_idx = adn_idx;
+
+			ref->pending_records =
+				g_slist_prepend(ref->pending_records, ext_rec);
+		}
+	}
+
+	return new_entry;
+
+end:
+	g_free(name);
+	g_free(number);
+
+	return NULL;
+}
+
+static void handle_iap(size_t len, const unsigned char *msg,
+			struct pb_ref_rec *ref,
+			const struct record_to_read *rec_data)
+{
+	GSList *l;
+	size_t i = 0;
+
+	for (l = ref->pb_files; l; l = l->next) {
+		struct pb_file_info *f_info = l->data;
+		if (f_info->pbr_type == TYPE_2_TAG) {
+			if (i >= len) {
+				ofono_error("%s: EF_IAP record too small",
+						__func__);
+				return;
+			}
+			if (msg[i] != UNUSED) {
+				struct record_to_read *new_rec =
+					g_try_malloc0(sizeof(*new_rec));
+				if (new_rec == NULL) {
+					ofono_error("%s: OOM", __func__);
+					return;
+				}
+				DBG("type 0x%X record %d",
+					f_info->file_type, msg[i]);
+
+				new_rec->file_id = f_info->file_id;
+				new_rec->type_tag = f_info->file_type;
+				new_rec->record_length = f_info->record_length;
+				new_rec->record = msg[i];
+				new_rec->adn_idx = rec_data->adn_idx;
+				new_rec->anr_ext = FALSE;
+				new_rec->set_by_iap = TRUE;
+
+				ref->pending_records =
+					g_slist_prepend(ref->pending_records,
+							new_rec);
+			}
+			++i;
+		}
+	}
+}
+
+static void handle_sne(size_t len, const unsigned char *msg,
+			struct pb_ref_rec *ref,
+			const struct record_to_read *rec_data)
+{
+	char *sne;
+
+	/* There are additional fields for type 2 files */
+	if (rec_data->set_by_iap)
+		len -= 2;
+
+	sne = sim_string_to_utf8(msg, len);
+
+	if (sne && *sne != '\0') {
+		struct phonebook_entry *entry;
+
+		entry = g_tree_lookup(ref->phonebook,
+				GINT_TO_POINTER(rec_data->adn_idx));
+		if (entry) {
+			/* If one already exists, delete it */
+			if (entry->sne)
+				g_free(entry->sne);
+
+			DBG("Adding SNE %s to %d", sne, rec_data->adn_idx);
+			DBG("name %s", entry->name);
+
+			entry->sne = sne;
+		} else {
+			g_free(sne);
+		}
+	} else {
+		g_free(sne);
+	}
+}
+
+static void handle_anr(size_t len,
+			const unsigned char *msg,
+			struct pb_ref_rec *ref,
+			const struct record_to_read *rec_data)
+{
+	unsigned number_length;
+	unsigned extension_record;
+	unsigned aas_record;
+	unsigned i, prefix;
+	char *anr;
+	struct phonebook_entry *entry;
+
+	if (len < 15) {
+		ofono_error("%s: bad EF_ANR record size", __func__);
+		return;
+	}
+
+	aas_record = msg[0];
+	if (aas_record == UNUSED)
+		return;
+
+	DBG("ANR %d", aas_record);
+
+	/* Length contains also TON & NPI */
+	number_length = msg[1];
+	if (number_length < 2)
+		return;
+
+	number_length--;
+	/* '+' + number + terminator */
+	anr = g_try_malloc0(2 * number_length + 2);
+	if (anr == NULL)
+		return;
+
+	prefix = 0;
+	if ((msg[2] & TON_MASK) == TON_INTERNATIONAL) {
+		anr[0] = '+';
+		prefix = 1;
+	}
+
+	for (i = 0; i < number_length; i++) {
+		anr[2 * i + prefix] = digit_to_utf8[msg[3 + i] & 0x0f];
+		anr[2 * i + 1 + prefix] = digit_to_utf8[msg[3 + i] >> 4];
+	}
+
+	entry = g_tree_lookup(ref->phonebook,
+				GINT_TO_POINTER(rec_data->adn_idx));
+	if (entry == NULL) {
+		g_free(anr);
+		return;
+	}
+
+	/* If one already exists, delete it */
+	if (entry->anr)
+		g_free(entry->anr);
+
+	DBG("Adding ANR %s to %d", anr, rec_data->adn_idx);
+	DBG("name %s", entry->name);
+
+	entry->anr = anr;
+
+	extension_record = msg[14];
+
+	DBG("ANR to entry %d number %s number length %d",
+		rec_data->adn_idx, anr, number_length);
+	DBG("extension_record %d aas %d", extension_record, aas_record);
+
+	if (extension_record != UNUSED) {
+		struct record_to_read *ext_rec =
+			g_try_malloc0(sizeof(*ext_rec));
+		const struct pb_file_info *f_info = ext1_info(ref->pb_files);
+
+		if (ext_rec && f_info) {
+			ext_rec->file_id = f_info->file_id;
+			ext_rec->type_tag = TYPE_EXT1;
+			ext_rec->record_length = f_info->record_length;
+			ext_rec->record = extension_record;
+			ext_rec->adn_idx = rec_data->adn_idx;
+			ext_rec->anr_ext = TRUE;
+
+			ref->pending_records =
+				g_slist_prepend(ref->pending_records, ext_rec);
+		}
+	}
+}
+
+static void handle_email(size_t len, const unsigned char *msg,
+			struct pb_ref_rec *ref,
+			const struct record_to_read *rec_data)
+{
+	char *email;
+	struct phonebook_entry *entry;
+
+	/* There are additional fields for type 2 files */
+	if (rec_data->set_by_iap)
+		len -= 2;
+
+	email = sim_string_to_utf8(msg, len);
+	if (email == NULL || *email == '\0') {
+		g_free(email);
+		return;
+	}
+
+	entry = g_tree_lookup(ref->phonebook,
+				GINT_TO_POINTER(rec_data->adn_idx));
+	if (entry == NULL) {
+		g_free(email);
+		return;
+	}
+
+	/* if one already exists, delete it */
+	if (entry->email)
+		g_free(entry->email);
+
+	DBG("Adding email to entry %d", rec_data->adn_idx);
+	DBG("name %s", entry->name);
+
+	entry->email = email;
+}
+
+static void handle_ext1(size_t len, const unsigned char *msg,
+			struct pb_ref_rec *ref,
+			const struct record_to_read *rec_data)
+{
+	unsigned number_length, i, next_extension_record;
+	struct phonebook_entry *entry;
+	char *ext_number;
+
+	if (len < 13) {
+		ofono_error("%s: bad EF_EXT1 record size", __func__);
+		return;
+	}
+
+	/* Check if there is more extension data */
+	next_extension_record = msg[12];
+	if (next_extension_record != UNUSED) {
+		struct record_to_read *ext_rec =
+			g_try_malloc0(sizeof(*ext_rec));
+		const struct pb_file_info *f_info = ext1_info(ref->pb_files);
+
+		if (ext_rec && f_info) {
+			DBG("next_extension_record %d", next_extension_record);
+
+			ext_rec->file_id = f_info->file_id;
+			ext_rec->record_length = f_info->record_length;
+			ext_rec->type_tag = TYPE_EXT1;
+			ext_rec->record = next_extension_record;
+			ext_rec->adn_idx = rec_data->adn_idx;
+			ext_rec->anr_ext = rec_data->anr_ext;
+
+			ref->pending_records =
+				g_slist_prepend(ref->pending_records, ext_rec);
+		}
+	}
+
+	if (msg[0] != EXT1_ADDITIONAL_DATA) {
+		DBG("EXT1 record with subaddress ignored");
+		return;
+	}
+
+	number_length = msg[1];
+	ext_number = g_try_malloc0(2 * number_length + 1);
+	if (ext_number == NULL)
+		return;
+
+	for (i = 0; i < number_length; i++) {
+		ext_number[2 * i] = digit_to_utf8[msg[2 + i] & 0x0f];
+		ext_number[2 * i + 1] = digit_to_utf8[msg[2 + i] >> 4];
+	}
+
+	DBG("Number extension %s", ext_number);
+	DBG("number length %d", number_length);
+
+	DBG("Looking for ADN entry %d", rec_data->adn_idx);
+	entry = g_tree_lookup(ref->phonebook,
+				GINT_TO_POINTER(rec_data->adn_idx));
+	if (entry == NULL) {
+		g_free(ext_number);
+		return;
+	}
+
+	if (rec_data->anr_ext) {
+		char *anr = entry->anr;
+		entry->anr = g_strconcat(anr, ext_number, NULL);
+		g_free(anr);
+	} else {
+		char *number = entry->number;
+		entry->number = g_strconcat(number, ext_number, NULL);
+		g_free(number);
+	}
+
+	g_free(ext_number);
+}
+
+static const char *file_tag_to_string(enum file_type_tag tag)
+{
+	switch (tag) {
+	case TYPE_ADN: return "ADN";
+	case TYPE_IAP: return "IAP";
+	case TYPE_EXT1: return "EXT1";
+	case TYPE_SNE: return "SNE";
+	case TYPE_ANR: return "ANR";
+	case TYPE_PBC: return "PBC";
+	case TYPE_GPR: return "GPR";
+	case TYPE_AAS: return "AAS";
+	case TYPE_GAS: return "GAS";
+	case TYPE_UID: return "UID";
+	case TYPE_EMAIL: return "EMAIL";
+	case TYPE_CCP1: return "CCP1";
+	default: return "<UNKNOWN>";
+	}
+}
+
+static void decode_read_response(const struct record_to_read *rec_data,
+					const unsigned char *msg, size_t len,
+					struct pb_ref_rec *ref)
+{
+	DBG("Decoding %s type record", file_tag_to_string(rec_data->type_tag));
+	switch (rec_data->type_tag) {
+	case TYPE_IAP:
+		handle_iap(len, msg, ref, rec_data);
+		break;
+	case TYPE_SNE:
+		handle_sne(len, msg, ref, rec_data);
+		break;
+	case TYPE_ANR:
+		handle_anr(len, msg, ref, rec_data);
+		break;
+	case TYPE_EMAIL:
+		handle_email(len, msg, ref, rec_data);
+		break;
+	case TYPE_EXT1:
+		handle_ext1(len, msg, ref, rec_data);
+		break;
+	default:
+		DBG("Skipping type");
+		break;
+	}
+}
+
+static gboolean export_entry(gpointer key, gpointer value, gpointer data)
+{
+	struct ofono_phonebook *pb = data;
+	struct phonebook_entry *entry = value;
+
+	ofono_phonebook_entry(pb, -1,
+				entry->number, -1,
+				entry->name, -1,
+				NULL,
+				entry->anr, -1,
+				entry->sne,
+				entry->email,
+				NULL, NULL);
+
+	g_free(entry->name);
+	g_free(entry->number);
+	g_free(entry->email);
+	g_free(entry->anr);
+	g_free(entry->sne);
+	g_free(entry);
+
+	return FALSE;
+}
+
+static void export_and_return(gboolean ok, struct cb_data *cbd)
+{
+	struct ofono_phonebook *pb = cbd->user;
+	ofono_phonebook_cb_t cb = cbd->cb;
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	GSList *l;
+
+	DBG("phonebook fully read");
+
+	for (l = pbd->pb_refs; l != NULL; l = l->next) {
+		struct pb_ref_rec *ref = l->data;
+
+		g_tree_foreach(ref->phonebook, export_entry, pb);
+		g_tree_destroy(ref->phonebook);
+		g_slist_free_full(ref->pending_records, g_free);
+		g_slist_free_full(ref->pb_files, g_free);
+	}
+
+	g_slist_free_full(pbd->pb_refs, g_free);
+	pbd->pb_refs = NULL;
+
+	if (ok)
+		CALLBACK_WITH_SUCCESS(cb, cbd->data);
+	else
+		CALLBACK_WITH_FAILURE(cb, cbd->data);
+
+	g_free(cbd);
+}
+
+static void read_record_cb(int ok, int total_length, int record,
+			const unsigned char *data,
+			int record_length, void *userdata)
+{
+	struct cb_data *cbd = userdata;
+	struct ofono_phonebook *pb = cbd->user;
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	struct pb_ref_rec *ref = pbd->pb_ref_next->data;
+	struct record_to_read *rec;
+
+	if (!ok) {
+		ofono_error("%s: error %d", __func__, ok);
+		export_and_return(FALSE, cbd);
+		return;
+	}
+
+	DBG("ok %d; total_length %d; record %d; record_length %d",
+		ok, total_length, record, record_length);
+
+	rec = ref->next_record->data;
+
+	/* This call might add elements to pending_records */
+	decode_read_response(rec, data, record_length, ref);
+
+	ref->pending_records = g_slist_remove(ref->pending_records, rec);
+	g_free(rec);
+
+	if (ref->pending_records) {
+		struct record_to_read *rec;
+
+		ref->next_record = ref->pending_records;
+		rec = ref->next_record->data;
+
+		ofono_sim_read_record(pbd->sim_context, rec->file_id,
+					OFONO_SIM_FILE_STRUCTURE_FIXED,
+					rec->record,
+					rec->record_length,
+					pbd->df_path, pbd->df_size,
+					read_record_cb, cbd);
+	} else {
+		/* Read files from next EF_PBR record, if any */
+
+		pbd->pb_ref_next = pbd->pb_ref_next->next;
+		if (pbd->pb_ref_next == NULL) {
+			export_and_return(TRUE, cbd);
+		} else {
+			struct pb_ref_rec *ref;
+			struct pb_file_info *file_info;
+
+			DBG("Next EFpbr record");
+
+			ref = pbd->pb_ref_next->data;
+
+			ref->pb_next = ref->pb_files;
+			file_info = ref->pb_files->data;
+
+			if (!file_info) {
+				export_and_return(TRUE, cbd);
+			} else {
+				ofono_sim_read_info(pbd->sim_context,
+						file_info->file_id,
+						OFONO_SIM_FILE_STRUCTURE_FIXED,
+						pbd->df_path, pbd->df_size,
+						read_info_cb, cbd);
+			}
+		}
+	}
+}
+
+static void pb_adn_cb(int ok, int total_length, int record,
+			const unsigned char *data,
+			int record_length, void *userdata)
+{
+	struct cb_data *cbd = userdata;
+	struct ofono_phonebook *pb = cbd->user;
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	struct pb_ref_rec *ref = pbd->pb_ref_next->data;
+	GSList *l;
+
+	if (!ok) {
+		ofono_error("%s: error %d", __func__, ok);
+		export_and_return(FALSE, cbd);
+		return;
+	}
+
+	DBG("ok %d; total_length %d; record %d; record_length %d",
+		ok, total_length, record, record_length);
+
+	if (handle_adn(record_length, data, ref, record) != NULL) {
+		/* Add type 1 records */
+		for (l = ref->pb_files; l; l = l->next) {
+			const struct pb_file_info *f_info = l->data;
+			struct record_to_read *ext_rec;
+
+			if (f_info->pbr_type == TYPE_1_TAG &&
+					f_info->file_type != TYPE_ADN) {
+				ext_rec = g_try_malloc0(sizeof(*ext_rec));
+				if (ext_rec == NULL)
+					break;
+
+				ext_rec->file_id = f_info->file_id;
+				ext_rec->type_tag = f_info->file_type;
+				ext_rec->record_length = f_info->record_length;
+				ext_rec->record = record;
+				ext_rec->adn_idx = record;
+
+				ref->pending_records =
+					g_slist_prepend(ref->pending_records,
+							ext_rec);
+			}
+		}
+	}
+
+	if (record*record_length >= total_length) {
+		DBG("All ADN records read: reading additional files");
+
+		if (ref->pending_records) {
+			struct record_to_read *rec;
+
+			ref->next_record = ref->pending_records;
+			rec = ref->next_record->data;
+
+			ofono_sim_read_record(pbd->sim_context, rec->file_id,
+						OFONO_SIM_FILE_STRUCTURE_FIXED,
+						rec->record,
+						rec->record_length,
+						pbd->df_path, pbd->df_size,
+						read_record_cb, cbd);
+		} else {
+			export_and_return(TRUE, cbd);
+		}
+	}
+}
+
+static void read_info_cb(int ok, unsigned char file_status,
+				int total_length, int record_length,
+				void *userdata)
+{
+	struct cb_data *cbd = userdata;
+	struct ofono_phonebook *pb = cbd->user;
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	struct pb_file_info *file_info;
+	struct pb_ref_rec *ref = pbd->pb_ref_next->data;
+
+	file_info = ref->pb_next->data;
+	ref->pb_next = ref->pb_next->next;
+
+	if (ok) {
+		file_info->record_length = record_length;
+		file_info->file_length = total_length;
+
+		DBG("file id %x record length %d total_length %d",
+			file_info->file_id, record_length, total_length);
+	} else {
+		ofono_warn("%s: %x not found", __func__, file_info->file_id);
+		ref->pb_files = g_slist_remove(ref->pb_files, file_info);
+		g_free(file_info);
+	}
+
+	if (ref->pb_next == NULL) {
+		if (ref->pb_files == NULL) {
+			ofono_warn("%s: no phonebook on SIM", __func__);
+			export_and_return(FALSE, cbd);
+			return;
+		}
+
+		/* Read full contents of the master file */
+		file_info = ref->pb_files->data;
+
+		ofono_sim_read_path(pbd->sim_context, file_info->file_id,
+					OFONO_SIM_FILE_STRUCTURE_FIXED,
+					pbd->df_path, pbd->df_size,
+					pb_adn_cb, cbd);
+	} else {
+		file_info = ref->pb_next->data;
+
+		ofono_sim_read_info(pbd->sim_context, file_info->file_id,
+					OFONO_SIM_FILE_STRUCTURE_FIXED,
+					pbd->df_path, pbd->df_size,
+					read_info_cb, cbd);
+	}
+}
+
+static void start_sim_app_read(struct cb_data *cbd)
+{
+	struct ofono_phonebook *pb = cbd->user;
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	struct pb_ref_rec *ref_rec;
+	struct pb_file_info *f_info;
+	struct pb_file_info *f_ext1;
+
+	pbd->df_path = sim_path;
+	pbd->df_size = sizeof(sim_path);
+
+	ref_rec = g_try_malloc0(sizeof(*ref_rec));
+	if (ref_rec == NULL) {
+		ofono_error("%s: OOM", __func__);
+		export_and_return(FALSE, cbd);
+		return;
+	}
+
+	ref_rec->phonebook = g_tree_new(comp_int);
+
+	/* Only EF_ADN and EF_EXT1 read for SIM */
+
+	f_info = g_try_malloc0(sizeof(*f_info));
+	if (f_info == NULL) {
+		ofono_error("%s: OOM", __func__);
+		export_and_return(FALSE, cbd);
+		return;
+	}
+
+	f_info->file_id = SIM_EFADN_FILEID;
+	f_info->pbr_type = TYPE_1_TAG;
+	f_info->file_type = TYPE_ADN;
+	ref_rec->pb_files = g_slist_append(ref_rec->pb_files, f_info);
+
+	f_ext1 = g_try_malloc0(sizeof(*f_ext1));
+	if (f_ext1 == NULL) {
+		ofono_error("%s: OOM", __func__);
+		export_and_return(FALSE, cbd);
+		return;
+	}
+
+	f_ext1->file_id = SIM_EFEXT1_FILEID;
+	f_ext1->pbr_type = TYPE_3_TAG;
+	f_ext1->file_type = TYPE_EXT1;
+	ref_rec->pb_files = g_slist_append(ref_rec->pb_files, f_ext1);
+
+	pbd->pb_refs = g_slist_append(pbd->pb_refs, ref_rec);
+	pbd->pb_ref_next = pbd->pb_refs;
+
+	ref_rec->pb_next = ref_rec->pb_files;
+
+	/* Start reading process for MF */
+	ofono_sim_read_info(pbd->sim_context, f_info->file_id,
+				OFONO_SIM_FILE_STRUCTURE_FIXED,
+				pbd->df_path, pbd->df_size,
+				read_info_cb, cbd);
+}
+
+static void pb_reference_data_cb(int ok, int total_length, int record,
+					const unsigned char *sdata,
+					int record_length, void *userdata)
+{
+	struct cb_data *cbd = userdata;
+	struct ofono_phonebook *pb = cbd->user;
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	const unsigned char *ptr = sdata;
+	gboolean finished = FALSE;
+	struct pb_ref_rec *ref_rec;
+
+	DBG("total_length %d record %d record_length %d",
+		total_length, record, record_length);
+
+	if (!ok) {
+		/* We migh have a SIM instead of USIM application: try that */
+		DBG("%s: error %d, trying SIM files", __func__, ok);
+		start_sim_app_read(cbd);
+		return;
+	}
+
+	ref_rec = g_try_malloc0(sizeof(*ref_rec));
+	if (ref_rec == NULL) {
+		ofono_error("%s: OOM", __func__);
+		export_and_return(FALSE, cbd);
+		return;
+	}
+
+	ref_rec->phonebook = g_tree_new(comp_int);
+
+	while (ptr < sdata + record_length && finished == FALSE) {
+		int typelen, file_id, i;
+		enum constructed_tag pbr_type = *ptr;
+
+		switch (pbr_type) {
+		case TYPE_1_TAG:
+		case TYPE_2_TAG:
+		case TYPE_3_TAG:
+			typelen = *(ptr + 1);
+			DBG("File type=%02X, len=%d", *ptr, typelen);
+			ptr += 2;
+			i = 0;
+
+			while (i < typelen) {
+				struct pb_file_info *file_info =
+					g_try_new0(struct pb_file_info, 1);
+				if (!file_info) {
+					ofono_error("%s: OOM", __func__);
+					export_and_return(FALSE, cbd);
+					return;
+				}
+
+				file_id = (ptr[i + 2] << 8) + ptr[i + 3];
+
+				DBG("creating file info for File type=%02X",
+					ptr[i]);
+				DBG("File ID=%04X", file_id);
+
+
+				file_info->pbr_type = pbr_type;
+				file_info->file_type = ptr[i];
+				file_info->file_id = file_id;
+				/* Keep order, important for type 2 files */
+				ref_rec->pb_files =
+					g_slist_append(ref_rec->pb_files,
+							file_info);
+				i += ptr[i + 1] + 2;
+			}
+
+			ptr += typelen;
+			break;
+		default:
+			DBG("All handled %02x", *ptr);
+			finished = TRUE;
+			break;
+		}
+	}
+
+	pbd->pb_refs = g_slist_append(pbd->pb_refs, ref_rec);
+
+	if (record*record_length >= total_length) {
+		struct pb_ref_rec *ref; 
+		struct pb_file_info *file_info;
+
+		DBG("All EFpbr records read");
+
+		pbd->pb_ref_next = pbd->pb_refs;
+		ref = pbd->pb_ref_next->data;
+
+		ref->pb_next = ref->pb_files;
+		file_info = ref->pb_files->data;
+		if (file_info == NULL) {
+			ofono_error("%s: no files to read", __func__);
+			export_and_return(FALSE, cbd);
+			return;
+		}
+
+		/* Start reading process for first EF_PBR entry */
+
+		ofono_sim_read_info(pbd->sim_context, file_info->file_id,
+					OFONO_SIM_FILE_STRUCTURE_FIXED,
+					pbd->df_path, pbd->df_size,
+					read_info_cb, cbd);
+	}
+}
+
+static void ril_export_entries(struct ofono_phonebook *pb,
+				const char *storage,
+				ofono_phonebook_cb_t cb, void *data)
+{
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+	struct cb_data *cbd;
+
+	DBG("Storage %s", storage);
+
+	/* Only for SIM memory */
+	if (strcmp(storage, "SM") != 0) {
+		CALLBACK_WITH_FAILURE(cb, data);
+		return;
+	}
+
+	cbd = cb_data_new(cb, data, pb);
+
+	/* Assume USIM, change in case EF_PBR is not present */
+	pbd->df_path = usim_path;
+	pbd->df_size = sizeof(usim_path);
+
+	ofono_sim_read(pbd->sim_context, SIM_EFPBR_FILEID,
+			OFONO_SIM_FILE_STRUCTURE_FIXED,
+			pb_reference_data_cb, cbd);
+}
+
+static gboolean ril_delayed_register(gpointer user_data)
+{
+	struct ofono_phonebook *pb = user_data;
+
+	ofono_phonebook_register(pb);
+	return FALSE;
+}
+
+static int ril_phonebook_probe(struct ofono_phonebook *pb,
+				unsigned int vendor, void *user)
+{
+	struct ofono_modem *modem = user;
+	struct pb_data *pd = g_try_new0(struct pb_data, 1);
+	if (pd == NULL)
+		return -ENOMEM;
+
+	pd->sim = __ofono_atom_find(OFONO_ATOM_TYPE_SIM, modem);
+	if (pd->sim == NULL)
+		return -ENOENT;
+
+	pd->sim_context = ofono_sim_context_create(pd->sim);
+	if (pd->sim_context == NULL)
+		return -ENOENT;
+
+	ofono_phonebook_set_data(pb, pd);
+
+	g_idle_add(ril_delayed_register, pb);
+
+	return 0;
+}
+
+static void ril_phonebook_remove(struct ofono_phonebook *pb)
+{
+	struct pb_data *pbd = ofono_phonebook_get_data(pb);
+
+	ofono_phonebook_set_data(pb, NULL);
+	ofono_sim_context_free(pbd->sim_context);
+
+	g_free(pbd);
+}
+
+static struct ofono_phonebook_driver driver = {
+	.name		= RILMODEM,
+	.probe		= ril_phonebook_probe,
+	.remove		= ril_phonebook_remove,
+	.export_entries	= ril_export_entries
+};
+
+void ril_phonebook_init(void)
+{
+	ofono_phonebook_driver_register(&driver);
+}
+
+void ril_phonebook_exit(void)
+{
+	ofono_phonebook_driver_unregister(&driver);
+}

=== modified file 'drivers/rilmodem/radio-settings.c'
--- drivers/rilmodem/radio-settings.c	2014-07-24 08:31:18 +0000
+++ drivers/rilmodem/radio-settings.c	2014-11-20 00:09:27 +0000
@@ -118,8 +118,16 @@
 		return;
 	}
 
+	/*
+	 * GSM_WCDMA_AUTO -> ril.h: GSM/WCDMA (auto mode, according to PRL)
+	 * PRL: preferred roaming list.
+	 * This value is returned when selecting the slot as having 3G
+	 * capabilities, so it is sort of the default for MTK modems.
+	 */
+
 	switch (pref) {
 	case PREF_NET_TYPE_GSM_WCDMA:
+	case PREF_NET_TYPE_GSM_WCDMA_AUTO:
 		mode = OFONO_RADIO_ACCESS_MODE_UMTS;
 		break;
 	case PREF_NET_TYPE_GSM_ONLY:

=== modified file 'drivers/rilmodem/rilmodem.c'
--- drivers/rilmodem/rilmodem.c	2014-04-21 07:56:17 +0000
+++ drivers/rilmodem/rilmodem.c	2014-11-20 00:09:27 +0000
@@ -51,6 +51,7 @@
 	ril_call_forwarding_init();
 	ril_radio_settings_init();
 	ril_call_barring_init();
+	ril_phonebook_init();
 
 	return 0;
 }
@@ -72,6 +73,7 @@
 	ril_call_forwarding_exit();
 	ril_radio_settings_exit();
 	ril_call_barring_exit();
+	ril_phonebook_exit();
 }
 
 OFONO_PLUGIN_DEFINE(rilmodem, "RIL modem driver", VERSION,

=== modified file 'drivers/rilmodem/rilmodem.h'
--- drivers/rilmodem/rilmodem.h	2014-04-21 07:56:17 +0000
+++ drivers/rilmodem/rilmodem.h	2014-11-20 00:09:27 +0000
@@ -66,3 +66,6 @@
 
 extern void ril_call_barring_init(void);
 extern void ril_call_barring_exit(void);
+
+extern void ril_phonebook_init(void);
+extern void ril_phonebook_exit(void);

=== modified file 'drivers/rilmodem/sim.c'
--- drivers/rilmodem/sim.c	2014-10-10 02:10:48 +0000
+++ drivers/rilmodem/sim.c	2014-11-20 00:09:27 +0000
@@ -85,7 +85,6 @@
 	guint app_type;
 	gchar *app_str;
 	guint app_index;
-	gboolean sim_registered;
 	enum ofono_sim_password_type passwd_type;
 	int retries[OFONO_SIM_PASSWORD_INVALID];
 	enum ofono_sim_password_type passwd_state;
@@ -646,55 +645,56 @@
 	struct ofono_sim *sim = user_data;
 	struct sim_data *sd = ofono_sim_get_data(sim);
 	struct reply_sim_status *status;
-	guint i = 0;
-	guint search_index = -1;
-
-	if (sd->sim_registered == FALSE) {
-		/* First status request, after sim_probe() */
-		ofono_sim_register(sim);
-		sd->sim_registered = TRUE;
-
-		if (sd->ril_state_watch != NULL &&
-				!ofono_sim_add_state_watch(sim,
-						sd->ril_state_watch,
-						sd->modem, NULL))
-			ofono_error("Error registering ril sim watch");
+	guint search_index;
+
+	status = g_ril_reply_parse_sim_status(sd->ril, message);
+	if (status == NULL) {
+		ofono_error("%s: Cannot parse SIM status reply", __func__);
+		return;
 	}
 
-	if ((status = g_ril_reply_parse_sim_status(sd->ril, message))
-			!= NULL
-			&& status->card_state == RIL_CARDSTATE_PRESENT
-			&& status->num_apps) {
-
-		DBG("num_apps: %d gsm_umts_index: %d", status->num_apps,
-			status->gsm_umts_index);
-
-		/*
-		 * TODO(CDMA): need some kind of logic to
-		 * set the correct app_index,
-		 */
-		search_index = status->gsm_umts_index;
-
-		for (i = 0; i < status->num_apps; i++) {
-			struct reply_sim_app *app = status->apps[i];
-			if (i == search_index &&
-					app->app_type != RIL_APPTYPE_UNKNOWN) {
-				configure_active_app(sd, app, i);
-				break;
-			}
-		}
-
-		/*
-		 * Note: There doesn't seem to be any other way to
-		 * force the core SIM code to recheck the PIN. This
-		 * call causes the core to call the this atom's
-		 * query_passwd() function.
-		 */
-		__ofono_sim_recheck_pin(sim);
-
-	} else if (status && status->card_state == RIL_CARDSTATE_ABSENT) {
-		ofono_info("SIM card absent");
+	DBG("SIM status is %u", status->card_state);
+
+	if (status->card_state == RIL_CARDSTATE_PRESENT)
+		ofono_sim_inserted_notify(sim, TRUE);
+	else if (status && status->card_state == RIL_CARDSTATE_ABSENT)
 		ofono_sim_inserted_notify(sim, FALSE);
+	else
+		ofono_error("%s: bad SIM state (%u)",
+				__func__, status->card_state);
+
+	/* TODO(CDMA): need some kind of logic to set the correct app_index */
+	search_index = status->gsm_umts_index;
+
+	/*
+	 * We cache the current password state. Ideally this should be done by
+	 * issuing a GET_SIM_STATUS request from ril_query_passwd_state, which
+	 * is called by the core after sending a password, but unfortunately the
+	 * response to GET_SIM_STATUS is not reliable in mako when sent just
+	 * after sending the password. Some time is needed before the modem
+	 * refreshes its internal state, and when it does it sends a
+	 * SIM_STATUS_CHANGED event. In that moment we retrieve the status and
+	 * this function is executed. We call __ofono_sim_recheck_pin as it is
+	 * the only way to indicate the core to call query_passwd_state again.
+	 * An option that can be explored in the future is wait before invoking
+	 * core callback for send_passwd until we know the real password state.
+	 */
+	if (status->card_state == RIL_CARDSTATE_PRESENT
+			&& search_index < status->num_apps) {
+		struct reply_sim_app *app = status->apps[search_index];
+
+		if (app->app_type != RIL_APPTYPE_UNKNOWN) {
+			configure_active_app(sd, app, search_index);
+			DBG("passwd_state: %d", sd->passwd_state);
+
+			/*
+			 * Note: There doesn't seem to be any other way to force
+			 * the core SIM code to recheck the PIN. This call
+			 * causes the core to call the this atom's
+			 * query_passwd() function.
+			 */
+			__ofono_sim_recheck_pin(sim);
+		}
 	}
 
 	g_ril_reply_free_sim_status(status);
@@ -823,7 +823,7 @@
 		g_free(retries);
 	}
 
-	/* TODO: re-bfactor to not use macro for FAILURE;
+	/* TODO: re-factor to not use macro for FAILURE;
 	   doesn't return error! */
 	if (message->error == RIL_E_SUCCESS) {
 		CALLBACK_WITH_SUCCESS(cb, cbd->data);
@@ -992,19 +992,40 @@
 	}
 }
 
-static gboolean ril_sim_register(gpointer user)
+static gboolean listen_and_get_sim_status(gpointer user)
 {
 	struct ofono_sim *sim = user;
 	struct sim_data *sd = ofono_sim_get_data(sim);
 
- 	DBG("");
-
- 	send_get_sim_status(sim);
+	send_get_sim_status(sim);
 
 	g_ril_register(sd->ril, RIL_UNSOL_RESPONSE_SIM_STATUS_CHANGED,
 			(GRilNotifyFunc) ril_sim_status_changed, sim);
 
 	/* TODO: should we also register for RIL_UNSOL_SIM_REFRESH? */
+	return FALSE;
+}
+
+static gboolean ril_sim_register(gpointer user)
+{
+	struct ofono_sim *sim = user;
+	struct sim_data *sd = ofono_sim_get_data(sim);
+
+ 	DBG("");
+
+ 	ofono_sim_register(sim);
+
+	if (sd->ril_state_watch != NULL &&
+			!ofono_sim_add_state_watch(sim, sd->ril_state_watch,
+							sd->modem, NULL))
+		ofono_error("Error registering ril sim watch");
+
+	/*
+	 * We use g_idle_add here to make sure that the presence of the SIM
+	 * interface is signalled before signalling anything else from the said
+	 * interface, as ofono_sim_register also uses g_idle_add.
+	 */
+	g_idle_add(listen_and_get_sim_status, sim);
 
 	return FALSE;
 }
@@ -1025,7 +1046,6 @@
 	sd->app_type = RIL_APPTYPE_UNKNOWN;
 	sd->passwd_state = OFONO_SIM_PASSWORD_NONE;
 	sd->passwd_type = OFONO_SIM_PASSWORD_NONE;
-	sd->sim_registered = FALSE;
 	sd->modem = ril_data->modem;
 	sd->ril_state_watch = ril_data->ril_state_watch;
 

=== modified file 'gril/grilreply.c'
--- gril/grilreply.c	2014-09-22 17:39:35 +0000
+++ gril/grilreply.c	2014-11-20 00:09:27 +0000
@@ -45,6 +45,13 @@
 
 #define OPERATOR_NUM_PARAMS 3
 
+/* Indexes for registration state replies */
+#define RST_IX_STATE 0
+#define RST_IX_LAC 1
+#define RST_IX_CID 2
+#define RST_IX_RAT 3
+#define RDST_IX_MAXDC 5
+
 #define MTK_MODEM_MAX_CIDS 3
 
 static void ril_reply_free_operator(gpointer data)
@@ -269,183 +276,236 @@
 	return NULL;
 }
 
-struct reply_reg_state *g_ril_reply_parse_reg_state(GRil *gril,
-						const struct ril_msg *message)
-
+static void set_reg_state(GRil *gril, struct reply_reg_state *reply,
+				int i, const char *str)
 {
-	struct parcel rilp;
-	int tmp, status;
-	char *sstatus = NULL, *slac = NULL, *sci = NULL;
-	char *stech = NULL, *sreason = NULL, *smax = NULL;
-	struct reply_reg_state *reply;
+	int val;
 	char *endp;
+	int base;
 	const char *strstate;
 
-	DBG("");
-
-	/*
-	 * If no array length is present, reply is invalid.
-	 */
-	if (message->buf_len < 4) {
-		ofono_error("%s: invalid %s reply: "
-				"size too small (< 4): %d ",
-				__func__,
-				ril_request_id_to_string(message->req),
-				(int) message->buf_len);
-		return NULL;
-	}
-
-	g_ril_init_parcel(message, &rilp);
-
-	reply =	g_new0(struct reply_reg_state, 1);
-
-	/*
-	 * Size of response string array
-	 * Should be:
-	 *   >= 4 for VOICE_REG reply
-	 *   >= 5 for DATA_REG reply
-	 * But we allow a minimum of 1 (infineon, not registered case)
-	 */
-	if ((tmp = parcel_r_int32(&rilp)) < 1) {
-		ofono_error("%s: invalid %s; response array is too small: %d",
-				__func__,
-				ril_request_id_to_string(message->req),
-				tmp);
-		goto error;
-	}
-
-	sstatus = parcel_r_string(&rilp);
-	--tmp;
-	if (tmp > 0) {
-		slac = parcel_r_string(&rilp);
-		--tmp;
-	}
-	if (tmp > 0) {
-		sci = parcel_r_string(&rilp);
-		--tmp;
-	}
-	if (tmp > 0) {
-		stech = parcel_r_string(&rilp);
-		--tmp;
-	}
-
-	/*
-	 * FIXME: need to review VOICE_REGISTRATION response
-	 * as it returns ~15 parameters ( vs. 6 for DATA ).
-	 *
-	 * The first four parameters are the same for both
-	 * responses ( although status includes values for
-	 * emergency calls for VOICE response ).
-	 *
-	 * Parameters 5 & 6 have different meanings for
-	 * voice & data response.
-	 */
-	if (tmp--) {
-		/* TODO: different use for CDMA */
-		sreason = parcel_r_string(&rilp);
-
-		if (tmp--) {
-			/* TODO: different use for CDMA */
-			smax = parcel_r_string(&rilp);
-
-			/*
-			 * MTK modem does not return max_cids, string for this
-			 * index actually contains the maximum data bearer
-			 * capability.
-			 */
-			if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK)
-				reply->max_cids = MTK_MODEM_MAX_CIDS;
-			else if (smax)
-				reply->max_cids = atoi(smax);
-		}
-	}
-
-
-	if (sstatus == NULL) {
-		ofono_error("%s: no status included in %s reply",
-				__func__,
-				ril_request_id_to_string(message->req));
-		goto error;
-	}
-
-	status = atoi(sstatus);
-
-	switch (status) {
-	case RIL_REG_STATE_NOT_REGISTERED:
-	case RIL_REG_STATE_REGISTERED:
-	case RIL_REG_STATE_SEARCHING:
-	case RIL_REG_STATE_DENIED:
-	case RIL_REG_STATE_UNKNOWN:
-	case RIL_REG_STATE_ROAMING:
-		/* Only valid values for ofono */
-		reply->status = status;
-		strstate = registration_status_to_string(status);
-		break;
-	case RIL_REG_STATE_EMERGENCY_NOT_REGISTERED:
-	case RIL_REG_STATE_EMERGENCY_SEARCHING:
-	case RIL_REG_STATE_EMERGENCY_DENIED:
-	case RIL_REG_STATE_EMERGENCY_UNKNOWN:
-		/* Map to states valid for ofono core */
-		reply->status = status - RIL_REG_STATE_EMERGENCY_NOT_REGISTERED;
-		strstate = sstatus;
-		break;
-	default:
-		reply->status = NETWORK_REGISTRATION_STATUS_UNKNOWN;
-		strstate = sstatus;
-		ofono_error("%s: Error unknown status code (%s)",
-				__func__, sstatus);
-	}
-
-
-	if (slac)
-		reply->lac = strtol(slac, NULL, 16);
-	else
-		reply->lac = -1;
-
-	if (sci)
-		reply->ci = strtol(sci, NULL, 16);
-	else
-		reply->ci = -1;
-
-	if (stech && *stech != '\0') {
-		reply->tech = (int) strtol(stech, &endp, 10);
-		if (*endp != '\0') {
-			ofono_error("%s: cannot parse tech: %s in %s reply",
-					__func__, stech,
-					ril_request_id_to_string(message->req));
-			reply->tech = RADIO_TECH_UNKNOWN;
-		}
-	} else {
-		ofono_error("%s: no tech included in %s reply",
-				__func__,
-				ril_request_id_to_string(message->req));
-		reply->tech = RADIO_TECH_UNKNOWN;
-	}
-
-	g_ril_append_print_buf(gril,
-				"{%s,%s,%s,%s,%s,%s}",
-				strstate,
-				slac,
-				sci,
-				ril_radio_tech_to_string(reply->tech),
-				sreason,
-				smax ? smax : "NULL");
-
-	g_ril_print_response(gril, message);
-
-	/* Free our parcel handlers */
-	g_free(sstatus);
-	g_free(slac);
-	g_free(sci);
-	g_free(stech);
-	g_free(sreason);
-	g_free(smax);
-
-	return reply;
-
-error:
-	g_free(reply);
-	return NULL;
+	if (str == NULL || *str == '\0')
+		goto no_val;
+
+	if (i == RST_IX_LAC || i == RST_IX_CID)
+		base = 16;
+	else
+		base = 10;
+
+	val = (int) strtol(str, &endp, base);
+	if (*endp != '\0')
+		goto no_val;
+
+	switch (i) {
+	case RST_IX_STATE:
+		switch (val) {
+		case RIL_REG_STATE_NOT_REGISTERED:
+		case RIL_REG_STATE_REGISTERED:
+		case RIL_REG_STATE_SEARCHING:
+		case RIL_REG_STATE_DENIED:
+		case RIL_REG_STATE_UNKNOWN:
+		case RIL_REG_STATE_ROAMING:
+			/* Only valid values for ofono */
+			strstate = registration_status_to_string(val);
+			break;
+		case RIL_REG_STATE_EMERGENCY_NOT_REGISTERED:
+		case RIL_REG_STATE_EMERGENCY_SEARCHING:
+		case RIL_REG_STATE_EMERGENCY_DENIED:
+		case RIL_REG_STATE_EMERGENCY_UNKNOWN:
+			/* Map to states valid for ofono core */
+			val -= RIL_REG_STATE_EMERGENCY_NOT_REGISTERED;
+			strstate = str;
+			break;
+		default:
+			val = NETWORK_REGISTRATION_STATUS_UNKNOWN;
+			strstate = str;
+		}
+		reply->status = val;
+		g_ril_append_print_buf(gril, "%s%s", print_buf, strstate);
+		break;
+	case RST_IX_LAC:
+		reply->lac = val;
+		g_ril_append_print_buf(gril, "%s0x%x", print_buf, val);
+		break;
+	case RST_IX_CID:
+		reply->ci = val;
+		g_ril_append_print_buf(gril, "%s0x%x", print_buf, val);
+		break;
+	case RST_IX_RAT:
+		reply->tech = val;
+		g_ril_append_print_buf(gril, "%s%s", print_buf,
+					ril_radio_tech_to_string(val));
+		break;
+	default:
+		goto no_val;
+	}
+
+	return;
+
+no_val:
+	g_ril_append_print_buf(gril, "%s%s", print_buf, str ? str : "(null)");
+}
+
+struct reply_reg_state *g_ril_reply_parse_voice_reg_state(GRil *gril,
+						const struct ril_msg *message)
+{
+	struct parcel rilp;
+	struct parcel_str_array *str_arr;
+	struct reply_reg_state *reply = NULL;
+	int i;
+
+	g_ril_init_parcel(message, &rilp);
+
+	str_arr = parcel_r_str_array(&rilp);
+	if (str_arr == NULL) {
+		ofono_error("%s: parse error for %s", __func__,
+				ril_request_id_to_string(message->req));
+		goto out;
+	}
+
+	reply =	g_try_malloc0(sizeof(*reply));
+	if (reply == NULL) {
+		ofono_error("%s: out of memory", __func__);
+		goto out;
+	}
+
+	reply->status = -1;
+	reply->lac = -1;
+	reply->ci = -1;
+
+	g_ril_append_print_buf(gril, "{");
+
+	for (i = 0; i < str_arr->num_str; ++i) {
+		char *str = str_arr->str[i];
+
+		if (i > 0)
+			g_ril_append_print_buf(gril, "%s,", print_buf);
+
+		switch (i) {
+		case RST_IX_STATE: case RST_IX_LAC:
+		case RST_IX_CID:   case RST_IX_RAT:
+			set_reg_state(gril, reply, i, str);
+			break;
+		default:
+			g_ril_append_print_buf(gril, "%s%s", print_buf,
+						str ? str : "(null)");
+		}
+	}
+
+	g_ril_append_print_buf(gril, "%s}", print_buf);
+	g_ril_print_response(gril, message);
+
+	/* As a minimum we require a valid status string */
+	if (reply->status == -1) {
+		ofono_error("%s: invalid status", __func__);
+		g_free(reply);
+		reply = NULL;
+	}
+
+out:
+	parcel_free_str_array(str_arr);
+
+	return reply;
+}
+
+static void set_data_reg_state(GRil *gril, struct reply_data_reg_state *reply,
+				int i, const char *str)
+{
+	unsigned val;
+	char *endp;
+
+	if (str == NULL || *str == '\0')
+		goto no_val;
+
+	val = (unsigned) strtoul(str, &endp, 10);
+	if (*endp != '\0')
+		goto no_val;
+
+	switch (i) {
+	case RDST_IX_MAXDC:
+		/*
+		 * MTK modem does not return max_cids, string for this index
+		 * actually contains the maximum data bearer capability.
+		 */
+		if (g_ril_vendor(gril) == OFONO_RIL_VENDOR_MTK)
+			reply->max_cids = MTK_MODEM_MAX_CIDS;
+		else
+			reply->max_cids = val;
+		g_ril_append_print_buf(gril, "%s%u", print_buf, val);
+		break;
+	default:
+		goto no_val;
+	}
+
+	return;
+
+no_val:
+	g_ril_append_print_buf(gril, "%s%s", print_buf, str ? str : "(null)");
+}
+
+struct reply_data_reg_state *g_ril_reply_parse_data_reg_state(GRil *gril,
+						const struct ril_msg *message)
+{
+	struct parcel rilp;
+	struct parcel_str_array *str_arr;
+	struct reply_data_reg_state *reply = NULL;
+	int i;
+
+	g_ril_init_parcel(message, &rilp);
+
+	str_arr = parcel_r_str_array(&rilp);
+	if (str_arr == NULL) {
+		ofono_error("%s: parse error for %s", __func__,
+				ril_request_id_to_string(message->req));
+		goto out;
+	}
+
+	reply =	g_try_malloc0(sizeof(*reply));
+	if (reply == NULL) {
+		ofono_error("%s: out of memory", __func__);
+		goto out;
+	}
+
+	reply->reg_state.status = -1;
+	reply->reg_state.lac = -1;
+	reply->reg_state.ci = -1;
+
+	g_ril_append_print_buf(gril, "{");
+
+	for (i = 0; i < str_arr->num_str; ++i) {
+		char *str = str_arr->str[i];
+
+		if (i > 0)
+			g_ril_append_print_buf(gril, "%s,", print_buf);
+
+		switch (i) {
+		case RST_IX_STATE: case RST_IX_LAC:
+		case RST_IX_CID:   case RST_IX_RAT:
+			set_reg_state(gril, &reply->reg_state, i, str);
+			break;
+		case RDST_IX_MAXDC:
+			set_data_reg_state(gril, reply, i, str);
+			break;
+		default:
+			g_ril_append_print_buf(gril, "%s%s", print_buf,
+						str ? str : "(null)");
+		}
+	}
+
+	g_ril_append_print_buf(gril, "%s}", print_buf);
+	g_ril_print_response(gril, message);
+
+	/* As a minimum we require a valid status string */
+	if (reply->reg_state.status == -1) {
+		ofono_error("%s: invalid status", __func__);
+		g_free(reply);
+		reply = NULL;
+	}
+
+out:
+	parcel_free_str_array(str_arr);
+
+	return reply;
 }
 
 void g_ril_reply_free_sim_io(struct reply_sim_io *reply)

=== modified file 'gril/grilreply.h'
--- gril/grilreply.h	2014-07-14 12:47:48 +0000
+++ gril/grilreply.h	2014-11-20 00:09:27 +0000
@@ -50,7 +50,10 @@
 	int lac;
 	int ci;
 	int tech;
-	int reason;
+};
+
+struct reply_data_reg_state {
+	struct reply_reg_state reg_state;
 	unsigned int max_cids;
 };
 
@@ -110,7 +113,9 @@
 
 gchar *g_ril_reply_parse_imsi(GRil *gril, const struct ril_msg *message);
 
-struct reply_reg_state *g_ril_reply_parse_reg_state(GRil *gril,
+struct reply_reg_state *g_ril_reply_parse_voice_reg_state(GRil *gril,
+						const struct ril_msg *message);
+struct reply_data_reg_state *g_ril_reply_parse_data_reg_state(GRil *gril,
 						const struct ril_msg *message);
 
 void g_ril_reply_free_sim_status(struct reply_sim_status *status);

=== modified file 'gril/parcel.c'
--- gril/parcel.c	2014-07-14 12:47:48 +0000
+++ gril/parcel.c	2014-11-20 00:09:27 +0000
@@ -257,3 +257,38 @@
 {
 	return (p->size - p->offset);
 }
+
+struct parcel_str_array *parcel_r_str_array(struct parcel *p)
+{
+	int i;
+	struct parcel_str_array *str_arr;
+	int num_str = parcel_r_int32(p);
+
+	if (p->malformed || num_str <= 0)
+		return NULL;
+
+	str_arr = g_try_malloc0(sizeof(*str_arr) + num_str * sizeof(char *));
+	if (str_arr == NULL)
+		return NULL;
+
+	str_arr->num_str = num_str;
+	for (i = 0; i < num_str; ++i)
+		str_arr->str[i] = parcel_r_string(p);
+
+	if (p->malformed) {
+		parcel_free_str_array(str_arr);
+		return NULL;
+	}
+
+	return str_arr;
+}
+
+void parcel_free_str_array(struct parcel_str_array *str_arr)
+{
+	if (str_arr) {
+		int i;
+		for (i = 0; i < str_arr->num_str; ++i)
+			g_free(str_arr->str[i]);
+		g_free(str_arr);
+	}
+}

=== modified file 'gril/parcel.h'
--- gril/parcel.h	2014-07-14 12:47:48 +0000
+++ gril/parcel.h	2014-11-20 00:09:27 +0000
@@ -32,6 +32,11 @@
 	int malformed;
 };
 
+struct parcel_str_array {
+	int num_str;
+	char *str[];
+};
+
 void parcel_init(struct parcel *p);
 void parcel_grow(struct parcel *p, size_t size);
 void parcel_free(struct parcel *p);
@@ -42,5 +47,7 @@
 int parcel_w_raw(struct parcel *p, const void *data, size_t len);
 void *parcel_r_raw(struct parcel *p,  int *len);
 size_t parcel_data_avail(struct parcel *p);
+struct parcel_str_array *parcel_r_str_array(struct parcel *p);
+void parcel_free_str_array(struct parcel_str_array *str_arr);
 
 #endif

=== modified file 'include/sim.h'
--- include/sim.h	2013-11-11 10:37:01 +0000
+++ include/sim.h	2014-11-20 00:09:27 +0000
@@ -104,6 +104,11 @@
 typedef void (*ofono_sim_file_read_cb_t)(int ok, int total_length, int record,
 					const unsigned char *data,
 					int record_length, void *userdata);
+
+typedef void (*ofono_sim_read_info_cb_t)(int ok, unsigned char file_status,
+					int total_length, int record_length,
+					void *userdata);
+
 typedef void (*ofono_sim_file_changed_cb_t)(int id, void *userdata);
 
 typedef void (*ofono_sim_file_write_cb_t)(int ok, void *userdata);
@@ -220,7 +225,8 @@
 struct ofono_sim_context *ofono_sim_context_create(struct ofono_sim *sim);
 void ofono_sim_context_free(struct ofono_sim_context *context);
 
-/* This will queue an operation to read all available records with id from the
+/*
+ * This will queue an operation to read all available records with id from the
  * SIM.  Callback cb will be called every time a record has been read, or once
  * if an error has occurred.  For transparent files, the callback will only
  * be called once.
@@ -231,6 +237,22 @@
 			enum ofono_sim_file_structure expected,
 			ofono_sim_file_read_cb_t cb, void *data);
 
+int ofono_sim_read_path(struct ofono_sim_context *context, int id,
+			enum ofono_sim_file_structure expected_type,
+			const unsigned char *path, unsigned int path_len,
+			ofono_sim_file_read_cb_t cb, void *data);
+
+int ofono_sim_read_info(struct ofono_sim_context *context, int id,
+			enum ofono_sim_file_structure expected_type,
+			const unsigned char *path, unsigned int pth_len,
+			ofono_sim_read_info_cb_t cb, void *data);
+
+int ofono_sim_read_record(struct ofono_sim_context *context, int id,
+				enum ofono_sim_file_structure expected_type,
+				int record, int record_length,
+				const unsigned char *path, unsigned int pth_len,
+				ofono_sim_file_read_cb_t cb, void *data);
+
 int ofono_sim_write(struct ofono_sim_context *context, int id,
 			ofono_sim_file_write_cb_t cb,
 			enum ofono_sim_file_structure structure, int record,

=== modified file 'plugins/mtk.c'
--- plugins/mtk.c	2014-09-16 08:03:09 +0000
+++ plugins/mtk.c	2014-11-20 00:09:27 +0000
@@ -66,6 +66,8 @@
 #include "drivers/mtkmodem/mtk_constants.h"
 #include "drivers/mtkmodem/mtkutil.h"
 #include "drivers/mtkmodem/mtkrequest.h"
+#include "drivers/mtkmodem/mtkreply.h"
+#include "drivers/mtkmodem/mtksettings.h"
 
 #define MAX_SIM_STATUS_RETRIES 15
 
@@ -76,16 +78,25 @@
 #define SIM_2_ACTIVE 2
 #define NO_SIM_ACTIVE 0
 
+#define SOCKET_NUM_FOR_DBG_0 -1
+#define SOCKET_NUM_FOR_DBG_1 -2
+
 /* this gives 30s for rild to initialize */
 #define RILD_MAX_CONNECT_RETRIES 5
 #define RILD_CONNECT_RETRY_TIME_S 5
 
+#define T_WAIT_DISCONN_MS 1000
+
+static const char hex_slot_0[] = "Slot 0: ";
+static const char hex_slot_1[] = "Slot 1: ";
+
 typedef void (*pending_cb_t)(struct cb_data *cbd);
 
 struct mtk_data {
 	GRil *modem;
 	int sim_status_retries;
 	ofono_bool_t ofono_online;
+	ofono_bool_t ofono_online_target;
 	int radio_state;
 	struct ofono_sim *sim;
 	/* pending_* are used in case we are disconnected from the socket */
@@ -106,8 +117,12 @@
 	struct ofono_call_settings *call_settings;
 	struct ofono_call_forwarding *call_forwarding;
 	struct ofono_call_barring *call_barring;
+	struct ofono_phonebook *phonebook;
 	struct ofono_gprs *gprs;
 	struct ofono_message_waiting *message_waiting;
+	struct ofono_modem *ofono_modem;
+	ofono_bool_t has_3g;
+	struct mtk_settings_data *mtk_settings;
 };
 
 /*
@@ -119,11 +134,27 @@
 static struct mtk_data *mtk_0;
 static struct mtk_data *mtk_1;
 
-static void send_get_sim_status(struct ofono_modem *modem);
+/* Some variables control global state of the modem and are then static */
+static gboolean disconnect_expected;
+static guint not_disconn_cb_id;
+
+struct socket_data {
+	GRil *gril;
+	const char *path;
+	int radio_state;
+	guint radio_state_ev_id;
+};
+
+static struct socket_data *sock_0, *sock_1;
+
 static int create_gril(struct ofono_modem *modem);
 static gboolean mtk_connected(gpointer user_data);
 static void mtk_set_online(struct ofono_modem *modem, ofono_bool_t online,
 				ofono_modem_online_cb_t callback, void *data);
+static void query_3g_caps(struct socket_data *sock);
+static void socket_disconnected(gpointer user_data);
+static void start_slot(struct mtk_data *ril, struct socket_data *sock,
+			const char *hex_prefix);
 
 static void mtk_debug(const char *str, void *user_data)
 {
@@ -140,6 +171,14 @@
 		return mtk_0;
 }
 
+static struct socket_data *socket_complement(struct socket_data *sock)
+{
+	if (sock == sock_0)
+		return sock_1;
+	else
+		return sock_0;
+}
+
 /*
  * mtk_set_attach_state and mtk_detach_received are called by mtkmodem's gprs
  * driver. They are needed to solve an issue with data attachment: in case
@@ -191,13 +230,34 @@
 	}
 }
 
-static gboolean sim_status_retry(gpointer user_data)
+static void radio_state_changed(struct ril_msg *message, gpointer user_data)
 {
-	struct ofono_modem *modem = user_data;
-	send_get_sim_status(modem);
-
-	/* Makes this a single shot */
-	return FALSE;
+	struct socket_data *sock = user_data;
+	int radio_state = g_ril_unsol_parse_radio_state_changed(sock->gril,
+								message);
+
+	if (radio_state != sock->radio_state) {
+		struct socket_data *sock_c = socket_complement(sock);
+
+		ofono_info("%s, state: %s", __func__,
+				ril_radio_state_to_string(radio_state));
+
+		/*
+		 * If there is just one slot, just start it. Otherwise, we ask
+		 * who owns the 3G capabilities in case both slots have already
+		 * radio state different from UNAVAILABLE.
+		 */
+		if (mtk_1 == NULL) {
+			mtk_0->has_3g = TRUE;
+			start_slot(mtk_0, sock, hex_slot_0);
+		} else if (sock->radio_state == RADIO_STATE_UNAVAILABLE &&
+				sock_c != NULL && sock_c->radio_state !=
+						RADIO_STATE_UNAVAILABLE) {
+			query_3g_caps(sock);
+		}
+
+		sock->radio_state = radio_state;
+	}
 }
 
 static void mtk_radio_state_changed(struct ril_msg *message, gpointer user_data)
@@ -214,9 +274,6 @@
 				ril_radio_state_to_string(radio_state),
 				ril->ofono_online);
 
-		if (ril->radio_state == RADIO_STATE_UNAVAILABLE)
-			mtk_connected(modem);
-
 		ril->radio_state = radio_state;
 
 		switch (radio_state) {
@@ -269,65 +326,6 @@
 	}
 }
 
-static void sim_status_cb(struct ril_msg *message, gpointer user_data)
-{
-	struct ofono_modem *modem = user_data;
-	struct mtk_data *ril = ofono_modem_get_data(modem);
-	struct reply_sim_status *status;
-
-	DBG("slot %d", ril->slot);
-
-	if (message->error != RIL_E_SUCCESS) {
-		ril->sim_status_retries++;
-
-		ofono_error("[slot %d] GET_SIM_STATUS request failed: "
-				"%s; retries: %d",
-				ril->slot, ril_error_to_string(message->error),
-				ril->sim_status_retries);
-
-		if (ril->sim_status_retries < MAX_SIM_STATUS_RETRIES)
-			g_timeout_add_seconds(2, sim_status_retry, modem);
-		else
-			ofono_error("[slot %d] Max retries for GET_SIM_STATUS"
-					" exceeded!", ril->slot);
-	} else {
-
-		/* Register for changes in SIM insertion */
-		g_ril_register(ril->modem, MTK_RIL_UNSOL_SIM_PLUG_OUT,
-				sim_removed, modem);
-		g_ril_register(ril->modem, MTK_RIL_UNSOL_SIM_PLUG_IN,
-				sim_inserted, modem);
-
-		if ((status = g_ril_reply_parse_sim_status(ril->modem, message))
-				!= NULL) {
-
-			if (status->card_state == RIL_CARDSTATE_PRESENT) {
-				DBG("Card PRESENT; num_apps: %d",
-					status->num_apps);
-
-				ofono_sim_inserted_notify(ril->sim, TRUE);
-			} else {
-				ofono_warn("[slot %d] Card NOT_PRESENT",
-						ril->slot);
-
-				ofono_sim_inserted_notify(ril->sim, FALSE);
-			}
-			g_ril_reply_free_sim_status(status);
-		}
-	}
-}
-
-static void send_get_sim_status(struct ofono_modem *modem)
-{
-	struct mtk_data *ril = ofono_modem_get_data(modem);
-
-	DBG("slot %d", ril->slot);
-
-	if (g_ril_send(ril->modem, RIL_REQUEST_GET_SIM_STATUS, NULL,
-			sim_status_cb, modem, NULL) == 0)
-		ofono_error("%s: failure sending request", __func__);
-}
-
 static int mtk_probe(struct ofono_modem *modem)
 {
 	struct mtk_data *ril = g_try_new0(struct mtk_data, 1);
@@ -349,6 +347,8 @@
 
 	DBG("slot %d", ril->slot);
 
+	ril->ofono_modem = modem;
+
 	ofono_modem_set_data(modem, ril);
 
 	return 0;
@@ -434,7 +434,9 @@
 		ril->call_barring =
 			ofono_call_barring_create(modem, OFONO_RIL_VENDOR_MTK,
 							RILMODEM, ril->modem);
-
+		ril->phonebook =
+			ofono_phonebook_create(modem, OFONO_RIL_VENDOR_MTK,
+						RILMODEM, modem);
 		ril->gprs = ofono_gprs_create(modem, OFONO_RIL_VENDOR_MTK,
 						MTKMODEM, &gprs_data);
 
@@ -470,6 +472,10 @@
 			ofono_gprs_remove(ril->gprs);
 			ril->gprs = NULL;
 		}
+		if (ril->phonebook) {
+			ofono_phonebook_remove(ril->phonebook);
+			ril->phonebook = NULL;
+		}
 		if (ril->call_barring) {
 			ofono_call_barring_remove(ril->call_barring);
 			ril->call_barring = NULL;
@@ -515,9 +521,11 @@
 	ofono_radio_settings_create(modem, OFONO_RIL_VENDOR_MTK,
 					MTKMODEM, ril->modem);
 
-	/* Ask sim status */
-	ril->sim_status_retries = 0;
-	send_get_sim_status(modem);
+	/* Register for changes in SIM insertion */
+	g_ril_register(ril->modem, MTK_RIL_UNSOL_SIM_PLUG_OUT,
+			sim_removed, modem);
+	g_ril_register(ril->modem, MTK_RIL_UNSOL_SIM_PLUG_IN,
+			sim_inserted, modem);
 }
 
 static void mtk_sim_mode_cb(struct ril_msg *message, gpointer user_data)
@@ -540,11 +548,18 @@
 		CALLBACK_WITH_FAILURE(cb, cbd->data);
 	}
 
+	if (ril->ofono_online)
+		ril->mtk_settings =
+			mtk_settings_create(ril->ofono_modem, ril->modem,
+						ril->has_3g);
+	else
+		mtk_settings_remove(ril->mtk_settings);
+
 	/* Execute possible pending operation on the other modem */
 
 	ril_c = ril_complement(ril);
 
-	if (ril_c->pending_online_cbd) {
+	if (ril_c != NULL && ril_c->pending_online_cbd) {
 		struct cb_data *pending_cbd = ril_c->pending_online_cbd;
 		ofono_modem_online_cb_t pending_cb = pending_cbd->cb;
 
@@ -594,6 +609,18 @@
 	}
 }
 
+static gboolean no_disconnect_case(gpointer user_data)
+{
+	struct cb_data *cbd = user_data;
+
+	ofono_info("%s: Execute pending sim mode switch", __func__);
+	not_disconn_cb_id = 0;
+
+	mtk_send_sim_mode(mtk_sim_mode_cb, cbd);
+
+	return FALSE;
+}
+
 static void poweron_cb(struct ril_msg *message, gpointer user_data)
 {
 	struct cb_data *cbd = user_data;
@@ -603,10 +630,41 @@
 
 	DBG("");
 
+	/*
+	 * MTK's rild behavior when a POWERON is sent to it is different
+	 * depending on whether a previous POWEROFF had been sent. When
+	 * the modem is initialized during device startup, POWERON is
+	 * sent without a prior POWEROFF, rild responds with an OK reply,
+	 * and the modem is brought up. Any subsequent POWERON requests
+	 * are sent whenever both modems have been offlined before ( meaning a
+	 * POWEROFF has been sent prior ). rild may respond to the POWERON
+	 * request, but will usually ( always? ) trigger a socket disconnect in
+	 * this case.
+	 *
+	 * This means there's a race condition between the POWERON reply
+	 * callback and the socket disconnect function ( which triggers a
+	 * SIM_MODE_SWITCH request ). In some cases rild is slower than
+	 * usual closing the socket, so we add a timeout to avoid following
+	 * the code path used when there is not a disconnection. Otherwise,
+	 * there would be a race and some requests would return errors due to
+	 * having been sent through the about-to-be-disconnected socket, leaving
+	 * ofono in an inconsistent state. So, we delay sending the
+	 * SIM_MODE_SWITCH for 1s, to allow the disconnect to happen when we
+	 * know that we have sent previously a POWEROFF.
+	 *
+	 * Also, I saw once that sending SIM_MODE while the
+	 * socket was being disconnected provoked a crash due to SIGPIPE being
+	 * issued. The timeout should also fix this.
+	 */
+
 	if (message->error == RIL_E_SUCCESS) {
 		g_ril_print_response_no_args(ril->modem, message);
 
-		mtk_send_sim_mode(mtk_sim_mode_cb, cbd);
+		if (disconnect_expected)
+			not_disconn_cb_id = g_timeout_add(T_WAIT_DISCONN_MS,
+						no_disconnect_case, cbd);
+		else
+			mtk_send_sim_mode(mtk_sim_mode_cb, cbd);
 	} else {
 		ofono_error("%s RADIO_POWERON error %s", __func__,
 				ril_error_to_string(message->error));
@@ -632,6 +690,8 @@
 	if (message->error == RIL_E_SUCCESS) {
 		g_ril_print_response_no_args(ril->modem, message);
 
+		mtk_settings_remove(ril->mtk_settings);
+
 		CALLBACK_WITH_SUCCESS(cb, cbd->data);
 	} else {
 		ofono_error("%s: RIL error %s", __func__,
@@ -704,12 +764,47 @@
 			ofono_error("%s: failure sending request", __func__);
 			CALLBACK_WITH_FAILURE(cb, cbd->data);
 			g_free(cbd);
+		} else {
+			disconnect_expected = TRUE;
 		}
 	} else {
 		mtk_send_sim_mode(mtk_sim_mode_cb, cbd);
 	}
 }
 
+static void set_online_cb(const struct ofono_error *error, void *data)
+{
+	if (mtk_1->ofono_online_target && !mtk_1->ofono_online)
+		mtk_set_online(mtk_1->ofono_modem, TRUE, set_online_cb, NULL);
+}
+
+static void set_offline_cb(const struct ofono_error *error, void *data)
+{
+	if (mtk_1->ofono_online)
+		mtk_set_online(mtk_1->ofono_modem, FALSE, set_offline_cb, NULL);
+	else if (mtk_0->ofono_online_target)
+		mtk_set_online(mtk_0->ofono_modem, TRUE, set_online_cb, NULL);
+	else
+		mtk_set_online(mtk_1->ofono_modem, TRUE, set_online_cb, NULL);
+}
+
+void mtk_reset_all_modems(void)
+{
+	if (!mtk_0->ofono_online && !mtk_1->ofono_online)
+		return;
+
+	mtk_0->ofono_online_target = mtk_0->ofono_online;
+	mtk_1->ofono_online_target = mtk_1->ofono_online;
+
+	ofono_modem_set_powered(mtk_0->ofono_modem, FALSE);
+	ofono_modem_set_powered(mtk_1->ofono_modem, FALSE);
+
+	if (mtk_0->ofono_online)
+		mtk_set_online(mtk_0->ofono_modem, FALSE, set_offline_cb, NULL);
+	else
+		mtk_set_online(mtk_1->ofono_modem, FALSE, set_offline_cb, NULL);
+}
+
 static void create_atoms_on_connection(struct ofono_modem *modem)
 {
 	struct mtk_data *ril = ofono_modem_get_data(modem);
@@ -728,14 +823,97 @@
 {
 	struct mtk_data *ril = ofono_modem_get_data(modem);
 
-	ofono_call_volume_remove(ril->callvolume);
+	if (__ofono_modem_find_atom(modem, OFONO_ATOM_TYPES_CALL_VOLUME))
+		ofono_call_volume_remove(ril->callvolume);
 	ril->callvolume = NULL;
-	ofono_voicecall_remove(ril->voicecall);
+	if (__ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_VOICECALL))
+		ofono_voicecall_remove(ril->voicecall);
 	ril->voicecall = NULL;
-	ofono_devinfo_remove(ril->devinfo);
+	if (__ofono_modem_find_atom(modem, OFONO_ATOM_TYPE_DEVINFO))
+		ofono_devinfo_remove(ril->devinfo);
 	ril->devinfo = NULL;
 }
 
+static void start_slot(struct mtk_data *ril, struct socket_data *sock,
+			const char *hex_prefix)
+{
+	ofono_info("Physical slot %d in socket %s", ril->slot, sock->path);
+
+	ril->modem = sock->gril;
+	ril->radio_state = sock->radio_state;
+
+	g_ril_set_slot(ril->modem, ril->slot);
+
+	if (getenv("OFONO_RIL_TRACE"))
+		g_ril_set_trace(ril->modem, TRUE);
+
+	if (getenv("OFONO_RIL_HEX_TRACE"))
+		g_ril_set_debugf(ril->modem, mtk_debug, (char *) hex_prefix);
+
+	g_ril_set_disconnect_function(ril->modem, socket_disconnected,
+					ril->ofono_modem);
+
+	g_ril_unregister(sock->gril, sock->radio_state_ev_id);
+
+	g_ril_register(ril->modem, RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
+			mtk_radio_state_changed, ril->ofono_modem);
+
+	mtk_connected(ril->ofono_modem);
+}
+
+static void query_3g_caps_cb(struct ril_msg *message, gpointer user_data)
+{
+	struct socket_data *sock = user_data;
+	struct socket_data *sock_for_mtk_0, *sock_for_mtk_1;
+	int slot_3g;
+
+	if (message->error != RIL_E_SUCCESS) {
+		ofono_error("%s: error %s", __func__,
+				ril_error_to_string(message->error));
+		return;
+	}
+
+	slot_3g = g_mtk_reply_parse_get_3g_capability(sock->gril, message);
+
+	/*
+	 * The socket at sock_slot_0 always connects to the slot with 3G
+	 * capabilities, while sock_slot_1 connects to the slot that is just 2G.
+	 * However, the physical slot that owns the 3G capabilities can be
+	 * changed dynamically using a RILd request, so the sockets can connect
+	 * to different physical slots depending on the current configuration.
+	 * We want to keep the relationship between the physical slots and
+	 * the modem names in DBus (so /ril_0 and /ril_1 always refer to the
+	 * same physical slots), so here we assign the sockets needed by mtk_0
+	 * and mtk_1 structures to make sure that happens.
+	 */
+	if (slot_3g == MULTISIM_SLOT_0) {
+		sock_for_mtk_0 = sock_0;
+		sock_for_mtk_1 = sock_1;
+		mtk_0->has_3g = TRUE;
+		mtk_1->has_3g = FALSE;
+	} else {
+		sock_for_mtk_0 = sock_1;
+		sock_for_mtk_1 = sock_0;
+		mtk_0->has_3g = FALSE;
+		mtk_1->has_3g = TRUE;
+	}
+
+	start_slot(mtk_0, sock_for_mtk_0, hex_slot_0);
+	start_slot(mtk_1, sock_for_mtk_1, hex_slot_1);
+
+	g_free(sock_0);
+	sock_0 = NULL;
+	g_free(sock_1);
+	sock_1 = NULL;
+}
+
+static void query_3g_caps(struct socket_data *sock)
+{
+	if (g_ril_send(sock->gril, MTK_RIL_REQUEST_GET_3G_CAPABILITY, NULL,
+			query_3g_caps_cb, sock, NULL) <= 0)
+		ofono_error("%s Error querying 3G capabilities", __func__);
+}
+
 static gboolean mtk_connected(gpointer user_data)
 {
 	struct ofono_modem *modem = (struct ofono_modem *) user_data;
@@ -745,10 +923,14 @@
 
 	DBG("calling set_powered(TRUE)");
 
-	ofono_modem_set_powered(modem, TRUE);
+	if (!ofono_modem_get_powered(modem))
+		ofono_modem_set_powered(modem, TRUE);
 
 	create_atoms_on_connection(modem);
 
+	if (ril->pending_cb)
+		ril->pending_cb(ril->pending_cbd);
+
 	/* Call the function just once */
 	return FALSE;
 }
@@ -763,11 +945,6 @@
 	if (create_gril(modem) < 0)
 		return TRUE;
 
-	create_atoms_on_connection(modem);
-
-	if (ril->pending_cb)
-		ril->pending_cb(ril->pending_cbd);
-
 	/* Reconnected: do not call this again */
 	return FALSE;
 }
@@ -787,36 +964,46 @@
 	g_ril_unref(ril->modem);
 	ril->modem = NULL;
 
+	/* Disconnection happened so we do not call failsafe function */
+	if (not_disconn_cb_id != 0) {
+		g_source_remove(not_disconn_cb_id);
+		not_disconn_cb_id = 0;
+	}
+
 	/* The disconnection happens because rild is re-starting, wait for it */
 	g_timeout_add(WAIT_FOR_RILD_TO_RESTART_MS, reconnect_rild, modem);
 }
 
 static const char sock_slot_0[] = "/dev/socket/rild";
 static const char sock_slot_1[] = "/dev/socket/rild2";
-static const char hex_slot_0[] = "Slot 0: ";
-static const char hex_slot_1[] = "Slot 1: ";
 
 static int create_gril(struct ofono_modem *modem)
 {
 	struct mtk_data *ril = ofono_modem_get_data(modem);
-	const char *sock_path;
-	const char *hex_prefix;
+	struct socket_data *sock;
+	int sock_num;
 
 	DBG("slot %d", ril->slot);
 
 	if (ril->modem != NULL)
 		return 0;
 
+	sock = g_try_malloc0(sizeof(*sock));
+	if (sock == NULL) {
+		ofono_error("%s: Cannot allocate socket_data", __func__);
+		return -ENOMEM;
+	}
+
 	if (ril->slot == MULTISIM_SLOT_0) {
-		sock_path = sock_slot_0;
-		hex_prefix = hex_slot_0;
+		sock_num = SOCKET_NUM_FOR_DBG_0;
+		sock->path = sock_slot_0;
 	} else {
-		sock_path = sock_slot_1;
-		hex_prefix = hex_slot_1;
+		sock_num = SOCKET_NUM_FOR_DBG_1;
+		sock->path = sock_slot_1;
 	}
 
 	/* Opens the socket to RIL */
-	ril->modem = g_ril_new(sock_path, OFONO_RIL_VENDOR_MTK);
+	sock->gril = g_ril_new(sock->path, OFONO_RIL_VENDOR_MTK);
 
 	/*
 	 * NOTE: Since AT modems open a tty, and then call
@@ -827,28 +1014,34 @@
 	 * abstraction... ( probaby not a bad idea ).
 	 */
 
-	if (ril->modem == NULL) {
-		ofono_error("g_ril_new() failed to create modem %d!",
-				ril->slot);
+	if (sock->gril == NULL) {
+		ofono_error("g_ril_new() failed to connect to %s!", sock->path);
+		g_free(sock);
 		return -EIO;
+	} else if (ril->slot == MULTISIM_SLOT_0) {
+		sock_0 = sock;
+	} else {
+		sock_1 = sock;
 	}
 
-	g_ril_set_slot(ril->modem, ril->slot);
-
-	g_ril_set_vendor_print_msg_id_funcs(ril->modem,
+	sock->radio_state = RADIO_STATE_UNAVAILABLE;
+	sock->radio_state_ev_id =
+		g_ril_register(sock->gril,
+				RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
+				radio_state_changed, sock);
+
+	/* sock_num is negative to avoid confusion with physical slots */
+	g_ril_set_slot(sock->gril, sock_num);
+
+	g_ril_set_vendor_print_msg_id_funcs(sock->gril,
 						mtk_request_id_to_string,
 						mtk_unsol_request_to_string);
 
 	if (getenv("OFONO_RIL_TRACE"))
-		g_ril_set_trace(ril->modem, TRUE);
+		g_ril_set_trace(sock->gril, TRUE);
 
 	if (getenv("OFONO_RIL_HEX_TRACE"))
-		g_ril_set_debugf(ril->modem, mtk_debug, (char *) hex_prefix);
-
-	g_ril_set_disconnect_function(ril->modem, socket_disconnected, modem);
-
-	g_ril_register(ril->modem, RIL_UNSOL_RESPONSE_RADIO_STATE_CHANGED,
-			mtk_radio_state_changed, modem);
+		g_ril_set_debugf(sock->gril, mtk_debug, (char *) sock->path);
 
 	return 0;
 }
@@ -875,14 +1068,14 @@
 {
 	int ret;
 
+	/* We handle SIM states due to MTK peculiarities */
+	ofono_modem_set_driver_watches_sim(modem, TRUE);
+
 	ret = create_gril(modem);
 	if (ret < 0)
 		g_timeout_add_seconds(RILD_CONNECT_RETRY_TIME_S,
 					connect_rild, modem);
 
-	/* We handle SIM states due to MTK peculiarities */
-	ofono_modem_set_driver_watches_sim(modem, TRUE);
-
 	/*
 	 * We will mark the modem as powered when we receive an event that
 	 * confirms that the radio is in a state different from unavailable
@@ -897,6 +1090,11 @@
 
 	DBG("%p", modem);
 
+	if (ril->slot == MULTISIM_SLOT_0 && not_disconn_cb_id != 0) {
+		g_source_remove(not_disconn_cb_id);
+		not_disconn_cb_id = 0;
+	}
+
 	if (ril->ofono_online) {
 		ril->ofono_online = FALSE;
 		mtk_send_sim_mode(NULL, NULL);

=== modified file 'plugins/ril.c'
--- plugins/ril.c	2014-09-20 19:12:27 +0000
+++ plugins/ril.c	2014-11-20 00:09:27 +0000
@@ -84,8 +84,6 @@
 	int rild_connect_retries;
 };
 
-static void send_get_sim_status(struct ofono_modem *modem);
-
 static void ril_debug(const char *str, void *user_data)
 {
 	const char *prefix = user_data;
@@ -93,15 +91,6 @@
 	ofono_info("%s%s", prefix, str);
 }
 
-static gboolean sim_status_retry(gpointer user_data)
-{
-	struct ofono_modem *modem = user_data;
-	send_get_sim_status(modem);
-
-	/* Makes this a single shot */
-	return FALSE;
-}
-
 static void ril_radio_state_changed(struct ril_msg *message, gpointer user_data)
 {
 	struct ofono_modem *modem = user_data;
@@ -127,7 +116,6 @@
 						ril->vendor, RILMODEM,
 						ril->modem);
 
-			send_get_sim_status(modem);
 			break;
 
 		case RADIO_STATE_UNAVAILABLE:
@@ -150,56 +138,6 @@
 	}
 }
 
-static void sim_status_cb(struct ril_msg *message, gpointer user_data)
-{
-	struct ofono_modem *modem = user_data;
-	struct ril_data *ril = ofono_modem_get_data(modem);
-	struct reply_sim_status *status;
-
-	DBG("");
-
-	if (message->error != RIL_E_SUCCESS) {
-		ril->sim_status_retries++;
-
-		ofono_error("GET_SIM_STATUS request failed: %s; retries: %d",
-				ril_error_to_string(message->error),
-				ril->sim_status_retries);
-
-		if (ril->sim_status_retries < MAX_SIM_STATUS_RETRIES)
-			g_timeout_add_seconds(2, sim_status_retry, modem);
-		else
-			ofono_error("Max retries for GET_SIM_STATUS exceeded!");
-	} else {
-
-		if ((status = g_ril_reply_parse_sim_status(ril->modem, message))
-				!= NULL) {
-
-			if (status->card_state == RIL_CARDSTATE_PRESENT) {
-				DBG("Card PRESENT; num_apps: %d",
-					status->num_apps);
-
-				ofono_sim_inserted_notify(ril->sim, TRUE);
-
-			} else {
-				ofono_warn("Card NOT_PRESENT.");
-
-				ofono_sim_inserted_notify(ril->sim, FALSE);
-			}
-			g_ril_reply_free_sim_status(status);
-		}
-	}
-}
-
-static void send_get_sim_status(struct ofono_modem *modem)
-{
-	struct ril_data *ril = ofono_modem_get_data(modem);
-
-	DBG("");
-
-	g_ril_send(ril->modem, RIL_REQUEST_GET_SIM_STATUS, NULL,
-			sim_status_cb, modem, NULL);
-}
-
 int ril_create(struct ofono_modem *modem, enum ofono_ril_vendor vendor)
 {
 	struct ril_data *ril = g_try_new0(struct ril_data, 1);
@@ -302,6 +240,8 @@
 		ofono_message_waiting_register(mw);
 
 	ofono_call_forwarding_create(modem, ril->vendor, RILMODEM, ril->modem);
+
+	ofono_phonebook_create(modem, ril->vendor, RILMODEM, modem);
 }
 
 void ril_post_online(struct ofono_modem *modem)

=== modified file 'src/sim.c'
--- src/sim.c	2014-09-16 08:03:09 +0000
+++ src/sim.c	2014-11-20 00:09:27 +0000
@@ -1604,7 +1604,7 @@
 	if (sim_sst_is_active(sim->efsst, sim->efsst_length,
 			SIM_SST_SERVICE_BDN)) {
 		sim_fs_read_info(sim->context, SIM_EFBDN_FILEID,
-				OFONO_SIM_FILE_STRUCTURE_FIXED,
+				OFONO_SIM_FILE_STRUCTURE_FIXED, NULL, 0,
 				sim_efbdn_info_read_cb, sim);
 		return TRUE;
 	}
@@ -1658,7 +1658,7 @@
 	if (sim_sst_is_active(sim->efsst, sim->efsst_length,
 				SIM_SST_SERVICE_FDN)) {
 		sim_fs_read_info(sim->context, SIM_EFADN_FILEID,
-					OFONO_SIM_FILE_STRUCTURE_FIXED,
+					OFONO_SIM_FILE_STRUCTURE_FIXED, NULL, 0,
 					sim_efadn_info_read_cb, sim);
 		return;
 	}
@@ -2206,6 +2206,34 @@
 	return sim_fs_read(context, id, expected_type, 0, 0, NULL, 0, cb, data);
 }
 
+int ofono_sim_read_path(struct ofono_sim_context *context, int id,
+			enum ofono_sim_file_structure expected_type,
+			const unsigned char *path, unsigned int path_len,
+			ofono_sim_file_read_cb_t cb, void *data)
+{
+	return sim_fs_read(context, id, expected_type, 0, 0,
+				path, path_len, cb, data);
+}
+
+int ofono_sim_read_info(struct ofono_sim_context *context, int id,
+			enum ofono_sim_file_structure expected_type,
+			const unsigned char *path, unsigned int pth_len,
+			ofono_sim_read_info_cb_t cb, void *data)
+{
+	return sim_fs_read_info(context, id, expected_type, path, pth_len,
+				cb, data);
+}
+
+int ofono_sim_read_record(struct ofono_sim_context *context, int id,
+				enum ofono_sim_file_structure expected_type,
+				int record, int record_length,
+				const unsigned char *path, unsigned int pth_len,
+				ofono_sim_file_read_cb_t cb, void *data)
+{
+	return sim_fs_read_record(context, id, expected_type, record,
+					record_length, path, pth_len, cb, data);
+}
+
 int ofono_sim_write(struct ofono_sim_context *context, int id,
 			ofono_sim_file_write_cb_t cb,
 			enum ofono_sim_file_structure structure, int record,

=== modified file 'src/simfs.c'
--- src/simfs.c	2012-11-23 13:22:25 +0000
+++ src/simfs.c	2014-11-20 00:09:27 +0000
@@ -264,7 +264,7 @@
 	}
 
 	if (op->info_only == TRUE)
-		((sim_fs_read_info_cb_t) op->cb)
+		((ofono_sim_read_info_cb_t) op->cb)
 			(0, 0, 0, 0, op->userdata);
 	else if (op->is_read == TRUE)
 		((ofono_sim_file_read_cb_t) op->cb)
@@ -335,6 +335,27 @@
 	sim_fs_end_current(fs);
 }
 
+static void sim_fs_op_read_record_cb(const struct ofono_error *error,
+					const unsigned char *sdata, int length,
+					void *data)
+{
+	struct sim_fs *fs = data;
+	struct sim_fs_op *op = g_queue_peek_head(fs->op_q);
+	ofono_sim_file_read_cb_t cb = op->cb;
+
+	if (cb == NULL) {
+		sim_fs_end_current(fs);
+		return;
+	}
+
+	if (error->type == OFONO_ERROR_TYPE_NO_ERROR)
+		cb(1, -1, op->current, sdata, length, op->userdata);
+	else
+		cb(0, -1, op->current, NULL, 0, op->userdata);
+
+	sim_fs_end_current(fs);
+}
+
 static void sim_fs_op_read_block_cb(const struct ofono_error *error,
 					const unsigned char *data, int len,
 					void *user)
@@ -565,7 +586,8 @@
 
 		driver->read_file_linear(fs->sim, op->id, op->current,
 						op->record_length,
-						NULL, 0,
+						op->path_len ? op->path : NULL,
+						op->path_len,
 						sim_fs_op_retrieve_cb, fs);
 		break;
 	case OFONO_SIM_FILE_STRUCTURE_CYCLIC:
@@ -576,7 +598,8 @@
 
 		driver->read_file_cyclic(fs->sim, op->id, op->current,
 						op->record_length,
-						NULL, 0,
+						op->path_len ? op->path : NULL,
+						op->path_len,
 						sim_fs_op_retrieve_cb, fs);
 		break;
 	default:
@@ -700,7 +723,7 @@
 		 * It's an info-only request, so there is no need to request
 		 * actual contents of the EF. Just return the EF-info.
 		 */
-		sim_fs_read_info_cb_t cb = op->cb;
+		ofono_sim_read_info_cb_t cb = op->cb;
 
 		cb(1, file_status, op->length,
 			op->record_length, op->userdata);
@@ -778,7 +801,7 @@
 		 * It's an info-only request, so there is no need to request
 		 * actual contents of the EF. Just return the EF-info.
 		 */
-		sim_fs_read_info_cb_t cb = op->cb;
+		ofono_sim_read_info_cb_t cb = op->cb;
 
 		cb(1, file_status, op->length,
 			op->record_length, op->userdata);
@@ -820,7 +843,28 @@
 		return FALSE;
 	}
 
-	if (op->is_read == TRUE) {
+	if (op->is_read == TRUE && op->current > 0) {
+		switch (op->structure) {
+		case OFONO_SIM_FILE_STRUCTURE_FIXED:
+			driver->read_file_linear(fs->sim, op->id,
+						op->current, op->record_length,
+						op->path_len ? op->path : NULL,
+						op->path_len,
+						sim_fs_op_read_record_cb, fs);
+			break;
+		case OFONO_SIM_FILE_STRUCTURE_CYCLIC:
+			driver->read_file_cyclic(fs->sim, op->id,
+						op->current, op->record_length,
+						op->path_len ? op->path : NULL,
+						op->path_len,
+						sim_fs_op_read_record_cb, fs);
+			break;
+		case OFONO_SIM_FILE_STRUCTURE_TRANSPARENT:
+		default:
+			ofono_error("Wrong file structure for reading record");
+			break;
+		}
+	} else if (op->is_read == TRUE) {
 		if (sim_fs_op_check_cached(fs))
 			return FALSE;
 
@@ -859,7 +903,8 @@
 
 int sim_fs_read_info(struct ofono_sim_context *context, int id,
 			enum ofono_sim_file_structure expected_type,
-			sim_fs_read_info_cb_t cb, void *data)
+			const unsigned char *path, unsigned int pth_len,
+			ofono_sim_read_info_cb_t cb, void *data)
 {
 	struct sim_fs *fs = context->fs;
 	struct sim_fs_op *op;
@@ -887,6 +932,8 @@
 	op->is_read = TRUE;
 	op->info_only = TRUE;
 	op->context = context;
+	memcpy(op->path, path, pth_len);
+	op->path_len = pth_len;
 
 	g_queue_push_tail(fs->op_q, op);
 
@@ -943,6 +990,59 @@
 	return 0;
 }
 
+int sim_fs_read_record(struct ofono_sim_context *context, int id,
+			enum ofono_sim_file_structure expected_type,
+			int record, int record_length,
+			const unsigned char *path, unsigned int path_len,
+			ofono_sim_file_read_cb_t cb, void *data)
+{
+	struct sim_fs *fs = context->fs;
+	struct sim_fs_op *op;
+
+	if (cb == NULL)
+		return -EINVAL;
+
+	if (fs->driver == NULL)
+		return -EINVAL;
+
+	if (record < 1)
+		return -EINVAL;
+
+	if ((expected_type == OFONO_SIM_FILE_STRUCTURE_FIXED &&
+			fs->driver->read_file_linear == NULL) ||
+			(expected_type == OFONO_SIM_FILE_STRUCTURE_CYCLIC &&
+				fs->driver->read_file_cyclic == NULL)) {
+		cb(0, 0, 0, NULL, 0, data);
+		return -ENOSYS;
+	}
+
+	if (fs->op_q == NULL)
+		fs->op_q = g_queue_new();
+
+	op = g_try_new0(struct sim_fs_op, 1);
+	if (op == NULL)
+		return -ENOMEM;
+
+	op->id = id;
+	op->structure = expected_type;
+	op->cb = cb;
+	op->userdata = data;
+	op->is_read = TRUE;
+	op->info_only = FALSE;
+	op->context = context;
+	op->record_length = record_length;
+	op->current = record;
+	memcpy(op->path, path, path_len);
+	op->path_len = path_len;
+
+	g_queue_push_tail(fs->op_q, op);
+
+	if (g_queue_get_length(fs->op_q) == 1)
+		fs->op_source = g_idle_add(sim_fs_op_next, fs);
+
+	return 0;
+}
+
 int sim_fs_write(struct ofono_sim_context *context, int id,
 			ofono_sim_file_write_cb_t cb,
 			enum ofono_sim_file_structure structure, int record,

=== modified file 'src/simfs.h'
--- src/simfs.h	2012-11-23 13:22:25 +0000
+++ src/simfs.h	2014-11-20 00:09:27 +0000
@@ -21,10 +21,6 @@
 
 struct sim_fs;
 
-typedef void (*sim_fs_read_info_cb_t)(int ok, unsigned char file_status,
-					int total_length, int record_length,
-					void *userdata);
-
 struct sim_fs *sim_fs_new(struct ofono_sim *sim,
 				const struct ofono_sim_driver *driver);
 struct ofono_sim_context *sim_fs_context_new(struct sim_fs *fs);
@@ -45,9 +41,16 @@
 		const unsigned char *path, unsigned int len,
 		ofono_sim_file_read_cb_t cb, void *data);
 
+int sim_fs_read_record(struct ofono_sim_context *context, int id,
+			enum ofono_sim_file_structure expected_type,
+			int record, int record_length,
+			const unsigned char *path, unsigned int len,
+			ofono_sim_file_read_cb_t cb, void *data);
+
 int sim_fs_read_info(struct ofono_sim_context *context, int id,
 		enum ofono_sim_file_structure expected_type,
-		sim_fs_read_info_cb_t cb, void *data);
+		const unsigned char *path, unsigned int pth_len,
+		ofono_sim_read_info_cb_t cb, void *data);
 
 void sim_fs_check_version(struct sim_fs *fs);
 

=== modified file 'src/simutil.c'
--- src/simutil.c	2014-05-26 13:26:20 +0000
+++ src/simutil.c	2014-11-20 00:09:27 +0000
@@ -73,6 +73,8 @@
 {	0x2F05, ROOTMF, ROOTMF, EF, BINARY, 0,		ALW,	PIN	},
 {	0x2FE2, ROOTMF, ROOTMF, EF, BINARY, 10,		ALW,	NEV	},
 {	0x4F20, 0x5F50, 0x5F50, EF, BINARY, 0,		PIN,	ADM	},
+{	0x4F30, 0x5F3A, 0x5F3A, EF, RECORD, 0,		PIN,	ADM	},
+{	0x5F3A, 0x7F10, 0x7F10, DF, 0, 0,		PIN,	PIN	},
 {	0x5F50, 0x7F10, 0x7F10, DF, 0, 0,		PIN,	ADM	},
 {	0x6F05, 0x7F20, 0x7FFF, EF, BINARY, 0,		ALW,	PIN	},
 {	0x6F07, 0x7F20, 0x7FFF, EF, BINARY, 9,		PIN,	ADM	},

=== modified file 'src/simutil.h'
--- src/simutil.h	2014-04-14 14:03:03 +0000
+++ src/simutil.h	2014-11-20 00:09:27 +0000
@@ -27,6 +27,7 @@
 	SIM_EF_ICCID_FILEID =			0x2FE2,
 	SIM_MF_FILEID =				0x3F00,
 	SIM_EFIMG_FILEID =			0x4F20,
+	SIM_EFPBR_FILEID =			0x4F30,
 	SIM_DFPHONEBOOK_FILEID =		0x5F3A,
 	SIM_EFLI_FILEID =			0x6F05,
 	SIM_EFARR_FILEID =			0x6F06,

=== added file 'test/set-3g-slot'
--- test/set-3g-slot	1970-01-01 00:00:00 +0000
+++ test/set-3g-slot	2014-11-20 00:09:27 +0000
@@ -0,0 +1,20 @@
+#!/usr/bin/python3
+
+import dbus
+import sys
+
+bus = dbus.SystemBus()
+
+if len(sys.argv) == 2:
+	path = sys.argv[1]
+else:
+	manager = dbus.Interface(bus.get_object('org.ofono', '/'),
+			'org.ofono.Manager')
+	modems = manager.GetModems()
+	path = modems[0][0]
+
+print("Activate 3G for %s..." % path)
+mtks = dbus.Interface(bus.get_object('org.ofono', path),
+		'org.ofono.MtkSettings')
+
+mtks.SetProperty("Has3G", True)

=== modified file 'unit/test-grilreply.c'
--- unit/test-grilreply.c	2014-09-22 17:39:35 +0000
+++ unit/test-grilreply.c	2014-11-20 00:09:27 +0000
@@ -679,7 +679,7 @@
 	0x04, 0x00, 0x00, 0x00, 0x31, 0x00, 0x62, 0x00, 0x33, 0x00, 0x66, 0x00,
 	0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00, 0x30, 0x00, 0x37, 0x00,
 	0x65, 0x00, 0x61, 0x00, 0x35, 0x00, 0x31, 0x00, 0x30, 0x00, 0x61, 0x00,
-	0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x39, 0x00, 0x00, 0x00,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 	0x01, 0x00, 0x00, 0x00, 0x31, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
@@ -1530,17 +1530,11 @@
 	}
 };
 
-static void test_reply_reg_state_invalid(gconstpointer data)
-{
-	struct reply_reg_state *reply =	g_ril_reply_parse_reg_state(NULL, data);
-	g_assert(reply == NULL);
-}
-
-static void test_reply_reg_state_valid(gconstpointer data)
+static void test_reply_voice_reg_state_valid(gconstpointer data)
 {
 	const reg_state_test *test = data;
 	struct reply_reg_state *reply =
-		g_ril_reply_parse_reg_state(NULL, &test->msg);
+		g_ril_reply_parse_voice_reg_state(NULL, &test->msg);
 
 	g_assert(reply != NULL);
 	g_assert(reply->status == test->status);
@@ -1549,6 +1543,26 @@
 	g_free(reply);
 }
 
+static void test_reply_data_reg_state_invalid(gconstpointer data)
+{
+	struct reply_data_reg_state *reply =
+		g_ril_reply_parse_data_reg_state(NULL, data);
+	g_assert(reply == NULL);
+}
+
+static void test_reply_data_reg_state_valid(gconstpointer data)
+{
+	const reg_state_test *test = data;
+	struct reply_data_reg_state *reply =
+		g_ril_reply_parse_data_reg_state(NULL, &test->msg);
+
+	g_assert(reply != NULL);
+	g_assert(reply->reg_state.status == test->status);
+
+	g_assert(reply->reg_state.tech == test->tech);
+	g_free(reply);
+}
+
 static void test_reply_operator_invalid(gconstpointer data)
 {
 	struct reply_operator *reply = g_ril_reply_parse_operator(NULL, data);
@@ -1778,127 +1792,127 @@
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"invalid DATA_REG_STATE Test 1",
 				&reply_data_reg_state_invalid_1,
-				test_reply_reg_state_invalid);
+				test_reply_data_reg_state_invalid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"invalid DATA_REG_STATE Test 2",
 				&reply_data_reg_state_invalid_2,
-				test_reply_reg_state_invalid);
+				test_reply_data_reg_state_invalid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"invalid DATA_REG_STATE Test 3",
 				&reply_data_reg_state_invalid_3,
-				test_reply_reg_state_invalid);
+				test_reply_data_reg_state_invalid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 1",
 				&data_reg_valid_1,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 2",
 				&data_reg_valid_2,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 3",
 				&data_reg_valid_3,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 4",
 				&data_reg_valid_4,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 5",
 				&data_reg_valid_5,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 6",
 				&data_reg_valid_6,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 7",
 				&data_reg_valid_7,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 8",
 				&data_reg_valid_8,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 9",
 				&data_reg_valid_9,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/gprs: "
 				"valid DATA_REG_STATE Test 10",
 				&data_reg_valid_10,
-				test_reply_reg_state_valid);
+				test_reply_data_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 1",
 				&voice_reg_valid_1,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 2",
 				&voice_reg_valid_2,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 3",
 				&voice_reg_valid_3,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 4",
 				&voice_reg_valid_4,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 5",
 				&voice_reg_valid_5,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 6",
 				&voice_reg_valid_6,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 7",
 				&voice_reg_valid_7,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 8",
 				&voice_reg_valid_8,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 9",
 				&voice_reg_valid_9,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 10",
 				&voice_reg_valid_10,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 11",
 				&voice_reg_valid_11,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"valid VOICE_REG_STATE Test 12",
 				&voice_reg_valid_12,
-				test_reply_reg_state_valid);
+				test_reply_voice_reg_state_valid);
 
 	g_test_add_data_func("/testgrilreply/netreg: "
 				"invalid GET_OPERATOR Test 1",

=== modified file 'unit/test-mtkreply.c'
--- unit/test-mtkreply.c	2014-07-29 16:35:05 +0000
+++ unit/test-mtkreply.c	2014-11-20 00:09:27 +0000
@@ -53,7 +53,7 @@
 };
 
 struct rep_3g_capability_test {
-	int is_3g;
+	int slot_3g;
 	const struct ril_msg msg;
 };
 
@@ -113,7 +113,7 @@
 };
 
 static const struct rep_3g_capability_test mtk_reply_3g_capability_valid_1 = {
-	.is_3g = 1,
+	.slot_3g = 0,
 	.msg = {
 		.buf = (char *) &mtk_reply_3g_capability_valid_parcel1,
 		.buf_len = sizeof(mtk_reply_3g_capability_valid_parcel1),
@@ -153,9 +153,9 @@
 {
 	GRil *gril = g_ril_new(NULL, OFONO_RIL_VENDOR_MTK);
 	const struct rep_3g_capability_test *test = data;
-	int is_3g = g_mtk_reply_parse_get_3g_capability(gril, &test->msg);
+	int slot_3g = g_mtk_reply_parse_get_3g_capability(gril, &test->msg);
 
-	g_assert(is_3g == test->is_3g);
+	g_assert(slot_3g == test->slot_3g);
 
 	g_ril_unref(gril);
 }

=== modified file 'unit/test-mtkrequest.c'
--- unit/test-mtkrequest.c	2014-06-12 11:02:03 +0000
+++ unit/test-mtkrequest.c	2014-11-20 00:09:27 +0000
@@ -207,6 +207,18 @@
 	.parcel_size = sizeof(req_set_fd_mode_parcel_valid_2),
 };
 
+/* MTK: set_3g_capability tests */
+
+static const guchar req_set_3g_capability_valid_1[] = {
+	0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
+};
+
+static const struct request_test_data set_set_3g_capability_valid_test_1 = {
+	.request = NULL,
+	.parcel_data = req_set_3g_capability_valid_1,
+	.parcel_size = sizeof(req_set_3g_capability_valid_1),
+};
+
 /* Test functions */
 
 static void test_mtk_req_sim_read_binary_valid(gconstpointer data)
@@ -322,6 +334,19 @@
 	parcel_free(&rilp);
 }
 
+static void test_request_set_3g_capability(gconstpointer data)
+{
+	const struct request_test_data *test_data = data;
+	struct parcel rilp;
+
+	g_mtk_request_set_3g_capability(NULL, &rilp);
+
+	g_assert(!memcmp(rilp.data, test_data->parcel_data,
+				test_data->parcel_size));
+
+	parcel_free(&rilp);
+}
+
 #endif	/* LITTLE_ENDIAN */
 
 int main(int argc, char **argv)
@@ -376,6 +401,11 @@
 				&set_fd_mode_valid_test_2,
 				test_request_set_fd_mode);
 
+	g_test_add_data_func("/testmtkrequest/mtk-settings: "
+				"valid SET_3G_CAPABILITY Test 1",
+				&set_set_3g_capability_valid_test_1,
+				test_request_set_3g_capability);
+
 #endif	/* LITTLE_ENDIAN */
 
 	return g_test_run();